Sync GitHub main 6bb97fb9a95926f8118bd61bec366af28afa0e5c (part 7)

research/reviews/DETERMINISM_REPRODUCTION_20261024/reproduce.py

@@ -0,0 +1,102 @@
+"""Source-bound reproduction; invoke with CLEAN_CHECKOUT OUTPUT_DIRECTORY."""
+import dataclasses
+import datetime
+import gzip
+import hashlib
+import json
+import os
+from pathlib import Path
+import platform
+import subprocess
+import sys
+
+
+def digest(data):
+    return hashlib.sha256(data).hexdigest()
+
+
+def write(path, value):
+    path.write_text(json.dumps(value, indent=2, sort_keys=True) + "\n", encoding="utf-8", newline="\n")
+
+
+root = Path(sys.argv[1]).resolve()
+output = Path(sys.argv[2]).resolve()
+if len(sys.argv) > 3 and sys.argv[3] == "--worker":
+    sys.path.insert(0, str(root))
+    import yaml
+    from src.research.experiment_suite import run_ping_v2
+    config = yaml.safe_load((root / "configs/learning_experiment.yaml").read_text(encoding="utf-8"))
+    write(output, [dataclasses.asdict(run) for run in run_ping_v2(config, seeds=(101, 102, 103), ticks=256)])
+    sys.exit(0)
+
+output.mkdir(parents=True, exist_ok=False)
+
+
+def git(*args):
+    return subprocess.check_output(["git", "-c", f"safe.directory={root.as_posix()}", "-c", "core.autocrlf=false", *args], cwd=root).decode("utf-8").strip()
+
+
+assert not git("status", "--porcelain", "--untracked-files=all"), "Checkout must be clean"
+files = {}
+for line in git("ls-files", "-s", "src", "configs").splitlines():
+    metadata, name = line.split("\t", 1)
+    blob = metadata.split()[1]
+    data = (root / name).read_bytes()
+    actual_blob = hashlib.sha1(b"blob " + str(len(data)).encode() + b"\0" + data).hexdigest()
+    assert actual_blob == blob, f"Non-exact source bytes: {name}"
+    files[name] = {"git_blob": blob, "sha256": digest(data)}
+historical = root / "research/experiments/EXP-BATCH-20260914074039-03"
+config_hash = files["configs/learning_experiment.yaml"]["sha256"]
+old_manifest = json.loads((historical / "manifest.json").read_text())
+assert config_hash == old_manifest["config"]["sha256"], "Historical config differs"
+freeze = {
+    "created_before_execution_utc": datetime.datetime.now(datetime.timezone.utc).isoformat(),
+    "commit": git("rev-parse", "HEAD"), "tree": git("rev-parse", "HEAD^{tree}"),
+    "status_before": git("status", "--porcelain", "--untracked-files=all"),
+    "source_and_config": files, "config_matches_historical": True,
+    "protocol": "deterministic_replica_v1", "runner": "src.research.experiment_suite.run_ping_v2",
+    "seeds": [101, 102, 103], "ticks": 256,
+    "python": sys.version, "executable": sys.executable, "platform": platform.platform(),
+    "machine": platform.machine(), "processor": platform.processor(),
+    "harness_sha256": digest(Path(__file__).read_bytes()),
+    "command": [sys.executable, *sys.argv],
+    "comparison": "All metrics plus before/after state digests in A/B pairs; historical four manuscript totals; full output across fresh processes",
+    "scientific_evidence": False,
+}
+write(output / "freeze.json", freeze)
+(output / "pip-freeze.txt").write_bytes(subprocess.check_output([sys.executable, "-m", "pip", "freeze", "--all"]))
+processes = []
+for hashseed in (0, 1, 42):
+    target = output / f"runs-hashseed-{hashseed}.json"
+    command = [sys.executable, "-B", str(Path(__file__).resolve()), str(root), str(target), "--worker"]
+    env = dict(os.environ, PYTHONHASHSEED=str(hashseed), PYTHONDONTWRITEBYTECODE="1")
+    result = subprocess.run(command, cwd=root, env=env, capture_output=True)
+    (output / f"stdout-{hashseed}.txt").write_bytes(result.stdout)
+    (output / f"stderr-{hashseed}.txt").write_bytes(result.stderr)
+    processes.append({"command": command, "PYTHONHASHSEED": hashseed, "exit_code": result.returncode})
+    write(output / "processes.json", processes)
+    if result.returncode:
+        raise RuntimeError(result.stderr.decode(errors="replace"))
+
+runs = json.loads((output / "runs-hashseed-0.json").read_text())
+checks = []
+keys = ("total_spikes", "delivered_synaptic_events", "recurrent_events", "propagation_depth")
+for seed in (101, 102, 103):
+    for arm, expected in (("recurrence_off", [3, 2, 0, 1]), ("recurrence_on", [33, 33, 10, 61])):
+        a, b = [next(r for r in runs if r["seed"] == seed and r["condition"] == f"{arm}_replica_{replica}") for replica in ("a", "b")]
+        old = json.loads(gzip.decompress(next((historical / "DATA/raw").glob(f"*{arm}_replica_a-seed-{seed}.json.gz")).read_bytes()))
+        checks.append({"seed": seed, "arm": arm,
+                       "all_metrics_equal": a["metrics"] == b["metrics"],
+                       "initial_state_equal": a["state_digest_before"] == b["state_digest_before"],
+                       "final_state_equal": a["state_digest_after"] == b["state_digest_after"],
+                       "ticks_satisfied": a["metrics"]["ticks_executed"] == b["metrics"]["ticks_executed"] == 256,
+                       "no_runtime_errors": a["runtime_error"] is None and b["runtime_error"] is None,
+                       "observed": [a["metrics"][key] for key in keys], "expected": expected,
+                       "historical_totals": [old["metrics"][key] for key in keys]})
+equal_processes = len({digest((output / f"runs-hashseed-{seed}.json").read_bytes()) for seed in (0, 1, 42)}) == 1
+status_after = git("status", "--porcelain", "--untracked-files=all")
+passed = equal_processes and not status_after and all(all(c[k] for k in ("all_metrics_equal", "initial_state_equal", "final_state_equal", "ticks_satisfied", "no_runtime_errors")) and c["observed"] == c["expected"] == c["historical_totals"] for c in checks)
+write(output / "result.json", {"passed": passed, "checks": checks, "fresh_process_outputs_identical": equal_processes, "status_after": status_after, "metric_order": keys, "run_count": 36, "pair_count": 18})
+write(output / "sha256sums.json", {p.name: digest(p.read_bytes()) for p in sorted(output.iterdir()) if p.is_file()})
+print(json.dumps({"passed": passed, "checks": checks, "fresh_process_outputs_identical": equal_processes}, indent=2))
+sys.exit(0 if passed else 1)

