Sync GitHub main af692537c27175c8410bf57a747be0caf23718e2 (part 7)

scripts/build_frozen_environment.py

@@ -0,0 +1,136 @@
+#!/usr/bin/env python3
+"""Build a deterministic Frozen-Environment engineering manifest artifact."""
+
+from __future__ import annotations
+
+import argparse
+import json
+
+from src.embodiment.deterministic import DeterministicTargetEnvironment
+from src.embodiment.msba import SymbolFrame
+from src.embodiment.neural_io_contracts import BoundaryFrame
+from src.experience.frozen_environment import (
+    FreezeMode,
+    FrozenBoundaryFrame,
+    FrozenEnvironmentManifest,
+    RNGContractMode,
+    WorldRNGContract,
+)
+from src.verification.frozen_environment import write_manifest_artifact
+
+
+def _boundary_frame(tick: int) -> FrozenBoundaryFrame:
+    symbol = SymbolFrame(
+        payload=json.dumps({"tick": tick}, sort_keys=True).encode("utf-8"),
+        codec="json",
+        sequence=tick,
+        provenance="fe-builder",
+    )
+    return FrozenBoundaryFrame.from_frame(
+        BoundaryFrame(
+            schema_version=1,
+            frame_id=f"fe-frame-{tick}",
+            stream_id="fe-sensor",
+            sequence=tick,
+            direction="INBOUND",
+            kind="DIGITAL",
+            content_type="application/json",
+            schema_id="fe-builder-v1",
+            symbol_frame=symbol,
+            correlation_id=f"fe-{tick}",
+            priority=0,
+            source_id="fe-builder",
+            provenance="engineering-verification",
+            arrival_time_ns=None,
+            admitted_tick=tick,
+        )
+    )
+
+
+def _build(
+    mode: FreezeMode, *, target: int, ticks: int, seed: int
+) -> FrozenEnvironmentManifest:
+    if ticks < 1:
+        raise ValueError("ticks must be >= 1")
+    schedule = tuple(range(ticks))
+    if mode is FreezeMode.FE1_BOUNDARY_REPLAY:
+        return FrozenEnvironmentManifest(
+            mode=mode,
+            environment_id="boundary-replay-v1",
+            environment_version="1",
+            environment_config={"builder": "deterministic-fixture"},
+            rng=WorldRNGContract(
+                algorithm="none",
+                version="1",
+                mode=RNGContractMode.NONE,
+                initial_fingerprint="none",
+            ),
+            sensor_schedule=schedule,
+            action_schema={"kind": "none"},
+            reward_contract={"kind": "none"},
+            episode_policy={"reset": "explicit"},
+            boundary_frames=tuple(_boundary_frame(tick) for tick in schedule),
+        )
+
+    env = DeterministicTargetEnvironment(target=target)
+    env.reset(seed=seed)
+    return FrozenEnvironmentManifest(
+        mode=mode,
+        environment_id=env.environment_id,
+        environment_version="1",
+        environment_config={"target": target},
+        rng=WorldRNGContract(
+            algorithm="none",
+            version="1",
+            mode=RNGContractMode.NONE,
+            initial_fingerprint=env.rng_fingerprint(),
+        ),
+        sensor_schedule=schedule,
+        action_schema={
+            "actuator_id": "target-actuator",
+            "actions": ["left", "right"],
+        },
+        reward_contract={"type": "target-hit", "hit_reward": 1.0},
+        episode_policy={
+            "reset": "explicit",
+            "pending_rewards_cross_episode": False,
+        },
+        initial_world_state=env.snapshot_state(),
+    )
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--mode", choices=[mode.value for mode in FreezeMode], required=True
+    )
+    parser.add_argument("--output", required=True)
+    parser.add_argument("--target", type=int, default=2)
+    parser.add_argument("--ticks", type=int, default=2)
+    parser.add_argument("--seed", type=int, default=0)
+    args = parser.parse_args()
+
+    manifest = _build(
+        FreezeMode(args.mode),
+        target=args.target,
+        ticks=args.ticks,
+        seed=args.seed,
+    )
+    path = write_manifest_artifact(args.output, manifest)
+    print(
+        json.dumps(
+            {
+                "classification": "FROZEN_ENVIRONMENT_ENGINEERING_ARTIFACT",
+                "scientific_evidence": False,
+                "path": str(path),
+                "mode": manifest.mode.value,
+                "manifest_sha256": manifest.manifest_sha256,
+            },
+            sort_keys=True,
+        )
+    )
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

scripts/check_canonical_imports.py

@@ -0,0 +1,48 @@
+"""Fail-closed canonical import boundary gate for Wave 4."""
+
+from __future__ import annotations
+
+import ast
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+TARGETS = (
+    ROOT / "src" / "acceleration",
+    ROOT / "src" / "verification",
+)
+
+
+def forbidden_imports() -> list[str]:
+    failures: list[str] = []
+    for root in TARGETS:
+        for path in root.rglob("*.py"):
+            tree = ast.parse(path.read_text(encoding="utf-8"), filename=str(path))
+            for node in ast.walk(tree):
+                if isinstance(node, ast.Import):
+                    for alias in node.names:
+                        if alias.name.startswith("src.playground"):
+                            failures.append(
+                                f"{path.relative_to(ROOT)}: import {alias.name}"
+                            )
+                elif isinstance(node, ast.ImportFrom):
+                    module = node.module or ""
+                    if module.startswith("src.playground"):
+                        failures.append(
+                            f"{path.relative_to(ROOT)}: from {module} import ..."
+                        )
+    return failures
+
+
+def main() -> int:
+    failures = forbidden_imports()
+    if failures:
+        raise SystemExit(
+            "canonical acceleration/verification layers import Playground:\n"
+            + "\n".join(failures)
+        )
+    print("canonical import boundary: PASS")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

scripts/check_cuda_kernel_freeze.py

@@ -0,0 +1,56 @@
+"""Verify Wave-4 CUDA kernel extraction preserved kernel bytes exactly."""
+
+from __future__ import annotations
+
+import hashlib
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+PAIRS = (
+    (
+        ROOT / "src" / "playground" / "cuda" / "recurrent.cu",
+        ROOT / "src" / "acceleration" / "cuda" / "recurrent" / "kernel.cu",
+    ),
+    (
+        ROOT / "src" / "playground" / "cuda" / "builder_synapses.cu",
+        ROOT / "src" / "acceleration" / "cuda" / "plasticity" / "kernel.cu",
+    ),
+)
+
+
+def sha256(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+
+def kernel_mismatches() -> list[str]:
+    mismatches: list[str] = []
+    for legacy, canonical in PAIRS:
+        if not legacy.is_file() or not canonical.is_file():
+            mismatches.append(
+                f"missing kernel pair: {legacy.relative_to(ROOT)} / "
+                f"{canonical.relative_to(ROOT)}"
+            )
+            continue
+        if legacy.read_bytes() != canonical.read_bytes():
+            mismatches.append(
+                f"kernel changed during extraction: "
+                f"{legacy.relative_to(ROOT)}={sha256(legacy)} "
+                f"{canonical.relative_to(ROOT)}={sha256(canonical)}"
+            )
+    return mismatches
+
+
+def main() -> int:
+    mismatches = kernel_mismatches()
+    if mismatches:
+        raise SystemExit("\n".join(mismatches))
+    for legacy, canonical in PAIRS:
+        print(
+            f"kernel freeze PASS: {canonical.relative_to(ROOT)} "
+            f"sha256={sha256(canonical)}"
+        )
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

scripts/check_cuda_parity_contract.py

@@ -0,0 +1,109 @@
+"""Fail-closed Wave-4 canonical cross-backend parity contract gate.
+
+Hosted CI does not have physical CUDA. This gate verifies that CPU and CUDA
+conform to the canonical ExecutionBackend surface, share one canonical
+configuration identity, and that the named physical acceptance test is wired
+through canonical parity functions rather than Playground helpers.
+
+Physical D1/D2 execution is performed by scripts/run_cuda_hardware_acceptance.py.
+"""
+
+from __future__ import annotations
+
+import ast
+from collections.abc import Mapping
+from pathlib import Path
+
+from src.acceleration.cuda import CUDABackend
+from src.acceleration.cuda.recurrent import (
+    CPUReferenceBackend,
+    recurrent_fixture,
+    recurrent_inputs_to_mapping,
+)
+from src.runtime.backend import ExecutionBackend
+from src.verification.parity import config_fingerprint
+
+ROOT = Path(__file__).resolve().parents[1]
+TEST_FILE = ROOT / "tests" / "test_cuda_wave4_backend.py"
+HARDWARE_TEST = "test_physical_cpu_cuda_cross_backend_d1_d2_parity"
+
+
+def _hardware_test_source() -> str:
+    source = TEST_FILE.read_text(encoding="utf-8")
+    tree = ast.parse(source, filename=str(TEST_FILE))
+    for node in tree.body:
+        if (
+            isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef))
+            and node.name == HARDWARE_TEST
+        ):
+            segment = ast.get_source_segment(source, node)
+            if segment is None:
+                raise RuntimeError("could not recover hardware acceptance test source")
+            return segment
+    raise RuntimeError(f"missing named hardware acceptance test: {HARDWARE_TEST}")
+
+
+def failures() -> list[str]:
+    problems: list[str] = []
+
+    cpu: ExecutionBackend = CPUReferenceBackend()
+    cuda: ExecutionBackend = CUDABackend()
+    config = recurrent_inputs_to_mapping(
+        recurrent_fixture(n_neurons=8, ticks=4, model="lif")
+    )
+    seed = 12345
+    cpu.initialize(config, seed)
+    cuda.initialize(config, seed)
+
+    cpu_config = cpu.snapshot().payload.get("config")
+    cuda_config = cuda.snapshot().payload.get("config")
+    if not isinstance(cpu_config, Mapping) or not isinstance(cuda_config, Mapping):
+        problems.append("backend snapshots must expose canonical mapping configs")
+    elif config_fingerprint(cpu_config) != config_fingerprint(cuda_config):
+        problems.append("CPU/CUDA canonical configuration fingerprints differ")
+
+    try:
+        test_source = _hardware_test_source()
+    except RuntimeError as exc:
+        problems.append(str(exc))
+        test_source = ""
+
+    required_tokens = (
+        "CPUReferenceBackend",
+        "CUDABackend",
+        "exact_spike_parity",
+        "state_vector_parity",
+        "tolerance=1.0e-4",
+    )
+    for token in required_tokens:
+        if token not in test_source:
+            problems.append(
+                "hardware parity acceptance test is missing canonical token: " + token
+            )
+
+    full_test_source = TEST_FILE.read_text(encoding="utf-8")
+    if "MHRN_TEST_CUDA_HARDWARE" not in full_test_source:
+        problems.append("hardware parity acceptance test must remain opt-in")
+
+    if "playground" in test_source.lower():
+        problems.append(
+            "hardware parity acceptance test must not use Playground parity helpers"
+        )
+
+    return problems
+
+
+def main() -> int:
+    problems = failures()
+    if problems:
+        raise SystemExit(
+            "Wave-4 canonical parity contract failed:\n" + "\n".join(problems)
+        )
+    print("Wave-4 canonical parity contract: PASS")
+    print("hardware acceptance test: PRESENT / OPT-IN")
+    print("D3 status: NOT_CLAIMED_IN_WAVE4")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

scripts/check_cuda_semantic_boundary.py

@@ -0,0 +1,86 @@
+"""Fail-closed Wave-4 CUDA capability/learning-semantics gate."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from src.acceleration.cuda import CUDABackend
+from src.acceleration.cuda.plasticity.contracts import (
+    LEARNING_CONTRACT_ID,
+    LEARNING_CONTRACT_STATUS,
+    PLASTICITY_SEMANTICS,
+)
+
+ROOT = Path(__file__).resolve().parents[1]
+LEARNING_CONTRACT = (
+    ROOT / "docs" / "02-architecture" / "MHRN_LEARNING_SYNAPSE_CONTRACT.md"
+)
+
+
+def failures() -> list[str]:
+    problems: list[str] = []
+    caps = CUDABackend().capabilities()
+
+    expected = {
+        "supports_recurrent": True,
+        "supports_plasticity": True,
+        "supports_pan_hyperstate": False,
+        "supports_structural_plasticity": False,
+        "max_neurons": 4096,
+        "max_ticks": 2000,
+        "max_edges": 65536,
+        "deterministic": True,
+        "plasticity_semantics": "NON_CANONICAL_DRAFT",
+        "execution_mode": "BOUNDED_REPLAY_REFERENCE",
+    }
+    actual = caps.to_mapping()
+    for key, value in expected.items():
+        if actual.get(key) != value:
+            problems.append(
+                f"CUDA capability mismatch: {key}={actual.get(key)!r}, expected {value!r}"
+            )
+
+    if PLASTICITY_SEMANTICS != "NON_CANONICAL_DRAFT":
+        problems.append(
+            "plasticity semantics must remain NON_CANONICAL_DRAFT until contract alignment"
+        )
+    if LEARNING_CONTRACT_ID != "mhrn-learning-synapse-v1":
+        problems.append(f"unexpected learning contract id: {LEARNING_CONTRACT_ID}")
+    if LEARNING_CONTRACT_STATUS != "ALIGNMENT_PENDING":
+        problems.append(
+            "learning contract status must remain ALIGNMENT_PENDING in Wave 4"
+        )
+
+    if not LEARNING_CONTRACT.is_file():
+        problems.append("canonical learning/synapse contract document is missing")
+    else:
+        text = LEARNING_CONTRACT.read_text(encoding="utf-8")
+        required = (
+            "canonical design contract; backend implementation alignment pending",
+            "learning_contract_id = mhrn-learning-synapse-v1",
+            "CPU and CUDA must not implement two merely similar learning rules",
+        )
+        for phrase in required:
+            if phrase not in text:
+                problems.append(
+                    "learning contract document no longer contains required boundary: "
+                    + phrase
+                )
+
+    return problems
+
+
+def main() -> int:
+    problems = failures()
+    if problems:
+        raise SystemExit(
+            "Wave-4 CUDA semantic boundary failed:\n" + "\n".join(problems)
+        )
+    print("Wave-4 CUDA semantic boundary: PASS")
+    print("plasticity_semantics=NON_CANONICAL_DRAFT")
+    print("learning_contract_status=ALIGNMENT_PENDING")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

scripts/run_cuda_hardware_acceptance.py

@@ -0,0 +1,291 @@
+"""Run canonical CUDA hardware acceptance on a physical NVIDIA GPU.
+
+The runner always performs Wave-4 D1/D2. Optional FE-3 adds both the historical
+Builder D3c bridge and the canonical FrozenEnvironment CPU-vs-CUDA live-loop
+acceptance. All outputs are engineering verification only.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import shutil
+import subprocess
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+DEFAULT_FE3_MANIFEST = (
+    ROOT
+    / "research"
+    / "verification"
+    / "frozen_environment"
+    / "FE3_DETERMINISTIC_TARGET_V1.json"
+)
+
+
+def _gpu_identity() -> str:
+    executable = shutil.which("nvidia-smi")
+    if executable is None:
+        raise SystemExit(
+            "CUDA hardware acceptance requires nvidia-smi on a physical NVIDIA host"
+        )
+    completed = subprocess.run(
+        [
+            executable,
+            "--query-gpu=name,driver_version",
+            "--format=csv,noheader",
+        ],
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+    identity = completed.stdout.strip()
+    if not identity:
+        raise SystemExit("nvidia-smi returned no GPU identity")
+    return identity
+
+
+def _last_json_object(stdout: str) -> dict[str, object] | None:
+    for line in reversed(stdout.splitlines()):
+        line = line.strip()
+        if not line.startswith("{"):
+            continue
+        try:
+            value = json.loads(line)
+        except json.JSONDecodeError:
+            continue
+        if isinstance(value, dict):
+            return value
+    return None
+
+
+def _run_command_case(
+    *,
+    label: str,
+    command: list[str],
+    env: dict[str, str],
+    parse_report: bool = False,
+) -> dict[str, object]:
+    print(f"[{label}] Running:", " ".join(command))
+    completed = subprocess.run(
+        command,
+        cwd=ROOT,
+        env=env,
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+    if completed.stdout:
+        print(completed.stdout, end="")
+    if completed.stderr:
+        print(completed.stderr, end="", file=sys.stderr)
+    result: dict[str, object] = {
+        "label": label,
+        "passed": completed.returncode == 0,
+        "returncode": completed.returncode,
+        "command": command,
+    }
+    if parse_report:
+        result["report"] = _last_json_object(completed.stdout)
+    return result
+
+
+def _run_pytest_case(
+    *,
+    label: str,
+    selectors: list[str],
+    env: dict[str, str],
+) -> dict[str, object]:
+    return _run_command_case(
+        label=label,
+        command=[sys.executable, "-m", "pytest", "-v", "--tb=short", *selectors],
+        env=env,
+    )
+
+
+def _write_artifacts(
+    report: dict[str, object],
+    output_dir: Path,
+) -> tuple[Path, Path]:
+    output_dir.mkdir(parents=True, exist_ok=True)
+    day = datetime.now(timezone.utc).date().isoformat()
+    json_path = output_dir / f"HARDWARE_ACCEPTANCE_{day}.json"
+    markdown_path = output_dir / f"HARDWARE_ACCEPTANCE_{day}.md"
+    json_path.write_text(
+        json.dumps(report, sort_keys=True, indent=2, ensure_ascii=True) + "\n",
+        encoding="utf-8",
+    )
+    markdown_path.write_text(
+        "\n".join(
+            [
+                f"# Hardware Acceptance {day}",
+                "",
+                "**Classification:** Engineering Verification; not DATA/EVID.",
+                "",
+                f"- GPU: {report['gpu_identity']}",
+                f"- Wave-4 D1/D2: {report['wave4_physical']}",
+                f"- Builder D3c bridge: {report['builder_d3c_bridge']}",
+                f"- Canonical Frozen-Environment FE-3: {report['frozen_environment_fe3']}",
+                f"- Full FE-3 accepted: {report['full_fe3_accepted']}",
+                "",
+                "## Interpretation boundary",
+                "",
+                "- No scientific EVID or CLAIM is created.",
+                "- No speedup claim is created.",
+                "- PAN hyperstate is not in scope.",
+                "- Canonical learning semantics are not in scope.",
+                "- CPU/CUDA execution fingerprints are expected to differ because backend identity is provenance.",
+                "- Exact FE-3 acceptance requires the same manifest hash, live-input fingerprint and D3c trajectory hash.",
+                "",
+            ]
+        ),
+        encoding="utf-8",
+    )
+    return json_path, markdown_path
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--full",
+        action="store_true",
+        help="rerun all recurrent/plasticity physical acceptance cases too",
+    )
+    parser.add_argument(
+        "--include-fe3",
+        action="store_true",
+        help=(
+            "add canonical Frozen-Environment FE-3 CPU-vs-CUDA D3c acceptance "
+            "and the historical Builder D3c bridge; Wave-4 checks still run"
+        ),
+    )
+    parser.add_argument(
+        "--manifest",
+        default=str(DEFAULT_FE3_MANIFEST),
+        help="versioned FE-3 manifest artifact used by --include-fe3",
+    )
+    parser.add_argument(
+        "--output-dir",
+        default=str(ROOT / "docs" / "canonical"),
+        help="write dated JSON and Markdown engineering-verification artifacts here",
+    )
+    parser.add_argument(
+        "--require-gpu",
+        default="",
+        help="fail unless the reported GPU identity contains this string",
+    )
+    args = parser.parse_args()
+
+    identity = _gpu_identity()
+    print(f"CUDA hardware identity: {identity}")
+    if args.require_gpu and args.require_gpu.lower() not in identity.lower():
+        raise SystemExit(
+            f"required GPU substring {args.require_gpu!r} not present in {identity!r}"
+        )
+
+    env = dict(os.environ)
+    env["MHRN_TEST_CUDA_HARDWARE"] = "1"
+
+    results: list[dict[str, object]] = []
+    results.append(
+        _run_pytest_case(
+            label="WAVE4_D1_D2",
+            selectors=[
+                "tests/test_cuda_wave4_backend.py::"
+                "test_physical_cpu_cuda_cross_backend_d1_d2_parity"
+            ],
+            env=env,
+        )
+    )
+
+    if args.full:
+        results.append(
+            _run_pytest_case(
+                label="WAVE4_RECURRENT_PLASTICITY_FULL",
+                selectors=[
+                    "tests/test_playground_cuda_recurrent.py",
+                    "tests/test_playground_cuda_plasticity.py",
+                    "-k",
+                    "physical",
+                ],
+                env=env,
+            )
+        )
+
+    bridge_status = "NOT_REQUESTED"
+    fe3_status = "NOT_REQUESTED"
+    full_fe3_accepted = False
+    if args.include_fe3:
+        bridge = _run_pytest_case(
+            label="BUILDER_D3C_BRIDGE",
+            selectors=[
+                "tests/test_playground_cuda_builder.py::"
+                "test_full_pan_builder_hardware_d3"
+            ],
+            env=env,
+        )
+        results.append(bridge)
+        bridge_status = "PASS" if bool(bridge["passed"]) else "FAIL"
+
+        fe3 = _run_command_case(
+            label="FROZEN_ENVIRONMENT_FE3_CPU_CUDA_D3C",
+            command=[
+                sys.executable,
+                "scripts/run_fe_acceptance.py",
+                "--manifest",
+                str(Path(args.manifest)),
+                "--require-cuda",
+            ],
+            env=env,
+            parse_report=True,
+        )
+        results.append(fe3)
+        fe3_status = "PASS" if bool(fe3["passed"]) else "FAIL"
+        full_fe3_accepted = bool(fe3["passed"])
+
+    passed = all(bool(item["passed"]) for item in results)
+    report: dict[str, object] = {
+        "classification": "CUDA_HARDWARE_ACCEPTANCE_REPORT",
+        "scientific_evidence": False,
+        "gpu_identity": identity,
+        "wave4_physical": "PASS" if bool(results[0]["passed"]) else "FAIL",
+        "builder_d3c_bridge": bridge_status,
+        "frozen_environment_fe3": fe3_status,
+        "full_fe3_accepted": full_fe3_accepted,
+        "fe3_manifest": str(Path(args.manifest)),
+        "kernel_semantics_changed": False,
+        "execution_fingerprint_rule": (
+            "BACKEND_IDENTITY_IS_PROVENANCE; CPU/CUDA FINGERPRINTS DIFFER"
+        ),
+        "limitations": {
+            "speedup_claim": False,
+            "pan_hyperstate": False,
+            "canonical_learning_contract": False,
+            "scientific_data": False,
+            "evidence": False,
+        },
+        "results": results,
+        "passed": passed,
+    }
+    json_path, markdown_path = _write_artifacts(report, Path(args.output_dir))
+    report["artifact_json"] = str(json_path)
+    report["artifact_markdown"] = str(markdown_path)
+    print(json.dumps(report, sort_keys=True))
+
+    if not passed:
+        raise SystemExit(1)
+
+    print("CUDA hardware acceptance selections: PASS")
+    if args.include_fe3:
+        print(
+            "Canonical Frozen-Environment FE-3 CPU/CUDA D3c: PASS; "
+            "engineering verification only"
+        )
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

scripts/run_fe_acceptance.py

@@ -0,0 +1,121 @@
+#!/usr/bin/env python3
+"""Run FE-1/FE-2/FE-3 engineering acceptance for one frozen manifest."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+from collections.abc import Callable
+
+from src.acceleration.cuda import CUDABackend
+from src.acceleration.cuda.recurrent import CPUReferenceBackend
+from src.embodiment.deterministic import DeterministicTargetEnvironment
+from src.embodiment.models import ActionCommand, EnvironmentObservation
+from src.experience.frozen_environment import FreezeMode, FrozenWorldAdapter
+from src.verification.frozen_environment import (
+    load_manifest_artifact,
+    run_fe1_integrity,
+    run_fe2_replay_determinism,
+    run_fe3_backend_parity,
+    run_fe3_cpu_self_control,
+)
+
+
+def _target_world_factory(target: int) -> Callable[[], FrozenWorldAdapter]:
+    def factory() -> FrozenWorldAdapter:
+        return DeterministicTargetEnvironment(target=target)
+
+    return factory
+
+
+def _right_policy(
+    tick: int,
+    _previous: EnvironmentObservation | None,
+) -> ActionCommand:
+    return ActionCommand("target-actuator", tick, "right")
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--manifest", required=True)
+    parser.add_argument("--repeats", type=int, default=10)
+    parser.add_argument(
+        "--require-cuda",
+        action="store_true",
+        help=(
+            "Fail unless canonical FrozenEnvironment FE-3 has a live backend adapter; "
+            "the Builder D3c hardware bridge does not satisfy this gate."
+        ),
+    )
+    args = parser.parse_args()
+
+    manifest = load_manifest_artifact(args.manifest)
+    results: list[dict[str, object]] = []
+
+    if manifest.mode is FreezeMode.FE1_BOUNDARY_REPLAY:
+        results.append(run_fe1_integrity(manifest).to_mapping())
+    else:
+        target = manifest.environment_config.get("target")
+        if type(target) is not int:
+            raise ValueError(
+                "acceptance CLI currently supports deterministic-target manifests only"
+            )
+        factory = _target_world_factory(target)
+        results.append(
+            run_fe2_replay_determinism(
+                manifest,
+                factory,
+                _right_policy,
+                repeats=args.repeats,
+            ).to_mapping()
+        )
+        if manifest.mode is FreezeMode.FE3_FULL_DETERMINISTIC_LIVE_LOOP:
+            results.append(
+                run_fe3_cpu_self_control(
+                    manifest,
+                    factory,
+                    _right_policy,
+                ).to_mapping()
+            )
+
+    cuda_status = "NOT_REQUESTED"
+    passed = all(bool(item["passed"]) for item in results)
+    if args.require_cuda:
+        if manifest.mode is not FreezeMode.FE3_FULL_DETERMINISTIC_LIVE_LOOP:
+            cuda_status = "REQUIRES_FE3_MANIFEST"
+            passed = False
+        elif os.environ.get("MHRN_TEST_CUDA_HARDWARE") != "1":
+            cuda_status = "REQUIRES_MHRN_TEST_CUDA_HARDWARE"
+            passed = False
+        else:
+            target = manifest.environment_config.get("target")
+            if type(target) is not int:
+                raise ValueError(
+                    "CUDA FE-3 acceptance supports deterministic-target manifests only"
+                )
+            hardware = run_fe3_backend_parity(
+                manifest,
+                _target_world_factory(target),
+                CPUReferenceBackend,
+                CUDABackend,
+            )
+            results.append(hardware.to_mapping())
+            cuda_status = "PASS" if hardware.passed else "FAIL"
+            passed = passed and hardware.passed
+
+    report = {
+        "classification": "FROZEN_ENVIRONMENT_ACCEPTANCE_REPORT",
+        "scientific_evidence": False,
+        "manifest_sha256": manifest.manifest_sha256,
+        "mode": manifest.mode.value,
+        "results": results,
+        "cuda_d3": cuda_status,
+        "passed": passed,
+    }
+    print(json.dumps(report, sort_keys=True))
+    return 0 if passed else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

scripts/run_playground_cuda_smoke.py

@@ -0,0 +1,119 @@
+"""Run a real single-tick CUDA gate-kernel smoke/parity check.
+
+This script requires:
+- NVIDIA driver visible to the process;
+- ptxas on PATH (CUDA toolkit);
+- a supported NVIDIA GPU.
+
+It is intentionally not part of ordinary hosted CI because GitHub-hosted Linux
+runners do not expose an NVIDIA device.
+"""
+
+from __future__ import annotations
+
+import json
+
+from src.playground.cuda import (
+    GateLaunchInputs,
+    compile_mapping,
+    cpu_gate_reference,
+    execute_gate_bundle,
+    gate_execution_parity_summary,
+)
+
+
+def _inputs(bundle: object) -> GateLaunchInputs:
+    manifest = getattr(bundle, "manifest")
+    abi = manifest["kernel_abi"]
+    pan_dimensions = int(abi["pan_dimensions"])
+    return GateLaunchInputs.from_sequences(
+        input_current=[1.0, 2.0, 0.5, 1.5],
+        channel_masks=[0xFF] * 4,
+        amplitudes=[1.0] * 8,
+        reward_ring=[0.5],
+        action_map=[
+            0.0,
+            0.0,
+            0.0,
+            0.0,
+            0.0,
+            0.0,
+            0.0,
+            0.0,
+            3.0,
+            4.0,
+            5.0,
+            6.0,
+            0.0,
+            0.0,
+            0.0,
+            0.0,
+            0.0,
+            0.0,
+            0.0,
+            0.0,
+            0.0,
+            0.0,
+            0.0,
+            0.0,
+            0.0,
+            0.0,
+            0.0,
+            0.0,
+            0.0,
+            0.0,
+            0.0,
+            0.0,
+        ],
+        feedback_matrix=[0.0] * (4 * pan_dimensions),
+        population=[0.0] * pan_dimensions,
+        logits=[
+            0.1,
+            0.2,
+            0.3,
+            0.9,
+            0.1,
+            0.8,
+            0.2,
+            0.3,
+            0.7,
+            0.2,
+            0.1,
+            0.0,
+            0.1,
+            0.2,
+            0.9,
+            0.3,
+        ],
+        tick=0,
+        target_index=2,
+        previous_action=1,
+        seed=12345,
+        epsilon=0.0,
+    )
+
+
+def main() -> int:
+    bundle = compile_mapping(
+        {
+            "closed_loop_preset": "minimal_closed_loop",
+            "pan_feedback_gain": 0.0,
+        }
+    )
+    inputs = _inputs(bundle)
+    reference = cpu_gate_reference(bundle, inputs)
+    cuda = execute_gate_bundle(bundle, inputs, block_size=64)
+    parity = gate_execution_parity_summary(reference, cuda)
+    result = {
+        "classification": "PLAYGROUND_CUDA1_3_HARDWARE_SMOKE",
+        "scientific_evidence": False,
+        "reference": reference,
+        "cuda": cuda,
+        "parity": parity,
+    }
+    print(json.dumps(result, indent=2, sort_keys=True))
+    return 0 if parity["passed"] else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

scripts/validate_playground_ptx.py

@@ -6,6 +6,8 @@ import json
 from pathlib import Path
 
 from src.playground.cuda import assemble_bundle, compile_mapping
+from src.playground.cuda.nvrtc import compile_cuda_source
+from src.playground.cuda.runtime import assemble_ptx
 
 
 def main() -> int:
@@ -25,6 +27,48 @@ def main() -> int:
             "spill_store_bytes": report.spill_store_bytes,
             "spill_load_bytes": report.spill_load_bytes,
         }
+    source = Path("src/playground/cuda/recurrent.cu").read_text()
+    recurrent_dir = root / "recurrent"
+    recurrent_dir.mkdir(parents=True, exist_ok=True)
+    ptx_path = recurrent_dir / "recurrent.ptx"
+    ptx_path.write_text(compile_cuda_source(source), encoding="utf-8")
+    recurrent_report = assemble_ptx(
+        ptx_path.read_text(), output_dir=recurrent_dir, target_sm="sm_86"
+    )
+    results["recurrent"] = recurrent_report.to_mapping()
+    plastic_report = assemble_ptx(
+        compile_cuda_source("#define PAN_PLASTIC\n" + source),
+        output_dir=root / "plasticity",
+        target_sm="sm_86",
+    )
+    results["plasticity"] = plastic_report.to_mapping()
+    results["builder_membrane"] = assemble_ptx(
+        compile_cuda_source(Path("src/playground/cuda/membrane.cu").read_text()),
+        output_dir=root / "builder-membrane",
+        target_sm="sm_86",
+    ).to_mapping()
+    results["builder_pan_state"] = assemble_ptx(
+        compile_cuda_source(Path("src/playground/cuda/pan_state.cu").read_text()),
+        output_dir=root / "builder-pan-state",
+        target_sm="sm_86",
+    ).to_mapping()
+    results["builder_synaptic_emission"] = assemble_ptx(
+        compile_cuda_source(
+            Path("src/playground/cuda/builder_synapses.cu").read_text()
+        ),
+        output_dir=root / "builder-synaptic-emission",
+        target_sm="sm_86",
+    ).to_mapping()
+    results["resident_delay_queue"] = assemble_ptx(
+        compile_cuda_source(Path("src/playground/cuda/delay_queue.cu").read_text()),
+        output_dir=root / "resident-delay-queue",
+        target_sm="sm_86",
+    ).to_mapping()
+    results["resident_neuron_traces"] = assemble_ptx(
+        compile_cuda_source(Path("src/playground/cuda/neuron_traces.cu").read_text()),
+        output_dir=root / "resident-neuron-traces",
+        target_sm="sm_86",
+    ).to_mapping()
     print(json.dumps(results, indent=2, sort_keys=True))
     return 0
 

src/acceleration/__init__.py

@@ -0,0 +1 @@
+"""Canonical hardware acceleration interfaces."""

src/acceleration/cuda/__init__.py

@@ -0,0 +1,34 @@
+"""Canonical CUDA acceleration layer.
+
+No module in this package may import :mod:`src.playground`.
+"""
+
+from .backend import CUDABackend, execution_backend_contract_check
+from .driver import CudaDriver, DriverModule
+from .errors import CudaDriverError, CudaRuntimeUnavailable
+from .memory import DeviceAllocation
+from .nvrtc import compile_cuda_source, toolkit_root
+from .preflight import (
+    CooperativePreflight,
+    cooperative_capacity,
+    validate_cuda_block_size,
+)
+from .ptxas import PtxasReport, assemble_ptx, parse_ptxas_verbose
+
+__all__ = [
+    "CUDABackend",
+    "CooperativePreflight",
+    "CudaDriver",
+    "CudaDriverError",
+    "CudaRuntimeUnavailable",
+    "DeviceAllocation",
+    "DriverModule",
+    "PtxasReport",
+    "assemble_ptx",
+    "compile_cuda_source",
+    "cooperative_capacity",
+    "parse_ptxas_verbose",
+    "toolkit_root",
+    "execution_backend_contract_check",
+    "validate_cuda_block_size",
+]

src/acceleration/cuda/backend.py

@@ -0,0 +1,176 @@
+"""ExecutionBackend facade for the bounded Wave-4 CUDA reference."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping, Sequence
+from typing import Any
+
+from src.runtime.backend import (
+    BackendCapabilities,
+    BackendState,
+    ExecutionBackend,
+    RunResult,
+    StepResult,
+)
+from src.verification.parity import config_fingerprint, execution_fingerprint
+
+from .plasticity.contracts import PLASTICITY_SEMANTICS
+from .recurrent.backend import execute_recurrent
+from .recurrent.state import (
+    canonical_int,
+    prefix_inputs,
+    recurrent_inputs_from_mapping,
+    recurrent_inputs_to_mapping,
+    set_external_tick_config,
+    stable_digest,
+    step_payload,
+)
+
+
+class CUDABackend:
+    """Bounded replay adapter over the hardware-verified recurrent kernel."""
+
+    backend_name = "cuda"
+    backend_version = "wave4-bounded-replay-v1"
+
+    def __init__(self) -> None:
+        self._config: dict[str, object] | None = None
+        self._seed = 0
+        self._tick = 0
+
+    def initialize(self, config: Mapping[str, object], seed: int) -> None:
+        inputs = recurrent_inputs_from_mapping(config, seed=seed)
+        self._config = recurrent_inputs_to_mapping(inputs)
+        self._seed = seed
+        self._tick = 0
+
+    def _require_config(self) -> dict[str, object]:
+        if self._config is None:
+            raise RuntimeError("backend is not initialized")
+        return self._config
+
+    def _execute_prefix(self, total_ticks: int) -> Mapping[str, object]:
+        config = self._require_config()
+        inputs = recurrent_inputs_from_mapping(config, seed=self._seed)
+        result = execute_recurrent(prefix_inputs(inputs, total_ticks))
+        outputs = result.get("outputs")
+        if not isinstance(outputs, Mapping):
+            raise RuntimeError("CUDA recurrent execution returned no outputs")
+        return outputs
+
+    def _step_from_outputs(
+        self, outputs: Mapping[str, object], tick: int
+    ) -> StepResult:
+        config = self._require_config()
+        payload = step_payload(
+            outputs,
+            tick=tick,
+            n_neurons=canonical_int(config["n_neurons"], field="n_neurons"),
+        )
+        spikes_raw = payload["spikes"]
+        if not isinstance(spikes_raw, list):
+            raise ValueError("spike payload must be a list")
+        spikes = tuple(
+            index for index, value in enumerate(spikes_raw) if int(value) == 1
+        )
+        return StepResult(
+            tick=tick + 1,
+            spikes=spikes,
+            state_digest=stable_digest(payload),
+            metrics={
+                "voltage": payload["voltage"],
+                "adaptation": payload["adaptation"],
+                "spike_count": len(spikes),
+            },
+        )
+
+    def set_external_tick(self, tick: int, currents: Sequence[float]) -> None:
+        """Inject one live input row without changing CUDA kernel semantics."""
+
+        if tick != self._tick:
+            raise ValueError("live external input tick must equal continuation cursor")
+        set_external_tick_config(self._require_config(), tick=tick, currents=currents)
+
+    def step(self, tick: int) -> StepResult:
+        if tick != self._tick:
+            raise ValueError("tick must equal the backend continuation cursor")
+        config = self._require_config()
+        if tick >= canonical_int(config["ticks"], field="ticks"):
+            raise ValueError("configured tick limit reached")
+        outputs = self._execute_prefix(tick + 1)
+        self._tick = tick + 1
+        return self._step_from_outputs(outputs, tick)
+
+    def run(self, ticks: int) -> RunResult:
+        if type(ticks) is not int or ticks < 1:
+            raise ValueError("ticks must be a positive int")
+        config = self._require_config()
+        total = self._tick + ticks
+        if total > canonical_int(config["ticks"], field="ticks"):
+            raise ValueError("requested run exceeds configured tick limit")
+        start = self._tick
+        outputs = self._execute_prefix(total)
+        steps = tuple(
+            self._step_from_outputs(outputs, tick) for tick in range(start, total)
+        )
+        self._tick = total
+        return RunResult(
+            ticks_requested=ticks,
+            steps=steps,
+            final_state=self.snapshot(),
+            execution_fingerprint=execution_fingerprint(
+                seed=self._seed,
+                config_hash=config_fingerprint(config),
+                backend_name=self.backend_name,
+                backend_version=self.backend_version,
+                ticks=total,
+            ),
+        )
+
+    def snapshot(self) -> BackendState:
+        config = self._require_config()
+        payload: dict[str, Any] = {
+            "backend": self.backend_version,
+            "seed": self._seed,
+            "tick": self._tick,
+            "config": config,
+            "replay_required": True,
+        }
+        return BackendState(
+            tick=self._tick,
+            payload=payload,
+            state_digest=stable_digest(payload),
+        )
+
+    def restore(self, state: BackendState) -> None:
+        payload = dict(state.payload)
+        if payload.get("backend") != self.backend_version:
+            raise ValueError("checkpoint backend version mismatch")
+        raw_config = payload.get("config")
+        raw_seed = payload.get("seed")
+        if not isinstance(raw_config, Mapping) or type(raw_seed) is not int:
+            raise ValueError("checkpoint is missing canonical config/seed")
+        self.initialize(raw_config, raw_seed)
+        if state.tick > canonical_int(self._require_config()["ticks"], field="ticks"):
+            raise ValueError("checkpoint tick exceeds configured limit")
+        self._tick = state.tick
+
+    def capabilities(self) -> BackendCapabilities:
+        return BackendCapabilities(
+            supports_recurrent=True,
+            supports_plasticity=True,
+            supports_pan_hyperstate=False,
+            supports_structural_plasticity=False,
+            max_neurons=4096,
+            max_ticks=2000,
+            max_edges=65536,
+            deterministic=True,
+            plasticity_semantics=PLASTICITY_SEMANTICS,
+            execution_mode="BOUNDED_REPLAY_REFERENCE",
+            supports_live_external_input=True,
+        )
+
+
+def execution_backend_contract_check() -> bool:
+    backend: ExecutionBackend = CUDABackend()
+    return isinstance(backend, ExecutionBackend)

src/acceleration/cuda/driver.py

@@ -0,0 +1,478 @@
+"""Canonical CUDA Driver API wrapper.
+
+This module owns device/context/module/memory/launch mechanics only. It has no
+Playground, PAN, Gate-IR or scientific semantics.
+"""
+
+from __future__ import annotations
+
+import ctypes
+import math
+import os
+from collections.abc import Sequence
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from .errors import CudaDriverError, CudaRuntimeUnavailable
+from .memory import DeviceAllocation
+from .preflight import CooperativePreflight, validate_cuda_block_size
+
+# CUDA Driver API attribute IDs from cuda.h.
+_CU_DEVICE_ATTRIBUTE_MULTIPROCESSOR_COUNT = 16
+_CU_DEVICE_ATTRIBUTE_COOPERATIVE_LAUNCH = 95
+
+
+@dataclass(frozen=True, slots=True)
+class DriverModule:
+    """Opaque handles returned by CUDA Driver API loading."""
+
+    context: ctypes.c_void_p
+    module: ctypes.c_void_p
+    function: ctypes.c_void_p
+    device_ordinal: int
+
+
+class CudaDriver:
+    """Minimal ctypes wrapper for CUDA-1 loading, memory and kernel launch."""
+
+    def __init__(self, library: str | None = None) -> None:
+        candidates = (
+            [library]
+            if library
+            else (["nvcuda.dll"] if os.name == "nt" else ["libcuda.so.1", "libcuda.so"])
+        )
+        loader = (
+            getattr(ctypes, "WinDLL", ctypes.CDLL) if os.name == "nt" else ctypes.CDLL
+        )
+        last_error: OSError | None = None
+        for candidate in candidates:
+            try:
+                self._lib = loader(candidate)
+                break
+            except OSError as exc:
+                last_error = exc
+        else:
+            names = ", ".join(candidates)
+            raise CudaRuntimeUnavailable(
+                f"CUDA driver library not available; tried: {names}"
+            ) from last_error
+        self._bind()
+
+    def _bind(self) -> None:
+        lib = self._lib
+        lib.cuInit.argtypes = [ctypes.c_uint]
+        lib.cuInit.restype = ctypes.c_int
+        lib.cuDeviceGet.argtypes = [ctypes.POINTER(ctypes.c_int), ctypes.c_int]
+        lib.cuDeviceGet.restype = ctypes.c_int
+        lib.cuDeviceGetAttribute.argtypes = [
+            ctypes.POINTER(ctypes.c_int),
+            ctypes.c_int,
+            ctypes.c_int,
+        ]
+        lib.cuDeviceGetAttribute.restype = ctypes.c_int
+        lib.cuCtxCreate_v2.argtypes = [
+            ctypes.POINTER(ctypes.c_void_p),
+            ctypes.c_uint,
+            ctypes.c_int,
+        ]
+        lib.cuCtxCreate_v2.restype = ctypes.c_int
+        lib.cuCtxDestroy_v2.argtypes = [ctypes.c_void_p]
+        lib.cuCtxDestroy_v2.restype = ctypes.c_int
+        lib.cuModuleLoad.argtypes = [
+            ctypes.POINTER(ctypes.c_void_p),
+            ctypes.c_char_p,
+        ]
+        lib.cuModuleLoad.restype = ctypes.c_int
+        lib.cuModuleUnload.argtypes = [ctypes.c_void_p]
+        lib.cuModuleUnload.restype = ctypes.c_int
+        lib.cuModuleGetFunction.argtypes = [
+            ctypes.POINTER(ctypes.c_void_p),
+            ctypes.c_void_p,
+            ctypes.c_char_p,
+        ]
+        lib.cuModuleGetFunction.restype = ctypes.c_int
+        lib.cuOccupancyMaxActiveBlocksPerMultiprocessor.argtypes = [
+            ctypes.POINTER(ctypes.c_int),
+            ctypes.c_void_p,
+            ctypes.c_int,
+            ctypes.c_size_t,
+        ]
+        lib.cuOccupancyMaxActiveBlocksPerMultiprocessor.restype = ctypes.c_int
+        lib.cuMemAlloc_v2.argtypes = [
+            ctypes.POINTER(ctypes.c_uint64),
+            ctypes.c_size_t,
+        ]
+        lib.cuMemAlloc_v2.restype = ctypes.c_int
+        lib.cuMemFree_v2.argtypes = [ctypes.c_uint64]
+        lib.cuMemFree_v2.restype = ctypes.c_int
+        lib.cuMemGetInfo_v2.argtypes = [
+            ctypes.POINTER(ctypes.c_size_t),
+            ctypes.POINTER(ctypes.c_size_t),
+        ]
+        lib.cuMemGetInfo_v2.restype = ctypes.c_int
+        lib.cuMemcpyHtoD_v2.argtypes = [
+            ctypes.c_uint64,
+            ctypes.c_void_p,
+            ctypes.c_size_t,
+        ]
+        lib.cuMemcpyHtoD_v2.restype = ctypes.c_int
+        lib.cuMemcpyDtoH_v2.argtypes = [
+            ctypes.c_void_p,
+            ctypes.c_uint64,
+            ctypes.c_size_t,
+        ]
+        lib.cuMemcpyDtoH_v2.restype = ctypes.c_int
+        lib.cuLaunchKernel.argtypes = [
+            ctypes.c_void_p,
+            ctypes.c_uint,
+            ctypes.c_uint,
+            ctypes.c_uint,
+            ctypes.c_uint,
+            ctypes.c_uint,
+            ctypes.c_uint,
+            ctypes.c_uint,
+            ctypes.c_void_p,
+            ctypes.POINTER(ctypes.c_void_p),
+            ctypes.POINTER(ctypes.c_void_p),
+        ]
+        lib.cuLaunchKernel.restype = ctypes.c_int
+        lib.cuCtxSynchronize.argtypes = []
+        lib.cuCtxSynchronize.restype = ctypes.c_int
+
+    @staticmethod
+    def _check(code: int, call: str) -> None:
+        if code != 0:
+            raise CudaDriverError(f"{call} failed with CUDA error code {code}")
+
+    def initialize(self) -> None:
+        self._check(self._lib.cuInit(0), "cuInit")
+
+    def _device(self, ordinal: int) -> int:
+        device = ctypes.c_int()
+        self._check(
+            self._lib.cuDeviceGet(ctypes.byref(device), ordinal),
+            "cuDeviceGet",
+        )
+        return int(device.value)
+
+    def device_attribute(self, ordinal: int, attribute: int) -> int:
+        device = self._device(ordinal)
+        value = ctypes.c_int()
+        self._check(
+            self._lib.cuDeviceGetAttribute(
+                ctypes.byref(value),
+                attribute,
+                device,
+            ),
+            "cuDeviceGetAttribute",
+        )
+        return int(value.value)
+
+    def alloc_device(self, size_bytes: int) -> DeviceAllocation:
+        """Allocate device memory owned by the current CUDA context."""
+
+        if size_bytes <= 0:
+            raise ValueError("size_bytes must be positive")
+        ptr = ctypes.c_uint64()
+        self._check(
+            self._lib.cuMemAlloc_v2(ctypes.byref(ptr), size_bytes),
+            "cuMemAlloc_v2",
+        )
+        return DeviceAllocation(ptr=int(ptr.value), size_bytes=size_bytes)
+
+    def free_device(self, allocation: DeviceAllocation) -> None:
+        """Release one device allocation."""
+
+        if allocation.ptr:
+            self._check(
+                self._lib.cuMemFree_v2(ctypes.c_uint64(allocation.ptr)),
+                "cuMemFree_v2",
+            )
+
+    def memory_info(self) -> tuple[int, int]:
+        """Return free and total bytes for the current CUDA context."""
+
+        free_bytes = ctypes.c_size_t()
+        total_bytes = ctypes.c_size_t()
+        self._check(
+            self._lib.cuMemGetInfo_v2(
+                ctypes.byref(free_bytes),
+                ctypes.byref(total_bytes),
+            ),
+            "cuMemGetInfo_v2",
+        )
+        return int(free_bytes.value), int(total_bytes.value)
+
+    def copy_host_to_device(
+        self,
+        allocation: DeviceAllocation,
+        source: ctypes.Array[Any],
+        *,
+        size_bytes: int | None = None,
+    ) -> None:
+        """Copy a ctypes-backed host buffer to device memory."""
+
+        count = allocation.size_bytes if size_bytes is None else size_bytes
+        host_bytes = ctypes.sizeof(source)
+        if count < 0 or count > allocation.size_bytes:
+            raise ValueError("host-to-device copy exceeds device allocation")
+        if count > host_bytes:
+            raise ValueError(
+                f"host-to-device copy exceeds host buffer: {count} > {host_bytes}"
+            )
+        self._check(
+            self._lib.cuMemcpyHtoD_v2(
+                ctypes.c_uint64(allocation.ptr),
+                ctypes.cast(source, ctypes.c_void_p),
+                count,
+            ),
+            "cuMemcpyHtoD_v2",
+        )
+
+    def copy_device_to_host(
+        self,
+        destination: ctypes.Array[Any],
+        allocation: DeviceAllocation,
+        *,
+        size_bytes: int | None = None,
+    ) -> None:
+        """Copy device memory into a ctypes-backed host buffer."""
+
+        count = allocation.size_bytes if size_bytes is None else size_bytes
+        host_bytes = ctypes.sizeof(destination)
+        if count < 0 or count > allocation.size_bytes:
+            raise ValueError("device-to-host copy exceeds device allocation")
+        if count > host_bytes:
+            raise ValueError(
+                f"device-to-host copy exceeds host buffer: {count} > {host_bytes}"
+            )
+        self._check(
+            self._lib.cuMemcpyDtoH_v2(
+                ctypes.cast(destination, ctypes.c_void_p),
+                ctypes.c_uint64(allocation.ptr),
+                count,
+            ),
+            "cuMemcpyDtoH_v2",
+        )
+
+    def launch_kernel(
+        self,
+        loaded: DriverModule,
+        *,
+        grid: tuple[int, int, int],
+        block: tuple[int, int, int],
+        arguments: Sequence[object],
+        dynamic_shared_bytes: int = 0,
+    ) -> None:
+        """Launch a loaded kernel with CUDA Driver API argument packing."""
+
+        if min(*grid, *block) <= 0:
+            raise ValueError("grid and block dimensions must be positive")
+        storage = list(arguments)
+        kernel_params = (ctypes.c_void_p * len(storage))()
+        for index, argument in enumerate(storage):
+            kernel_params[index] = ctypes.cast(
+                ctypes.byref(argument), ctypes.c_void_p  # type: ignore[arg-type]
+            )
+        self._check(
+            self._lib.cuLaunchKernel(
+                loaded.function,
+                grid[0],
+                grid[1],
+                grid[2],
+                block[0],
+                block[1],
+                block[2],
+                dynamic_shared_bytes,
+                None,
+                kernel_params,
+                None,
+            ),
+            "cuLaunchKernel",
+        )
+
+    def synchronize(self) -> None:
+        """Synchronize the current CUDA context."""
+
+        self._check(self._lib.cuCtxSynchronize(), "cuCtxSynchronize")
+
+    def launch_cooperative(
+        self,
+        loaded: DriverModule,
+        *,
+        n_neurons: int,
+        block_size: int,
+        arguments: Sequence[object],
+    ) -> CooperativePreflight:
+        """Launch a resident 1D grid only after checking actual kernel occupancy."""
+        preflight = self.cooperative_preflight(
+            loaded, n_neurons=n_neurons, block_size=block_size
+        )
+        if n_neurons < 1 or not preflight.launch_fits:
+            raise ValueError(
+                "cooperative grid exceeds the device/kernel resident capacity"
+            )
+        launch = self._lib.cuLaunchCooperativeKernel
+        launch.argtypes = [
+            ctypes.c_void_p,
+            ctypes.c_uint,
+            ctypes.c_uint,
+            ctypes.c_uint,
+            ctypes.c_uint,
+            ctypes.c_uint,
+            ctypes.c_uint,
+            ctypes.c_uint,
+            ctypes.c_void_p,
+            ctypes.POINTER(ctypes.c_void_p),
+        ]
+        launch.restype = ctypes.c_int
+        storage = list(arguments)
+        parameters = (ctypes.c_void_p * len(storage))()
+        for index, argument in enumerate(storage):
+            parameters[index] = ctypes.cast(
+                ctypes.byref(argument), ctypes.c_void_p  # type: ignore[arg-type]
+            )
+        self._check(
+            launch(
+                loaded.function,
+                preflight.required_blocks,
+                1,
+                1,
+                block_size,
+                1,
+                1,
+                0,
+                None,
+                parameters,
+            ),
+            "cuLaunchCooperativeKernel",
+        )
+        return preflight
+
+    def load_cubin(
+        self,
+        cubin_path: Path,
+        *,
+        kernel_name: str = "pan_gate_kernel",
+        device_ordinal: int = 0,
+    ) -> DriverModule:
+        """Load a ptxas-generated cubin and resolve one kernel symbol."""
+
+        self.initialize()
+        device = self._device(device_ordinal)
+        context = ctypes.c_void_p()
+        self._check(
+            self._lib.cuCtxCreate_v2(ctypes.byref(context), 0, device),
+            "cuCtxCreate_v2",
+        )
+        module = ctypes.c_void_p()
+        try:
+            self._check(
+                self._lib.cuModuleLoad(
+                    ctypes.byref(module),
+                    str(cubin_path).encode("utf-8"),
+                ),
+                "cuModuleLoad",
+            )
+            function = ctypes.c_void_p()
+            self._check(
+                self._lib.cuModuleGetFunction(
+                    ctypes.byref(function),
+                    module,
+                    kernel_name.encode("ascii"),
+                ),
+                "cuModuleGetFunction",
+            )
+        except Exception:
+            if module.value:
+                self._lib.cuModuleUnload(module)
+            self._lib.cuCtxDestroy_v2(context)
+            raise
+        return DriverModule(
+            context=context,
+            module=module,
+            function=function,
+            device_ordinal=device_ordinal,
+        )
+
+    def kernel(self, loaded: DriverModule, name: str) -> DriverModule:
+        """Borrow another function in the same owned module/context; do not unload it separately."""
+        if not name or not name.isascii() or not name.replace("_", "").isalnum():
+            raise ValueError("invalid CUDA kernel symbol")
+        function = ctypes.c_void_p()
+        self._check(
+            self._lib.cuModuleGetFunction(
+                ctypes.byref(function), loaded.module, name.encode("ascii")
+            ),
+            "cuModuleGetFunction",
+        )
+        return DriverModule(
+            loaded.context, loaded.module, function, loaded.device_ordinal
+        )
+
+    def unload(self, loaded: DriverModule) -> None:
+        module_error: CudaDriverError | None = None
+        if loaded.module.value:
+            try:
+                self._check(
+                    self._lib.cuModuleUnload(loaded.module),
+                    "cuModuleUnload",
+                )
+            except CudaDriverError as exc:
+                module_error = exc
+        if loaded.context.value:
+            try:
+                self._check(
+                    self._lib.cuCtxDestroy_v2(loaded.context),
+                    "cuCtxDestroy_v2",
+                )
+            except CudaDriverError:
+                if module_error is None:
+                    raise
+        if module_error is not None:
+            raise module_error
+
+    def cooperative_preflight(
+        self,
+        loaded: DriverModule,
+        *,
+        n_neurons: int,
+        block_size: int = 128,
+        dynamic_shared_bytes: int = 0,
+    ) -> CooperativePreflight:
+        """Calculate whether the full cooperative grid can be resident."""
+
+        validate_cuda_block_size(block_size)
+        cooperative = bool(
+            self.device_attribute(
+                loaded.device_ordinal,
+                _CU_DEVICE_ATTRIBUTE_COOPERATIVE_LAUNCH,
+            )
+        )
+        sms = self.device_attribute(
+            loaded.device_ordinal,
+            _CU_DEVICE_ATTRIBUTE_MULTIPROCESSOR_COUNT,
+        )
+        active = ctypes.c_int()
+        self._check(
+            self._lib.cuOccupancyMaxActiveBlocksPerMultiprocessor(
+                ctypes.byref(active),
+                loaded.function,
+                block_size,
+                dynamic_shared_bytes,
+            ),
+            "cuOccupancyMaxActiveBlocksPerMultiprocessor",
+        )
+        required = math.ceil(n_neurons / block_size)
+        capacity = int(active.value) * sms
+        return CooperativePreflight(
+            cooperative_launch=cooperative,
+            multiprocessor_count=sms,
+            active_blocks_per_sm=int(active.value),
+            block_size=block_size,
+            required_blocks=required,
+            resident_block_capacity=capacity,
+            launch_fits=cooperative and required <= capacity,
+            n_neurons=n_neurons,
+        )

src/acceleration/cuda/errors.py

@@ -0,0 +1,9 @@
+"""Canonical CUDA acceleration errors."""
+
+
+class CudaRuntimeUnavailable(RuntimeError):
+    """Raised when an optional CUDA-1 dependency is not available."""
+
+
+class CudaDriverError(RuntimeError):
+    """Raised when a CUDA Driver API call fails."""

src/acceleration/cuda/memory.py

@@ -0,0 +1,13 @@
+"""Canonical CUDA memory ownership contracts."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True, slots=True)
+class DeviceAllocation:
+    """One owned CUDA device allocation."""
+
+    ptr: int
+    size_bytes: int

src/acceleration/cuda/nvrtc.py

@@ -0,0 +1,116 @@
+"""Optional CUDA source compilation without a host C++ compiler."""
+
+from __future__ import annotations
+
+import ctypes
+import os
+import re
+import shutil
+from contextlib import nullcontext
+from pathlib import Path
+
+from .errors import CudaRuntimeUnavailable
+
+
+def toolkit_root() -> Path:
+    candidates = [os.environ.get("CUDA_PATH", ""), os.environ.get("CUDA_HOME", "")]
+    compiler = shutil.which("nvcc")
+    if compiler:
+        candidates.append(str(Path(compiler).resolve().parent.parent))
+    candidates.append("/usr/local/cuda")
+    if os.name == "nt":
+        base = Path(os.environ.get("ProgramFiles", "C:/Program Files"))
+        candidates.extend(
+            str(p)
+            for p in sorted(
+                (base / "NVIDIA GPU Computing Toolkit/CUDA").glob("v*"), reverse=True
+            )
+        )
+    for candidate in candidates:
+        if candidate and (Path(candidate) / "include/cooperative_groups.h").is_file():
+            return Path(candidate)
+    raise CudaRuntimeUnavailable("CUDA toolkit headers/NVRTC are required")
+
+
+def compile_cuda_source(source: str, *, target_sm: str = "sm_86") -> str:
+    """Compile a bounded trusted source string to PTX; no GPU is required."""
+    if not re.fullmatch(r"sm_[0-9]{2,3}", target_sm):
+        raise ValueError("invalid CUDA architecture")
+    root = toolkit_root()
+    patterns = (
+        ["bin/nvrtc64_*.dll", "bin/x64/nvrtc64_*.dll"]
+        if os.name == "nt"
+        else ["lib64/libnvrtc.so*", "targets/x86_64-linux/lib/libnvrtc.so*"]
+    )
+    libraries = [
+        p for pattern in patterns for p in root.glob(pattern) if ".alt." not in p.name
+    ]
+    if not libraries:
+        raise CudaRuntimeUnavailable("NVRTC library is not installed")
+    library = libraries[0]
+    directory = (
+        getattr(os, "add_dll_directory")(str(library.parent))
+        if os.name == "nt"
+        else nullcontext()
+    )
+    with directory:
+        lib = ctypes.CDLL(str(library))
+        lib.nvrtcCreateProgram.argtypes = [
+            ctypes.POINTER(ctypes.c_void_p),
+            ctypes.c_char_p,
+            ctypes.c_char_p,
+            ctypes.c_int,
+            ctypes.c_void_p,
+            ctypes.c_void_p,
+        ]
+        lib.nvrtcCompileProgram.argtypes = [
+            ctypes.c_void_p,
+            ctypes.c_int,
+            ctypes.POINTER(ctypes.c_char_p),
+        ]
+        lib.nvrtcGetProgramLogSize.argtypes = [
+            ctypes.c_void_p,
+            ctypes.POINTER(ctypes.c_size_t),
+        ]
+        lib.nvrtcGetProgramLog.argtypes = [ctypes.c_void_p, ctypes.c_void_p]
+        lib.nvrtcGetPTXSize.argtypes = [
+            ctypes.c_void_p,
+            ctypes.POINTER(ctypes.c_size_t),
+        ]
+        lib.nvrtcGetPTX.argtypes = [ctypes.c_void_p, ctypes.c_void_p]
+        lib.nvrtcDestroyProgram.argtypes = [ctypes.POINTER(ctypes.c_void_p)]
+        program = ctypes.c_void_p()
+        code = lib.nvrtcCreateProgram(
+            ctypes.byref(program), source.encode(), b"recurrent.cu", 0, None, None
+        )
+        if code:
+            raise CudaRuntimeUnavailable(f"nvrtcCreateProgram failed: {code}")
+        try:
+            options = [
+                f"--gpu-architecture=compute_{target_sm[3:]}",
+                f"--include-path={root / 'include'}",
+                "--std=c++17",
+                "--fmad=false",
+            ]
+            if (root / "include/cccl").is_dir():
+                options.append(f"--include-path={root / 'include/cccl'}")
+            encoded = (ctypes.c_char_p * len(options))(
+                *(item.encode() for item in options)
+            )
+            code = lib.nvrtcCompileProgram(program, len(options), encoded)
+            size = ctypes.c_size_t()
+            lib.nvrtcGetProgramLogSize(program, ctypes.byref(size))
+            log = ctypes.create_string_buffer(max(1, size.value))
+            lib.nvrtcGetProgramLog(program, log)
+            if code:
+                raise CudaRuntimeUnavailable(
+                    f"NVRTC compilation failed ({code}): {log.value.decode(errors='replace')}"
+                )
+            if lib.nvrtcGetPTXSize(program, ctypes.byref(size)):
+                raise CudaRuntimeUnavailable("NVRTC PTX size unavailable")
+            ptx = ctypes.create_string_buffer(size.value)
+            if lib.nvrtcGetPTX(program, ptx):
+                raise CudaRuntimeUnavailable("NVRTC PTX retrieval failed")
+            return ptx.value.decode()
+        finally:
+            lib.nvrtcDestroyProgram(ctypes.byref(program))

src/acceleration/cuda/plasticity/__init__.py

@@ -0,0 +1,18 @@
+"""Canonical CUDA plasticity engineering package."""
+
+from .backend import BuilderSynapseStepper
+from .contracts import (
+    LEARNING_CONTRACT_ID,
+    LEARNING_CONTRACT_STATUS,
+    PLASTICITY_SEMANTICS,
+)
+from .reference import SynapseConfig, SynapseState
+
+__all__ = [
+    "BuilderSynapseStepper",
+    "LEARNING_CONTRACT_ID",
+    "LEARNING_CONTRACT_STATUS",
+    "PLASTICITY_SEMANTICS",
+    "SynapseConfig",
+    "SynapseState",
+]

src/acceleration/cuda/plasticity/backend.py

@@ -0,0 +1,268 @@
+"""CUDA synaptic kernels extracted from the Playground engineering path.
+
+Semantics remain NON_CANONICAL_DRAFT until the canonical learning contract is
+implemented by both CPU and CUDA paths.
+"""
+
+from __future__ import annotations
+
+import ctypes
+import math
+from collections.abc import Sequence
+from typing import Any
+
+from ..driver import CudaDriver, DriverModule
+from ..errors import CudaDriverError
+from ..memory import DeviceAllocation
+
+
+class BuilderSynapseStepper:
+    """Reuse bounded buffers for emission and per-tick recovery/decay."""
+
+    def __init__(self, driver: CudaDriver, loaded: DriverModule, capacity: int) -> None:
+        if type(capacity) is not int or not 1 <= capacity <= 20000:
+            raise ValueError("invalid CUDA synaptic capacity")
+        self.driver, self.capacity = driver, capacity
+        self.emit_kernel = driver.kernel(loaded, "pan_synaptic_emit")
+        self.recover_kernel = driver.kernel(loaded, "pan_synaptic_recover")
+        self.reward_kernel = driver.kernel(loaded, "pan_synaptic_reward")
+        self.plasticity_kernel = driver.kernel(loaded, "pan_synaptic_plasticity")
+        self.scale_kernel = driver.kernel(loaded, "pan_synaptic_scale")
+        self.device: dict[str, DeviceAllocation] = {}
+        self.host: dict[str, Any] = {
+            "input": (ctypes.c_double * (12 * capacity))(),
+            "output": (ctypes.c_double * (3 * capacity))(),
+        }
+        self.emitted_events = 0
+        self.recovery_calls = 0
+        self.reward_calls = 0
+        self.plasticity_calls = 0
+        try:
+            for name in self.host:
+                self.device[name] = driver.alloc_device(ctypes.sizeof(self.host[name]))
+        except BaseException:
+            self.close()
+            raise
+
+    def close(self) -> None:
+        for allocation in reversed(list(self.device.values())):
+            try:
+                self.driver.free_device(allocation)
+            except CudaDriverError:
+                pass
+        self.device.clear()
+
+    def _execute(
+        self,
+        rows: list[tuple[float, float, float, float, float]],
+        *,
+        stp: bool,
+        first: float,
+        second: float,
+        kernel: DriverModule,
+    ) -> list[tuple[float, float]]:
+        count = len(rows)
+        if (
+            count > self.capacity
+            or any(
+                len(row) != 5 or any(not math.isfinite(x) for x in row) for row in rows
+            )
+            or not all(math.isfinite(x) for x in (first, second))
+        ):
+            raise ValueError("invalid CUDA synaptic shape/non-finite input")
+        if not count:
+            return []
+        self.host["input"][: 5 * count] = [x for row in rows for x in row]
+        self.driver.copy_host_to_device(
+            self.device["input"], self.host["input"], size_bytes=5 * count * 8
+        )
+        args: list[object] = [
+            ctypes.c_uint32(count),
+            ctypes.c_uint32(bool(stp)),
+            ctypes.c_double(first),
+            ctypes.c_double(second),
+            ctypes.c_uint64(self.device["input"].ptr),
+            ctypes.c_uint64(self.device["output"].ptr),
+        ]
+        self.driver.launch_kernel(
+            kernel, grid=((count + 127) // 128, 1, 1), block=(128, 1, 1), arguments=args
+        )
+        self.driver.synchronize()
+        self.driver.copy_device_to_host(
+            self.host["output"], self.device["output"], size_bytes=2 * count * 8
+        )
+        values = list(self.host["output"][: 2 * count])
+        if any(not math.isfinite(x) for x in values):
+            raise ValueError("non-finite CUDA synaptic output")
+        return [(values[2 * i], values[2 * i + 1]) for i in range(count)]
+
+    def emit(
+        self,
+        rows: list[tuple[float, float, float, float, float]],
+        *,
+        stp: bool,
+        gaba: float,
+        ratio: float,
+    ) -> list[tuple[float, float]]:
+        if (
+            not math.isfinite(gaba)
+            or gaba < 0
+            or not math.isfinite(ratio)
+            or ratio <= 0
+        ):
+            raise ValueError("invalid CUDA inhibitory scaling")
+        for _weight, available, amplitude, draw, inhibitory in rows:
+            if (
+                not 0 <= available <= 1
+                or not 0 <= amplitude <= 1
+                or not 0 <= draw < 1
+                or inhibitory not in (0, 1)
+            ):
+                raise ValueError("invalid CUDA STP/amplitude/RNG descriptor")
+        result = self._execute(
+            rows, stp=stp, first=gaba, second=ratio, kernel=self.emit_kernel
+        )
+        self.emitted_events += len(rows)
+        return result
+
+    def recover(
+        self,
+        weights: list[float],
+        resources: list[float],
+        *,
+        stp: bool,
+        decay: float,
+        maximum: float,
+    ) -> list[tuple[float, float]]:
+        if (
+            len(weights) != len(resources)
+            or not 0 <= decay <= 1
+            or not 0 < maximum <= 100
+            or any(not 0 <= x <= 1 for x in resources)
+        ):
+            raise ValueError("invalid CUDA recovery/decay parameters")
+        result = self._execute(
+            [(w, r, 0.0, 0.0, 0.0) for w, r in zip(weights, resources)],
+            stp=stp,
+            first=decay,
+            second=maximum,
+            kernel=self.recover_kernel,
+        )
+        if result:
+            self.recovery_calls += 1
+        return result
+
+    def reward(
+        self,
+        weights: list[float],
+        eligibility: list[float],
+        ages: list[int],
+        *,
+        scale: float,
+        reward: float,
+        maximum: float,
+        window: int,
+        respect_window: bool,
+    ) -> list[float]:
+        if (
+            len(weights) != len(eligibility)
+            or len(weights) != len(ages)
+            or not 0 < maximum <= 100
+            or type(window) is not int
+            or window < 0
+            or any(type(age) is not int for age in ages)
+        ):
+            raise ValueError("invalid CUDA live reward shape/window")
+        rows = [
+            (w, e, float(age), float(window), maximum)
+            for w, e, age in zip(weights, eligibility, ages)
+        ]
+        values = self._execute(
+            rows,
+            stp=respect_window,
+            first=scale,
+            second=reward,
+            kernel=self.reward_kernel,
+        )
+        if values:
+            self.reward_calls += 1
+        return [w for w, _ in values]
+
+    def plasticity(
+        self,
+        rows: Sequence[tuple[float, ...]],
+        *,
+        pair: bool,
+        triplet: bool,
+        eligibility_active: bool,
+        decay: float,
+        learning: float,
+    ) -> list[tuple[float, float, int]]:
+        count = len(rows)
+        if (
+            count > self.capacity
+            or not math.isfinite(decay)
+            or not 0 <= decay <= 1
+            or not math.isfinite(learning)
+            or learning < 0
+            or any(
+                len(row) != 12 or any(not math.isfinite(x) for x in row) for row in rows
+            )
+        ):
+            raise ValueError("invalid CUDA plasticity input")
+        for row in rows:
+            if (
+                row[7] not in (0, 1)
+                or row[8] not in (0, 1)
+                or row[9] == row[10]
+                or any(x != int(x) for x in (row[2], row[9], row[10], row[11]))
+            ):
+                raise ValueError("invalid CUDA plasticity event/index")
+        if not count:
+            return []
+        self.host["input"][: 12 * count] = [x for row in rows for x in row]
+        self.driver.copy_host_to_device(
+            self.device["input"], self.host["input"], size_bytes=12 * count * 8
+        )
+        flags = int(pair) | int(triplet) * 2 | int(eligibility_active) * 4
+        args: list[object] = [
+            ctypes.c_uint32(count),
+            ctypes.c_uint32(flags),
+            ctypes.c_double(decay),
+            ctypes.c_double(learning),
+            ctypes.c_uint64(self.device["input"].ptr),
+            ctypes.c_uint64(self.device["output"].ptr),
+        ]
+        self.driver.launch_kernel(
+            self.plasticity_kernel,
+            grid=((count + 127) // 128, 1, 1),
+            block=(128, 1, 1),
+            arguments=args,
+        )
+        self.driver.synchronize()
+        self.driver.copy_device_to_host(
+            self.host["output"], self.device["output"], size_bytes=3 * count * 8
+        )
+        values = list(self.host["output"][: 3 * count])
+        if any(not math.isfinite(x) for x in values) or any(
+            x != int(x) for x in values[2::3]
+        ):
+            raise ValueError("invalid CUDA plasticity output")
+        self.plasticity_calls += 1
+        return [
+            (values[3 * i], values[3 * i + 1], int(values[3 * i + 2]))
+            for i in range(count)
+        ]
+
+    def scale_weights(
+        self, weights: list[float], *, factor: float, maximum: float
+    ) -> list[float]:
+        if not math.isfinite(factor) or factor < 0 or not 0 < maximum <= 100:
+            raise ValueError("invalid CUDA weight scaling")
+        rows = [(w, 0.0, 0.0, 0.0, 0.0) for w in weights]
+        return [
+            w
+            for w, _ in self._execute(
+                rows, stp=False, first=factor, second=maximum, kernel=self.scale_kernel
+            )
+        ]

src/acceleration/cuda/plasticity/contracts.py

@@ -0,0 +1,28 @@
+"""Wave-4 plasticity capability markers with Wave-7 draft linkage."""
+
+from __future__ import annotations
+
+from typing import Final
+
+from src.learning.contract import (
+    LEARNING_CONTRACT_ID as LEARNING_DRAFT_CONTRACT_ID,
+)
+from src.learning.contract import (
+    LEARNING_CONTRACT_STATUS as LEARNING_DRAFT_CONTRACT_STATUS,
+)
+
+PLASTICITY_SEMANTICS: Final[str] = "NON_CANONICAL_DRAFT"
+
+# Frozen Wave-4 compatibility boundary. These values are intentionally retained
+# so the extracted CUDA backend does not retroactively change its acceptance
+# contract while Wave 7 is still drafting the common learning semantics.
+LEARNING_CONTRACT_ID: Final[str] = "mhrn-learning-synapse-v1"
+LEARNING_CONTRACT_STATUS: Final[str] = "ALIGNMENT_PENDING"
+
+__all__ = [
+    "LEARNING_CONTRACT_ID",
+    "LEARNING_CONTRACT_STATUS",
+    "LEARNING_DRAFT_CONTRACT_ID",
+    "LEARNING_DRAFT_CONTRACT_STATUS",
+    "PLASTICITY_SEMANTICS",
+]

src/acceleration/cuda/plasticity/kernel.cu

@@ -0,0 +1,62 @@
+// Builder emission algebra; host supplies traversal-ordered random draws.
+extern "C" __global__ void pan_synaptic_emit(unsigned count, unsigned stp,
+    double gaba, double ratio, const double* input, double* output) {
+    unsigned i=blockIdx.x*blockDim.x+threadIdx.x; if(i>=count) return;
+    const double* x=input+5*i;
+    double amplitude=x[0], available=x[1];
+    if(x[4]!=0.0) amplitude=-fabs(amplitude)*gaba/ratio;
+    amplitude*=x[2];
+    if(stp) {
+        amplitude*=x[3]<fmin(0.95,0.25+0.7*available)?1.0:0.0;
+        available=fmax(0.1,available*0.72);
+    }
+    output[2*i]=amplitude; output[2*i+1]=available;
+}
+extern "C" __global__ void pan_synaptic_recover(unsigned count, unsigned stp,
+    double decay, double maximum, const double* input, double* output) {
+    unsigned i=blockIdx.x*blockDim.x+threadIdx.x; if(i>=count) return;
+    double weight=input[5*i], available=input[5*i+1];
+    if(stp) available=fmin(1.0,available+0.025);
+    if(decay!=0.0) weight*=fmax(0.0,1.0-decay);
+    output[2*i]=fmin(maximum,fmax(0.0,weight)); output[2*i+1]=available;
+}
+
+// Live target/posture rewards keep the Builder's eligibility-window contract.
+extern "C" __global__ void pan_synaptic_reward(unsigned count, unsigned filter_age,
+    double scale, double reward, const double* input, double* output) {
+    unsigned i=blockIdx.x*blockDim.x+threadIdx.x; if(i>=count) return;
+    const double* x=input+5*i;
+    double weight=x[0];
+    if(!filter_age || x[2]<=x[3]) weight=fmin(x[4],fmax(0.0,weight+scale*x[1]*reward));
+    output[2*i]=weight; output[2*i+1]=x[1];
+}
+
+// Independent edges reproduce the original ascending-neuron event order.
+extern "C" __global__ void pan_synaptic_plasticity(unsigned count, unsigned flags,
+    double decay, double learning, const double* input, double* output) {
+    unsigned i=blockIdx.x*blockDim.x+threadIdx.x; if(i>=count) return;
+    // weight, eligibility, eligibility time, pre/post deltas, decayed traces,
+    // spike flags, source/target IDs, current tick.
+    const double* x=input+12*i;
+    double weight=x[0], eligibility=x[1]*decay, last=x[2];
+    bool pre=x[7]!=0.0, post=x[8]!=0.0, pre_first=x[9]<x[10];
+    for(unsigned event=0;event<2;++event) {
+        bool source_event=(event==0)==pre_first;
+        if(source_event && pre) {
+            if((flags&1) && x[4]>0.0 && x[4]<=20.0) weight=fmax(0.0,weight-0.08*learning);
+            if(flags&2) weight=fmax(0.0,weight-0.04*(x[6]+((!pre_first && post)?1.0:0.0)));
+            if(flags&4) {eligibility-=0.5;last=x[11];}
+        } else if(!source_event && post) {
+            if((flags&1) && x[3]>0.0 && x[3]<=20.0) weight=fmin(100.0,weight+0.1*learning);
+            if(flags&2) weight=fmin(100.0,fmax(0.0,weight+0.06*(x[5]+((pre_first && pre)?1.0:0.0))+0.025*x[6]));
+            if(flags&4) {eligibility+=1.0;last=x[11];}
+        }
+    }
+    output[3*i]=weight;output[3*i+1]=eligibility;output[3*i+2]=last;
+}
+
+extern "C" __global__ void pan_synaptic_scale(unsigned count, unsigned unused,
+    double factor, double maximum, const double* input, double* output) {
+    unsigned i=blockIdx.x*blockDim.x+threadIdx.x;if(i>=count)return;
+    output[2*i]=fmax(0.0,fmin(maximum,input[5*i]*factor));output[2*i+1]=0.0;
+}

src/acceleration/cuda/plasticity/reference.py

@@ -0,0 +1,161 @@
+"""Ordered scalar synapse oracle for the canonical bounded CUDA reference."""
+
+from __future__ import annotations
+
+import math
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from src.runtime.determinism import (
+    release_uniform as release_uniform,
+)
+from src.runtime.determinism import (
+    ring_slot as ring_slot,
+)
+
+if TYPE_CHECKING:
+    from ..recurrent.backend import RecurrentInputs
+
+
+@dataclass(frozen=True)
+class SynapseConfig:
+    stdp: bool = True
+    stp: bool = True
+    reward_modulated: bool = True
+    seed: int = 12345
+    learning_rate: float = 0.2
+    weight_decay: float = 0.001
+    weight_max: float = 20.0
+    eligibility_tau: float = 100.0
+    credit_window: int = 64
+    td_lambda: float = 0.9
+    gamma: float = 0.99
+
+    def parameters(self) -> list[float]:
+        return [
+            float(self.stdp),
+            float(self.stp),
+            float(self.reward_modulated),
+            float(self.seed),
+            self.learning_rate,
+            self.weight_decay,
+            self.weight_max,
+            self.eligibility_tau,
+            float(self.credit_window),
+            self.td_lambda,
+            self.gamma,
+        ]
+
+    def validate(self) -> None:
+        if any(
+            type(value) is not bool
+            for value in (self.stdp, self.stp, self.reward_modulated)
+        ):
+            raise ValueError("synapse mode flags must be boolean")
+        if type(self.seed) is not int or not 0 <= self.seed <= 0xFFFFFFFF:
+            raise ValueError("synapse seed must be uint32")
+        if type(self.credit_window) is not int or not 0 <= self.credit_window <= 2000:
+            raise ValueError("credit_window must be in [0,2000]")
+        for name, value, low, high in (
+            ("learning_rate", self.learning_rate, 0.0, 1.0),
+            ("weight_decay", self.weight_decay, 0.0, 1.0),
+            ("weight_max", self.weight_max, 0.001, 100.0),
+            ("eligibility_tau", self.eligibility_tau, 0.001, 10000.0),
+            ("td_lambda", self.td_lambda, 0.0, 1.0),
+            ("gamma", self.gamma, 0.0, 1.0),
+        ):
+            if (
+                isinstance(value, bool)
+                or not math.isfinite(value)
+                or not low <= value <= high
+            ):
+                raise ValueError(f"invalid synapse {name}")
+
+
+class SynapseState:
+    def __init__(self, inputs: RecurrentInputs, config: SynapseConfig) -> None:
+        self.inputs = inputs
+        self.config = config
+        self.weights = list(inputs.weights)
+        self.eligibility = [0.0] * len(inputs.sources)
+        self.available = [1.0] * len(inputs.sources)
+        self.last_event = [-10_000_000] * len(inputs.sources)
+        self.last_spike = [-10_000_000] * inputs.n_neurons
+        self.ring_size = max(inputs.delays, default=1) + 1
+        self.emitted = [[0.0] * len(inputs.sources) for _ in range(self.ring_size)]
+
+    def incoming(self, tick: int, neuron: int) -> float:
+        # Kept for external callers; the membrane oracle sums in edge order.
+        return sum(
+            self.edge_current(tick, edge)
+            for edge in range(
+                self.inputs.offsets[neuron], self.inputs.offsets[neuron + 1]
+            )
+        )
+
+    def edge_current(self, tick: int, edge: int) -> float:
+        previous = tick - self.inputs.delays[edge]
+        return (
+            self.emitted[ring_slot(previous, self.ring_size)][edge]
+            if previous >= 0
+            else 0.0
+        )
+
+    def update(self, tick: int, spikes: list[int], reward: float) -> None:
+        c, inputs = self.config, self.inputs
+        for target in range(inputs.n_neurons):
+            for edge in range(inputs.offsets[target], inputs.offsets[target + 1]):
+                source = inputs.sources[edge]
+                pre, post = spikes[source], spikes[target]
+                weight = self.weights[edge]
+                eligibility = self.eligibility[edge] * math.exp(
+                    -inputs.dt_ms / c.eligibility_tau
+                )
+                # Match ascending-neuron pair-rule ordering, including self edges.
+                operations = ("pre", "post") if source <= target else ("post", "pre")
+                for operation in operations:
+                    if operation == "pre" and pre:
+                        if c.stdp and 0 < tick - self.last_spike[target] <= 20:
+                            weight = max(0.0, weight - 0.08)
+                        eligibility -= 0.5
+                    if operation == "post" and post:
+                        if c.stdp and 0 < tick - self.last_spike[source] <= 20:
+                            weight = min(100.0, weight + 0.1)
+                        eligibility += 1.0
+                if pre or post:
+                    self.last_event[edge] = tick
+                if (
+                    c.reward_modulated
+                    and tick - self.last_event[edge] <= c.credit_window
+                ):
+                    weight = min(
+                        100.0,
+                        max(
+                            0.0,
+                            weight
+                            + c.learning_rate
+                            * c.td_lambda
+                            * c.gamma
+                            * eligibility
+                            * reward,
+                        ),
+                    )
+                amplitude = weight if pre else 0.0
+                available = self.available[edge]
+                if c.stp:
+                    if pre:
+                        amplitude *= float(
+                            release_uniform(c.seed, tick, edge)
+                            < min(0.95, 0.25 + 0.7 * available)
+                        )
+                        available = max(0.1, available * 0.72)
+                    available = min(1.0, available + 0.025)
+                self.available[edge] = available
+                self.emitted[ring_slot(tick, self.ring_size)][edge] = amplitude
+                self.weights[edge] = min(
+                    c.weight_max, max(0.0, weight * (1.0 - c.weight_decay))
+                )
+                self.eligibility[edge] = eligibility
+        for neuron, spike in enumerate(spikes):
+            if spike:
+                self.last_spike[neuron] = tick

src/acceleration/cuda/preflight.py

@@ -0,0 +1,78 @@
+"""Backend-neutral CUDA cooperative launch preflight contracts."""
+
+from __future__ import annotations
+
+import math
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True, slots=True)
+class CooperativePreflight:
+    """Host/device limits required for a cooperative persistent launch."""
+
+    cooperative_launch: bool
+    multiprocessor_count: int
+    active_blocks_per_sm: int
+    block_size: int
+    required_blocks: int
+    resident_block_capacity: int
+    launch_fits: bool
+    n_neurons: int
+
+    def to_mapping(self) -> dict[str, object]:
+        return {
+            "cooperative_launch": self.cooperative_launch,
+            "multiprocessor_count": self.multiprocessor_count,
+            "active_blocks_per_sm": self.active_blocks_per_sm,
+            "block_size": self.block_size,
+            "required_blocks": self.required_blocks,
+            "resident_block_capacity": self.resident_block_capacity,
+            "launch_fits": self.launch_fits,
+            "n_neurons": self.n_neurons,
+        }
+
+
+def validate_cuda_block_size(block_size: int) -> int:
+    """Validate a legal one-dimensional CUDA block size."""
+
+    if isinstance(block_size, bool) or not isinstance(block_size, int):
+        raise ValueError("block_size must be an integer")
+    if not 1 <= block_size <= 1024:
+        raise ValueError("block_size must be in [1, 1024]")
+    if block_size % 32 != 0:
+        raise ValueError("block_size must be a multiple of 32")
+    return block_size
+
+
+def cooperative_capacity(
+    *,
+    n_neurons: int,
+    block_size: int,
+    multiprocessor_count: int,
+    active_blocks_per_sm: int,
+    cooperative_launch: bool = True,
+) -> CooperativePreflight:
+    """Pure helper used by CI to verify occupancy-bound grid logic."""
+
+    if (
+        min(
+            n_neurons,
+            block_size,
+            multiprocessor_count,
+            active_blocks_per_sm,
+        )
+        <= 0
+    ):
+        raise ValueError("cooperative capacity inputs must be positive")
+    required = math.ceil(n_neurons / block_size)
+    capacity = multiprocessor_count * active_blocks_per_sm
+    return CooperativePreflight(
+        cooperative_launch=cooperative_launch,
+        multiprocessor_count=multiprocessor_count,
+        active_blocks_per_sm=active_blocks_per_sm,
+        block_size=block_size,
+        required_blocks=required,
+        resident_block_capacity=capacity,
+        launch_fits=cooperative_launch and required <= capacity,
+        n_neurons=n_neurons,
+    )

src/acceleration/cuda/ptxas.py

@@ -0,0 +1,119 @@
+"""Canonical PTX assembly and resource-report helpers."""
+
+from __future__ import annotations
+
+import re
+import shutil
+import subprocess
+import tempfile
+from dataclasses import dataclass
+from pathlib import Path
+
+from .errors import CudaDriverError, CudaRuntimeUnavailable
+
+
+@dataclass(frozen=True, slots=True)
+class PtxasReport:
+    """Measured resource report emitted by ptxas."""
+
+    target_sm: str
+    registers: int | None
+    shared_bytes: int | None
+    constant_bytes: int | None
+    stack_bytes: int | None
+    spill_store_bytes: int | None
+    spill_load_bytes: int | None
+    cubin_path: Path
+    verbose_output: str
+
+    def to_mapping(self) -> dict[str, object]:
+        return {
+            "target_sm": self.target_sm,
+            "registers": self.registers,
+            "shared_bytes": self.shared_bytes,
+            "constant_bytes": self.constant_bytes,
+            "stack_bytes": self.stack_bytes,
+            "spill_store_bytes": self.spill_store_bytes,
+            "spill_load_bytes": self.spill_load_bytes,
+            "cubin_path": str(self.cubin_path),
+            "verbose_output": self.verbose_output,
+        }
+
+
+_REGISTER_RE = re.compile(r"Used\s+(\d+)\s+registers")
+_SMEM_RE = re.compile(r"(\d+)\s+bytes smem")
+_CMEM_RE = re.compile(r"(\d+)\s+bytes cmem\[\d+\]")
+_STACK_RE = re.compile(r"(\d+)\s+bytes stack frame")
+_SPILL_STORE_RE = re.compile(r"(\d+)\s+bytes spill stores")
+_SPILL_LOAD_RE = re.compile(r"(\d+)\s+bytes spill loads")
+
+
+def _first_int(pattern: re.Pattern[str], text: str) -> int | None:
+    match = pattern.search(text)
+    return int(match.group(1)) if match else None
+
+
+def parse_ptxas_verbose(
+    verbose_output: str,
+    *,
+    target_sm: str,
+    cubin_path: Path,
+) -> PtxasReport:
+    """Parse stable resource fields from ptxas verbose diagnostics."""
+
+    constant_values = [int(value) for value in _CMEM_RE.findall(verbose_output)]
+    return PtxasReport(
+        target_sm=target_sm,
+        registers=_first_int(_REGISTER_RE, verbose_output),
+        shared_bytes=_first_int(_SMEM_RE, verbose_output),
+        constant_bytes=sum(constant_values) if constant_values else None,
+        stack_bytes=_first_int(_STACK_RE, verbose_output),
+        spill_store_bytes=_first_int(_SPILL_STORE_RE, verbose_output),
+        spill_load_bytes=_first_int(_SPILL_LOAD_RE, verbose_output),
+        cubin_path=cubin_path,
+        verbose_output=verbose_output,
+    )
+
+
+def assemble_ptx(
+    ptx_source: str,
+    *,
+    target_sm: str = "sm_86",
+    output_dir: Path | None = None,
+    ptxas: str = "ptxas",
+) -> PtxasReport:
+    """Assemble generated PTX and return measured ptxas resources."""
+
+    executable = shutil.which(ptxas)
+    if executable is None:
+        raise CudaRuntimeUnavailable(f"{ptxas} is not available on PATH")
+
+    root = output_dir or Path(tempfile.mkdtemp(prefix="mhrn-ptxas-"))
+    root.mkdir(parents=True, exist_ok=True)
+    ptx_path = root / "pan_gate_kernel.ptx"
+    cubin_path = root / "pan_gate_kernel.cubin"
+    ptx_path.write_text(ptx_source, encoding="utf-8")
+
+    process = subprocess.run(
+        [
+            executable,
+            "--verbose",
+            f"--gpu-name={target_sm}",
+            str(ptx_path),
+            "--output-file",
+            str(cubin_path),
+        ],
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+    verbose = "\n".join(part for part in (process.stdout, process.stderr) if part)
+    if process.returncode != 0:
+        raise CudaDriverError(
+            "ptxas rejected generated PTX " f"(exit={process.returncode}):\n{verbose}"
+        )
+    return parse_ptxas_verbose(
+        verbose,
+        target_sm=target_sm,
+        cubin_path=cubin_path,
+    )

src/acceleration/cuda/recurrent/__init__.py

@@ -0,0 +1,27 @@
+"""Canonical bounded recurrent CUDA package."""
+
+from .backend import (
+    RecurrentInputs,
+    cpu_recurrent_reference,
+    execute_recurrent,
+    recurrent_fixture,
+    recurrent_parity,
+    validate_recurrent_inputs,
+)
+from .config import SUPPORTED_MODELS, CudaReferenceModelProfile
+from .reference import CPUReferenceBackend
+from .state import recurrent_inputs_from_mapping, recurrent_inputs_to_mapping
+
+__all__ = [
+    "CPUReferenceBackend",
+    "CudaReferenceModelProfile",
+    "RecurrentInputs",
+    "SUPPORTED_MODELS",
+    "cpu_recurrent_reference",
+    "execute_recurrent",
+    "recurrent_fixture",
+    "recurrent_inputs_from_mapping",
+    "recurrent_inputs_to_mapping",
+    "recurrent_parity",
+    "validate_recurrent_inputs",
+]

src/acceleration/cuda/recurrent/backend.py

@@ -0,0 +1,375 @@
+"""Canonical bounded CUDA recurrent reference with explicit FP64 state.
+
+The CUDA kernel is byte-identical to the previously hardware-verified
+Playground kernel. This module changes ownership and interfaces, not kernel
+semantics. PAN hyperstate, structural plasticity and live environment state are
+outside this Wave-4 backend.
+"""
+
+from __future__ import annotations
+
+import ctypes
+import math
+import tempfile
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from src.verification.parity import max_abs_error
+
+from ..driver import CudaDriver
+from ..errors import CudaDriverError
+from ..memory import DeviceAllocation
+from ..nvrtc import compile_cuda_source
+from ..plasticity.reference import SynapseConfig, SynapseState
+from ..preflight import validate_cuda_block_size
+from .config import SUPPORTED_MODELS, cuda_reference_model_profile, step_reference
+
+PARAMETER_NAMES = (
+    "v_rest",
+    "v_t",
+    "delta_t",
+    "tau_m_ms",
+    "tau_w_ms",
+    "a",
+    "b",
+    "threshold",
+    "reset",
+    "resistance",
+)
+
+
+@dataclass(frozen=True)
+class RecurrentInputs:
+    n_neurons: int
+    ticks: int
+    offsets: tuple[int, ...]
+    sources: tuple[int, ...]
+    delays: tuple[int, ...]
+    weights: tuple[float, ...]
+    external: tuple[float, ...]
+    voltage: tuple[float, ...]
+    adaptation: tuple[float, ...]
+    model: str = "lif"
+    dt_ms: float = 1.0
+    synapses: SynapseConfig | None = None
+    rewards: tuple[float, ...] = ()
+
+
+def _bounded_integer(value: object, lower: int, upper: int) -> bool:
+    return (
+        not isinstance(value, bool)
+        and isinstance(value, int)
+        and lower <= value <= upper
+    )
+
+
+def _bounded_number(value: object) -> bool:
+    return (
+        not isinstance(value, bool)
+        and isinstance(value, (int, float))
+        and math.isfinite(value)
+        and abs(value) <= 1e6
+    )
+
+
+def validate_recurrent_inputs(inputs: RecurrentInputs) -> None:
+    for name, value, upper in (
+        ("n_neurons", inputs.n_neurons, 4096),
+        ("ticks", inputs.ticks, 2000),
+    ):
+        if not _bounded_integer(value, 1, upper):
+            raise ValueError(f"{name} must be an integer in [1,{upper}]")
+    n, ticks = inputs.n_neurons, inputs.ticks
+    if inputs.synapses is not None:
+        inputs.synapses.validate()
+        if len(inputs.rewards) != ticks or any(
+            not _bounded_number(x) for x in inputs.rewards
+        ):
+            raise ValueError("plastic execution requires finite reward per tick")
+        if not inputs.sources:
+            raise ValueError("plastic execution requires at least one synapse")
+        if any(weight < 0 for weight in inputs.weights):
+            raise ValueError("plastic weights must be nonnegative")
+    if n * ticks > 4_000_000:
+        raise ValueError("state history exceeds bounded reference capacity")
+    if inputs.model not in SUPPORTED_MODELS:
+        raise ValueError("unsupported recurrent membrane model")
+    if (
+        isinstance(inputs.dt_ms, bool)
+        or not math.isfinite(inputs.dt_ms)
+        or not 0 < inputs.dt_ms <= 1
+    ):
+        raise ValueError("dt_ms must be finite in (0,1]")
+    edges = len(inputs.sources)
+    if edges > 65536 or len(inputs.offsets) != n + 1:
+        raise ValueError("invalid incoming CSR shape")
+    for values, upper in (
+        (inputs.offsets, edges),
+        (inputs.sources, n - 1),
+        (inputs.delays, 64),
+    ):
+        if any(not _bounded_integer(x, 0, upper) for x in values):
+            raise ValueError("invalid CSR integer/index/delay")
+    if (
+        inputs.offsets[0] != 0
+        or inputs.offsets[-1] != edges
+        or any(a > b for a, b in zip(inputs.offsets, inputs.offsets[1:]))
+    ):
+        raise ValueError("incoming CSR offsets must be monotone and span all edges")
+    if len(inputs.delays) != edges or any(x < 1 for x in inputs.delays):
+        raise ValueError("each edge requires a delay in [1,64]")
+    for name, numbers, length in (
+        ("weights", inputs.weights, edges),
+        ("external", inputs.external, n * ticks),
+        ("voltage", inputs.voltage, n),
+        ("adaptation", inputs.adaptation, n),
+    ):
+        if len(numbers) != length or any(not _bounded_number(x) for x in numbers):
+            raise ValueError(
+                f"{name} has an invalid shape or non-finite/out-of-range values"
+            )
+
+
+def cpu_recurrent_reference(inputs: RecurrentInputs) -> dict[str, object]:
+    """Use the existing Python neuron model as an independent scalar oracle."""
+    validate_recurrent_inputs(inputs)
+    profile = cuda_reference_model_profile(inputs.model)
+    states = [{"v": v, "w": w} for v, w in zip(inputs.voltage, inputs.adaptation)]
+    n = inputs.n_neurons
+    spikes: list[int] = []
+    voltage: list[float] = []
+    adaptation: list[float] = []
+    synapses = (
+        SynapseState(inputs, inputs.synapses) if inputs.synapses is not None else None
+    )
+    for tick in range(inputs.ticks):
+        for neuron in range(n):
+            current = inputs.external[tick * n + neuron]
+            for edge in range(inputs.offsets[neuron], inputs.offsets[neuron + 1]):
+                previous = tick - inputs.delays[edge]
+                if synapses is not None:
+                    current += synapses.edge_current(tick, edge)
+                elif previous >= 0:
+                    current += (
+                        inputs.weights[edge]
+                        * spikes[previous * n + inputs.sources[edge]]
+                    )
+            spike = step_reference(profile, states[neuron], current, inputs.dt_ms)
+            spikes.append(int(spike))
+            voltage.append(float(states[neuron]["v"]))
+            adaptation.append(float(states[neuron]["w"]))
+        if synapses is not None:
+            synapses.update(
+                tick, spikes[tick * n : (tick + 1) * n], inputs.rewards[tick]
+            )
+    result: dict[str, object] = {
+        "voltage": voltage,
+        "adaptation": adaptation,
+        "spikes": spikes,
+    }
+    if synapses is not None:
+        result.update(
+            weights=synapses.weights,
+            eligibility=synapses.eligibility,
+            available=synapses.available,
+        )
+    return result
+
+
+def execute_recurrent(
+    inputs: RecurrentInputs,
+    *,
+    block_size: int = 64,
+    target_sm: str = "sm_86",
+    output_dir: Path | None = None,
+) -> dict[str, object]:
+    validate_recurrent_inputs(inputs)
+    validate_cuda_block_size(block_size)
+    if output_dir is None:
+        with tempfile.TemporaryDirectory(prefix="mhrn-recurrent-") as directory:
+            return execute_recurrent(
+                inputs,
+                block_size=block_size,
+                target_sm=target_sm,
+                output_dir=Path(directory),
+            )
+    output_dir.mkdir(parents=True, exist_ok=True)
+    source = Path(__file__).with_name("kernel.cu").read_text()
+    if inputs.synapses is not None:
+        source = "#define PAN_PLASTIC\n" + source
+    ptx = compile_cuda_source(source, target_sm=target_sm)
+    artifact = output_dir / "recurrent.ptx"
+    artifact.write_text(ptx, encoding="utf-8")
+    driver = CudaDriver()
+    loaded = driver.load_cubin(artifact, kernel_name="pan_recurrent_kernel")
+    allocations: list[DeviceAllocation] = []
+    try:
+        n, count = inputs.n_neurons, inputs.n_neurons * inputs.ticks
+        ring_size = max(inputs.delays, default=1) + 1
+        params = cuda_reference_model_profile(inputs.model).parameters
+        parameter_row = [
+            params.get(
+                name, 1.0 if name in {"resistance", "tau_w_ms", "delta_t"} else 0.0
+            )
+            for name in PARAMETER_NAMES
+        ]
+        uint, double = ctypes.c_uint32, ctypes.c_double
+        host: dict[str, Any] = {}
+        for name, kind, values in (
+            ("offsets", uint, inputs.offsets),
+            ("sources", uint, inputs.sources),
+            ("delays", uint, inputs.delays),
+            ("weights", double, inputs.weights),
+            ("external", double, inputs.external),
+            ("parameters", double, parameter_row * n),
+            ("voltage", double, inputs.voltage),
+            ("adaptation", double, inputs.adaptation),
+            ("ring", uint, [0] * (ring_size * n)),
+            ("voltage_history", double, [0.0] * count),
+            ("adaptation_history", double, [0.0] * count),
+            ("spikes", uint, [0] * count),
+        ):
+            # CUDA does not accept a zero-byte allocation for an empty graph.
+            array_type: Any = kind * max(1, len(values))
+            host[name] = array_type(*values)
+        if inputs.synapses is not None:
+            edges = len(inputs.sources)
+            host.update(
+                synapse_config=(double * 11)(*inputs.synapses.parameters()),
+                rewards=(double * inputs.ticks)(*inputs.rewards),
+                eligibility=(double * edges)(),
+                available=(double * edges)(*([1.0] * edges)),
+                last_event=(ctypes.c_int32 * edges)(*([-10_000_000] * edges)),
+                last_spike=(ctypes.c_int32 * n)(*([-10_000_000] * n)),
+                emitted=(double * (ring_size * edges))(),
+            )
+        device: dict[str, DeviceAllocation] = {}
+        for name, buffer in host.items():
+            allocation = driver.alloc_device(ctypes.sizeof(buffer))
+            allocations.append(allocation)
+            device[name] = allocation
+            driver.copy_host_to_device(allocation, buffer)
+        arguments: list[object] = [
+            uint(n),
+            uint(inputs.ticks),
+            uint(ring_size),
+            uint(inputs.model != "lif"),
+            double(inputs.dt_ms),
+        ]
+        arguments.extend(ctypes.c_uint64(device[name].ptr) for name in host)
+        preflight = driver.launch_cooperative(
+            loaded, n_neurons=n, block_size=block_size, arguments=arguments
+        )
+        driver.synchronize()
+        outputs: dict[str, object] = {}
+        for name, key in (
+            ("voltage_history", "voltage"),
+            ("adaptation_history", "adaptation"),
+            ("spikes", "spikes"),
+        ):
+            driver.copy_device_to_host(host[name], device[name])
+            outputs[key] = list(host[name])
+        if inputs.synapses is not None:
+            for name in ("weights", "eligibility", "available"):
+                driver.copy_device_to_host(host[name], device[name])
+                outputs[name] = list(host[name])
+        return {
+            "classification": (
+                "MHRN_CUDA15_PLASTIC_REFERENCE"
+                if inputs.synapses
+                else "MHRN_CUDA14_RECURRENT_REFERENCE"
+            ),
+            "scientific_evidence": False,
+            "execution_status": "GPU_KERNEL_EXECUTED",
+            "state_dtype": "float64",
+            "comparison_scope": (
+                "MEMBRANE_AND_FROZEN_REWARD_PLASTICITY"
+                if inputs.synapses
+                else "STATIC_SYNAPSES_AND_MEMBRANE_ONLY"
+            ),
+            "full_pan_backend": False,
+            "preflight": preflight.to_mapping(),
+            "ticks": inputs.ticks,
+            "outputs": outputs,
+        }
+    finally:
+        try:
+            for allocation in reversed(allocations):
+                try:
+                    driver.free_device(allocation)
+                except CudaDriverError:
+                    pass
+        finally:
+            driver.unload(loaded)
+
+
+def recurrent_parity(
+    reference: dict[str, Any], candidate: dict[str, Any], *, tolerance: float = 1e-4
+) -> dict[str, object]:
+    if isinstance(tolerance, bool) or not math.isfinite(tolerance) or tolerance < 0:
+        raise ValueError("tolerance must be finite and non-negative")
+    try:
+        names = ["voltage", "adaptation"]
+        if any(
+            name in reference or name in candidate
+            for name in ("weights", "eligibility", "available")
+        ):
+            names.extend(("weights", "eligibility", "available"))
+        errors = {
+            name: max_abs_error(reference.get(name, []), candidate.get(name, []))
+            for name in names
+        }
+    except (ValueError, TypeError, OverflowError) as exc:
+        return {
+            "passed": False,
+            "failure_reason": str(exc),
+            "scientific_evidence": False,
+        }
+    spikes = reference.get("spikes", [])
+    other = candidate.get("spikes", [])
+    exact = (
+        bool(spikes)
+        and len(spikes)
+        == len(other)
+        == len(reference["voltage"])
+        == len(reference["adaptation"])
+        and all(a in (0, 1) and b in (0, 1) and a == b for a, b in zip(spikes, other))
+    )
+    return {
+        "passed": exact
+        and all(math.isfinite(x) and x <= tolerance for x in errors.values()),
+        "D1_spikes_exact": exact,
+        "D2_max_abs_error": errors,
+        "scientific_evidence": False,
+        "scope": (
+            "MEMBRANE_AND_FROZEN_REWARD_PLASTICITY"
+            if "weights" in names
+            else "MEMBRANE_AND_STATIC_SYNAPSES"
+        ),
+    }
+
+
+def recurrent_fixture(
+    *, n_neurons: int = 129, ticks: int = 100, model: str = "pan_adex_5d"
+) -> RecurrentInputs:
+    """Nontrivial cross-block ring graph used by CLI, HTTP and hardware checks."""
+    if not _bounded_integer(n_neurons, 1, 4096):
+        raise ValueError("n_neurons must be in [1,4096]")
+    if not _bounded_integer(ticks, 1, 2000) or n_neurons * ticks > 4_000_000:
+        raise ValueError("ticks or history exceeds diagnostic capacity")
+    n = n_neurons
+    inputs = RecurrentInputs(
+        n,
+        ticks,
+        tuple(range(n + 1)),
+        tuple((i - 65) % n for i in range(n)),
+        tuple(1 + i % 7 for i in range(n)),
+        (2.0,) * n,
+        tuple(40.0 + (i % 5) * 2 for _ in range(ticks) for i in range(n)),
+        (-65.0,) * n,
+        (0.0,) * n,
+        model=model,
+    )
+    validate_recurrent_inputs(inputs)
+    return inputs

src/acceleration/cuda/recurrent/config.py

@@ -0,0 +1,116 @@
+"""Frozen model profiles for the bounded CUDA recurrent reference.
+
+These profiles preserve the hardware-tested CUDA-1.4/1.5 membrane semantics
+without importing the exploratory Playground registry. They are engineering
+compatibility profiles, not a new scientific neuron-model registry.
+"""
+
+from __future__ import annotations
+
+import math
+from collections.abc import Mapping
+from dataclasses import dataclass
+from types import MappingProxyType
+from typing import Any, Final
+
+
+@dataclass(frozen=True, slots=True)
+class CudaReferenceModelProfile:
+    name: str
+    parameters: Mapping[str, float]
+    family: str
+
+
+_PROFILES: Final[dict[str, CudaReferenceModelProfile]] = {
+    "lif": CudaReferenceModelProfile(
+        "lif",
+        MappingProxyType(
+            {
+                "v_rest": -65.0,
+                "threshold": -50.0,
+                "reset": -65.0,
+                "tau_m_ms": 20.0,
+                "resistance": 1.0,
+            }
+        ),
+        "bounded-lif-reference",
+    ),
+    "adex": CudaReferenceModelProfile(
+        "adex",
+        MappingProxyType(
+            {
+                "v_rest": -65.0,
+                "v_t": -50.0,
+                "delta_t": 2.0,
+                "tau_m_ms": 20.0,
+                "tau_w_ms": 120.0,
+                "a": 0.02,
+                "b": 0.5,
+                "threshold": 20.0,
+                "reset": -58.0,
+            }
+        ),
+        "bounded-adex-reference",
+    ),
+    "pan_adex_5d": CudaReferenceModelProfile(
+        "pan_adex_5d",
+        MappingProxyType(
+            {
+                "v_rest": -65.0,
+                "v_t": -55.0,
+                "delta_t": 2.0,
+                "tau_m_ms": 20.0,
+                "tau_w_ms": 120.0,
+                "a": 0.02,
+                "b": 0.5,
+                "threshold": -20.0,
+                "reset": -60.0,
+            }
+        ),
+        "bounded-pan-adex-membrane-reference",
+    ),
+}
+
+SUPPORTED_MODELS: Final[frozenset[str]] = frozenset(_PROFILES)
+
+
+def cuda_reference_model_profile(name: str) -> CudaReferenceModelProfile:
+    try:
+        return _PROFILES[name]
+    except KeyError as exc:
+        raise ValueError(f"unsupported recurrent membrane model: {name}") from exc
+
+
+def step_reference(
+    profile: CudaReferenceModelProfile,
+    state: dict[str, Any],
+    current: float,
+    dt_ms: float,
+) -> bool:
+    params = profile.parameters
+    v = float(state["v"])
+    if profile.name == "lif":
+        tau = max(params["tau_m_ms"], 1e-6)
+        v += dt_ms * (
+            (params["v_rest"] - v + params.get("resistance", 1.0) * current) / tau
+        )
+        spiked = v >= params["threshold"]
+        state["v"] = params["reset"] if spiked else v
+        state["w"] = float(state.get("w", 0.0))
+        return spiked
+
+    w = float(state.get("w", 0.0))
+    exponent = min(20.0, (v - params["v_t"]) / params["delta_t"])
+    dv = (
+        -(v - params["v_rest"]) + params["delta_t"] * math.exp(exponent) - w + current
+    ) / params["tau_m_ms"]
+    dw = (params["a"] * (v - params["v_rest"]) - w) / params["tau_w_ms"]
+    v += dt_ms * dv
+    w += dt_ms * dw
+    spiked = v >= params["threshold"]
+    if spiked:
+        v = params["reset"]
+        w += params["b"]
+    state["v"] = v
+    state["w"] = w
+    return spiked

src/acceleration/cuda/recurrent/kernel.cu

@@ -0,0 +1,113 @@
+#include <cooperative_groups.h>
+
+#ifdef PAN_PLASTIC
+__device__ double release_uniform(unsigned seed, unsigned tick, unsigned edge) {
+    unsigned bits = seed ^ (tick * 0x9E3779B9u) ^ (edge * 0x85EBCA6Bu);
+    bits ^= bits >> 16; bits *= 0x7FEB352Du;
+    bits ^= bits >> 15; bits *= 0x846CA68Bu; bits ^= bits >> 16;
+    return (bits >> 8) / 16777216.0;
+}
+#endif
+
+// Deterministic incoming-edge gather: no floating point atomic accumulation.
+// All blocks participate in the barrier, including partial-block inactive lanes.
+extern "C" __global__ void pan_recurrent_kernel(
+    const unsigned n, const unsigned ticks, const unsigned ring_size,
+    const unsigned model, const double dt,
+    const unsigned* offsets, const unsigned* sources,
+    const unsigned* delays, double* weights,
+    const double* external, const double* parameters,
+    double* voltage, double* adaptation, unsigned* ring,
+    double* voltage_history, double* adaptation_history, unsigned* spikes
+#ifdef PAN_PLASTIC
+    , const double* config, const double* rewards, double* eligibility,
+    double* available, int* last_event, int* last_spike, double* emitted
+#endif
+    ) {
+    auto grid = cooperative_groups::this_grid();
+    const unsigned neuron = blockIdx.x * blockDim.x + threadIdx.x;
+    for (unsigned tick = 0; tick < ticks; ++tick) {
+        if (neuron < n) {
+            double current = external[tick * n + neuron];
+            for (unsigned edge = offsets[neuron]; edge < offsets[neuron + 1]; ++edge) {
+                if (tick >= delays[edge]) {
+                    const unsigned slot = (tick - delays[edge]) % ring_size;
+#ifdef PAN_PLASTIC
+                    current += emitted[slot * offsets[n] + edge];
+#else
+                    current += weights[edge] * ring[slot * n + sources[edge]];
+#endif
+                }
+            }
+            const double* p = parameters + neuron * 10;
+            double v = voltage[neuron];
+            double w = adaptation[neuron];
+            if (model == 0) {
+                v += dt * ((p[0] - v + p[9] * current) / p[3]);
+            } else {
+                const double exponent = fmin(20.0, (v - p[1]) / p[2]);
+                const double dv = (-(v - p[0]) + p[2] * exp(exponent) - w + current) / p[3];
+                const double dw = (p[5] * (v - p[0]) - w) / p[4];
+                v += dt * dv;
+                w += dt * dw;
+            }
+            const unsigned spike = v >= p[7];
+            if (spike) {
+                v = p[8];
+                if (model != 0) w += p[6];
+            }
+            voltage[neuron] = v;
+            adaptation[neuron] = w;
+            voltage_history[tick * n + neuron] = v;
+            adaptation_history[tick * n + neuron] = w;
+            spikes[tick * n + neuron] = spike;
+            ring[(tick % ring_size) * n + neuron] = spike;
+        }
+        grid.sync();
+#ifdef PAN_PLASTIC
+        if (neuron < n) {
+            const unsigned post = spikes[tick * n + neuron];
+            for (unsigned edge = offsets[neuron]; edge < offsets[neuron + 1]; ++edge) {
+                const unsigned source = sources[edge];
+                const unsigned pre = spikes[tick * n + source];
+                double weight = weights[edge];
+                double trace = eligibility[edge] * exp(-dt / config[7]);
+                const int since_pre = (int)tick - last_spike[source];
+                const int since_post = (int)tick - last_spike[neuron];
+                for (unsigned phase = 0; phase < 2; ++phase) {
+                    const bool pre_phase = source <= neuron ? phase == 0 : phase == 1;
+                    if (pre_phase && pre) {
+                        if (config[0] && since_post > 0 && since_post <= 20)
+                            weight = fmax(0.0, weight - 0.08);
+                        trace -= 0.5;
+                    }
+                    if (!pre_phase && post) {
+                        if (config[0] && since_pre > 0 && since_pre <= 20)
+                            weight = fmin(100.0, weight + 0.1);
+                        trace += 1.0;
+                    }
+                }
+                if (pre || post) last_event[edge] = tick;
+                if (config[2] && (int)tick - last_event[edge] <= config[8])
+                    weight = fmin(100.0, fmax(0.0, weight + config[4] * config[9] * config[10] * trace * rewards[tick]));
+                double amplitude = pre ? weight : 0.0;
+                double resource = available[edge];
+                if (config[1]) {
+                    if (pre) {
+                        amplitude *= release_uniform((unsigned)config[3], tick, edge) < fmin(0.95, 0.25 + 0.7 * resource);
+                        resource = fmax(0.1, resource * 0.72);
+                    }
+                    resource = fmin(1.0, resource + 0.025);
+                }
+                available[edge] = resource;
+                emitted[(tick % ring_size) * offsets[n] + edge] = amplitude;
+                weights[edge] = fmin(config[6], fmax(0.0, weight * (1.0 - config[5])));
+                eligibility[edge] = trace;
+            }
+        }
+        grid.sync();
+        if (neuron < n && spikes[tick * n + neuron]) last_spike[neuron] = tick;
+        grid.sync();
+#endif
+    }
+}

src/acceleration/cuda/recurrent/reference.py

@@ -0,0 +1,153 @@
+"""CPU scalar reference backend for canonical Wave-4 parity."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping, Sequence
+from typing import Any
+
+from src.runtime.backend import BackendCapabilities, BackendState, RunResult, StepResult
+from src.verification.parity import config_fingerprint, execution_fingerprint
+
+from .backend import cpu_recurrent_reference
+from .state import (
+    canonical_int,
+    prefix_inputs,
+    recurrent_inputs_from_mapping,
+    recurrent_inputs_to_mapping,
+    set_external_tick_config,
+    stable_digest,
+    step_payload,
+)
+
+
+class CPUReferenceBackend:
+    backend_name = "cpu-reference"
+    backend_version = "wave4-scalar-reference-v1"
+
+    def __init__(self) -> None:
+        self._config: dict[str, object] | None = None
+        self._seed = 0
+        self._tick = 0
+
+    def initialize(self, config: Mapping[str, object], seed: int) -> None:
+        inputs = recurrent_inputs_from_mapping(config, seed=seed)
+        self._config = recurrent_inputs_to_mapping(inputs)
+        self._seed = seed
+        self._tick = 0
+
+    def _require_config(self) -> dict[str, object]:
+        if self._config is None:
+            raise RuntimeError("backend is not initialized")
+        return self._config
+
+    def _execute_prefix(self, total_ticks: int) -> Mapping[str, object]:
+        inputs = recurrent_inputs_from_mapping(self._require_config(), seed=self._seed)
+        return cpu_recurrent_reference(prefix_inputs(inputs, total_ticks))
+
+    def _step_from_outputs(
+        self, outputs: Mapping[str, object], tick: int
+    ) -> StepResult:
+        config = self._require_config()
+        payload = step_payload(
+            outputs,
+            tick=tick,
+            n_neurons=canonical_int(config["n_neurons"], field="n_neurons"),
+        )
+        spikes_raw = payload["spikes"]
+        if not isinstance(spikes_raw, list):
+            raise ValueError("spike payload must be a list")
+        spikes = tuple(
+            index for index, value in enumerate(spikes_raw) if int(value) == 1
+        )
+        return StepResult(
+            tick=tick + 1,
+            spikes=spikes,
+            state_digest=stable_digest(payload),
+            metrics={
+                "voltage": payload["voltage"],
+                "adaptation": payload["adaptation"],
+                "spike_count": len(spikes),
+            },
+        )
+
+    def set_external_tick(self, tick: int, currents: Sequence[float]) -> None:
+        if tick != self._tick:
+            raise ValueError("live external input tick must equal continuation cursor")
+        set_external_tick_config(self._require_config(), tick=tick, currents=currents)
+
+    def step(self, tick: int) -> StepResult:
+        if tick != self._tick:
+            raise ValueError("tick must equal the backend continuation cursor")
+        config = self._require_config()
+        if tick >= canonical_int(config["ticks"], field="ticks"):
+            raise ValueError("configured tick limit reached")
+        outputs = self._execute_prefix(tick + 1)
+        self._tick = tick + 1
+        return self._step_from_outputs(outputs, tick)
+
+    def run(self, ticks: int) -> RunResult:
+        if type(ticks) is not int or ticks < 1:
+            raise ValueError("ticks must be a positive int")
+        config = self._require_config()
+        total = self._tick + ticks
+        if total > canonical_int(config["ticks"], field="ticks"):
+            raise ValueError("requested run exceeds configured tick limit")
+        start = self._tick
+        outputs = self._execute_prefix(total)
+        steps = tuple(
+            self._step_from_outputs(outputs, tick) for tick in range(start, total)
+        )
+        self._tick = total
+        return RunResult(
+            ticks_requested=ticks,
+            steps=steps,
+            final_state=self.snapshot(),
+            execution_fingerprint=execution_fingerprint(
+                seed=self._seed,
+                config_hash=config_fingerprint(config),
+                backend_name=self.backend_name,
+                backend_version=self.backend_version,
+                ticks=total,
+            ),
+        )
+
+    def snapshot(self) -> BackendState:
+        config = self._require_config()
+        payload: dict[str, Any] = {
+            "backend": self.backend_version,
+            "seed": self._seed,
+            "tick": self._tick,
+            "config": config,
+            "replay_required": True,
+        }
+        return BackendState(
+            tick=self._tick,
+            payload=payload,
+            state_digest=stable_digest(payload),
+        )
+
+    def restore(self, state: BackendState) -> None:
+        payload = dict(state.payload)
+        if payload.get("backend") != self.backend_version:
+            raise ValueError("checkpoint backend version mismatch")
+        raw_config = payload.get("config")
+        raw_seed = payload.get("seed")
+        if not isinstance(raw_config, Mapping) or type(raw_seed) is not int:
+            raise ValueError("checkpoint is missing canonical config/seed")
+        self.initialize(raw_config, raw_seed)
+        self._tick = state.tick
+
+    def capabilities(self) -> BackendCapabilities:
+        return BackendCapabilities(
+            supports_recurrent=True,
+            supports_plasticity=True,
+            supports_pan_hyperstate=False,
+            supports_structural_plasticity=False,
+            max_neurons=4096,
+            max_ticks=2000,
+            max_edges=65536,
+            deterministic=True,
+            plasticity_semantics="REFERENCE_MATCH_TARGET_DRAFT",
+            execution_mode="BOUNDED_REPLAY_REFERENCE",
+            supports_live_external_input=True,
+        )

src/acceleration/cuda/recurrent/state.py

@@ -0,0 +1,223 @@
+"""Serialization helpers for the bounded recurrent backend."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from collections.abc import Mapping, Sequence
+from dataclasses import asdict, replace
+
+from ..plasticity.reference import SynapseConfig
+from .backend import RecurrentInputs, validate_recurrent_inputs
+
+
+def stable_digest(value: object) -> str:
+    encoded = json.dumps(
+        value,
+        sort_keys=True,
+        separators=(",", ":"),
+        ensure_ascii=False,
+        allow_nan=False,
+    ).encode("utf-8")
+    return hashlib.sha256(encoded).hexdigest()
+
+
+def canonical_int(value: object, *, field: str) -> int:
+    if isinstance(value, bool) or not isinstance(value, int):
+        raise ValueError(f"{field} must be an integer")
+    return value
+
+
+def canonical_float(value: object, *, field: str) -> float:
+    if isinstance(value, bool) or not isinstance(value, (int, float)):
+        raise ValueError(f"{field} must be numeric")
+    return float(value)
+
+
+def recurrent_inputs_to_mapping(inputs: RecurrentInputs) -> dict[str, object]:
+    result: dict[str, object] = {
+        "n_neurons": inputs.n_neurons,
+        "ticks": inputs.ticks,
+        "offsets": list(inputs.offsets),
+        "sources": list(inputs.sources),
+        "delays": list(inputs.delays),
+        "weights": list(inputs.weights),
+        "external": list(inputs.external),
+        "voltage": list(inputs.voltage),
+        "adaptation": list(inputs.adaptation),
+        "model": inputs.model,
+        "dt_ms": inputs.dt_ms,
+        "rewards": list(inputs.rewards),
+    }
+    result["synapses"] = (
+        asdict(inputs.synapses) if inputs.synapses is not None else None
+    )
+    return result
+
+
+def _tuple_int(values: object, *, field: str) -> tuple[int, ...]:
+    if not isinstance(values, (list, tuple)):
+        raise ValueError(f"{field} must be a list/tuple")
+    return tuple(
+        canonical_int(value, field=f"{field}[{index}]")
+        for index, value in enumerate(values)
+    )
+
+
+def _tuple_float(values: object, *, field: str) -> tuple[float, ...]:
+    if not isinstance(values, (list, tuple)):
+        raise ValueError(f"{field} must be a list/tuple")
+    return tuple(
+        canonical_float(value, field=f"{field}[{index}]")
+        for index, value in enumerate(values)
+    )
+
+
+def recurrent_inputs_from_mapping(
+    config: Mapping[str, object],
+    *,
+    seed: int,
+) -> RecurrentInputs:
+    if type(seed) is not int or not 0 <= seed <= 0xFFFFFFFF:
+        raise ValueError("seed must be uint32")
+    raw_synapses = config.get("synapses")
+    synapses: SynapseConfig | None = None
+    if raw_synapses is not None:
+        if not isinstance(raw_synapses, Mapping):
+            raise ValueError("synapses must be a mapping or null")
+        supplied_seed = canonical_int(
+            raw_synapses.get("seed", seed), field="synapses.seed"
+        )
+        if supplied_seed != seed:
+            raise ValueError("backend seed must match synapse seed")
+        synapses = SynapseConfig(
+            stdp=bool(raw_synapses.get("stdp", True)),
+            stp=bool(raw_synapses.get("stp", True)),
+            reward_modulated=bool(raw_synapses.get("reward_modulated", True)),
+            seed=seed,
+            learning_rate=canonical_float(
+                raw_synapses.get("learning_rate", 0.2),
+                field="synapses.learning_rate",
+            ),
+            weight_decay=canonical_float(
+                raw_synapses.get("weight_decay", 0.001),
+                field="synapses.weight_decay",
+            ),
+            weight_max=canonical_float(
+                raw_synapses.get("weight_max", 20.0),
+                field="synapses.weight_max",
+            ),
+            eligibility_tau=canonical_float(
+                raw_synapses.get("eligibility_tau", 100.0),
+                field="synapses.eligibility_tau",
+            ),
+            credit_window=canonical_int(
+                raw_synapses.get("credit_window", 64),
+                field="synapses.credit_window",
+            ),
+            td_lambda=canonical_float(
+                raw_synapses.get("td_lambda", 0.9),
+                field="synapses.td_lambda",
+            ),
+            gamma=canonical_float(
+                raw_synapses.get("gamma", 0.99),
+                field="synapses.gamma",
+            ),
+        )
+    try:
+        inputs = RecurrentInputs(
+            n_neurons=canonical_int(config["n_neurons"], field="n_neurons"),
+            ticks=canonical_int(config["ticks"], field="ticks"),
+            offsets=_tuple_int(config["offsets"], field="offsets"),
+            sources=_tuple_int(config["sources"], field="sources"),
+            delays=_tuple_int(config["delays"], field="delays"),
+            weights=_tuple_float(config["weights"], field="weights"),
+            external=_tuple_float(config["external"], field="external"),
+            voltage=_tuple_float(config["voltage"], field="voltage"),
+            adaptation=_tuple_float(config["adaptation"], field="adaptation"),
+            model=str(config.get("model", "lif")),
+            dt_ms=canonical_float(config.get("dt_ms", 1.0), field="dt_ms"),
+            synapses=synapses,
+            rewards=_tuple_float(config.get("rewards", ()), field="rewards"),
+        )
+    except KeyError as exc:
+        raise ValueError(f"missing recurrent config field: {exc.args[0]}") from exc
+    validate_recurrent_inputs(inputs)
+    return inputs
+
+
+def set_external_tick_config(
+    config: dict[str, object],
+    *,
+    tick: int,
+    currents: Sequence[float],
+) -> None:
+    """Replace exactly one external-current row in a canonical replay config."""
+
+    n = canonical_int(config.get("n_neurons"), field="n_neurons")
+    ticks = canonical_int(config.get("ticks"), field="ticks")
+    if type(tick) is not int or not 0 <= tick < ticks:
+        raise ValueError("tick is outside configured replay range")
+    if len(currents) != n:
+        raise ValueError("external-current row must match n_neurons")
+    raw_external = config.get("external")
+    if not isinstance(raw_external, (list, tuple)):
+        raise ValueError("external must be a list/tuple")
+    if len(raw_external) != n * ticks:
+        raise ValueError("external has invalid configured shape")
+    external = [
+        canonical_float(value, field=f"external[{index}]")
+        for index, value in enumerate(raw_external)
+    ]
+    row = [
+        canonical_float(value, field=f"currents[{index}]")
+        for index, value in enumerate(currents)
+    ]
+    start = tick * n
+    external[start : start + n] = row
+    config["external"] = external
+
+
+def prefix_inputs(inputs: RecurrentInputs, ticks: int) -> RecurrentInputs:
+    if not 1 <= ticks <= inputs.ticks:
+        raise ValueError("prefix ticks outside configured range")
+    n = inputs.n_neurons
+    return replace(
+        inputs,
+        ticks=ticks,
+        external=inputs.external[: ticks * n],
+        rewards=inputs.rewards[:ticks] if inputs.synapses is not None else (),
+    )
+
+
+def step_payload(
+    outputs: Mapping[str, object],
+    *,
+    tick: int,
+    n_neurons: int,
+) -> dict[str, object]:
+    start, stop = tick * n_neurons, (tick + 1) * n_neurons
+    voltage_raw = outputs.get("voltage")
+    adaptation_raw = outputs.get("adaptation")
+    spikes_raw = outputs.get("spikes")
+    if not isinstance(voltage_raw, list):
+        raise ValueError("voltage output must be a list")
+    if not isinstance(adaptation_raw, list):
+        raise ValueError("adaptation output must be a list")
+    if not isinstance(spikes_raw, list):
+        raise ValueError("spikes output must be a list")
+    return {
+        "tick": tick,
+        "voltage": [
+            canonical_float(value, field="voltage output")
+            for value in voltage_raw[start:stop]
+        ],
+        "adaptation": [
+            canonical_float(value, field="adaptation output")
+            for value in adaptation_raw[start:stop]
+        ],
+        "spikes": [
+            canonical_int(value, field="spike output")
+            for value in spikes_raw[start:stop]
+        ],
+    }

src/controller/runtime.py

@@ -23,7 +23,7 @@ Example:
 Integration with dashboard:
     >>> from src.dashboard.operator_bridge import OperatorBridge
     >>> bridge = OperatorBridge(controller=controller)
-    >>> serve_dashboard(host="127.0.0.1", port=8765, structural_bridge=bridge)
+    >>> serve_dashboard(host="127.0.0.1", port=8767, structural_bridge=bridge)
 """
 
 from __future__ import annotations

src/dashboard/__init__.py

@@ -15,10 +15,10 @@ and accessed via a web browser.
 
 Example:
     >>> from src.dashboard import serve_dashboard
-    >>> serve_dashboard(host="127.0.0.1", port=8765)
+    >>> serve_dashboard(host="127.0.0.1", port=8767)
 
     Or via command line:
-    >>> python -m src.dashboard --host 0.0.0.0 --port 8765
+    >>> python -m src.dashboard --host 0.0.0.0 --port 8767
 """
 
 from __future__ import annotations
@@ -45,6 +45,7 @@ from .models import (
     StructuralMetrics,
     SystemMetrics,
 )
+from .network_settings import DASHBOARD_HOST, DASHBOARD_PORT
 from .operator_bridge import OperatorBridge
 from .server import serve_dashboard
 from .state import (
@@ -67,8 +68,8 @@ logger = logging.getLogger(__name__)
 
 
 def create_default_dashboard(
-    host: str = "127.0.0.1",
-    port: int = 8765,
+    host: str = DASHBOARD_HOST,
+    port: int = DASHBOARD_PORT,
     snapshot_path: str | None = None,
     docs_root: str | None = None,
     state_store: DashboardStateStore | None = None,
@@ -81,7 +82,7 @@ def create_default_dashboard(
 
     Args:
         host: Host address to bind to (default: 127.0.0.1).
-        port: Port to bind to (default: 8765).
+        port: Port to bind to (default: 8767).
         snapshot_path: Optional path to the default B5D snapshot.
         docs_root: Optional path to the documentation root.
         state_store: Optional custom state store.

src/dashboard/experiment_evaluation.py

@@ -0,0 +1,166 @@
+"""Controlled post-hoc scientific interpretation artifacts for experiments."""
+
+from __future__ import annotations
+
+import json
+import re
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, cast
+
+
+class ExperimentEvaluationError(ValueError):
+    """Raised when a post-hoc evaluation cannot be safely recorded."""
+
+
+_EXPERIMENT_ID = re.compile(r"^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$")
+_ANSWERS = frozenset({"supported", "refuted", "mixed", "inconclusive", "not_assessed"})
+_TEXT_LIMITS = {
+    "evaluator": 200,
+    "evaluation": 30_000,
+    "observations": 20_000,
+    "limitations": 20_000,
+    "follow_up": 20_000,
+}
+
+
+def _text(payload: dict[str, object], key: str, *, required: bool = False) -> str:
+    value = payload.get(key, "")
+    if not isinstance(value, str):
+        raise ExperimentEvaluationError(f"{key} must be text")
+    result = value.strip()
+    if required and not result:
+        raise ExperimentEvaluationError(f"{key} is required")
+    limit = _TEXT_LIMITS.get(key)
+    if limit is not None and len(result) > limit:
+        raise ExperimentEvaluationError(f"{key} exceeds {limit} characters")
+    return result
+
+
+def _experiment_dir(research_root: Path, experiment_id: str) -> Path:
+    if not _EXPERIMENT_ID.fullmatch(experiment_id):
+        raise ExperimentEvaluationError("invalid experiment_id")
+    directory = research_root / "experiments" / experiment_id
+    manifest = directory / "manifest.json"
+    if not manifest.is_file():
+        raise ExperimentEvaluationError(f"experiment not found: {experiment_id}")
+    return directory
+
+
+def read_experiment_evaluation(
+    research_root: Path, experiment_id: str
+) -> dict[str, object]:
+    """Return the saved evaluation without exposing arbitrary filesystem paths."""
+
+    directory = _experiment_dir(research_root, experiment_id)
+    path = directory / "posthoc" / "evaluation.json"
+    if not path.is_file():
+        return {"exists": False, "experiment_id": experiment_id}
+    try:
+        value: Any = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError) as exc:
+        raise ExperimentEvaluationError("saved evaluation is unreadable") from exc
+    if not isinstance(value, dict):
+        raise ExperimentEvaluationError("saved evaluation must be an object")
+    return {"exists": True, **value}
+
+
+def write_experiment_evaluation(
+    research_root: Path, payload: dict[str, object]
+) -> dict[str, object]:
+    """Write a versioned interpretation artifact linked from the manifest."""
+
+    experiment_id = _text(payload, "experiment_id", required=True)
+    directory = _experiment_dir(research_root, experiment_id)
+    answer = _text(payload, "hypothesis_answer", required=True)
+    if answer not in _ANSWERS:
+        raise ExperimentEvaluationError("invalid hypothesis_answer")
+
+    evaluation: dict[str, object] = {
+        "schema": "MHRN_POSTHOC_EVALUATION_V1",
+        "experiment_id": experiment_id,
+        "research_question": _text(payload, "research_question"),
+        "hypothesis": _text(payload, "hypothesis"),
+        "hypothesis_answer": answer,
+        "evaluator": _text(payload, "evaluator", required=True),
+        "evaluation": _text(payload, "evaluation", required=True),
+        "observations": _text(payload, "observations"),
+        "limitations": _text(payload, "limitations"),
+        "follow_up": _text(payload, "follow_up"),
+        "created_at": _text(payload, "created_at")
+        or datetime.now(timezone.utc).isoformat(),
+        "scientific_evidence": False,
+        "epistemic_layer": "post_hoc_interpretation",
+        "human_review_status": "not_reviewed",
+        "automatic_evidence_promotion": False,
+    }
+
+    artifact_dir = directory / "posthoc"
+    artifact_dir.mkdir(exist_ok=True)
+    json_path = artifact_dir / "evaluation.json"
+    markdown_path = artifact_dir / "evaluation.md"
+    json_path.write_text(
+        json.dumps(evaluation, indent=2, ensure_ascii=True) + "\n", encoding="utf-8"
+    )
+    markdown_path.write_text(_markdown(evaluation), encoding="utf-8")
+
+    manifest_path = directory / "manifest.json"
+    manifest_value: Any = json.loads(manifest_path.read_text(encoding="utf-8"))
+    if not isinstance(manifest_value, dict):
+        raise ExperimentEvaluationError("experiment manifest must be an object")
+    manifest = cast(dict[str, object], manifest_value)
+    artifacts_value = manifest.get("artifacts")
+    artifacts = (
+        cast(dict[str, object], artifacts_value)
+        if isinstance(artifacts_value, dict)
+        else {}
+    )
+    artifacts["posthoc_evaluation"] = "posthoc/evaluation.md"
+    artifacts["posthoc_evaluation_data"] = "posthoc/evaluation.json"
+    manifest["artifacts"] = artifacts
+    manifest["posthoc_evaluation"] = {
+        "status": "recorded_interpretation_not_evidence",
+        "hypothesis_answer": answer,
+        "updated_at": evaluation["created_at"],
+    }
+    manifest_path.write_text(
+        json.dumps(manifest, indent=2, ensure_ascii=True) + "\n",
+        encoding="utf-8",
+    )
+
+    return {
+        "ok": True,
+        "experiment_id": experiment_id,
+        "markdown_path": f"experiments/{experiment_id}/posthoc/evaluation.md",
+        "json_path": f"experiments/{experiment_id}/posthoc/evaluation.json",
+        "scientific_evidence": False,
+        "epistemic_layer": "post_hoc_interpretation",
+    }
+
+
+def _markdown(evaluation: dict[str, object]) -> str:
+    def value(key: str, fallback: str = "Nicht angegeben") -> str:
+        return str(evaluation.get(key) or fallback)
+
+    return (
+        "# Post-hoc wissenschaftliche Auswertung\n\n"
+        f"- Experiment: `{value('experiment_id')}`\n"
+        f"- Forschungsfrage: {value('research_question')}\n"
+        f"- Hypothese: {value('hypothesis')}\n"
+        f"- Hypothesenantwort: **{value('hypothesis_answer')}**\n"
+        f"- Auswertende Person: {value('evaluator')}\n"
+        f"- Zeitpunkt: {value('created_at')}\n\n"
+        "## Wissenschaftliche Auswertung\n\n"
+        f"{value('evaluation')}\n\n"
+        "## Beobachtungen und Auswertungskriterien\n\n"
+        f"{value('observations')}\n\n"
+        "## Limitationen und Alternativerklärungen\n\n"
+        f"{value('limitations')}\n\n"
+        "## Nächste Schritte\n\n"
+        f"{value('follow_up')}\n\n"
+        "## Evidenzgrenze\n\n"
+        "Dieses Dokument ist eine nachgelagerte Interpretation. Es ist keine "
+        "automatische EVID-Einstufung, verändert keine Hypothesenregistrierung "
+        "und benötigt einen separaten Human-Review-/EVID-Workflow, bevor es als "
+        "wissenschaftlich geprüfte Aussage in die Arbeit eingehen kann.\n"
+    )

src/dashboard/gate_status.py

@@ -720,7 +720,7 @@ class GateStatusBuilder:
                 gate=GATE_A,
                 id="A-SINGLE-LISTENER",
                 category="technical_integration",
-                label="Exactly one TCP LISTEN socket on 127.0.0.1:8765 owned by MHRN PID",
+                label="Exactly one TCP LISTEN socket on 127.0.0.1:8767 owned by MHRN PID",
                 status=G_PASSED if listener_verified else G_PENDING,
                 maturity=VERIFIED if listener_verified else IMPLEMENTED,
                 source=(

src/dashboard/integration_status.py

@@ -16,6 +16,7 @@ A component disabled by config is NEVER reported as "failed".
 
 from __future__ import annotations
 
+import json
 from pathlib import Path
 from typing import Any, cast
 
@@ -128,6 +129,206 @@ class IntegrationStatusBuilder:
             "total": len(items),
             "items": cast(JSONValue, items),
             "source": "live_backend",
+            "acceleration": cast(JSONValue, self._build_acceleration_status()),
+        }
+
+    def _build_acceleration_status(self) -> dict[str, JSONValue]:
+        """Project canonical CUDA/FE-3 integration state without executing GPU work."""
+
+        manifest_path = (
+            self.repo_root
+            / "research"
+            / "verification"
+            / "frozen_environment"
+            / "FE3_DETERMINISTIC_TARGET_V1.json"
+        )
+        manifest_status: dict[str, JSONValue] = {
+            "path": str(manifest_path.relative_to(self.repo_root)),
+            "status": "missing",
+            "valid": False,
+        }
+        try:
+            from src.verification.frozen_environment import load_manifest_artifact
+
+            manifest = load_manifest_artifact(manifest_path)
+            manifest_status = {
+                "path": str(manifest_path.relative_to(self.repo_root)),
+                "status": "verified",
+                "valid": True,
+                "mode": manifest.mode.value,
+                "contract_id": manifest.contract_id,
+                "manifest_sha256": manifest.manifest_sha256,
+                "environment_id": manifest.environment_id,
+                "sensor_ticks": len(manifest.sensor_schedule),
+            }
+        except (OSError, ValueError) as exc:
+            manifest_status["message"] = str(exc)
+
+        backend_status: dict[str, JSONValue]
+        try:
+            from src.acceleration.cuda import (
+                CUDABackend,
+                execution_backend_contract_check,
+            )
+
+            backend = CUDABackend()
+            capabilities = backend.capabilities().to_mapping()
+            backend_status = {
+                "status": "integrated",
+                "contract_ok": execution_backend_contract_check(),
+                "backend_name": backend.backend_name,
+                "backend_version": backend.backend_version,
+                "capabilities": cast(JSONValue, capabilities),
+            }
+        except Exception as exc:  # fail closed in dashboard projection
+            backend_status = {
+                "status": "unavailable",
+                "contract_ok": False,
+                "message": str(exc),
+            }
+
+        reports = sorted(
+            (self.repo_root / "docs" / "canonical").glob("HARDWARE_ACCEPTANCE_*.json")
+        )
+        hardware: dict[str, JSONValue]
+        if not reports:
+            hardware = {
+                "status": "pending",
+                "accepted": False,
+                "artifact": None,
+                "message": "No reviewed physical hardware acceptance artifact is present.",
+            }
+        else:
+            latest = reports[-1]
+            try:
+                raw_object: object = json.loads(latest.read_text(encoding="utf-8"))
+                if not isinstance(raw_object, dict):
+                    raise ValueError("hardware acceptance artifact must be an object")
+                raw = cast(dict[str, object], raw_object)
+                accepted = bool(raw.get("passed")) and bool(
+                    raw.get("full_fe3_accepted")
+                )
+                hardware = {
+                    "status": "passed" if accepted else "failed",
+                    "accepted": accepted,
+                    "artifact": str(latest.relative_to(self.repo_root)),
+                    "gpu_identity": cast(JSONValue, raw.get("gpu_identity")),
+                    "wave4_physical": cast(JSONValue, raw.get("wave4_physical")),
+                    "builder_d3c_bridge": cast(
+                        JSONValue, raw.get("builder_d3c_bridge")
+                    ),
+                    "frozen_environment_fe3": cast(
+                        JSONValue, raw.get("frozen_environment_fe3")
+                    ),
+                    "full_fe3_accepted": bool(raw.get("full_fe3_accepted")),
+                    "scientific_evidence": False,
+                }
+            except (OSError, ValueError, json.JSONDecodeError) as exc:
+                hardware = {
+                    "status": "failed",
+                    "accepted": False,
+                    "artifact": str(latest.relative_to(self.repo_root)),
+                    "message": str(exc),
+                }
+
+        capabilities_object = backend_status.get("capabilities")
+        backend_live = False
+        if isinstance(capabilities_object, dict):
+            capabilities_mapping = capabilities_object
+            backend_live = (
+                capabilities_mapping.get("supports_live_external_input") is True
+            )
+        fe3_software_ready = bool(manifest_status["valid"]) and backend_live
+
+        try:
+            from src.homeostasis.pan_wave5b_preflight import (
+                evaluate_pan_wave5b_readiness,
+            )
+
+            pan_wave5b = evaluate_pan_wave5b_readiness(self.repo_root).to_mapping()
+        except Exception as exc:  # fail closed in dashboard projection
+            pan_wave5b = {
+                "classification": "PAN_WAVE5B_PREFLIGHT",
+                "scientific_evidence": False,
+                "integration_claimed": False,
+                "preflight_ready": False,
+                "ready_for_execution": False,
+                "blockers": ["PAN_WAVE5B_PREFLIGHT_UNAVAILABLE"],
+                "next_gate": "REPAIR_PAN_WAVE5B_PREFLIGHT",
+                "message": str(exc),
+            }
+
+        pan_preflight_ready = pan_wave5b.get("preflight_ready") is True
+
+        waves: list[dict[str, JSONValue]] = [
+            {"id": "wave1", "label": "Neural I/O Contracts", "status": "integrated"},
+            {
+                "id": "wave2",
+                "label": "Codecs / Adapter / Gateway",
+                "status": "integrated",
+            },
+            {
+                "id": "wave3",
+                "label": "ExecutionBackend / Parity / Determinism",
+                "status": "integrated",
+            },
+            {"id": "wave4", "label": "Canonical CUDA Backend", "status": "integrated"},
+            {
+                "id": "fe3",
+                "label": "FE-3 Live Backend Bridge",
+                "status": "software_verified" if fe3_software_ready else "blocked",
+            },
+            {
+                "id": "hardware",
+                "label": "Physical RTX Hardware Acceptance",
+                "status": str(hardware["status"]),
+            },
+            {
+                "id": "wave5",
+                "label": "PAN Hyperstate / Wave 5B",
+                "status": (
+                    "preflight_ready" if pan_preflight_ready else "contract_draft"
+                ),
+            },
+            {"id": "wave6", "label": "Structural Plasticity", "status": "blocked"},
+            {
+                "id": "wave7",
+                "label": "Canonical Learning Contract",
+                "status": "blocked",
+            },
+        ]
+
+        return {
+            "classification": "MHRN_ACCELERATION_INTEGRATION_STATUS",
+            "scientific_evidence": False,
+            "software_path_closed": fe3_software_ready,
+            "physical_hardware_accepted": bool(hardware["accepted"]),
+            "provenance_rule": (
+                "CPU/CUDA execution fingerprints differ by design; "
+                "semantic equality is manifest + live-input + D3c parity."
+            ),
+            "backend": cast(JSONValue, backend_status),
+            "fe3_manifest": cast(JSONValue, manifest_status),
+            "hardware_acceptance": cast(JSONValue, hardware),
+            "pan_wave5b_preflight": cast(JSONValue, pan_wave5b),
+            "waves": cast(JSONValue, waves),
+            "next_gate": str(
+                pan_wave5b.get(
+                    "next_gate",
+                    "REPAIR_PAN_WAVE5B_PREFLIGHT",
+                )
+            ),
+            "limitations": cast(
+                JSONValue,
+                {
+                    "scientific_data": False,
+                    "evidence": False,
+                    "speedup_claim": False,
+                    "pan_hyperstate": False,
+                    "structural_plasticity": False,
+                    "canonical_learning_contract": False,
+                },
+            ),
         }
 
     # ------------------------------------------------------------------------

src/dashboard/network_settings.py

@@ -0,0 +1,69 @@
+"""Central network settings for the MHRN dashboard.
+
+All components (launcher, server, start scripts, Hugging Face config)
+read their default host, port and LAN policy from this single module.
+Change values here to reconfigure the entire stack.
+"""
+
+from __future__ import annotations
+
+# ---------------------------------------------------------------------------
+# Dashboard HTTP server
+# ---------------------------------------------------------------------------
+
+DASHBOARD_HOST: str = "127.0.0.1"
+"""Default bind address for direct Python dashboard startup."""
+
+DASHBOARD_LAN_HOST: str = "0.0.0.0"  # nosec B104 - trusted-LAN wrapper default
+"""Trusted-LAN bind address used by the Windows convenience wrappers.
+
+The Windows launchers intentionally expose the dashboard to the host's private
+network by default. Direct Python startup remains loopback-only unless the user
+passes an explicit host.
+"""
+
+DASHBOARD_PORT: int = 8767
+"""Default TCP port for the dashboard HTTP server."""
+
+# ---------------------------------------------------------------------------
+# Public / Internet policy
+# ---------------------------------------------------------------------------
+
+ALLOW_PUBLIC_DEPLOYMENT: bool = False
+"""Whether the dashboard is allowed to bind to a public interface.
+
+Set this to ``True`` only when a proper reverse proxy, TLS, authentication,
+logging and privacy notice are in place. The dashboard exposes operator,
+research and file-management endpoints without built-in access control.
+"""
+
+PUBLIC_DEPLOYMENT_NOTE: str = (
+    "The dashboard exposes operator, research and file-management capabilities. "
+    "Do not expose it directly to the public Internet. For trusted-LAN use, "
+    f"restrict TCP port {DASHBOARD_PORT} to the intended private network."
+)
+"""Safety note displayed in the README and referenced in deployment docs."""
+
+# ---------------------------------------------------------------------------
+# Hugging Face Space
+# ---------------------------------------------------------------------------
+
+HF_SPACE_PORT: int = DASHBOARD_PORT
+"""Port used inside the Hugging Face Docker Space (must match EXPOSE)."""
+
+HF_SPACE_HOST: str = "0.0.0.0"  # nosec B104 - required container bind for HF Spaces
+"""Host used inside the Hugging Face Space container."""
+
+# ---------------------------------------------------------------------------
+# Convenience accessors
+# ---------------------------------------------------------------------------
+
+
+def dashboard_local_url() -> str:
+    """Return the loopback URL of the dashboard."""
+    return f"http://127.0.0.1:{DASHBOARD_PORT}"
+
+
+def dashboard_bind_spec() -> str:
+    """Return the ``host:port`` string used for bind / firewall docs."""
+    return f"{DASHBOARD_HOST}:{DASHBOARD_PORT}"

src/dashboard/playground_api.py

@@ -2,17 +2,42 @@
 
 from __future__ import annotations
 
+import shutil
 import threading
 import time
 from collections import deque
-from collections.abc import Mapping
+from collections.abc import Callable, Mapping
+from dataclasses import replace
 from typing import cast
 
 from src.playground import service
-from src.playground.cuda import compile_mapping
+from src.playground.cuda import (
+    CompileBundle,
+    CudaDriver,
+    CudaDriverError,
+    CudaRuntimeUnavailable,
+    GateLaunchInputs,
+    compile_mapping,
+    cpu_gate_reference,
+    execute_gate_bundle,
+    gate_execution_parity_summary,
+    preflight_bundle,
+    validate_cuda_block_size,
+)
+from src.playground.cuda.builder_parity import run_builder_parity
+from src.playground.cuda.recurrent import (
+    cpu_recurrent_reference,
+    execute_recurrent,
+    recurrent_fixture,
+    recurrent_parity,
+)
+from src.playground.cuda.synapses import SynapseConfig
+from src.playground.integration import integration_catalog, transfer_element
 from src.playground.models import PlaygroundConfig
 from src.playground.night_run import NightRunManager
 from src.playground.pan import PANEmbodiedSandboxSession, PANSessionDaemon
+from src.playground.pan.cue_controls import run_cue_controls
+from src.playground.pan.transfer import run_synaptic_transfer
 
 _MAX_CONCURRENT_RUNS = 2
 _RUNS_PER_MINUTE = 20
@@ -98,20 +123,29 @@ def _reserve_rate_slot() -> None:
         _RECENT_RUNS.append(now)
 
 
-def _bounded_run(path: str, payload: Mapping[str, object]) -> dict[str, object]:
+def _bounded_operation(
+    operation: Callable[[], dict[str, object]],
+) -> dict[str, object]:
     _reserve_rate_slot()
     if not _RUN_SEMAPHORE.acquire(blocking=False):
         raise PlaygroundBusyError(
             "Playground is busy; at most two simulation requests run concurrently."
         )
     try:
+        return operation()
+    finally:
+        _RUN_SEMAPHORE.release()
+
+
+def _bounded_run(path: str, payload: Mapping[str, object]) -> dict[str, object]:
+    def operation() -> dict[str, object]:
         if path == "/api/playground/run":
             return service.run(payload)
         if path == "/api/playground/robustness":
             return service.robustness(payload)
         raise ValueError(f"unknown Playground POST route: {path}")
-    finally:
-        _RUN_SEMAPHORE.release()
+
+    return _bounded_operation(operation)
 
 
 def _live_parts(path: str) -> list[str]:
@@ -121,9 +155,314 @@ def _live_parts(path: str) -> list[str]:
     return [part for part in path[len(prefix) :].split("/") if part]
 
 
+def _cuda_runtime_status() -> dict[str, object]:
+    ptxas_path = shutil.which("ptxas")
+    driver_available = False
+    driver_error: str | None = None
+    try:
+        driver = CudaDriver()
+        driver.initialize()
+        driver_available = True
+    except (CudaRuntimeUnavailable, CudaDriverError, OSError) as exc:
+        driver_error = str(exc)
+
+    return {
+        "classification": "PLAYGROUND_CUDA_DIAGNOSTICS_STATUS",
+        "scientific_evidence": False,
+        "canonical_cuda_backend": False,
+        "target_default": "sm_86",
+        "ptxas_available": ptxas_path is not None,
+        "ptxas_path": ptxas_path,
+        "cuda_driver_available": driver_available,
+        "cuda_driver_error": driver_error,
+        "stages": {
+            "CUDA-1.0": "PTXAS_LOAD_PREFLIGHT_IMPLEMENTED",
+            "CUDA-1.1": "DETERMINISM_FREEZE_PARITY_CONTRACT_IMPLEMENTED",
+            "CUDA-1.2": "LAUNCH_ABI_BUFFER_VALIDATION_IMPLEMENTED",
+            "CUDA-1.3": "CPU_GATE_REFERENCE_D2_IMPLEMENTED_HARDWARE_VERIFICATION_REQUIRED",
+            "CUDA-1.4": "BOUNDED_RECURRENT_FP64_REFERENCE_IMPLEMENTED",
+            "CUDA-1.5": "BOUNDED_FROZEN_REWARD_PLASTICITY_REFERENCE_IMPLEMENTED",
+            "CUDA-1.6": "HYBRID_BUILDER_MEMBRANE_AND_OPTIONAL_PAN_STATE_GPU_BODY_CPU_IMPLEMENTED",
+        },
+        "application_cpu": {
+            "sandbox_physics": True,
+            "sensorics": True,
+            "actuation": True,
+            "posture_analysis": True,
+            "reward_triggers": True,
+            "closed_loop": True,
+        },
+        "gpu_porting": {
+            "gate_single_tick": True,
+            "membrane_state_100_ticks": True,
+            "adaptation_state": True,
+            "pan_health_energy_hyperstate": "OPTIONAL_CUDA_PAN_BUILDER",
+            "pan_apoptosis_decision": "OPTIONAL_CUDA_PAN_BUILDER",
+            "pan_feedback_projection": "OPTIONAL_CUDA_PAN_BUILDER",
+            "refractory_state": False,
+            "synapses": "BUILDER_GPU_EMISSION_PLASTICITY_REWARD_RESIDENT_QUEUE_HOST_TRACE",
+            "builder_rng_semantics": "HOST_TRAVERSAL_STREAM_PRESERVED",
+            "builder_inhibitory_emission": True,
+            "delays": True,
+            "builder_delay_queue": "DEVICE_RESIDENT_RING_65",
+            "builder_neuron_traces": "DEVICE_RESIDENT_TWO_PHASE",
+            "builder_pan_population": "CUDA_ORDERED_AXIS_REDUCTION",
+            "plasticity": "BUILDER_PAIR_TRIPLET_ELIGIBILITY_MODULATION_AND_BOUNDED_REFERENCE",
+            "sandbox_physics": False,
+        },
+        "verification": {
+            "cpu_gate_reference": True,
+            "single_tick_d2_endpoint": True,
+            "rng_action_path_endpoint": True,
+            "raw_rng_value_parity": True,
+            "memory_leak_instrumentation": True,
+        },
+    }
+
+
+def _diagnostic_inputs(
+    bundle: CompileBundle,
+    *,
+    n_neurons: int,
+    seed: int,
+    epsilon: float,
+) -> GateLaunchInputs:
+    manifest = bundle.manifest
+    raw_abi = manifest.get("kernel_abi")
+    if not isinstance(raw_abi, Mapping):
+        raise ValueError("compile bundle is missing kernel_abi")
+    abi = cast(Mapping[str, object], raw_abi)
+    input_channels = _payload_int(abi, "input_channels", 8)
+    action_count = _payload_int(abi, "action_space_size", 4)
+    pan_dimensions = _payload_int(abi, "pan_dimensions", 5)
+    full_mask = (1 << input_channels) - 1 if input_channels < 64 else 0xFFFFFFFFFFFFFFFF
+    logits: list[float] = []
+    for neuron in range(n_neurons):
+        preferred = neuron % action_count
+        for action in range(action_count):
+            logits.append(1.0 if action == preferred else 0.05 * (action + 1))
+    return GateLaunchInputs.from_sequences(
+        input_current=[1.0 + 0.125 * (index % 7) for index in range(n_neurons)],
+        channel_masks=[full_mask] * n_neurons,
+        amplitudes=[1.0 + 0.05 * channel for channel in range(input_channels)],
+        reward_ring=[0.5, -0.25, 0.75, 0.0],
+        action_map=[
+            0.1 * (action + 1) * (channel + 1)
+            for action in range(action_count)
+            for channel in range(input_channels)
+        ],
+        feedback_matrix=[
+            0.01 * (1 + ((neuron + dimension) % 5))
+            for neuron in range(n_neurons)
+            for dimension in range(pan_dimensions)
+        ],
+        population=[0.1 * (dimension + 1) for dimension in range(pan_dimensions)],
+        logits=logits,
+        tick=3,
+        target_index=min(2, action_count - 1),
+        previous_action=min(1, action_count - 1),
+        seed=seed,
+        epsilon=epsilon,
+    )
+
+
+def _cuda_config_payload(payload: Mapping[str, object]) -> dict[str, object]:
+    excluded = {
+        "target_sm",
+        "ptx_version",
+        "n_neurons",
+        "block_size",
+        "device_ordinal",
+        "reference_commit",
+        "rng_samples",
+    }
+    return {key: value for key, value in payload.items() if key not in excluded}
+
+
+def _cuda_preflight(payload: Mapping[str, object]) -> dict[str, object]:
+    target_sm = _payload_text(payload, "target_sm", "sm_86")
+    ptx_version = _payload_text(payload, "ptx_version", "7.1")
+    n_neurons = _payload_int(payload, "n_neurons", 256)
+    block_size = validate_cuda_block_size(_payload_int(payload, "block_size", 64))
+    device_ordinal = _payload_int(payload, "device_ordinal", 0)
+    if not 1 <= n_neurons <= 12_288:
+        raise ValueError("n_neurons must be in [1, 12288]")
+    bundle = compile_mapping(
+        _cuda_config_payload(payload),
+        target_sm=target_sm,
+        ptx_version=ptx_version,
+    )
+    return preflight_bundle(
+        bundle,
+        n_neurons=n_neurons,
+        block_size=block_size,
+        device_ordinal=device_ordinal,
+    )
+
+
+def _cuda_smoke(payload: Mapping[str, object]) -> dict[str, object]:
+    target_sm = _payload_text(payload, "target_sm", "sm_86")
+    ptx_version = _payload_text(payload, "ptx_version", "7.1")
+    n_neurons = _payload_int(payload, "n_neurons", 64)
+    block_size = validate_cuda_block_size(_payload_int(payload, "block_size", 64))
+    device_ordinal = _payload_int(payload, "device_ordinal", 0)
+    reference_commit = _payload_text(payload, "reference_commit", "")
+    if not 1 <= n_neurons <= 4096:
+        raise ValueError("n_neurons must be in [1, 4096] for hardware smoke")
+    bundle = compile_mapping(
+        _cuda_config_payload(payload),
+        target_sm=target_sm,
+        ptx_version=ptx_version,
+    )
+    inputs = _diagnostic_inputs(
+        bundle,
+        n_neurons=n_neurons,
+        seed=12345,
+        epsilon=0.0,
+    )
+    reference = cpu_gate_reference(bundle, inputs)
+    first = execute_gate_bundle(
+        bundle,
+        inputs,
+        block_size=block_size,
+        device_ordinal=device_ordinal,
+    )
+    second = execute_gate_bundle(
+        bundle,
+        inputs,
+        block_size=block_size,
+        device_ordinal=device_ordinal,
+    )
+    first_parity = gate_execution_parity_summary(
+        reference,
+        first,
+        tolerance=1.0e-5,
+        reference_commit=reference_commit,
+    )
+    second_parity = gate_execution_parity_summary(
+        reference,
+        second,
+        tolerance=1.0e-5,
+        reference_commit=reference_commit,
+    )
+    deterministic = first.get("outputs") == second.get("outputs")
+    return {
+        "classification": "PLAYGROUND_CUDA1_3_HARDWARE_SMOKE",
+        "scientific_evidence": False,
+        "canonical_cuda_backend": False,
+        "reference": reference,
+        "first": first,
+        "second": second,
+        "parity": first_parity,
+        "second_parity": second_parity,
+        "gpu_repeat_exact": deterministic,
+        "passed": bool(first_parity["passed"])
+        and bool(second_parity["passed"])
+        and deterministic,
+        "cleanup_contract": {
+            "device_allocations_released_in_finally": True,
+            "driver_module_unloaded": True,
+            "memory_leak_instrumented": True,
+            "first_memory": first.get("memory"),
+            "second_memory": second.get("memory"),
+        },
+    }
+
+
+def _cuda_rng_parity(payload: Mapping[str, object]) -> dict[str, object]:
+    target_sm = _payload_text(payload, "target_sm", "sm_86")
+    ptx_version = _payload_text(payload, "ptx_version", "7.1")
+    samples = _payload_int(payload, "rng_samples", 1000)
+    block_size = validate_cuda_block_size(_payload_int(payload, "block_size", 64))
+    device_ordinal = _payload_int(payload, "device_ordinal", 0)
+    if not 1 <= samples <= 4096:
+        raise ValueError("rng_samples must be in [1, 4096]")
+    bundle = compile_mapping(
+        _cuda_config_payload(payload),
+        target_sm=target_sm,
+        ptx_version=ptx_version,
+    )
+    inputs = _diagnostic_inputs(
+        bundle,
+        n_neurons=samples,
+        seed=12345,
+        epsilon=1.0,
+    )
+    reference = cpu_gate_reference(bundle, inputs)
+    candidate = execute_gate_bundle(
+        bundle,
+        inputs,
+        block_size=block_size,
+        device_ordinal=device_ordinal,
+    )
+    reference_outputs = cast(Mapping[str, object], reference["outputs"])
+    candidate_outputs = cast(Mapping[str, object], candidate["outputs"])
+    reference_actions = cast(list[int], reference_outputs["action"])
+    candidate_actions = cast(list[int], candidate_outputs["action"])
+    actions_exact = reference_actions == candidate_actions
+    return {
+        "classification": "PLAYGROUND_CUDA_RNG_ACTION_PATH_PARITY",
+        "scientific_evidence": False,
+        "samples": samples,
+        "seed": 12345,
+        "tick": inputs.tick,
+        "epsilon": 1.0,
+        "actions_exact": actions_exact,
+        "passed": actions_exact,
+        "first_reference_actions": reference_actions[:20],
+        "first_cuda_actions": candidate_actions[:20],
+        "scope": "HASH_EPSILON_GREEDY_ACTION_PATH_UINT24_TO_F32_HALF_OPEN",
+    }
+
+
+def _cuda_recurrent_parity(payload: Mapping[str, object]) -> dict[str, object]:
+    block_size = validate_cuda_block_size(_payload_int(payload, "block_size", 64))
+    inputs = recurrent_fixture(
+        n_neurons=_payload_int(payload, "n_neurons", 129),
+        ticks=_payload_int(payload, "ticks", 100),
+        model=_payload_text(payload, "model", "pan_adex_5d"),
+    )
+    plasticity = payload.get("plasticity", False)
+    if not isinstance(plasticity, bool):
+        raise ValueError("plasticity must be boolean")
+    if plasticity:
+        inputs = replace(
+            inputs,
+            synapses=SynapseConfig(),
+            rewards=tuple(
+                1.0 if tick % 32 == 0 else 0.0 for tick in range(inputs.ticks)
+            ),
+        )
+    reference = cpu_recurrent_reference(inputs)
+    candidate = execute_recurrent(
+        inputs,
+        block_size=block_size,
+        target_sm=_payload_text(payload, "target_sm", "sm_86"),
+    )
+    return {
+        "classification": (
+            "PLAYGROUND_CUDA15_PLASTICITY_PARITY"
+            if plasticity
+            else "PLAYGROUND_CUDA14_RECURRENT_PARITY"
+        ),
+        "scientific_evidence": False,
+        "model": inputs.model,
+        "ticks": inputs.ticks,
+        "state_dtype": candidate["state_dtype"],
+        "preflight": candidate["preflight"],
+        "parity": recurrent_parity(
+            reference, cast(dict[str, object], candidate["outputs"])
+        ),
+        "scope": candidate["comparison_scope"],
+        "full_pan_backend": False,
+    }
+
+
 def get_playground(path: str) -> dict[str, object] | None:
     if path == "/api/playground/catalog":
         return service.catalog()
+    if path == "/api/playground/integration":
+        return integration_catalog()
     if path == "/api/playground/sessions":
         return service.sessions()
     if path.startswith("/api/playground/sessions/"):
@@ -131,6 +470,8 @@ def get_playground(path: str) -> dict[str, object] | None:
         return service.replay(session_id)
     if path == "/api/playground/night":
         return _NIGHT_RUN.status()
+    if path == "/api/playground/cuda/status":
+        return _cuda_runtime_status()
     if path == "/api/playground/live":
         return {
             "class": "PLAYGROUND_LIVE_SESSIONS",
@@ -149,6 +490,15 @@ def post_playground(
     if path in {"/api/playground/run", "/api/playground/robustness"}:
         return _bounded_run(path, payload)
 
+    if path == "/api/playground/integration/transfer":
+        return transfer_element(payload)
+
+    if path == "/api/playground/research/synaptic-transfer":
+        return _bounded_operation(lambda: run_synaptic_transfer(payload))
+
+    if path == "/api/playground/research/cue-controls":
+        return _bounded_operation(lambda: run_cue_controls(payload))
+
     if path == "/api/playground/determinism":
         return service.determinism(payload)
 
@@ -164,6 +514,21 @@ def post_playground(
             ptx_version=ptx_version,
         ).to_mapping()
 
+    if path == "/api/playground/cuda/preflight":
+        return _bounded_operation(lambda: _cuda_preflight(payload))
+
+    if path == "/api/playground/cuda/smoke":
+        return _bounded_operation(lambda: _cuda_smoke(payload))
+
+    if path == "/api/playground/cuda/rng-parity":
+        return _bounded_operation(lambda: _cuda_rng_parity(payload))
+
+    if path == "/api/playground/cuda/builder-parity":
+        return _bounded_operation(lambda: run_builder_parity(payload))
+
+    if path == "/api/playground/cuda/recurrent-parity":
+        return _bounded_operation(lambda: _cuda_recurrent_parity(payload))
+
     if path == "/api/playground/night/start":
         return _NIGHT_RUN.start(
             hours=_payload_float(payload, "hours", 8.0),
@@ -205,7 +570,11 @@ def post_playground(
         session = _LIVE_DAEMON.get(session_id)
         if action == "step":
             ticks = _payload_int(payload, "ticks", 32)
-            return {"session_id": session_id, **session.step(ticks)}
+            include_topology = payload.get("include_topology", True) is not False
+            return {
+                "session_id": session_id,
+                **session.step(ticks, include_topology=include_topology),
+            }
         if action == "input":
             values = _numeric_list(payload.get("values", []), "values")
             duration = _payload_int(payload, "duration_ticks", 16)

src/dashboard/server.py

@@ -93,6 +93,11 @@ from .development_timeline import build_development_timeline
 from .docs_source import DocumentationSource, create_docs_source
 from .embedding_jobs import EmbeddingJobError, list_embedding_jobs, run_embedding_job
 from .experiment_archive import ExperimentArchiveError, ExperimentArchiveService
+from .experiment_evaluation import (
+    ExperimentEvaluationError,
+    read_experiment_evaluation,
+    write_experiment_evaluation,
+)
 from .experiment_organizer import ExperimentOrganizerService
 from .experiment_workflow import (
     ExperimentWorkflowService,
@@ -206,6 +211,9 @@ class DashboardServer(ThreadingHTTPServer):
 
     allow_reuse_address = True
     daemon_threads = True
+    # A browser opens bursts of parallel ES-module and asset connections.
+    # The stdlib's older backlog of five rejects some on Windows.
+    request_queue_size = 64
 
     def __init__(
         self,
@@ -683,6 +691,11 @@ class DashboardRequestHandler(BaseHTTPRequestHandler):
             if path == "/api/research/experiments/archive":
                 self._serve_archived_experiments()
                 return
+            if path.startswith("/api/research/experiments/") and path.endswith(
+                "/evaluation"
+            ):
+                self._serve_experiment_evaluation(path)
+                return
             if path == "/api/research/experiment-series":
                 self._serve_experiment_series()
                 return
@@ -727,6 +740,10 @@ class DashboardRequestHandler(BaseHTTPRequestHandler):
             # Integration Status (real backend data, Phase 14)
             # ----------------------------------------------------------------
 
+            if path == "/api/settings/network":
+                self._serve_network_settings()
+                return
+
             if path == "/api/integration/status":
                 self._serve_integration_status()
                 return
@@ -1058,6 +1075,9 @@ class DashboardRequestHandler(BaseHTTPRequestHandler):
             if path == "/api/research/experiments/archive":
                 self._archive_experiment(body)
                 return
+            if path == "/api/research/experiments/evaluation":
+                self._write_experiment_evaluation(body)
+                return
             if path == "/api/research/analysis-jobs":
                 self._run_analysis_job(body)
                 return
@@ -2165,6 +2185,33 @@ class DashboardRequestHandler(BaseHTTPRequestHandler):
 
         self._send_api_not_found(path)
 
+    # ========================================================================
+    # Network Settings (central config)
+    # ========================================================================
+
+    def _serve_network_settings(self) -> None:
+        from .network_settings import (
+            ALLOW_PUBLIC_DEPLOYMENT,
+            DASHBOARD_HOST,
+            DASHBOARD_PORT,
+            HF_SPACE_HOST,
+            HF_SPACE_PORT,
+            PUBLIC_DEPLOYMENT_NOTE,
+        )
+
+        self._send_json(
+            {
+                "dashboard_host": DASHBOARD_HOST,
+                "dashboard_port": DASHBOARD_PORT,
+                "local_url": f"http://127.0.0.1:{DASHBOARD_PORT}",
+                "hf_space_host": HF_SPACE_HOST,
+                "hf_space_port": HF_SPACE_PORT,
+                "allow_public_deployment": ALLOW_PUBLIC_DEPLOYMENT,
+                "public_deployment_note": PUBLIC_DEPLOYMENT_NOTE,
+                "source": "src/dashboard/network_settings.py",
+            }
+        )
+
     # ========================================================================
     # Integration Status (real backend data, Phase 14)
     # ========================================================================
@@ -4361,7 +4408,7 @@ class DashboardRequestHandler(BaseHTTPRequestHandler):
         tenant = os.environ.get("BRAIN5D_MICROSOFT_TENANT", "common").strip()
         redirect_uri = os.environ.get(
             "BRAIN5D_MICROSOFT_REDIRECT_URI",
-            "http://127.0.0.1:8765/api/research/chat/oauth/callback",
+            "http://127.0.0.1:8767/api/research/chat/oauth/callback",
         ).strip()
         if not client_id:
             self._send_json(
@@ -4570,6 +4617,32 @@ class DashboardRequestHandler(BaseHTTPRequestHandler):
             {"experiments": cast(list[JSONValue], source.list_experiments())}
         )
 
+    def _serve_experiment_evaluation(self, path: str) -> None:
+        prefix = "/api/research/experiments/"
+        experiment_id = unquote(path[len(prefix) : -len("/evaluation")]).strip("/")
+        try:
+            source = self._require_research_source()
+            self._send_json(
+                cast(
+                    Mapping[str, JSONValue],
+                    read_experiment_evaluation(source.root(), experiment_id),
+                )
+            )
+        except ExperimentEvaluationError as exc:
+            self._send_json({"error": str(exc)}, HTTPStatus.BAD_REQUEST)
+
+    def _write_experiment_evaluation(self, body: dict[str, Any]) -> None:
+        source = self._require_research_source()
+        try:
+            result = write_experiment_evaluation(source.root(), body)
+        except ExperimentEvaluationError as exc:
+            self._send_json({"error": str(exc)}, HTTPStatus.BAD_REQUEST)
+            return
+        self._send_json(
+            cast(Mapping[str, JSONValue], result),
+            HTTPStatus.CREATED,
+        )
+
     def _write_artifact_review(self, body: dict[str, Any]) -> None:
         source = self._require_research_source()
         artifact_path = body.get("artifact_path")
@@ -6262,7 +6335,7 @@ def main() -> None:
     parser.add_argument(
         "--port",
         type=int,
-        default=8765,
+        default=8767,
     )
 
     parser.add_argument(

src/dashboard/static/experiment-workflow-base.js

@@ -613,7 +613,9 @@ export class ExperimentWorkflowPanel {
     if (artifacts.calibration) resultButtons.push(`<button type="button" class="btn-small exp-open-btn" data-experiment-open="calibration" data-experiment-id="${expId}" data-artifact-path="${escapeHtml(artifacts.calibration)}" title="Kalibrierungsdaten">⚙ Kalibrierung</button>`);
     if (artifacts.manifest) resultButtons.push(`<button type="button" class="btn-small exp-open-btn" data-experiment-open="manifest" data-experiment-id="${expId}" data-artifact-path="${escapeHtml(artifacts.manifest)}" title="Manifest und Provenienz">🧾 Manifest</button>`);
     if (artifacts.review) resultButtons.push(`<button type="button" class="btn-small exp-open-btn" data-experiment-open="review" data-experiment-id="${expId}" data-artifact-path="${escapeHtml(artifacts.review)}" title="Review und wissenschaftliche Weiterverarbeitung">✓ Review</button>`);
-    const resultActions = resultButtons.length ? `<div class="experiment-library-results">${resultButtons.join("")}</div>` : "";
+    if (artifacts.posthoc_evaluation) resultButtons.push(`<button type="button" class="btn-small exp-open-btn" data-experiment-open="posthoc" data-experiment-id="${expId}" data-artifact-path="${escapeHtml(artifacts.posthoc_evaluation)}" title="Gespeicherte wissenschaftliche Auswertung">📝 Auswertung</button>`);
+    const evaluationAction = `<button type="button" class="btn-small exp-evaluate-btn" data-experiment-evaluate="${expId}" title="Nachträgliche wissenschaftliche Auswertung erfassen">✎ Auswertung erfassen</button>`;
+    const resultActions = `<div class="experiment-library-results">${resultButtons.join("")}${evaluationAction}</div>`;
     const action = archived
       ? `<button type="button" class="btn-small" data-experiment-action="restore" data-experiment-id="${expId}">↶ Wiederherstellen</button>`
       : `<button type="button" class="btn-small" data-experiment-action="archive" data-experiment-id="${expId}">▣ Archivieren</button>`;
@@ -685,6 +687,124 @@ export class ExperimentWorkflowPanel {
     return `<details class="experiment-series-item ${item.archived ? "is-archived" : ""}"><summary><span><strong>${escapeHtml(item.series_id)}</strong><small>${escapeHtml(item.created_at || "")}</small></span><em class="series-status-${escapeHtml(item.status)}">${escapeHtml(item.status)} · ${escapeHtml(item.assessment_status)}${archiveLabel}</em></summary><div class="experiment-series-assessment"><div class="experiment-series-kpis"><span><small>Erfolgreich</small><strong>${Number(item.completed || 0)}</strong></span><span><small>Fehlgeschlagen</small><strong>${Number(item.failed || 0)}</strong></span><span><small>Ticks</small><strong>${escapeHtml(item.requested_ticks ?? "—")}</strong></span><span><small>Seeds</small><strong>${escapeHtml(item.seeds ?? "—")}</strong></span></div><p>${escapeHtml(item.assessment_boundary || "Technische Bewertung; Human Review erforderlich.")}</p><ul class="experiment-series-results">${resultRows}</ul><div class="experiment-series-actions">${reportButton}${archiveAction}</div></div></details>`;
   }
 
+  _ensurePosthocEvaluationDialog() {
+    let dialog = byId("workflow-posthoc-evaluation-dialog");
+    if (dialog) return dialog;
+    dialog = document.createElement("dialog");
+    dialog.id = "workflow-posthoc-evaluation-dialog";
+    dialog.className = "posthoc-evaluation-dialog";
+    dialog.innerHTML = `
+      <header class="posthoc-evaluation-header"><div><span class="workspace-kicker">POST-HOC INTERPRETATION</span><h3>Wissenschaftliche Auswertung</h3><p id="posthoc-evaluation-context"></p></div><button type="button" id="posthoc-evaluation-close" class="icon-btn" aria-label="Auswertung schließen">×</button></header>
+      <div class="posthoc-evaluation-boundary"><strong>Nachgelagerte Auswertung</strong><span>Diese Antwort verändert weder den Lauf noch den EVID-Status. Sie wird als Interpretation gespeichert und benötigt für wissenschaftliche Verwendung einen separaten Human-Review-/EVID-Workflow.</span></div>
+      <div class="posthoc-evaluation-form">
+        <label>Auswertende Person<input id="posthoc-evaluation-evaluator" type="text" required placeholder="Name / Verantwortliche Person"></label>
+        <label>Antwort auf die Hypothese<select id="posthoc-evaluation-answer"><option value="supported">unterstützt</option><option value="refuted">widerlegt</option><option value="mixed">gemischt / teilweise</option><option value="inconclusive">nicht entscheidbar</option><option value="not_assessed">noch nicht bewertet</option></select></label>
+        <label class="posthoc-evaluation-wide">Wissenschaftliche Auswertung<textarea id="posthoc-evaluation-text" rows="8" required placeholder="Welche Auswertung beantwortet die Hypothese? Beziehe dich auf registrierte Outcomes, Kontrollen, Seeds und die beobachteten Daten."></textarea></label>
+        <label class="posthoc-evaluation-wide">Beobachtungen und Auswertungskriterien<textarea id="posthoc-evaluation-observations" rows="5" placeholder="Welche Messwerte, Vergleiche oder Artefakte tragen die Antwort?"></textarea></label>
+        <label class="posthoc-evaluation-wide">Limitationen und Alternativerklärungen<textarea id="posthoc-evaluation-limitations" rows="5" placeholder="Welche Unsicherheiten, fehlenden Kontrollen oder alternativen Erklärungen bleiben offen?"></textarea></label>
+        <label class="posthoc-evaluation-wide">Nächste Schritte für die wissenschaftliche Arbeit<textarea id="posthoc-evaluation-follow-up" rows="5" placeholder="Welche Replikation, Kontrolle, Abbildung oder Textpassage soll daraus entstehen?"></textarea></label>
+      </div>
+      <footer class="posthoc-evaluation-actions"><span id="posthoc-evaluation-status" role="status"></span><button type="button" id="posthoc-evaluation-open" class="btn-secondary" disabled>Im File Viewer öffnen</button><button type="button" id="posthoc-evaluation-save" class="btn-primary">Auswertung speichern</button></footer>`;
+    document.body.append(dialog);
+    if (!document.getElementById("posthoc-evaluation-style")) {
+      const style = document.createElement("style");
+      style.id = "posthoc-evaluation-style";
+      style.textContent = `.posthoc-evaluation-dialog{width:min(94vw,880px);max-height:92vh;padding:0;border:1px solid var(--rule-3);border-radius:var(--r-md);background:var(--paper);color:var(--ink);box-shadow:var(--shadow-float)}.posthoc-evaluation-dialog::backdrop{background:rgba(20,16,12,.58);backdrop-filter:blur(4px)}.posthoc-evaluation-header{display:flex;justify-content:space-between;gap:12px;padding:14px 16px;border-bottom:1px solid var(--rule);background:var(--paper-2)}.posthoc-evaluation-header h3{margin:3px 0;font-size:1.05rem}.posthoc-evaluation-header p{margin:0;color:var(--ink-3);font-size:.7rem}.posthoc-evaluation-boundary{margin:12px 16px;padding:9px 11px;border-left:3px solid var(--amber);background:var(--amber-wash);font-size:.7rem;line-height:1.45}.posthoc-evaluation-boundary strong{display:block}.posthoc-evaluation-form{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:10px;padding:0 16px 12px;overflow:auto}.posthoc-evaluation-form label{display:grid;gap:5px;color:var(--ink-3);font-size:.68rem}.posthoc-evaluation-form input,.posthoc-evaluation-form select,.posthoc-evaluation-form textarea{width:100%;padding:7px;border:1px solid var(--rule-2);border-radius:var(--r-xs);background:var(--paper-2);color:var(--ink);font:inherit}.posthoc-evaluation-form textarea{resize:vertical;line-height:1.45}.posthoc-evaluation-wide{grid-column:1/-1}.posthoc-evaluation-actions{display:flex;align-items:center;justify-content:flex-end;gap:8px;padding:10px 16px;border-top:1px solid var(--rule);background:var(--paper-2)}.posthoc-evaluation-actions span{margin-right:auto;color:var(--ink-3);font-size:.68rem}.posthoc-evaluation-actions button:disabled{opacity:.55}@media(max-width:700px){.posthoc-evaluation-form{grid-template-columns:1fr}.posthoc-evaluation-wide{grid-column:auto}.posthoc-evaluation-actions{flex-wrap:wrap}.posthoc-evaluation-actions span{flex-basis:100%}}`;
+      document.head.appendChild(style);
+    }
+    dialog.querySelector("#posthoc-evaluation-close")?.addEventListener("click", () => dialog.close());
+    dialog.querySelector("#posthoc-evaluation-save")?.addEventListener("click", () => this._savePosthocEvaluation());
+    dialog.querySelector("#posthoc-evaluation-open")?.addEventListener("click", () => {
+      const path = dialog.dataset.markdownPath;
+      if (path) this._openArtifact(path);
+    });
+    return dialog;
+  }
+
+  async _openPosthocEvaluation(item) {
+    const dialog = this._ensurePosthocEvaluationDialog();
+    const manifest = item.manifest && typeof item.manifest === "object" ? item.manifest : {};
+    const experimentId = String(item.experiment_id || item.id || "");
+    const questions = Array.isArray(manifest.research_questions) ? manifest.research_questions : [];
+    const hypotheses = Array.isArray(manifest.hypotheses) ? manifest.hypotheses : [];
+    const researchQuestion = questions.join(", ") || manifest.research_question || "";
+    const hypothesis = hypotheses.join(", ") || manifest.hypothesis || "";
+    dialog.dataset.experimentId = experimentId;
+    dialog.dataset.researchQuestion = String(researchQuestion);
+    dialog.dataset.hypothesis = String(hypothesis);
+    dialog.dataset.markdownPath = "";
+    const set = (id, value) => { const node = byId(id); if (node) node.value = String(value ?? ""); };
+    const context = byId("posthoc-evaluation-context");
+    if (context) context.textContent = `${experimentId} · ${researchQuestion || "Forschungsfrage nicht hinterlegt"} · ${hypothesis || "Hypothese nicht hinterlegt"}`;
+    set("posthoc-evaluation-evaluator", "");
+    set("posthoc-evaluation-answer", "not_assessed");
+    set("posthoc-evaluation-text", "");
+    set("posthoc-evaluation-observations", "");
+    set("posthoc-evaluation-limitations", "");
+    set("posthoc-evaluation-follow-up", "");
+    set("posthoc-evaluation-status", "Lade vorhandene Auswertung …");
+    const openButton = byId("posthoc-evaluation-open");
+    if (openButton) openButton.disabled = true;
+    if (!dialog.open) dialog.showModal();
+    try {
+      const saved = await fetchJson(`/api/research/experiments/${encodeURIComponent(experimentId)}/evaluation`);
+      if (saved.exists) {
+        set("posthoc-evaluation-evaluator", saved.evaluator);
+        set("posthoc-evaluation-answer", saved.hypothesis_answer || "not_assessed");
+        set("posthoc-evaluation-text", saved.evaluation);
+        set("posthoc-evaluation-observations", saved.observations);
+        set("posthoc-evaluation-limitations", saved.limitations);
+        set("posthoc-evaluation-follow-up", saved.follow_up);
+        set("posthoc-evaluation-status", "Vorhandene Auswertung geladen.");
+        dialog.dataset.markdownPath = `experiments/${experimentId}/posthoc/evaluation.md`;
+        if (openButton) openButton.disabled = false;
+      } else {
+        set("posthoc-evaluation-status", "Noch keine Auswertung erfasst.");
+      }
+    } catch (error) {
+      set("posthoc-evaluation-status", `Auswertung konnte nicht geladen werden: ${error.message || error}`);
+    }
+    byId("posthoc-evaluation-evaluator")?.focus();
+  }
+
+  async _savePosthocEvaluation() {
+    const dialog = byId("workflow-posthoc-evaluation-dialog");
+    const experimentId = dialog?.dataset.experimentId;
+    if (!dialog || !experimentId) return;
+    const value = (id) => byId(id)?.value?.trim() || "";
+    const status = byId("posthoc-evaluation-status");
+    const saveButton = byId("posthoc-evaluation-save");
+    const payload = {
+      experiment_id: experimentId,
+      research_question: dialog.dataset.researchQuestion || "",
+      hypothesis: dialog.dataset.hypothesis || "",
+      evaluator: value("posthoc-evaluation-evaluator"),
+      hypothesis_answer: value("posthoc-evaluation-answer"),
+      evaluation: value("posthoc-evaluation-text"),
+      observations: value("posthoc-evaluation-observations"),
+      limitations: value("posthoc-evaluation-limitations"),
+      follow_up: value("posthoc-evaluation-follow-up"),
+    };
+    if (!payload.evaluator || !payload.evaluation) {
+      if (status) status.textContent = "Auswertende Person und wissenschaftliche Auswertung sind Pflichtfelder.";
+      return;
+    }
+    if (saveButton) { saveButton.disabled = true; saveButton.textContent = "Speichere …"; }
+    try {
+      const result = await fetchJson("/api/research/experiments/evaluation", { method: "POST", body: JSON.stringify(payload) });
+      dialog.dataset.markdownPath = result.markdown_path;
+      if (status) status.textContent = "Gespeichert; EVID bleibt unverändert.";
+      if (byId("posthoc-evaluation-open")) byId("posthoc-evaluation-open").disabled = false;
+      await this._loadExperimentCollections();
+      await this._openArtifact(result.markdown_path);
+      dialog.close();
+    } catch (error) {
+      if (status) status.textContent = `Speichern fehlgeschlagen: ${error.message || error}`;
+    } finally {
+      if (saveButton) { saveButton.disabled = false; saveButton.textContent = "Auswertung speichern"; }
+    }
+  }
+
   async _handleExperimentLibraryAction(event) {
     const button = event.target.closest?.("[data-experiment-action], [data-series-action], [data-series-report], [data-experiment-open], [data-experiment-toggle], [data-experiment-use]");
     if (!button) return;
@@ -713,6 +833,12 @@ export class ExperimentWorkflowPanel {
     const seriesId = button.dataset.seriesId;
     const seriesReport = button.dataset.seriesReport;
     const openKind = button.dataset.experimentOpen;
+    const evaluateId = button.dataset.experimentEvaluate;
+    if (evaluateId) {
+      const item = this._findExperimentDetail(evaluateId);
+      if (item) await this._openPosthocEvaluation(item);
+      return;
+    }
     if (seriesReport) {
       await this._openArtifact(seriesReport);
       return;
@@ -1006,6 +1132,7 @@ export class ExperimentWorkflowPanel {
     if (artifacts.summary) buttons.push({ kind: "summary", label: "Summary", path: artifacts.summary });
     if (artifacts.statistics) buttons.push({ kind: "statistics", label: "Statistics", path: artifacts.statistics });
     if (artifacts.data_index || artifacts.raw_run_index) buttons.push({ kind: "raw", label: "Raw Index", path: artifacts.data_index || artifacts.raw_run_index });
+    if (artifacts.posthoc_evaluation) buttons.push({ kind: "posthoc", label: "Auswertung", path: artifacts.posthoc_evaluation });
     if (!buttons.length) return;
     const group = document.createElement("span");
     group.dataset.experimentPopupActions = "true";

src/dashboard/static/frontend/index.js

@@ -35,6 +35,7 @@ import { initSmallSNNStage } from "./modules/small-snn-stage.js";
 import { initRecurrentSNNStage } from "./modules/recurrent-snn-stage.js";
 import { initWorkspaceRouter } from "./workspace-router.js";
 import { initPlayground } from "./modules/playground.js";
+import { initAccelerationIntegrationStatus } from "./modules/acceleration-integration.js";
 import { initExternalReview } from "../external-review.js";
 
 installPollingGovernor();
@@ -77,6 +78,7 @@ function init() {
   initRuntimeNeuron();
   initSmallSNNStage();
   initRecurrentSNNStage();
+  initAccelerationIntegrationStatus();
 }
 
 if (document.readyState === "loading") {

src/dashboard/static/frontend/modules/acceleration-integration.js

@@ -0,0 +1,204 @@
+"use strict";
+
+const STATUS_LABELS = {
+  integrated: "integriert",
+  software_verified: "Software verifiziert",
+  pending: "Hardware ausstehend",
+  passed: "physisch akzeptiert",
+  failed: "fehlgeschlagen",
+  blocked: "blockiert",
+  contract_draft: "Semantikvertrag in Arbeit",
+  preflight_ready: "Preflight bereit",
+  unavailable: "nicht verfügbar",
+};
+
+function escapeHtml(value) {
+  return String(value ?? "").replace(/[&<>"']/g, (character) => ({
+    "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;",
+  }[character]));
+}
+
+async function readJson(url) {
+  const response = await fetch(url, { cache: "no-store" });
+  if (!response.ok) throw new Error(`${url}: HTTP ${response.status}`);
+  return response.json();
+}
+
+function statusClass(status) {
+  if (status === "integrated" || status === "software_verified" || status === "passed") return "ok";
+  if (status === "failed" || status === "unavailable") return "bad";
+  return "pending";
+}
+
+function injectStyles() {
+  if (document.getElementById("mhrn-acceleration-integration-styles")) return;
+  const style = document.createElement("style");
+  style.id = "mhrn-acceleration-integration-styles";
+  style.textContent = `
+    .mhrn-accel-panel{margin:14px 0;padding:14px;border:1px solid var(--rule);border-radius:var(--r-md);background:var(--paper-2)}
+    .mhrn-accel-head{display:flex;justify-content:space-between;gap:16px;align-items:flex-start;margin-bottom:12px}
+    .mhrn-accel-head h3{margin:.2rem 0}.mhrn-accel-head p{margin:.2rem 0;max-width:88ch}
+    .mhrn-accel-grid{display:grid;grid-template-columns:repeat(auto-fit,minmax(190px,1fr));gap:9px}
+    .mhrn-accel-card{padding:10px;border:1px solid var(--rule);border-radius:8px;background:var(--paper)}
+    .mhrn-accel-card h4{margin:0 0 6px}.mhrn-accel-card p{margin:4px 0}
+    .mhrn-accel-state{display:inline-flex;padding:2px 7px;border-radius:999px;border:1px solid var(--rule);font-size:.78rem}
+    .mhrn-accel-state.ok{font-weight:700}.mhrn-accel-state.bad{font-weight:700}
+    .mhrn-accel-meta{display:grid;grid-template-columns:max-content 1fr;gap:4px 10px;margin-top:10px;font-size:.85rem}
+    .mhrn-accel-meta dt{font-weight:700}.mhrn-accel-meta dd{margin:0;overflow-wrap:anywhere}
+    .mhrn-accel-actions{display:flex;flex-wrap:wrap;gap:7px;margin-top:10px}
+    .mhrn-accel-boundary{padding:9px;border-left:3px solid var(--accent);background:var(--paper)}
+  `;
+  document.head.append(style);
+}
+
+function panel(id, parent, title, intro, routeTag = null) {
+  if (!parent) return null;
+  let node = document.getElementById(id);
+  if (node) return node;
+  node = document.createElement("section");
+  node.id = id;
+  node.className = "mhrn-accel-panel";
+  if (routeTag) node.dataset.mhrnRoute = routeTag;
+  node.innerHTML = `
+    <div class="mhrn-accel-head">
+      <div><span class="workspace-kicker">CUDA · FE-3</span><h3>${escapeHtml(title)}</h3><p>${escapeHtml(intro)}</p></div>
+      <button type="button" data-accel-refresh>Aktualisieren</button>
+    </div>
+    <div data-accel-body>Lade kanonischen Integrationsstatus …</div>
+  `;
+  parent.append(node);
+  return node;
+}
+
+function ensurePanels() {
+  const playgroundHost = document.getElementById("pg-mhrn-integration") || document.getElementById("tab-playground");
+  const releaseHost = document.querySelector('[data-release-view="development"]');
+  const scienceMetrics = document.getElementById("mhrn-scientific-metrics");
+  const scienceHost = scienceMetrics?.parentElement || document.getElementById("tab-research");
+  const oldHost = document.querySelector('#tab-old [data-area-overview="old"]') || document.getElementById("tab-old");
+  return {
+    playground: panel(
+      "mhrn-acceleration-playground",
+      playgroundHost,
+      "Playground → MHRN Integrationsbrücke",
+      "Welche Playground-Bausteine bereits kanonisch sind und welches Gate als Nächstes fehlt."
+    ),
+    release: panel(
+      "mhrn-acceleration-release",
+      releaseHost,
+      "CUDA / FE-3 Engineering Acceptance",
+      "Release-Sicht auf Backend-Vertrag, FE-3-Manifest und physische Hardware-Abnahme."
+    ),
+    science: panel(
+      "mhrn-acceleration-science",
+      scienceHost,
+      "Backend-Parität: Evidenzgrenze",
+      "Engineering Verification bleibt getrennt von wissenschaftlichen DATA/EVID.",
+      "science:observatory"
+    ),
+    old: panel(
+      "mhrn-acceleration-old",
+      oldHost,
+      "Archivierte Integrationsflächen",
+      "OLD bleibt funktionsfähig, ist aber kein automatischer Promotion-Pfad in den MHRN-Core."
+    ),
+  };
+}
+
+function waveMarkup(waves) {
+  return `<div class="mhrn-accel-grid">${(waves || []).map((wave) => `
+    <article class="mhrn-accel-card" data-accel-wave="${escapeHtml(wave.id)}">
+      <h4>${escapeHtml(wave.label)}</h4>
+      <span class="mhrn-accel-state ${statusClass(wave.status)}">${escapeHtml(STATUS_LABELS[wave.status] || wave.status)}</span>
+    </article>
+  `).join("")}</div>`;
+}
+
+function hardwareMarkup(acceleration) {
+  const hardware = acceleration.hardware_acceptance || {};
+  const manifest = acceleration.fe3_manifest || {};
+  const backend = acceleration.backend || {};
+  const caps = backend.capabilities || {};
+  const pan = acceleration.pan_wave5b_preflight || {};
+  return `
+    <div class="mhrn-accel-boundary"><strong>Interpretationsgrenze:</strong> ${escapeHtml(acceleration.provenance_rule)} Keine Anzeige in diesem Panel erzeugt DATA oder EVID.</div>
+    ${waveMarkup(acceleration.waves)}
+    <dl class="mhrn-accel-meta">
+      <dt>FE-3 Manifest</dt><dd>${escapeHtml(manifest.status)} · ${escapeHtml(manifest.manifest_sha256 || "—")}</dd>
+      <dt>CUDA Backend</dt><dd>${escapeHtml(backend.backend_version || backend.status || "—")}</dd>
+      <dt>Live Input</dt><dd>${caps.supports_live_external_input === true ? "ja" : "nein"}</dd>
+      <dt>Grenzen</dt><dd>${escapeHtml(caps.max_neurons || "—")} Neuronen · ${escapeHtml(caps.max_edges || "—")} Kanten · ${escapeHtml(caps.max_ticks || "—")} Ticks</dd>
+      <dt>Plasticity</dt><dd>${escapeHtml(caps.plasticity_semantics || "—")}</dd>
+      <dt>PAN Wave 5B</dt><dd>${pan.preflight_ready === true ? "Preflight bereit" : "Preflight unvollständig"} · ${pan.ready_for_execution === true ? "Ausführung freigegeben" : "Ausführung gesperrt"}</dd>
+      <dt>PAN Contract</dt><dd>${escapeHtml(pan.contract_status || "—")} · ${pan.contract_frozen === true ? "frozen" : "nicht frozen"}</dd>
+      <dt>PAN Blocker</dt><dd>${escapeHtml((pan.blockers || []).join(", ") || "keine")}</dd>
+      <dt>Hardware</dt><dd><span class="mhrn-accel-state ${statusClass(hardware.status)}">${escapeHtml(STATUS_LABELS[hardware.status] || hardware.status || "—")}</span> ${escapeHtml(hardware.gpu_identity || "")}</dd>
+      <dt>Artefakt</dt><dd>${escapeHtml(hardware.artifact || "noch kein HARDWARE_ACCEPTANCE_<date>.json")}</dd>
+      <dt>Nächstes Gate</dt><dd>${escapeHtml(acceleration.next_gate || "—")}</dd>
+    </dl>
+  `;
+}
+
+function scienceMarkup(acceleration) {
+  const hardware = acceleration.hardware_acceptance || {};
+  return `
+    <div class="mhrn-accel-boundary">
+      <strong>Kein Evidenzsprung.</strong> FE-3 und CUDA-Parität sind Engineering Verification. Selbst ein grünes physisches Artefakt wird nicht automatisch DATA/EVID.
+    </div>
+    <div class="mhrn-accel-grid">
+      <article class="mhrn-accel-card"><h4>Softwarepfad</h4><span class="mhrn-accel-state ${acceleration.software_path_closed ? "ok" : "pending"}">${acceleration.software_path_closed ? "geschlossen" : "offen"}</span></article>
+      <article class="mhrn-accel-card"><h4>Physische FE-3-Abnahme</h4><span class="mhrn-accel-state ${statusClass(hardware.status)}">${escapeHtml(STATUS_LABELS[hardware.status] || hardware.status)}</span></article>
+      <article class="mhrn-accel-card"><h4>Scientific status</h4><span class="mhrn-accel-state pending">keine DATA / keine EVID</span></article>
+    </div>
+  `;
+}
+
+function oldMarkup(catalog) {
+  const old = (catalog?.candidates || []).find((item) => item.element_id === "old_frontend_views");
+  const routes = old?.old_routes || [];
+  return `
+    <div class="mhrn-accel-boundary"><strong>OLD-Regel:</strong> Aufbewahren statt löschen. Reaktivierung erfolgt explizit; Archivansichten werden nicht stillschweigend kanonisch.</div>
+    <p><strong>${routes.length}</strong> Integrations-/Kompatibilitätsrouten sind im Promotion-Katalog ausdrücklich als OLD markiert.</p>
+    <p>${escapeHtml(routes.join(", ") || "Keine expliziten OLD-Routen gemeldet.")}</p>
+  `;
+}
+
+async function refresh(panels) {
+  const [integration, catalog] = await Promise.all([
+    readJson("/api/integration/status"),
+    readJson("/api/playground/integration"),
+  ]);
+  const acceleration = integration.acceleration;
+  if (!acceleration) throw new Error("/api/integration/status enthält keinen acceleration-Block");
+
+  if (panels.playground) panels.playground.querySelector("[data-accel-body]").innerHTML = hardwareMarkup(acceleration);
+  if (panels.release) panels.release.querySelector("[data-accel-body]").innerHTML = hardwareMarkup(acceleration);
+  if (panels.science) panels.science.querySelector("[data-accel-body]").innerHTML = scienceMarkup(acceleration);
+  if (panels.old) panels.old.querySelector("[data-accel-body]").innerHTML = oldMarkup(catalog);
+}
+
+export function initAccelerationIntegrationStatus() {
+  injectStyles();
+  const panels = ensurePanels();
+  const roots = Object.values(panels).filter(Boolean);
+  if (!roots.length) return;
+
+  document.addEventListener("click", (event) => {
+    const button = event.target.closest("[data-accel-refresh]");
+    if (button && roots.some((root) => root.contains(button))) {
+      refresh(panels).catch((error) => {
+        roots.forEach((root) => {
+          const body = root.querySelector("[data-accel-body]");
+          if (body) body.textContent = `Integrationsstatus nicht verfügbar: ${error.message || error}`;
+        });
+      });
+    }
+  });
+
+  refresh(panels).catch((error) => {
+    roots.forEach((root) => {
+      const body = root.querySelector("[data-accel-body]");
+      if (body) body.textContent = `Integrationsstatus nicht verfügbar: ${error.message || error}`;
+    });
+  });
+}

src/dashboard/static/frontend/modules/neuron-model-science.js

@@ -62,8 +62,8 @@ const FIELD_LABELS = Object.freeze({
   "neuron.enable_homeostasis": "Homeostatic regulation",
 });
 
-const ROUTE_ID = "cellmodel";
-const ROUTE = Object.freeze([ROUTE_ID, "Cell Model", "network", "view", ROUTE_ID]);
+const ROUTE_ID = "science-cellmodel";
+const ROUTE = Object.freeze([ROUTE_ID, "Wissenschaft · Cell Modell", "network", "focus", "#mhrn-neuron-model-science"]);
 const ROUTER_STORAGE_KEY = "mhrn-workspace-router-v1";
 
 const state = {
@@ -295,25 +295,25 @@ function addContextRouteButton(nav, architecture) {
   button.setAttribute("role", "tab");
   button.dataset.areaRoute = ROUTE_ID;
   button.title = "Stage 0 single-neuron model and settings";
-  button.textContent = "Cell Model";
-  const networkButton = nav.querySelector('[data-area-route="network"]');
+  button.textContent = "Wissenschaft · Cell Modell";
+  const networkButton = nav.querySelector('[data-area-route="science-network"]');
   if (networkButton?.nextSibling) nav.insertBefore(button, networkButton.nextSibling);
   else nav.appendChild(button);
-  button.addEventListener("click", () => architecture.selectRoute("science", ROUTE_ID));
+  button.addEventListener("click", () => architecture.selectRoute("old", ROUTE_ID));
 }
 
 function addOverviewRouteCard(architecture) {
-  const grid = document.querySelector('[data-area-overview="science"] .mhrn-area-route-grid');
+  const grid = document.querySelector('[data-area-overview="old"] .mhrn-area-route-grid');
   if (!grid || grid.querySelector(`[data-route-card="${ROUTE_ID}"]`)) return;
   const button = document.createElement("button");
   button.type = "button";
   button.dataset.routeCard = ROUTE_ID;
-  button.title = "Cell Model öffnen";
-  button.innerHTML = '<span>04</span><strong>Cell Model</strong>';
-  const networkCard = grid.querySelector('[data-route-card="network"]');
+  button.title = "Cell Modell öffnen";
+  button.innerHTML = '<span>W0</span><strong>Wissenschaft · Cell Modell</strong>';
+  const networkCard = grid.querySelector('[data-route-card="science-network"]');
   if (networkCard?.nextSibling) grid.insertBefore(button, networkCard.nextSibling);
   else grid.appendChild(button);
-  button.addEventListener("click", () => architecture.selectRoute("science", ROUTE_ID));
+  button.addEventListener("click", () => architecture.selectRoute("old", ROUTE_ID));
 }
 
 function ensureSettingsNavigationFallback(architecture) {
@@ -330,15 +330,15 @@ function ensureSettingsNavigationFallback(architecture) {
 
 function ensureCanonicalRoute() {
   const architecture = window.MHRNWorkspaceArchitecture;
-  const routes = architecture?.areas?.science?.routes;
+  const routes = architecture?.areas?.old?.routes;
   if (!architecture?.selectRoute || !Array.isArray(routes)) return false;
 
   if (!routes.some(([id]) => id === ROUTE_ID)) {
-    const networkIndex = routes.findIndex(([id]) => id === "network");
+    const networkIndex = routes.findIndex(([id]) => id === "science-network");
     routes.splice(networkIndex >= 0 ? networkIndex + 1 : routes.length, 0, [...ROUTE]);
   }
 
-  document.querySelectorAll('.mhrn-context-nav[data-area="science"]').forEach((nav) => {
+  document.querySelectorAll('.mhrn-context-nav[data-area="old"]').forEach((nav) => {
     addContextRouteButton(nav, architecture);
   });
   addOverviewRouteCard(architecture);
@@ -381,7 +381,7 @@ function ensureWorkbench() {
       </div>
       <div id="science-neuron-note" class="neuron-model-warning" role="note"></div>
       <div class="neuron-model-shortcuts" aria-label="Related settings">
-        <button type="button" class="btn-secondary" data-route-jump="control:parameters">Alle Parameter</button>
+        <button type="button" class="btn-secondary" data-route-jump="settings:parameters">Alle Parameter</button>
         <button type="button" class="btn-secondary" data-route-jump="settings:overview">App Settings</button>
       </div>
       <div id="science-neuron-fields" class="neuron-model-fields" aria-live="polite"></div>
@@ -419,8 +419,8 @@ function bind() {
 function restoreCellModelRouteIfRequested() {
   try {
     const saved = JSON.parse(localStorage.getItem(ROUTER_STORAGE_KEY) || "null");
-    if (saved?.area === "science" && saved?.route === ROUTE_ID) {
-      window.MHRNWorkspaceArchitecture?.selectRoute?.("science", ROUTE_ID);
+    if (saved?.area === "old" && saved?.route === ROUTE_ID) {
+      window.MHRNWorkspaceArchitecture?.selectRoute?.("old", ROUTE_ID);
     }
   } catch (_) {}
 }

src/dashboard/static/frontend/modules/playground-workspace.js

@@ -0,0 +1,859 @@
+// Guided controls share the existing Playground form and API contract.
+const $ = (id) => document.getElementById(id);
+const escape = (value) =>
+  String(value ?? "").replace(
+    /[&<>"']/g,
+    (c) =>
+      ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[
+        c
+      ],
+  );
+const groups = [
+  [
+    "Modell & Netzwerk",
+    "Zellen, Verbindungen und zeitliche Dynamik",
+    [1, 2, 3, 15],
+  ],
+  ["Lauf & Stimulus", "Eingabe, Seed und Ausführung festlegen", [4, 7]],
+  ["PAN-Kern", "Hyperzustand, Geometrie und Feedback", [5, 6]],
+  [
+    "Lernen & Closed Loop",
+    "Kanäle, Aktionen, Ziele und Kredit-Zuweisung",
+    [8, 10, 11, 12, 13, 14],
+  ],
+  ["Anwendung", "Körperhaltung, Reward-Ereignisse und Episoden", [20, 21, 22]],
+  [
+    "Operationen",
+    "Neural I/O, Live-Monitor, CUDA und Nachtlauf",
+    [9, 17, 18, 19],
+  ],
+];
+const channelFields = [
+  "pg-input-amplitudes",
+  "pg-input-frequencies",
+  "pg-input-phases",
+];
+const limits = [
+  [0, 500, 0],
+  [1, 200, 20],
+  [0, Math.PI * 2, 0],
+];
+const help = {
+  "pg-pan-feedback-threshold":
+    "Schwelle für das konfigurierte Feedback-Routing. Zusammen mit Quelle, Nichtlinearität und Sättigung betrachten.",
+  "pg-inhibitory-fraction":
+    "Anteil inhibitorischer Neuronen. Ohne GABA-Stärke entsteht daraus keine inhibitorische Wirkung.",
+  "pg-gaba-strength":
+    "Stärke der inhibitorischen Kopplung; 0 deaktiviert deren Wirkung.",
+  "pg-behavior-epsilon":
+    "Explorationswahrscheinlichkeit: 0 nutzt die bevorzugte Aktion, 1 exploriert immer.",
+  "pg-seed":
+    "Ein fester Seed macht gleiche CPU-Konfigurationen reproduzierbar. Modell- und Hardware-Parität separat prüfen.",
+  "pg-action-to-input-map":
+    "auto erzeugt die Zuordnung im Backend. Alternativ eine JSON-Matrix mit einer Zeile je Aktion eingeben.",
+  "pg-threshold-variance":
+    "Streuung der Neuronenschwellen. 0 lässt alle Schwellen identisch.",
+  "pg-tau-m-variance":
+    "Streuung der Membranzeitkonstanten. Mit identischem Seed gegen 0 vergleichen.",
+};
+
+export function initGuidedWorkspace({
+  payload,
+  presets,
+  applyPreset,
+  setValue,
+  lastResult,
+}) {
+  const root = $("playground-builder");
+  if (!root || root.dataset.guided) return;
+  root.dataset.guided = "true";
+  const style = document.createElement("style");
+  style.textContent = `
+    #playground-run .playground-analysis-card{min-width:0}#playground-run .playground-analysis-card pre{max-width:100%;overflow:auto}
+    .pg-page-intro{padding:18px 0 12px;border-bottom:1px solid var(--rule);margin-bottom:16px}.pg-page-intro h2{font-size:1.35rem;margin:0 0 6px}.pg-page-intro p{color:var(--ink-3);max-width:75ch;line-height:1.5}
+    .pg-group{margin:12px 0;border:1px solid var(--rule-2);border-radius:8px;background:var(--paper-2);overflow:hidden}.pg-group>summary{padding:16px;cursor:pointer;font-size:1rem;font-weight:650}.pg-group>summary small{display:block;font-size:.75rem;font-weight:400;color:var(--ink-3);margin:5px 0 0 18px}.pg-group-body{padding:0 12px 12px;display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:12px}.pg-group-body>*{min-width:0}.pg-group-body>.playground-card{border-top:1px solid var(--rule)}.pg-group-body>.pg-wide{grid-column:1/-1}.pg-section-reset{float:right;font-size:.65rem;padding:3px 7px}
+    #tab-playground button{cursor:pointer}#tab-playground button:disabled{opacity:.5;cursor:not-allowed}#tab-playground :focus-visible{outline:2px solid var(--accent);outline-offset:3px}
+    .pg-tools{display:flex;flex-wrap:wrap;gap:8px;margin:12px 0}.pg-tools button,.pg-page-intro button{min-height:36px;padding:7px 12px}.pg-preset-grid{max-height:360px;overflow:auto;display:grid;grid-template-columns:repeat(auto-fit,minmax(220px,1fr));gap:10px;margin:12px 0}.pg-preset-card{border:1px solid var(--rule);border-radius:6px;padding:14px;background:var(--paper-2);display:flex;flex-direction:column;gap:8px}.pg-preset-card h4,.pg-preset-card p{margin:0}.pg-preset-card p{font-size:.78rem;line-height:1.45}.pg-preset-card small{color:var(--ink-3)}.pg-preset-card button{margin-top:auto;align-self:start}.pg-preset-card[hidden]{display:none}
+    .pg-channel-wrap{grid-column:1/-1;overflow:auto}.pg-channel-table{width:100%;border-collapse:collapse;font-size:.8rem}.pg-channel-table th,.pg-channel-table td{padding:8px;border-bottom:1px solid var(--rule);text-align:left}.pg-channel-table input{width:100%;min-width:75px}.pg-channel-table td:nth-child(2) input{min-width:160px}.pg-validation{margin:12px 0;font-size:.8rem;line-height:1.6}.pg-validation a{color:var(--crimson)}.pg-warning{color:var(--amber);padding:4px 0}.pg-field-error{display:block;color:var(--crimson);font-size:.7rem;grid-column:1/-1}[aria-invalid=true]{outline:2px solid var(--crimson)!important}.pg-help{display:block;font-size:.68rem;line-height:1.4;color:var(--ink-3);grid-column:1/-1}
+    .pg-run-empty{padding:36px;border:1px dashed var(--rule-3);text-align:center;color:var(--ink-3)}.pg-config-preview{max-height:320px;overflow:auto;white-space:pre-wrap;font-size:.75rem}.pg-search{width:100%;max-width:460px;padding:10px;margin:10px 0}.pg-summary{padding:12px;border-left:3px solid var(--accent);background:var(--paper-2);line-height:1.6;font-size:.8rem}.pg-raw{margin:12px 0}.pg-raw>summary{cursor:pointer;padding:8px;font-size:.8rem}
+    @media(max-width:850px){.pg-group-body{grid-template-columns:1fr}.pg-preset-grid{grid-template-columns:1fr}.pg-group>summary{font-size:.9rem}.pg-tools button{min-height:44px}.pg-live-monitor-body{overflow:auto;max-height:75vh}.pg-live-monitor-params{overflow:auto}.playground-session{flex-wrap:wrap}}
+  `;
+  document.head.append(style);
+  const intro = (id, title, description) => {
+    const node = document.createElement("header");
+    node.className = "pg-page-intro";
+    node.innerHTML = `<h2>${title}</h2><p>${description}</p>`;
+    $(id).prepend(node);
+    return node;
+  };
+  intro(
+    "playground-builder",
+    "Experiment aufbauen",
+    "1 · Startpunkt wählen. 2 · Parameter prüfen. 3 · CPU, CUDA-Membran oder CUDA-PAN-Zustand wählen und den Lauf starten.",
+  );
+  intro(
+    "playground-run",
+    "Lauf & Auswertung",
+    "Aktivität, Netzwerk und Lernmechanismen gemeinsam betrachten. Die Diagramme zeigen den zuletzt ausgeführten oder geladenen Playground-Lauf.",
+  );
+  intro(
+    "playground-sessions",
+    "Gespeicherte Sessions",
+    "Persistierte Läufe vom lokalen Server öffnen und deren Ergebnisse vergleichen. Browser-Presets und Server-Sessions sind getrennte Speicher.",
+  );
+  intro(
+    "playground-catalog",
+    "Bausteine & Fähigkeiten",
+    "Modelle, Topologien, Lernregeln und Schnittstellen erkunden. Ein Eintrag öffnet die Erklärung und den Implementierungsstatus.",
+  );
+  const cards = new Map();
+  root.querySelectorAll("h3").forEach((h) => {
+    const n = Number(h.textContent.match(/^(\d+) ·/)?.[1]);
+    if (n) cards.set(n, h.parentElement);
+  });
+  const container = document.createElement("div");
+  container.id = "pg-groups";
+  root.querySelector(".playground-grid").before(container);
+  root.querySelectorAll("input[type=number][step]").forEach((e) => {
+    if (e.step.includes(".")) e.step = "any";
+  });
+  const defaults = new Map();
+  const controls = () =>
+    [...root.querySelectorAll("input[id],select[id],textarea[id]")].filter(
+      (e) =>
+        (e.id === "pg-user-preset-select" || !e.id.startsWith("pg-user-")) &&
+        !e.id.startsWith("pg-workspace-"),
+    );
+  const snapshot = () =>
+    Object.fromEntries(
+      controls().map((e) => [
+        e.id,
+        e.type === "checkbox" ? e.checked : e.value,
+      ]),
+    );
+  groups.forEach(([title, description, numbers], index) => {
+    const group = document.createElement("details");
+    group.className = "pg-group";
+    group.id = `pg-group-${index}`;
+    group.open = index === 0;
+    group.innerHTML = `<summary>${String.fromCharCode(65 + index)} · ${title}<small>${description}</small></summary><div class="pg-group-body"></div>`;
+    container.append(group);
+    numbers.forEach((n, position) => {
+      const card = cards.get(n);
+      if (!card) return;
+      const heading = card.querySelector("h3");
+      heading.textContent = heading.textContent.replace(
+        /^\d+ ·/,
+        `${String.fromCharCode(65 + index)}${position + 1} ·`,
+      );
+      if (n >= 17) card.classList.add("pg-wide");
+      const button = document.createElement("button");
+      button.type = "button";
+      button.className = "pg-section-reset";
+      button.textContent = "Zurücksetzen";
+      button.title = "Auf Werte des Startprofils zurücksetzen";
+      button.onclick = () => {
+        card
+          .querySelectorAll("input[id],select[id],textarea[id]")
+          .forEach((e) => {
+            if (defaults.has(e.id)) {
+              if (e.type === "checkbox") e.checked = defaults.get(e.id);
+              else e.value = defaults.get(e.id);
+            }
+          });
+        refresh();
+        remember();
+      };
+      heading.append(button);
+      group.lastElementChild.append(card);
+    });
+  });
+  root.querySelectorAll(".playground-grid").forEach((e) => {
+    if (!e.children.length) e.remove();
+  });
+  const tools = document.createElement("div");
+  tools.className = "pg-tools";
+  tools.innerHTML = `<button type="button" id="pg-workspace-expand">Alle öffnen</button><button type="button" id="pg-workspace-collapse">Alle schließen</button><button type="button" id="pg-workspace-undo" disabled>Änderung rückgängig</button><button type="button" id="pg-workspace-export">Konfiguration exportieren</button><button type="button" id="pg-workspace-import">JSON importieren</button><input type="file" id="pg-workspace-file" accept=".json,application/json" hidden>`;
+  container.before(tools);
+  const message = document.createElement("div");
+  message.id = "pg-workspace-message";
+  message.setAttribute("role", "status");
+  tools.after(message);
+  const validation = document.createElement("div");
+  validation.id = "pg-validation";
+  validation.className = "pg-validation";
+  validation.setAttribute("aria-live", "polite");
+  container.before(validation);
+  const summary = document.createElement("div");
+  summary.id = "pg-workspace-summary";
+  summary.className = "pg-summary";
+  container.before(summary);
+  $("pg-workspace-expand").onclick = () =>
+    container.querySelectorAll("details").forEach((e) => (e.open = true));
+  $("pg-workspace-collapse").onclick = () =>
+    container.querySelectorAll("details").forEach((e) => (e.open = false));
+  const history = [];
+  function remember() {
+    const current = snapshot();
+    if (JSON.stringify(current) !== JSON.stringify(history.at(-1))) {
+      history.push(current);
+      if (history.length > 30) history.shift();
+    }
+    $("pg-workspace-undo").disabled = history.length < 2;
+  }
+  $("pg-workspace-undo").onclick = () => {
+    history.pop();
+    Object.entries(history.at(-1) || {}).forEach(([id, v]) => {
+      if ($(id).type === "checkbox") $(id).checked = v;
+      else $(id).value = v;
+    });
+    refresh();
+    $("pg-workspace-undo").disabled = history.length < 2;
+  };
+  const download = (data, name) => {
+    const url = URL.createObjectURL(
+      new Blob([JSON.stringify(data, null, 2)], { type: "application/json" }),
+    );
+    const a = document.createElement("a");
+    a.href = url;
+    a.download = name;
+    a.click();
+    setTimeout(() => URL.revokeObjectURL(url), 1000);
+  };
+  $("pg-workspace-export").onclick = () => {
+    try {
+      if (!validate())
+        throw Error("Bitte zuerst die markierten Felder korrigieren.");
+      download(
+        {
+          schema: "mhrn-playground-config-v1",
+          settings: payload(),
+          controls: snapshot(),
+        },
+        "playground-config.json",
+      );
+      message.textContent =
+        "Konfiguration exportiert. Eigene Presets liegen nur im Browser-Speicher dieses Profils.";
+    } catch (e) {
+      message.textContent = e.message;
+    }
+  };
+  $("pg-workspace-import").onclick = () => $("pg-workspace-file").click();
+  $("pg-workspace-file").onchange = async (event) => {
+    try {
+      const file = event.target.files[0];
+      if (!file) return;
+      if (file.size > 1000000) throw Error("Datei ist größer als 1 MB.");
+      const data = JSON.parse(await file.text());
+      if (
+        data.schema !== "mhrn-playground-config-v1" ||
+        !data.settings ||
+        typeof data.settings !== "object" ||
+        Array.isArray(data.settings)
+      )
+        throw Error("Eine exportierte Playground-Konfiguration auswählen.");
+      const allowed = new Set(Object.keys(payload()));
+      const entries = Object.entries(data.settings);
+      if (
+        entries.some(
+          ([k, v]) =>
+            !allowed.has(k) ||
+            v === null ||
+            (!["number", "boolean", "string"].includes(typeof v) &&
+              !Array.isArray(v)),
+        )
+      )
+        throw Error(
+          "Unbekannte Felder oder ungültige Werte in der Konfiguration.",
+        );
+      if (
+        data.settings.closed_loop_preset &&
+        [...$("pg-user-preset-select").options].some(
+          (o) => o.value === data.settings.closed_loop_preset,
+        )
+      )
+        $("pg-user-preset-select").value = data.settings.closed_loop_preset;
+      if (data.controls) {
+        const known = new Map(controls().map((e) => [e.id, e]));
+        if (
+          Object.entries(data.controls).some(
+            ([id, v]) =>
+              !known.has(id) ||
+              typeof v !==
+                (known.get(id).type === "checkbox" ? "boolean" : "string"),
+          )
+        )
+          throw Error("Ungültige Formularfelder im Export.");
+        Object.entries(data.controls).forEach(([id, v]) => {
+          const e = known.get(id);
+          if (e.type === "checkbox") e.checked = v;
+          else e.value = v;
+        });
+      } else {
+        entries.forEach(([k, v]) => setValue(k, v));
+      }
+      refresh();
+      remember();
+      message.textContent =
+        "Konfiguration importiert. Hinweise und Validierung vor dem Start prüfen.";
+    } catch (e) {
+      message.textContent = `Import fehlgeschlagen: ${e.message}`;
+    } finally {
+      event.target.value = "";
+    }
+  };
+
+  const presetBox = document.createElement("details");
+  presetBox.open = true;
+  presetBox.className = "pg-raw";
+  presetBox.innerHTML =
+    '<summary>Preset-Katalog erkunden & vergleichen</summary><input class="pg-search" id="pg-workspace-preset-search" aria-label="Presets durchsuchen" placeholder="Preset suchen …"><div class="pg-preset-grid" id="pg-preset-grid"></div><pre class="pg-config-preview" id="pg-workspace-comparison" aria-live="polite"></pre>';
+  root.querySelector(".playground-preset-deck").after(presetBox);
+  const storageNote = document.createElement("p");
+  storageNote.className = "pg-help";
+  storageNote.textContent =
+    "Integrierte und Katalog-Presets kommen aus dieser Serverversion. Eigene Presets werden im localStorage dieses Browserprofils gespeichert. Exportierte JSON-Dateien können auf einem anderen Gerät importiert werden.";
+  presetBox.before(storageNote);
+  function renderPresets() {
+    const all = presets();
+    $("pg-preset-grid").innerHTML = Object.entries(all)
+      .map(
+        ([name, p]) =>
+          `<article class="pg-preset-card" data-name="${escape(name)}"><h4>${escape(p.label || name)}</h4><small>${p.source === "catalog" ? "Server-Katalog" : p.saved_at ? "Browser · eigenes Preset" : "Integriert"}</small><p>${escape(p.description)}</p>${p.expected_success != null ? `<small>Hypothese: ${escape(p.expected_success)} Erfolgsanteil · kein Messergebnis</small>` : ""}<button type="button" data-apply="${escape(name)}">Anwenden</button><button type="button" data-compare="${escape(name)}">Mit aktueller Konfiguration vergleichen</button></article>`,
+      )
+      .join("");
+    $("pg-preset-grid")
+      .querySelectorAll("[data-apply]")
+      .forEach(
+        (b) =>
+          (b.onclick = () => {
+            $("pg-user-preset-select").value = b.dataset.apply;
+            applyPreset();
+            refresh();
+            remember();
+          }),
+      );
+    $("pg-preset-grid")
+      .querySelectorAll("[data-compare]")
+      .forEach(
+        (b) =>
+          (b.onclick = () => {
+            try {
+              const current = payload(),
+                settings = all[b.dataset.compare].settings || {};
+              $("pg-workspace-comparison").textContent =
+                Object.entries(settings)
+                  .filter(
+                    ([k, v]) =>
+                      JSON.stringify(v) !== JSON.stringify(current[k]),
+                  )
+                  .map(
+                    ([k, v]) =>
+                      `${k}\n  Aktuell: ${JSON.stringify(current[k])}\n  Preset:  ${JSON.stringify(v)}`,
+                  )
+                  .join("\n\n") || "Keine abweichenden Einstellungen.";
+            } catch (e) {
+              message.textContent = e.message;
+            }
+          }),
+      );
+  }
+  $("pg-workspace-preset-search").oninput = (e) => {
+    $("pg-preset-grid")
+      .querySelectorAll("article")
+      .forEach(
+        (card) =>
+          (card.hidden = !card.textContent
+            .toLowerCase()
+            .includes(e.target.value.toLowerCase())),
+      );
+  };
+  const raw = document.createElement("details");
+  raw.className = "pg-raw";
+  raw.innerHTML = "<summary>Erweitert: Kanalwerte als JSON</summary>";
+  const channelCard = $("pg-input-amplitudes").closest("article");
+  channelCard.append(raw);
+  ["pg-input-channel-map", ...channelFields].forEach((id) =>
+    raw.append($(id).closest("label")),
+  );
+  const table = document.createElement("div");
+  table.className = "pg-channel-wrap";
+  table.innerHTML =
+    '<p class="pg-help">Automatische Neuronenzuordnung bleibt im Backend. Eigene IDs kommagetrennt eingeben. Leere Werte verwenden die Runtime-Defaults: 0 / 20 Hz / 0 rad; kurze Listen werden zyklisch wiederholt.</p><table class="pg-channel-table"><thead><tr><th>Kanal</th><th>Neuronen</th><th>Amplitude</th><th>Hz</th><th>Phase (rad)</th></tr></thead><tbody id="pg-channel-rows"></tbody></table><div class="pg-tools"><button type="button" id="pg-channel-frequency-up">Alle Frequenzen +2 Hz</button><button type="button" id="pg-channel-auto">Neuronenzuordnung automatisch</button></div>';
+  raw.before(table);
+  const arrays = () =>
+    ["pg-input-channel-map", ...channelFields].map((id) => {
+      const v = JSON.parse($(id).value);
+      if (!Array.isArray(v)) throw Error(`${id}: JSON-Liste erwartet.`);
+      return v;
+    });
+  function renderChannels() {
+    try {
+      const [map, ...vectors] = arrays();
+      const n = Number($("pg-input-channels").value);
+      if (!Number.isInteger(n) || n < 1 || n > 64) return;
+      $("pg-channel-rows").innerHTML = Array.from(
+        { length: n },
+        (_, i) =>
+          `<tr><th scope="row">${i}</th><td><input id="pg-workspace-channel-map-${i}" aria-label="Kanal ${i} Neuronen" data-channel="${i}" data-column="map" value="${escape(map[i]?.join(", ") || "")}" placeholder="Automatisch · ${escape($("pg-input-topology").value)}"></td>${vectors.map((v, j) => `<td><input id="pg-workspace-channel-${i}-${j}" type="number" required step="any" min="${limits[j][0]}" max="${limits[j][1]}" aria-label="Kanal ${i} ${["Amplitude", "Frequenz", "Phase"][j]}" data-channel="${i}" data-column="${j}" value="${escape(v.length ? v[i % v.length] : limits[j][2])}"></td>`).join("")}</tr>`,
+      ).join("");
+    } catch {
+      /* Raw JSON errors are displayed by validation. */
+    }
+  }
+  table.addEventListener("input", (e) => {
+    const input = e.target;
+    if (!input.dataset.channel) return;
+    const i = Number(input.dataset.channel),
+      col = input.dataset.column,
+      n = Number($("pg-input-channels").value);
+    try {
+      const [map, ...vectors] = arrays();
+      if (col === "map") {
+        if (
+          input.value.trim() &&
+          !/^\d+(\s*,\s*\d+)*$/.test(input.value.trim())
+        ) {
+          input.setCustomValidity(
+            "IDs als kommagetrennte ganze Zahlen eingeben.",
+          );
+          return;
+        }
+        input.setCustomValidity("");
+        while (map.length < n) map.push([]);
+        map[i] = input.value.trim() ? input.value.split(",").map(Number) : [];
+        $("pg-input-channel-map").value = JSON.stringify(map);
+      } else {
+        const j = Number(col),
+          old = vectors[j];
+        const values = Array.from({ length: n }, (_, k) =>
+          old.length ? old[k % old.length] : limits[j][2],
+        );
+        if (input.value !== "" && Number.isFinite(input.valueAsNumber)) {
+          values[i] = input.valueAsNumber;
+          $(channelFields[j]).value = JSON.stringify(values);
+        }
+      }
+    } catch (e) {
+      message.textContent = e.message;
+    }
+  });
+  $("pg-channel-frequency-up").onclick = () => {
+    try {
+      const v = arrays()[2],
+        n = Number($("pg-input-channels").value);
+      $("pg-input-frequencies").value = JSON.stringify(
+        Array.from({ length: n }, (_, i) =>
+          Math.min(200, (v.length ? v[i % v.length] : 20) + 2),
+        ),
+      );
+      refresh();
+      remember();
+    } catch (e) {
+      message.textContent = e.message;
+    }
+  };
+  $("pg-channel-auto").onclick = () => {
+    $("pg-input-channel-map").value = "[]";
+    refresh();
+    remember();
+  };
+  for (const [id, text] of Object.entries(help)) {
+    const field = $(id);
+    if (field) {
+      const note = document.createElement("small");
+      note.className = "pg-help";
+      note.id = `${id}-help`;
+      note.textContent = text;
+      field.closest("label").append(note);
+      field.setAttribute("aria-describedby", note.id);
+    }
+  }
+
+  function validate() {
+    const errors = [],
+      warnings = [];
+    root
+      .querySelectorAll("[aria-invalid]")
+      .forEach((e) => e.removeAttribute("aria-invalid"));
+    root.querySelectorAll(".pg-field-error").forEach((e) => e.remove());
+    root.querySelectorAll("input[type=number]").forEach((e) => {
+      e.setAttribute(
+        "aria-invalid",
+        String(
+          !e.validity.valid ||
+            e.value === "" ||
+            !Number.isFinite(e.valueAsNumber),
+        ),
+      );
+      if (e.getAttribute("aria-invalid") === "true")
+        errors.push([
+          e.id,
+          e.getAttribute("aria-label") ||
+            e.closest("label")?.firstChild?.textContent ||
+            "Kanalwert",
+          e.validationMessage || "Eine endliche Zahl eingeben.",
+        ]);
+    });
+    root.querySelectorAll("[data-column=map]").forEach((e) => {
+      if (!e.validity.valid)
+        errors.push([e.id, "Neuronenzuordnung", e.validationMessage]);
+    });
+    const value = (id) => Number($(id)?.value),
+      enabled = (id) => $(id)?.checked;
+    try {
+      const [map, ...vectors] = arrays(),
+        n = value("pg-input-channels");
+      vectors.forEach((v, j) => {
+        if (
+          v.length > n ||
+          v.some(
+            (x) =>
+              typeof x !== "number" ||
+              !Number.isFinite(x) ||
+              x < limits[j][0] ||
+              x > limits[j][1],
+          )
+        )
+          errors.push([
+            channelFields[j],
+            "Input-Kanäle",
+            `Maximal ${n} Werte im Bereich ${limits[j][0]} bis ${limits[j][1]}.`,
+          ]);
+      });
+      if (
+        map.length > n ||
+        map.some(
+          (row) =>
+            !Array.isArray(row) ||
+            row.some(
+              (x) => !Number.isInteger(x) || x < 0 || x >= value("pg-neurons"),
+            ),
+        )
+      )
+        errors.push([
+          "pg-input-channel-map",
+          "Neuronenzuordnung",
+          "Nur gültige Neuronen-IDs und maximal eine Gruppe je Kanal verwenden.",
+        ]);
+      if (map.length)
+        warnings.push(
+          "Eigene Neuronenzuordnung aktiv: leere Zeilen enthalten keine Neuronen. Mit ‚automatisch‘ zur Topologie-Zuordnung zurückkehren.",
+        );
+    } catch (e) {
+      errors.push(["pg-input-amplitudes", "Input-Kanäle", e.message]);
+    }
+    for (const id of [
+      "pg-target-cue-channel",
+      "pg-reward-cue-channel",
+      "pg-reward-channel",
+      "pg-action-feedback-channel",
+      "pg-posture-score-channel",
+      "pg-reward-event-channel",
+    ]) {
+      if (value(id) >= value("pg-input-channels"))
+        errors.push([
+          id,
+          "Kanalzuordnung",
+          `Kanal muss kleiner als ${value("pg-input-channels")} sein.`,
+        ]);
+    }
+    if (enabled("pg-posture-reward-enabled") && !enabled("pg-sandbox-enabled"))
+      warnings.push(
+        "Posture Reward ist aktiv, aber die Stick-Figure Sandbox ist nicht gekoppelt.",
+      );
+    if (value("pg-inhibitory-fraction") > 0 && value("pg-gaba-strength") === 0)
+      warnings.push(
+        "Inhibitorischer Anteil ohne GABA-Stärke: die inhibitorische Kopplung bleibt wirkungslos.",
+      );
+    if (
+      enabled("pg-action-loop-enabled") &&
+      !$("pg-action-to-input-map").value.trim()
+    )
+      errors.push([
+        "pg-action-to-input-map",
+        "Aktions-Loop",
+        "auto oder eine gültige Action → Input Map eingeben.",
+      ]);
+    if (
+      enabled("pg-reward-enabled") &&
+      $("pg-target-encoding").value !== "none" &&
+      value("pg-target-cue-channel") === value("pg-reward-channel")
+    )
+      warnings.push(
+        "Ziel und Reward verwenden denselben Kanal. Signale können sich überlagern.",
+      );
+    if (
+      enabled("pg-action-loop-enabled") &&
+      $("pg-target-encoding").value !== "none" &&
+      value("pg-action-feedback-channel") === value("pg-target-cue-channel")
+    )
+      warnings.push("Action-Feedback und Ziel-Cue verwenden denselben Kanal.");
+    if (value("pg-execution-low") >= value("pg-execution-high"))
+      errors.push([
+        "pg-execution-low",
+        "PAN Runtime",
+        "θ low muss kleiner als θ high sein.",
+      ]);
+    if (!errors.length) {
+      try {
+        payload();
+      } catch (e) {
+        errors.push(["pg-action-to-input-map", "Konfiguration", e.message]);
+      }
+    }
+    errors.forEach(([id, , text]) => {
+      const field = $(id);
+      if (field) {
+        field.setAttribute("aria-invalid", "true");
+        const note = document.createElement("small");
+        note.className = "pg-field-error";
+        note.textContent = text;
+        field.after(note);
+      }
+    });
+    validation.innerHTML =
+      errors
+        .map(
+          ([id, label, text]) =>
+            `<div><a href="#${id}">${escape(label)}: ${escape(text)}</a></div>`,
+        )
+        .join("") +
+      warnings
+        .map((text) => `<div class="pg-warning">Hinweis: ${escape(text)}</div>`)
+        .join("");
+    for (const id of ["pg-run", "pg-robustness", "pg-user-preset-save"]) {
+      if ($(id)) $(id).disabled = errors.length > 0;
+    }
+    summary.textContent = `${value("pg-neurons")} Neuronen · ${value("pg-edges")} Kanten · ${value("pg-ticks")} Ticks · Seed ${$("pg-seed").value} · ${$("pg-neuron-backend")?.value === "cuda_pan" ? "CUDA-Membran + PAN-Zustand" : $("pg-neuron-backend")?.value === "cuda_membrane" ? "CUDA-Membran / CPU-PAN" : "CPU-Referenz"}. ${errors.length ? `${errors.length} Eingabefehler.` : "Eingaben geprüft."} Laufzeit: noch keine belastbare Messung für diese Konfiguration. CUDA-PAN führt auch PAN-Zustand, Feedback und synaptische Regeln auf der GPU aus. Körper, Policy und übergeordnete Steuerung bleiben CPU; die Ergebnistabelle zeigt die tatsächlichen Komponenten.`;
+    return errors.length === 0;
+  }
+  validation.onclick = (e) => {
+    const a = e.target.closest("a");
+    if (a) {
+      e.preventDefault();
+      const target = $(a.hash.slice(1));
+      for (
+        let parent = target?.parentElement;
+        parent;
+        parent = parent.parentElement
+      )
+        if (parent.tagName === "DETAILS") parent.open = true;
+      target?.focus();
+    }
+  };
+  function refresh() {
+    renderChannels();
+    validate();
+  }
+  root.addEventListener("input", validate);
+  root.addEventListener(
+    "click",
+    (e) => {
+      if (
+        e.target.closest(
+          "#pg-run,#pg-robustness,#pg-live-open,#pg-night-start,#pg-cpu-determinism,#pg-cuda-compile,#pg-cuda-preflight,#pg-cuda-smoke,#pg-cuda-rng",
+        ) &&
+        !validate()
+      ) {
+        e.preventDefault();
+        e.stopImmediatePropagation();
+        validation.scrollIntoView({ block: "center" });
+      }
+    },
+    true,
+  );
+  root.addEventListener("change", (e) => {
+    if (
+      [
+        "pg-input-channels",
+        "pg-input-topology",
+        "pg-neurons",
+        ...channelFields,
+        "pg-input-channel-map",
+      ].includes(e.target.id)
+    ) {
+      if (e.target.id === "pg-input-channels") {
+        const n = Number(e.target.value);
+        if (Number.isInteger(n) && n >= 1 && n <= 64) {
+          try {
+            ["pg-input-channel-map", ...channelFields].forEach(
+              (id) =>
+                ($(id).value = JSON.stringify(
+                  JSON.parse($(id).value).slice(0, n),
+                )),
+            );
+          } catch {}
+        }
+      }
+      refresh();
+    }
+    remember();
+  });
+  root.addEventListener("click", (e) => {
+    if (
+      e.target.closest(
+        "#pg-user-preset-apply,#pg-reset,#pg-user-preset-save,#pg-user-preset-delete",
+      )
+    ) {
+      refresh();
+      renderPresets();
+      remember();
+    }
+  });
+  $("pg-user-preset-select").addEventListener("change", () => {
+    refresh();
+    remember();
+  });
+  controls().forEach((e) =>
+    defaults.set(e.id, e.type === "checkbox" ? e.checked : e.value),
+  );
+  renderPresets();
+  refresh();
+  remember();
+
+  for (const id of [
+    "pg-run-json",
+    "pg-cuda-stage-state",
+    "pg-cuda-resource-state",
+    "pg-cuda-parity-state",
+    "pg-cuda-rng-state",
+    "pg-cuda-compiler-state",
+  ]) {
+    const node = $(id);
+    if (!node) continue;
+    const detail = document.createElement("details");
+    detail.className = "pg-raw";
+    detail.innerHTML = "<summary>Technische Details / JSON</summary>";
+    node.before(detail);
+    detail.append(node);
+    if (id.startsWith("pg-cuda-")) {
+      const status = document.createElement("p");
+      status.className = "pg-summary";
+      status.setAttribute("role", "status");
+      detail.before(status);
+      const update = () => {
+        try {
+          const data = JSON.parse(node.textContent);
+          if ("passed" in data)
+            status.textContent = `${data.passed ? "Bestanden" : "Nicht bestanden"}${data.parity ? ` · D2-Abweichung ${data.parity.current_max_abs_error ?? "nicht bestimmbar"} · Wiederholung ${data.gpu_repeat_exact ? "identisch" : "abweichend"}` : ""}${data.samples ? ` · ${data.samples} RNG-Aktionen` : ""}`;
+          else if ("ptxas_available" in data)
+            status.textContent = `ptxas ${data.ptxas_available ? "verfügbar" : "fehlt"} · Treiber ${data.cuda_driver_available ? "verfügbar" : "fehlt"}. Hardware-Nachweis nur durch einen aktuellen Smoke-Test.`;
+          else if (data.ptxas)
+            status.textContent = `Register ${data.ptxas.registers ?? "—"} · Spill Store/Load ${data.ptxas.spill_store_bytes ?? "—"}/${data.ptxas.spill_load_bytes ?? "—"} Byte${"ready_for_cooperative_launch" in data ? ` · Preflight ${data.ready_for_cooperative_launch ? "bereit" : "nicht bereit"}` : ""}`;
+          else if (data.manifest)
+            status.textContent =
+              "Gate-IR und PTX erzeugt. Nächster Schritt: ptxas + Occupancy.";
+          else
+            status.textContent =
+              "Diagnose verfügbar – technische Details öffnen.";
+        } catch {
+          status.textContent = node.textContent;
+        }
+      };
+      new MutationObserver(update).observe(node, { childList: true });
+      update();
+    }
+  }
+  const runSummary = document.createElement("div");
+  runSummary.id = "pg-result-summary";
+  runSummary.className = "pg-run-empty";
+  runSummary.textContent =
+    "Noch kein Lauf. Im Builder ein Preset wählen und starten oder eine gespeicherte Session öffnen.";
+  $("pg-metrics").before(runSummary);
+  const backendTable = document.createElement("table");
+  backendTable.id = "pg-backend-components";
+  backendTable.hidden = true;
+  runSummary.after(backendTable);
+  const resultPanels = [
+    ...$("playground-run").querySelectorAll(
+      ".playground-metrics,.playground-viz-grid,.playground-analysis-grid",
+    ),
+  ];
+  resultPanels.forEach((panel) => (panel.hidden = true));
+  new MutationObserver(() => {
+    const r = lastResult();
+    resultPanels.forEach((panel) => (panel.hidden = !r?.monitors));
+    if (r) {
+      backendTable.replaceChildren();
+      backendTable.hidden = !r.execution?.components;
+      if (r.execution?.components) {
+        const caption = document.createElement("caption");
+        caption.textContent =
+          "Tatsächliche Ausführung dieses Laufs · hybrider Playground, kein vollständiges CUDA-MHRN";
+        backendTable.append(caption);
+        for (const [component, backend] of Object.entries(
+          r.execution.components,
+        )) {
+          const row = document.createElement("tr"),
+            label = document.createElement("th"),
+            value = document.createElement("td");
+          label.textContent = component.replaceAll("_", " ");
+          value.textContent = backend === "cuda" ? "GPU (CUDA)" : "CPU";
+          row.append(label, value);
+          backendTable.append(row);
+        }
+      }
+      runSummary.className = "pg-summary";
+      runSummary.textContent = !r.session_id
+        ? "Robustheitskontrollen abgeschlossen. Ergebnisse stehen in den technischen Details und im Export bereit."
+        : `Session ${r.session_id || "—"} · Seed ${r.config?.seed ?? "—"} · ${r.execution?.neuron_backend === "cuda_pan" ? "CUDA-Membran + PAN-Zustand" : r.execution?.neuron_backend === "cuda_membrane" ? "CUDA-Membran / CPU-PAN" : "CPU-Referenz"} · ${r.metrics?.total_spikes ?? 0} Spikes · explorativer Lauf, keine wissenschaftliche Evidenz.`;
+      if (r.cue_decoding?.status === "DESCRIPTIVE_ONLY") {
+        runSummary.textContent += ` Aktivitaetsdecoder: ${(r.cue_decoding.accuracy * 100).toFixed(1)} % auf ${r.cue_decoding.test_episodes} Testepisoden; ${r.cue_decoding.input_cue_control || "aligned"}. Kein Nachweis eines neuronalen Lernvorteils.`;
+      }
+      if (r.behavioral_learning) {
+        const learning = r.behavioral_learning;
+        const contexts = Object.keys(learning.context_policies || {}).length;
+        runSummary.textContent += ` Lernen: ${contexts} Reiz-Kontexte · ${learning.policy_updates || 0} Updates · ${((learning.success_fraction || 0) * 100).toFixed(1)} % Erfolg bei bewerteten Aktionen.`;
+        if (r.closed_loop?.policy_context_source) {
+          runSummary.textContent +=
+            " Kontext aus ausgesendetem Zielreiz; kein Nachweis neuronaler Reizdekodierung.";
+        }
+      }
+    }
+  }).observe($("pg-run-json"), { childList: true });
+  const runTools = document.createElement("div");
+  runTools.className = "pg-tools";
+  runTools.innerHTML =
+    '<button type="button" id="pg-result-export">Letzten Lauf exportieren</button>';
+  runSummary.after(runTools);
+  $("pg-result-export").onclick = () => {
+    const r = lastResult();
+    if (r) download(r, "playground-result.json");
+    else
+      runSummary.textContent =
+        "Zuerst einen Lauf ausführen oder eine Session laden.";
+  };
+  for (const [id, target, selector, placeholder] of [
+    [
+      "pg-workspace-session-search",
+      "pg-session-list",
+      "article",
+      "Sessions durchsuchen …",
+    ],
+    [
+      "pg-workspace-catalog-search",
+      "pg-catalog-grid",
+      "article",
+      "Bausteine durchsuchen …",
+    ],
+  ]) {
+    const search = document.createElement("input");
+    search.id = id;
+    search.className = "pg-search";
+    search.placeholder = placeholder;
+    search.setAttribute("aria-label", placeholder);
+    $(target).before(search);
+    const filter = () =>
+      $(target)
+        .querySelectorAll(selector)
+        .forEach(
+          (e) =>
+            (e.hidden = !e.textContent
+              .toLowerCase()
+              .includes(search.value.toLowerCase())),
+        );
+    search.oninput = filter;
+    new MutationObserver(filter).observe($(target), { childList: true });
+  }
+}

src/dashboard/static/frontend/modules/playground.js

@@ -1,6 +1,7 @@
 "use strict";
 
 import { apiGet, apiPost, byId } from "../core/api.js";
+import { initGuidedWorkspace } from "./playground-workspace.js";
 import { getLanguage } from "../core/i18n.js?v=i18n-fix-20260920b";
 
 let lastResult = null;
@@ -11,7 +12,7 @@ let nightPollTimer = null;
 let catalogInfoItems = new Map();
 let activeCatalogInfo = null;
 const PLAYGROUND_PRESETS_STORAGE = "mhrn.playground.presets.v1";
-const DEFAULT_PLAYGROUND_PRESET = "full_embodiment";
+const DEFAULT_PLAYGROUND_PRESET = "pan_full_balanced";
 const BUILTIN_PLAYGROUND_PRESETS = {
   izhikevich_reference: {
     label: "Izhikevich · Referenz",
@@ -123,6 +124,7 @@ function updateDefaultHints() {
     field.title = message;
     field.closest("label")?.classList.toggle("pg-non-default", changed);
   });
+  refreshCatalogOptionAvailability();
 }
 
 function injectStyles() {
@@ -142,7 +144,7 @@ function injectStyles() {
     .playground-status{padding:9px 11px;border:1px solid var(--rule);border-left:3px solid var(--rule-3);border-radius:var(--r-xs);background:var(--paper-2);color:var(--ink-2);font-size:.68rem;white-space:pre-wrap;overflow:auto}.playground-status[data-state="error"]{border-left-color:var(--crimson);color:var(--crimson)}.playground-status[data-state="ok"]{border-left-color:var(--moss);color:var(--moss)}
     .pg-live-monitor{width:min(94vw,1000px);max-height:84vh;padding:0;border:1px solid var(--rule-3);border-radius:var(--r-md);background:var(--paper);color:var(--ink);box-shadow:var(--shadow-float)}.pg-live-monitor::backdrop{background:rgba(20,16,12,.55);backdrop-filter:blur(4px)}.pg-live-monitor>header{display:flex;align-items:flex-start;justify-content:space-between;gap:10px;padding:9px 12px;border-bottom:1px solid var(--rule);background:var(--paper-2)}.pg-live-monitor>header h2{margin:0;font-size:.95rem}.pg-live-monitor>header p{margin:2px 0 0;color:var(--ink-3);font-size:.61rem}.pg-live-monitor-close{min-width:28px;padding:0}.pg-live-monitor-body{padding:9px;overflow:hidden}.pg-live-monitor-metrics{display:grid;grid-template-columns:repeat(5,minmax(0,1fr));gap:5px;margin-bottom:7px}.pg-live-monitor-metric{padding:6px;border:1px solid var(--rule);border-radius:var(--r-xs);background:var(--paper-2)}.pg-live-monitor-metric span{display:block;color:var(--ink-4);font:700 .46rem/1.1 var(--font-mono);text-transform:uppercase}.pg-live-monitor-metric strong{display:block;margin-top:3px;font:600 .7rem/1 var(--font-mono)}.pg-live-monitor-grid{display:grid;grid-template-columns:minmax(0,1.5fr) minmax(220px,1fr);gap:7px}.pg-live-monitor-panel{min-width:0;padding:7px;border:1px solid var(--rule);border-radius:var(--r-xs);background:var(--paper-2)}.pg-live-monitor-panel h3{margin:0 0 5px;padding-bottom:4px;border-bottom:1px solid var(--rule);font-size:.68rem}.pg-live-monitor-panel canvas{display:block;width:100%;height:130px;background:var(--paper);border:1px solid var(--rule)}.pg-live-monitor-params{margin:0;max-height:118px;overflow:hidden;font:500 .55rem/1.25 var(--font-mono);white-space:pre-wrap}.pg-live-monitor-actions{display:flex;flex-wrap:wrap;gap:5px;margin-top:7px}.pg-live-monitor-actions button{min-height:27px;padding:0 8px;font-size:.6rem}.pg-live-monitor-actions .pg-monitor-primary{border-color:var(--accent);background:var(--accent);color:var(--paper-2)}
     .playground-metrics{display:grid;grid-template-columns:repeat(8,minmax(0,1fr));gap:5px;margin:10px 0}.playground-metric{padding:8px 9px;border:1px solid var(--rule);border-radius:var(--r-xs);background:var(--paper-2)}.playground-metric span{display:block;color:var(--ink-4);font:700 .5rem/1.2 var(--font-mono);letter-spacing:.07em;text-transform:uppercase}.playground-metric strong{display:block;margin-top:4px;color:var(--ink);font:600 .82rem/1.1 var(--font-mono)}
-    .pg-live-monitor-visuals{display:grid;grid-template-columns:repeat(5,minmax(0,1fr));gap:5px;margin-top:7px}.pg-live-monitor-tile{display:block;width:100%;padding:5px;border:1px solid var(--rule);border-radius:var(--r-xs);background:var(--paper-2);color:var(--ink);text-align:left;cursor:pointer}.pg-live-monitor-tile:hover,.pg-live-monitor-tile:focus-visible{border-color:var(--accent);background:var(--accent-wash)}.pg-live-monitor-tile span{display:block;margin-bottom:3px;color:var(--ink-3);font:700 .47rem/1.1 var(--font-mono);text-transform:uppercase}.pg-live-monitor-tile canvas{width:100%;height:65px;background:var(--paper);border:1px solid var(--rule)}.pg-live-zoom{width:min(94vw,1100px);padding:0;border:1px solid var(--rule-3);border-radius:var(--r-md);background:var(--paper);box-shadow:var(--shadow-float)}.pg-live-zoom::backdrop{background:rgba(20,16,12,.58);backdrop-filter:blur(4px)}.pg-live-zoom header{display:flex;justify-content:space-between;align-items:center;padding:10px 13px;border-bottom:1px solid var(--rule);background:var(--paper-2)}.pg-live-zoom canvas{display:block;width:100%;height:min(70vh,600px);padding:12px;background:var(--paper)}
+    .pg-live-monitor-visuals{display:grid;grid-template-columns:repeat(5,minmax(0,1fr));gap:5px;margin-top:7px}.pg-live-monitor-tile{display:block;width:100%;padding:5px;border:1px solid var(--rule);border-radius:var(--r-xs);background:var(--paper-2);color:var(--ink);text-align:left;cursor:pointer}.pg-live-monitor-tile:hover,.pg-live-monitor-tile:focus-visible{border-color:var(--accent);background:var(--accent-wash)}.pg-live-monitor-tile span{display:block;margin-bottom:3px;color:var(--ink-3);font:700 .47rem/1.1 var(--font-mono);text-transform:uppercase}.pg-live-monitor-tile canvas{display:block;width:100%;height:65px;background:var(--paper);border:1px solid var(--rule);image-rendering:auto}.pg-live-zoom{width:min(96vw,1400px);max-height:92vh;padding:0;border:1px solid var(--rule-3);border-radius:var(--r-md);background:var(--paper);box-shadow:var(--shadow-float)}.pg-live-zoom::backdrop{background:rgba(20,16,12,.66);backdrop-filter:blur(5px)}.pg-live-zoom header{display:flex;justify-content:space-between;align-items:flex-start;gap:12px;padding:10px 13px;border-bottom:1px solid var(--rule);background:var(--paper-2)}.pg-live-zoom header strong{display:block;font-size:.96rem}.pg-live-zoom header p{margin:3px 0 0;color:var(--ink-3);font-size:.62rem}.pg-live-zoom-toolbar{display:flex;flex-wrap:wrap;gap:6px;padding:8px 13px;border-bottom:1px solid var(--rule);background:var(--paper-3)}.pg-live-zoom-toolbar button{min-height:30px;padding:0 9px;border:1px solid var(--rule-2);border-radius:var(--r-xs);background:var(--paper);color:var(--ink-2);font-size:.64rem}.pg-live-zoom-toolbar button:hover,.pg-live-zoom-toolbar button:focus-visible{border-color:var(--accent);background:var(--accent-wash)}.pg-live-zoom-stage{min-height:360px;padding:12px;overflow:auto;background:var(--paper)}.pg-live-zoom canvas{display:block;width:100%;height:min(72vh,760px);min-height:360px;background:var(--paper-2);border:1px solid var(--rule);image-rendering:auto}
     .playground-viz-grid{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:10px}.playground-viz{min-height:260px}.playground-viz canvas{width:100%;height:210px;display:block}
     .playground-analysis-grid{display:grid;grid-template-columns:repeat(3,minmax(0,1fr));gap:8px;margin-top:10px}.playground-analysis-card pre{font-size:.62rem;max-height:260px;overflow:auto;white-space:pre-wrap}
     .playground-session-list{display:grid;gap:6px}.playground-session{display:flex;justify-content:space-between;gap:1rem;align-items:center;padding:9px 10px;border:1px solid var(--rule);border-radius:var(--r-xs);background:var(--paper-2)}.playground-session small{display:block;color:var(--ink-4)}
@@ -156,10 +158,26 @@ function injectStyles() {
 function optionMarkup(items, labelKey = "label") {
   return (items || []).filter((item) => item.available !== false).map((item) => {
     const label = item[labelKey] || item.name;
-    return `<option value="${item.name}" title="${item.note || ""}">${label}</option>`;
+    const executable = item.executable !== false;
+    const minimum = Number(item.min_dimensions || 0);
+    const status = executable ? "" : " · nur Katalog";
+    const note = item.note || (executable ? "Ausführbarer Playground-Referenzpfad." : "Nicht ausführbar; nur dokumentierter Katalogeintrag.");
+    return `<option value="${playgroundEscape(item.name)}" data-min-dimensions="${minimum}" data-executable="${String(executable)}" title="${playgroundEscape(note)}"${executable && !minimum ? "" : " disabled"}>${playgroundEscape(label)}${status}</option>`;
   }).join("");
 }
 
+function refreshCatalogOptionAvailability() {
+  const dimensions = Number(byId("pg-dimensions")?.value || 5);
+  ["pg-neuron-model", "pg-synapse-model", "pg-plasticity", "pg-readout", "pg-topology", "pg-stimulus"].forEach((id) => {
+    byId(id)?.querySelectorAll("option").forEach((option) => {
+      const executable = option.dataset.executable !== "false";
+      const minimum = Number(option.dataset.minDimensions || 0);
+      option.disabled = !executable || (minimum > 0 && dimensions < minimum);
+      if (minimum > 0 && dimensions < minimum) option.title = `Ausführbar ab ${minimum}D; bei ${dimensions}D nur Katalogeintrag.`;
+    });
+  });
+}
+
 function ensurePermanentBoundary(root) {
   if (byId("pg-permanent-boundary")) return;
   const boundary = document.createElement("div");
@@ -177,7 +195,7 @@ function buildPanels(root) {
     <section data-generated-panel="builder" id="playground-builder">
       <div class="pg-neutral-note"><strong>Neutraler Baukasten:</strong> Keine Modell- oder Topologieauswahl ist eine Empfehlung. <code>MHRN 5D</code> ist der Architektur-Default, weil er den nativen MHRN-Vertrag <code>(x,y,z,d4,d5)</code> verwendet — nicht weil 5D als überlegen gilt.</div>
       <section class="playground-preset-deck" aria-labelledby="pg-preset-deck-title">
-        <div class="playground-preset-copy"><div><h3 id="pg-preset-deck-title">Preset Lab</h3><p>Empfohlene Startpunkte für Izhikevich und PAN. Presets verändern nur den Playground und werden lokal auf diesem Gerät gespeichert.</p></div></div>
+        <div class="playground-preset-copy"><div><h3 id="pg-preset-deck-title">Preset Lab</h3><p>Empfohlene Startpunkte für Izhikevich und PAN. Presets verändern nur den Playground. Eigene Profile liegen im Browser; der Katalog kommt vom Server.</p></div></div>
         <div class="playground-preset-controls"><label>Profil<select id="pg-user-preset-select"></select></label><label>Eigenes Preset speichern<input id="pg-user-preset-name" type="text" placeholder="z. B. PAN · Seed 2"></label><button type="button" id="pg-user-preset-apply">Anwenden</button><button type="button" id="pg-user-preset-save">Speichern</button><button type="button" id="pg-user-preset-delete">Eigenes löschen</button><p id="pg-user-preset-description" class="playground-preset-description">Preset auswählen oder eigene Einstellungen speichern.</p></div>
       </section>
       <div class="playground-grid">
@@ -214,7 +232,7 @@ function buildPanels(root) {
           <label>Seed-Ensemble<input id="pg-ensemble" type="number" min="1" max="8" value="1"></label>
           <label><span><input id="pg-persist" type="checkbox"> Session lokal speichern</span></label>
         </article>
-        <article class="playground-card"><h3>05 · PAN-Hyperstate</h3>
+        <article class="playground-card" id="pg-pan-settings"><h3>05 · PAN-Hyperstate</h3>
           <label><span><input id="pg-pan-enabled" type="checkbox"> PAN explorativ aktivieren</span></label>
           <label>PAN-Dimensionen<input id="pg-pan-dimensions" type="number" min="5" max="32" value="5"></label>
           <label><span><input id="pg-pan-closed-loop" type="checkbox" checked> Closed Loop</span></label>
@@ -243,6 +261,7 @@ function buildPanels(root) {
           <label>Clock<select id="pg-clock-mode"><option value="continuous">Continuous</option><option value="dual">Dual · Event + Continuous</option></select></label>
           <label>Base Hz<input id="pg-clock-base-hz" type="number" min="1" max="10000" value="100"></label>
           <label>Event Batch ms<input id="pg-clock-event-batch" type="number" min="0.05" max="1000" step="0.05" value="10"></label>
+          <label>Neuron-/PAN-Ausfuehrung<select id="pg-neuron-backend"><option value="cpu">CPU-Referenz</option><option value="cuda_membrane">CUDA FP64 · Membran (PAN/Koerper auf CPU)</option><option value="cuda_pan">CUDA FP64 · PAN + synaptische Regeln (Koerper/Policy/Steuerung CPU)</option></select></label>
           <label>Execution<select id="pg-execution-mode"><option value="HYBRID_AUTO">HYBRID_AUTO</option><option value="EVENT_ONLY">EVENT_ONLY</option><option value="TICK_ONLY">TICK_ONLY</option></select></label>
           <label>Initial Engine<select id="pg-execution-initial"><option value="EVENT_ONLY">EVENT_ONLY</option><option value="TICK_ONLY">TICK_ONLY</option></select></label>
           <label>θ high<input id="pg-execution-high" type="number" min="0" max="1" step="0.01" value="0.30"></label>
@@ -276,7 +295,7 @@ function buildPanels(root) {
           <label><span><input id="pg-cortical-plasticity" type="checkbox" checked> Layer-Gain plastisch</span></label>
           <label>Layer Lernrate<input id="pg-cortical-lr" type="number" min="0" max="1" step="0.005" value="0.01"></label>
           <label><span><input id="pg-behavior-enabled" type="checkbox"> Verhalten lernen</span></label>
-          <label>Aktionen<input id="pg-behavior-actions" type="number" min="2" max="16" value="4"></label>
+          <label>Aktionen<input id="pg-behavior-actions" type="number" min="1" max="16" value="4"></label>
           <label>Zielaktion<input id="pg-behavior-target" type="number" min="0" max="15" value="0"></label>
           <label>Zielmodus<select id="pg-behavior-target-mode"><option value="cycle">cycle</option><option value="fixed">fixed</option></select></label>
           <label>Min. Aktivität<input id="pg-behavior-min-activity" type="number" min="0" max="1" step="0.01" value="0.01"></label>
@@ -318,7 +337,7 @@ function buildPanels(root) {
           <label><span><input id="pg-action-loop-enabled" type="checkbox"> Aktions-Loop aktiv</span></label>
           <label>Loop Delay<input id="pg-action-loop-delay" type="number" min="1" max="64" value="1"></label>
           <label>Persistenz<input id="pg-action-persistence" type="number" min="1" max="128" value="1"></label>
-          <label>Aktionsraum<input id="pg-action-space-size" type="number" min="2" max="32" value="4"></label>
+          <label>Aktionsraum<input id="pg-action-space-size" type="number" min="1" max="32" value="4"></label>
           <label>Action → Input Map<input id="pg-action-to-input-map" value="auto"></label>
           <label>Kopplungsstärke<input id="pg-action-coupling" type="number" min="0" max="10" step="0.1" value="0"></label>
           <label>Aktionsrauschen<input id="pg-action-noise" type="number" min="0" max="1" step="0.01" value="0"></label>
@@ -328,6 +347,7 @@ function buildPanels(root) {
           <label>Sandbox Sensor Noise<input id="pg-sandbox-sensor-noise" type="number" min="0" max="1" step="0.01" value="0.05"></label>
         </article>
         <article class="playground-card"><h3>12 · Ziel-Kodierung</h3>
+          <label>Cue-Kontrolle<select id="pg-target-cue-control"><option value="aligned">Zielreiz passend</option><option value="randomized">Zielreiz unabhaengig randomisiert</option><option value="absent">Zielreiz entfernt</option></select></label>
           <label>Kodierung<select id="pg-target-encoding"><option value="none">none</option><option value="one_hot">one_hot</option><option value="rate">rate</option><option value="population_latency">population_latency</option></select></label>
           <label>Ziel sichtbar (Ticks)<input id="pg-target-persistence" type="number" min="1" max="256" value="1"></label>
           <label>Ziel-Cue Strom<input id="pg-target-cue-current" type="number" min="0" max="500" step="0.5" value="0"></label>
@@ -366,20 +386,41 @@ function buildPanels(root) {
         </article>
       </div>
       <div class="playground-actions"><button type="button" class="primary" id="pg-run">▶ Playground starten</button><button type="button" id="pg-robustness">Robustheitskontrollen</button><button type="button" id="pg-reset">Standardwerte</button></div>
-      <article class="playground-card playground-live-launcher"><h3>17 · PAN Live Monitor</h3><p>Die laufende PAN-Session mit Start/Pause, Input, Sandbox-Männchen und allen Live-Grafiken im Monitor-Popup.</p><div class="playground-actions"><button type="button" class="primary" id="pg-live-open">Live Monitor öffnen</button><button type="button" id="pg-live-clear">Temporäre Sessions löschen</button></div><pre id="pg-live-state">Keine Live-Session geöffnet.</pre></article>
-      <article class="playground-card"><h3>18 · CUDA & Parität</h3>
+      <article class="playground-card playground-live-launcher" id="pg-pan-live-monitor"><h3>17 · PAN Live Monitor</h3><p>Die laufende PAN-Session mit Start/Pause, Input, Sandbox-Männchen und allen Live-Grafiken im Monitor-Popup.</p><div class="playground-actions"><button type="button" class="primary" id="pg-live-open">Live Monitor öffnen</button><button type="button" id="pg-live-clear">Temporäre Sessions löschen</button></div><pre id="pg-live-state">Keine Live-Session geöffnet.</pre></article>
+      <article class="playground-card" id="pg-cuda-controls"><h3>18 · CUDA & Parität</h3>
         <div class="playground-grid">
           <label>Target SM<input id="pg-cuda-target-sm" value="sm_86"></label>
           <label>PTX Version<input id="pg-cuda-ptx-version" value="7.1"></label>
+          <label>GPU Neuronen<input id="pg-cuda-neurons" type="number" min="1" max="12288" value="256"></label>
+          <label>Blockgröße<select id="pg-cuda-block-size"><option>32</option><option selected>64</option><option>128</option><option>256</option><option>512</option></select></label>
+          <label>Device<input id="pg-cuda-device" type="number" min="0" value="0"></label>
+          <label>RNG Samples<input id="pg-cuda-rng-samples" type="number" min="1" max="4096" value="1000"></label>
           <label><span><input id="pg-freeze-actions" type="checkbox"> Actions einfrieren</span></label>
           <label><span><input id="pg-freeze-rewards" type="checkbox"> Rewards einfrieren</span></label>
           <label>Referenz-Commit<input id="pg-parity-reference-commit" placeholder="Git SHA"></label>
         </div>
         <div class="playground-actions">
-          <button type="button" id="pg-cpu-determinism">CPU-Determinismus prüfen</button>
-          <button type="button" id="pg-cuda-compile">Builder → Gate IR / PTX</button>
+          <button type="button" id="pg-cuda-status">CUDA-Status</button>
+          <button type="button" id="pg-cpu-determinism">CPU-Determinismus</button>
+          <button type="button" id="pg-cuda-compile">Gate IR / PTX</button>
+          <button type="button" id="pg-cuda-preflight">ptxas + Occupancy</button>
+          <button type="button" class="primary" id="pg-cuda-smoke">RTX Hardware-Smoke</button>
+          <button type="button" id="pg-cuda-rng">RNG-Parität</button>
+          <button type="button" id="pg-cuda-recurrent">CUDA-1.4 · 100 Ticks / 3 Blöcke</button>
+          <button type="button" id="pg-synaptic-transfer">Synaptischer Transfer · Kontrollvergleich</button>
+          <button type="button" id="pg-cue-controls">Cue-Decoding · 6 Kontrollen</button>
+          <button type="button" id="pg-cuda-builder-parity">D3 · Builder CPU/CUDA vergleichen</button>
+          <button type="button" id="pg-cuda-plasticity">CUDA-1.5 · STP/STDP-Parität</button>
+        </div>
+        <small>D1 = exakte Spike-Ereignisse · D2 = numerische Zustandsparität · D3 = Verhaltens-/Metrikparität. CUDA-1.3 prüft den 17-Parameter-Gate-ABI gegen dieselbe CPU-Gate-Referenz. GPU-Portierung von Membran-/Adaptations-/Refractory-State, Synapsen, Delays, Plastizität und Sandbox folgt in CUDA-1.4 bis 1.6.</small>
+        <div class="playground-analysis-grid">
+          <article class="playground-analysis-card"><h3>CUDA Reifegrad</h3><pre id="pg-cuda-stage-state">Status noch nicht geladen.</pre></article>
+          <article class="playground-analysis-card"><h3>ptxas & Occupancy</h3><pre id="pg-cuda-resource-state">Noch kein Preflight.</pre></article>
+          <article class="playground-analysis-card"><h3>D2 Hardware-Parität</h3><pre id="pg-cuda-parity-state">Noch kein Hardware-Smoke.</pre></article>
+          <article class="playground-analysis-card"><h3>RNG ε-greedy</h3><pre id="pg-cuda-rng-state">Noch kein RNG-Paritätstest.</pre></article>
+          <article class="playground-analysis-card"><h3>Rekurrente Membran-Parität</h3><p>129 AdEx-Neuronen, statische Synapsen und Delays; FP64-Referenz. Noch kein vollständiger PAN-GPU-Lauf.</p><pre id="pg-cuda-recurrent-state">Noch kein Mehrtakt-Test.</pre></article>
+          <article class="playground-analysis-card"><h3>GPU-Plastizität</h3><p>STP, STDP, Eligibility und eingefrorene Reward-Folge; FP64-Referenz. Der Live-Regelkreis ist ein separater Schritt.</p><pre id="pg-cuda-plasticity-state">Noch kein Plastizitätstest.</pre><p>Builder-D3: echte Aktionen und Koerpertrajektorie; Membran auf GPU, Synapsen und Umwelt auf CPU.</p><pre id="pg-cuda-builder-parity-state">Noch kein Builder-Vergleich.</pre><p>Cue-Experiment: passend / randomisiert / entfernt, jeweils mit und ohne Pair-STDP. Ohne Policy-Strom und Koerperrueckkopplung; kein automatischer Lernnachweis.</p><pre id="pg-cue-controls-state">Noch kein Cue-Experiment.</pre><p id="pg-transfer-summary">Transfer: vortrainierte Gewichte gegen frische Initialisierung auf neuen Cue-Kanaelen. Alle anderen Zustaende werden zurueckgesetzt.</p><details><summary>Transfer-Protokoll und Decoder-Kurven</summary><pre id="pg-transfer-state" style="max-height:360px;overflow:auto">Noch kein Transfer-Vergleich.</pre></details></article>
         </div>
-        <small>D1 = exakte Spike-Ereignisse · D2 = numerische Zustandsparität · D3 = Verhaltens-/Metrikparität. CUDA-Codegen ist vorhanden, ein echter GPU-Kernel-Launch ist hier noch nicht nachgewiesen.</small>
         <pre id="pg-cuda-compiler-state">Noch kein CUDA-/Parity-Lauf.</pre>
       </article>
       <article class="playground-card"><h3>19 · Meta-Nachtlauf</h3>
@@ -431,6 +472,7 @@ function buildPanels(root) {
     <section data-generated-panel="run" id="playground-run">
       <div class="playground-metrics" id="pg-metrics"></div>
       <div class="playground-viz-grid">
+        <article class="playground-viz" id="pg-run-sandbox-panel" hidden><h3>PAN-Strichmann</h3><canvas id="pg-run-sandbox-canvas" width="800" height="360"></canvas><input id="pg-run-sandbox-frame" style="width:100%" type="range" min="0" max="0" value="0" aria-label="Strichmann-Zeitschritt"><p id="pg-run-sandbox-summary" aria-live="polite"></p><details><summary>Technische Frame-Daten</summary><pre id="pg-run-sandbox-state" style="max-height:240px;overflow:auto"></pre></details></article>
         <article class="playground-viz"><h3>Spike Raster</h3><canvas id="pg-raster" width="800" height="300"></canvas></article>
         <article class="playground-viz"><h3>Population Rate</h3><canvas id="pg-rate-canvas" width="800" height="300"></canvas></article>
         <article class="playground-viz"><h3>Topologie · neutrale 2D-Projektion</h3><canvas id="pg-topology-canvas" width="800" height="300"></canvas></article>
@@ -522,6 +564,7 @@ function formPayload() {
     clock_mode: byId("pg-clock-mode").value,
     clock_base_hz: Number(byId("pg-clock-base-hz").value),
     clock_event_batch_ms: Number(byId("pg-clock-event-batch").value),
+    neuron_backend: byId("pg-neuron-backend").value,
     execution_mode: byId("pg-execution-mode").value,
     execution_initial_mode: byId("pg-execution-initial").value,
     execution_theta_high: Number(byId("pg-execution-high").value),
@@ -644,6 +687,7 @@ function formPayload() {
     frozen_reward_sequence: lastResult?.closed_loop?.reward_history||[],
     parity_reference_source: "CPU_PYTHON_PLAYGROUND",
     parity_reference_commit: byId("pg-parity-reference-commit")?.value?.trim()||"",
+    target_cue_control: byId("pg-target-cue-control").value,
     target_encoding: byId("pg-target-encoding").value,
     target_persistence: Number(byId("pg-target-persistence").value),
     target_cue_current: Number(byId("pg-target-cue-current").value),
@@ -720,14 +764,21 @@ function renderResult(result){
   byId("pg-analysis-spike").textContent=JSON.stringify(a.spike_time||{},null,2);
   byId("pg-analysis-network").textContent=JSON.stringify({network:net,dimensionality:dim,ensemble:result.ensemble||null,pan:result.pan||null,closed_loop:result.closed_loop||null,heterogeneity:result.heterogeneity||null,temporal_dynamics:result.temporal_dynamics||null,geometry:result.geometry||null,gates:result.gates||null,clock:result.clock||null,execution:result.execution||null,growth:result.growth||null,storage:result.storage||null},null,2);
   byId("pg-analysis-plasticity").textContent=JSON.stringify({plasticity:a.plasticity||{},performance:a.performance||{},pan:result.pan||null,growth:result.growth||null,behavioral_learning:result.behavioral_learning||null,credit_assignment:result.credit_assignment||null,closed_loop:result.closed_loop||null,thalamic_gating:result.thalamic_gating||null,cortical_organization:result.cortical_organization||null,storage:result.storage||null,hardware:result.hardware||null},null,2);
-  byId("pg-analysis-io").textContent=JSON.stringify({neural_io:result.neural_io||{status:"disabled"},interfaces:result.interfaces||null},null,2);
+  byId("pg-analysis-io").textContent=JSON.stringify({neural_io:result.neural_io||{status:"disabled"},cue_decoding:result.cue_decoding||null,interfaces:result.interfaces||null},null,2);
   byId("pg-run-json").textContent=JSON.stringify({session_id:result.session_id,manifest:result.manifest,model:result.model,config:result.config,metrics:result.metrics,readout:result.readout},null,2);
+  const sandboxPanel=byId("pg-run-sandbox-panel"),sandboxSlider=byId("pg-run-sandbox-frame");
+  sandboxPanel.hidden=!result.sandbox?.world;
+  const frames=result.sandbox?.frames||[];
+  sandboxSlider.max=String(Math.max(0,frames.length-1));sandboxSlider.value=sandboxSlider.max;
+  const renderSandboxFrame=()=>{const frame=frames[Number(sandboxSlider.value)]||result.sandbox?.world;drawLiveSandbox(frame,"pg-run-sandbox-canvas");byId("pg-run-sandbox-summary").textContent=`Schritt ${Math.max(1,(result.sandbox?.ticks||frames.length)-frames.length+Number(sandboxSlider.value)+1)} / ${result.sandbox?.ticks||frames.length} · Haltung ${(Number(frame?.posture_score||0)*100).toFixed(1)} % · Aktion ${frame?.pan_action??"keine"} · Reward ${Number(frame?.reward||0).toFixed(3)}${frame?.terminal?` · ${frame.terminal}`:""}`;byId("pg-run-sandbox-state").textContent=JSON.stringify({backend:result.sandbox?.backend,ticks:result.sandbox?.ticks,dt_seconds:result.sandbox?.dt_seconds,posture_credit_updates:result.sandbox?.posture_credit_updates,frame},null,2);};
+  sandboxSlider.oninput=renderSandboxFrame;
+  if(!sandboxPanel.hidden)renderSandboxFrame();
   drawRaster(result);drawSeries("pg-rate-canvas",(result.monitors?.tick_spike_counts||[]).map(Number));drawTopology(result);drawState(result);drawSpectrum(result);drawDegree(result);
 }
 
 
-function drawLiveSandbox(world){
-  const item=ctxFor("pg-live-sandbox-canvas");if(!item||!world?.joints)return;
+function drawLiveSandbox(world,canvasId="pg-live-sandbox-canvas"){
+  const item=ctxFor(canvasId);if(!item||!world?.joints)return;
   const{canvas,ctx}=item;
   const px=p=>[canvas.width/2+Number(p.x||0)*170,canvas.height-30-Number(p.y||0)*150];
   const links=[["head","neck"],["neck","hip"],["neck","shoulder_l"],["neck","shoulder_r"],["hip","knee_l"],["hip","knee_r"],["knee_l","foot_l"],["knee_r","foot_r"]];
@@ -738,12 +789,36 @@ function drawLiveSandbox(world){
 let liveMonitorHistory=[];
 let liveMonitorPaused=false;
 let liveMonitorWorld=null;
+let liveZoomKind=null;
+let liveUpdateFactor=1;
+let liveStepBusy=false;
+let liveVisualFrame=0;
+let pendingLivePayload=null;
+let liveMonitorTopology=null;
+let liveTopologyRefreshCounter=0;
+
+function prepareLiveTileCanvases(root){
+  root.querySelectorAll(".pg-live-monitor-tile canvas").forEach(canvas=>{canvas.width=880;canvas.height=480;canvas.dataset.pgLiveHiDpi="true";});
+}
+
+function resizeLiveZoomCanvas(){
+  const canvas=byId("pg-live-zoom-canvas");if(!canvas)return;
+  const bounds=canvas.getBoundingClientRect();const ratio=Math.min(2,window.devicePixelRatio||1);const width=Math.max(640,Math.round(bounds.width*ratio));const height=Math.max(360,Math.round(bounds.height*ratio));
+  if(canvas.width!==width||canvas.height!==height){canvas.width=width;canvas.height=height;}
+}
+
+function refreshLiveZoom(){
+  if(!liveZoomKind)return;
+  const dialog=byId("pg-live-zoom"),source=byId(`pg-live-tile-${liveZoomKind}`),target=byId("pg-live-zoom-canvas");if(!dialog?.open||!source||!target)return;
+  resizeLiveZoomCanvas();const ctx=target.getContext("2d");ctx.imageSmoothingEnabled=false;ctx.clearRect(0,0,target.width,target.height);ctx.drawImage(source,0,0,target.width,target.height);
+}
 
 function ensureLiveMonitor(){
   let dialog=byId("pg-live-monitor");if(dialog)return dialog;
   dialog=document.createElement("dialog");dialog.id="pg-live-monitor";dialog.className="pg-live-monitor";
   dialog.innerHTML=`<header><div><span class="workspace-kicker">PAN LIVE MONITOR</span><h2>Live-Session</h2><p id="pg-live-monitor-status">Bereit</p></div><button type="button" class="pg-live-monitor-close" aria-label="Monitor schließen">×</button></header><div class="pg-live-monitor-body"><div class="pg-live-monitor-metrics"><div class="pg-live-monitor-metric"><span>Tick</span><strong id="pg-live-monitor-tick">0</strong></div><div class="pg-live-monitor-metric"><span>Spikes</span><strong id="pg-live-monitor-spikes">0</strong></div><div class="pg-live-monitor-metric"><span>Aktion</span><strong id="pg-live-monitor-action">—</strong></div><div class="pg-live-monitor-metric"><span>Reward</span><strong id="pg-live-monitor-reward">0</strong></div><div class="pg-live-monitor-metric"><span>Engine</span><strong id="pg-live-monitor-engine">—</strong></div></div><div class="pg-live-monitor-visuals"><button class="pg-live-monitor-tile" data-pg-live-expand="reset"><span>Reset</span><canvas id="pg-live-tile-reset" width="220" height="120"></canvas></button><button class="pg-live-monitor-tile" data-pg-live-expand="figure"><span>PAN-Männchen</span><canvas id="pg-live-tile-figure" width="220" height="120"></canvas></button><button class="pg-live-monitor-tile" data-pg-live-expand="raster"><span>Spike Raster</span><canvas id="pg-live-tile-raster" width="220" height="120"></canvas></button><button class="pg-live-monitor-tile" data-pg-live-expand="rate"><span>Populationsrate</span><canvas id="pg-live-tile-rate" width="220" height="120"></canvas></button><button class="pg-live-monitor-tile" data-pg-live-expand="topology"><span>Topologie · live</span><canvas id="pg-live-tile-topology" width="220" height="120"></canvas></button><button class="pg-live-monitor-tile" data-pg-live-expand="input"><span>Input</span><canvas id="pg-live-tile-input" width="220" height="120"></canvas></button><button class="pg-live-monitor-tile" data-pg-live-expand="output"><span>Output</span><canvas id="pg-live-tile-output" width="220" height="120"></canvas></button><button class="pg-live-monitor-tile" data-pg-live-expand="membrane"><span>Membranpotential</span><canvas id="pg-live-tile-membrane" width="220" height="120"></canvas></button><button class="pg-live-monitor-tile" data-pg-live-expand="spectrum"><span>Spectrum</span><canvas id="pg-live-tile-spectrum" width="220" height="120"></canvas></button><button class="pg-live-monitor-tile" data-pg-live-expand="degree"><span>Degree</span><canvas id="pg-live-tile-degree" width="220" height="120"></canvas></button></div><div class="pg-live-monitor-grid"><section class="pg-live-monitor-panel"><h3>Aktivität / Spike-Verlauf</h3><canvas id="pg-live-monitor-chart" width="760" height="260"></canvas></section><section class="pg-live-monitor-panel"><h3>Parameter</h3><pre id="pg-live-monitor-params" class="pg-live-monitor-params">—</pre></section><section class="pg-live-monitor-panel"><h3>Session</h3><pre id="pg-live-monitor-state" class="pg-live-monitor-params">—</pre></section></div><div class="pg-live-monitor-actions"><button type="button" id="pg-live-monitor-start" class="pg-monitor-primary">Start</button><button type="button" id="pg-live-monitor-pause">Pause</button><button type="button" id="pg-live-monitor-step">+32 Ticks</button><button type="button" id="pg-live-monitor-input">Input</button><button type="button" id="pg-live-monitor-stop">Stop</button><button type="button" id="pg-live-monitor-reset">Reset Ansicht</button></div></div>`;
-  document.body.append(dialog);
+  document.body.append(dialog);prepareLiveTileCanvases(dialog);
+  const actions=dialog.querySelector(".pg-live-monitor-actions");if(actions&&!byId("pg-live-update-factor")){const scale=document.createElement("label");scale.className="pg-live-update-scale";scale.innerHTML='<span>UI-Update</span><select id="pg-live-update-factor" aria-label="Simulation steps per UI update"><option value="1">1x</option><option value="5">5x</option><option value="10">10x</option><option value="25">25x</option><option value="50">50x</option><option value="100">100x</option></select>';actions.prepend(scale);scale.querySelector("select").addEventListener("change",event=>{liveUpdateFactor=Math.max(1,Number(event.target.value)||1);updateLiveZoomState();});}
   dialog.querySelector(".pg-live-monitor-close").addEventListener("click",()=>dialog.close());
   dialog.querySelector("#pg-live-monitor-start").addEventListener("click",()=>{liveMonitorPaused=false;startLiveLoop().catch(error=>updateLiveMonitor({error:String(error.message||error)}));});
   dialog.querySelector("#pg-live-monitor-pause").addEventListener("click",()=>{liveMonitorPaused=true;stopLiveLoop();updateLiveMonitor({status:"paused"});});
@@ -765,10 +840,16 @@ function drawLiveMonitorChart(){
 const LIVE_TILE_TITLES={reset:"Live-Ansicht zurückgesetzt",figure:"PAN-Männchen",raster:"Spike Raster",rate:"Populationsrate",topology:"Topologie",input:"Input-Kanäle",output:"Output-Aktionen",membrane:"Membranpotential",spectrum:"Spectrum",degree:"Degree-Verteilung"};
 function ensureLiveZoom(){
   if(byId("pg-live-zoom"))return;
-  const dialog=document.createElement("dialog");dialog.id="pg-live-zoom";dialog.className="pg-live-zoom";dialog.innerHTML=`<header><strong id="pg-live-zoom-title">Live-Grafik</strong><button type="button" id="pg-live-zoom-close" aria-label="Grafik schließen">×</button></header><canvas id="pg-live-zoom-canvas" width="1100" height="620"></canvas>`;document.body.append(dialog);dialog.querySelector("#pg-live-zoom-close").addEventListener("click",()=>dialog.close());
+  const dialog=document.createElement("dialog");dialog.id="pg-live-zoom";dialog.className="pg-live-zoom";dialog.innerHTML=`<header><div><span class="workspace-kicker">LIVE DETAIL VIEW</span><strong id="pg-live-zoom-title">Live-Grafik</strong><p id="pg-live-zoom-state">Bereit</p></div><button type="button" id="pg-live-zoom-close" aria-label="Grafik schließen">×</button></header><div class="pg-live-zoom-toolbar"><button type="button" id="pg-live-zoom-start">Start</button><button type="button" id="pg-live-zoom-pause">Pause</button><button type="button" id="pg-live-zoom-step">Schritt</button><button type="button" id="pg-live-zoom-input">Input senden</button><button type="button" id="pg-live-zoom-reset">Reset</button><button type="button" id="pg-live-zoom-stop">Stop</button></div><div class="pg-live-zoom-stage"><canvas id="pg-live-zoom-canvas" width="1600" height="900"></canvas></div>`;document.body.append(dialog);dialog.querySelector("#pg-live-zoom-close").addEventListener("click",()=>{liveZoomKind=null;dialog.close();});dialog.querySelector("#pg-live-zoom-start").addEventListener("click",()=>startLiveLoop().catch(error=>updateLiveZoomState(error.message)));dialog.querySelector("#pg-live-zoom-pause").addEventListener("click",()=>{stopLiveLoop();updateLiveZoomState("Pausiert");});dialog.querySelector("#pg-live-zoom-step").addEventListener("click",()=>stepLiveSession().catch(error=>updateLiveZoomState(error.message)));dialog.querySelector("#pg-live-zoom-input").addEventListener("click",()=>injectLiveInput().catch(error=>updateLiveZoomState(error.message)));dialog.querySelector("#pg-live-zoom-reset").addEventListener("click",()=>{resetForm();liveMonitorHistory=[];drawLiveMonitorVisuals({});updateLiveZoomState("Ansicht zurückgesetzt");});dialog.querySelector("#pg-live-zoom-stop").addEventListener("click",()=>stopLiveSession().catch(error=>updateLiveZoomState(error.message)));dialog.addEventListener("close",()=>{liveZoomKind=null;});window.addEventListener("resize",refreshLiveZoom);
+}
+function currentLiveUpdateFactor(){return Math.max(1,Number(byId("pg-live-update-factor")?.value)||liveUpdateFactor);}
+function updateLiveZoomState(message){const node=byId("pg-live-zoom-state");if(node)node.textContent=`${String(message||((liveMonitorPaused||!liveLoopTimer)?"Pausiert":"Läuft"))} · ${currentLiveUpdateFactor()}x UI-Update`;}
+function ensureLiveZoomScaleControl(){
+  const toolbar=byId("pg-live-zoom")?.querySelector(".pg-live-zoom-toolbar");if(!toolbar||byId("pg-live-zoom-factor"))return;
+  const label=document.createElement("label");label.textContent="UI-Update";const select=document.createElement("select");select.id="pg-live-zoom-factor";select.setAttribute("aria-label","Simulation steps per UI update");select.innerHTML='<option value="1">1x</option><option value="5">5x</option><option value="10">10x</option><option value="25">25x</option><option value="50">50x</option><option value="100">100x</option>';select.value=String(liveUpdateFactor);select.addEventListener("change",event=>{liveUpdateFactor=Math.max(1,Number(event.target.value)||1);const monitorSelect=byId("pg-live-update-factor");if(monitorSelect)monitorSelect.value=String(liveUpdateFactor);updateLiveZoomState();});label.prepend(select);toolbar.prepend(label);
 }
 function openLiveZoom(kind){
-  ensureLiveZoom();const dialog=byId("pg-live-zoom"),source=byId(`pg-live-tile-${kind}`),target=byId("pg-live-zoom-canvas");if(!dialog||!source||!target)return;byId("pg-live-zoom-title").textContent=LIVE_TILE_TITLES[kind]||kind;const ctx=target.getContext("2d");ctx.clearRect(0,0,target.width,target.height);ctx.drawImage(source,0,0,target.width,target.height);dialog.showModal();
+  ensureLiveZoom();ensureLiveZoomScaleControl();const dialog=byId("pg-live-zoom"),source=byId(`pg-live-tile-${kind}`);if(!dialog||!source)return;liveZoomKind=kind;byId("pg-live-zoom-title").textContent=LIVE_TILE_TITLES[kind]||kind;dialog.showModal();resizeLiveZoomCanvas();refreshLiveZoom();updateLiveZoomState();
 }
 function drawTileSeries(id,values,color){
   const canvas=byId(id),ctx=canvas?.getContext("2d");if(!canvas||!ctx)return;ctx.clearRect(0,0,canvas.width,canvas.height);ctx.strokeStyle=color||getComputedStyle(document.body).getPropertyValue("--accent")||"#b23a1a";ctx.lineWidth=2;ctx.beginPath();const data=values.length?values:[0];const max=Math.max(1,...data);data.forEach((value,index)=>{const x=5+index/Math.max(1,data.length-1)*(canvas.width-10);const y=canvas.height-5-(Number(value)||0)/max*(canvas.height-10);if(index===0)ctx.moveTo(x,y);else ctx.lineTo(x,y);});ctx.stroke();
@@ -779,8 +860,8 @@ function drawLiveMonitorVisuals(payload={}){
   const raster=byId("pg-live-tile-raster"),rasterCtx=raster?.getContext("2d");if(raster&&rasterCtx){rasterCtx.clearRect(0,0,raster.width,raster.height);rasterCtx.fillStyle=getComputedStyle(document.body).getPropertyValue("--accent")||"#b23a1a";spikes.slice(-160).forEach(item=>{rasterCtx.fillRect((Number(item.tick)||0)%100/100*raster.width,(Number(item.neuron_id)||0)%128/128*raster.height,2,2);});}
   const membrane=byId("pg-live-tile-membrane"),mctx=membrane?.getContext("2d");if(membrane&&mctx){mctx.clearRect(0,0,membrane.width,membrane.height);mctx.strokeStyle=getComputedStyle(document.body).getPropertyValue("--moss")||"#2f5d47";mctx.lineWidth=2;const mean=Number(payload.mean_v??-65),min=Number(payload.min_v??-70),max=Number(payload.max_v??30);const y=membrane.height-5-(mean-min)/Math.max(1,max-min)*(membrane.height-10);mctx.beginPath();mctx.moveTo(5,y);mctx.lineTo(membrane.width-5,y);mctx.stroke();}
   const inputValues=[Number(payload.input_active_neurons||0),Number(payload.input_peak||0)];drawTileSeries("pg-live-tile-input",inputValues,getComputedStyle(document.body).getPropertyValue("--accent")||"#b23a1a");drawTileSeries("pg-live-tile-output",counts.length?counts:[0],getComputedStyle(document.body).getPropertyValue("--moss")||"#2f5d47");
-  const topology=byId("pg-live-tile-topology"),tctx=topology?.getContext("2d"),topologyData=payload.topology; if(topology&&tctx){tctx.clearRect(0,0,topology.width,topology.height);const coords=topologyData?.coordinates||[],edges=topologyData?.edges||[];if(coords.length){const xs=coords.map(point=>Number(point[0]||0)),ys=coords.map(point=>Number(point[1]??point[2]??0)),minX=Math.min(...xs),maxX=Math.max(...xs),minY=Math.min(...ys),maxY=Math.max(...ys),scaleX=value=>(value-minX)/Math.max(1e-9,maxX-minX)*(topology.width-12)+6,scaleY=value=>(value-minY)/Math.max(1e-9,maxY-minY)*(topology.height-12)+6;tctx.strokeStyle=getComputedStyle(document.body).getPropertyValue("--rule-3")||"#777";tctx.globalAlpha=.25;edges.slice(0,600).forEach(edge=>{const source=coords[edge[0]],target=coords[edge[1]];if(!source||!target)return;tctx.beginPath();tctx.moveTo(scaleX(Number(source[0]||0)),scaleY(Number(source[1]??source[2]??0)));tctx.lineTo(scaleX(Number(target[0]||0)),scaleY(Number(target[1]??target[2]??0)));tctx.stroke();});tctx.globalAlpha=.9;tctx.fillStyle=getComputedStyle(document.body).getPropertyValue("--indigo")||"#2f4a7a";coords.forEach(point=>tctx.fillRect(scaleX(Number(point[0]||0))-1,scaleY(Number(point[1]??point[2]??0))-1,3,3));}}
-  if(payload.world)liveMonitorWorld=payload.world;drawLiveMonitorFigure(liveMonitorWorld,"pg-live-tile-figure");
+  if(payload.topology)liveMonitorTopology=payload.topology;const topology=byId("pg-live-tile-topology"),tctx=topology?.getContext("2d"),topologyData=payload.topology||liveMonitorTopology; if(topology&&tctx){tctx.clearRect(0,0,topology.width,topology.height);const coords=topologyData?.coordinates||[],edges=topologyData?.edges||[];if(coords.length){const xs=coords.map(point=>Number(point[0]||0)),ys=coords.map(point=>Number(point[1]??point[2]??0)),minX=Math.min(...xs),maxX=Math.max(...xs),minY=Math.min(...ys),maxY=Math.max(...ys),scaleX=value=>(value-minX)/Math.max(1e-9,maxX-minX)*(topology.width-12)+6,scaleY=value=>(value-minY)/Math.max(1e-9,maxY-minY)*(topology.height-12)+6;tctx.strokeStyle=getComputedStyle(document.body).getPropertyValue("--rule-3")||"#777";tctx.globalAlpha=.25;edges.slice(0,600).forEach(edge=>{const source=coords[edge[0]],target=coords[edge[1]];if(!source||!target)return;tctx.beginPath();tctx.moveTo(scaleX(Number(source[0]||0)),scaleY(Number(source[1]??source[2]??0)));tctx.lineTo(scaleX(Number(target[0]||0)),scaleY(Number(target[1]??target[2]??0)));tctx.stroke();});tctx.globalAlpha=.9;tctx.fillStyle=getComputedStyle(document.body).getPropertyValue("--indigo")||"#2f4a7a";coords.forEach(point=>tctx.fillRect(scaleX(Number(point[0]||0))-1,scaleY(Number(point[1]??point[2]??0))-1,3,3));}}
+  if(payload.world)liveMonitorWorld=payload.world;drawLiveMonitorFigure(liveMonitorWorld,"pg-live-tile-figure");refreshLiveZoom();
 }
 
 function drawLiveMonitorFigure(world,targetId="pg-live-tile-figure"){
@@ -792,13 +873,13 @@ function updateLiveMonitor(payload={}){
   const state=payload.state||payload;const tick=Number(state.tick??payload.tick??0);const spikes=Number(state.total_spikes??payload.total_spikes??0);const actions=payload.actions||state.actions||[];const rewards=payload.rewards||state.rewards||[];
   if(Number.isFinite(spikes)){liveMonitorHistory.push({tick,spikes});if(liveMonitorHistory.length>120)liveMonitorHistory.shift();}
   const set=(id,value)=>{const node=byId(id);if(node)node.textContent=String(value);};set("pg-live-monitor-tick",tick);set("pg-live-monitor-spikes",spikes);set("pg-live-monitor-action",actions.length?actions[actions.length-1]:"—");set("pg-live-monitor-reward",rewards.length?Number(rewards[rewards.length-1]).toFixed(3):"0");set("pg-live-monitor-engine",state.execution?.current_engine||payload.execution?.current_engine||"—");set("pg-live-monitor-status",payload.error||((liveMonitorPaused||!liveLoopTimer)?"Pausiert":"Läuft"));
-  const params={session_id:liveSessionId,tick,posture_score:payload.posture_score??payload.world?.posture_score??null,reward:payload.reward??null,reward_events:payload.reward_events||[],terminal:payload.terminal||null,pan_bias_current:byId("pg-pan-bias-current")?.value,feedback_gain:byId("pg-pan-feedback-gain")?.value,learning_rate:byId("pg-behavior-lr")?.value,epsilon:byId("pg-behavior-epsilon")?.value,edge_budget:byId("pg-edges")?.value};const paramsNode=byId("pg-live-monitor-params");if(paramsNode)paramsNode.textContent=JSON.stringify(params,null,2);const stateNode=byId("pg-live-monitor-state");if(stateNode)stateNode.textContent=JSON.stringify({state_digest:state.state_digest||payload.state_digest||null,input_queue_depth:state.input_queue_depth??payload.input_queue_depth??0,learning:state.learning||payload.learning||null},null,2);drawLiveMonitorChart();drawLiveMonitorVisuals(payload);drawLiveMonitorFigure(payload.world||state.world||null);
+  const params={session_id:liveSessionId,tick,posture_score:payload.posture_score??payload.world?.posture_score??null,reward:payload.reward??null,reward_events:payload.reward_events||[],terminal:payload.terminal||null,pan_bias_current:byId("pg-pan-bias-current")?.value,feedback_gain:byId("pg-pan-feedback-gain")?.value,learning_rate:byId("pg-behavior-lr")?.value,epsilon:byId("pg-behavior-epsilon")?.value,edge_budget:byId("pg-edges")?.value};const paramsNode=byId("pg-live-monitor-params");if(paramsNode)paramsNode.textContent=JSON.stringify(params,null,2);const stateNode=byId("pg-live-monitor-state");if(stateNode)stateNode.textContent=JSON.stringify({state_digest:state.state_digest||payload.state_digest||null,input_queue_depth:state.input_queue_depth??payload.input_queue_depth??0,learning:state.learning||payload.learning||null},null,2);pendingLivePayload=payload;if(!liveVisualFrame){liveVisualFrame=requestAnimationFrame(()=>{liveVisualFrame=0;const nextPayload=pendingLivePayload||{};pendingLivePayload=null;drawLiveMonitorChart();drawLiveMonitorVisuals(nextPayload);drawLiveMonitorFigure(nextPayload.world||(nextPayload.state||{}).world||null);});}updateLiveZoomState(payload.error);
 }
 
 async function createLiveSession(canRecover=true){
   const payload={...formPayload(),neuron_model:"pan_adex_5d",pan_enabled:true,thalamic_relay_threshold:0,pan_bias_current:Number(byId("pg-pan-bias-current").value),behavior_target_mode:byId("pg-behavior-target-mode").value};
   try{
-    const result=await apiPost("/api/playground/live/create",payload);liveSessionId=result.session_id;liveMonitorHistory=[];liveMonitorWorld=null;const monitor=ensureLiveMonitor();if(!monitor.open)monitor.showModal();byId("pg-live-state").textContent=JSON.stringify(result,null,2);updateLiveMonitor(result.state||result);
+    const result=await apiPost("/api/playground/live/create",payload);liveSessionId=result.session_id;liveMonitorHistory=[];liveMonitorWorld=null;liveMonitorTopology=null;liveTopologyRefreshCounter=0;const monitor=ensureLiveMonitor();if(!monitor.open)monitor.showModal();byId("pg-live-state").textContent=JSON.stringify(result,null,2);updateLiveMonitor(result.state||result);
   }catch(error){
     if(canRecover&&/maximum live Playground sessions reached/i.test(String(error.message||error))){await clearLiveSessions();return createLiveSession(false);}
     throw error;
@@ -817,16 +898,19 @@ async function clearLiveSessions(){
     await Promise.all(sessions.map(session=>apiPost(`/api/playground/live/${encodeURIComponent(session.session_id)}/stop`,{}).catch(()=>null)));
     result={classification:"PLAYGROUND_LIVE_SESSIONS_CLEARED",scientific_evidence:false,cleared:sessions.length,compatibility_cleanup:true};
   }
-  liveSessionId=null;liveMonitorWorld=null;liveMonitorHistory=[];
+  liveSessionId=null;liveMonitorWorld=null;liveMonitorTopology=null;liveTopologyRefreshCounter=0;liveMonitorHistory=[];
   byId("pg-live-state").textContent=JSON.stringify(result,null,2);
   const monitor=byId("pg-live-monitor");if(monitor?.open)monitor.close();
 }
 async function stepLiveSession(){
   if(!liveSessionId)throw new Error("Zuerst Live-Session starten.");
-  const result=await apiPost(`/api/playground/live/${encodeURIComponent(liveSessionId)}/step`,{ticks:32});
-  try{const sandbox=await apiPost(`/api/playground/live/${encodeURIComponent(liveSessionId)}/sandbox`,{ticks:8});result.world=sandbox.world;liveMonitorWorld=sandbox.world;}catch{}
-  try{Object.assign(result,await apiGet(`/api/playground/live/${encodeURIComponent(liveSessionId)}`));}catch{}
-  byId("pg-live-state").textContent=JSON.stringify(result,null,2);updateLiveMonitor(result);
+  if(liveStepBusy)return null;
+  liveStepBusy=true;
+  try{
+    const factor=currentLiveUpdateFactor();const includeTopology=liveMonitorTopology===null||liveTopologyRefreshCounter++%10===0;const result=await apiPost(`/api/playground/live/${encodeURIComponent(liveSessionId)}/step`,{ticks:Math.min(4096,32*factor),include_topology:includeTopology});
+    try{const sandbox=await apiPost(`/api/playground/live/${encodeURIComponent(liveSessionId)}/sandbox`,{ticks:Math.min(64,Math.max(8,8*factor))});result.world=sandbox.world;liveMonitorWorld=sandbox.world;}catch{}
+    byId("pg-live-state").textContent=JSON.stringify(result,null,2);updateLiveMonitor(result);return result;
+  } finally {liveStepBusy=false;}
 }
 async function startLiveLoop(){
   if(!liveSessionId)throw new Error("Zuerst Live-Session starten.");
@@ -924,6 +1008,92 @@ async function checkCpuDeterminism(){
   return result;
 }
 
+function cudaRequestPayload(){
+  return {
+    ...formPayload(),
+    target_sm:byId("pg-cuda-target-sm")?.value||"sm_86",
+    ptx_version:byId("pg-cuda-ptx-version")?.value||"7.1",
+    n_neurons:Number(byId("pg-cuda-neurons")?.value||256),
+    block_size:Number(byId("pg-cuda-block-size")?.value||64),
+    device_ordinal:Number(byId("pg-cuda-device")?.value||0),
+    reference_commit:byId("pg-parity-reference-commit")?.value||"",
+    rng_samples:Number(byId("pg-cuda-rng-samples")?.value||1000),
+  };
+}
+
+async function refreshCudaStatus(){
+  const node=byId("pg-cuda-stage-state");
+  if(node)node.textContent="CUDA-Laufzeit wird geprüft …";
+  const result=await apiGet("/api/playground/cuda/status");
+  if(node)node.textContent=JSON.stringify({
+    target_default:result.target_default,
+    ptxas_available:result.ptxas_available,
+    cuda_driver_available:result.cuda_driver_available,
+    cuda_driver_error:result.cuda_driver_error,
+    stages:result.stages,
+    application_cpu:result.application_cpu,
+    gpu_porting:result.gpu_porting,
+    verification:result.verification,
+  },null,2);
+  return result;
+}
+
+async function runCudaPreflight(){
+  const node=byId("pg-cuda-resource-state");
+  if(node)node.textContent="ptxas + Driver-Load + Occupancy werden geprüft …";
+  const result=await apiPost("/api/playground/cuda/preflight",cudaRequestPayload());
+  if(node)node.textContent=JSON.stringify({
+    execution_status:result.execution_status,
+    ready_for_cooperative_launch:result.ready_for_cooperative_launch,
+    ptxas:result.ptxas,
+    cooperative:result.cooperative,
+  },null,2);
+  return result;
+}
+
+async function runCudaHardwareSmoke(){
+  const node=byId("pg-cuda-parity-state");
+  if(node)node.textContent="GPU-Kernel wird zweimal ausgeführt und gegen CPU-Gate-ABI verglichen …";
+  const payload={...cudaRequestPayload(),n_neurons:Math.min(Number(byId("pg-cuda-neurons")?.value||64),4096)};
+  const result=await apiPost("/api/playground/cuda/smoke",payload);
+  const first=result.first||{},ptxas=first.ptxas||{};
+  if(node)node.textContent=JSON.stringify({
+    passed:result.passed,
+    gpu_repeat_exact:result.gpu_repeat_exact,
+    parity:result.parity,
+    launch:first.launch,
+    registers:ptxas.registers,
+    shared_bytes:ptxas.shared_bytes,
+    spill_store_bytes:ptxas.spill_store_bytes,
+    spill_load_bytes:ptxas.spill_load_bytes,
+    cleanup_contract:result.cleanup_contract,
+  },null,2);
+  const resources=byId("pg-cuda-resource-state");
+  if(resources)resources.textContent=JSON.stringify({
+    ptxas:first.ptxas||null,
+    launch:first.launch||null,
+  },null,2);
+  return result;
+}
+
+async function runCudaRngParity(){
+  const node=byId("pg-cuda-rng-state");
+  if(node)node.textContent="ε-greedy-Hashpfad wird CPU ↔ CUDA verglichen …";
+  const result=await apiPost("/api/playground/cuda/rng-parity",cudaRequestPayload());
+  if(node)node.textContent=JSON.stringify(result,null,2);
+  return result;
+}
+
+async function runCudaRecurrentParity(plasticity=false){
+  plasticity=plasticity===true;
+  const node=byId(plasticity?"pg-cuda-plasticity-state":"pg-cuda-recurrent-state");
+  node.textContent="100 Ticks mit kooperativem Grid und Delay-Ring werden geprüft …";
+  try {
+    const result=await apiPost("/api/playground/cuda/recurrent-parity",{n_neurons:129,ticks:100,block_size:64,plasticity,target_sm:byId("pg-cuda-target-sm")?.value||"sm_86"});
+    node.textContent=JSON.stringify(result,null,2);
+  } catch(error) { node.textContent=String(error.message||error); }
+}
+
 async function compileCudaGates(){
   const node=byId("pg-cuda-compiler-state");
   if(node)node.textContent="Gate-IR/PTX wird erzeugt …";
@@ -949,7 +1119,7 @@ async function runSession(){
 
 async function runRobustness(){
   const status=byId("pg-status");status.dataset.state="running";status.textContent="Explorative Robustheitskontrollen laufen …";
-  try{const result=await apiPost("/api/playground/robustness",{...formPayload(),persist:false,ensemble_runs:1});status.dataset.state="ok";status.textContent="Robustheitssuite abgeschlossen · nicht preregistriert · keine Evidenz";byId("pg-run-json").textContent=JSON.stringify(result,null,2);window.MHRNWorkspaceArchitecture?.selectRoute?.("playground","run");}
+  try{const result=await apiPost("/api/playground/robustness",{...formPayload(),persist:false,ensemble_runs:1});status.dataset.state="ok";status.textContent="Robustheitssuite abgeschlossen · nicht preregistriert · keine Evidenz";lastResult=result;byId("pg-run-json").textContent=JSON.stringify(result,null,2);window.MHRNWorkspaceArchitecture?.selectRoute?.("playground","run");}
   catch(error){status.dataset.state="error";status.textContent=`Robustheitssuite fehlgeschlagen: ${error.message||error}`;}
 }
 
@@ -962,14 +1132,16 @@ function setBuilderValue(key,value){
     pan_feedback_gain:"pan-feedback-gain",pan_feedback_nonlinearity:"pan-feedback-nonlinearity",pan_feedback_saturation:"pan-feedback-saturation",
     action_loop_enabled:"action-loop-enabled",action_loop_delay:"action-loop-delay",action_persistence:"action-persistence",action_to_input_map:"action-to-input-map",action_space_size:"action-space-size",action_coupling_strength:"action-coupling",action_noise:"action-noise",
     reward_signal_enabled:"reward-enabled",reward_magnitude:"reward-magnitude",reward_delay_ticks:"reward-delay",reward_shaping:"reward-shaping",reward_baseline:"reward-baseline",reward_decay:"reward-decay",reward_channel:"reward-channel",
-    target_encoding:"target-encoding",target_cue_channel:"target-cue-channel",target_cue_current:"target-cue-current",target_persistence:"target-persistence",target_shuffle:"target-shuffle",target_predictability:"target-predictability",
+    target_cue_control:"target-cue-control",target_encoding:"target-encoding",target_cue_channel:"target-cue-channel",target_cue_current:"target-cue-current",target_persistence:"target-persistence",target_shuffle:"target-shuffle",target_predictability:"target-predictability",
     credit_assignment:"credit-assignment",credit_window:"credit-window",eligibility_trace_tau:"eligibility-tau",td_lambda:"td-lambda",gamma_discount:"gamma-discount",
     neuron_threshold_variance:"threshold-variance",neuron_tau_m_variance:"tau-m-variance",inhibitory_fraction:"inhibitory-fraction",gaba_strength:"gaba-strength",e_i_ratio:"e-i-ratio",delay_distribution:"delay-distribution",delay_mean_ticks:"delay-mean",
     refractory_variance:"refractory-variance",adaptation_strength:"adaptation-strength",adaptation_tau:"adaptation-tau",oscillation_enabled:"oscillation-enabled",oscillation_frequency:"oscillation-frequency",
     input_topology:"input-topology",input_channels:"input-channels",input_noise_sigma:"input-noise",action_feedback_channel:"action-feedback-channel",reward_cue_channel:"reward-cue-channel",
     geometry_input_coupling:"geometry-input-coupling",geometry_input_sigma:"geometry-input-sigma",sandbox_enabled:"sandbox-enabled",sandbox_sensor_noise:"sandbox-sensor-noise",
-    neuron_model:"neuron-model",synapse_model:"synapse-model",plasticity_rule:"plasticity",topology:"topology",readout:"readout",pan_enabled:"pan-enabled",behavior_learning_enabled:"behavior-enabled",stimulus:"stimulus"
+    neuron_model:"neuron-model",synapse_model:"synapse-model",plasticity_rule:"plasticity",topology:"topology",readout:"readout",pan_enabled:"pan-enabled",behavior_learning_enabled:"behavior-enabled",stimulus:"stimulus",
+    weight_decay:"weight-decay",weight_max_clamp:"weight-max-clamp",persist:"persist",clock_mode:"clock-mode",clock_base_hz:"clock-base-hz",clock_event_batch_ms:"clock-event-batch",neuron_backend:"neuron-backend",execution_mode:"execution-mode",execution_initial_mode:"execution-initial",execution_theta_high:"execution-high",execution_theta_low:"execution-low",execution_hysteresis:"execution-hysteresis",execution_min_dwell:"execution-dwell",execution_activity_window:"execution-window",execution_transition_mode:"execution-transition",execution_sync_on_switch:"execution-sync",execution_log_transitions:"execution-log",growth_enabled:"growth-enabled",growth_activity_threshold:"growth-activity",growth_coactivation_threshold:"growth-coactivation",growth_information_threshold:"growth-info",growth_prune_threshold:"growth-prune",growth_max_synapses_per_neuron:"growth-max-synapses",growth_max_new_synapses_per_barrier:"growth-max-new",hardware_profile_name:"hardware-profile",cuda_budget_mb:"cuda-budget",offload_enabled:"offload-enabled",offload_snapshot_interval:"offload-snapshot",thalamic_gating_enabled:"thalamic-enabled",thalamic_relay_threshold:"thalamic-threshold",thalamic_attention_gain:"thalamic-attention",thalamic_inhibition_gain:"thalamic-inhibition",cortical_layers_enabled:"cortical-enabled",cortical_plasticity:"cortical-plasticity",cortical_learning_rate:"cortical-lr",behavior_target_mode:"behavior-target-mode",behavior_min_activity:"behavior-min-activity",behavior_learning_rate:"behavior-lr",behavior_epsilon:"behavior-epsilon",geometry_lambda_a:"geometry-lambda-a",geometry_lambda_b:"geometry-lambda-b",geometry_sigma:"geometry-sigma",geometry_p0:"geometry-p0",geometry_mode:"geometry-mode",geometry_delay_velocity:"geometry-delay-velocity",neural_io_enabled:"neural-io-enabled",neural_io_input_channels:"neural-io-input-channels",neural_io_output_channels:"neural-io-output-channels",neural_io_input_codec:"neural-io-codec",neural_io_output_decoder:"neural-io-decoder",neural_io_window_ticks:"neural-io-window",neural_io_input_current:"neural-io-current",neural_io_input_role:"neural-io-input-role",neural_io_output_role:"neural-io-output-role",neural_io_phase:"neural-io-phase",neural_io_modality:"neural-io-modality",neural_io_source_id:"neural-io-source",posture_score_channel:"posture-score-channel",reward_event_channel:"reward-event-channel",posture_current_scale:"posture-current-scale",reward_event_scale:"reward-event-scale",posture_reward_enabled:"posture-reward-enabled",posture_weight_upright:"posture-weight-upright",posture_weight_height:"posture-weight-height",posture_weight_stability:"posture-weight-stability",posture_weight_symmetry:"posture-weight-symmetry",posture_target_height:"posture-target-height",posture_tilt_max:"posture-tilt-max",posture_velocity_max:"posture-velocity-max",trigger_good_score:"trigger-good-score",trigger_good_duration:"trigger-good-duration",trigger_good_reward:"trigger-good-reward",trigger_warning_score:"trigger-warning-score",trigger_warning_reward:"trigger-warning-reward",trigger_falling_rate:"trigger-falling-rate",trigger_falling_reward:"trigger-falling-reward",trigger_collapse_score:"trigger-collapse-score",trigger_collapse_reward:"trigger-collapse-reward",trigger_recovery_bonus:"trigger-recovery-bonus",reward_continuous_alpha:"reward-continuous-alpha",episode_termination_enabled:"episode-termination-enabled",episode_max_ticks:"episode-max-ticks",episode_reset_on_collapse:"episode-reset-on-collapse",pan_feedback_delay:"pan-feedback-delay",pan_feedback_source:"pan-feedback-source",pan_feedback_target:"pan-feedback-target",pan_feedback_threshold:"pan-feedback-threshold",freeze_actions:"freeze-actions",freeze_rewards:"freeze-rewards",parity_reference_commit:"parity-reference-commit"
   };
+  if(key==="neural_io_input_payload"){const field=byId("pg-neural-io-payload");if(field)field.value=typeof value==="string"?value:JSON.stringify(value);return;}
   const id="pg-"+(aliases[key]||key.replaceAll("_","-"));
   const el=byId(id);if(!el)return;
   if(el.type==="checkbox")el.checked=Boolean(value);
@@ -991,7 +1163,7 @@ function renderUserPresetOptions(){
   const select=byId("pg-user-preset-select");if(!select)return;
   const selected=select.value;
   const presets=allPlaygroundPresets();
-  select.innerHTML=Object.entries(presets).map(([name,preset])=>`<option value="${name}">${preset.label||name}${BUILTIN_PLAYGROUND_PRESETS[name]?"":" · lokal"}</option>`).join("");
+  select.innerHTML=Object.entries(presets).map(([name,preset])=>`<option value="${playgroundEscape(name)}">${playgroundEscape(preset.label||name)} · ${preset.source==="catalog"?"Katalog":BUILTIN_PLAYGROUND_PRESETS[name]?"integriert":"Browser"}</option>`).join("");
   if(selected&&presets[selected])select.value=selected;else if(!select.value)select.value=presets[DEFAULT_PLAYGROUND_PRESET]?DEFAULT_PLAYGROUND_PRESET:"pan_exploration";
   const preset=presets[select.value];
   if(byId("pg-user-preset-description"))byId("pg-user-preset-description").textContent=preset?.description||"Preset auswählen oder eigene Einstellungen speichern.";
@@ -1058,13 +1230,21 @@ function ensureCatalogInfoDialog(){
 }
 
 function showCatalogInfo(item){
-  activeCatalogInfo=item;const language=catalogLanguage();const dialog=ensureCatalogInfoDialog();const category=catalogCategoryTitle(item.categoryKey||item.category||"repo",language);const description=describeCatalogItem(item,category,language);byId("pg-catalog-info-category").textContent=category;byId("pg-catalog-info-title").textContent=item.label||item.name||"—";byId("pg-catalog-info-body").innerHTML=`<p>${playgroundEscape(description)}</p>${item.source?`<p><strong>${language==="de"?"Quelle":"Source"}:</strong> <code>${playgroundEscape(item.source)}</code></p>`:""}<p><strong>${language==="de"?"Grenze":"Boundary"}:</strong> ${language==="de"?"Explorativ. Der Katalogeintrag ist keine Instanzierung und erzeugt keine wissenschaftliche Evidenz.":"Exploratory. This catalog entry is not an instantiation and does not create scientific evidence."}</p>`;dialog.querySelector("#pg-catalog-info-close").setAttribute("aria-label",language==="de"?"Bausteininfo schließen":"Close component information");dialog.showModal();
+  activeCatalogInfo=item;const language=catalogLanguage();const dialog=ensureCatalogInfoDialog();const categoryKey=item.categoryKey||item.category||"repo";const category=catalogCategoryTitle(categoryKey,language);const description=describeCatalogItem(item,category,language);const execution=catalogExecutionLabel(item,categoryKey,language);byId("pg-catalog-info-category").textContent=category;byId("pg-catalog-info-title").textContent=item.label||item.name||"—";byId("pg-catalog-info-body").innerHTML=`<p><strong>${language==="de"?"Ausführbarkeit":"Execution"}:</strong> ${playgroundEscape(execution)}</p><p>${playgroundEscape(description)}</p>${item.source?`<p><strong>${language==="de"?"Quelle":"Source"}:</strong> <code>${playgroundEscape(item.source)}</code></p>`:""}<p><strong>${language==="de"?"Grenze":"Boundary"}:</strong> ${language==="de"?"Explorativ. Der Katalogeintrag ist keine Instanzierung und erzeugt keine wissenschaftliche Evidenz.":"Exploratory. This catalog entry is not an instantiation and does not create scientific evidence."}</p>`;dialog.querySelector("#pg-catalog-info-close").setAttribute("aria-label",language==="de"?"Bausteininfo schließen":"Close component information");dialog.showModal();
 }
 
 function bindCatalogInfo(){
   const grid=byId("pg-catalog-grid");if(!grid||grid.dataset.infoBound)return;grid.dataset.infoBound="true";grid.addEventListener("click",event=>{const button=event.target.closest("[data-pg-catalog-info]");if(!button)return;const item=catalogInfoItems.get(button.dataset.pgCatalogInfo);if(item)showCatalogInfo(item);});
 }
 
+function catalogExecutionLabel(item, categoryKey, language=catalogLanguage()){
+  const nonExecutableCategory=["panCandidates","panLiterature","geometryLiterature","neuralIO","analyses","robustness","cudaCompiler","cudaParity","repo"].includes(categoryKey);
+  const minimum=Number(item.min_dimensions||0);const dimensions=Number(byId("pg-dimensions")?.value||5);
+  if (item.executable===false||nonExecutableCategory) return language==="de"?"Nur Katalog / nicht direkt ausführbar":"Catalog-only / not directly executable";
+  if (minimum>0&&dimensions<minimum) return language==="de"?`Nicht ausführbar bei ${dimensions}D; benötigt ${minimum}D`:`Not executable at ${dimensions}D; requires ${minimum}D`;
+  return language==="de"?"Ausführbarer Referenzpfad":"Executable reference path";
+}
+
 function renderCatalogCards(catalog){
   const panCandidates=(catalog.pan?.research_candidates||[]).map(item=>({name:item.id,note:item.question}));
   const panLiterature=(catalog.pan?.literature_context?.sources||[]).map(item=>({name:item.key,note:item.citation}));
@@ -1072,9 +1252,9 @@ function renderCatalogCards(catalog){
   const neuralIOCodecs=(catalog.neural_io?.codecs||[]).map(item=>({name:item.id,note:`${item.input_kind||""} · ${item.reconstruction_class||""}`}));
   const parityClasses=Object.entries(catalog.cuda_parity?.classes||{}).map(([name,item])=>({name,note:item.name||item.target_stage||""}));
   const groups=[["models",catalog.models],["topologies",catalog.topologies],["stimuli",catalog.stimuli],["synapses",catalog.synapses],["plasticity",catalog.plasticity],["readouts",catalog.readouts],["panCandidates",panCandidates],["panLiterature",panLiterature],["geometryLiterature",geometryLiterature],["neuralIO",neuralIOCodecs],["analyses",(catalog.analyses||[]).map(name=>({name}))],["robustness",(catalog.robustness_controls||[]).map(name=>({name}))],["cudaCompiler",(catalog.cuda_gate_compiler?.gate_types||[]).map(name=>({name,note:catalog.cuda_gate_compiler?.status||""}))],["cudaParity",parityClasses]];
-  groups.push(["repo",PLAYGROUND_REPO_ELEMENTS.map(([name,category,description,source])=>({name,label:name,note:description,category,source}))]);
+  groups.push(["repo",PLAYGROUND_REPO_ELEMENTS.map(([name,category,description,source])=>({name,label:name,note:description,category,source,executable:false}))]);
   catalogInfoItems=new Map();let itemIndex=0;const language=catalogLanguage();
-  byId("pg-catalog-grid").innerHTML=groups.map(([categoryKey,items])=>{const title=catalogCategoryTitle(categoryKey,language);return `<article><h3>${playgroundEscape(title)}</h3>${(items||[]).map(item=>{const infoKey=String(itemIndex++);const info={...item,categoryKey};catalogInfoItems.set(infoKey,info);const description=describeCatalogItem(info,title,language);return `<button type="button" class="playground-chip" data-pg-catalog-info="${infoKey}" title="${playgroundEscape(description)}">${playgroundEscape(item.label||item.name)}</button>`;}).join("")}</article>`;}).join("");
+  byId("pg-catalog-grid").innerHTML=groups.map(([categoryKey,items])=>{const title=catalogCategoryTitle(categoryKey,language);return `<article><h3>${playgroundEscape(title)}</h3>${(items||[]).map(item=>{const infoKey=String(itemIndex++);const info={...item,categoryKey};catalogInfoItems.set(infoKey,info);const description=describeCatalogItem(info,title,language);const execution=catalogExecutionLabel(info,categoryKey,language);return `<button type="button" class="playground-chip" data-pg-catalog-info="${infoKey}" title="${playgroundEscape(`${execution}. ${description}`)}">${playgroundEscape(item.label||item.name)}</button>`;}).join("")}</article>`;}).join("");
 }
 
 function renderCatalog(catalog){
@@ -1092,16 +1272,107 @@ function renderCatalog(catalog){
   const status=byId("pg-status");status.dataset.state="ok";status.textContent=`Bereit · bis ${catalog.limits.n_neurons} Neuronen · ${catalog.limits.edges} Kanten · ${catalog.limits.dimensions}D · scientific_evidence=false`;
 }
 
+
+function integrationStatusLabel(status){
+  return {
+    INTEGRATED:"In MHRN integriert",
+    READY_FOR_NEXT_WAVE:"Bereit für nächste Welle",
+    READY_FOR_WAVE4:"Bereit für Wave 4",
+    READY_AFTER_BACKEND_CONTRACT:"Backend-Vertrag zuerst",
+    BLOCKED_CONTRACT_FREEZE:"Contract-Freeze erforderlich",
+    BLOCKED_FROZEN_ENVIRONMENT:"Frozen-Environment erforderlich",
+    FE_CONTRACT_EXECUTABLE_CUDA_D3_PENDING:"FE-Vertrag ausführbar · CUDA-D3 offen",
+    FE_CONTRACT_EXECUTABLE_BUILDER_D3_BRIDGE_AVAILABLE_FE3_PENDING:"FE-Vertrag ausführbar · Builder-D3c Hardware-Bridge verfügbar · FE-3 Live-Adapter offen",
+    BLOCKED_PAN_SEMANTICS:"PAN-Semantik erforderlich",
+    SEMANTIC_CONTRACT_DRAFT:"Semantikvertrag in Arbeit",
+    WAVE6_CONTRACT_DRAFT:"Wave 6 · Structural-Approval-Draft",
+    WAVE7_CONTRACT_DRAFT:"Wave 7 · Learning-Contract-Draft",
+    RETAINED_NOT_CORE:"Unter OLD behalten",
+    FE3_LIVE_ADAPTER_IMPLEMENTED_HARDWARE_ACCEPTANCE_PENDING:"FE-3 Adapter integriert · Hardware-Abnahme offen",
+  }[status]||status;
+}
+
+function ensureMhrnIntegrationPanel(){
+  const builder=byId("playground-builder");
+  if(!builder||byId("pg-mhrn-integration"))return;
+  const panel=document.createElement("section");
+  panel.id="pg-mhrn-integration";
+  panel.className="playground-card pg-wide";
+  panel.innerHTML=`
+    <h3>MHRN Integration</h3>
+    <p>Playground-Bausteine kontrolliert in die kanonische MHRN-Struktur übernehmen. Der Transfer erzeugt keine DATA/EVID und verändert niemals Repository-Quellcode zur Laufzeit.</p>
+    <div class="pg-summary"><strong>Richtung:</strong> Playground → MHRN. MHRN importiert niemals Playground.</div>
+    <div id="pg-mhrn-integration-list" class="playground-analysis-grid"><p>Integrationsstatus wird geladen …</p></div>
+    <pre id="pg-mhrn-integration-state" class="pg-config-preview">Noch keine Transferprüfung ausgeführt.</pre>
+  `;
+  const grid=builder.querySelector(".playground-grid");
+  if(grid)grid.before(panel);else builder.append(panel);
+}
+
+function renderIntegrationCatalog(catalog){
+  const root=byId("pg-mhrn-integration-list");if(!root)return;
+  const candidates=catalog?.candidates||[];
+  root.innerHTML=candidates.map(item=>`
+    <article class="playground-analysis-card" data-pg-integration-card="${playgroundEscape(item.element_id)}">
+      <h4>${playgroundEscape(item.label)}</h4>
+      <p><strong>${playgroundEscape(integrationStatusLabel(item.status))}</strong></p>
+      <p>${playgroundEscape(item.notes||"")}</p>
+      <small>Quelle: ${playgroundEscape((item.source_paths||[]).join(", ")||"—")}<br>Ziel: ${playgroundEscape((item.target_paths||[]).join(", ")||"OLD / kein Core-Ziel")}<br>Nächstes Gate: ${playgroundEscape(item.next_gate||"—")}</small>
+      ${(item.old_routes||[]).length?`<p><small>OLD: ${playgroundEscape(item.old_routes.join(", "))}</small></p>`:""}
+      <button type="button" data-pg-transfer="${playgroundEscape(item.element_id)}">${item.status==="INTEGRATED"?"Übertragung prüfen":"Übernahme vorbereiten"}</button>
+    </article>
+  `).join("");
+}
+
+async function refreshIntegrationCatalog(){
+  ensureMhrnIntegrationPanel();
+  const catalog=await apiGet("/api/playground/integration");
+  renderIntegrationCatalog(catalog);
+  return catalog;
+}
+
+async function transferIntegrationElement(elementId){
+  const state=byId("pg-mhrn-integration-state");
+  if(state)state.textContent=`${elementId}: Transfer-Gate wird geprüft …`;
+  try{
+    const result=await apiPost("/api/playground/integration/transfer",{element_id:elementId});
+    if(state)state.textContent=JSON.stringify(result,null,2);
+    await refreshIntegrationCatalog();
+    return result;
+  }catch(error){
+    if(state)state.textContent=`Transferprüfung fehlgeschlagen: ${error.message||error}`;
+    throw error;
+  }
+}
+
 export async function initPlayground(){
   const root=byId("tab-playground");if(!root)return;
-  injectStyles();ensurePermanentBoundary(root);buildPanels(root);
+  injectStyles();ensurePermanentBoundary(root);buildPanels(root);ensureMhrnIntegrationPanel();
+  root.addEventListener("click",event=>{const button=event.target.closest("[data-pg-transfer]");if(button)transferIntegrationElement(button.dataset.pgTransfer).catch(()=>{});});
+  byId("pg-synaptic-transfer")?.addEventListener("click",async()=>{
+    const summary=byId("pg-transfer-summary"),node=byId("pg-transfer-state");summary.textContent="Vortraining und zwei gepaarte Transferlaeufe ...";
+    try{const result=await apiPost("/api/playground/research/synaptic-transfer",formPayload());node.textContent=JSON.stringify(result,null,2);summary.textContent=`Vergleich abgeschlossen · ${result.changed_pretraining_weights} veraenderte Gewichte. Externer Aktivitaetsdecoder; kein automatischer Nachweis schnellerer neuronaler Aufgabenloesung.`;}catch(error){summary.textContent=`Transfer-Vergleich fehlgeschlagen: ${error.message}`;}
+  });
+  byId("pg-cue-controls")?.addEventListener("click",async()=>{
+    const node=byId("pg-cue-controls-state");node.textContent="Sechs gepaarte Kontrolllaeufe ...";
+    try{node.textContent=JSON.stringify(await apiPost("/api/playground/research/cue-controls",formPayload()),null,2);}catch(error){node.textContent=`Cue-Kontrollen fehlgeschlagen: ${error.message}`;}
+  });
+  byId("pg-cuda-builder-parity")?.addEventListener("click",async()=>{
+    const node=byId("pg-cuda-builder-parity-state");node.textContent="CPU- und CUDA-Builder laufen ...";
+    try{node.textContent=JSON.stringify(await apiPost("/api/playground/cuda/builder-parity",formPayload()),null,2);}catch(error){node.textContent=`Builder-Paritaet fehlgeschlagen: ${error.message}`;}
+  });
+  byId("pg-cuda-recurrent")?.addEventListener("click",runCudaRecurrentParity);
+  byId("pg-cuda-plasticity")?.addEventListener("click",()=>runCudaRecurrentParity(true));
   if(!root.dataset.languageBound){root.dataset.languageBound="true";document.addEventListener("mhrn:language-change",()=>{if(catalogState)renderCatalogCards(catalogState);const dialog=byId("pg-catalog-info-dialog");if(dialog?.open&&activeCatalogInfo)showCatalogInfo(activeCatalogInfo);});}
-  byId("pg-run")?.addEventListener("click",runSession);byId("pg-cpu-determinism")?.addEventListener("click",()=>checkCpuDeterminism().catch(error=>{const node=byId("pg-cuda-compiler-state");if(node)node.textContent=String(error.message||error);}));byId("pg-cuda-compile")?.addEventListener("click",()=>compileCudaGates().catch(error=>{const node=byId("pg-cuda-compiler-state");if(node)node.textContent=String(error.message||error);}));byId("pg-user-preset-apply")?.addEventListener("click",applyUserPreset);byId("pg-user-preset-save")?.addEventListener("click",saveUserPreset);byId("pg-user-preset-delete")?.addEventListener("click",deleteUserPreset);byId("pg-user-preset-select")?.addEventListener("change",()=>{renderUserPresetOptions();applyUserPreset();});byId("pg-robustness")?.addEventListener("click",runRobustness);byId("pg-reset")?.addEventListener("click",resetForm);byId("pg-live-open")?.addEventListener("click",()=>openLiveMonitor().catch(error=>byId("pg-live-state").textContent=String(error.message||error)));byId("pg-live-clear")?.addEventListener("click",()=>clearLiveSessions().catch(error=>byId("pg-live-state").textContent=String(error.message||error)));byId("pg-night-start")?.addEventListener("click",()=>startNightRun().catch(error=>byId("pg-night-state").textContent=String(error.message||error)));byId("pg-night-stop")?.addEventListener("click",()=>stopNightRun().catch(error=>byId("pg-night-state").textContent=String(error.message||error)));byId("pg-night-refresh")?.addEventListener("click",()=>refreshNightStatus().catch(error=>byId("pg-night-state").textContent=String(error.message||error)));
+  byId("pg-run")?.addEventListener("click",runSession);byId("pg-cuda-status")?.addEventListener("click",()=>refreshCudaStatus().catch(error=>{const node=byId("pg-cuda-stage-state");if(node)node.textContent=String(error.message||error);}));byId("pg-cpu-determinism")?.addEventListener("click",()=>checkCpuDeterminism().catch(error=>{const node=byId("pg-cuda-compiler-state");if(node)node.textContent=String(error.message||error);}));byId("pg-cuda-compile")?.addEventListener("click",()=>compileCudaGates().catch(error=>{const node=byId("pg-cuda-compiler-state");if(node)node.textContent=String(error.message||error);}));byId("pg-cuda-preflight")?.addEventListener("click",()=>runCudaPreflight().catch(error=>{const node=byId("pg-cuda-resource-state");if(node)node.textContent=String(error.message||error);}));byId("pg-cuda-smoke")?.addEventListener("click",()=>runCudaHardwareSmoke().catch(error=>{const node=byId("pg-cuda-parity-state");if(node)node.textContent=String(error.message||error);}));byId("pg-cuda-rng")?.addEventListener("click",()=>runCudaRngParity().catch(error=>{const node=byId("pg-cuda-rng-state");if(node)node.textContent=String(error.message||error);}));byId("pg-user-preset-apply")?.addEventListener("click",applyUserPreset);byId("pg-user-preset-save")?.addEventListener("click",saveUserPreset);byId("pg-user-preset-delete")?.addEventListener("click",deleteUserPreset);byId("pg-user-preset-select")?.addEventListener("change",()=>{renderUserPresetOptions();applyUserPreset();});byId("pg-robustness")?.addEventListener("click",runRobustness);byId("pg-reset")?.addEventListener("click",resetForm);byId("pg-live-open")?.addEventListener("click",()=>openLiveMonitor().catch(error=>byId("pg-live-state").textContent=String(error.message||error)));byId("pg-live-clear")?.addEventListener("click",()=>clearLiveSessions().catch(error=>byId("pg-live-state").textContent=String(error.message||error)));byId("pg-night-start")?.addEventListener("click",()=>startNightRun().catch(error=>byId("pg-night-state").textContent=String(error.message||error)));byId("pg-night-stop")?.addEventListener("click",()=>stopNightRun().catch(error=>byId("pg-night-state").textContent=String(error.message||error)));byId("pg-night-refresh")?.addEventListener("click",()=>refreshNightStatus().catch(error=>byId("pg-night-state").textContent=String(error.message||error)));
   renderUserPresetOptions();
   try{renderCatalog(await apiGet("/api/playground/catalog"));renderUserPresetOptions();resetForm();}catch(error){const status=byId("pg-status");status.dataset.state="error";status.textContent=`Katalog nicht verfügbar: ${error.message}`;}
+  try{await refreshIntegrationCatalog();}catch(error){const state=byId("pg-mhrn-integration-state");if(state)state.textContent=`Integrationsstatus nicht verfügbar: ${error.message}`;}
   byId("playground-builder")?.addEventListener("input", updateDefaultHints);
   byId("playground-builder")?.addEventListener("change", updateDefaultHints);
+  initGuidedWorkspace({payload:formPayload,presets:()=>Object.fromEntries(Object.entries(allPlaygroundPresets()).map(([name,preset])=>[name,{...preset,settings:preset.source==="catalog"?resolvedPresetSettings(name):preset.settings}])),applyPreset:applyUserPreset,setValue:setBuilderValue,lastResult:()=>lastResult});
   await refreshSessions();
   try{await refreshNightStatus();}catch{ /* night manager is optional during partial deployments */ }
-  window.MHRNPlayground={run:runSession,runRobustness,checkCpuDeterminism,compileCudaGates,refreshSessions,get catalog(){return catalogState;},get lastResult(){return lastResult;}};
+  try{await refreshCudaStatus();}catch{ /* CUDA toolkit/driver is optional */ }
+  window.MHRNPlayground={run:runSession,runRobustness,checkCpuDeterminism,compileCudaGates,refreshCudaStatus,runCudaPreflight,runCudaHardwareSmoke,runCudaRngParity,refreshSessions,refreshIntegrationCatalog,transferIntegrationElement,get catalog(){return catalogState;},get lastResult(){return lastResult;}};
 }

src/dashboard/static/frontend/modules/recurrent-snn-stage.js

@@ -1,10 +1,7 @@
 "use strict";
 
-const ROUTES = Object.freeze({
-  science: ["recurrent", "Rekurrentes SNN", "network", "view", "recurrent"],
-  wesen: ["recurrent", "Rekurrenz", "wesen", "focus", "#mhrn-runtime-recurrent"],
-  control: ["recurrent", "Rekurrenz-Parameter", "settings", "focus", "#mhrn-recurrent-control"],
-});
+const ROUTES = Object.freeze({});
+
 
 const EDITABLE = Object.freeze([
   "network.initial_connections_per_neuron",
@@ -102,7 +99,7 @@ function ensureSciencePanel() {
     <div id="recurrent-science-summary" class="small-snn-summary"></div>
     <div class="small-snn-grid">
       <section><h3>Live-Netz</h3><div id="recurrent-science-graph" class="small-snn-graph"></div></section>
-      <section><h3>Stage-2 Contract</h3><div class="small-snn-contract"><strong>A → B → C → D → A</strong><span>20.000 ticks reference run</span><span>bounded event queue</span><span>deterministic replay identity</span><span>restart/restore independently verified</span><span>RQ-SNN-001: 100.000 ticks/run research DATA</span></div><div class="small-snn-actions"><button type="button" data-route-jump="wesen:recurrent">Runtime ansehen</button><button type="button" data-route-jump="control:recurrent">Rekurrenz-Parameter</button><button type="button" data-route-jump="release:development">Release-Entwicklung</button></div></section>
+      <section><h3>Stage-2 Contract</h3><div class="small-snn-contract"><strong>A → B → C → D → A</strong><span>20.000 ticks reference run</span><span>bounded event queue</span><span>deterministic replay identity</span><span>restart/restore independently verified</span><span>RQ-SNN-001: 100.000 ticks/run research DATA</span></div><div class="small-snn-actions"><button type="button" data-route-jump="old:wesen-recurrent">Runtime ansehen</button><button type="button" data-route-jump="old:control-recurrent">Rekurrenz-Parameter</button><button type="button" data-route-jump="release:development">Release-Entwicklung</button></div></section>
     </div>
     <div id="recurrent-science-status" class="small-snn-status">lade …</div>`;
   root.appendChild(panel);
@@ -114,7 +111,7 @@ function ensureRuntimePanel() {
   const panel = document.createElement("section");
   panel.id = "mhrn-runtime-recurrent";
   panel.className = "card small-snn-panel runtime-snn-panel";
-  panel.dataset.mhrnRoute = "wesen:recurrent";
+  panel.dataset.mhrnRoute = "old:wesen-recurrent";
   panel.hidden = true;
   panel.innerHTML = `
     <header class="small-snn-head"><div><span class="workspace-kicker">RUNTIME & WESEN · STAGE 2</span><h2>Rekurrenz Live</h2><p>Read-only Beobachtung des real laufenden Netzwerks mit Tick, Aktivität, Queue und rückgekoppelten Kanten im sichtbaren Ausschnitt.</p></div><button id="recurrent-runtime-refresh" type="button">↻ Aktualisieren</button></header>
@@ -132,12 +129,12 @@ function ensureControlPanel() {
   const panel = document.createElement("section");
   panel.id = "mhrn-recurrent-control";
   panel.className = "card small-snn-panel";
-  panel.dataset.mhrnRoute = "control:recurrent";
+  panel.dataset.mhrnRoute = "old:control-recurrent";
   panel.hidden = true;
   panel.innerHTML = `
     <header class="small-snn-head"><div><span class="workspace-kicker">CONTROL · STAGE 2</span><h2>Rekurrenz-Parameter</h2><p>Relevante Konstruktionsparameter werden ausschließlich als Pending Changes vorbereitet.</p></div><span id="recurrent-pending" class="small-snn-stage-badge">0 pending</span></header>
     <div id="recurrent-control-fields" class="small-snn-control-fields"></div>
-    <div class="small-snn-actions"><button id="recurrent-stage" type="button">Stage changes</button><button id="recurrent-apply" type="button" class="btn-primary">Apply</button><button type="button" data-route-jump="control:parameters">Alle Parameter</button><button type="button" data-route-jump="science:recurrent">Wissenschaft</button></div>
+    <div class="small-snn-actions"><button id="recurrent-stage" type="button">Stage changes</button><button id="recurrent-apply" type="button" class="btn-primary">Apply</button><button type="button" data-route-jump="settings:parameters">Alle Parameter</button><button type="button" data-route-jump="old:science-recurrent">Wissenschaft</button></div>
     <div id="recurrent-control-status" class="small-snn-status">lade …</div>
     <div class="small-snn-boundary">Topologie-, Radius- und Refraktäränderungen sind wissenschaftlich sensitiv. Ein neuer Run/Restart ist erforderlich.</div>`;
   root.appendChild(panel);
@@ -228,7 +225,7 @@ function summaryHtml(data) {
 }
 
 async function refreshScience() {
-  if (document.body.dataset.currentArea !== "science" || document.body.dataset.currentRoute !== "recurrent") return;
+  if (document.body.dataset.currentArea !== "old" || document.body.dataset.currentRoute !== "science-recurrent") return;
   try {
     const data = await loadNetwork();
     $("recurrent-science-summary").innerHTML = summaryHtml(data);
@@ -241,8 +238,8 @@ async function refreshScience() {
 
 async function refreshRuntime() {
   if (
-    document.body.dataset.currentArea !== "wesen" ||
-    document.body.dataset.currentRoute !== "recurrent" ||
+    document.body.dataset.currentArea !== "old" ||
+    document.body.dataset.currentRoute !== "wesen-recurrent" ||
     state.inFlight
   ) return;
   state.inFlight = true;
@@ -284,7 +281,7 @@ function renderControl() {
 }
 
 async function refreshControl() {
-  if (document.body.dataset.currentArea !== "control" || document.body.dataset.currentRoute !== "recurrent") return;
+  if (document.body.dataset.currentArea !== "old" || document.body.dataset.currentRoute !== "control-recurrent") return;
   try {
     const [parameters, pending] = await Promise.all([
       json("/api/parameters"),
@@ -342,17 +339,17 @@ async function applyControl() {
 function routeRefresh() {
   const area = document.body.dataset.currentArea;
   const route = document.body.dataset.currentRoute;
-  if (route !== "recurrent") return;
-  if (area === "science") refreshScience();
-  if (area === "wesen") refreshRuntime();
-  if (area === "control") refreshControl();
+  if (area !== "old") return;
+  if (route === "science-recurrent") refreshScience();
+  if (route === "wesen-recurrent") refreshRuntime();
+  if (route === "control-recurrent") refreshControl();
 }
 
 function syncPolling() {
   const area = document.body.dataset.currentArea;
   const route = document.body.dataset.currentRoute;
-  const liveRoute = route === "recurrent" && (area === "science" || area === "wesen");
-  if (route === "recurrent") routeRefresh();
+  const liveRoute = area === "old" && (route === "science-recurrent" || route === "wesen-recurrent");
+  if (area === "old" && route.endsWith("-recurrent")) routeRefresh();
   if (liveRoute && !state.timer) {
     state.timer = setInterval(routeRefresh, 1000);
     return;
@@ -374,7 +371,7 @@ export function initRecurrentSNNStage() {
     attributeFilter: ["data-current-area", "data-current-route"],
   });
   document.addEventListener("click", (event) => {
-    if (event.target.closest('[data-area-route="recurrent"], [data-route-card="recurrent"]')) {
+    if (event.target.closest('[data-area-route="science-recurrent"], [data-area-route="wesen-recurrent"], [data-area-route="control-recurrent"], [data-route-card="science-recurrent"], [data-route-card="wesen-recurrent"], [data-route-card="control-recurrent"]')) {
       setTimeout(syncPolling, 0);
     }
   });