research/reviews/MANUSCRIPT_FOLLOWUP_20261024/README.md

@@ -0,0 +1,30 @@
+# Manuscript-review follow-up — 2026-10-24
+
+This work follows the five remaining items of the 2026-10-17 TODO. It is
+recorded on a local branch; publication and independent review are not implied.
+
+| Item | Delivered | Remaining boundary |
+| --- | --- | --- |
+| 10% memory compression | [R1 protocol](../../preregistrations/PREREG-MEM-COMPRESSION-R1.md): complete accounting categories, matched-byte controls, 95% retention/non-inferiority rule, stop and architecture decision rules | REVIEW_READY_NOT_FROZEN: canonical RQ/H admission, byte-accounting/restore implementation tests, dataset/source freeze and R1 human approval remain. No experiment executed. |
+| H-EMB-001-B | [V4 report](../../experiments/EXP-EMB001B-UNSEEN-V4-20261024/report.md): 120 runs, disturbance unknown to donor tape, matched causal controls, all integrity checks passed | Exploratory synthetic DATA only; human scientific review and EVID promotion pending. |
+| 5D ablation | [R2 design](../../preregistrations/PREREG-5D-MATCHED-R2.md) and [hash freeze](../../preregistrations/PREREG-5D-MATCHED-R2.freeze.json) | Design frozen before evaluation; dedicated executable R2 runner, preflight and authorization still required. Does not bypass blocked efficiency R1. |
+| Prior art | [Source-based assessment](../PRIOR_ART_REVIEW_20261024.md), explicit antecedents and bounded novelty wording | Independent external reviewer has not reviewed it; the independence TODO remains open. |
+| Maturity percentages | [Method](../../../docs/05-quality/SCIENTIFIC_MATURITY_METHOD.md), arithmetic audit, corrected dashboard and enforcing checker | Status labels remain judgment-based; no evidence promotion and no probability interpretation. Historical editions unchanged. |
+
+The memorandum is an addendum to edition 1.8, not a silent rewriting of its
+published historical results. New DATA should enter a future publication only
+with the scoped limitations and review status above. Source-bound experiment
+details live in its own freeze record, not in the later documentation commit.
+
+The memory R1 plan is concrete enough for methodological review but cannot be
+called a full freeze merely because its prose is finished. The implementation
+work listed there is required before an execution request. No result-dependent
+choice, favorable outcome or automatic score change substitutes for review.
+
+Validation: 43 focused tests passed (embodiment compatibility/controls,
+publication maturity contracts and deliberate score-corruption cases).
+Ruff, JavaScript syntax, documentation consistency and scientific-maturity
+integrity checks passed. `verify_emb001b_unseen_v4.py` independently recomputes
+the primary outcome from all 120 stored traces and checks archived hashes,
+causal sentinels and source hashes against the pre-execution Git commit.
+This second computation is an internal verifier, not independent peer review.

research/reviews/MANUSCRIPT_FOLLOWUP_20261024/maturity-score-audit.json

@@ -0,0 +1,73 @@
+{
+  "source_commit": "fdfd0568",
+  "criteria_changed": false,
+  "evidence_promoted": false,
+  "stages": [
+    {
+      "stage": 0,
+      "previous_score": 0.925,
+      "weighted_status_score": 0.925,
+      "difference": 0.0
+    },
+    {
+      "stage": 1,
+      "previous_score": 0.85,
+      "weighted_status_score": 0.85,
+      "difference": 0.0
+    },
+    {
+      "stage": 2,
+      "previous_score": 0.65,
+      "weighted_status_score": 0.75,
+      "difference": 0.1
+    },
+    {
+      "stage": 3,
+      "previous_score": 0.55,
+      "weighted_status_score": 0.65,
+      "difference": 0.1
+    },
+    {
+      "stage": 4,
+      "previous_score": 0.55,
+      "weighted_status_score": 0.65,
+      "difference": 0.1
+    },
+    {
+      "stage": 5,
+      "previous_score": 0.55,
+      "weighted_status_score": 0.65,
+      "difference": 0.1
+    },
+    {
+      "stage": 6,
+      "previous_score": 0.4,
+      "weighted_status_score": 0.45,
+      "difference": 0.05
+    },
+    {
+      "stage": 7,
+      "previous_score": 0.28,
+      "weighted_status_score": 0.325,
+      "difference": 0.045
+    },
+    {
+      "stage": 8,
+      "previous_score": 0.23,
+      "weighted_status_score": 0.4,
+      "difference": 0.17
+    },
+    {
+      "stage": 9,
+      "previous_score": 0.15,
+      "weighted_status_score": 0.3,
+      "difference": 0.15
+    },
+    {
+      "stage": 10,
+      "previous_score": 0.13,
+      "weighted_status_score": 0.3,
+      "difference": 0.17
+    }
+  ]
+}

research/reviews/PRIOR_ART_REVIEW_20261024.md

@@ -0,0 +1,69 @@
+# Prior-art assessment of the methodology claims
+
+2026-10-24. **AI-assisted source review; independent external review PENDING.**
+The assistant preparing this review also changed repository methods and
+documentation. It is not an independent reviewer. No external person has
+been contacted or represented as having approved this assessment.
+
+## Search and inclusion record
+
+Web search on 2026-10-24, queries: “research provenance W3C PROV
+recommendation 2013 executable paper computational reproducibility Knuth
+1984 literate programming”; “Nosek 2018 preregistration revolution reflexivity
+scientific research positionality Finlay 2002”; “eLife executable research
+2020”; “Jupyter Notebooks 2016 Kluyver”; “site.cos.io registered reports peer
+review before results”. Included original standards, author publications,
+institutional author deposits and publisher descriptions directly addressing
+one of the four claims. General blog summaries and search aggregators were
+excluded. This is a targeted scoping review, not an exhaustive systematic
+search or a patent novelty opinion. Ranking, language and database coverage
+can omit relevant work; absence from this table is not absence of prior art.
+
+## Claim-to-source comparison
+
+| MHRN claim family | Prior art and verified scope | Consequence for novelty |
+| --- | --- | --- |
+| Research provenance | [W3C PROV-DM (2013)](https://www.w3.org/TR/prov-dm/) models entities, activities, agents and derivation. | Recording origins and transformations is established. MHRN's hashes, DATA/EVID distinctions and domain-specific gates are implementation choices; they do not invent provenance. No formal PROV interoperability has been demonstrated here. |
+| Preregistration | [Nosek et al. (2018)](https://pmc.ncbi.nlm.nih.gov/articles/5856500/) distinguish prospective predictions/analysis plans from postdiction. [COS Registered Reports](https://www.cos.io/initiatives/registered-reports) describes review before data collection. | Frozen plans and separating exploratory from confirmatory work are established. A local Git freeze is not independent registry deposit or a journal's in-principle acceptance. |
+| Executable publication | [Knuth's author account of literate programming](https://cs.stanford.edu/~knuth/lp.html) combines program and documentation; [Kluyver et al. (2016)](https://escholarship.org/uc/item/08b3d4s2) presents notebooks as reproducible-workflow publication; [eLife's ERA launch (2020)](https://elifesciences.org/for-the-press/eb096af1/elife-launches-executable-research-articles-for-publishing-computationally-reproducible-results) embeds executable code and outputs. | Linking narrative, code and results is not new. MHRN's source-bound publication pipeline is a project-specific realization; an exportable manuscript or artifact link alone is not an in-browser executable article. |
+| Reflexive methodology | [Finlay (2002)](https://doi.org/10.1177/146879410200200205) discusses several forms of researcher reflexivity and their difficulties. Only the publisher's abstract and accessible page were inspected. | Documenting researcher influence, choices and limitations has substantial antecedents. AI participation adds a context needing evaluation, not an automatic claim of a new epistemology. |
+| Independent verification | [COS TOP Guidelines](https://www.cos.io/initiatives/top-guidelines) distinguishes verification by an independent party, reproducibility and replication. | Passing local checks or reusing a different software implementation does not by itself establish independent replication. |
+
+All descriptions above are paraphrases. The Knuth original journal DOI
+`10.1093/comjnl/27.2.97` was identified, but its full publisher page could not
+be retrieved; the author's accessible overview is used for the limited claim.
+No inaccessible full text is presented as read.
+
+## Assessment of the actual manuscript claim
+
+Edition 1.8, `parts/10_synthesis.md`, locates the project's contribution in
+integration of research software engineering and governance: RQ/H registry,
+preregistration, source-bound DATA, human review, EVID status, provenance,
+test adequacy and viewer. That modest integration claim is more defensible
+than claiming invention of any component. It remains a description of work
+performed, not proof that its combination is unprecedented or improves
+scientific quality compared with existing workflows.
+
+Recommended wording for subsequent editions:
+
+> MHRN implements a domain-specific integration of established provenance,
+> preregistration, reproducible-computation and reflexive-documentation
+> practices. Its contribution is the explicit implementation and audit of
+> these practices in this evolving SNN programme. Priority of the combination
+> and comparative gains in research quality have not been established.
+
+This recommendation does not silently rewrite an already published edition.
+To establish a stronger claim, compare MHRN against established workflow and
+publication systems on predefined capabilities and failure cases. Include
+maintenance cost, usability, audit error rates and negative outcomes; a
+feature inventory alone is not a causal evaluation of governance quality.
+
+## External review handoff
+
+An independent reviewer should disclose involvement/conflicts, expand the
+search beyond these starting sources, inspect actual implementation and
+manuscript passages, distinguish conceptual antecedents from engineering
+differences, and return a dated signed assessment with cited counterexamples.
+Acceptance requires a review artifact, reviewer identity/role, search scope,
+claim-by-claim decisions and explicit unresolved limitations. Until then the
+TODO's independence requirement remains open; this preparation is complete.

review_portal/build_static.py

@@ -0,0 +1,59 @@
+"""Package only public questionnaire assets, with online collection disabled."""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+SOURCE = ROOT / "src/dashboard/static/review"
+FILES = ("index.html", "app.js", "model.js", "instrument.js", "review.css")
+
+
+def build(output: Path) -> dict[str, object]:
+    """Create a new directory; never publish admin pages, secrets or response data."""
+    contents = {name: (SOURCE / name).read_bytes() for name in FILES}
+    html = contents["index.html"].decode("utf-8")
+    html = html.replace('<html lang="de">', '<html lang="de" data-review-mode="export-only">')
+    html = html.replace('="/review/', '="./')
+    html = html.replace("connect-src 'self'", "connect-src 'none'")
+    html = html.replace(
+        '<a href="./admin.html">Erhebungsverwaltung</a>',
+        '<a href="./privacy.html">Datenschutz und Exportmodus</a>',
+    )
+    if 'data-review-mode="export-only"' not in html or "admin.html" in html:
+        raise ValueError("Static export contract changed; inspect the source HTML")
+    contents["index.html"] = html.encode("utf-8")
+    contents["review.css"] += (
+        b'\nhtml[data-review-mode="export-only"] .withdrawal { display: none; }\n'
+    )
+    contents["privacy.html"] = (ROOT / "review_portal/privacy-export.html").read_bytes()
+    contents[".nojekyll"] = b""
+    manifest = {
+        "mode": "export-only",
+        "collection_enabled": False,
+        "files_sha256": {
+            name: hashlib.sha256(data).hexdigest() for name, data in contents.items()
+        },
+        "independent_review": "not_asserted",
+    }
+    output.mkdir(parents=True, exist_ok=False)
+    for name, data in contents.items():
+        (output / name).write_bytes(data)
+    (output / "deployment-manifest.json").write_text(
+        json.dumps(manifest, indent=2) + "\n", encoding="utf-8", newline="\n"
+    )
+    return manifest
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--output", type=Path, required=True)
+    args = parser.parse_args()
+    print(json.dumps(build(args.output), indent=2))
+
+
+if __name__ == "__main__":
+    main()

review_portal/privacy-export.html

@@ -0,0 +1,21 @@
+<!doctype html>
+<html lang="de"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1">
+<meta name="referrer" content="no-referrer">
+<meta http-equiv="Content-Security-Policy" content="default-src 'none'; style-src 'self'; base-uri 'none'; form-action 'none'">
+<title>MHRN — Datenschutz und Exportmodus</title><link rel="stylesheet" href="./review.css"></head>
+<body><header class="masthead"><a class="brand" href="./index.html">MHRN — zum Fragebogen</a></header>
+<main><section class="card"><h1>Datenschutz und lokaler Export</h1>
+<p>Stand: 24. Oktober 2026. Dieses Paket ist ausschließlich für den Exportmodus auf GitHub Pages vorbereitet.</p>
+<h2>Verantwortlich für das Portal</h2>
+<p>Thomas Heisig, Wolffsheide 10, 27777 Ganderkesee, Deutschland. Kontakt: <a href="mailto:t_heisig@gmx.de">t_heisig@gmx.de</a>.</p>
+<h2>Ihre Antworten</h2>
+<p>Es gibt hier keine zentrale Online-Abgabe. Antworten werden im Browser verarbeitet und nicht automatisch an die Projektleitung, GitHub oder einen KI-Dienst versendet. Das Ausfüllen ist freiwillig; persönliche und sensible Angaben sollten vermieden werden. Eine Bewertung ist keine unabhängige Ethikfreigabe oder wissenschaftliche Evidenz.</p>
+<p>Ohne aktivierte Gerätespeicherung bleibt der Entwurf nur im Arbeitsspeicher der Seite. Auf Wunsch können Sie einen unverschlüsselten Entwurf im lokalen Browserspeicher ablegen und mit „Lokalen Entwurf löschen“ entfernen. Von Ihnen heruntergeladene JSON-/CSV-Dateien verwalten und löschen Sie selbst. Browserdaten können verloren gehen; das Portal erstellt keine Antwort-Backups.</p>
+<p>Ein Export ist keine Serverabgabe. Für eine spätere Übermittlung an eine prüfende Person müssen Empfänger, Zweck, sicherer Übermittlungsweg und Aufbewahrung gesondert vereinbart werden. Dieses Portal verlangt keine Zusendung per E-Mail.</p>
+<h2>Hosting und technische Verbindungsdaten</h2>
+<p>Beim Abruf über GitHub Pages erhält der Hostingdienst technische Verbindungsdaten. GitHub erklärt, IP-Adressen von Seitenbesuchern zu Sicherheitszwecken zu protokollieren. Die Aussage „kein Antwortversand“ bedeutet deshalb nicht „keine Verbindungsdaten“.</p>
+<p>Weitere Angaben zu GitHubs Verarbeitung, Speicherdauern, Übermittlungen und Datenschutzrechten stehen in der <a href="https://docs.github.com/en/site-policy/privacy-policies/github-general-privacy-statement" rel="noreferrer">GitHub-Datenschutzerklärung</a> und der <a href="https://docs.github.com/en/pages/getting-started-with-github-pages/what-is-github-pages#data-collection" rel="noreferrer">Pages-Dokumentation</a>. Das Portal verwendet keine eigenen Analyse-Tracker.</p>
+<h2>Fragen und Rechte</h2>
+<p>Für Fragen zur Verarbeitung durch die Projektleitung nutzen Sie den obigen Kontakt. Je nach Verarbeitung bestehen Rechte auf Auskunft, Berichtigung, Löschung, Einschränkung, Datenübertragbarkeit und Widerspruch sowie ein Beschwerderecht bei einer Datenschutzaufsichtsbehörde. Eine etwaige Einwilligung kann für die Zukunft widerrufen werden. Lokale Antworten können wir nicht abrufen oder für Sie löschen.</p>
+<p>Der Exportmodus aktiviert keine zentral gespeicherte Studie. Vor einer Online-Erhebung sind deren konkrete Rechtsgrundlage, Hosting, Zugriff, Fristen und unabhängige Prüfung gesondert festzulegen.</p>
+</section></main></body></html>

review_portal/tests/browser_static.py

@@ -0,0 +1,71 @@
+"""Exercise the export package under a project subpath with no collector."""
+
+from functools import partial
+from http.server import SimpleHTTPRequestHandler, ThreadingHTTPServer
+import os
+from pathlib import Path
+from tempfile import TemporaryDirectory
+from threading import Thread
+
+from playwright.sync_api import expect, sync_playwright
+
+from review_portal.build_static import build
+
+
+class QuietHandler(SimpleHTTPRequestHandler):
+    def log_message(self, *args):
+        pass
+
+
+def main():
+    with TemporaryDirectory(prefix="review-static-") as directory:
+        root = Path(directory)
+        build(root / "MHRN")
+        server = ThreadingHTTPServer(
+            ("127.0.0.1", 0), partial(QuietHandler, directory=directory)
+        )
+        thread = Thread(target=server.serve_forever, daemon=True)
+        thread.start()
+        try:
+            with sync_playwright() as playwright:
+                browser = playwright.chromium.launch(
+                    channel=os.environ.get("MHRN_TEST_BROWSER_CHANNEL")
+                )
+                page = browser.new_page(accept_downloads=True)
+                errors, requests = [], []
+                page.on("pageerror", lambda error: errors.append(str(error)))
+                page.on("request", lambda request: requests.append(request))
+                url = f"http://127.0.0.1:{server.server_port}/MHRN/index.html"
+                page.goto(url, wait_until="networkidle")
+                expect(page.locator("#mode")).to_contain_text("kein Versand")
+                expect(page.locator("a[href='./privacy.html']")).to_be_visible()
+                expect(page.locator(".withdrawal")).not_to_be_visible()
+                page.locator("#adult").check()
+                page.locator("#consent").check()
+                page.locator("#start").click()
+                page.locator('.question:has(.qid:text-is("A4")) textarea').first.fill(
+                    "SYNTHETIC EXPORT TEST"
+                )
+                assert page.evaluate("localStorage.length") == 0
+                with page.expect_download() as download:
+                    page.locator("#save").click()
+                assert "SYNTHETIC EXPORT TEST" in Path(download.value.path()).read_text(
+                    encoding="utf-8"
+                )
+                page.set_viewport_size({"width": 390, "height": 844})
+                assert page.evaluate("document.documentElement.scrollWidth <= innerWidth")
+                expect(page.locator("#online")).not_to_be_visible()
+                assert not errors, errors
+                assert all("/api/" not in r.url and r.method == "GET" for r in requests)
+                page.goto(url.replace("index.html", "privacy.html"))
+                expect(page.locator("h1")).to_have_text("Datenschutz und lokaler Export")
+                browser.close()
+        finally:
+            server.shutdown()
+            server.server_close()
+            thread.join(timeout=5)
+    print("PASS: project subpath, offline export, privacy page, mobile; zero API requests")
+
+
+if __name__ == "__main__":
+    main()

review_portal/tests/test_static_export.py

@@ -0,0 +1,32 @@
+"""Static deployment must remain portable and unable to collect responses."""
+
+import hashlib
+import json
+
+import pytest
+
+from review_portal.build_static import FILES, build
+
+
+def test_only_export_assets_are_packaged(tmp_path):
+    output = tmp_path / "MHRN"
+    result = build(output)
+    assert set(p.name for p in output.iterdir()) == set(FILES) | {
+        "privacy.html", ".nojekyll", "deployment-manifest.json"
+    }
+    html = (output / "index.html").read_text(encoding="utf-8")
+    assert 'data-review-mode="export-only"' in html
+    assert "connect-src 'none'" in html
+    assert '="/review/' not in html
+    assert "admin.html" not in html
+    assert result["collection_enabled"] is False
+    stored = json.loads((output / "deployment-manifest.json").read_text())
+    for name, digest in stored["files_sha256"].items():
+        assert hashlib.sha256((output / name).read_bytes()).hexdigest() == digest
+
+
+def test_existing_directory_is_never_published_or_overwritten(tmp_path):
+    (tmp_path / "private-response.json").write_text("private")
+    with pytest.raises(FileExistsError):
+        build(tmp_path)
+    assert list(tmp_path.iterdir()) == [tmp_path / "private-response.json"]

scripts/check_scientific_maturity_integrity.py

@@ -90,6 +90,25 @@ def main() -> int:
                 isinstance(criteria, list) and bool(criteria),
                 f"stage {stage_no} missing scientific criteria",
             )
+            if isinstance(criteria, list) and isinstance(weights, dict):
+                ids = [c.get("id") for c in criteria if isinstance(c, dict)]
+                require(
+                    len(ids) == len(set(ids)) and set(ids) == set(weights),
+                    f"stage {stage_no} must contain each weighted criterion once",
+                )
+                scale = {"met": 1.0, "partial": 0.5, "open": 0.0}
+                valid = all(
+                    isinstance(c, dict) and c.get("status") in scale for c in criteria
+                )
+                require(valid, f"stage {stage_no} has an unsupported criterion status")
+                if valid and set(ids) == set(weights):
+                    expected = sum(
+                        float(weights[c["id"]]) * scale[c["status"]] for c in criteria
+                    )
+                    require(
+                        abs(score - expected) < 1e-9,
+                        f"stage {stage_no} score does not match weighted criteria",
+                    )
 
         stage6 = next(
             (

scripts/check_stage1_frozen_prefreeze.py

@@ -0,0 +1,48 @@
+"""Revalidate frozen R2 methods without replacing hash-bound audit artifacts."""
+
+from __future__ import annotations
+
+import hashlib
+import importlib
+import json
+import sys
+import tempfile
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT))
+
+
+def main() -> None:
+    freeze = json.loads(
+        (
+            ROOT / "research/preregistrations/PREREG-S1-TOPO-REFERENCE-R2.freeze.json"
+        ).read_text(encoding="utf-8")
+    )
+    for key in (
+        "mechanism_audit",
+        "dynamics_reuse_validation",
+        "topology_mapping_parity",
+        "integrator_parity",
+        "reset_parity",
+        "synapse_delay_parity",
+    ):
+        entry = freeze[key]
+        path = ROOT / entry["path"].replace("\\", "/")
+        if hashlib.sha256(path.read_bytes()).hexdigest() != entry["sha256"]:
+            raise ValueError(f"Frozen artifact changed: {key}")
+    with tempfile.TemporaryDirectory(prefix="mhrn-r2-revalidation-") as directory:
+        for name in (
+            "audit_stage1_reference_mechanisms",
+            "verify_stage1_reference_dynamics_reuse_r2",
+            "run_stage1_reference_topology_mapping_r2",
+        ):
+            module = importlib.import_module(f"scripts.{name}")
+            module.OUT = Path(directory) / f"{name}.json"
+            if module.main() != 0:
+                raise ValueError(f"Current method revalidation failed: {name}")
+    print("PASS: frozen artifacts intact and current R2 method gates passed")
+
+
+if __name__ == "__main__":
+    main()

scripts/freeze_stage1_topology_reference_r2.py

@@ -3,9 +3,12 @@
 
 from __future__ import annotations
 
+import argparse
 import hashlib
 import json
 import subprocess
+import sys
+from datetime import date
 from pathlib import Path
 
 ROOT = Path(__file__).resolve().parents[1]
@@ -75,6 +78,14 @@ def git(*args):
 
 
 def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "--freeze-date",
+        type=date.fromisoformat,
+        required=True,
+        help="Actual freeze date (YYYY-MM-DD); never inherit the draft's date",
+    )
+    args = parser.parse_args()
     if F.exists():
         raise FileExistsError(F)
     if git("status", "--porcelain"):
@@ -106,11 +117,11 @@ def main() -> int:
         or proto.get("framework_version") != "2.10.1"
     ):
         raise RuntimeError("R2 protocol mismatch")
-    subprocess.run(["python", str(IND.relative_to(ROOT))], cwd=ROOT, check=True)
-    subprocess.run(["python", str(SEED.relative_to(ROOT))], cwd=ROOT, check=True)
+    subprocess.run([sys.executable, str(IND.relative_to(ROOT))], cwd=ROOT, check=True)
+    subprocess.run([sys.executable, str(SEED.relative_to(ROOT))], cwd=ROOT, check=True)
     subprocess.run(
         [
-            "python",
+            sys.executable,
             "-m",
             "pytest",
             str(CT.relative_to(ROOT)),
@@ -130,7 +141,7 @@ def main() -> int:
         "schema_version": 1,
         "preregistration_id": p["preregistration_id"],
         "supersedes": "PREREG-S1-TOPO-REFERENCE-R1",
-        "freeze_date": "2026-09-27",
+        "freeze_date": args.freeze_date.isoformat(),
         "freeze_commit": git("rev-parse", "HEAD"),
         "preregistration_sha256_before_status_update": sha(P),
         "reference_data_created": False,
@@ -203,7 +214,11 @@ def main() -> int:
         "authorization_rule": p["execution_authorization_requirements"],
         "note": "R2 corrects the pre-DATA R1 mapping ambiguity. Freeze fixes the scientific contract only; separate explicit human execution authorization remains mandatory.",
     }
-    F.write_text(json.dumps(freeze, indent=2, sort_keys=True) + "\n", encoding="utf-8")
+    F.write_text(
+        json.dumps(freeze, indent=2, sort_keys=True) + "\n",
+        encoding="utf-8",
+        newline="\n",
+    )
     p["status"] = "FROZEN_BEFORE_REFERENCE_EXECUTION_AUTHORIZATION"
     p["execution_authorized"] = False
     p["freeze_authorization"] = {
@@ -216,7 +231,11 @@ def main() -> int:
     p["freeze_semantics"] = (
         "R2 scientific contract is frozen. Reference DATA remain forbidden until a separate explicit human execution-authorization record binds this freeze commit and runner hash."
     )
-    P.write_text(json.dumps(p, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
+    P.write_text(
+        json.dumps(p, indent=2, ensure_ascii=False) + "\n",
+        encoding="utf-8",
+        newline="\n",
+    )
     print(json.dumps({"status": p["status"], "execution_authorized": False}))
     return 0
 

scripts/publication_empirical.py

@@ -34,7 +34,7 @@ def save(path: Path, value: object) -> None:
 
 def inventory(path: Path) -> dict[str, str]:
     return {
-        str(p.relative_to(path)): sha(p)
+        p.relative_to(path).as_posix(): sha(p)
         for p in sorted(path.rglob("*"))
         if p.is_file() and p.name != "ARTIFACTS.json"
     }

scripts/run_emb001b_unseen_v4.py

@@ -0,0 +1,238 @@
+"""Run frozen exploratory V4 to an external, new output directory."""
+
+from __future__ import annotations
+
+import argparse
+import datetime
+import hashlib
+import json
+import math
+import os
+import platform
+import statistics
+import subprocess
+import sys
+import time
+from dataclasses import asdict
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT))
+
+import yaml  # noqa: E402
+
+from src.research.connectome_embodiment import _simulate  # noqa: E402
+
+
+def save(path, value):
+    path.write_text(
+        json.dumps(value, indent=2, sort_keys=True, allow_nan=False) + "\n",
+        encoding="utf-8",
+        newline="\n",
+    )
+
+
+def git(*args):
+    return (
+        subprocess.check_output(
+            ["git", "-c", f"safe.directory={ROOT.as_posix()}", *args], cwd=ROOT
+        )
+        .decode()
+        .strip()
+    )
+
+
+def sha(path):
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--output", type=Path, required=True)
+    out = parser.parse_args().output.resolve()
+    if out.is_relative_to(ROOT):
+        raise ValueError("Output must be outside the tested checkout")
+    if git("status", "--porcelain"):
+        raise ValueError("Clean committed source required")
+    p = ROOT / "research/preregistrations/PREREG-EMB001B-UNSEEN-V4.json"
+    protocol = json.loads(p.read_text())
+    config_path = ROOT / "configs/learning_experiment.yaml"
+    config = yaml.safe_load(config_path.read_text())
+    out.mkdir(parents=True, exist_ok=False)
+    save(
+        out / "freeze.json",
+        {
+            "commit": git("rev-parse", "HEAD"),
+            "tree": git("rev-parse", "HEAD^{tree}"),
+            "utc_before_execution": datetime.datetime.now(
+                datetime.timezone.utc
+            ).isoformat(),
+            "python": sys.version,
+            "platform": platform.platform(),
+            "command": [sys.executable, *sys.argv],
+            "PYTHONHASHSEED": os.environ.get("PYTHONHASHSEED"),
+            "protocol": protocol,
+            "status_before": "",
+            "hashes": {
+                str(f.relative_to(ROOT)): sha(f)
+                for f in [
+                    p,
+                    config_path,
+                    Path(__file__),
+                    *sorted((ROOT / "src").rglob("*.py")),
+                ]
+            },
+        },
+    )
+    (out / "pip-freeze.txt").write_text(
+        subprocess.check_output(
+            [sys.executable, "-m", "pip", "freeze", "--all"]
+        ).decode(),
+        encoding="utf-8",
+        newline="\n",
+    )
+    results, integrity = [], []
+    started = time.monotonic()
+    for seed in protocol["seeds"]:
+        ticks = protocol["ticks"]
+        schedule = tuple(
+            (0.003 if seed % 2 == 0 else -0.003) if 250 <= t < 500 else 0.0
+            for t in range(ticks)
+        )
+        donor = _simulate(config, seed, ticks, "closed_loop", perturb=False)
+        save(out / f"donor-{seed}.json", asdict(donor))
+        runs = {
+            "donor_unperturbed": donor,
+            "yoked_unperturbed": _simulate(
+                config, seed, ticks, "yoked_replay", donor=donor, perturb=False
+            ),
+            "closed_challenge": _simulate(
+                config, seed, ticks, "closed_loop", external_torque_schedule=schedule
+            ),
+            "yoked_challenge": _simulate(
+                config,
+                seed,
+                ticks,
+                "yoked_replay",
+                donor=donor,
+                external_torque_schedule=schedule,
+            ),
+            "feedback_absent_challenge": _simulate(
+                config,
+                seed,
+                ticks,
+                "feedback_absent",
+                external_torque_schedule=schedule,
+            ),
+            "pd_challenge": _simulate(
+                config,
+                seed,
+                ticks,
+                "controller_only",
+                external_torque_schedule=schedule,
+            ),
+        }
+        y = runs["yoked_challenge"]
+        checks = {
+            "complete": all(
+                r.error is None and r.metrics["ticks_executed"] == ticks
+                for r in runs.values()
+            ),
+            "initial_neural_equal": len({r.before for r in runs.values()}) == 1,
+            "initial_body_equal": all(
+                r.metrics["gateway_state_before"]
+                == donor.metrics["gateway_state_before"]
+                for r in runs.values()
+            ),
+            "graph_equal": all(
+                r.metrics["graph"] == donor.metrics["graph"] for r in runs.values()
+            ),
+            "sentinel_exact": runs["yoked_unperturbed"].metrics["trace"]
+            == donor.metrics["trace"],
+            "donor_observations_exact": [
+                (r["observed_q_rad"], r["observed_omega_rad_s"])
+                for r in y.metrics["trace"]
+            ]
+            == donor.sensor_tape,
+            "yoked_commands_unchanged": y.motor_tape == donor.motor_tape,
+            "body_responds_to_disturbance": y.sensor_tape != donor.sensor_tape,
+            "absent_zero": all(
+                r["observed_q_rad"] == r["observed_omega_rad_s"] == 0
+                for r in runs["feedback_absent_challenge"].metrics["trace"]
+            ),
+        }
+        integrity.append({"seed": seed, "checks": checks})
+        for condition, run in runs.items():
+            trace = run.metrics["trace"][250:]
+            rmse = math.sqrt(
+                statistics.mean((r["target_rad"] - r["q_rad"]) ** 2 for r in trace)
+            )
+            results.append(
+                {
+                    "seed": seed,
+                    "condition": condition,
+                    "post_disturbance_rmse": rmse,
+                    "full_rmse": run.metrics["tracking_rmse_rad"],
+                    "error": run.error,
+                }
+            )
+        save(
+            out / f"runs-{seed}.json",
+            {"schedule": schedule, "runs": {k: asdict(v) for k, v in runs.items()}},
+        )
+        save(out / "integrity.json", integrity)
+        save(out / "outcomes.json", results)
+        if (
+            time.monotonic() - started > 600
+            or sum(f.stat().st_size for f in out.iterdir()) > 100000000
+        ):
+            raise RuntimeError(
+                "Frozen resource ceiling exceeded; partial outputs retained"
+            )
+    differences = []
+    for seed in protocol["seeds"]:
+        rows = {r["condition"]: r for r in results if r["seed"] == seed}
+        differences.append(
+            {
+                "seed": seed,
+                "difference": rows["yoked_challenge"]["post_disturbance_rmse"]
+                - rows["closed_challenge"]["post_disturbance_rmse"],
+            }
+        )
+    summary = {}
+    for name, selected in (
+        ("pooled", differences),
+        ("positive_torque", [r for r in differences if r["seed"] % 2 == 0]),
+        ("negative_torque", [r for r in differences if r["seed"] % 2]),
+    ):
+        values = [r["difference"] for r in selected]
+        summary[name] = {
+            "n": len(values),
+            "mean": statistics.mean(values),
+            "median": statistics.median(values),
+            "min": min(values),
+            "max": max(values),
+            "positive": sum(v > 0 for v in values),
+            "zero": values.count(0),
+            "negative": sum(v < 0 for v in values),
+        }
+    valid = all(all(row["checks"].values()) for row in integrity) and not git(
+        "status", "--porcelain"
+    )
+    save(
+        out / "result.json",
+        {
+            "valid": valid,
+            "status_after": git("status", "--porcelain"),
+            "paired_differences": differences,
+            "summary": summary,
+            "scientific_evidence": False,
+        },
+    )
+    save(out / "sha256sums.json", {f.name: sha(f) for f in sorted(out.iterdir())})
+    print(json.dumps({"valid": valid, "summary": summary}, indent=2))
+    return 0 if valid else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

scripts/run_stage1_reference_topology_mapping_r2.py

@@ -6,9 +6,12 @@ from __future__ import annotations
 import hashlib
 import json
 import random
+import sys
 from pathlib import Path
 from typing import Any
 
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
 from reference.stage1_topology_brian2 import runner_r2 as reference
 from scripts.run_stage1_topology_v2 import (
     canonical_coords,
@@ -90,7 +93,9 @@ def main() -> int:
     }
     OUT.parent.mkdir(parents=True, exist_ok=True)
     OUT.write_text(
-        json.dumps(payload, indent=2, sort_keys=True) + "\n", encoding="utf-8"
+        json.dumps(payload, indent=2, sort_keys=True) + "\n",
+        encoding="utf-8",
+        newline="\n",
     )
     print(
         json.dumps(

scripts/verify_determinism_reproduction.py

@@ -0,0 +1,29 @@
+"""Verify archived reproduction bytes without modifying or rerunning the study."""
+
+import hashlib
+import json
+from pathlib import Path
+
+
+def main() -> None:
+    report = (
+        Path(__file__).resolve().parents[1]
+        / "research/reviews/DETERMINISM_REPRODUCTION_20261024"
+    )
+    artifacts = report / "artifacts"
+    checksums = json.loads((artifacts / "sha256sums.json").read_text(encoding="utf-8"))
+    for name, expected in checksums.items():
+        target = artifacts / name
+        if target.resolve().parent != artifacts.resolve():
+            raise ValueError(f"Invalid artifact path: {name}")
+        if hashlib.sha256(target.read_bytes()).hexdigest() != expected:
+            raise ValueError(f"Reproduction artifact changed: {name}")
+    freeze = json.loads((artifacts / "freeze.json").read_text(encoding="utf-8"))
+    actual = hashlib.sha256((report / "reproduce.py").read_bytes()).hexdigest()
+    if actual != freeze["harness_sha256"]:
+        raise ValueError("Executed reproduction harness changed")
+    print(f"PASS: {len(checksums)} immutable artifacts and executed harness")
+
+
+if __name__ == "__main__":
+    main()

scripts/verify_emb001b_unseen_v4.py

@@ -0,0 +1,106 @@
+"""Verify archived V4 bytes and recompute the primary outcome from traces."""
+
+import hashlib
+import json
+import math
+import statistics
+import subprocess
+import zipfile
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+OUT = ROOT / "research/experiments/EXP-EMB001B-UNSEEN-V4-20261024"
+
+
+def main():
+    archive = json.loads((OUT / "archive-index.json").read_text())
+    assert (
+        hashlib.sha256((OUT / archive["archive"]).read_bytes()).hexdigest()
+        == archive["sha256"]
+    )
+    freeze = json.loads((OUT / "freeze.json").read_text())
+    git = ["git", "-c", f"safe.directory={ROOT.as_posix()}"]
+    for name, expected in freeze["hashes"].items():
+        name = name.replace("\\", "/")
+        blob = subprocess.check_output(
+            git + ["show", freeze["commit"] + ":" + name], cwd=ROOT
+        )
+        assert hashlib.sha256(blob).hexdigest() == expected, name
+    outcomes = json.loads((OUT / "outcomes.json").read_text())
+    assert len(outcomes) == 120
+    differences = []
+    with zipfile.ZipFile(OUT / archive["archive"]) as z:
+        for name, expected in json.loads((OUT / "sha256sums.json").read_text()).items():
+            data = (
+                z.read(name)
+                if name in archive["members"]
+                else (OUT / name).read_bytes()
+            )
+            assert hashlib.sha256(data).hexdigest() == expected, name
+        for seed in freeze["protocol"]["seeds"]:
+            raw = json.loads(z.read(f"runs-{seed}.json"))
+            assert set(raw["runs"]) == set(freeze["protocol"]["conditions"])
+            donor = raw["runs"]["donor_unperturbed"]
+            assert donor == json.loads(z.read(f"donor-{seed}.json"))
+            assert raw["schedule"] == [
+                (0.003 if seed % 2 == 0 else -0.003) if 250 <= t < 500 else 0.0
+                for t in range(1000)
+            ]
+            values = {}
+            for condition, run in raw["runs"].items():
+                trace = run["metrics"]["trace"]
+                assert run["error"] is None and len(trace) == 1000
+                assert run["before"] == donor["before"]
+                assert run["metrics"]["graph"] == donor["metrics"]["graph"]
+                assert (
+                    run["metrics"]["gateway_state_before"]
+                    == donor["metrics"]["gateway_state_before"]
+                )
+                value = math.sqrt(
+                    statistics.mean(
+                        (r["target_rad"] - r["q_rad"]) ** 2 for r in trace[250:]
+                    )
+                )
+                row = next(
+                    r
+                    for r in outcomes
+                    if r["seed"] == seed and r["condition"] == condition
+                )
+                assert value == row["post_disturbance_rmse"]
+                values[condition] = value
+            yoke = raw["runs"]["yoked_challenge"]
+            assert (
+                raw["runs"]["yoked_unperturbed"]["metrics"]["trace"]
+                == donor["metrics"]["trace"]
+            )
+            assert [
+                [r["observed_q_rad"], r["observed_omega_rad_s"]]
+                for r in yoke["metrics"]["trace"]
+            ] == donor["sensor_tape"]
+            assert yoke["motor_tape"] == donor["motor_tape"]
+            assert yoke["sensor_tape"] != donor["sensor_tape"]
+            assert all(
+                r["observed_q_rad"] == r["observed_omega_rad_s"] == 0
+                for r in raw["runs"]["feedback_absent_challenge"]["metrics"]["trace"]
+            )
+            differences.append(
+                {
+                    "seed": seed,
+                    "difference": values["yoked_challenge"]
+                    - values["closed_challenge"],
+                }
+            )
+    result = json.loads((OUT / "result.json").read_text())
+    assert result["valid"] and result["status_after"] == ""
+    assert differences == result["paired_differences"]
+    assert (
+        statistics.mean(r["difference"] for r in differences)
+        == result["summary"]["pooled"]["mean"]
+    )
+    print(
+        "PASS: source bindings, archived hashes, 120 raw runs, causal controls and paired primary outcomes"
+    )
+
+
+if __name__ == "__main__":
+    main()

scripts/verify_emb002a_delay_sweep_v4.py

@@ -5,6 +5,8 @@ from __future__ import annotations
 
 import hashlib
 import json
+import re
+import subprocess
 from pathlib import Path
 from typing import Any
 
@@ -100,9 +102,16 @@ def main() -> int:
     assert hashes["preregistration"] == sha256(PREREG)
     assert hashes["evaluation_data"] == sha256(OUT / "data/evaluation.json")
     assert hashes["statistics"] == sha256(OUT / "analysis/statistics.json")
-    assert hashes["canonical_embodiment_source"] == sha256(
-        ROOT / "src/research/connectome_embodiment.py"
-    )
+    # Persisted DATA bind the executed commit, not later runtime development.
+    source_commit = manifest["source_freeze"]["commit"]
+    assert re.fullmatch(r"[0-9a-f]{40}", source_commit)
+    source = subprocess.run(
+        ["git", "show", f"{source_commit}:src/research/connectome_embodiment.py"],
+        cwd=ROOT,
+        check=True,
+        capture_output=True,
+    ).stdout
+    assert hashes["canonical_embodiment_source"] == hashlib.sha256(source).hexdigest()
 
     for line in (OUT / "checksums.sha256").read_text(encoding="utf-8").splitlines():
         digest, relpath = line.split("  ", 1)

scripts/verify_stage1_reference_dynamics_reuse_r2.py

@@ -120,7 +120,9 @@ def main() -> int:
     }
     OUT.parent.mkdir(parents=True, exist_ok=True)
     OUT.write_text(
-        json.dumps(payload, indent=2, sort_keys=True) + "\n", encoding="utf-8"
+        json.dumps(payload, indent=2, sort_keys=True) + "\n",
+        encoding="utf-8",
+        newline="\n",
     )
     print(
         json.dumps(