diff --git a/README.md b/README.md
index 68aa3ecaf9bbe28ca9609175ece9e248f916344a..f8ac77fa033e054d0780f4f51944b9f526e36356 100644
--- a/README.md
+++ b/README.md
@@ -64,10 +64,11 @@ existing one.
 > suite and cannot be reproduced from this subset alone.
 
 > [!IMPORTANT]
-> Doc2Harness is an **executable** benchmark. This dataset lets you browse and
-> analyze the scenarios, the development document, and the contract skeleton.
-> To actually score a harness (Docker, mock gateway, drivers), use the code on
-> [GitHub](https://github.com/YuyaoGe/doc2harness).
+> Doc2Harness is an **executable** benchmark. The `scenarios` and `leaderboard`
+> configs are for browsing and analysis; `load_dataset` alone does not score
+> anything. To score a harness, use the full evaluation code shipped in
+> [`code/`](#run-the-benchmark) (a snapshot of the
+> [GitHub repository](https://github.com/YuyaoGe/doc2harness)) with Docker.
 
 ## Contents
 
@@ -77,6 +78,7 @@ existing one.
 | `data/leaderboard.jsonl` | Pass rates of 19 frontier models on the full 328-case suite (config `leaderboard`) |
 | `development_document/functional_spec_v6.md` | The development document given to the build model in Stage 1 |
 | `contract_skeleton/` | The interface-only contract skeleton (CLI, headless entry point, evaluation API), plus `AGENT_CONTRACT-v2.md` |
+| `code/` | Full evaluation code: Stage 1 build pipeline and Stage 2 framework (catalog, drivers, mock gateway), identical to GitHub commit [`5411f53`](https://github.com/YuyaoGe/doc2harness/tree/5411f53d497a6c76c1dd41bd55f08cc033203d2b) |
 
 ## Usage
 
@@ -99,6 +101,47 @@ path = snapshot_download("YuyaoGe/doc2harness", repo_type="dataset",
                          allow_patterns=["development_document/*", "contract_skeleton/**"])
 ```
 
+## Run the benchmark
+
+**Requirements:** Python 3.11+ and Docker. Both stages use the standard library only.
+
+```bash
+pip install -U huggingface_hub
+hf download YuyaoGe/doc2harness --repo-type dataset --include "code/*" --local-dir doc2harness
+cd doc2harness/code
+
+# sanity check: loading the catalog verifies its digests
+PYTHONPATH=src python3 -c "from doc2harness.benchmark.dispatch import active_scenario_ids as a; print(len(a()))"
+# 94
+```
+
+**Stage 2 only: score an existing harness.** No model key is needed; scenarios
+drive the product against a mock gateway.
+
+```bash
+docker build --target evaluation -t doc2harness/evaluation:candidate -f containers/Dockerfile .
+
+PYTHONPATH=src:tools:run python3 tools/run_production_catalog.py \
+  --artifact /path/to/product --artifact-id my-product \
+  --output /tmp/scores --concurrency 12 --timeout 300
+```
+
+Each scenario writes a JSON receipt, plus a `catalog_receipt.json`. The score is
+`pass / (pass + fail)` over applicable scenarios; a scenario that cannot be
+observed on a product is `INCONCLUSIVE`, not a failure. Narrow the selection
+with `--family headless` or `--scenario-id <id>`.
+
+**Stage 1: build a new harness, then score it.** This needs the builder image
+and a local LiteLLM gateway holding your own API key; see
+`code/src/stage1/README.md`.
+
+```bash
+docker pull ghcr.io/yuyaoge/doc2harness-builder:latest
+PYTHONPATH=src python3 src/stage1/run_build.py --builder-tag <model> --dry-run   # prints the plan, no key needed
+PYTHONPATH=src python3 src/stage1/run_build.py --builder-tag <model> --out-dir results/
+# then score results/<run_id>/agent as above
+```
+
 ## Scenario fields (`scenarios`)
 
 | Field | Type | Description |
diff --git a/code/.d2a_spec/typed_event_hooks.json b/code/.d2a_spec/typed_event_hooks.json
new file mode 100644
index 0000000000000000000000000000000000000000..ec4bf140fec97ba7c12601ade3014a22ddd42de7
--- /dev/null
+++ b/code/.d2a_spec/typed_event_hooks.json
@@ -0,0 +1,7 @@
+{
+  "schema": "doc2harness.typed-event-hooks/1",
+  "tool_lifecycle": true,
+  "subprocess": true,
+  "workspace": true,
+  "cleanup": true
+}
diff --git a/code/.github/workflows/quality.yml b/code/.github/workflows/quality.yml
new file mode 100644
index 0000000000000000000000000000000000000000..4c856a7e833cc334a0465c8647c6d1ebc1699261
--- /dev/null
+++ b/code/.github/workflows/quality.yml
@@ -0,0 +1,133 @@
+name: quality
+
+on:
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+env:
+  LC_ALL: C.UTF-8
+  PYTHONHASHSEED: "0"
+  SOURCE_DATE_EPOCH: "315532800"
+  TZ: UTC
+
+jobs:
+  clean-wheel:
+    runs-on: ubuntu-24.04
+    timeout-minutes: 15
+    permissions:
+      contents: read
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.11", "3.12"]
+    steps:
+      - name: Check out source
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          persist-credentials: false
+      - name: Set up Python
+        uses: actions/setup-python@ece7cb06caefa5fff74198d8649806c4678c61a1 # v6.3.0
+        with:
+          python-version: ${{ matrix.python-version }}
+          check-latest: false
+      - name: Install hash-locked verification tools
+        env:
+          PIP_DISABLE_PIP_VERSION_CHECK: "1"
+        run: python -m pip install --require-hashes -r requirements/build-tools.txt
+      - name: Build distributions without dependency discovery
+        run: python -m build --no-isolation --sdist --wheel
+      - name: Compile source
+        run: python -m compileall -q src
+      - name: Rebuild the wheel offline from the source distribution
+        shell: bash
+        env:
+          PIP_NO_INDEX: "1"
+        run: |
+          sdist_archive=(dist/*.tar.gz)
+          test "${#sdist_archive[@]}" -eq 1
+          export SDIST_ARCHIVE="${sdist_archive[0]}"
+          export SDIST_UNPACK_ROOT="${RUNNER_TEMP}/sdist-source"
+          python - <<'PY'
+          import os
+          import tarfile
+          from pathlib import Path, PurePosixPath
+
+          archive_path = Path(os.environ["SDIST_ARCHIVE"])
+          destination = Path(os.environ["SDIST_UNPACK_ROOT"])
+          destination.mkdir()
+          with tarfile.open(archive_path, mode="r:gz") as archive:
+              member_names = set()
+              for member in archive.getmembers():
+                  path = PurePosixPath(member.name)
+                  if path.is_absolute() or ".." in path.parts:
+                      raise SystemExit("unsafe source-distribution member")
+                  if path.as_posix() != member.name or member.name in member_names:
+                      raise SystemExit("non-canonical source-distribution member")
+                  member_names.add(member.name)
+                  if member.issym() or member.islnk() or not (
+                      member.isfile() or member.isdir()
+                  ):
+                      raise SystemExit("unsupported source-distribution member type")
+              archive.extractall(destination, filter="data")
+          PY
+          sdist_root="${SDIST_UNPACK_ROOT}/doc2harness-0.0.0"
+          mkdir "${sdist_root}/dist"
+          cp "${SDIST_ARCHIVE}" "${sdist_root}/dist/"
+          python -m build --no-isolation --wheel --outdir "${sdist_root}/dist" "${sdist_root}"
+          cmp dist/*.whl "${sdist_root}/dist/"*.whl
+      - name: Install source-distribution wheel into a clean environment
+        shell: bash
+        run: |
+          python -m venv --without-pip "${RUNNER_TEMP}/installed"
+          python -m pip --python "${RUNNER_TEMP}/installed/bin/python" install \
+            --no-index --no-deps \
+            "${RUNNER_TEMP}/sdist-source/doc2harness-0.0.0/dist/"*.whl
+      - name: Smoke-import the installed wheel
+        shell: bash
+        run: |
+          "${RUNNER_TEMP}/installed/bin/python" -I -c "
+          import doc2harness
+          from doc2harness.benchmark.dispatch import active_scenario_ids
+          ids = active_scenario_ids()
+          print('installed wheel ok, scenarios:', len(ids))
+          assert len(ids) == 94
+          "
+
+  # Verify the catalog from source (the wheel only ships src/doc2harness; stage1
+  # runs from source and is not packaged into the wheel).
+  source-catalog:
+    runs-on: ubuntu-24.04
+    timeout-minutes: 10
+    permissions:
+      contents: read
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.11", "3.12"]
+    steps:
+      - name: Check out source
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          persist-credentials: false
+      - name: Set up Python
+        uses: actions/setup-python@ece7cb06caefa5fff74198d8649806c4678c61a1 # v6.3.0
+        with:
+          python-version: ${{ matrix.python-version }}
+          check-latest: false
+      - name: Verify catalog integrity and size
+        run: |
+          PYTHONPATH=src python - <<'PY'
+          from doc2harness.benchmark.dispatch import active_scenario_ids, load_scenario_owner
+          from collections import Counter
+          ids = active_scenario_ids()
+          families = Counter(
+              load_scenario_owner(i).definition.classification.primary for i in ids
+          )
+          print("scenarios:", len(ids))
+          for name, count in sorted(families.items()):
+              print(f"  {name} {count}")
+          assert len(ids) == 94, f"active catalog changed size: {len(ids)}"
+          assert len(families) == 9, f"family count changed: {sorted(families)}"
+          PY
diff --git a/code/.gitignore b/code/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..8cf985c38b2b387ce78c27e321da2bf32c9c4615
--- /dev/null
+++ b/code/.gitignore
@@ -0,0 +1,12 @@
+.venv/
+build/
+dist/
+*.egg-info/
+__pycache__/
+.pytest_cache/
+run-results/
+
+# stage1 local build outputs and artifact registry: large, and they contain
+# products emitted by the model under test, so they stay out of the repository.
+/results/
+/artifacts_store/
diff --git a/code/LICENSE b/code/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..ad63d32c1b74cb42334175bf00dfc5eafc9e0f0f
--- /dev/null
+++ b/code/LICENSE
@@ -0,0 +1,160 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship made available under
+      the License, as indicated by a copyright notice that is included in
+      or attached to the work (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean, as defined by the Licensor, any work of
+      authorship, including the original version of the Work and any
+      modifications or additions to that Work or Derivative Works of the Work,
+      that is intentionally submitted to the Licensor for inclusion in the Work
+      by the copyright owner or by an individual or Legal Entity authorized to
+      submit on behalf of the copyright owner.
+
+      "Contributor" shall mean Licensor and any Legal Entity on behalf of
+      whom a Contribution has been received by the Licensor and included
+      within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by the combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a cross-claim
+      or counterclaim in a lawsuit) alleging that the Work or any
+      Contribution embodied within the Work constitutes direct or
+      contributory patent infringement, then any patent licenses granted to
+      You under this License for that Work shall terminate as of the date
+      such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or Derivative
+          Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, You must include a readable copy of the
+          attribution notices contained within such NOTICE file, in
+          at least one of the following places: within a NOTICE text
+          file distributed as part of the Derivative Works; within
+          the Source form or documentation, if provided along with the
+          Derivative Works; or, within a display generated by the
+          Derivative Works, if and wherever such third-party notices
+          normally appear. The contents of the NOTICE file are for
+          informational purposes only and do not modify the License.
+          You may add Your own attribution notices within Derivative
+          Works that You distribute, alongside or as an addendum to
+          the NOTICE text from the Work, provided that such additional
+          attribution notices cannot be construed as modifying the License.
+
+      You may add Your own license statement for Your modifications and
+      may provide additional grant of rights to use, copy, modify, merge,
+      publish, distribute, sublicense, and/or sell copies of the Work
+      and derivative works.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or reproducing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or exemplary damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or all other
+      commercial damages or losses), even if such Contributor has been
+      advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may offer only
+      conditions consistent with this License.
+
+   END OF TERMS AND CONDITIONS
diff --git a/code/MANIFEST.in b/code/MANIFEST.in
new file mode 100644
index 0000000000000000000000000000000000000000..7ef872a0c9782d269400603a9d1706d7ab2cd435
--- /dev/null
+++ b/code/MANIFEST.in
@@ -0,0 +1,12 @@
+include README.md
+include NOTICE
+include LICENSE
+include pyproject.toml
+include .github/workflows/quality.yml
+include requirements/build-tools.txt
+include requirements/run.txt
+recursive-include src/doc2harness *.py *.toml
+recursive-include run *.sh *.py *.yaml *.md
+prune containers
+global-exclude *.py[cod]
+global-exclude .DS_Store
diff --git a/code/NOTICE b/code/NOTICE
new file mode 100644
index 0000000000000000000000000000000000000000..723338c34b58463c82e1ee1f64cab35a3c0d6e1a
--- /dev/null
+++ b/code/NOTICE
@@ -0,0 +1,45 @@
+# Third-party notices
+
+doc2harness evaluates coding-agent products. This file records the upstream work
+it builds on and relates to. It is an attribution record, not a license grant —
+see `LICENSE` for this project's own terms.
+
+## mini-swe-agent
+
+MIT License, Copyright (c) 2025 Kilian A. Lieret and Carlos E. Jimenez
+https://mini-swe-agent.com/ · https://github.com/SWE-agent/mini-swe-agent
+
+stage1 asks a model to build a harness product by implementing a hollowed
+skeleton. That skeleton derives from mini-swe-agent's project layout.
+
+Scope of what is redistributed here: **no mini-swe-agent source code is vendored
+in this repository.** The skeleton at `src/stage1/f0_clean/` is a few small
+files of contract sockets that raise `NotImplementedError`; it carries no upstream
+implementation, and neither image installs mini-swe-agent. A product a builder
+derives from mini-swe-agent remains subject to the MIT license above — anyone
+distributing such a product needs to carry that notice with it.
+
+Note for product builders: the stage1 build prompt instructs the model to
+present the product under its own name and to suppress the upstream startup
+banner. That is an evaluation-fidelity measure (the benchmark observes the
+product's own declared behaviour), not an attempt to obscure provenance. It does
+not remove the MIT attribution obligation, which this notice discharges for the
+benchmark and which a product's own distribution must discharge for itself.
+
+## OpenCode
+
+https://opencode.ai/
+
+The builder image installs the OpenCode CLI binary, which drives the model
+during a stage1 build. It is installed from upstream at image build time under
+its own license; this repository redistributes no OpenCode code. The published
+builder image does contain the binary — consult OpenCode's terms before
+redistributing that image.
+
+## LiteLLM
+
+https://github.com/BerriAI/LiteLLM
+
+Used at runtime as the model gateway. It is a runtime dependency supplied by the
+operator, is not a dependency of the published wheel, and no LiteLLM code is
+redistributed here.
diff --git a/code/README.md b/code/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..cfd69b0c2faed37ddea2f3ffd73178397c912e4f
--- /dev/null
+++ b/code/README.md
@@ -0,0 +1,177 @@
+<p align="center">
+  <a href="https://geyuyao.com/doc2harness/"><img src="assets/logo.png" alt="Doc2Harness" width="420"></a>
+</p>
+
+<h3 align="center">Benchmarking LLMs on Long-Horizon Harness Engineering of Coding Agents</h3>
+
+<p align="center">
+  <a href="https://geyuyao.com/doc2harness/"><img src="https://img.shields.io/badge/Project-Page-0055E9?logo=googlechrome&logoColor=white" alt="Project Page"></a>
+  <a href="https://arxiv.org/abs/2610.20344"><img src="https://img.shields.io/badge/arXiv-2610.20344-b31b1b?logo=arxiv" alt="arXiv:2610.20344"></a>
+  <a href="LICENSE"><img src="https://img.shields.io/badge/License-Apache%202.0-green" alt="License"></a>
+  <img src="https://img.shields.io/badge/Python-3.11%2B-3776AB?logo=python&logoColor=white" alt="Python 3.11+">
+  <img src="https://img.shields.io/badge/deps-stdlib%20only-success" alt="stdlib only">
+  <img src="https://img.shields.io/badge/Docker-required-2496ED?logo=docker&logoColor=white" alt="Docker">
+  <a href="https://github.com/users/YuyaoGe/packages/container/package/doc2harness-builder"><img src="https://img.shields.io/badge/ghcr.io-builder%20image-181717?logo=github" alt="Builder image"></a>
+</p>
+
+<p align="center">
+  <a href="https://geyuyao.com/doc2harness/">🌐 Website</a> •
+  <a href="https://arxiv.org/abs/2610.20344">📄 Paper</a> •
+  <a href="#-quick-start">⚡ Quick start</a> •
+  <a href="#-scenario-catalog">🧪 Scenarios</a> •
+  <a href="#-leaderboard">🏆 Leaderboard</a> •
+  <a href="#-citation">📝 Citation</a>
+</p>
+
+---
+
+Doc2Harness measures how well a model can **build a working coding agent** —
+the harness itself — rather than how well it writes a patch inside one.
+
+- 🏗️ **Stage 1 — Build.** A build model, working through
+  [OpenCode](https://github.com/anomalyco/opencode) in an isolated container,
+  receives a development document and an interface-only skeleton and has to
+  implement a complete agent harness.
+- 🔬 **Stage 2 — Evaluate.** The harness is frozen, moved to a separate
+  container, and driven end to end by a scripted **mock model**. Each scenario
+  reads four observable channels — requests sent to the model, files on disk,
+  exit code, command output — and **positive controls** rule out vacuous passes.
+
+<p align="center">
+  <a href="https://geyuyao.com/doc2harness/"><img src="assets/pipeline.png" alt="Doc2Harness pipeline" width="92%"></a>
+</p>
+
+> [!NOTE]
+> 📦 **This is a partial open-source release.** The full benchmark in the paper
+> has **328 test cases**; this repository releases a subset of **94 scenarios**
+> (53 scored test cases plus the 41 positive controls that gate them). The
+> remaining test cases are held out. Numbers on the leaderboard below come from
+> the full suite and cannot be reproduced from this subset alone.
+
+## 🏆 Leaderboard
+
+<p align="center">
+  <a href="https://geyuyao.com/doc2harness/"><img src="assets/leaderboard.png" alt="Pass rate of nineteen models" width="100%"></a>
+</p>
+
+Pass rate of **19 frontier models** on the full 328-case suite, strongest on the
+left. Each model built **three independent harnesses**; a bar is their mean.
+The best model reaches **53.05%** and the weakest **27.44%** — even the
+strongest still fails nearly half the cases. See the
+[project page](https://geyuyao.com/doc2harness/) for per-category breakdowns
+and case studies.
+
+## ⚡ Quick start
+
+**Requirements:** Python 3.11+ and Docker. No third-party Python packages —
+both stages are standard library only.
+
+### 1️⃣ Score an existing harness (Stage 2 only)
+
+No model key needed: scenarios drive the product against a mock gateway.
+
+```bash
+# build the evaluation image once (see containers/README.md for mirror options)
+docker build --target evaluation -t doc2harness/evaluation:candidate -f containers/Dockerfile .
+
+# run all 94 scenarios against a product directory (one containing src/yuyao/)
+PYTHONPATH=src:tools:run python3 tools/run_production_catalog.py \
+  --artifact /path/to/product --artifact-id my-product \
+  --output /tmp/scores --concurrency 12 --timeout 300
+```
+
+- Narrow the selection with `--family headless` or `--scenario-id <id>`.
+- Output: one JSON receipt per scenario plus `catalog_receipt.json`. The
+  score is `pass / (pass + fail)` over applicable scenarios; a scenario that
+  cannot be observed on a product is `INCONCLUSIVE`, not a failure.
+- The full catalog takes about 25–90 seconds at concurrency 12.
+
+### 2️⃣ Build a new harness (Stage 1), then score it
+
+Needs the builder image and a local [LiteLLM](https://github.com/BerriAI/litellm)
+gateway holding **your** API key — setup in
+[`src/stage1/README.md`](src/stage1/README.md).
+
+```bash
+docker pull ghcr.io/yuyaoge/doc2harness-builder:latest
+
+# free: prints the full orchestration plan, starts nothing, needs no key
+PYTHONPATH=src python3 src/stage1/run_build.py --builder-tag <model> --dry-run
+
+# the real build (~15 minutes)
+PYTHONPATH=src python3 src/stage1/run_build.py --builder-tag <model> --out-dir results/
+
+# then score results/<run_id>/agent with step 1️⃣
+```
+
+### ✅ Sanity check
+
+```bash
+PYTHONPATH=src python3 -c "from doc2harness.benchmark.dispatch import active_scenario_ids as a; print(len(a()))"
+# 94
+```
+
+Loading the catalog also verifies its digests, so an edited or inconsistent
+catalog fails here instead of silently scoring a different set.
+
+## 🧪 Scenario catalog
+
+| Family | Total | Scored | Controls | What it observes |
+|---|--:|--:|--:|---|
+| 📄 `file` | 17 | 9 | 8 | Read / edit / patch tools, including hostile encodings |
+| 🔒 `permission` | 16 | 8 | 8 | Whether permission rules really constrain spawned processes |
+| 💾 `state` | 14 | 7 | 7 | Slash commands and session state |
+| 🤖 `headless` | 13 | 6 | 7 | Non-interactive runs and contract entry points |
+| 🔌 `direct` | 11 | 6 | 5 | Wire-level model protocol against a mock gateway |
+| 🖥️ `tui` | 9 | 5 | 4 | Interactive terminal behaviour over a real pty |
+| 📦 `artifact` | 7 | 7 | 0 | Product shape: entry point, launcher, lockfile, wheels |
+| 🚀 `startup` | 5 | 4 | 1 | Install and launch, ambient-environment isolation |
+| 🧩 `extension` | 2 | 1 | 1 | Extension points that must not fire without their trigger |
+| **Total** | **94** | **53** | **41** | |
+
+Each scenario is one file:
+`src/doc2harness/benchmark/harnesses/<family>/scenarios/<scenario_id>.py`.
+
+**Controls are not scored and are not free passes.** A control proves that the
+command *can* succeed when nothing blocks it, so a blocked run reads as "the
+rule held" rather than "the command never worked". Each scored scenario
+declares its controls in `definition.dependencies`; if you narrow the selection,
+keep it closed under those dependencies.
+
+## 📁 Repository layout
+
+```text
+src/doc2harness/   Stage 2 evaluation framework: catalog, drivers, mock gateway
+src/stage1/        Stage 1 build pipeline: spec, skeleton, builder image, smoke layers
+tools/             run_production_catalog.py — score a product
+run/               YAML-driven launchers
+containers/        evaluation image
+assets/            figures for this README
+```
+
+## 📝 Citation
+
+If you find Doc2Harness useful, please cite the
+[paper](https://arxiv.org/abs/2610.20344):
+
+```bibtex
+@article{ge2026doc2harness,
+  title   = {Doc2Harness: Benchmarking LLMs on Long-Horizon Harness Engineering of Coding Agents},
+  author  = {Ge, Yuyao and Liu, Shenghua and Gao, Peizhong and Ge, Chendi and Liu, Chenxu and
+             Wang, Yiwei and Mei, Lingrui and Bi, Baolong and Yao, Jiayu and Guo, Jiafeng and
+             Cheng, Xueqi},
+  journal = {arXiv preprint arXiv:2610.20344},
+  year    = {2026}
+}
+```
+
+## 🙏 Acknowledgments
+
+The product skeleton derives from the project layout of
+**[mini-swe-agent](https://github.com/SWE-agent/mini-swe-agent)** (MIT).
+Builds run through **[OpenCode](https://github.com/anomalyco/opencode)**, and
+the model gateway is **[LiteLLM](https://github.com/BerriAI/litellm)**. We
+thank their authors and contributors.
+
+Licensed under [Apache 2.0](LICENSE); see [`NOTICE`](NOTICE) for upstream
+attribution.
diff --git a/code/assets/leaderboard.png b/code/assets/leaderboard.png
new file mode 100644
index 0000000000000000000000000000000000000000..af93b02df60e91fd2c421cd03aa86f9efb68fa11
--- /dev/null
+++ b/code/assets/leaderboard.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2f789477a5a24535462d47c4f31e540e3a3b1fa697e23997d0fb8c0d9d2a8005
+size 182310
diff --git a/code/assets/logo.png b/code/assets/logo.png
new file mode 100644
index 0000000000000000000000000000000000000000..9019a6769abac1124eed726509f9d7988ae8eebc
--- /dev/null
+++ b/code/assets/logo.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7c10a641f41596c38e5fad58b44808805bc44df469a351d0e597fd8a91a774bf
+size 22521
diff --git a/code/assets/pipeline.png b/code/assets/pipeline.png
new file mode 100644
index 0000000000000000000000000000000000000000..5bc77a89102457f85d08f23f5a8d46716076e7af
--- /dev/null
+++ b/code/assets/pipeline.png
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dbff56c7405f33c5e6ca20393955b2f85c503adbc5723bc70e3409a6a9bd5ea2
+size 145952
diff --git a/code/containers/Dockerfile b/code/containers/Dockerfile
new file mode 100644
index 0000000000000000000000000000000000000000..7b3724c5eac2ee138c73228e22a5334b27bcda48
--- /dev/null
+++ b/code/containers/Dockerfile
@@ -0,0 +1,53 @@
+# syntax=docker/dockerfile:1.7
+
+ARG PYTHON_IMAGE=python:3.12-slim@sha256:090ba77e2958f6af52a5341f788b50b032dd4ca28377d2893dcf1ecbdfdfe203
+
+FROM ${PYTHON_IMAGE} AS runtime
+ARG DEBIAN_MIRROR=https://mirrors.aliyun.com/debian
+ARG DEBIAN_SECURITY_MIRROR=https://mirrors.aliyun.com/debian-security
+ARG PYPI_INDEX_URL=https://mirrors.aliyun.com/pypi/simple
+ARG SOURCE_DATE_EPOCH=315532800
+ENV DEBIAN_FRONTEND=noninteractive \
+    PIP_DISABLE_PIP_VERSION_CHECK=1 \
+    PIP_NO_CACHE_DIR=1 \
+    PYTHONDONTWRITEBYTECODE=1
+RUN sed -i \
+      -e "s|http://deb.debian.org/debian-security|${DEBIAN_SECURITY_MIRROR}|g" \
+      -e "s|http://deb.debian.org/debian|${DEBIAN_MIRROR}|g" \
+      /etc/apt/sources.list.d/debian.sources \
+    && apt-get update \
+    && apt-get install -y --no-install-recommends \
+      bash ca-certificates curl dnsutils git iproute2 iptables ripgrep unzip \
+    && rm -rf /var/lib/apt/lists/* /var/log/apt/* \
+    && rm -f /var/log/alternatives.log /var/log/dpkg.log \
+      /var/cache/ldconfig/aux-cache
+COPY containers/requirements/runtime.lock /tmp/runtime.lock
+RUN python -m pip install --no-cache-dir --index-url "${PYPI_INDEX_URL}" \
+      --requirement /tmp/runtime.lock \
+    && python -m pip check \
+    && find /usr/local/lib/python3.12/site-packages \
+      -type f -name '*.pyc' -delete \
+    && PYTHONHASHSEED=0 SOURCE_DATE_EPOCH="${SOURCE_DATE_EPOCH}" \
+      python -m compileall -q -f --invalidation-mode checked-hash \
+      /usr/local/lib/python3.12/site-packages \
+    && python - <<'PY'
+import importlib.metadata
+import importlib.util
+
+assert importlib.util.find_spec("minisweagent") is None
+try:
+    importlib.metadata.distribution("mini-swe-agent")
+except importlib.metadata.PackageNotFoundError:
+    pass
+else:
+    raise SystemExit("mini-swe-agent distribution leaked into runtime image")
+PY
+RUN mkdir -p /opt/f0 && test -z "$(find /opt/f0 -mindepth 1 -print -quit)"
+WORKDIR /opt/f0
+
+FROM runtime AS evaluation
+LABEL org.opencontainers.image.title="doc2harness evaluation environment" \
+      org.opencontainers.image.description="Minimal environment for isolated artifact evaluation"
+RUN test ! -e /usr/local/bin/opencode \
+    && test ! -e /root/.opencode \
+    && test -z "$(find /opt/f0 -mindepth 1 -print -quit)"
diff --git a/code/containers/README.md b/code/containers/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..604749d4fa0d9a157d370de668f2341fced9408f
--- /dev/null
+++ b/code/containers/README.md
@@ -0,0 +1,46 @@
+# Evaluation image
+
+stage2 runs every scenario that needs isolation inside one image, built from
+`containers/Dockerfile`: a Python runtime with the pinned dependencies in
+`requirements/runtime.lock`, an empty `/opt/f0`, and no OpenCode.
+
+The image contains no product. The caller injects the artifact under test at
+run time, so one image serves every product.
+
+The stage1 builder image is a different image; see
+[`src/stage1/README.md`](../src/stage1/README.md).
+
+## Building
+
+```sh
+docker build --target evaluation \
+  --tag doc2harness/evaluation:candidate \
+  --file containers/Dockerfile .
+```
+
+That tag is the default the code looks for. Override it with
+`SBH_EVALUATION_IMAGE` if you tag differently.
+
+## Mirrors
+
+The checked-in defaults use Aliyun's Debian and PyPI mirrors. They are build
+arguments, not edits to the Dockerfile:
+
+```sh
+docker build --target evaluation \
+  --build-arg DEBIAN_MIRROR=https://deb.debian.org/debian \
+  --build-arg DEBIAN_SECURITY_MIRROR=https://security.debian.org/debian-security \
+  --build-arg PYPI_INDEX_URL=https://pypi.org/simple \
+  --tag doc2harness/evaluation:candidate \
+  --file containers/Dockerfile .
+```
+
+Changing a mirror must not change what lands in the image. The Python base is
+pinned by digest and the Python dependencies by `requirements/runtime.lock`; a
+mirror serves those same packages or the build fails.
+
+## What the build asserts
+
+The build ends with checks that fail it rather than ship a wrong image:
+OpenCode is absent, `/opt/f0` is empty, and no mini-swe-agent tree,
+distribution, or cache is present.
diff --git a/code/containers/requirements/runtime.lock b/code/containers/requirements/runtime.lock
new file mode 100644
index 0000000000000000000000000000000000000000..07a58bff993cf83afbc077c0bc4db0e31805fdc2
--- /dev/null
+++ b/code/containers/requirements/runtime.lock
@@ -0,0 +1,74 @@
+# Exact runtime inventory of the evaluation image.
+# mini-swe-agent is intentionally absent.
+Jinja2==3.1.6
+MarkupSafe==3.0.3
+PyYAML==6.0.3
+Pygments==2.20.0
+aiohappyeyeballs==2.7.1
+aiohttp==3.14.3
+aiosignal==1.4.0
+annotated-doc==0.0.5
+annotated-types==0.8.0
+anyio==4.14.2
+attrs==26.1.0
+certifi==2026.7.22
+charset-normalizer==3.4.9
+click==8.4.2
+datasets==5.0.1
+dill==0.4.1
+distro==1.9.0
+fastuuid==0.14.0
+filelock==3.32.2
+frozenlist==1.8.0
+fsspec==2026.6.0
+h11==0.16.0
+hf-xet==1.6.0
+httpcore==1.0.9
+httpx==0.28.1
+huggingface_hub==1.26.1
+idna==3.18
+importlib_metadata==8.9.0
+jiter==0.16.0
+jsonschema-specifications==2025.9.1
+jsonschema==4.26.0
+linkify-it-py==2.1.0
+litellm==1.95.0
+markdown-it-py==4.2.0
+mdit-py-plugins==0.6.1
+mdurl==0.1.2
+multidict==6.7.1
+multiprocess==0.70.19
+numpy==2.5.1
+openai==2.53.0
+packaging==26.3
+pandas==3.0.5
+platformdirs==4.11.0
+prompt_toolkit==3.0.53
+propcache==0.5.2
+pyarrow==25.0.0
+pydantic==2.13.4
+pydantic_core==2.46.4
+python-dateutil==2.9.0.post0
+python-dotenv==1.2.2
+referencing==0.37.0
+regex==2026.7.19
+requests==2.34.2
+rich==15.0.0
+rpds-py==2026.6.3
+shellingham==1.5.4
+six==1.17.0
+sniffio==1.3.1
+tenacity==9.1.4
+textual==8.2.8
+tiktoken==0.13.0
+tokenizers==0.23.1
+tqdm==4.70.0
+typer==0.27.1
+typing-inspection==0.4.2
+typing_extensions==4.16.0
+uc-micro-py==2.0.0
+urllib3==2.7.0
+wcwidth==0.8.2
+xxhash==3.8.1
+yarl==1.24.5
+zipp==4.1.0
diff --git a/code/pyproject.toml b/code/pyproject.toml
new file mode 100644
index 0000000000000000000000000000000000000000..1f562bd9d1d5c412ffbeebdc6d38297c1eb98b7d
--- /dev/null
+++ b/code/pyproject.toml
@@ -0,0 +1,31 @@
+[build-system]
+requires = ["setuptools==84.0.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "doc2harness"
+version = "0.0.0"
+description = "doc2harness: a two-stage benchmark for coding-agent evaluation"
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = []
+
+[tool.setuptools]
+include-package-data = false
+
+[tool.setuptools.package-data]
+"doc2harness.benchmark" = ["*.toml", "*.json"]
+"doc2harness.benchmark.harnesses.artifact" = ["catalog.toml"]
+"doc2harness.benchmark.harnesses.direct" = ["catalog.toml"]
+"doc2harness.benchmark.harnesses.extension" = ["catalog.toml"]
+"doc2harness.benchmark.harnesses.file" = ["catalog.toml"]
+"doc2harness.benchmark.harnesses.headless" = ["catalog.toml"]
+"doc2harness.benchmark.harnesses.permission" = ["catalog.toml"]
+"doc2harness.benchmark.harnesses.startup" = ["catalog.toml"]
+"doc2harness.benchmark.harnesses.state" = ["catalog.toml"]
+"doc2harness.benchmark.harnesses.tui" = ["catalog.toml"]
+
+[tool.setuptools.packages.find]
+where = ["src"]
+include = ["doc2harness*"]
+namespaces = false
diff --git a/code/requirements/build-tools.txt b/code/requirements/build-tools.txt
new file mode 100644
index 0000000000000000000000000000000000000000..558ea88529914038c66864e3a555e56b679aa7ae
--- /dev/null
+++ b/code/requirements/build-tools.txt
@@ -0,0 +1,17 @@
+--index-url https://pypi.org/simple
+--only-binary :all:
+
+# Audited 2026-08-25 from the PyPI project release files. This lock is for
+# build and verification only; none of these packages is a runtime dependency.
+build==1.5.0 \
+    --hash=sha256:13f3eecb844759ab66efec90ca17639bbf14dc06cb2fdf37a9010322d9c50a6f
+packaging==26.3 \
+    --hash=sha256:d7193f7c8e4e93f444fde0262bf90af30e16fa0ad0ad44cb553c87339b23cd1c
+pip==26.2.1 \
+    --hash=sha256:71138adf1f4ca900cdb7d289c21b7494329f2332b6d85f0e1c42108c0384ed3e
+pyproject-hooks==1.2.0 \
+    --hash=sha256:9e5c6bfa8dcc30091c74b0cf803c81fdd29d94f01992a7707bc97babb1141913
+setuptools==84.0.0 \
+    --hash=sha256:51a52592b3b99e102b609654876bd65f19f999935166d1352678931132b0c670
+wheel==0.48.0 \
+    --hash=sha256:3217dcc807155e45db462d7ef2431f5ddda0d7273b700d05a67b271ceb1287ab
diff --git a/code/requirements/run.txt b/code/requirements/run.txt
new file mode 100644
index 0000000000000000000000000000000000000000..1910948f82d7b228755552cd3f5b343cebbca412
--- /dev/null
+++ b/code/requirements/run.txt
@@ -0,0 +1 @@
+PyYAML>=6.0,<7
diff --git a/code/run/README.md b/code/run/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..9168e1d751d1fba0ee05fee98c54d796d6673ab6
--- /dev/null
+++ b/code/run/README.md
@@ -0,0 +1,34 @@
+# Run commands
+
+`run_from_config.sh` is the generic YAML entry point:
+
+```sh
+./run/run_from_config.sh run/configs/project.yaml --dry-run
+```
+
+Install the small YAML-only run dependency when setting up a fresh environment:
+
+```sh
+python3 -m pip install -r requirements/run.txt
+```
+
+The YAML declares the catalog selection, models, output directory, and an
+explicit production executor command.  The command is executed once per model
+with `SBH_MODEL_ID`, `SBH_RUN_CONFIG`, `SBH_SCENARIO_COUNT`, and the validated
+`SBH_IDS_FILE` selection in its environment.  There is no built-in fallback
+executor, and an existing receipt is never re-read as if it were a fresh score.
+
+The two-candidate command is deliberately strict:
+
+```sh
+export CANDIDATE_A_ARTIFACT=/path/to/first/artifact
+export CANDIDATE_B_ARTIFACT=/path/to/second/artifact
+./run/run_94_example.sh --dry-run
+```
+
+It requires exactly the complete active catalog (currently 94 IDs) and the
+two model IDs `candidate-a` and `candidate-b`.  A real run uses the
+`run_production_executor.py` adapter and requires both artifact directories.
+Missing or unresolved paths fail closed instead of claiming that the 94-point
+run completed.  The executor drives each scenario directly; it never reads old
+result rows or verdicts.
diff --git a/code/run/configs/example-94.yaml b/code/run/configs/example-94.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..9389e54fb9ff0920f0af62bd41d2e77e1d35f58a
--- /dev/null
+++ b/code/run/configs/example-94.yaml
@@ -0,0 +1,29 @@
+schema: doc2harness.run-config/1
+
+run:
+  id: example-94
+  output_dir: run-results/example-94
+  concurrency: 2
+  catalog_concurrency: 2
+  catalog_timeout: 900
+  opencode_compression: false
+
+selection:
+  mode: all
+
+# Set this to the reviewed production artifact executor before running.  A
+# blank command is rejected; no previously recorded receipt is substituted.
+executor:
+  command:
+    - python3
+    - run/run_production_executor.py
+
+models:
+  - id: candidate-a
+    artifact_ref: ${CANDIDATE_A_ARTIFACT}
+    env:
+      SBH_ARTIFACT_REF: ${CANDIDATE_A_ARTIFACT}
+  - id: candidate-b
+    artifact_ref: ${CANDIDATE_B_ARTIFACT}
+    env:
+      SBH_ARTIFACT_REF: ${CANDIDATE_B_ARTIFACT}
diff --git a/code/run/configs/project.yaml b/code/run/configs/project.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..3d71c795274d9408712d2613f02957214152ad57
--- /dev/null
+++ b/code/run/configs/project.yaml
@@ -0,0 +1,19 @@
+schema: doc2harness.run-config/1
+
+run:
+  id: project-run
+  output_dir: run-results/project-run
+  concurrency: 4
+  opencode_compression: false
+
+selection:
+  mode: all
+
+# The executor is intentionally explicit.  Replace this with the reviewed
+# production executor command; the launcher has no fallback executor.
+executor:
+  command: []
+
+models:
+  - id: configured-model
+    env: {}
diff --git a/code/run/run_94_example.sh b/code/run/run_94_example.sh
new file mode 100644
index 0000000000000000000000000000000000000000..d02e3ac57a0fcf2305f2a457e8284f93ad39e138
--- /dev/null
+++ b/code/run/run_94_example.sh
@@ -0,0 +1,17 @@
+#!/usr/bin/env bash
+set -Eeuo pipefail
+
+# Run the frozen 94-point catalog for two candidate artifacts.
+# This deliberately uses the same YAML-driven runner as run_from_config.sh;
+# it does not reuse recorded verdicts or manufacture a score from old receipts.
+
+script_dir="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd -P)"
+repo_root="$(cd -- "${script_dir}/.." && pwd -P)"
+config_path="${repo_root}/run/configs/example-94.yaml"
+
+exec python3 "${script_dir}/run_config.py" \
+  --repo-root "${repo_root}" \
+  --config "${config_path}" \
+  --require-models candidate-a,candidate-b \
+  --require-count 94 \
+  "$@"
diff --git a/code/run/run_config.py b/code/run/run_config.py
new file mode 100644
index 0000000000000000000000000000000000000000..f60d1830104c250814ef5582eac0ae02b2259e53
--- /dev/null
+++ b/code/run/run_config.py
@@ -0,0 +1,262 @@
+"""Validate and execute a YAML-defined doc2harness run.
+
+A run must name an executable production backend in ``executor.command`` (or
+through ``SBH_PRODUCTION_EXECUTOR``); there is no built-in stand-in that would
+let a misconfigured run look like it scored something.  ``--dry-run`` validates
+the complete plan and writes no model result; without it, each configured model
+is invoked through the declared executor, respecting the configured concurrency
+limit.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import shlex
+import subprocess
+import sys
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from pathlib import Path
+from typing import Any
+
+
+class RunConfigError(ValueError):
+    """Raised when a run configuration is incomplete or unsafe."""
+
+
+def _load_yaml(path: Path) -> dict[str, Any]:
+    try:
+        import yaml  # type: ignore[import-not-found]
+    except ImportError as exc:  # pragma: no cover - environment dependent
+        raise RunConfigError(
+            "PyYAML is required for YAML run configs; install the run requirements"
+        ) from exc
+    try:
+        value = yaml.safe_load(path.read_text(encoding="utf-8"))
+    except (OSError, yaml.YAMLError) as exc:
+        raise RunConfigError(f"cannot read YAML config {path}: {exc}") from exc
+    if not isinstance(value, dict):
+        raise RunConfigError("top-level YAML value must be a mapping")
+    return value
+
+
+def _mapping(value: Any, name: str) -> dict[str, Any]:
+    if not isinstance(value, dict):
+        raise RunConfigError(f"{name} must be a mapping")
+    return value
+
+
+def _nonempty_string(value: Any, name: str) -> str:
+    if not isinstance(value, str) or not value.strip():
+        raise RunConfigError(f"{name} must be a non-empty string")
+    return value.strip()
+
+
+def _repo_path(repo_root: Path, value: Any, name: str) -> Path:
+    raw = Path(_nonempty_string(value, name)).expanduser()
+    return raw if raw.is_absolute() else repo_root / raw
+
+
+def _catalog_ids(repo_root: Path) -> tuple[str, ...]:
+    from doc2harness.benchmark.catalog import (
+        load_catalog_sources,
+        parse_catalog_root,
+    )
+
+    package = repo_root / "src" / "doc2harness"
+    benchmark = package / "benchmark"
+    root = parse_catalog_root((benchmark / "catalog_root.toml").read_bytes())
+    resources = {
+        root.taxonomy_resource: (benchmark / "taxonomy.toml").read_bytes(),
+        **{
+            shard.resource: (package / Path(*shard.resource.segments)).read_bytes()
+            for shard in root.shards
+        },
+    }
+    definitions = load_catalog_sources(
+        root,
+        resources,
+        lambda module, export: __import__(module, fromlist=[export]).__dict__[export],
+    )
+    return tuple(item.scenario_id for item in definitions)
+
+
+def _expand(value: str) -> str:
+    return os.path.expandvars(value)
+
+
+def _command(executor: dict[str, Any], *, allow_missing: bool) -> list[str]:
+    configured = executor.get("command")
+    if configured is None or configured == []:
+        env_command = os.environ.get("SBH_PRODUCTION_EXECUTOR", "").strip()
+        if not env_command:
+            if allow_missing:
+                return []
+            raise RunConfigError(
+                "executor.command is missing; set a production executor explicitly "
+                "(SBH_PRODUCTION_EXECUTOR may provide one)"
+            )
+        configured = shlex.split(env_command)
+    if isinstance(configured, str):
+        configured = shlex.split(configured)
+    if not isinstance(configured, list) or not configured or not all(
+        isinstance(item, str) and item.strip() for item in configured
+    ):
+        raise RunConfigError("executor.command must be a non-empty string/list command")
+    return [_expand(item) for item in configured]
+
+
+def _validate(
+    repo_root: Path,
+    config_path: Path,
+    document: dict[str, Any],
+    required_models: tuple[str, ...] = (),
+    required_count: int | None = None,
+) -> dict[str, Any]:
+    if document.get("schema") != "doc2harness.run-config/1":
+        raise RunConfigError("schema must be doc2harness.run-config/1")
+    run = _mapping(document.get("run"), "run")
+    selection = _mapping(document.get("selection"), "selection")
+    executor = _mapping(document.get("executor"), "executor")
+    models_value = document.get("models")
+    if not isinstance(models_value, list) or not models_value:
+        raise RunConfigError("models must be a non-empty list")
+    catalog = _catalog_ids(repo_root)
+    requested = selection.get("mode", "all")
+    if requested == "all":
+        selected = catalog
+    elif requested == "ids_file":
+        ids_file = _repo_path(repo_root, selection.get("ids_file"), "selection.ids_file")
+        try:
+            selected = tuple(
+                line.strip()
+                for line in ids_file.read_text(encoding="utf-8").splitlines()
+                if line.strip() and not line.lstrip().startswith("#")
+            )
+        except OSError as exc:
+            raise RunConfigError(f"cannot read selection.ids_file: {ids_file}") from exc
+    else:
+        raise RunConfigError("selection.mode must be all or ids_file")
+    if not selected or len(selected) != len(set(selected)):
+        raise RunConfigError("selection must contain unique non-empty scenario IDs")
+    if required_count is not None and len(selected) != required_count:
+        raise RunConfigError(
+            f"selection must contain exactly {required_count} scenario IDs, found {len(selected)}"
+        )
+    unknown = sorted(set(selected) - set(catalog))
+    if unknown:
+        raise RunConfigError(f"selection contains unknown scenario IDs: {unknown[:5]}")
+    if required_models:
+        names = tuple(_nonempty_string(_mapping(item, "model").get("id"), "model.id") for item in models_value)
+        if names != required_models:
+            raise RunConfigError(f"models must be exactly {list(required_models)}, found {list(names)}")
+    command = _command(executor, allow_missing=bool(document.get("_dry_run")))
+    output_dir = _repo_path(repo_root, run.get("output_dir", "run-results"), "run.output_dir")
+    if not output_dir.is_relative_to(repo_root):
+        raise RunConfigError("run.output_dir must remain inside the repository")
+    concurrency = run.get("concurrency", 1)
+    if type(concurrency) is not int or concurrency < 1:
+        raise RunConfigError("run.concurrency must be a positive integer")
+    return {
+        "repo_root": str(repo_root),
+        "config_path": str(config_path),
+        "run": run,
+        "selection": {"mode": requested, "count": len(selected), "ids": selected},
+        "models": models_value,
+        "executor": {"command": command, "output_dir": str(output_dir)},
+    }
+
+
+def _execute(plan: dict[str, Any], *, dry_run: bool) -> int:
+    output_dir = Path(plan["executor"]["output_dir"])
+    output_dir.mkdir(parents=True, exist_ok=True)
+    manifest = output_dir / "run-plan.json"
+    manifest.write_text(json.dumps(plan, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+    selection_file = output_dir / "selected-scenarios.txt"
+    selection_file.write_text(
+        "".join(f"{scenario_id}\n" for scenario_id in plan["selection"]["ids"]),
+        encoding="utf-8",
+    )
+    if dry_run:
+        print(json.dumps({"status": "VALID", "selection_count": plan["selection"]["count"], "models": [item["id"] for item in plan["models"]]}, ensure_ascii=False))
+        return 0
+    command = plan["executor"]["command"]
+    if not command:
+        raise RunConfigError(
+            "no production executor configured; set executor.command or "
+            "SBH_PRODUCTION_EXECUTOR before a real run"
+        )
+    def run_model(model: Any) -> tuple[str, int]:
+        model_map = _mapping(model, "model")
+        model_id = _nonempty_string(model_map.get("id"), "model.id")
+        environment = os.environ.copy()
+        environment.update(
+            {
+                str(key): _expand(str(value))
+                for key, value in _mapping(model_map.get("env", {}), "model.env").items()
+            }
+        )
+        environment["SBH_RUN_CONFIG"] = plan["config_path"]
+        environment["SBH_MODEL_ID"] = model_id
+        environment["SBH_SCENARIO_COUNT"] = str(plan["selection"]["count"])
+        environment["SBH_IDS_FILE"] = str(selection_file)
+        environment["SBH_RUN_OUTPUT_DIR"] = plan["executor"]["output_dir"]
+        environment["SBH_CATALOG_CONCURRENCY"] = str(
+            plan["run"].get("catalog_concurrency", 1)
+        )
+        environment["SBH_CATALOG_TIMEOUT"] = str(
+            plan["run"].get("catalog_timeout", 900)
+        )
+        print(
+            f"[doc2harness] starting model={model_id} "
+            f"scenarios={plan['selection']['count']}",
+            flush=True,
+        )
+        result = subprocess.run(command, cwd=Path(plan["repo_root"]), env=environment, check=False)
+        return model_id, result.returncode
+
+    concurrency = min(int(plan["run"].get("concurrency", 1)), len(plan["models"]))
+    with ThreadPoolExecutor(max_workers=concurrency) as pool:
+        futures = [pool.submit(run_model, model) for model in plan["models"]]
+        for future in as_completed(futures):
+            model_id, returncode = future.result()
+            if returncode != 0:
+                print(
+                    f"[doc2harness] executor failed model={model_id} rc={returncode}",
+                    file=sys.stderr,
+                )
+                return returncode
+    print(json.dumps({"status": "COMPLETED", "selection_count": plan["selection"]["count"], "models": [item["id"] for item in plan["models"]]}, ensure_ascii=False))
+    return 0
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--repo-root", type=Path, required=True)
+    parser.add_argument("--config", type=Path, required=True)
+    parser.add_argument("--dry-run", action="store_true")
+    parser.add_argument("--require-models", default="")
+    parser.add_argument("--require-count", type=int)
+    args = parser.parse_args()
+    try:
+        repo_root = args.repo_root.resolve()
+        config_path = args.config.resolve()
+        sys.path.insert(0, str(repo_root / "src"))
+        document = _load_yaml(config_path)
+        document["_dry_run"] = args.dry_run
+        plan = _validate(
+            repo_root,
+            config_path,
+            document,
+            tuple(item for item in args.require_models.split(",") if item),
+            args.require_count,
+        )
+        return _execute(plan, dry_run=args.dry_run)
+    except (OSError, RunConfigError, ImportError) as exc:
+        print(f"error[SBH-RUN-CONFIG]: {exc}", file=sys.stderr)
+        return 4
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/code/run/run_from_config.sh b/code/run/run_from_config.sh
new file mode 100644
index 0000000000000000000000000000000000000000..80fe1bc5ee6cec70a0ec54c452b8342935465fd9
--- /dev/null
+++ b/code/run/run_from_config.sh
@@ -0,0 +1,26 @@
+#!/usr/bin/env bash
+set -Eeuo pipefail
+
+# Run the harness from a YAML run configuration.
+# The Python entry point performs schema, catalog, and executor checks before
+# starting any model process.  Paths in the YAML file are resolved relative to
+# the repository unless they are explicitly absolute.
+
+script_dir="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd -P)"
+repo_root="$(cd -- "${script_dir}/.." && pwd -P)"
+
+if [[ $# -lt 1 ]]; then
+  printf 'usage: %s CONFIG.yaml [--dry-run]\n' "$0" >&2
+  exit 2
+fi
+
+config_path="$1"
+shift
+if [[ "${config_path}" != /* ]]; then
+  config_path="${repo_root}/${config_path}"
+fi
+
+exec python3 "${script_dir}/run_config.py" \
+  --repo-root "${repo_root}" \
+  --config "${config_path}" \
+  "$@"
diff --git a/code/run/run_production_executor.py b/code/run/run_production_executor.py
new file mode 100644
index 0000000000000000000000000000000000000000..8754aa13e0907379847e7657ed76064c1b6b5e02
--- /dev/null
+++ b/code/run/run_production_executor.py
@@ -0,0 +1,112 @@
+"""Bridge the YAML launch boundary to the reviewed production catalog runner.
+
+The generic YAML launcher owns validation and per-model scheduling.  This
+adapter owns only the explicit argument translation needed by the production
+catalog executor; it never reads previously recorded verdicts.  The deterministic model stimulus ships inside the package, so
+running a scenario needs nothing beyond the artifact under test.
+"""
+
+from __future__ import annotations
+
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+
+def _required(name: str) -> str:
+    value = os.environ.get(name, "").strip()
+    if not value or value.startswith("${"):
+        raise SystemExit(f"SBH production executor requires {name}")
+    return value
+
+
+def _positive_int(name: str, default: int) -> int:
+    value = os.environ.get(name, str(default)).strip()
+    try:
+        parsed = int(value)
+    except ValueError as exc:
+        raise SystemExit(f"{name} must be a positive integer") from exc
+    if parsed < 1:
+        raise SystemExit(f"{name} must be a positive integer")
+    return parsed
+
+
+def _positive_float(name: str, default: float) -> str:
+    value = os.environ.get(name, str(default)).strip()
+    try:
+        parsed = float(value)
+    except ValueError as exc:
+        raise SystemExit(f"{name} must be a positive number") from exc
+    if not 0 < parsed <= 3600:
+        raise SystemExit(f"{name} must be in (0, 3600]")
+    return value
+
+
+def build_command() -> tuple[list[str], Path]:
+    """Build the reviewed catalog command from explicit launcher bindings."""
+
+    repo_root = Path(__file__).resolve().parents[1]
+    artifact = Path(_required("SBH_ARTIFACT_REF")).expanduser().resolve()
+    output_root = Path(_required("SBH_RUN_OUTPUT_DIR")).expanduser()
+    if not output_root.is_absolute():
+        output_root = (repo_root / output_root).resolve()
+    model_id = _required("SBH_MODEL_ID")
+    scenario_count = _positive_int("SBH_SCENARIO_COUNT", 1)
+    concurrency = _positive_int("SBH_CATALOG_CONCURRENCY", 1)
+    timeout = _positive_float("SBH_CATALOG_TIMEOUT", 900.0)
+    output = output_root / model_id
+    if not artifact.is_dir() or not (artifact / "run_agent.sh").is_file():
+        raise SystemExit("SBH_ARTIFACT_REF must contain run_agent.sh")
+    command = [
+        sys.executable,
+        str(repo_root / "tools" / "run_production_catalog.py"),
+        "--repo-root",
+        str(repo_root),
+        "--artifact",
+        str(artifact),
+        "--artifact-id",
+        model_id,
+        "--output",
+        str(output),
+        "--concurrency",
+        str(concurrency),
+        "--timeout",
+        timeout,
+    ]
+    scenario_id = os.environ.get("SBH_SCENARIO_ID", "").strip()
+    ids_file = os.environ.get("SBH_IDS_FILE", "").strip()
+    if scenario_id and ids_file:
+        raise SystemExit("set only one of SBH_SCENARIO_ID and SBH_IDS_FILE")
+    if scenario_id:
+        command.extend(["--scenario-id", scenario_id])
+    elif ids_file:
+        command.extend(["--ids-file", str(Path(ids_file).expanduser().resolve())])
+    if scenario_count < 1:
+        raise SystemExit("SBH_SCENARIO_COUNT must be positive")
+    return command, output
+
+
+def main() -> int:
+    command, output = build_command()
+    output.mkdir(parents=True, exist_ok=True)
+    repo_root = Path(__file__).resolve().parents[1]
+    environment = os.environ.copy()
+    source_path = str(repo_root / "src")
+    existing_pythonpath = environment.get("PYTHONPATH", "")
+    environment["PYTHONPATH"] = (
+        source_path
+        if not existing_pythonpath
+        else source_path + os.pathsep + existing_pythonpath
+    )
+    completed = subprocess.run(
+        command,
+        cwd=repo_root,
+        env=environment,
+        check=False,
+    )
+    return completed.returncode
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/code/src/doc2harness/__init__.py b/code/src/doc2harness/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..a9a2c5b3bb437bff74e283b62c894075e8c15331
--- /dev/null
+++ b/code/src/doc2harness/__init__.py
@@ -0,0 +1 @@
+__all__ = []
diff --git a/code/src/doc2harness/benchmark/__init__.py b/code/src/doc2harness/benchmark/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..5cabc54610eb46b4b68735f0716b7dda44837fa7
--- /dev/null
+++ b/code/src/doc2harness/benchmark/__init__.py
@@ -0,0 +1,57 @@
+"""Typed, non-executing benchmark catalog contracts."""
+
+from doc2harness.benchmark.catalog import (
+    CatalogRoot,
+    CatalogShard,
+    CatalogVerification,
+    LogicalCatalogResource,
+    load_catalog_sources,
+    parse_catalog_root,
+    parse_catalog_shard,
+    verify_catalog_sources,
+)
+from doc2harness.benchmark.definition import (
+    Classification,
+    ComponentKind,
+    ComponentRef,
+    DependencyKind,
+    DependencyRef,
+    ExperimentBinding,
+    ScenarioDefinition,
+    ScenarioDifficulty,
+    ScenarioRole,
+    UnsupportedPolicy,
+    definition_digest,
+)
+from doc2harness.benchmark.taxonomy import (
+    Taxonomy,
+    TaxonomyEntry,
+    parse_taxonomy,
+    validate_classification,
+)
+
+__all__ = [
+    "CatalogRoot",
+    "CatalogShard",
+    "CatalogVerification",
+    "Classification",
+    "ComponentKind",
+    "ComponentRef",
+    "DependencyKind",
+    "DependencyRef",
+    "ExperimentBinding",
+    "LogicalCatalogResource",
+    "ScenarioDefinition",
+    "ScenarioDifficulty",
+    "ScenarioRole",
+    "Taxonomy",
+    "TaxonomyEntry",
+    "UnsupportedPolicy",
+    "definition_digest",
+    "load_catalog_sources",
+    "parse_catalog_root",
+    "parse_catalog_shard",
+    "parse_taxonomy",
+    "validate_classification",
+    "verify_catalog_sources",
+]
diff --git a/code/src/doc2harness/benchmark/catalog.py b/code/src/doc2harness/benchmark/catalog.py
new file mode 100644
index 0000000000000000000000000000000000000000..43cca0082ccd3b6ab99f28f252636f8349c4ecf2
--- /dev/null
+++ b/code/src/doc2harness/benchmark/catalog.py
@@ -0,0 +1,470 @@
+"""Explicit catalog sources, verification, and authority-backed sealing."""
+
+from __future__ import annotations
+
+import hashlib
+import re
+from collections.abc import Callable
+from dataclasses import dataclass
+
+from doc2harness.benchmark.definition import (
+    DependencyKind,
+    ScenarioDefinition,
+    ScenarioRole,
+    definition_digest,
+)
+from doc2harness.benchmark.taxonomy import (
+    Taxonomy,
+    _exact_keys,
+    _parse_closed_toml,
+    parse_taxonomy,
+    validate_classification,
+)
+from doc2harness.contracts.canonical import canonical_json
+from doc2harness.contracts.primitives import (
+    ContractDocumentError,
+    require_digest,
+)
+
+_SEGMENT = re.compile(r"[A-Za-z0-9][A-Za-z0-9._-]{0,127}\Z", re.ASCII)
+_IDENTIFIER = re.compile(r"[a-z0-9][a-z0-9._-]{0,127}\Z", re.ASCII)
+_MODULE = re.compile(r"[a-z][a-z0-9_]*(?:\.[a-z][a-z0-9_]*)*\Z", re.ASCII)
+_EXPORT = re.compile(r"[a-z][a-z0-9_]{0,127}\Z", re.ASCII)
+_MODULE_PREFIX = "doc2harness.benchmark.harnesses."
+_MAX_DEFINITIONS = 4096
+_MAX_EXPORTS = 4096
+_MAX_SHARDS = 4096
+_MAX_SOURCE_BYTES = 1_048_576
+_SHARD_DOMAIN = b"doc2harness.catalog-shard/1\x00"
+_ROOT_DOMAIN = b"doc2harness.catalog-root/1\x00"
+_VERIFICATION_DOMAIN = b"doc2harness.catalog-verification/1\x00"
+
+
+@dataclass(frozen=True, slots=True)
+class LogicalCatalogResource:
+    """A package-relative resource identity, never a host filesystem path."""
+
+    segments: tuple[str, ...]
+
+    def __post_init__(self) -> None:
+        if type(self.segments) is not tuple or not self.segments or len(self.segments) > 32:
+            raise ContractDocumentError("catalog resource must have bounded exact segments")
+        for segment in self.segments:
+            if type(segment) is not str or _SEGMENT.fullmatch(segment) is None:
+                raise ContractDocumentError("catalog resource contains an unsafe segment")
+            if segment in {".", ".."} or segment.startswith("~") or ":" in segment:
+                raise ContractDocumentError("catalog resource contains an unsafe segment")
+
+
+def _digest(value: object, name: str) -> str:
+    try:
+        return require_digest(value, name=name)
+    except ContractDocumentError:
+        raise
+
+
+def _raw_digest(raw: bytes) -> str:
+    return "sha256:" + hashlib.sha256(raw).hexdigest()
+
+
+def _resource(value: object, name: str) -> LogicalCatalogResource:
+    if type(value) is not str or not value or value.startswith(("/", "~")):
+        raise ContractDocumentError(f"{name} is not a canonical relative resource")
+    if (
+        value.endswith("/")
+        or "//" in value
+        or "\\" in value
+        or ":" in value
+        or "%" in value
+        or not value.isascii()
+    ):
+        raise ContractDocumentError(f"{name} is not a canonical relative resource")
+    return LogicalCatalogResource(tuple(value.split("/")))
+
+
+def _module_export(value: object, name: str) -> tuple[str, str]:
+    row = _exact_keys(value, frozenset({"module", "export"}), name)
+    module = row["module"]
+    export = row["export"]
+    if (
+        type(module) is not str
+        or len(module) > 255
+        or _MODULE.fullmatch(module) is None
+        or not module.startswith(_MODULE_PREFIX)
+    ):
+        raise ContractDocumentError(f"{name} module is not canonical")
+    if type(export) is not str or _EXPORT.fullmatch(export) is None:
+        raise ContractDocumentError(f"{name} export is not canonical")
+    return module, export
+
+
+def _exports(value: object, name: str) -> tuple[tuple[str, str], ...]:
+    if type(value) is not list or not value or len(value) > _MAX_EXPORTS:
+        raise ContractDocumentError(f"{name} must be a bounded non-empty array")
+    result = tuple(_module_export(item, name) for item in value)
+    if result != tuple(sorted(result)) or len(set(result)) != len(result):
+        raise ContractDocumentError(f"{name} must be sorted and unique")
+    return result
+
+
+def _shard_semantic_body(
+    function_id: str,
+    resource: LogicalCatalogResource,
+    exports: tuple[tuple[str, str], ...],
+) -> dict[str, object]:
+    return {
+        "exports": [
+            {"export": export, "module": module} for module, export in exports
+        ],
+        "function_id": function_id,
+        "resource": list(resource.segments),
+    }
+
+
+def _semantic_digest(domain: bytes, body: dict[str, object]) -> str:
+    return "sha256:" + hashlib.sha256(domain + canonical_json(body)).hexdigest()
+
+
+@dataclass(frozen=True, slots=True)
+class CatalogShard:
+    function_id: str
+    resource: LogicalCatalogResource
+    exports: tuple[tuple[str, str], ...]
+    source_digest: str
+    semantic_digest: str
+
+    def __post_init__(self) -> None:
+        if type(self.function_id) is not str or _IDENTIFIER.fullmatch(self.function_id) is None:
+            raise ContractDocumentError("shard function id is not canonical")
+        if type(self.resource) is not LogicalCatalogResource:
+            raise ContractDocumentError("shard resource must be a logical resource")
+        expected_resource = (
+            "benchmark",
+            "harnesses",
+            *self.function_id.split("."),
+            "catalog.toml",
+        )
+        if self.resource.segments != expected_resource:
+            raise ContractDocumentError("shard resource does not match its function")
+        if type(self.exports) is not tuple or not self.exports or len(self.exports) > _MAX_EXPORTS:
+            raise ContractDocumentError("shard exports must be a bounded exact tuple")
+        for item in self.exports:
+            if type(item) is not tuple or len(item) != 2:
+                raise ContractDocumentError("shard exports require exact pairs")
+            module, export = item
+            _module_export({"module": module, "export": export}, "shard export")
+        if self.exports != tuple(sorted(self.exports)) or len(set(self.exports)) != len(self.exports):
+            raise ContractDocumentError("shard exports must be sorted and unique")
+        _digest(self.source_digest, "shard source digest")
+        _digest(self.semantic_digest, "shard semantic digest")
+        expected_semantic = _semantic_digest(
+            _SHARD_DOMAIN,
+            _shard_semantic_body(self.function_id, self.resource, self.exports),
+        )
+        if self.semantic_digest != expected_semantic:
+            raise ContractDocumentError("shard semantic digest differs from its fields")
+
+
+@dataclass(frozen=True, slots=True)
+class CatalogRoot:
+    taxonomy_resource: LogicalCatalogResource
+    taxonomy_digest: str
+    shards: tuple[CatalogShard, ...]
+    source_digest: str
+    semantic_digest: str
+
+    def __post_init__(self) -> None:
+        if (
+            type(self.taxonomy_resource) is not LogicalCatalogResource
+            or self.taxonomy_resource.segments != ("benchmark", "taxonomy.toml")
+        ):
+            raise ContractDocumentError("taxonomy resource is not canonical")
+        _digest(self.taxonomy_digest, "taxonomy digest")
+        if type(self.shards) is not tuple or not self.shards or len(self.shards) > _MAX_SHARDS:
+            raise ContractDocumentError("catalog root must contain a bounded exact shard tuple")
+        if any(type(item) is not CatalogShard for item in self.shards):
+            raise ContractDocumentError("catalog root shards must use CatalogShard")
+        identities = tuple(item.function_id for item in self.shards)
+        resources = tuple(item.resource for item in self.shards)
+        if identities != tuple(sorted(identities)) or len(set(identities)) != len(identities):
+            raise ContractDocumentError("catalog root shard functions must be sorted and unique")
+        if len(set(resources)) != len(resources):
+            raise ContractDocumentError("catalog root shard resources must be unique")
+        export_count = 0
+        seen_exports: set[tuple[str, str]] = set()
+        for shard in self.shards:
+            for export in shard.exports:
+                export_count += 1
+                if export_count > _MAX_EXPORTS:
+                    raise ContractDocumentError("catalog root exports exceed the total limit")
+                if export in seen_exports:
+                    raise ContractDocumentError("catalog root exports must be globally unique")
+                seen_exports.add(export)
+        _digest(self.source_digest, "root source digest")
+        _digest(self.semantic_digest, "root semantic digest")
+        expected_semantic = _semantic_digest(
+            _ROOT_DOMAIN,
+            _root_body(self.taxonomy_resource, self.taxonomy_digest, self.shards),
+        )
+        if self.semantic_digest != expected_semantic:
+            raise ContractDocumentError("root semantic digest differs from its fields")
+
+
+@dataclass(frozen=True, slots=True)
+class CatalogVerification:
+    definitions: tuple[ScenarioDefinition, ...]
+    source_digests: tuple[str, ...]
+    semantic_digest: str
+
+    def __post_init__(self) -> None:
+        if type(self.definitions) is not tuple or not self.definitions:
+            raise ContractDocumentError("catalog verification requires definitions")
+        if any(type(item) is not ScenarioDefinition for item in self.definitions):
+            raise ContractDocumentError("verified definitions must use ScenarioDefinition")
+        if type(self.source_digests) is not tuple or not self.source_digests:
+            raise ContractDocumentError("catalog verification requires source digests")
+        for item in self.source_digests:
+            _digest(item, "source digest")
+        _digest(self.semantic_digest, "catalog semantic digest")
+
+
+CatalogImporter = Callable[[str, str], ScenarioDefinition]
+
+
+def _root_body(
+    taxonomy_resource: LogicalCatalogResource,
+    taxonomy_digest: str,
+    shards: tuple[CatalogShard, ...],
+) -> dict[str, object]:
+    return {
+        "shards": [
+            {
+                "exports": [
+                    {"export": export, "module": module}
+                    for module, export in shard.exports
+                ],
+                "function_id": shard.function_id,
+                "resource": list(shard.resource.segments),
+                "semantic_digest": shard.semantic_digest,
+                "source_digest": shard.source_digest,
+            }
+            for shard in shards
+        ],
+        "taxonomy_resource": list(taxonomy_resource.segments),
+        "taxonomy_source_digest": taxonomy_digest,
+    }
+
+
+def parse_catalog_root(raw: bytes, /) -> CatalogRoot:
+    source = _exact_keys(
+        _parse_closed_toml(raw, "catalog root"),
+        frozenset({"format", "taxonomy_resource", "taxonomy_source_digest", "shards"}),
+        "catalog root",
+    )
+    if source["format"] != "doc2harness.catalog-root-source/1":
+        raise ContractDocumentError("catalog root format is unsupported")
+    taxonomy_resource = _resource(source["taxonomy_resource"], "taxonomy resource")
+    taxonomy_digest = _digest(source["taxonomy_source_digest"], "taxonomy source digest")
+    raw_shards = source["shards"]
+    if type(raw_shards) is not list or not raw_shards or len(raw_shards) > _MAX_SHARDS:
+        raise ContractDocumentError("catalog root shards must be a bounded non-empty array")
+    shards: list[CatalogShard] = []
+    total_exports = 0
+    for item in raw_shards:
+        row = _exact_keys(
+            item,
+            frozenset({"function_id", "resource", "source_digest", "semantic_digest", "exports"}),
+            "catalog root shard",
+        )
+        exports = _exports(row["exports"], "catalog root exports")
+        total_exports += len(exports)
+        if total_exports > _MAX_EXPORTS:
+            raise ContractDocumentError("catalog root exports exceed the total limit")
+        shards.append(
+            CatalogShard(
+                row["function_id"],
+                _resource(row["resource"], "shard resource"),
+                exports,
+                _digest(row["source_digest"], "shard source digest"),
+                _digest(row["semantic_digest"], "shard semantic digest"),
+            )
+        )
+    typed_shards = tuple(shards)
+    semantic = _semantic_digest(
+        _ROOT_DOMAIN,
+        _root_body(taxonomy_resource, taxonomy_digest, typed_shards),
+    )
+    return CatalogRoot(
+        taxonomy_resource,
+        taxonomy_digest,
+        typed_shards,
+        _raw_digest(raw),
+        semantic,
+    )
+
+
+def parse_catalog_shard(raw: bytes, /) -> CatalogShard:
+    source = _exact_keys(
+        _parse_closed_toml(raw, "catalog shard"),
+        frozenset({"format", "function_id", "resource", "exports"}),
+        "catalog shard",
+    )
+    if source["format"] != "doc2harness.catalog-shard-source/1":
+        raise ContractDocumentError("catalog shard format is unsupported")
+    function_id = source["function_id"]
+    resource = _resource(source["resource"], "shard resource")
+    exports = _exports(source["exports"], "catalog shard exports")
+    semantic = _semantic_digest(
+        _SHARD_DOMAIN,
+        _shard_semantic_body(function_id, resource, exports),
+    )
+    return CatalogShard(function_id, resource, exports, _raw_digest(raw), semantic)
+
+
+def _ordered_definitions(
+    definitions: tuple[ScenarioDefinition, ...],
+) -> tuple[dict[str, int], dict[str, ScenarioDefinition]]:
+    if (
+        type(definitions) is not tuple
+        or not definitions
+        or len(definitions) > _MAX_DEFINITIONS
+        or any(type(item) is not ScenarioDefinition for item in definitions)
+    ):
+        raise ContractDocumentError("definitions must be a bounded non-empty exact tuple")
+    order: dict[str, int] = {}
+    by_id: dict[str, ScenarioDefinition] = {}
+    for ordinal, definition in enumerate(definitions):
+        if definition.scenario_id in order:
+            raise ContractDocumentError("scenario ids must be globally unique")
+        order[definition.scenario_id] = ordinal
+        by_id[definition.scenario_id] = definition
+    graph: dict[str, set[str]] = {}
+    for definition in definitions:
+        dependency_ids = tuple(item.scenario_id for item in definition.dependencies)
+        if len(set(dependency_ids)) != len(dependency_ids):
+            raise ContractDocumentError("a scenario cannot reference one id with multiple kinds")
+        unknown = set(dependency_ids) - set(order)
+        if unknown:
+            raise ContractDocumentError("scenario dependency is unknown")
+        for dependency in definition.dependencies:
+            target = by_id[dependency.scenario_id]
+            if dependency.kind in {DependencyKind.CONTROL, DependencyKind.GATE} and (
+                target.role is not ScenarioRole.CONTROL or target.weight_microunits != 0
+            ):
+                raise ContractDocumentError("control and gate dependencies require controls")
+        graph[definition.scenario_id] = set(dependency_ids)
+    remaining = {node: len(edges) for node, edges in graph.items()}
+    dependents: dict[str, set[str]] = {node: set() for node in graph}
+    for node, edges in graph.items():
+        for edge in edges:
+            dependents[edge].add(node)
+    ready = [node for node, count in remaining.items() if count == 0]
+    visited = 0
+    while ready:
+        node = ready.pop()
+        visited += 1
+        for dependent in dependents[node]:
+            remaining[dependent] -= 1
+            if remaining[dependent] == 0:
+                ready.append(dependent)
+    if visited != len(graph):
+        raise ContractDocumentError("scenario dependency graph contains a cycle")
+    return order, by_id
+
+
+def verify_catalog_sources(
+    root: CatalogRoot,
+    definitions: tuple[ScenarioDefinition, ...],
+    /,
+) -> CatalogVerification:
+    if type(root) is not CatalogRoot:
+        raise ContractDocumentError("catalog root must use the exact typed structure")
+    flattened = tuple(
+        (shard.function_id, export)
+        for shard in root.shards
+        for export in shard.exports
+    )
+    if type(definitions) is not tuple or len(definitions) != len(flattened):
+        raise ContractDocumentError("definition count does not match catalog exports")
+    _ordered_definitions(definitions)
+    for definition, (function_id, _export) in zip(definitions, flattened, strict=True):
+        if definition.classification.primary != function_id:
+            raise ContractDocumentError("definition primary classification differs from owner shard")
+    digests = tuple(definition_digest(item) for item in definitions)
+    semantic = _semantic_digest(
+        _VERIFICATION_DOMAIN,
+        {"definition_digests": list(digests), "root_semantic_digest": root.semantic_digest},
+    )
+    source_digests = (
+        root.source_digest,
+        root.taxonomy_digest,
+        *(shard.source_digest for shard in root.shards),
+    )
+    return CatalogVerification(definitions, source_digests, semantic)
+
+
+def load_catalog_sources(
+    root: CatalogRoot,
+    resources: dict[LogicalCatalogResource, bytes],
+    importer: CatalogImporter,
+    /,
+) -> tuple[ScenarioDefinition, ...]:
+    if type(root) is not CatalogRoot or type(resources) is not dict or not callable(importer):
+        raise ContractDocumentError("catalog loading requires exact root, dict resources and importer")
+    if len(resources) > _MAX_SHARDS + 1:
+        raise ContractDocumentError("catalog resources exceed the size limit")
+    if any(type(key) is not LogicalCatalogResource or type(value) is not bytes for key, value in resources.items()):
+        raise ContractDocumentError("catalog resources require exact logical keys and byte values")
+    if any(not value or len(value) > _MAX_SOURCE_BYTES for value in resources.values()):
+        raise ContractDocumentError("catalog resource bytes exceed source limits")
+    snapshot = dict(resources)
+    expected = {root.taxonomy_resource, *(shard.resource for shard in root.shards)}
+    if set(snapshot) != expected:
+        raise ContractDocumentError("catalog resource set does not match the root")
+    taxonomy_raw = snapshot[root.taxonomy_resource]
+    if _raw_digest(taxonomy_raw) != root.taxonomy_digest:
+        raise ContractDocumentError("taxonomy source digest differs from the root")
+    taxonomy: Taxonomy = parse_taxonomy(taxonomy_raw)
+    known_functions = frozenset(item.function_id for item in taxonomy.entries)
+    if any(shard.function_id not in known_functions for shard in root.shards):
+        raise ContractDocumentError("catalog root contains an unknown taxonomy function")
+    parsed_shards: list[CatalogShard] = []
+    for expected_shard in root.shards:
+        raw = snapshot[expected_shard.resource]
+        if _raw_digest(raw) != expected_shard.source_digest:
+            raise ContractDocumentError("shard source digest differs from the root")
+        parsed = parse_catalog_shard(raw)
+        if parsed != expected_shard:
+            raise ContractDocumentError("shard source differs from its root descriptor")
+        parsed_shards.append(parsed)
+    definitions: list[ScenarioDefinition] = []
+    object_ids: set[int] = set()
+    for shard in parsed_shards:
+        for module, export in shard.exports:
+            try:
+                definition = importer(module, export)
+            except Exception:
+                raise ContractDocumentError("catalog importer failed") from None
+            if type(definition) is not ScenarioDefinition:
+                raise ContractDocumentError("catalog importer returned an invalid definition")
+            if id(definition) in object_ids:
+                raise ContractDocumentError("catalog importer reused a definition object")
+            object_ids.add(id(definition))
+            if definition.classification.primary != shard.function_id:
+                raise ContractDocumentError("imported definition differs from its owner shard")
+            validate_classification(definition.classification, taxonomy)
+            definitions.append(definition)
+    return verify_catalog_sources(root, tuple(definitions)).definitions
+
+
+__all__ = [
+    "CatalogImporter",
+    "CatalogRoot",
+    "CatalogShard",
+    "CatalogVerification",
+    "LogicalCatalogResource",
+    "load_catalog_sources",
+    "parse_catalog_root",
+    "parse_catalog_shard",
+    "verify_catalog_sources",
+]
diff --git a/code/src/doc2harness/benchmark/catalog_root.toml b/code/src/doc2harness/benchmark/catalog_root.toml
new file mode 100644
index 0000000000000000000000000000000000000000..9b353ba8164db3cf0cb6ffc498adb448bbade70f
--- /dev/null
+++ b/code/src/doc2harness/benchmark/catalog_root.toml
@@ -0,0 +1,169 @@
+format = "doc2harness.catalog-root-source/1"
+taxonomy_resource = "benchmark/taxonomy.toml"
+taxonomy_source_digest = "sha256:43b99ad485708c75a6ce93c95669b85bd9c384f03cbff027dfb490cc9df3c779"
+
+[[shards]]
+function_id = "artifact"
+resource = "benchmark/harnesses/artifact/catalog.toml"
+source_digest = "sha256:ab17d776974982aabacdaf55493fedef33225bf9f21ba7f4674a3c3430bf6325"
+semantic_digest = "sha256:e0f2c5d47ad715c4b0e56a6166ae4c2e31138327fe0770721da2b237d1fbbd1c"
+exports = [
+  { module = "doc2harness.benchmark.harnesses.artifact.scenarios.artifact_declares_dependencies", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.artifact.scenarios.artifact_has_entry_py", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.artifact.scenarios.artifact_has_install_sh", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.artifact.scenarios.artifact_has_offline_wheel", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.artifact.scenarios.artifact_has_requirements_lock", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.artifact.scenarios.artifact_has_run_agent_sh", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.artifact.scenarios.artifact_has_version_file", export = "definition" },
+]
+
+[[shards]]
+function_id = "direct"
+resource = "benchmark/harnesses/direct/catalog.toml"
+source_digest = "sha256:b83648161b87b31473c4eaf384b44830a2a9a1a9ed874119c1b6cbe152f66cb7"
+semantic_digest = "sha256:7555e696b9886c9f87c30bbaa01b3afaa0817a9e40e9368841d967e5577db54c"
+exports = [
+  { module = "doc2harness.benchmark.harnesses.direct.scenarios.exfil_glob_pem_not_leaked", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.direct.scenarios.http_proxy_hermetic", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.direct.scenarios.http_proxy_hermetic_control", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.direct.scenarios.quality_gate_blocks_completion", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.direct.scenarios.quality_gate_blocks_completion_control", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.direct.scenarios.secret_probe_mechanism_control", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.direct.scenarios.shell_output_edge_whitespace", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.direct.scenarios.shell_output_edge_whitespace_control", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.direct.scenarios.unreferenced_secret_not_in_request_body", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.direct.scenarios.webfetch_http_failure", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.direct.scenarios.webfetch_http_failure_control", export = "definition" },
+]
+
+[[shards]]
+function_id = "extension"
+resource = "benchmark/harnesses/extension/catalog.toml"
+source_digest = "sha256:78ca3a4f9b32aae12a3f901fa8fe6ba621de830fa0c01319f226743a59d7ecfb"
+semantic_digest = "sha256:1cd6e9811b82411ccd00fa4f43828beff035d9ec9d7e35a1354c75cc92ae7abc"
+exports = [
+  { module = "doc2harness.benchmark.harnesses.extension.scenarios.extension_definition_symlink_outside_fenced", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.extension.scenarios.extension_inside_symlink_discovery_control", export = "definition" },
+]
+
+[[shards]]
+function_id = "file"
+resource = "benchmark/harnesses/file/catalog.toml"
+source_digest = "sha256:7f3ae97eca67f93812bef69a8d591b9d76527593b8c237548d39a1f42939faf5"
+semantic_digest = "sha256:202e42f04f066970a2e65ad02f6b7bea1b86398be2cbcb0183a2dd1a7936bc45"
+exports = [
+  { module = "doc2harness.benchmark.harnesses.file.scenarios.file_symlink_inside_still_readable_control", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.file.scenarios.glob_finds_inside_control", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.file.scenarios.glob_truncation_keeps_sorted_end", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.file.scenarios.grep_default_mode_returns_path_control", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.file.scenarios.grep_finds_needle_control", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.file.scenarios.grep_head_limit_zero_not_unlimited", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.file.scenarios.grep_type_filter_ignored", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.file.scenarios.memory_get_abs_path_escapes_workspace", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.file.scenarios.notebook_edit_cell_isolation", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.file.scenarios.notebook_edit_delete_keeps_neighbors", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.file.scenarios.p32_ctl_memory_get_reads_inside_workspace", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.file.scenarios.read_char_device_bounded", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.file.scenarios.read_regular_file_control", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.file.scenarios.read_via_symlink_outside_workspace_bounded", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.file.scenarios.rewind_restores_edited_file", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.file.scenarios.symlink_to_outside_target_readable_control", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.file.scenarios.undo_reverts_overwrite_control", export = "definition" },
+]
+
+[[shards]]
+function_id = "headless"
+resource = "benchmark/harnesses/headless/catalog.toml"
+source_digest = "sha256:ec48824b157b32c10beab39254d57924756a62069e91c547a89e5f3ae5618704"
+semantic_digest = "sha256:f29ef08c7ea259da1515f99be1860413a083c95f127141c8f25ccefb42567b55"
+exports = [
+  { module = "doc2harness.benchmark.harnesses.headless.scenarios.at_ref_expands_in_headless", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.headless.scenarios.budget_type_domain", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.headless.scenarios.budget_type_domain_control", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.headless.scenarios.exec_requires_bg", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.headless.scenarios.exec_requires_bg_control", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.headless.scenarios.headless_p_json_model_error_wellformed", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.headless.scenarios.headless_p_json_wellformed", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.headless.scenarios.p34_ctl_bare_mention_not_auto_read", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.headless.scenarios.p34_ctl_task_text_reaches_wire", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.headless.scenarios.runtime_error_stdout", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.headless.scenarios.runtime_error_stdout_control", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.headless.scenarios.session_flag_subcommand_conflict", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.headless.scenarios.session_flag_subcommand_conflict_control", export = "definition" },
+]
+
+[[shards]]
+function_id = "permission"
+resource = "benchmark/harnesses/permission/catalog.toml"
+source_digest = "sha256:c515c06dbb8a17857ce86242bd0045a573c6684b4e56e7a1ee4e342980058be4"
+semantic_digest = "sha256:d0cd5ba6de354ad72f8abbc46b7353db084e86325d99b2c26a36bf1a2cfc6b83"
+exports = [
+  { module = "doc2harness.benchmark.harnesses.permission.scenarios.ask_mode_denies_write_and_allows_read", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.permission.scenarios.autoedit_blocks_mutable_shell", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.permission.scenarios.autoreview_blocks_canonical_danger", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.permission.scenarios.blocking_hook_missing_exec_control", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.permission.scenarios.blocking_hook_missing_exec_fail_closed", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.permission.scenarios.custom_cmd_at_file_read_fences_control", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.permission.scenarios.custom_cmd_at_file_respects_read_fences", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.permission.scenarios.deny_blocks_monitor_spawned_cmd", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.permission.scenarios.hook_absent_bash_write_runs_control", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.permission.scenarios.hook_blocks_bash_write", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.permission.scenarios.monitor_spawns_command_control", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.permission.scenarios.network_off_blocks_offline_npm_test", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.permission.scenarios.p37_ctl_plain_cmd_chain_runs", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.permission.scenarios.p46_ctl_yolo_rm_really_deletes", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.permission.scenarios.p60_ctl_yolo_both_work", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.permission.scenarios.yolo_mutable_shell_lands_control", export = "definition" },
+]
+
+[[shards]]
+function_id = "startup"
+resource = "benchmark/harnesses/startup/catalog.toml"
+source_digest = "sha256:9893ae5607570c43319ca2934f2c2eb451276c7cff31fe9496aee84fd4391f20"
+semantic_digest = "sha256:7439429b84748b822599c2bd4a4cbab0270f39c0ececc93eb991d632ebf010c1"
+exports = [
+  { module = "doc2harness.benchmark.harnesses.startup.scenarios.launcher_ambient_python_isolated", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.startup.scenarios.launcher_health_control", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.startup.scenarios.launcher_python_minimum_fallback", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.startup.scenarios.startup_bom_config", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.startup.scenarios.startup_broken_config_file", export = "definition" },
+]
+
+[[shards]]
+function_id = "state"
+resource = "benchmark/harnesses/state/catalog.toml"
+source_digest = "sha256:29d6d7694b1821cd86e0767784ab8fe17851de947a117557acf59bcd60b4b193"
+semantic_digest = "sha256:bfb6dfab995d43d01c912c0c05eb7ef919281e30c16b5009134693fd7679fcdc"
+exports = [
+  { module = "doc2harness.benchmark.harnesses.state.scenarios.agent_api_close_retry_incomplete", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.state.scenarios.agent_api_close_retry_incomplete_control", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.state.scenarios.child_add_dir_inheritance", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.state.scenarios.child_add_dir_inheritance_control", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.state.scenarios.copy_utf8_clipboard_bytes", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.state.scenarios.copy_utf8_clipboard_control", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.state.scenarios.custom_args_no_secondary_expansion", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.state.scenarios.custom_args_single_expansion_control", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.state.scenarios.memory_query_topk_residency", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.state.scenarios.memory_query_topk_residency_control", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.state.scenarios.p30_ctl_security_review_sees_worktree_change", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.state.scenarios.plugin_declared_command_reaches_wire", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.state.scenarios.plugin_toplevel_command_control", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.state.scenarios.security_review_covers_branch_commits", export = "definition" },
+]
+
+[[shards]]
+function_id = "tui"
+resource = "benchmark/harnesses/tui/catalog.toml"
+source_digest = "sha256:33c5b7a874a86ed54b7dd7bef266298e13ad78c0618968fa05c586e20a39e6bd"
+semantic_digest = "sha256:71eb0680a3a71bb9e913bb666c282d30aa43802baca4f3a41c859433acb54a98"
+exports = [
+  { module = "doc2harness.benchmark.harnesses.tui.scenarios.history_realpath_key", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.tui.scenarios.history_workspace_a_fresh_control", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.tui.scenarios.history_workspace_b_fresh_control", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.tui.scenarios.trajectory_autocommit_fail_recorded", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.tui.scenarios.trajectory_autocommit_fail_recorded_control", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.tui.scenarios.trajectory_step_limit_terminal_accurate", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.tui.scenarios.trajectory_step_limit_terminal_accurate_control", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.tui.scenarios.tui_bang_alone_enters_shell_mode", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.tui.scenarios.tui_ctrl_byte_storm_survives", export = "definition" },
+]
diff --git a/code/src/doc2harness/benchmark/definition.py b/code/src/doc2harness/benchmark/definition.py
new file mode 100644
index 0000000000000000000000000000000000000000..92261eb0134ecd8a1f67348d8669e09c874cff55
--- /dev/null
+++ b/code/src/doc2harness/benchmark/definition.py
@@ -0,0 +1,220 @@
+"""Immutable scenario definitions without execution behavior."""
+
+from __future__ import annotations
+
+import hashlib
+import re
+from dataclasses import dataclass
+from enum import Enum
+
+from doc2harness.contracts.canonical import canonical_json
+from doc2harness.contracts.primitives import ContractDocumentError
+
+_IDENTIFIER = re.compile(r"[a-z0-9][a-z0-9._-]{0,127}\Z", re.ASCII)
+_REVISION = re.compile(r"[1-9][0-9]{0,8}\Z", re.ASCII)
+_DIGEST_DOMAIN = b"doc2harness.scenario-definition/1\x00"
+_MAX_CLASSIFICATIONS = 32
+_MAX_DEPENDENCIES = 256
+_MAX_WEIGHT = 2**63 - 1
+
+
+def _identifier(value: object, name: str) -> str:
+    if type(value) is not str or _IDENTIFIER.fullmatch(value) is None:
+        raise ContractDocumentError(f"{name} is not a canonical identifier")
+    return value
+
+
+class ScenarioRole(str, Enum):
+    TARGET = "TARGET"
+    CONTROL = "CONTROL"
+
+
+class ScenarioDifficulty(str, Enum):
+    STANDARD = "STANDARD"
+    HARD = "HARD"
+
+
+class UnsupportedPolicy(str, Enum):
+    FAIL = "FAIL"
+    NOT_APPLICABLE = "NOT_APPLICABLE"
+
+
+class ComponentKind(str, Enum):
+    FIXTURE = "FIXTURE"
+    STIMULUS = "STIMULUS"
+    OBSERVER = "OBSERVER"
+    ORACLE = "ORACLE"
+    CLEANUP = "CLEANUP"
+    NO_OP = "NO_OP"
+
+
+class DependencyKind(str, Enum):
+    REQUIREMENT = "REQUIREMENT"
+    CONTROL = "CONTROL"
+    GATE = "GATE"
+
+
+@dataclass(frozen=True, slots=True)
+class Classification:
+    """One stable primary function and zero or more ordered secondary functions."""
+
+    primary: str
+    secondary: tuple[str, ...] = ()
+
+    def __post_init__(self) -> None:
+        _identifier(self.primary, "primary classification")
+        if type(self.secondary) is not tuple:
+            raise ContractDocumentError("secondary classifications must be an exact tuple")
+        if len(self.secondary) > _MAX_CLASSIFICATIONS:
+            raise ContractDocumentError("secondary classifications exceed the size limit")
+        for item in self.secondary:
+            _identifier(item, "secondary classification")
+        if self.primary in self.secondary or len(set(self.secondary)) != len(self.secondary):
+            raise ContractDocumentError("classifications must be unique")
+        if self.secondary != tuple(sorted(self.secondary)):
+            raise ContractDocumentError("secondary classifications must be sorted")
+
+
+@dataclass(frozen=True, slots=True)
+class ComponentRef:
+    """A versioned component identity; NO_OP is explicit, never represented by None."""
+
+    component_id: str
+    revision: str
+    kind: ComponentKind
+
+    def __post_init__(self) -> None:
+        _identifier(self.component_id, "component id")
+        if type(self.revision) is not str or _REVISION.fullmatch(self.revision) is None:
+            raise ContractDocumentError("component revision is not canonical")
+        if type(self.kind) is not ComponentKind:
+            raise ContractDocumentError("component kind must use ComponentKind")
+        if self.kind is ComponentKind.NO_OP and self.component_id != "no-op":
+            raise ContractDocumentError("NO_OP must use the canonical no-op component")
+        if self.kind is not ComponentKind.NO_OP and self.component_id == "no-op":
+            raise ContractDocumentError("the canonical no-op component must use NO_OP")
+
+    @classmethod
+    def no_op(cls) -> ComponentRef:
+        return cls("no-op", "1", ComponentKind.NO_OP)
+
+
+@dataclass(frozen=True, slots=True)
+class DependencyRef:
+    scenario_id: str
+    kind: DependencyKind
+
+    def __post_init__(self) -> None:
+        _identifier(self.scenario_id, "dependency scenario id")
+        if type(self.kind) is not DependencyKind:
+            raise ContractDocumentError("dependency kind must use DependencyKind")
+
+
+@dataclass(frozen=True, slots=True)
+class ExperimentBinding:
+    fixture: ComponentRef
+    stimulus: ComponentRef
+    observer: ComponentRef
+    oracle: ComponentRef
+    cleanup: ComponentRef
+
+    def __post_init__(self) -> None:
+        expected = (
+            (self.fixture, ComponentKind.FIXTURE),
+            (self.stimulus, ComponentKind.STIMULUS),
+            (self.observer, ComponentKind.OBSERVER),
+            (self.oracle, ComponentKind.ORACLE),
+            (self.cleanup, ComponentKind.CLEANUP),
+        )
+        for value, kind in expected:
+            if type(value) is not ComponentRef:
+                raise ContractDocumentError("experiment bindings require exact ComponentRef values")
+            if value.kind not in {kind, ComponentKind.NO_OP}:
+                raise ContractDocumentError("component kind does not match its binding slot")
+
+
+@dataclass(frozen=True, slots=True)
+class ScenarioDefinition:
+    scenario_id: str
+    revision: str
+    classification: Classification
+    role: ScenarioRole
+    weight_microunits: int
+    difficulty: ScenarioDifficulty
+    dependencies: tuple[DependencyRef, ...]
+    experiment: ExperimentBinding
+    unsupported_policy: UnsupportedPolicy
+
+    def __post_init__(self) -> None:
+        _identifier(self.scenario_id, "scenario id")
+        if type(self.revision) is not str or _REVISION.fullmatch(self.revision) is None:
+            raise ContractDocumentError("scenario revision is not canonical")
+        if type(self.classification) is not Classification:
+            raise ContractDocumentError("classification must use the exact typed structure")
+        if type(self.role) is not ScenarioRole:
+            raise ContractDocumentError("role must use ScenarioRole")
+        if (
+            type(self.weight_microunits) is not int
+            or self.weight_microunits < 0
+            or self.weight_microunits > _MAX_WEIGHT
+        ):
+            raise ContractDocumentError("weight must be a bounded non-negative exact integer")
+        if (self.role is ScenarioRole.TARGET) != (self.weight_microunits > 0):
+            raise ContractDocumentError("targets require positive weight and controls require zero weight")
+        if type(self.difficulty) is not ScenarioDifficulty:
+            raise ContractDocumentError("difficulty must use ScenarioDifficulty")
+        if type(self.dependencies) is not tuple or len(self.dependencies) > _MAX_DEPENDENCIES:
+            raise ContractDocumentError("dependencies must be a bounded exact tuple")
+        if any(type(item) is not DependencyRef for item in self.dependencies):
+            raise ContractDocumentError("dependencies must be an exact tuple of DependencyRef")
+        identities = tuple((item.scenario_id, item.kind.value) for item in self.dependencies)
+        if len(set(identities)) != len(identities) or identities != tuple(sorted(identities)):
+            raise ContractDocumentError("dependencies must be sorted and unique")
+        if any(item.scenario_id == self.scenario_id for item in self.dependencies):
+            raise ContractDocumentError("scenario cannot depend on itself")
+        if type(self.experiment) is not ExperimentBinding:
+            raise ContractDocumentError("experiment must use ExperimentBinding")
+        if type(self.unsupported_policy) is not UnsupportedPolicy:
+            raise ContractDocumentError("unsupported policy must use UnsupportedPolicy")
+
+
+def _component_body(value: ComponentRef) -> dict[str, str]:
+    return {"component_id": value.component_id, "kind": value.kind.value, "revision": value.revision}
+
+
+def definition_digest(definition: ScenarioDefinition, /) -> str:
+    """Return the domain-separated semantic digest of one typed definition."""
+
+    if type(definition) is not ScenarioDefinition:
+        raise ContractDocumentError("definition must use ScenarioDefinition")
+    body = {
+        "classification": {
+            "primary": definition.classification.primary,
+            "secondary": list(definition.classification.secondary),
+        },
+        "dependencies": [
+            {"kind": item.kind.value, "scenario_id": item.scenario_id}
+            for item in definition.dependencies
+        ],
+        "difficulty": definition.difficulty.value,
+        "experiment": {
+            "cleanup": _component_body(definition.experiment.cleanup),
+            "fixture": _component_body(definition.experiment.fixture),
+            "observer": _component_body(definition.experiment.observer),
+            "oracle": _component_body(definition.experiment.oracle),
+            "stimulus": _component_body(definition.experiment.stimulus),
+        },
+        "revision": definition.revision,
+        "role": definition.role.value,
+        "scenario_id": definition.scenario_id,
+        "unsupported_policy": definition.unsupported_policy.value,
+        "weight_microunits": definition.weight_microunits,
+    }
+    return "sha256:" + hashlib.sha256(_DIGEST_DOMAIN + canonical_json(body)).hexdigest()
+
+
+__all__ = [
+    "Classification", "ComponentKind", "ComponentRef", "DependencyKind",
+    "DependencyRef", "ExperimentBinding", "ScenarioDefinition", "ScenarioDifficulty",
+    "ScenarioRole", "UnsupportedPolicy", "definition_digest",
+]
diff --git a/code/src/doc2harness/benchmark/dispatch.py b/code/src/doc2harness/benchmark/dispatch.py
new file mode 100644
index 0000000000000000000000000000000000000000..7b7d1f1bfb550927c7a18936d4ada16b3aa4e97e
--- /dev/null
+++ b/code/src/doc2harness/benchmark/dispatch.py
@@ -0,0 +1,108 @@
+"""Resolve active catalog IDs to their scenario-local execution owners."""
+
+from __future__ import annotations
+
+import importlib
+from dataclasses import dataclass
+from functools import lru_cache
+from importlib.resources import files
+from typing import Callable
+
+from doc2harness.benchmark.catalog import (
+    CatalogRoot,
+    load_catalog_sources,
+    parse_catalog_root,
+)
+from doc2harness.benchmark.definition import ScenarioDefinition
+from doc2harness.contracts.primitives import ContractDocumentError
+
+_PACKAGE = "doc2harness"
+_BENCHMARK = "benchmark"
+
+
+@dataclass(frozen=True, slots=True)
+class ScenarioOwner:
+    """One catalog definition and the module that owns its runtime recipe."""
+
+    definition: ScenarioDefinition
+    scenario: object
+    judge: Callable[[object], object]
+    module: str
+
+
+def _catalog_root() -> CatalogRoot:
+    root = files(_PACKAGE).joinpath(_BENCHMARK)
+    return parse_catalog_root(root.joinpath("catalog_root.toml").read_bytes())
+
+
+@lru_cache(maxsize=1)
+def _definitions_and_modules() -> tuple[
+    tuple[ScenarioDefinition, ...], dict[str, str]
+]:
+    package = files(_PACKAGE)
+    benchmark = package.joinpath(_BENCHMARK)
+    root = _catalog_root()
+    resources = {
+        root.taxonomy_resource: benchmark.joinpath("taxonomy.toml").read_bytes(),
+        **{
+            shard.resource: package.joinpath(*shard.resource.segments).read_bytes()
+            for shard in root.shards
+        },
+    }
+    definitions = load_catalog_sources(
+        root,
+        resources,
+        lambda module, export: getattr(importlib.import_module(module), export),
+    )
+    modules = {
+        getattr(importlib.import_module(module), export).scenario_id: module
+        for shard in root.shards
+        for module, export in shard.exports
+    }
+    if len(modules) != len(definitions):
+        raise ContractDocumentError("active catalog module index is ambiguous")
+    return definitions, modules
+
+
+def active_scenario_ids() -> tuple[str, ...]:
+    """Return the complete, catalog-ordered active scenario universe."""
+
+    definitions, _ = _definitions_and_modules()
+    return tuple(item.scenario_id for item in definitions)
+
+
+def load_scenario_owner(scenario_id: str, /) -> ScenarioOwner:
+    """Load one local recipe/judge owner and verify its catalog binding."""
+
+    if type(scenario_id) is not str or not scenario_id:
+        raise ContractDocumentError("scenario id must be a non-empty string")
+    definitions, modules = _definitions_and_modules()
+    definitions_by_id = {item.scenario_id: item for item in definitions}
+    definition = definitions_by_id.get(scenario_id)
+    module_name = modules.get(scenario_id)
+    if definition is None or module_name is None:
+        raise ContractDocumentError("scenario id is absent from the active catalog")
+    module = importlib.import_module(module_name)
+    scenario = getattr(module, "SCENARIO", None)
+    alias = getattr(module, "scenario", None)
+    judge = getattr(module, "judge", None)
+    local_definition = getattr(module, "definition", None)
+    if scenario is None or alias is None:
+        raise ContractDocumentError("scenario module has no canonical local owner")
+    if local_definition is not definition:
+        raise ContractDocumentError("scenario module definition differs from catalog import")
+    owned_definition = getattr(scenario, "definition", None)
+    if owned_definition is not definition:
+        raise ContractDocumentError("scenario owner definition differs from catalog import")
+    if getattr(alias, "definition", None) is not definition:
+        raise ContractDocumentError("catalog compatibility scenario differs from catalog import")
+    if not callable(judge):
+        raise ContractDocumentError("scenario module has no local judge")
+    return ScenarioOwner(definition, scenario, judge, module_name)
+
+
+__all__ = [
+    "ScenarioOwner",
+    "active_scenario_ids",
+    "load_scenario_owner",
+]
diff --git a/code/src/doc2harness/benchmark/harnesses/__init__.py b/code/src/doc2harness/benchmark/harnesses/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..a71017ff1f7f676033e4b16621424e31f562cad3
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/__init__.py
@@ -0,0 +1,3 @@
+"""Primary Harness layer packages."""
+
+__all__: list[str] = []
diff --git a/code/src/doc2harness/benchmark/harnesses/artifact/__init__.py b/code/src/doc2harness/benchmark/harnesses/artifact/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..b4855458fef17eeb99a820e781cf7fd19f317f95
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/artifact/__init__.py
@@ -0,0 +1,29 @@
+"""Typed declarations for the static artifact Harness layer."""
+
+from doc2harness.benchmark.harnesses.artifact.contracts import (
+    ArtifactLogicalPath,
+    ArtifactProbe,
+    ArtifactProbeApplicability,
+    ArtifactProbeEvaluation,
+    ArtifactProbeKind,
+    ArtifactProbeMetrics,
+    ArtifactProbeObservation,
+    ArtifactProbeOutcome,
+    ArtifactScenario,
+    create_artifact_probe_observation,
+    define_artifact_scenario,
+)
+
+__all__ = [
+    "ArtifactLogicalPath",
+    "ArtifactProbe",
+    "ArtifactProbeApplicability",
+    "ArtifactProbeEvaluation",
+    "ArtifactProbeKind",
+    "ArtifactProbeMetrics",
+    "ArtifactProbeObservation",
+    "ArtifactProbeOutcome",
+    "ArtifactScenario",
+    "create_artifact_probe_observation",
+    "define_artifact_scenario",
+]
diff --git a/code/src/doc2harness/benchmark/harnesses/artifact/catalog.toml b/code/src/doc2harness/benchmark/harnesses/artifact/catalog.toml
new file mode 100644
index 0000000000000000000000000000000000000000..a5b3b1c119fbfa0c9faa242543f03bba735792d3
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/artifact/catalog.toml
@@ -0,0 +1,12 @@
+format = "doc2harness.catalog-shard-source/1"
+function_id = "artifact"
+resource = "benchmark/harnesses/artifact/catalog.toml"
+exports = [
+  { module = "doc2harness.benchmark.harnesses.artifact.scenarios.artifact_declares_dependencies", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.artifact.scenarios.artifact_has_entry_py", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.artifact.scenarios.artifact_has_install_sh", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.artifact.scenarios.artifact_has_offline_wheel", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.artifact.scenarios.artifact_has_requirements_lock", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.artifact.scenarios.artifact_has_run_agent_sh", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.artifact.scenarios.artifact_has_version_file", export = "definition" },
+]
diff --git a/code/src/doc2harness/benchmark/harnesses/artifact/contracts.py b/code/src/doc2harness/benchmark/harnesses/artifact/contracts.py
new file mode 100644
index 0000000000000000000000000000000000000000..932c6a349df8df14f88fcf6cf92e12d9b1ae3142
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/artifact/contracts.py
@@ -0,0 +1,394 @@
+"""Fail-closed declaration boundary for static artifact scenarios."""
+
+from __future__ import annotations
+
+import re
+import unicodedata
+import hashlib
+from dataclasses import dataclass
+from enum import Enum
+
+from doc2harness.benchmark.definition import (
+    Classification,
+    ComponentKind,
+    ComponentRef,
+    ExperimentBinding,
+    ScenarioDefinition,
+    ScenarioDifficulty,
+    ScenarioRole,
+    UnsupportedPolicy,
+    definition_digest,
+)
+from doc2harness.contracts.canonical import canonical_json
+from doc2harness.contracts.primitives import ContractDocumentError
+
+_SCENARIO_ID = re.compile(r"[a-z0-9][a-z0-9._-]{0,127}\Z", re.ASCII)
+_MAX_PATHS = 8
+_MAX_SEGMENTS = 32
+_MAX_SEGMENT_BYTES = 255
+
+
+class ArtifactProbeKind(str, Enum):
+    FILE_PRESENT = "FILE_PRESENT"
+    FILE_NONEMPTY = "FILE_NONEMPTY"
+    DIRECTORY_MEMBER_SUFFIX = "DIRECTORY_MEMBER_SUFFIX"
+    DEPENDENCY_DECLARATION = "DEPENDENCY_DECLARATION"
+
+
+class ArtifactProbeOutcome(str, Enum):
+    PASS = "PASS"
+    FAIL = "FAIL"
+
+
+class ArtifactProbeApplicability(str, Enum):
+    APPLICABLE = "APPLICABLE"
+
+
+@dataclass(frozen=True, slots=True)
+class ArtifactLogicalPath:
+    """A bounded path relative to the runtime-owned artifact root."""
+
+    segments: tuple[str, ...]
+
+    def __post_init__(self) -> None:
+        if type(self.segments) is not tuple or not self.segments or len(self.segments) > _MAX_SEGMENTS:
+            raise ContractDocumentError("artifact path must contain bounded exact segments")
+        for segment in self.segments:
+            if type(segment) is not str or segment in {"", ".", ".."}:
+                raise ContractDocumentError("artifact path contains an invalid segment")
+            if unicodedata.normalize("NFC", segment) != segment:
+                raise ContractDocumentError("artifact path segment is not Unicode NFC")
+            try:
+                encoded = segment.encode("utf-8", errors="strict")
+            except UnicodeError:
+                raise ContractDocumentError("artifact path segment is not valid UTF-8") from None
+            if (
+                len(encoded) > _MAX_SEGMENT_BYTES
+                or "/" in segment
+                or "\\" in segment
+                or any(ord(character) < 32 or ord(character) == 127 for character in segment)
+            ):
+                raise ContractDocumentError("artifact path segment is unsafe")
+
+
+@dataclass(frozen=True, slots=True)
+class ArtifactProbe:
+    """Declarative probe intent; it contains no host path or execution behavior."""
+
+    kind: ArtifactProbeKind
+    paths: tuple[ArtifactLogicalPath, ...]
+    member_suffix: str | None = None
+
+    def __post_init__(self) -> None:
+        if type(self.kind) is not ArtifactProbeKind:
+            raise ContractDocumentError("artifact probe kind must use the closed vocabulary")
+        if (
+            type(self.paths) is not tuple
+            or not self.paths
+            or len(self.paths) > _MAX_PATHS
+            or any(type(path) is not ArtifactLogicalPath for path in self.paths)
+        ):
+            raise ContractDocumentError("artifact probe paths must be a bounded exact tuple")
+        if len(set(self.paths)) != len(self.paths):
+            raise ContractDocumentError("artifact probe paths must be unique")
+        if self.kind is ArtifactProbeKind.DIRECTORY_MEMBER_SUFFIX:
+            if (
+                len(self.paths) != 1
+                or type(self.member_suffix) is not str
+                or not self.member_suffix.startswith(".")
+                or len(self.member_suffix) > 32
+                or not self.member_suffix.isascii()
+                or any(character in self.member_suffix for character in "/\\")
+            ):
+                raise ContractDocumentError("directory member probes require one safe suffix")
+        elif self.kind is ArtifactProbeKind.DEPENDENCY_DECLARATION:
+            expected = (
+                ArtifactLogicalPath(("pyproject.toml",)),
+                ArtifactLogicalPath(("requirements.txt",)),
+            )
+            if self.paths != expected or self.member_suffix is not None:
+                raise ContractDocumentError("dependency probes require the canonical manifest paths")
+        elif len(self.paths) != 1 or self.member_suffix is not None:
+            raise ContractDocumentError("file probes require one path and no suffix")
+
+
+@dataclass(frozen=True, slots=True)
+class ArtifactScenario:
+    """One immutable scenario definition paired with its declarative probe."""
+
+    definition: ScenarioDefinition
+    probe: ArtifactProbe
+
+    def __post_init__(self) -> None:
+        if type(self.definition) is not ScenarioDefinition or type(self.probe) is not ArtifactProbe:
+            raise ContractDocumentError("artifact scenarios require exact typed values")
+        if self.definition.classification.primary != "artifact":
+            raise ContractDocumentError("artifact scenario owner differs from its Harness layer")
+
+
+@dataclass(frozen=True, slots=True)
+class ArtifactProbeMetrics:
+    """Closed path-free facts emitted by the four static probe shapes."""
+
+    file_exists: bool | None = None
+    directory_exists: bool | None = None
+    size_bytes: int | None = None
+    matching_members: int | None = None
+    project_marker: bool | None = None
+    requirements_nonempty: bool | None = None
+
+    def __post_init__(self) -> None:
+        for value in (
+            self.file_exists,
+            self.directory_exists,
+            self.project_marker,
+            self.requirements_nonempty,
+        ):
+            if value is not None and type(value) is not bool:
+                raise ContractDocumentError("artifact metric booleans must be exact bool values")
+        for value in (self.size_bytes, self.matching_members):
+            if value is not None and (type(value) is not int or value < 0):
+                raise ContractDocumentError("artifact metric counts must be non-negative exact integers")
+
+
+def _digest(value: object, name: str) -> str:
+    if (
+        type(value) is not str
+        or not value.startswith("sha256:")
+        or len(value) != 71
+        or any(character not in "0123456789abcdef" for character in value[7:])
+    ):
+        raise ContractDocumentError(f"{name} is invalid")
+    return value
+
+
+def _probe_body(probe: ArtifactProbe) -> dict[str, object]:
+    return {
+        "kind": probe.kind.value,
+        "member_suffix": probe.member_suffix,
+        "paths": [list(path.segments) for path in probe.paths],
+    }
+
+
+def _metrics_body(metrics: ArtifactProbeMetrics) -> dict[str, object]:
+    return {
+        "directory_exists": metrics.directory_exists,
+        "file_exists": metrics.file_exists,
+        "matching_members": metrics.matching_members,
+        "project_marker": metrics.project_marker,
+        "requirements_nonempty": metrics.requirements_nonempty,
+        "size_bytes": metrics.size_bytes,
+    }
+
+
+def _observation_digest(
+    scenario_id: str,
+    scenario_revision: str,
+    semantic_definition_digest: str,
+    artifact_id: str,
+    artifact_digest: str,
+    probe: ArtifactProbe,
+    metrics: ArtifactProbeMetrics,
+    runtime_evidence_digests: tuple[str, ...],
+) -> str:
+    body = {
+        "artifact": {"artifact_id": artifact_id, "content_digest": artifact_digest},
+        "definition_digest": semantic_definition_digest,
+        "metrics": _metrics_body(metrics),
+        "probe": _probe_body(probe),
+        "runtime_evidence_digests": list(runtime_evidence_digests),
+        "scenario_id": scenario_id,
+        "scenario_revision": scenario_revision,
+    }
+    domain = b"doc2harness.artifact-static-probe-evidence/1\0"
+    return "sha256:" + hashlib.sha256(domain + canonical_json(body)).hexdigest()
+
+
+@dataclass(frozen=True, slots=True)
+class ArtifactProbeObservation:
+    """Path-free facts bound to definition, artifact, probe and runtime evidence."""
+
+    scenario_id: str
+    scenario_revision: str
+    definition_digest: str
+    artifact_id: str
+    artifact_digest: str
+    probe: ArtifactProbe
+    metrics: ArtifactProbeMetrics
+    runtime_evidence_digests: tuple[str, ...]
+    evidence_digest: str
+
+    def __post_init__(self) -> None:
+        if type(self.scenario_id) is not str or _SCENARIO_ID.fullmatch(self.scenario_id) is None:
+            raise ContractDocumentError("artifact observation scenario id is invalid")
+        if type(self.scenario_revision) is not str or not self.scenario_revision.isascii():
+            raise ContractDocumentError("artifact observation revision is invalid")
+        _digest(self.definition_digest, "artifact observation definition digest")
+        if type(self.artifact_id) is not str or _SCENARIO_ID.fullmatch(self.artifact_id) is None:
+            raise ContractDocumentError("artifact observation artifact id is invalid")
+        _digest(self.artifact_digest, "artifact observation artifact digest")
+        if type(self.probe) is not ArtifactProbe or type(self.metrics) is not ArtifactProbeMetrics:
+            raise ContractDocumentError("artifact observation uses invalid typed facts")
+        if type(self.runtime_evidence_digests) is not tuple or not self.runtime_evidence_digests:
+            raise ContractDocumentError("artifact observation requires runtime evidence")
+        for value in self.runtime_evidence_digests:
+            _digest(value, "artifact runtime evidence digest")
+        _digest(self.evidence_digest, "artifact observation digest")
+        expected = _observation_digest(
+            self.scenario_id,
+            self.scenario_revision,
+            self.definition_digest,
+            self.artifact_id,
+            self.artifact_digest,
+            self.probe,
+            self.metrics,
+            self.runtime_evidence_digests,
+        )
+        if self.evidence_digest != expected:
+            raise ContractDocumentError("artifact observation evidence does not bind its facts")
+
+
+def create_artifact_probe_observation(
+    scenario: ArtifactScenario,
+    artifact_id: str,
+    artifact_digest: str,
+    metrics: ArtifactProbeMetrics,
+    runtime_evidence_digests: tuple[str, ...],
+    /,
+) -> ArtifactProbeObservation:
+    """Seal runtime facts to their scenario, artifact and lower-level evidence."""
+
+    if type(scenario) is not ArtifactScenario or type(metrics) is not ArtifactProbeMetrics:
+        raise ContractDocumentError("artifact observation inputs use invalid typed contracts")
+    semantic_digest = definition_digest(scenario.definition)
+    evidence = _observation_digest(
+        scenario.definition.scenario_id,
+        scenario.definition.revision,
+        semantic_digest,
+        artifact_id,
+        artifact_digest,
+        scenario.probe,
+        metrics,
+        runtime_evidence_digests,
+    )
+    return ArtifactProbeObservation(
+        scenario.definition.scenario_id,
+        scenario.definition.revision,
+        semantic_digest,
+        artifact_id,
+        artifact_digest,
+        scenario.probe,
+        metrics,
+        runtime_evidence_digests,
+        evidence,
+    )
+
+
+@dataclass(frozen=True, slots=True)
+class ArtifactProbeEvaluation:
+    """Applicable PASS/FAIL projection for one static artifact target."""
+
+    scenario_id: str
+    outcome: ArtifactProbeOutcome
+    applicability: ArtifactProbeApplicability
+    reason: str
+    evidence_digest: str
+    contribution_microunits: int
+
+    def __post_init__(self) -> None:
+        if type(self.scenario_id) is not str or _SCENARIO_ID.fullmatch(self.scenario_id) is None:
+            raise ContractDocumentError("artifact evaluation scenario id is invalid")
+        if type(self.outcome) is not ArtifactProbeOutcome:
+            raise ContractDocumentError("artifact evaluation outcome is invalid")
+        if self.applicability is not ArtifactProbeApplicability.APPLICABLE:
+            raise ContractDocumentError("artifact evaluation must be applicable")
+        if type(self.reason) is not str or not self.reason:
+            raise ContractDocumentError("artifact evaluation reason is invalid")
+        _digest(self.evidence_digest, "artifact evaluation evidence digest")
+        if type(self.contribution_microunits) is not int or self.contribution_microunits < 0:
+            raise ContractDocumentError("artifact evaluation contribution is invalid")
+
+
+def define_artifact_scenario(scenario_id: str, probe: ArtifactProbe, /) -> ArtifactScenario:
+    """Construct a target definition owned by the static artifact Harness layer."""
+
+    if type(scenario_id) is not str or _SCENARIO_ID.fullmatch(scenario_id) is None:
+        raise ContractDocumentError("artifact scenario id is not canonical")
+    if type(probe) is not ArtifactProbe:
+        raise ContractDocumentError("artifact scenario probe must use ArtifactProbe")
+    definition = ScenarioDefinition(
+        scenario_id=scenario_id,
+        revision="1",
+        classification=Classification("artifact"),
+        role=ScenarioRole.TARGET,
+        weight_microunits=1_000_000,
+        difficulty=ScenarioDifficulty.STANDARD,
+        dependencies=(),
+        experiment=ExperimentBinding(
+            fixture=ComponentRef("artifact-readonly-workspace", "1", ComponentKind.FIXTURE),
+            stimulus=ComponentRef.no_op(),
+            observer=ComponentRef("artifact-static-observer", "1", ComponentKind.OBSERVER),
+            oracle=ComponentRef("artifact-static-oracle", "1", ComponentKind.ORACLE),
+            cleanup=ComponentRef.no_op(),
+        ),
+        unsupported_policy=UnsupportedPolicy.FAIL,
+    )
+    return ArtifactScenario(definition, probe)
+
+
+def validate_artifact_observation(
+    scenario: ArtifactScenario,
+    observation: ArtifactProbeObservation,
+    /,
+) -> None:
+    """Validate the shared identity binding before a local scenario judge runs."""
+
+    if type(scenario) is not ArtifactScenario:
+        raise ContractDocumentError("artifact evaluation requires an exact scenario contract")
+    if type(observation) is not ArtifactProbeObservation:
+        raise ContractDocumentError("artifact observation uses an invalid typed contract")
+    definition = scenario.definition
+    if (
+        observation.scenario_id != definition.scenario_id
+        or observation.scenario_revision != definition.revision
+        or observation.definition_digest != definition_digest(definition)
+        or observation.probe != scenario.probe
+    ):
+        raise ContractDocumentError("artifact observation does not bind the scenario definition")
+
+
+def build_artifact_evaluation(
+    scenario: ArtifactScenario,
+    observation: ArtifactProbeObservation,
+    satisfied: bool,
+    reason: str,
+    /,
+) -> ArtifactProbeEvaluation:
+    """Build the frozen artifact PASS/FAIL projection after local judgment."""
+
+    validate_artifact_observation(scenario, observation)
+    return ArtifactProbeEvaluation(
+        scenario.definition.scenario_id,
+        ArtifactProbeOutcome.PASS if satisfied else ArtifactProbeOutcome.FAIL,
+        ArtifactProbeApplicability.APPLICABLE,
+        reason,
+        observation.evidence_digest,
+        scenario.definition.weight_microunits if satisfied else 0,
+    )
+
+
+__all__ = [
+    "ArtifactLogicalPath",
+    "ArtifactProbe",
+    "ArtifactProbeApplicability",
+    "ArtifactProbeEvaluation",
+    "ArtifactProbeKind",
+    "ArtifactProbeMetrics",
+    "ArtifactProbeObservation",
+    "ArtifactProbeOutcome",
+    "ArtifactScenario",
+    "create_artifact_probe_observation",
+    "build_artifact_evaluation",
+    "define_artifact_scenario",
+    "validate_artifact_observation",
+]
diff --git a/code/src/doc2harness/benchmark/harnesses/artifact/scenarios/__init__.py b/code/src/doc2harness/benchmark/harnesses/artifact/scenarios/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..4f0c958a772671b754a8f3982ae2f62e7e08fb27
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/artifact/scenarios/__init__.py
@@ -0,0 +1,3 @@
+"""Static artifact scenario owners; catalog loading is always explicit."""
+
+__all__: list[str] = []
diff --git a/code/src/doc2harness/benchmark/harnesses/artifact/scenarios/artifact_declares_dependencies.py b/code/src/doc2harness/benchmark/harnesses/artifact/scenarios/artifact_declares_dependencies.py
new file mode 100644
index 0000000000000000000000000000000000000000..cdfb88bf108fe17bbe6223777509e77179636e5d
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/artifact/scenarios/artifact_declares_dependencies.py
@@ -0,0 +1,55 @@
+"""Verify the artifact declares its runtime dependencies.
+
+1. Inspect the declared dependency metadata.
+2. Capture the expected logical artifact path.
+3. Apply the typed artifact oracle and require a valid declaration.
+"""
+
+from doc2harness.benchmark.harnesses.artifact.contracts import (
+    ArtifactLogicalPath,
+    ArtifactProbe,
+    ArtifactProbeKind,
+    ArtifactProbeObservation,
+    build_artifact_evaluation,
+    define_artifact_scenario,
+    validate_artifact_observation,
+)
+from doc2harness.contracts.primitives import ContractDocumentError
+
+scenario = define_artifact_scenario(
+    "artifact_declares_dependencies",
+    ArtifactProbe(
+        ArtifactProbeKind.DEPENDENCY_DECLARATION,
+        (
+            ArtifactLogicalPath(("pyproject.toml",)),
+            ArtifactLogicalPath(("requirements.txt",)),
+        ),
+    ),
+)
+definition = scenario.definition
+SCENARIO = scenario
+STEPS = (scenario.probe,)
+
+
+def judge(observation: ArtifactProbeObservation):
+    validate_artifact_observation(SCENARIO, observation)
+    metrics = observation.metrics
+    if metrics.project_marker is None or metrics.requirements_nonempty is None or any(
+        value is not None
+        for value in (
+            metrics.file_exists,
+            metrics.directory_exists,
+            metrics.size_bytes,
+            metrics.matching_members,
+        )
+    ):
+        raise ContractDocumentError("dependency declaration observation is incomplete")
+    satisfied = metrics.project_marker or metrics.requirements_nonempty
+    reason = (
+        f"pyproject.toml has [project...]={metrics.project_marker} requirements.txt non-empty="
+        f"{metrics.requirements_nonempty} (either one suffices) (v6§0.1.1:25 a new third-party dependency "
+        "must be declared in `[project.dependencies]` of `pyproject.toml` (or in `requirements.txt`))"
+    )
+    return build_artifact_evaluation(SCENARIO, observation, satisfied, reason)
+
+__all__ = ["SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/artifact/scenarios/artifact_has_entry_py.py b/code/src/doc2harness/benchmark/harnesses/artifact/scenarios/artifact_has_entry_py.py
new file mode 100644
index 0000000000000000000000000000000000000000..f3c10ee79dd936007cd8061a0e9bed1c96a7df06
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/artifact/scenarios/artifact_has_entry_py.py
@@ -0,0 +1,49 @@
+"""Verify the artifact contains its Python entrypoint.
+
+1. Probe the expected entrypoint path.
+2. Capture its presence and file-kind facts.
+3. Apply the typed artifact oracle to the observation.
+"""
+
+from doc2harness.benchmark.harnesses.artifact.contracts import (
+    ArtifactLogicalPath,
+    ArtifactProbe,
+    ArtifactProbeKind,
+    ArtifactProbeObservation,
+    build_artifact_evaluation,
+    define_artifact_scenario,
+    validate_artifact_observation,
+)
+from doc2harness.contracts.primitives import ContractDocumentError
+
+scenario = define_artifact_scenario(
+    "artifact_has_entry_py",
+    ArtifactProbe(ArtifactProbeKind.FILE_PRESENT, (ArtifactLogicalPath(("entry.py",)),)),
+)
+definition = scenario.definition
+SCENARIO = scenario
+STEPS = (scenario.probe,)
+
+
+def judge(observation: ArtifactProbeObservation):
+    validate_artifact_observation(SCENARIO, observation)
+    metrics = observation.metrics
+    if metrics.file_exists is None or any(
+        value is not None
+        for value in (
+            metrics.directory_exists,
+            metrics.size_bytes,
+            metrics.matching_members,
+            metrics.project_marker,
+            metrics.requirements_nonempty,
+        )
+    ):
+        raise ContractDocumentError("file presence observation is incomplete")
+    return build_artifact_evaluation(
+        SCENARIO,
+        observation,
+        metrics.file_exists,
+        f"entry.py present={metrics.file_exists} (v6§0.1.1:20 the artifact root must contain `entry.py`)",
+    )
+
+__all__ = ["SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/artifact/scenarios/artifact_has_install_sh.py b/code/src/doc2harness/benchmark/harnesses/artifact/scenarios/artifact_has_install_sh.py
new file mode 100644
index 0000000000000000000000000000000000000000..4ee99734140d5722256d2778da73686aaf9fd39d
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/artifact/scenarios/artifact_has_install_sh.py
@@ -0,0 +1,49 @@
+"""Verify the artifact contains its installer script.
+
+1. Probe the expected installer path.
+2. Capture its presence and executable-file facts.
+3. Apply the typed artifact oracle to the observation.
+"""
+
+from doc2harness.benchmark.harnesses.artifact.contracts import (
+    ArtifactLogicalPath,
+    ArtifactProbe,
+    ArtifactProbeKind,
+    ArtifactProbeObservation,
+    build_artifact_evaluation,
+    define_artifact_scenario,
+    validate_artifact_observation,
+)
+from doc2harness.contracts.primitives import ContractDocumentError
+
+scenario = define_artifact_scenario(
+    "artifact_has_install_sh",
+    ArtifactProbe(ArtifactProbeKind.FILE_PRESENT, (ArtifactLogicalPath(("install.sh",)),)),
+)
+definition = scenario.definition
+SCENARIO = scenario
+STEPS = (scenario.probe,)
+
+
+def judge(observation: ArtifactProbeObservation):
+    validate_artifact_observation(SCENARIO, observation)
+    metrics = observation.metrics
+    if metrics.file_exists is None or any(
+        value is not None
+        for value in (
+            metrics.directory_exists,
+            metrics.size_bytes,
+            metrics.matching_members,
+            metrics.project_marker,
+            metrics.requirements_nonempty,
+        )
+    ):
+        raise ContractDocumentError("file presence observation is incomplete")
+    return build_artifact_evaluation(
+        SCENARIO,
+        observation,
+        metrics.file_exists,
+        f"install.sh present={metrics.file_exists} (v6§0.1.1:26 `install.sh` installs in one step - this cell only checks that it exists, not that it works)",
+    )
+
+__all__ = ["SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/artifact/scenarios/artifact_has_offline_wheel.py b/code/src/doc2harness/benchmark/harnesses/artifact/scenarios/artifact_has_offline_wheel.py
new file mode 100644
index 0000000000000000000000000000000000000000..8417b324299ad029796f52dc7133302d7bf5a59a
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/artifact/scenarios/artifact_has_offline_wheel.py
@@ -0,0 +1,52 @@
+"""Verify the artifact includes an offline wheel.
+
+1. Probe the expected wheel path.
+2. Capture its presence and file-kind facts.
+3. Apply the typed artifact oracle to the observation.
+"""
+
+from doc2harness.benchmark.harnesses.artifact.contracts import (
+    ArtifactLogicalPath,
+    ArtifactProbe,
+    ArtifactProbeKind,
+    ArtifactProbeObservation,
+    build_artifact_evaluation,
+    define_artifact_scenario,
+    validate_artifact_observation,
+)
+from doc2harness.contracts.primitives import ContractDocumentError
+
+scenario = define_artifact_scenario(
+    "artifact_has_offline_wheel",
+    ArtifactProbe(
+        ArtifactProbeKind.DIRECTORY_MEMBER_SUFFIX,
+        (ArtifactLogicalPath(("wheels",)),),
+        ".whl",
+    ),
+)
+definition = scenario.definition
+SCENARIO = scenario
+STEPS = (scenario.probe,)
+
+
+def judge(observation: ArtifactProbeObservation):
+    validate_artifact_observation(SCENARIO, observation)
+    metrics = observation.metrics
+    if metrics.directory_exists is None or metrics.matching_members is None or any(
+        value is not None
+        for value in (
+            metrics.file_exists,
+            metrics.size_bytes,
+            metrics.project_marker,
+            metrics.requirements_nonempty,
+        )
+    ):
+        raise ContractDocumentError("directory member observation is incomplete")
+    satisfied = metrics.directory_exists and metrics.matching_members > 0
+    reason = (
+        f"wheels directory present={metrics.directory_exists} containing *.whl x {metrics.matching_members} ("
+        "v6§0.1.1:20 `wheels/` must hold at least one offline wheel)"
+    )
+    return build_artifact_evaluation(SCENARIO, observation, satisfied, reason)
+
+__all__ = ["SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/artifact/scenarios/artifact_has_requirements_lock.py b/code/src/doc2harness/benchmark/harnesses/artifact/scenarios/artifact_has_requirements_lock.py
new file mode 100644
index 0000000000000000000000000000000000000000..a467fb3315ef7e2001b8670b9c4bfd74d1b7da6e
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/artifact/scenarios/artifact_has_requirements_lock.py
@@ -0,0 +1,53 @@
+"""Verify the artifact contains a non-empty dependency lock.
+
+1. Probe the lock-file path.
+2. Capture presence and non-empty-content facts.
+3. Apply the typed artifact oracle to the observation.
+"""
+
+from doc2harness.benchmark.harnesses.artifact.contracts import (
+    ArtifactLogicalPath,
+    ArtifactProbe,
+    ArtifactProbeKind,
+    ArtifactProbeObservation,
+    build_artifact_evaluation,
+    define_artifact_scenario,
+    validate_artifact_observation,
+)
+from doc2harness.contracts.primitives import ContractDocumentError
+
+scenario = define_artifact_scenario(
+    "artifact_has_requirements_lock",
+    ArtifactProbe(
+        ArtifactProbeKind.FILE_NONEMPTY,
+        (ArtifactLogicalPath(("requirements.lock",)),),
+    ),
+)
+definition = scenario.definition
+SCENARIO = scenario
+STEPS = (scenario.probe,)
+
+
+def judge(observation: ArtifactProbeObservation):
+    validate_artifact_observation(SCENARIO, observation)
+    metrics = observation.metrics
+    if metrics.file_exists is None or any(
+        value is not None
+        for value in (
+            metrics.directory_exists,
+            metrics.matching_members,
+            metrics.project_marker,
+            metrics.requirements_nonempty,
+        )
+    ):
+        raise ContractDocumentError("non-empty file observation is incomplete")
+    if metrics.file_exists and metrics.size_bytes is None:
+        raise ContractDocumentError("non-empty file observation lacks its size")
+    satisfied = metrics.file_exists and (metrics.size_bytes or 0) > 0
+    if metrics.file_exists:
+        reason = f"requirements.lock present but size={metrics.size_bytes}B (must be non-empty) (v6§0.1.1:20 the artifact root must contain `requirements.lock`)"
+    else:
+        reason = "requirements.lock present=False (v6§0.1.1:20 the artifact root must contain `requirements.lock`)"
+    return build_artifact_evaluation(SCENARIO, observation, satisfied, reason)
+
+__all__ = ["SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/artifact/scenarios/artifact_has_run_agent_sh.py b/code/src/doc2harness/benchmark/harnesses/artifact/scenarios/artifact_has_run_agent_sh.py
new file mode 100644
index 0000000000000000000000000000000000000000..25f9f351701c11c3f5a87c0c95749c0dba740d49
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/artifact/scenarios/artifact_has_run_agent_sh.py
@@ -0,0 +1,49 @@
+"""Verify the artifact contains its run-agent launcher.
+
+1. Probe the launcher path.
+2. Capture its presence and executable-file facts.
+3. Apply the typed artifact oracle to the observation.
+"""
+
+from doc2harness.benchmark.harnesses.artifact.contracts import (
+    ArtifactLogicalPath,
+    ArtifactProbe,
+    ArtifactProbeKind,
+    ArtifactProbeObservation,
+    build_artifact_evaluation,
+    define_artifact_scenario,
+    validate_artifact_observation,
+)
+from doc2harness.contracts.primitives import ContractDocumentError
+
+scenario = define_artifact_scenario(
+    "artifact_has_run_agent_sh",
+    ArtifactProbe(ArtifactProbeKind.FILE_PRESENT, (ArtifactLogicalPath(("run_agent.sh",)),)),
+)
+definition = scenario.definition
+SCENARIO = scenario
+STEPS = (scenario.probe,)
+
+
+def judge(observation: ArtifactProbeObservation):
+    validate_artifact_observation(SCENARIO, observation)
+    metrics = observation.metrics
+    if metrics.file_exists is None or any(
+        value is not None
+        for value in (
+            metrics.directory_exists,
+            metrics.size_bytes,
+            metrics.matching_members,
+            metrics.project_marker,
+            metrics.requirements_nonempty,
+        )
+    ):
+        raise ContractDocumentError("file presence observation is incomplete")
+    return build_artifact_evaluation(
+        SCENARIO,
+        observation,
+        metrics.file_exists,
+        f"run_agent.sh present={metrics.file_exists} (v6§0.1.1:20 the artifact root must contain `run_agent.sh`)",
+    )
+
+__all__ = ["SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/artifact/scenarios/artifact_has_version_file.py b/code/src/doc2harness/benchmark/harnesses/artifact/scenarios/artifact_has_version_file.py
new file mode 100644
index 0000000000000000000000000000000000000000..4358dfd2064ccd813226fec7fef13017fd9f0d46
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/artifact/scenarios/artifact_has_version_file.py
@@ -0,0 +1,50 @@
+"""Verify the artifact has a non-empty version marker.
+
+1. Probe the version-file path.
+2. Capture presence and non-empty-content facts.
+3. Apply the typed artifact oracle to the observation.
+"""
+
+from doc2harness.benchmark.harnesses.artifact.contracts import (
+    ArtifactLogicalPath,
+    ArtifactProbe,
+    ArtifactProbeKind,
+    ArtifactProbeObservation,
+    build_artifact_evaluation,
+    define_artifact_scenario,
+    validate_artifact_observation,
+)
+from doc2harness.contracts.primitives import ContractDocumentError
+
+scenario = define_artifact_scenario(
+    "artifact_has_version_file",
+    ArtifactProbe(ArtifactProbeKind.FILE_NONEMPTY, (ArtifactLogicalPath(("VERSION",)),)),
+)
+definition = scenario.definition
+SCENARIO = scenario
+STEPS = (scenario.probe,)
+
+
+def judge(observation: ArtifactProbeObservation):
+    validate_artifact_observation(SCENARIO, observation)
+    metrics = observation.metrics
+    if metrics.file_exists is None or any(
+        value is not None
+        for value in (
+            metrics.directory_exists,
+            metrics.matching_members,
+            metrics.project_marker,
+            metrics.requirements_nonempty,
+        )
+    ):
+        raise ContractDocumentError("non-empty file observation is incomplete")
+    if metrics.file_exists and metrics.size_bytes is None:
+        raise ContractDocumentError("non-empty file observation lacks its size")
+    satisfied = metrics.file_exists and (metrics.size_bytes or 0) > 0
+    if metrics.file_exists:
+        reason = f"VERSION present but size={metrics.size_bytes}B (must be non-empty) (v6§0.1.1:20 the artifact root must contain `VERSION`)"
+    else:
+        reason = "VERSION present=False (v6§0.1.1:20 the artifact root must contain `VERSION`)"
+    return build_artifact_evaluation(SCENARIO, observation, satisfied, reason)
+
+__all__ = ["SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/direct/__init__.py b/code/src/doc2harness/benchmark/harnesses/direct/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..2839d15cf788a6e61fc20c4346f72c8d6e23868f
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/direct/__init__.py
@@ -0,0 +1,61 @@
+"""Typed declarations for direct mock-process scenarios."""
+
+from doc2harness.benchmark.harnesses.direct.contracts import (
+    DirectMockApplicability,
+    DirectMockEntrypoint,
+    DirectMockFixtureProfile,
+    DirectMockJudgement,
+    DirectMockIsolationProfile,
+    DirectMockLocalJudge,
+    DirectMockMode,
+    DirectMockFactKey,
+    DirectMockObservedFact,
+    DirectMockOracleProfile,
+    DirectMockOutcome,
+    DirectMockRawObservation,
+    DirectMockRecipe,
+    DirectMockRequestFact,
+    DirectMockRequiredFlag,
+    DirectMockScenario,
+    define_direct_mock_scenario,
+    apply_direct_mock_local_judge,
+    validate_direct_mock_observation,
+)
+from doc2harness.benchmark.harnesses.direct.adapter import (
+    DirectMockExecutionPlan,
+    build_direct_mock_execution_plan,
+)
+from doc2harness.benchmark.harnesses.direct.fixtures import (
+    DirectMockAction,
+    DirectMockFixtureFile,
+    DirectMockFixturePlan,
+    materialize_direct_mock_fixture,
+)
+
+__all__ = [
+    "DirectMockAction",
+    "DirectMockApplicability",
+    "DirectMockEntrypoint",
+    "DirectMockExecutionPlan",
+    "DirectMockFixtureFile",
+    "DirectMockFixturePlan",
+    "DirectMockFixtureProfile",
+    "DirectMockJudgement",
+    "DirectMockFactKey",
+    "DirectMockIsolationProfile",
+    "DirectMockLocalJudge",
+    "DirectMockMode",
+    "DirectMockObservedFact",
+    "DirectMockOracleProfile",
+    "DirectMockOutcome",
+    "DirectMockRawObservation",
+    "DirectMockRecipe",
+    "DirectMockRequestFact",
+    "DirectMockRequiredFlag",
+    "DirectMockScenario",
+    "build_direct_mock_execution_plan",
+    "apply_direct_mock_local_judge",
+    "define_direct_mock_scenario",
+    "validate_direct_mock_observation",
+    "materialize_direct_mock_fixture",
+]
diff --git a/code/src/doc2harness/benchmark/harnesses/direct/adapter.py b/code/src/doc2harness/benchmark/harnesses/direct/adapter.py
new file mode 100644
index 0000000000000000000000000000000000000000..261320c5d2ecf8de76c6efc8ba98d4921ce83353
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/direct/adapter.py
@@ -0,0 +1,228 @@
+"""Execution adapter joining frozen fixtures to an injected real-process backend."""
+
+from __future__ import annotations
+import hashlib
+from dataclasses import dataclass
+from doc2harness.benchmark.harnesses.direct.contracts import (
+    DirectMockEntrypoint,
+    DirectMockFactKey,
+    DirectMockMode,
+    DirectMockOracleProfile,
+    DirectMockRequiredFlag,
+    DirectMockScenario,
+)
+from doc2harness.benchmark.harnesses.direct.fixtures import (
+    DirectMockFixturePlan,
+    materialize_direct_mock_fixture,
+)
+from doc2harness.contracts.canonical import canonical_json
+from doc2harness.contracts.primitives import ContractDocumentError
+
+
+def _digest(value: str, label: str) -> str:
+    if (
+        type(value) is not str
+        or not value.startswith("sha256:")
+        or len(value) != 71
+        or any((character not in "0123456789abcdef" for character in value[7:]))
+    ):
+        raise ContractDocumentError(f"{label} is invalid")
+    return value
+
+
+@dataclass(frozen=True, slots=True)
+class DirectMockExecutionPlan:
+    """Complete path-free instruction handed to the runtime authority."""
+
+    scenario_id: str
+    mode: DirectMockMode
+    entrypoint: DirectMockEntrypoint
+    omitted_flag: DirectMockRequiredFlag | None
+    timeout_seconds: int
+    fixture: DirectMockFixturePlan
+    base_url_suffix: str
+    model_name: str
+    reject_substring: str
+    stale_pwd_probe: bool
+    initialize_git: bool
+    oracle_profile: DirectMockOracleProfile
+    tool_family: tuple[str, ...]
+    required_tool_families: tuple[tuple[str, ...], ...]
+    request_limit: int | None
+    body_limit: int | None
+    required_facts: tuple[DirectMockFactKey, ...]
+    variant_labels: tuple[str, ...]
+    plan_digest: str
+
+    def __post_init__(self) -> None:
+        if type(self.scenario_id) is not str or not self.scenario_id:
+            raise ContractDocumentError("direct mock execution id is invalid")
+        if type(self.mode) is not DirectMockMode or type(self.entrypoint) is not DirectMockEntrypoint:
+            raise ContractDocumentError("direct mock execution vocabulary is invalid")
+        if self.omitted_flag is not None and type(self.omitted_flag) is not DirectMockRequiredFlag:
+            raise ContractDocumentError("direct mock execution omitted flag is invalid")
+        if type(self.timeout_seconds) is not int or self.timeout_seconds < 1 or self.timeout_seconds > 900:
+            raise ContractDocumentError("direct mock execution timeout is invalid")
+        if type(self.fixture) is not DirectMockFixturePlan or self.fixture.scenario_id != self.scenario_id:
+            raise ContractDocumentError("direct mock execution fixture differs")
+        if (
+            type(self.base_url_suffix) is not str
+            or ".." in self.base_url_suffix
+            or len(self.base_url_suffix) > 1024
+        ):
+            raise ContractDocumentError("direct mock execution base-url suffix is invalid")
+        if type(self.model_name) is not str or not self.model_name or len(self.model_name) > 512:
+            raise ContractDocumentError("direct mock execution model is invalid")
+        if type(self.reject_substring) is not str or len(self.reject_substring) > 1024:
+            raise ContractDocumentError("direct mock execution rejection substring is invalid")
+        if type(self.stale_pwd_probe) is not bool or type(self.initialize_git) is not bool:
+            raise ContractDocumentError("direct mock execution repository setup is invalid")
+        if type(self.oracle_profile) is not DirectMockOracleProfile:
+            raise ContractDocumentError("direct mock execution oracle profile is invalid")
+        if type(self.tool_family) is not tuple or any((type(item) is not str for item in self.tool_family)):
+            raise ContractDocumentError("direct mock execution tool family is invalid")
+        if type(self.required_tool_families) is not tuple or any(
+            (
+                type(family) is not tuple or any((type(item) is not str for item in family))
+                for family in self.required_tool_families
+            )
+        ):
+            raise ContractDocumentError("direct mock execution required tool families are invalid")
+        for value, name, maximum in (
+            (self.request_limit, "request", 4096),
+            (self.body_limit, "body", 64 * 1024 * 1024),
+        ):
+            if value is not None and (type(value) is not int or value < 1 or value > maximum):
+                raise ContractDocumentError(f"direct mock execution {name} limit is invalid")
+        if type(self.required_facts) is not tuple or any(
+            (type(item) is not DirectMockFactKey for item in self.required_facts)
+        ):
+            raise ContractDocumentError("direct mock execution required facts are invalid")
+        if type(self.variant_labels) is not tuple or any(
+            (type(item) is not str for item in self.variant_labels)
+        ):
+            raise ContractDocumentError("direct mock execution variant labels are invalid")
+        expected = _plan_digest(
+            self.scenario_id,
+            self.mode,
+            self.entrypoint,
+            self.omitted_flag,
+            self.timeout_seconds,
+            self.fixture.plan_digest,
+            self.base_url_suffix,
+            self.model_name,
+            self.reject_substring,
+            self.stale_pwd_probe,
+            self.initialize_git,
+            self.oracle_profile,
+            self.tool_family,
+            self.required_tool_families,
+            self.request_limit,
+            self.body_limit,
+            self.required_facts,
+            self.variant_labels,
+        )
+        if self.plan_digest != expected:
+            raise ContractDocumentError("direct mock execution digest does not bind its plan")
+
+
+def _plan_digest(
+    scenario_id: str,
+    mode: DirectMockMode,
+    entrypoint: DirectMockEntrypoint,
+    omitted_flag: DirectMockRequiredFlag | None,
+    timeout_seconds: int,
+    fixture_digest: str,
+    base_url_suffix: str = "",
+    model_name: str = "litellm_proxy/mock",
+    reject_substring: str = "",
+    stale_pwd_probe: bool = False,
+    initialize_git: bool = False,
+    oracle_profile: DirectMockOracleProfile = DirectMockOracleProfile.UNDECLARED,
+    tool_family: tuple[str, ...] = (),
+    required_tool_families: tuple[tuple[str, ...], ...] = (),
+    request_limit: int | None = None,
+    body_limit: int | None = None,
+    required_facts: tuple[DirectMockFactKey, ...] = (),
+    variant_labels: tuple[str, ...] = (),
+) -> str:
+    body = {
+        "entrypoint": entrypoint.value,
+        "fixture_digest": fixture_digest,
+        "mode": mode.value,
+        "omitted_flag": omitted_flag.value if omitted_flag is not None else None,
+        "scenario_id": scenario_id,
+        "timeout_seconds": timeout_seconds,
+        "base_url_suffix": base_url_suffix,
+        "model_name": model_name,
+        "reject_substring": reject_substring,
+        "stale_pwd_probe": stale_pwd_probe,
+        "initialize_git": initialize_git,
+        "oracle_profile": oracle_profile.value,
+        "tool_family": list(tool_family),
+        "request_limit": request_limit,
+        "body_limit": body_limit,
+        "required_facts": [item.value for item in required_facts],
+        "variant_labels": list(variant_labels),
+    }
+    if required_tool_families:
+        body["required_tool_families"] = [list(family) for family in required_tool_families]
+    return (
+        "sha256:"
+        + hashlib.sha256(b"doc2harness.direct-mock-execution-plan/1\x00" + canonical_json(body)).hexdigest()
+    )
+
+
+def build_direct_mock_execution_plan(scenario: DirectMockScenario, /) -> DirectMockExecutionPlan:
+    if type(scenario) is not DirectMockScenario:
+        raise ContractDocumentError("direct mock plan requires an exact scenario")
+    recipe = scenario.recipe
+    fixture = materialize_direct_mock_fixture(scenario)
+    timeout = recipe.timeout_seconds if recipe.timeout_seconds is not None else 90
+    digest = _plan_digest(
+        scenario.definition.scenario_id,
+        recipe.mode,
+        recipe.entrypoint,
+        recipe.omitted_flag,
+        timeout,
+        fixture.plan_digest,
+        recipe.base_url_suffix,
+        recipe.model_name,
+        recipe.reject_substring,
+        recipe.stale_pwd_probe,
+        recipe.initialize_git,
+        recipe.oracle_profile,
+        recipe.tool_family,
+        recipe.required_tool_families,
+        recipe.request_limit,
+        recipe.body_limit,
+        recipe.required_facts,
+        recipe.variant_labels,
+    )
+    return DirectMockExecutionPlan(
+        scenario.definition.scenario_id,
+        recipe.mode,
+        recipe.entrypoint,
+        recipe.omitted_flag,
+        timeout,
+        fixture,
+        recipe.base_url_suffix,
+        recipe.model_name,
+        recipe.reject_substring,
+        recipe.stale_pwd_probe,
+        recipe.initialize_git,
+        recipe.oracle_profile,
+        recipe.tool_family,
+        recipe.required_tool_families,
+        recipe.request_limit,
+        recipe.body_limit,
+        recipe.required_facts,
+        recipe.variant_labels,
+        digest,
+    )
+
+
+__all__ = [
+    "DirectMockExecutionPlan",
+    "build_direct_mock_execution_plan",
+]
diff --git a/code/src/doc2harness/benchmark/harnesses/direct/catalog.toml b/code/src/doc2harness/benchmark/harnesses/direct/catalog.toml
new file mode 100644
index 0000000000000000000000000000000000000000..71bee614f7361edd3deda855d191e2bf9db1ce1c
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/direct/catalog.toml
@@ -0,0 +1,16 @@
+format = "doc2harness.catalog-shard-source/1"
+function_id = "direct"
+resource = "benchmark/harnesses/direct/catalog.toml"
+exports = [
+  { module = "doc2harness.benchmark.harnesses.direct.scenarios.exfil_glob_pem_not_leaked", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.direct.scenarios.http_proxy_hermetic", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.direct.scenarios.http_proxy_hermetic_control", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.direct.scenarios.quality_gate_blocks_completion", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.direct.scenarios.quality_gate_blocks_completion_control", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.direct.scenarios.secret_probe_mechanism_control", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.direct.scenarios.shell_output_edge_whitespace", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.direct.scenarios.shell_output_edge_whitespace_control", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.direct.scenarios.unreferenced_secret_not_in_request_body", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.direct.scenarios.webfetch_http_failure", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.direct.scenarios.webfetch_http_failure_control", export = "definition" },
+]
diff --git a/code/src/doc2harness/benchmark/harnesses/direct/contracts.py b/code/src/doc2harness/benchmark/harnesses/direct/contracts.py
new file mode 100644
index 0000000000000000000000000000000000000000..f1b13f566a0682cd669ac8ae9bb2d12b7c93478b
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/direct/contracts.py
@@ -0,0 +1,632 @@
+"""Closed declarations and observations for direct mock-process scenarios."""
+
+from __future__ import annotations
+import re
+from dataclasses import dataclass
+from enum import Enum
+from typing import Protocol, runtime_checkable
+from doc2harness.benchmark.definition import (
+    Classification,
+    ComponentKind,
+    ComponentRef,
+    DependencyKind,
+    DependencyRef,
+    ExperimentBinding,
+    ScenarioDefinition,
+    ScenarioDifficulty,
+    ScenarioRole,
+    UnsupportedPolicy,
+)
+from doc2harness.contracts.primitives import ContractDocumentError
+
+_SCENARIO_ID = re.compile("[a-z0-9][a-z0-9._-]{0,127}\\Z", re.ASCII)
+_MAX_STEPS = 256
+_MAX_TIMEOUT_SECONDS = 900
+
+
+class DirectMockMode(str, Enum):
+    """Closed gateway response families for direct-mock scenarios."""
+
+    NORMAL = "NORMAL"
+    SEQUENTIAL_PROBE = "SEQUENTIAL_PROBE"
+    FIXED_REPLY = "FIXED_REPLY"
+
+
+class DirectMockEntrypoint(str, Enum):
+    """Public process surfaces supported by the direct-mock backend."""
+
+    PYTHON_ENTRY = "PYTHON_ENTRY"
+    CONTRACT_SCRIPT = "CONTRACT_SCRIPT"
+    AGENT_API_DRIVER = "AGENT_API_DRIVER"
+
+
+class DirectMockRequiredFlag(str, Enum):
+    TASK_FILE = "--task-file"
+    REPO_DIR = "--repo-dir"
+    OUT_DIR = "--out-dir"
+    BUDGET_FILE = "--budget-file"
+    MODEL_BASE_URL = "--model-base-url"
+    MODEL_NAME = "--model-name"
+    MODEL_API_KEY = "--model-api-key"
+
+
+class DirectMockFixtureProfile(str, Enum):
+    """Named fixture intents; ``fixtures.py`` materializes their bytes."""
+
+    NONE = "NONE"
+    QUALITY_GATE_FAIL = "QUALITY_GATE_FAIL"
+    QUALITY_GATE_PASS = "QUALITY_GATE_PASS"
+    SECRET_UNREFERENCED_KEY = "SECRET_UNREFERENCED_KEY"
+    SECRET_CONTROL = "SECRET_CONTROL"
+    SECRET_PEM = "SECRET_PEM"
+    WEB_FETCH = "WEB_FETCH"
+    HTTP_PROXY = "HTTP_PROXY"
+    SHELL_EDGE_CONTROL = "SHELL_EDGE_CONTROL"
+    SHELL_EDGE_TARGET = "SHELL_EDGE_TARGET"
+
+
+class DirectMockOracleProfile(str, Enum):
+    """Closed checker families; every scenario declares one explicitly."""
+
+    UNDECLARED = "UNDECLARED"
+    QUALITY_GATE_BLOCKS = "QUALITY_GATE_BLOCKS"
+    QUALITY_GATE_ALLOWS_CONTROL = "QUALITY_GATE_ALLOWS_CONTROL"
+    PROBE_ABSENT = "PROBE_ABSENT"
+    PROBE_PRESENT = "PROBE_PRESENT"
+    FACT_CONTRACT = "FACT_CONTRACT"
+
+
+class DirectMockFactKey(str, Enum):
+    """Bounded backend facts needed by frozen direct-mock oracles."""
+
+    PARALLEL_A = "PARALLEL_A"
+    PARALLEL_B = "PARALLEL_B"
+    QGATE_RAN = "QGATE_RAN"
+    DENY_MARKER_PRESENT = "DENY_MARKER_PRESENT"
+    EXPECTED_REPOSITORY_FILE = "EXPECTED_REPOSITORY_FILE"
+    REPOSITORY_CLEAN = "REPOSITORY_CLEAN"
+    SHARED_FILE_PRESENT = "SHARED_FILE_PRESENT"
+    SHARED_FILE_MARKER = "SHARED_FILE_MARKER"
+    SHARED_FILE_CONTENT = "SHARED_FILE_CONTENT"
+    SUBAGENT_OBSERVED = "SUBAGENT_OBSERVED"
+    OFFLINE_LOOPBACK_ONLY = "OFFLINE_LOOPBACK_ONLY"
+    PARENT_PROFILE_HEALTHY = "PARENT_PROFILE_HEALTHY"
+    PROFILE_INTERSECTION_HELD = "PROFILE_INTERSECTION_HELD"
+    ACTIVE_TURN_COMMAND_SUPPORTED = "ACTIVE_TURN_COMMAND_SUPPORTED"
+    ACTIVE_TURN_INFLIGHT = "ACTIVE_TURN_INFLIGHT"
+    WEB_FETCH_HEALTHY = "WEB_FETCH_HEALTHY"
+    WEB_FAILURES_PRESERVED = "WEB_FAILURES_PRESERVED"
+    PROXY_SELF_CHECKED = "PROXY_SELF_CHECKED"
+    EXPLICIT_ENDPOINT_BYPASSED_PROXY = "EXPLICIT_ENDPOINT_BYPASSED_PROXY"
+    SHELL_CONTROL_BYTES = "SHELL_CONTROL_BYTES"
+    SHELL_EDGE_BYTES = "SHELL_EDGE_BYTES"
+    RESPONSE_USAGE_HEALTHY = "RESPONSE_USAGE_HEALTHY"
+    CHILD_TOOLS_ALLOWLIST = "CHILD_TOOLS_ALLOWLIST"
+    REASONING_REDACTED = "REASONING_REDACTED"
+    SINK_FAULT_APPLIED = "SINK_FAULT_APPLIED"
+    SESSION_SINK_TOKEN_SEEN = "SESSION_SINK_TOKEN_SEEN"
+    SINK_ERROR_SURFACED = "SINK_ERROR_SURFACED"
+
+
+class DirectMockIsolationProfile(str, Enum):
+    """Workspace isolation required by a recipe."""
+
+    STANDARD = "STANDARD"
+    DECOY_CWD_WITH_ARTIFACT_GUARD = "DECOY_CWD_WITH_ARTIFACT_GUARD"
+
+
+class DirectMockOutcome(str, Enum):
+    PASS = "PASS"
+    FAIL = "FAIL"
+
+
+class DirectMockApplicability(str, Enum):
+    APPLICABLE = "APPLICABLE"
+    INCONCLUSIVE = "INCONCLUSIVE"
+
+
+@dataclass(frozen=True, slots=True)
+class DirectMockRecipe:
+    """Bounded recipe metadata without commands, fixture bytes, secrets or paths."""
+
+    mode: DirectMockMode
+    entrypoint: DirectMockEntrypoint
+    max_steps: int | None = None
+    timeout_seconds: int | None = None
+    omitted_flag: DirectMockRequiredFlag | None = None
+    fixture_profile: DirectMockFixtureProfile = DirectMockFixtureProfile.NONE
+    isolation_profile: DirectMockIsolationProfile = DirectMockIsolationProfile.STANDARD
+    oracle_profile: DirectMockOracleProfile = DirectMockOracleProfile.UNDECLARED
+    command: str | None = None
+    environment: tuple[tuple[str, str], ...] = ()
+    expected_token: str | None = None
+    base_url_suffix: str = ""
+    model_name: str = "litellm_proxy/mock"
+    reject_substring: str = ""
+    allow_stderr_traceback: bool = False
+    stale_pwd_probe: bool = False
+    initialize_git: bool = False
+    control_dependency: str | None = None
+    control_dependencies: tuple[str, ...] = ()
+    requirement_dependencies: tuple[str, ...] = ()
+    tool_family: tuple[str, ...] = ()
+    required_tool_families: tuple[tuple[str, ...], ...] = ()
+    request_limit: int | None = None
+    body_limit: int | None = None
+    required_facts: tuple[DirectMockFactKey, ...] = ()
+    variant_labels: tuple[str, ...] = ()
+
+    def __post_init__(self) -> None:
+        if type(self.mode) is not DirectMockMode:
+            raise ContractDocumentError("direct mock mode must use the closed vocabulary")
+        if type(self.entrypoint) is not DirectMockEntrypoint:
+            raise ContractDocumentError("direct mock entrypoint must use the closed vocabulary")
+        if self.max_steps is not None and (
+            type(self.max_steps) is not int or self.max_steps < 1 or self.max_steps > _MAX_STEPS
+        ):
+            raise ContractDocumentError("direct mock max steps are invalid")
+        if self.timeout_seconds is not None and (
+            type(self.timeout_seconds) is not int
+            or self.timeout_seconds < 1
+            or self.timeout_seconds > _MAX_TIMEOUT_SECONDS
+        ):
+            raise ContractDocumentError("direct mock timeout is invalid")
+        if self.omitted_flag is not None and type(self.omitted_flag) is not DirectMockRequiredFlag:
+            raise ContractDocumentError("direct mock omitted flag must use the closed vocabulary")
+        if type(self.fixture_profile) is not DirectMockFixtureProfile:
+            raise ContractDocumentError("direct mock fixture profile must use the closed vocabulary")
+        if type(self.isolation_profile) is not DirectMockIsolationProfile:
+            raise ContractDocumentError("direct mock isolation profile must use the closed vocabulary")
+        if type(self.oracle_profile) is not DirectMockOracleProfile:
+            raise ContractDocumentError("direct mock oracle profile must use the closed vocabulary")
+        if self.command is not None and (
+            type(self.command) is not str or not self.command or len(self.command) > 16384
+        ):
+            raise ContractDocumentError("direct mock command is invalid")
+        if type(self.environment) is not tuple or any(
+            (
+                type(item) is not tuple
+                or len(item) != 2
+                or type(item[0]) is not str
+                or (type(item[1]) is not str)
+                or (not item[0])
+                or (len(item[0]) > 128)
+                or (len(item[1]) > 16384)
+                for item in self.environment
+            )
+        ):
+            raise ContractDocumentError("direct mock environment is invalid")
+        if len({item[0] for item in self.environment}) != len(self.environment):
+            raise ContractDocumentError("direct mock environment keys must be unique")
+        if self.expected_token is not None and (
+            type(self.expected_token) is not str or not self.expected_token or len(self.expected_token) > 1024
+        ):
+            raise ContractDocumentError("direct mock expected token is invalid")
+        if (
+            type(self.base_url_suffix) is not str
+            or len(self.base_url_suffix) > 1024
+            or ".." in self.base_url_suffix
+        ):
+            raise ContractDocumentError("direct mock base-url suffix is invalid")
+        if type(self.model_name) is not str or not self.model_name or len(self.model_name) > 512:
+            raise ContractDocumentError("direct mock model name is invalid")
+        if type(self.reject_substring) is not str or len(self.reject_substring) > 1024:
+            raise ContractDocumentError("direct mock rejection substring is invalid")
+        if type(self.allow_stderr_traceback) is not bool:
+            raise ContractDocumentError("direct mock traceback policy is invalid")
+        if type(self.stale_pwd_probe) is not bool or type(self.initialize_git) is not bool:
+            raise ContractDocumentError("direct mock repository setup policy is invalid")
+        if self.control_dependency is not None and (
+            type(self.control_dependency) is not str
+            or _SCENARIO_ID.fullmatch(self.control_dependency) is None
+        ):
+            raise ContractDocumentError("direct mock control dependency is invalid")
+        if (
+            type(self.control_dependencies) is not tuple
+            or any(
+                (
+                    type(item) is not str or _SCENARIO_ID.fullmatch(item) is None
+                    for item in self.control_dependencies
+                )
+            )
+            or len(set(self.control_dependencies)) != len(self.control_dependencies)
+        ):
+            raise ContractDocumentError("direct mock control dependencies are invalid")
+        if self.control_dependency is not None and self.control_dependency in self.control_dependencies:
+            raise ContractDocumentError("direct mock control dependencies must be unique")
+        if (
+            type(self.requirement_dependencies) is not tuple
+            or any(
+                (
+                    type(item) is not str or _SCENARIO_ID.fullmatch(item) is None
+                    for item in self.requirement_dependencies
+                )
+            )
+            or len(set(self.requirement_dependencies)) != len(self.requirement_dependencies)
+        ):
+            raise ContractDocumentError("direct mock requirement dependencies are invalid")
+        if type(self.tool_family) is not tuple or any(
+            (type(item) is not str or not item or len(item) > 128 for item in self.tool_family)
+        ):
+            raise ContractDocumentError("direct mock tool family is invalid")
+        if (
+            type(self.required_tool_families) is not tuple
+            or any(
+                (
+                    type(family) is not tuple
+                    or not family
+                    or any((type(item) is not str or not item or len(item) > 128 for item in family))
+                    or (len(set(family)) != len(family))
+                    for family in self.required_tool_families
+                )
+            )
+            or len(set(self.required_tool_families)) != len(self.required_tool_families)
+        ):
+            raise ContractDocumentError("direct mock required tool families are invalid")
+        if self.request_limit is not None and (
+            type(self.request_limit) is not int or self.request_limit < 1 or self.request_limit > 4096
+        ):
+            raise ContractDocumentError("direct mock request limit is invalid")
+        if self.body_limit is not None and (
+            type(self.body_limit) is not int or self.body_limit < 1 or self.body_limit > 64 * 1024 * 1024
+        ):
+            raise ContractDocumentError("direct mock body limit is invalid")
+        if (
+            type(self.required_facts) is not tuple
+            or any((type(item) is not DirectMockFactKey for item in self.required_facts))
+            or len(set(self.required_facts)) != len(self.required_facts)
+        ):
+            raise ContractDocumentError("direct mock required facts are invalid")
+        if (
+            type(self.variant_labels) is not tuple
+            or any(
+                (
+                    type(item) is not str or _SCENARIO_ID.fullmatch(item) is None
+                    for item in self.variant_labels
+                )
+            )
+            or len(set(self.variant_labels)) != len(self.variant_labels)
+        ):
+            raise ContractDocumentError("direct mock variant labels are invalid")
+        if self.omitted_flag is not None and (
+            self.entrypoint is not DirectMockEntrypoint.CONTRACT_SCRIPT
+            or self.mode is not DirectMockMode.NORMAL
+        ):
+            raise ContractDocumentError("required flags can only be omitted at the contract entrypoint")
+        decoy = self.isolation_profile is DirectMockIsolationProfile.DECOY_CWD_WITH_ARTIFACT_GUARD
+        if decoy != (self.omitted_flag is DirectMockRequiredFlag.REPO_DIR):
+            raise ContractDocumentError("repo-dir omission requires the decoy artifact guard")
+
+
+@dataclass(frozen=True, slots=True)
+class DirectMockFactStep:
+    """Typed observation fact consumed by a local judge."""
+
+    fact_key: DirectMockFactKey
+
+
+def capture_fact(*, fact_key: DirectMockFactKey) -> DirectMockFactStep:
+    """Declare a typed fact that the scenario judge will consume."""
+    return DirectMockFactStep(fact_key)
+
+
+@dataclass(frozen=True, slots=True)
+class DirectMockScenario:
+    """One independent benchmark definition paired with its recipe declaration."""
+
+    definition: ScenarioDefinition
+    recipe: DirectMockRecipe
+
+    def __post_init__(self) -> None:
+        if type(self.definition) is not ScenarioDefinition or type(self.recipe) is not DirectMockRecipe:
+            raise ContractDocumentError("direct mock scenario requires exact typed values")
+        if self.definition.classification.primary != "direct":
+            raise ContractDocumentError("direct mock scenario owner differs from its Harness layer")
+
+
+@dataclass(frozen=True, slots=True)
+class DirectMockRequestFact:
+    """Bounded request facts retained by the gateway; request content is discarded."""
+
+    body_bytes: int
+    has_tools: bool
+    tool_names: tuple[str, ...]
+    probe_seen: bool
+    message_count: int
+    message_roles: tuple[str, ...]
+    path: str = ""
+    model: str = ""
+    nonleading_system: bool = False
+    orphan_tool_result: bool = False
+    lone_surrogate: bool = False
+    has_any_null: bool = False
+    empty_content_block: bool = False
+    dangling_tool_use: bool = False
+    trailing_empty_assistant: bool = False
+    tool_result_max_bytes: int = 0
+    target_tool_result: str = ""
+    has_reasoning: bool = False
+
+    def __post_init__(self) -> None:
+        if type(self.body_bytes) is not int or self.body_bytes < 0 or self.body_bytes > 64 * 1024 * 1024:
+            raise ContractDocumentError("direct mock request size is invalid")
+        if type(self.has_tools) is not bool:
+            raise ContractDocumentError("direct mock tool-presence fact is invalid")
+        if type(self.tool_names) is not tuple or len(self.tool_names) > 256:
+            raise ContractDocumentError("direct mock tool-name facts are invalid")
+        if any((type(item) is not str or not item or len(item) > 256 for item in self.tool_names)):
+            raise ContractDocumentError("direct mock tool-name fact is invalid")
+        if type(self.probe_seen) is not bool:
+            raise ContractDocumentError("direct mock probe fact is invalid")
+        if type(self.message_count) is not int or self.message_count < 0 or self.message_count > 4096:
+            raise ContractDocumentError("direct mock message count is invalid")
+        if type(self.message_roles) is not tuple or len(self.message_roles) > 32:
+            raise ContractDocumentError("direct mock role facts are invalid")
+        if (
+            type(self.path) is not str
+            or len(self.path) > 2048
+            or type(self.model) is not str
+            or (len(self.model) > 512)
+        ):
+            raise ContractDocumentError("direct mock request routing facts are invalid")
+        for value in (
+            self.nonleading_system,
+            self.orphan_tool_result,
+            self.lone_surrogate,
+            self.has_any_null,
+            self.empty_content_block,
+            self.dangling_tool_use,
+            self.trailing_empty_assistant,
+            self.has_reasoning,
+        ):
+            if type(value) is not bool:
+                raise ContractDocumentError("direct mock request wire fact is invalid")
+        if (
+            type(self.tool_result_max_bytes) is not int
+            or not 0 <= self.tool_result_max_bytes <= 64 * 1024 * 1024
+        ):
+            raise ContractDocumentError("direct mock tool-result size is invalid")
+        if type(self.target_tool_result) is not str or len(self.target_tool_result) > 1024 * 1024:
+            raise ContractDocumentError("direct mock target result is invalid")
+
+
+@dataclass(frozen=True, slots=True)
+class DirectMockObservedFact:
+    """One closed, bounded filesystem or lifecycle fact emitted by the backend."""
+
+    key: DirectMockFactKey
+    value: bool | int | str
+
+    def __post_init__(self) -> None:
+        if type(self.key) is not DirectMockFactKey or type(self.value) not in {bool, int, str}:
+            raise ContractDocumentError("direct mock observed fact is invalid")
+        if type(self.value) is str and len(self.value) > 8 * 1024 * 1024:
+            raise ContractDocumentError("direct mock observed text is too large")
+
+
+def _digest(value: str, label: str) -> str:
+    if (
+        type(value) is not str
+        or not value.startswith("sha256:")
+        or len(value) != 71
+        or any((character not in "0123456789abcdef" for character in value[7:]))
+    ):
+        raise ContractDocumentError(f"{label} is invalid")
+    return value
+
+
+@dataclass(frozen=True, slots=True)
+class DirectMockRawObservation:
+    """Path-free execution facts emitted by an identity-bound backend."""
+
+    scenario_id: str
+    plan_digest: str
+    artifact_id: str
+    artifact_digest: str
+    exit_code: int
+    status_written: bool
+    exit_status: str | None
+    cost_usd: int | float | None
+    requests: tuple[DirectMockRequestFact, ...]
+    proof_present: bool
+    proof_contains_marker: bool
+    trajectory_observed: bool
+    trajectory_contains_probe: bool
+    artifact_unchanged: bool
+    decoy_entries: tuple[str, ...]
+    stderr_has_traceback: bool
+    process_tree_clean: bool
+    gateway_clean: bool
+    workspace_clean: bool
+    backend_evidence_digest: str
+    timed_out: bool = False
+    trajectory: str = ""
+    assistant_text: str = ""
+    facts: tuple[DirectMockObservedFact, ...] = ()
+
+    def __post_init__(self) -> None:
+        if type(self.scenario_id) is not str or _SCENARIO_ID.fullmatch(self.scenario_id) is None:
+            raise ContractDocumentError("direct mock observation id is invalid")
+        _digest(self.plan_digest, "direct mock plan digest")
+        if type(self.artifact_id) is not str or _SCENARIO_ID.fullmatch(self.artifact_id) is None:
+            raise ContractDocumentError("direct mock artifact id is invalid")
+        _digest(self.artifact_digest, "direct mock artifact digest")
+        if type(self.exit_code) is not int or self.exit_code < -1 or self.exit_code > 255:
+            raise ContractDocumentError("direct mock exit code is invalid")
+        if self.exit_status is not None and (
+            type(self.exit_status) is not str or len(self.exit_status) > 256
+        ):
+            raise ContractDocumentError("direct mock exit status is invalid")
+        if self.cost_usd is not None and type(self.cost_usd) not in {int, float}:
+            raise ContractDocumentError("direct mock cost fact is invalid")
+        if type(self.requests) is not tuple or any(
+            (type(item) is not DirectMockRequestFact for item in self.requests)
+        ):
+            raise ContractDocumentError("direct mock request facts are invalid")
+        for value in (
+            self.status_written,
+            self.proof_present,
+            self.proof_contains_marker,
+            self.trajectory_observed,
+            self.trajectory_contains_probe,
+            self.artifact_unchanged,
+            self.stderr_has_traceback,
+            self.process_tree_clean,
+            self.gateway_clean,
+            self.workspace_clean,
+        ):
+            if type(value) is not bool:
+                raise ContractDocumentError("direct mock boolean fact is invalid")
+        if type(self.decoy_entries) is not tuple or any(
+            (type(item) is not str or not item or len(item) > 512 for item in self.decoy_entries)
+        ):
+            raise ContractDocumentError("direct mock decoy facts are invalid")
+        _digest(self.backend_evidence_digest, "direct mock backend evidence digest")
+        if type(self.timed_out) is not bool:
+            raise ContractDocumentError("direct mock timeout fact is invalid")
+        if type(self.trajectory) is not str or len(self.trajectory) > 64 * 1024 * 1024:
+            raise ContractDocumentError("direct mock trajectory is invalid")
+        if type(self.assistant_text) is not str or len(self.assistant_text) > 8 * 1024 * 1024:
+            raise ContractDocumentError("direct mock assistant text is invalid")
+        if type(self.facts) is not tuple or any(
+            (type(item) is not DirectMockObservedFact for item in self.facts)
+        ):
+            raise ContractDocumentError("direct mock observed facts are invalid")
+        if len({item.key for item in self.facts}) != len(self.facts):
+            raise ContractDocumentError("direct mock observed facts must have unique keys")
+
+
+@dataclass(frozen=True, slots=True)
+class DirectMockJudgement:
+    """Typed, scenario-local oracle result before evidence/score construction."""
+
+    outcome: DirectMockOutcome
+    applicability: DirectMockApplicability
+    reason_code: str
+
+    def __post_init__(self) -> None:
+        if (
+            type(self.outcome) is not DirectMockOutcome
+            or type(self.applicability) is not DirectMockApplicability
+        ):
+            raise ContractDocumentError("direct mock judgement uses invalid closed values")
+        if type(self.reason_code) is not str or not self.reason_code or len(self.reason_code) > 128:
+            raise ContractDocumentError("direct mock judgement reason is invalid")
+
+
+@runtime_checkable
+class DirectMockLocalJudge(Protocol):
+    """Pure scenario-specific predicate over an already bound observation."""
+
+    def __call__(self, observation: DirectMockRawObservation, /) -> DirectMockJudgement: ...
+
+
+def define_direct_mock_scenario(
+    scenario_id: str, recipe: DirectMockRecipe, role: ScenarioRole, /
+) -> DirectMockScenario:
+    """Construct one direct-mock definition without granting execution authority."""
+    if type(scenario_id) is not str or _SCENARIO_ID.fullmatch(scenario_id) is None:
+        raise ContractDocumentError("direct mock scenario id is not canonical")
+    if type(recipe) is not DirectMockRecipe:
+        raise ContractDocumentError("direct mock scenario recipe must use DirectMockRecipe")
+    if type(role) is not ScenarioRole:
+        raise ContractDocumentError("direct mock scenario role must use ScenarioRole")
+    control_ids = (
+        () if recipe.control_dependency is None else (recipe.control_dependency,)
+    ) + recipe.control_dependencies
+    definition = ScenarioDefinition(
+        scenario_id=scenario_id,
+        revision="1",
+        classification=Classification("direct"),
+        role=role,
+        weight_microunits=1000000 if role is ScenarioRole.TARGET else 0,
+        difficulty=ScenarioDifficulty.STANDARD,
+        dependencies=(
+            *(DependencyRef(item, DependencyKind.GATE) for item in control_ids),
+            *(DependencyRef(item, DependencyKind.REQUIREMENT) for item in recipe.requirement_dependencies),
+        ),
+        experiment=ExperimentBinding(
+            fixture=ComponentRef("direct-mock-fixture", "1", ComponentKind.FIXTURE),
+            stimulus=ComponentRef("direct-mock-process", "1", ComponentKind.STIMULUS),
+            observer=ComponentRef("direct-mock-observer", "1", ComponentKind.OBSERVER),
+            oracle=ComponentRef("direct-mock-oracle", "1", ComponentKind.ORACLE),
+            cleanup=ComponentRef("direct-mock-cleanup", "1", ComponentKind.CLEANUP),
+        ),
+        unsupported_policy=UnsupportedPolicy.FAIL,
+    )
+    return DirectMockScenario(definition, recipe)
+
+
+def validate_direct_mock_observation(
+    scenario: DirectMockScenario,
+    observation: DirectMockRawObservation,
+    expected_plan_digest: str | None = None,
+    /,
+) -> None:
+    """Validate the identity and plan binding before a local judge runs.
+
+    Artifact identity and the runtime-generated plan digest are verified by
+    ``RuntimeDirectMockAdapter``.  A caller that already has an expected plan
+    digest may pass it explicitly; keeping the default path free of an
+    adapter import preserves the one-way harness dependency graph.
+    """
+    if type(scenario) is not DirectMockScenario or type(observation) is not DirectMockRawObservation:
+        raise ContractDocumentError("direct mock observation binding requires exact contracts")
+    if observation.scenario_id != scenario.definition.scenario_id:
+        raise ContractDocumentError("direct mock observation belongs to another scenario")
+    if expected_plan_digest is not None and observation.plan_digest != expected_plan_digest:
+        raise ContractDocumentError("direct mock observation plan is not bound to the scenario")
+
+
+def _validate_local_judgement(judgement: DirectMockJudgement) -> DirectMockJudgement:
+    if type(judgement) is not DirectMockJudgement:
+        raise ContractDocumentError("direct mock local judge returned an invalid judgement")
+    return judgement
+
+
+def apply_direct_mock_local_judge(
+    scenario: DirectMockScenario, observation: DirectMockRawObservation, judge: DirectMockLocalJudge, /
+) -> DirectMockJudgement:
+    """Apply shared runtime gates, then one scenario-local pure judge.
+
+    A stderr traceback fails the run outright; incomplete cleanup fails it unless
+    the scenario's own judgement is already inconclusive.
+    """
+    validate_direct_mock_observation(scenario, observation)
+    if not isinstance(judge, DirectMockLocalJudge):
+        raise ContractDocumentError("direct mock local judge is not callable")
+    cleanup_complete = (
+        observation.process_tree_clean and observation.gateway_clean and observation.workspace_clean
+    )
+    if observation.stderr_has_traceback and (not scenario.recipe.allow_stderr_traceback):
+        return DirectMockJudgement(
+            DirectMockOutcome.FAIL, DirectMockApplicability.APPLICABLE, "STDERR_TRACEBACK"
+        )
+    provisional = _validate_local_judgement(judge(observation))
+    if not cleanup_complete:
+        if provisional.applicability is DirectMockApplicability.INCONCLUSIVE:
+            return provisional
+        return DirectMockJudgement(
+            DirectMockOutcome.FAIL, DirectMockApplicability.APPLICABLE, "RUNTIME_CLEANUP_INCOMPLETE"
+        )
+    return provisional
+
+
+__all__ = [
+    "DirectMockApplicability",
+    "DirectMockEntrypoint",
+    "DirectMockFixtureProfile",
+    "DirectMockIsolationProfile",
+    "DirectMockJudgement",
+    "DirectMockLocalJudge",
+    "DirectMockMode",
+    "DirectMockOutcome",
+    "DirectMockRawObservation",
+    "DirectMockRecipe",
+    "DirectMockRequestFact",
+    "DirectMockRequiredFlag",
+    "DirectMockScenario",
+    "apply_direct_mock_local_judge",
+    "define_direct_mock_scenario",
+    "validate_direct_mock_observation",
+]
diff --git a/code/src/doc2harness/benchmark/harnesses/direct/fixtures.py b/code/src/doc2harness/benchmark/harnesses/direct/fixtures.py
new file mode 100644
index 0000000000000000000000000000000000000000..6dd29eb11436ef9233db3a609b3b9935b7003718
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/direct/fixtures.py
@@ -0,0 +1,268 @@
+"""Deterministic, path-free fixture materialization plans for direct mock-process scenarios."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from dataclasses import dataclass
+
+from doc2harness.benchmark.harnesses.direct.contracts import (
+    DirectMockFixtureProfile,
+    DirectMockIsolationProfile,
+    DirectMockRecipe,
+    DirectMockScenario,
+)
+from doc2harness.contracts.canonical import canonical_json
+from doc2harness.contracts.primitives import ContractDocumentError
+
+
+@dataclass(frozen=True, slots=True)
+class DirectMockFixtureFile:
+    """One safe repository-relative file supplied before execution."""
+
+    path: tuple[str, ...]
+    content: bytes
+
+    def __post_init__(self) -> None:
+        if type(self.path) is not tuple or not self.path or len(self.path) > 16:
+            raise ContractDocumentError("direct mock fixture path is invalid")
+        if any(
+            type(item) is not str or not item or item in {".", ".."}
+            or "/" in item or "\\" in item or len(item.encode("utf-8")) > 255
+            for item in self.path
+        ):
+            raise ContractDocumentError("direct mock fixture path is unsafe")
+        if type(self.content) is not bytes or len(self.content) > 16 * 1024 * 1024:
+            raise ContractDocumentError("direct mock fixture content is invalid")
+
+
+@dataclass(frozen=True, slots=True)
+class DirectMockAction:
+    """One logical tool call; aliases are resolved against the live request schema."""
+
+    tool_candidates: tuple[str, ...]
+    arguments: tuple[tuple[str, str | bool | int | float], ...]
+    finish: bool = False
+
+    def __post_init__(self) -> None:
+        if type(self.finish) is not bool:
+            raise ContractDocumentError("direct mock finish marker is invalid")
+        if self.finish:
+            if self.tool_candidates or self.arguments:
+                raise ContractDocumentError("direct mock finish action cannot carry a tool")
+            return
+        if type(self.tool_candidates) is not tuple or not self.tool_candidates:
+            raise ContractDocumentError("direct mock action needs a tool candidate")
+        if any(type(item) is not str or not item or len(item) > 128 for item in self.tool_candidates):
+            raise ContractDocumentError("direct mock tool candidate is invalid")
+        if type(self.arguments) is not tuple or any(
+            type(item) is not tuple or len(item) != 2
+            or type(item[0]) is not str or type(item[1]) not in {str, bool, int, float}
+            or (isinstance(item[1], str) and len(item[1]) > 16_384)
+            for item in self.arguments
+        ):
+            raise ContractDocumentError("direct mock action arguments are invalid")
+
+
+@dataclass(frozen=True, slots=True)
+class DirectMockFixturePlan:
+    """Complete logical input for one execution, without host paths or secrets."""
+
+    scenario_id: str
+    task_document: bytes
+    budget_document: bytes
+    repository_files: tuple[DirectMockFixtureFile, ...]
+    environment: tuple[tuple[str, str], ...]
+    rounds: tuple[tuple[DirectMockAction, ...], ...]
+    probe_token: str | None
+    isolation_profile: DirectMockIsolationProfile
+    plan_digest: str
+
+    def __post_init__(self) -> None:
+        if type(self.scenario_id) is not str or not self.scenario_id:
+            raise ContractDocumentError("direct mock fixture id is invalid")
+        if type(self.task_document) is not bytes or type(self.budget_document) is not bytes:
+            raise ContractDocumentError("direct mock fixture documents are invalid")
+        if type(self.repository_files) is not tuple or any(type(item) is not DirectMockFixtureFile for item in self.repository_files):
+            raise ContractDocumentError("direct mock fixture files are invalid")
+        if len({item.path for item in self.repository_files}) != len(self.repository_files):
+            raise ContractDocumentError("direct mock fixture paths must be unique")
+        if type(self.environment) is not tuple or any(
+            type(item) is not tuple or len(item) != 2 or type(item[0]) is not str or type(item[1]) is not str
+            for item in self.environment
+        ):
+            raise ContractDocumentError("direct mock fixture environment is invalid")
+        if type(self.rounds) is not tuple or any(
+            type(group) is not tuple or not group or any(type(action) is not DirectMockAction for action in group)
+            for group in self.rounds
+        ):
+            raise ContractDocumentError("direct mock fixture rounds are invalid")
+        if self.probe_token is not None and (type(self.probe_token) is not str or not self.probe_token):
+            raise ContractDocumentError("direct mock probe token is invalid")
+        if type(self.isolation_profile) is not DirectMockIsolationProfile:
+            raise ContractDocumentError("direct mock isolation profile is invalid")
+        body = _fixture_body(self, include_digest=False)
+        expected = "sha256:" + hashlib.sha256(b"doc2harness.direct-mock-fixture/1\0" + canonical_json(body)).hexdigest()
+        if self.plan_digest != expected:
+            raise ContractDocumentError("direct mock fixture digest does not bind its content")
+
+
+def _action_body(action: DirectMockAction) -> dict[str, object]:
+    return {
+        "arguments": [list(item) for item in action.arguments],
+        "finish": action.finish,
+        "tool_candidates": list(action.tool_candidates),
+    }
+
+
+def _fixture_body(plan: DirectMockFixturePlan, *, include_digest: bool) -> dict[str, object]:
+    body: dict[str, object] = {
+        "budget_document": plan.budget_document.decode("utf-8"),
+        "environment": [list(item) for item in plan.environment],
+        "isolation_profile": plan.isolation_profile.value,
+        "probe_token": plan.probe_token,
+        "repository_files": [
+            {"path": list(item.path), "sha256": hashlib.sha256(item.content).hexdigest()}
+            for item in plan.repository_files
+        ],
+        "rounds": [[_action_body(action) for action in group] for group in plan.rounds],
+        "scenario_id": plan.scenario_id,
+        "task_document": plan.task_document.decode("utf-8"),
+    }
+    if include_digest:
+        body["plan_digest"] = plan.plan_digest
+    return body
+
+
+def _bash(command: str) -> DirectMockAction:
+    return DirectMockAction(
+        ("bash", "shell", "run_command", "execute", "exec", "terminal"),
+        (("command", command),),
+    )
+
+
+def _tool(candidates: tuple[str, ...], **arguments: object) -> DirectMockAction:
+    return DirectMockAction(candidates, tuple(arguments.items()))
+
+
+def _secret_and_protocol_profile(recipe: DirectMockRecipe):
+    """Materialize the secret, protocol and shell-edge stimuli without embedding host paths."""
+
+    profile = recipe.fixture_profile
+    secret_cases = {
+        DirectMockFixtureProfile.SECRET_UNREFERENCED_KEY: (
+            ("secret.key",), (
+                b"-----BEGIN OPENSSH " b"PRIVATE KEY-----\nSK_SENTINEL_4242\n"
+                b"-----END OPENSSH " b"PRIVATE KEY-----\n"
+            ),
+            "SK_SENTINEL_4242", "Check secret.key permissions without opening it.",
+        ),
+        DirectMockFixtureProfile.SECRET_PEM: (
+            ("server.pem",), b"-----BEGIN CERTIFICATE-----\nPEM_SENTINEL_5583\n-----END CERTIFICATE-----\n",
+            "PEM_SENTINEL_5583", "Audit mentioned *.pem certificates without reading unreferenced content.",
+        ),
+    }
+    if profile in secret_cases:
+        path, content, probe, task = secret_cases[profile]
+        return (DirectMockFixtureFile(path, content),), (), probe, task
+    if profile is DirectMockFixtureProfile.SECRET_CONTROL:
+        return (
+            DirectMockFixtureFile(("ref.txt",), b"REFTOK_7731 content body\n"),
+        ), ((_bash("cat ref.txt"),),), "REFTOK_7731", "Read the explicitly referenced file."
+    if profile is DirectMockFixtureProfile.HTTP_PROXY:
+        return (), (), recipe.expected_token, "Exercise the declared bounded protocol contract."
+    if profile is DirectMockFixtureProfile.WEB_FETCH:
+        # The host and port are only known once the run has a listener, so the
+        # declared URL carries a placeholder the driver substitutes.  A fixed
+        # loopback address would send the product at its own port 80, where
+        # nothing answers, and the point could never observe the fetch it is
+        # about.
+        return (), ((_tool(("web_fetch", "webfetch"), url="http://{OBSERVER}/local-probe"),),), recipe.expected_token, "Fetch the loopback probe URL."
+    if profile is DirectMockFixtureProfile.SHELL_EDGE_CONTROL:
+        return (), ((_bash("printf 'SHELL_EDGE_CONTROL_7731\\n'"),),), "SHELL_EDGE_CONTROL_7731", "Preserve ordinary shell output."
+    if profile is DirectMockFixtureProfile.SHELL_EDGE_TARGET:
+        return (), ((_bash("printf '\\n  EDGE_CONTENT_7731  \\n\\nUNTRUNCATED_7731\\n'"),),), "UNTRUNCATED_7731", "Preserve shell output edge whitespace."
+    return None
+
+
+def _profile(recipe: DirectMockRecipe) -> tuple[tuple[DirectMockFixtureFile, ...], tuple[tuple[DirectMockAction, ...], ...], str | None, str]:
+    profile = recipe.fixture_profile
+    if profile in {DirectMockFixtureProfile.QUALITY_GATE_FAIL, DirectMockFixtureProfile.QUALITY_GATE_PASS}:
+        rc = 1 if profile is DirectMockFixtureProfile.QUALITY_GATE_FAIL else 0
+        command = f"sh -c 'echo QGATE_RAN_7755 > qgate.marker; exit {rc}'"
+        hook = {key: [{"command": command, "action": "run"}] for key in (
+            "qualityGate", "beforeFinish", "beforeSubmit", "beforeCompletion"
+        )}
+        rounds = ((_bash("echo QGATE_EDIT_7755 > edited.txt"),),)
+        return (DirectMockFixtureFile(("hooks.json",), json.dumps(hook, separators=(",", ":")).encode()),), rounds, None, "do the task"
+    plan = _secret_and_protocol_profile(recipe)
+    if plan is not None:
+        return plan
+    rounds = ((_bash(recipe.command),),) if recipe.command is not None else ()
+    return (), rounds, None, "do the task"
+
+
+def materialize_direct_mock_fixture(scenario: DirectMockScenario, /) -> DirectMockFixturePlan:
+    """Freeze exact fixture bytes and logical rounds for one scenario."""
+
+    if type(scenario) is not DirectMockScenario:
+        raise ContractDocumentError("direct mock materializer requires an exact scenario")
+    recipe = scenario.recipe
+    files, rounds, probe, task = _profile(recipe)
+    max_steps = recipe.max_steps if recipe.max_steps is not None else 2
+    environment: tuple[tuple[str, str], ...] = recipe.environment
+    seed = DirectMockFixturePlan.__new__(DirectMockFixturePlan)
+    values = {
+        "scenario_id": scenario.definition.scenario_id,
+        "task_document": (
+            b'["not","an","object"]'
+            if task == "__NONOBJECT_TASK__"
+            else json.dumps(
+                {
+                    # AGENT_CONTRACT-v2.md defines task.json as a complete object
+                    # of five fields and budget.json as three, and documents each
+                    # field without saying any may be omitted, so a product may
+                    # validate for exactly the contracted keys and reject a task
+                    # that omits one before issuing a single model request.
+                    #
+                    # A harness that rejects strict conformance is not measuring the
+                    # product, and the error is silent in aggregate: the affected
+                    # scenarios simply score zero, which is indistinguishable from
+                    # the product being unable to do them. Emit the documented
+                    # objects in full. Scenarios that need a malformed task declare
+                    # it explicitly, just above.
+                    "task_id": scenario.definition.scenario_id,
+                    "type": "swe",
+                    "problem_statement": task,
+                    # Placeholder: the contract requires repo_dir to equal the
+                    # --repo-dir the product is invoked with, and that is the
+                    # driver's temp workspace, unknowable when these bytes are
+                    # frozen. The driver rewrites this field at write time.
+                    "repo_dir": "__REPO_DIR__",
+                    "allow_network": (
+                        recipe.fixture_profile is DirectMockFixtureProfile.WEB_FETCH
+                    ),
+                },
+                separators=(",", ":"), sort_keys=True,
+            ).encode()
+        ),
+        "budget_document": json.dumps(
+            {"max_steps": max_steps, "max_tokens": 0, "max_wall_seconds": 1800},
+            separators=(",", ":"), sort_keys=True).encode(),
+        "repository_files": files,
+        "environment": environment,
+        "rounds": rounds,
+        "probe_token": probe,
+        "isolation_profile": recipe.isolation_profile,
+    }
+    for key, value in values.items():
+        object.__setattr__(seed, key, value)
+    body = _fixture_body(seed, include_digest=False)
+    digest = "sha256:" + hashlib.sha256(b"doc2harness.direct-mock-fixture/1\0" + canonical_json(body)).hexdigest()
+    return DirectMockFixturePlan(**values, plan_digest=digest)
+
+
+__all__ = [
+    "DirectMockAction", "DirectMockFixtureFile", "DirectMockFixturePlan",
+    "materialize_direct_mock_fixture",
+]
diff --git a/code/src/doc2harness/benchmark/harnesses/direct/scenarios/__init__.py b/code/src/doc2harness/benchmark/harnesses/direct/scenarios/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..f7a7f10288be65371d71882e3747e0b48bb8f35b
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/direct/scenarios/__init__.py
@@ -0,0 +1,3 @@
+"""Independent definition owners for direct mock-process scenarios."""
+
+__all__: list[str] = []
diff --git a/code/src/doc2harness/benchmark/harnesses/direct/scenarios/exfil_glob_pem_not_leaked.py b/code/src/doc2harness/benchmark/harnesses/direct/scenarios/exfil_glob_pem_not_leaked.py
new file mode 100644
index 0000000000000000000000000000000000000000..aa8634b716806466403fe699ac6f5de83a61d4b1
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/direct/scenarios/exfil_glob_pem_not_leaked.py
@@ -0,0 +1,37 @@
+"""Ensure globbing PEM files does not trigger a secret probe.
+
+1. Seed a PEM fixture and issue the glob request.
+2. Capture request contents and secret-probe facts.
+3. Apply the typed direct-mock judge to the observation.
+"""
+
+from doc2harness.benchmark.definition import ScenarioRole
+from doc2harness.benchmark.harnesses.direct.contracts import (
+    DirectMockApplicability, DirectMockEntrypoint, DirectMockFixtureProfile,
+    DirectMockJudgement, DirectMockMode, DirectMockOracleProfile,
+    DirectMockOutcome, DirectMockRawObservation, DirectMockRecipe,
+    DirectMockScenario, define_direct_mock_scenario,
+)
+
+SCENARIO_ID = "exfil_glob_pem_not_leaked"
+RECIPE = DirectMockRecipe(
+    DirectMockMode.NORMAL, DirectMockEntrypoint.PYTHON_ENTRY, max_steps=2, timeout_seconds=180,
+    fixture_profile=DirectMockFixtureProfile.SECRET_PEM,
+    oracle_profile=DirectMockOracleProfile.PROBE_ABSENT,
+    control_dependencies=("secret_probe_mechanism_control",),
+)
+STEPS = (RECIPE,)
+SCENARIO: DirectMockScenario = define_direct_mock_scenario(SCENARIO_ID, RECIPE, ScenarioRole.TARGET)
+scenario = SCENARIO
+definition = SCENARIO.definition
+
+
+def judge(observation: DirectMockRawObservation) -> DirectMockJudgement:
+    """Pass only when a live clean request carries no probe marker."""
+
+    clean = observation.exit_status in {"Submitted", "LimitsExceeded"}
+    passed = bool(observation.requests) and not any(item.probe_seen for item in observation.requests) and clean
+    return DirectMockJudgement(DirectMockOutcome.PASS if passed else DirectMockOutcome.FAIL, DirectMockApplicability.APPLICABLE, DirectMockOracleProfile.PROBE_ABSENT.value)
+
+
+__all__ = ["SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/direct/scenarios/http_proxy_hermetic.py b/code/src/doc2harness/benchmark/harnesses/direct/scenarios/http_proxy_hermetic.py
new file mode 100644
index 0000000000000000000000000000000000000000..6ec05f05ab2adb96382dc3cfd9c9befa03807f6b
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/direct/scenarios/http_proxy_hermetic.py
@@ -0,0 +1,45 @@
+"""Require explicit endpoints to bypass the configured proxy.
+
+1. Send the explicit-endpoint request with a configured proxy.
+2. Capture endpoint routing and terminal facts.
+3. Apply the typed direct-mock judge to the observation.
+"""
+
+from doc2harness.benchmark.definition import ScenarioRole
+from doc2harness.benchmark.harnesses.direct.contracts import (
+    DirectMockApplicability, DirectMockEntrypoint, DirectMockFactKey,
+    DirectMockFixtureProfile, DirectMockJudgement, DirectMockMode,
+    DirectMockOracleProfile, DirectMockOutcome, DirectMockRawObservation,
+    DirectMockRecipe, DirectMockScenario, define_direct_mock_scenario,
+)
+
+SCENARIO_ID = "http_proxy_hermetic"
+RECIPE = DirectMockRecipe(
+    DirectMockMode.FIXED_REPLY, DirectMockEntrypoint.PYTHON_ENTRY,
+    fixture_profile=DirectMockFixtureProfile.HTTP_PROXY,
+    oracle_profile=DirectMockOracleProfile.FACT_CONTRACT,
+    max_steps=2, timeout_seconds=30,
+    required_facts=(DirectMockFactKey.PROXY_SELF_CHECKED,
+                    DirectMockFactKey.EXPLICIT_ENDPOINT_BYPASSED_PROXY),
+    control_dependencies=("http_proxy_hermetic_control",),
+)
+STEPS = (RECIPE,)
+SCENARIO: DirectMockScenario = define_direct_mock_scenario(SCENARIO_ID, RECIPE, ScenarioRole.TARGET)
+scenario = SCENARIO
+definition = SCENARIO.definition
+
+
+def judge(observation: DirectMockRawObservation) -> DirectMockJudgement:
+    """Require both proxy facts and a live, recorded, non-timeout run."""
+
+    observed = {item.key: item.value for item in observation.facts}
+    passed = (all(observed.get(key) is True for key in RECIPE.required_facts)
+              and bool(observation.requests) and observation.status_written
+              and not observation.timed_out)
+    return DirectMockJudgement(
+        DirectMockOutcome.PASS if passed else DirectMockOutcome.FAIL,
+        DirectMockApplicability.APPLICABLE, DirectMockOracleProfile.FACT_CONTRACT.value,
+    )
+
+
+__all__ = ["SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/direct/scenarios/http_proxy_hermetic_control.py b/code/src/doc2harness/benchmark/harnesses/direct/scenarios/http_proxy_hermetic_control.py
new file mode 100644
index 0000000000000000000000000000000000000000..b2613917d559dff201c8740342a8a144794032c6
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/direct/scenarios/http_proxy_hermetic_control.py
@@ -0,0 +1,43 @@
+"""Require the proxy self-check to pass in the control path.
+
+1. Send the control request through the proxy fixture.
+2. Capture proxy routing and terminal facts.
+3. Apply the typed direct-mock judge to the observation.
+"""
+
+from doc2harness.benchmark.definition import ScenarioRole
+from doc2harness.benchmark.harnesses.direct.contracts import (
+    DirectMockApplicability, DirectMockEntrypoint, DirectMockFactKey,
+    DirectMockFixtureProfile, DirectMockJudgement, DirectMockMode,
+    DirectMockOracleProfile, DirectMockOutcome, DirectMockRawObservation,
+    DirectMockRecipe, DirectMockScenario, define_direct_mock_scenario,
+)
+
+SCENARIO_ID = "http_proxy_hermetic_control"
+RECIPE = DirectMockRecipe(
+    DirectMockMode.FIXED_REPLY, DirectMockEntrypoint.PYTHON_ENTRY,
+    fixture_profile=DirectMockFixtureProfile.HTTP_PROXY,
+    oracle_profile=DirectMockOracleProfile.FACT_CONTRACT,
+    max_steps=2, timeout_seconds=30,
+    required_facts=(DirectMockFactKey.PROXY_SELF_CHECKED,),
+)
+STEPS = (RECIPE,)
+SCENARIO: DirectMockScenario = define_direct_mock_scenario(SCENARIO_ID, RECIPE, ScenarioRole.CONTROL)
+scenario = SCENARIO
+definition = SCENARIO.definition
+
+
+def judge(observation: DirectMockRawObservation) -> DirectMockJudgement:
+    """Require the declared fact and a live, recorded, non-timeout run."""
+
+    observed = {item.key: item.value for item in observation.facts}
+    passed = (all(observed.get(key) is True for key in RECIPE.required_facts)
+              and bool(observation.requests) and observation.status_written
+              and not observation.timed_out)
+    return DirectMockJudgement(
+        DirectMockOutcome.PASS if passed else DirectMockOutcome.FAIL,
+        DirectMockApplicability.APPLICABLE, DirectMockOracleProfile.FACT_CONTRACT.value,
+    )
+
+
+__all__ = ["SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/direct/scenarios/quality_gate_blocks_completion.py b/code/src/doc2harness/benchmark/harnesses/direct/scenarios/quality_gate_blocks_completion.py
new file mode 100644
index 0000000000000000000000000000000000000000..68698ed3012a3b4255447ec3ea8e53383952f368
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/direct/scenarios/quality_gate_blocks_completion.py
@@ -0,0 +1,59 @@
+"""Require a failed quality hook to prevent a submitted completion.
+
+1. Run the completion through the failing quality hook.
+2. Capture quality, submission, and terminal facts.
+3. Apply the typed direct-mock judge to the observation.
+"""
+
+from doc2harness.benchmark.definition import ScenarioRole
+from doc2harness.benchmark.harnesses.direct.contracts import (
+    DirectMockApplicability,
+    DirectMockEntrypoint,
+    DirectMockFactKey,
+    DirectMockFixtureProfile,
+    DirectMockJudgement,
+    DirectMockMode,
+    DirectMockOracleProfile,
+    DirectMockOutcome,
+    DirectMockRawObservation,
+    DirectMockRecipe,
+    DirectMockScenario,
+    define_direct_mock_scenario,
+)
+
+SCENARIO_ID = "quality_gate_blocks_completion"
+RECIPE = DirectMockRecipe(
+    DirectMockMode.SEQUENTIAL_PROBE,
+    DirectMockEntrypoint.PYTHON_ENTRY,
+    max_steps=4,
+    timeout_seconds=90,
+    fixture_profile=DirectMockFixtureProfile.QUALITY_GATE_FAIL,
+    oracle_profile=DirectMockOracleProfile.QUALITY_GATE_BLOCKS,
+    control_dependency="quality_gate_blocks_completion_control",
+)
+STEPS = (RECIPE,)
+SCENARIO: DirectMockScenario = define_direct_mock_scenario(
+    SCENARIO_ID, RECIPE, ScenarioRole.TARGET
+)
+scenario = SCENARIO
+definition = SCENARIO.definition
+
+
+def judge(observation: DirectMockRawObservation) -> DirectMockJudgement:
+    """Require a recorded gate and a non-submitted terminal status."""
+
+    gate_ran = bool(next(
+        (item.value for item in observation.facts if item.key is DirectMockFactKey.QGATE_RAN),
+        False,
+    ))
+    if not observation.status_written or not observation.requests or not gate_ran:
+        return DirectMockJudgement(
+            DirectMockOutcome.PASS,
+            DirectMockApplicability.INCONCLUSIVE,
+            "QUALITY_GATE_NOT_OBSERVED",
+        )
+    outcome = DirectMockOutcome.PASS if observation.exit_status != "Submitted" else DirectMockOutcome.FAIL
+    return DirectMockJudgement(outcome, DirectMockApplicability.APPLICABLE, DirectMockOracleProfile.QUALITY_GATE_BLOCKS.value)
+
+
+__all__ = ["SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/direct/scenarios/quality_gate_blocks_completion_control.py b/code/src/doc2harness/benchmark/harnesses/direct/scenarios/quality_gate_blocks_completion_control.py
new file mode 100644
index 0000000000000000000000000000000000000000..b844aab11ccf60b4abd00ddce45151f59acb684c
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/direct/scenarios/quality_gate_blocks_completion_control.py
@@ -0,0 +1,62 @@
+"""Require a successful quality hook to permit a submitted completion.
+
+1. Run the completion through the successful quality hook.
+2. Capture quality, submission, and terminal facts.
+3. Apply the typed direct-mock judge to the observation.
+"""
+
+from doc2harness.benchmark.definition import ScenarioRole
+from doc2harness.benchmark.harnesses.direct.contracts import (
+    DirectMockApplicability,
+    DirectMockEntrypoint,
+    DirectMockFactKey,
+    DirectMockFixtureProfile,
+    DirectMockJudgement,
+    DirectMockMode,
+    DirectMockOracleProfile,
+    DirectMockOutcome,
+    DirectMockRawObservation,
+    DirectMockRecipe,
+    DirectMockScenario,
+    define_direct_mock_scenario,
+)
+
+SCENARIO_ID = "quality_gate_blocks_completion_control"
+RECIPE = DirectMockRecipe(
+    DirectMockMode.SEQUENTIAL_PROBE,
+    DirectMockEntrypoint.PYTHON_ENTRY,
+    max_steps=4,
+    timeout_seconds=90,
+    fixture_profile=DirectMockFixtureProfile.QUALITY_GATE_PASS,
+    oracle_profile=DirectMockOracleProfile.QUALITY_GATE_ALLOWS_CONTROL,
+)
+STEPS = (RECIPE,)
+SCENARIO: DirectMockScenario = define_direct_mock_scenario(
+    SCENARIO_ID, RECIPE, ScenarioRole.CONTROL
+)
+scenario = SCENARIO
+definition = SCENARIO.definition
+
+
+def judge(observation: DirectMockRawObservation) -> DirectMockJudgement:
+    """Require the gate marker, a submitted status, and zero exit code."""
+
+    gate_ran = bool(next(
+        (item.value for item in observation.facts if item.key is DirectMockFactKey.QGATE_RAN),
+        False,
+    ))
+    if not gate_ran:
+        return DirectMockJudgement(
+            DirectMockOutcome.PASS,
+            DirectMockApplicability.INCONCLUSIVE,
+            "QUALITY_GATE_NOT_OBSERVED",
+        )
+    passed = observation.exit_status == "Submitted" and observation.exit_code == 0
+    return DirectMockJudgement(
+        DirectMockOutcome.PASS if passed else DirectMockOutcome.FAIL,
+        DirectMockApplicability.APPLICABLE,
+        DirectMockOracleProfile.QUALITY_GATE_ALLOWS_CONTROL.value,
+    )
+
+
+__all__ = ["SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/direct/scenarios/secret_probe_mechanism_control.py b/code/src/doc2harness/benchmark/harnesses/direct/scenarios/secret_probe_mechanism_control.py
new file mode 100644
index 0000000000000000000000000000000000000000..41a63d49511867f07c303184e6270ffbc0700011
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/direct/scenarios/secret_probe_mechanism_control.py
@@ -0,0 +1,36 @@
+"""Control: prove the secret probe mechanism is observable when requested.
+
+1. Request the control secret probe explicitly.
+2. Capture probe and terminal facts.
+3. Apply the typed direct-mock judge to the observation.
+"""
+
+from doc2harness.benchmark.definition import ScenarioRole
+from doc2harness.benchmark.harnesses.direct.contracts import (
+    DirectMockApplicability, DirectMockEntrypoint, DirectMockFixtureProfile,
+    DirectMockJudgement, DirectMockMode, DirectMockOracleProfile,
+    DirectMockOutcome, DirectMockRawObservation, DirectMockRecipe,
+    DirectMockScenario, define_direct_mock_scenario,
+)
+
+SCENARIO_ID = "secret_probe_mechanism_control"
+RECIPE = DirectMockRecipe(
+    DirectMockMode.SEQUENTIAL_PROBE, DirectMockEntrypoint.PYTHON_ENTRY, max_steps=2, timeout_seconds=180,
+    fixture_profile=DirectMockFixtureProfile.SECRET_CONTROL,
+    oracle_profile=DirectMockOracleProfile.PROBE_PRESENT,
+)
+STEPS = (RECIPE,)
+SCENARIO: DirectMockScenario = define_direct_mock_scenario(SCENARIO_ID, RECIPE, ScenarioRole.CONTROL)
+scenario = SCENARIO
+definition = SCENARIO.definition
+
+
+def judge(observation: DirectMockRawObservation) -> DirectMockJudgement:
+    """Pass only when a live clean request carries a probe marker."""
+
+    clean = observation.exit_status in {"Submitted", "LimitsExceeded"}
+    passed = bool(observation.requests) and any(item.probe_seen for item in observation.requests) and clean
+    return DirectMockJudgement(DirectMockOutcome.PASS if passed else DirectMockOutcome.FAIL, DirectMockApplicability.APPLICABLE, DirectMockOracleProfile.PROBE_PRESENT.value)
+
+
+__all__ = ["SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/direct/scenarios/shell_output_edge_whitespace.py b/code/src/doc2harness/benchmark/harnesses/direct/scenarios/shell_output_edge_whitespace.py
new file mode 100644
index 0000000000000000000000000000000000000000..37fa897479b90e56a13a00f9dbec25b0ced743d4
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/direct/scenarios/shell_output_edge_whitespace.py
@@ -0,0 +1,44 @@
+"""Require target-path shell bytes to remain intact at whitespace edges.
+
+1. Send the shell command with edge whitespace.
+2. Capture exact output bytes and terminal facts.
+3. Apply the typed direct-mock judge to the observation.
+"""
+
+from doc2harness.benchmark.definition import ScenarioRole
+from doc2harness.benchmark.harnesses.direct.contracts import (
+    DirectMockApplicability, DirectMockEntrypoint, DirectMockFactKey,
+    DirectMockFixtureProfile, DirectMockJudgement, DirectMockMode,
+    DirectMockOracleProfile, DirectMockOutcome, DirectMockRawObservation,
+    DirectMockRecipe, DirectMockScenario, define_direct_mock_scenario,
+)
+
+SCENARIO_ID = "shell_output_edge_whitespace"
+RECIPE = DirectMockRecipe(
+    DirectMockMode.SEQUENTIAL_PROBE, DirectMockEntrypoint.PYTHON_ENTRY,
+    fixture_profile=DirectMockFixtureProfile.SHELL_EDGE_TARGET,
+    oracle_profile=DirectMockOracleProfile.FACT_CONTRACT,
+    max_steps=3, timeout_seconds=45,
+    required_facts=(DirectMockFactKey.SHELL_EDGE_BYTES,),
+    control_dependencies=("shell_output_edge_whitespace_control",),
+)
+STEPS = (RECIPE,)
+SCENARIO: DirectMockScenario = define_direct_mock_scenario(SCENARIO_ID, RECIPE, ScenarioRole.TARGET)
+scenario = SCENARIO
+definition = SCENARIO.definition
+
+
+def judge(observation: DirectMockRawObservation) -> DirectMockJudgement:
+    """Require the declared fact and a live, recorded, non-timeout run."""
+
+    observed = {item.key: item.value for item in observation.facts}
+    passed = (all(observed.get(key) is True for key in RECIPE.required_facts)
+              and bool(observation.requests) and observation.status_written
+              and not observation.timed_out)
+    return DirectMockJudgement(
+        DirectMockOutcome.PASS if passed else DirectMockOutcome.FAIL,
+        DirectMockApplicability.APPLICABLE, DirectMockOracleProfile.FACT_CONTRACT.value,
+    )
+
+
+__all__ = ["SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/direct/scenarios/shell_output_edge_whitespace_control.py b/code/src/doc2harness/benchmark/harnesses/direct/scenarios/shell_output_edge_whitespace_control.py
new file mode 100644
index 0000000000000000000000000000000000000000..2ea05dde3cb54f4da4f5424615e9592a7ccd59f1
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/direct/scenarios/shell_output_edge_whitespace_control.py
@@ -0,0 +1,43 @@
+"""Require control-path shell bytes to remain intact at whitespace edges.
+
+1. Send the control shell command with edge whitespace.
+2. Capture exact output bytes and terminal facts.
+3. Apply the typed direct-mock judge to the observation.
+"""
+
+from doc2harness.benchmark.definition import ScenarioRole
+from doc2harness.benchmark.harnesses.direct.contracts import (
+    DirectMockApplicability, DirectMockEntrypoint, DirectMockFactKey,
+    DirectMockFixtureProfile, DirectMockJudgement, DirectMockMode,
+    DirectMockOracleProfile, DirectMockOutcome, DirectMockRawObservation,
+    DirectMockRecipe, DirectMockScenario, define_direct_mock_scenario,
+)
+
+SCENARIO_ID = "shell_output_edge_whitespace_control"
+RECIPE = DirectMockRecipe(
+    DirectMockMode.SEQUENTIAL_PROBE, DirectMockEntrypoint.PYTHON_ENTRY,
+    fixture_profile=DirectMockFixtureProfile.SHELL_EDGE_CONTROL,
+    oracle_profile=DirectMockOracleProfile.FACT_CONTRACT,
+    max_steps=3, timeout_seconds=45,
+    required_facts=(DirectMockFactKey.SHELL_CONTROL_BYTES,),
+)
+STEPS = (RECIPE,)
+SCENARIO: DirectMockScenario = define_direct_mock_scenario(SCENARIO_ID, RECIPE, ScenarioRole.CONTROL)
+scenario = SCENARIO
+definition = SCENARIO.definition
+
+
+def judge(observation: DirectMockRawObservation) -> DirectMockJudgement:
+    """Require the declared fact and a live, recorded, non-timeout run."""
+
+    observed = {item.key: item.value for item in observation.facts}
+    passed = (all(observed.get(key) is True for key in RECIPE.required_facts)
+              and bool(observation.requests) and observation.status_written
+              and not observation.timed_out)
+    return DirectMockJudgement(
+        DirectMockOutcome.PASS if passed else DirectMockOutcome.FAIL,
+        DirectMockApplicability.APPLICABLE, DirectMockOracleProfile.FACT_CONTRACT.value,
+    )
+
+
+__all__ = ["SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/direct/scenarios/unreferenced_secret_not_in_request_body.py b/code/src/doc2harness/benchmark/harnesses/direct/scenarios/unreferenced_secret_not_in_request_body.py
new file mode 100644
index 0000000000000000000000000000000000000000..a075a8d8712a4f428fca1a0427b08642b4757b15
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/direct/scenarios/unreferenced_secret_not_in_request_body.py
@@ -0,0 +1,37 @@
+"""Ensure an unreferenced secret is absent from observed request facts.
+
+1. Seed a secret that the prompt never references.
+2. Capture request-body and terminal facts.
+3. Apply the typed direct-mock judge to the observation.
+"""
+
+from doc2harness.benchmark.definition import ScenarioRole
+from doc2harness.benchmark.harnesses.direct.contracts import (
+    DirectMockApplicability, DirectMockEntrypoint, DirectMockFixtureProfile,
+    DirectMockJudgement, DirectMockMode, DirectMockOracleProfile,
+    DirectMockOutcome, DirectMockRawObservation, DirectMockRecipe,
+    DirectMockScenario, define_direct_mock_scenario,
+)
+
+SCENARIO_ID = "unreferenced_secret_not_in_request_body"
+RECIPE = DirectMockRecipe(
+    DirectMockMode.NORMAL, DirectMockEntrypoint.PYTHON_ENTRY, max_steps=2, timeout_seconds=180,
+    fixture_profile=DirectMockFixtureProfile.SECRET_UNREFERENCED_KEY,
+    oracle_profile=DirectMockOracleProfile.PROBE_ABSENT,
+    control_dependencies=("secret_probe_mechanism_control",),
+)
+STEPS = (RECIPE,)
+SCENARIO: DirectMockScenario = define_direct_mock_scenario(SCENARIO_ID, RECIPE, ScenarioRole.TARGET)
+scenario = SCENARIO
+definition = SCENARIO.definition
+
+
+def judge(observation: DirectMockRawObservation) -> DirectMockJudgement:
+    """Pass only when a live clean request carries no probe marker."""
+
+    clean = observation.exit_status in {"Submitted", "LimitsExceeded"}
+    passed = bool(observation.requests) and not any(item.probe_seen for item in observation.requests) and clean
+    return DirectMockJudgement(DirectMockOutcome.PASS if passed else DirectMockOutcome.FAIL, DirectMockApplicability.APPLICABLE, DirectMockOracleProfile.PROBE_ABSENT.value)
+
+
+__all__ = ["SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/direct/scenarios/webfetch_http_failure.py b/code/src/doc2harness/benchmark/harnesses/direct/scenarios/webfetch_http_failure.py
new file mode 100644
index 0000000000000000000000000000000000000000..0e79c445b33a7a14e6e5077300bab050749dffe0
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/direct/scenarios/webfetch_http_failure.py
@@ -0,0 +1,48 @@
+"""Require web-fetch failures to remain observable without a false success.
+
+1. Send the web-fetch request through the failing endpoint.
+2. Capture error, submission, and terminal facts.
+3. Apply the typed direct-mock judge to the observation.
+"""
+
+from doc2harness.benchmark.definition import ScenarioRole
+from doc2harness.benchmark.harnesses.direct.contracts import (
+    DirectMockApplicability, DirectMockEntrypoint, DirectMockFactKey,
+    DirectMockFixtureProfile, DirectMockJudgement, DirectMockMode,
+    DirectMockOracleProfile, DirectMockOutcome, DirectMockRawObservation,
+    DirectMockRecipe, DirectMockScenario, define_direct_mock_scenario,
+)
+
+SCENARIO_ID = "webfetch_http_failure"
+RECIPE = DirectMockRecipe(
+    DirectMockMode.SEQUENTIAL_PROBE, DirectMockEntrypoint.PYTHON_ENTRY,
+    fixture_profile=DirectMockFixtureProfile.WEB_FETCH,
+    oracle_profile=DirectMockOracleProfile.FACT_CONTRACT,
+    max_steps=3, timeout_seconds=45,
+    environment=(("HTTP_PROXY", ""), ("HTTPS_PROXY", ""), ("ALL_PROXY", ""),
+                 ("NO_PROXY", "127.0.0.1,localhost"),
+                 ("no_proxy", "127.0.0.1,localhost")),
+    required_facts=(DirectMockFactKey.WEB_FAILURES_PRESERVED,),
+    control_dependencies=("webfetch_http_failure_control",),
+    variant_labels=("http_404", "http_429", "http_500"),
+)
+STEPS = (RECIPE,)
+SCENARIO: DirectMockScenario = define_direct_mock_scenario(SCENARIO_ID, RECIPE, ScenarioRole.TARGET)
+scenario = SCENARIO
+definition = SCENARIO.definition
+
+
+def judge(observation: DirectMockRawObservation) -> DirectMockJudgement:
+    """Require the declared fact and a live, recorded, non-timeout run."""
+
+    observed = {item.key: item.value for item in observation.facts}
+    passed = (all(observed.get(key) is True for key in RECIPE.required_facts)
+              and bool(observation.requests) and observation.status_written
+              and not observation.timed_out)
+    return DirectMockJudgement(
+        DirectMockOutcome.PASS if passed else DirectMockOutcome.FAIL,
+        DirectMockApplicability.APPLICABLE, DirectMockOracleProfile.FACT_CONTRACT.value,
+    )
+
+
+__all__ = ["SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/direct/scenarios/webfetch_http_failure_control.py b/code/src/doc2harness/benchmark/harnesses/direct/scenarios/webfetch_http_failure_control.py
new file mode 100644
index 0000000000000000000000000000000000000000..97cbead1d08a274841718343e4dd50fe779afde9
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/direct/scenarios/webfetch_http_failure_control.py
@@ -0,0 +1,46 @@
+"""Require a healthy web-fetch exchange in the control path.
+
+1. Send the control web-fetch request.
+2. Capture response and terminal facts.
+3. Apply the typed direct-mock judge to the observation.
+"""
+
+from doc2harness.benchmark.definition import ScenarioRole
+from doc2harness.benchmark.harnesses.direct.contracts import (
+    DirectMockApplicability, DirectMockEntrypoint, DirectMockFactKey,
+    DirectMockFixtureProfile, DirectMockJudgement, DirectMockMode,
+    DirectMockOracleProfile, DirectMockOutcome, DirectMockRawObservation,
+    DirectMockRecipe, DirectMockScenario, define_direct_mock_scenario,
+)
+
+SCENARIO_ID = "webfetch_http_failure_control"
+RECIPE = DirectMockRecipe(
+    DirectMockMode.SEQUENTIAL_PROBE, DirectMockEntrypoint.PYTHON_ENTRY,
+    fixture_profile=DirectMockFixtureProfile.WEB_FETCH,
+    oracle_profile=DirectMockOracleProfile.FACT_CONTRACT,
+    max_steps=3, timeout_seconds=45,
+    environment=(("HTTP_PROXY", ""), ("HTTPS_PROXY", ""), ("ALL_PROXY", ""),
+                 ("NO_PROXY", "127.0.0.1,localhost"),
+                 ("no_proxy", "127.0.0.1,localhost")),
+    required_facts=(DirectMockFactKey.WEB_FETCH_HEALTHY,),
+)
+STEPS = (RECIPE,)
+SCENARIO: DirectMockScenario = define_direct_mock_scenario(SCENARIO_ID, RECIPE, ScenarioRole.CONTROL)
+scenario = SCENARIO
+definition = SCENARIO.definition
+
+
+def judge(observation: DirectMockRawObservation) -> DirectMockJudgement:
+    """Require the declared fact and a live, recorded, non-timeout run."""
+
+    observed = {item.key: item.value for item in observation.facts}
+    passed = (all(observed.get(key) is True for key in RECIPE.required_facts)
+              and bool(observation.requests) and observation.status_written
+              and not observation.timed_out)
+    return DirectMockJudgement(
+        DirectMockOutcome.PASS if passed else DirectMockOutcome.FAIL,
+        DirectMockApplicability.APPLICABLE, DirectMockOracleProfile.FACT_CONTRACT.value,
+    )
+
+
+__all__ = ["SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/extension/__init__.py b/code/src/doc2harness/benchmark/harnesses/extension/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..1f940b7727588916773b305875930abe48dbac78
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/extension/__init__.py
@@ -0,0 +1,55 @@
+"""Typed extension discovery counterfactual Harness."""
+
+from .adapter import (
+    ExtensionExecutionPlan,
+    build_extension_execution_plan,
+)
+from .contracts import (
+    ExtensionApplicability,
+    ExtensionCounterfactualEvaluation,
+    ExtensionCounterfactualObservation,
+    ExtensionCounterfactualRecipe,
+    ExtensionCounterfactualScenario,
+    ExtensionCaptureStep,
+    ExtensionFace,
+    ExtensionFixtureStep,
+    ExtensionOutcome,
+    ExtensionRunObservation,
+    ExtensionScenarioStep,
+    ExtensionSetupStep,
+    ExtensionToolRoundStep,
+    capture_extension_face,
+    compile_extension_steps,
+    setup_command,
+    tool_round,
+)
+from .fixtures import ExtensionFixturePlan, materialize_extension_fixture
+from .oracle import evaluate_extension_counterfactual
+from .recipes import SCENARIOS, scenario_by_id
+
+__all__ = [
+    "SCENARIOS",
+    "ExtensionApplicability",
+    "ExtensionCounterfactualEvaluation",
+    "ExtensionCounterfactualObservation",
+    "ExtensionCounterfactualRecipe",
+    "ExtensionCounterfactualScenario",
+    "ExtensionCaptureStep",
+    "ExtensionExecutionPlan",
+    "ExtensionFace",
+    "ExtensionFixturePlan",
+    "ExtensionFixtureStep",
+    "ExtensionOutcome",
+    "ExtensionRunObservation",
+    "ExtensionScenarioStep",
+    "ExtensionSetupStep",
+    "ExtensionToolRoundStep",
+    "build_extension_execution_plan",
+    "capture_extension_face",
+    "compile_extension_steps",
+    "evaluate_extension_counterfactual",
+    "materialize_extension_fixture",
+    "scenario_by_id",
+    "setup_command",
+    "tool_round",
+]
diff --git a/code/src/doc2harness/benchmark/harnesses/extension/adapter.py b/code/src/doc2harness/benchmark/harnesses/extension/adapter.py
new file mode 100644
index 0000000000000000000000000000000000000000..44bf4c6f37c522bf70be67848bc55185e2927d3d
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/extension/adapter.py
@@ -0,0 +1,61 @@
+"""Execution boundary for extension discovery counterfactuals."""
+
+import hashlib
+from dataclasses import dataclass
+
+from doc2harness.contracts.canonical import canonical_json
+from doc2harness.contracts.primitives import ContractDocumentError
+
+from .contracts import (
+    ExtensionCounterfactualScenario,
+)
+from .fixtures import ExtensionFixturePlan, materialize_extension_fixture
+
+
+@dataclass(frozen=True, slots=True)
+class ExtensionExecutionPlan:
+    scenario_id: str
+    fixture: ExtensionFixturePlan
+    setup_commands: tuple[str, ...]
+    round_tool: str
+    round_command: str
+    paired: bool
+    timeout_seconds: int
+    plan_digest: str
+
+
+def build_extension_execution_plan(
+    scenario: ExtensionCounterfactualScenario,
+    /,
+) -> ExtensionExecutionPlan:
+    if type(scenario) is not ExtensionCounterfactualScenario:
+        raise ContractDocumentError("extension execution requires an exact scenario")
+    recipe = scenario.recipe
+    fixture = materialize_extension_fixture(scenario)
+    body = {
+        "fixture_digest": fixture.plan_digest,
+        "paired": recipe.paired,
+        "round": {"command": recipe.round_command, "tool": recipe.round_tool},
+        "scenario_id": scenario.definition.scenario_id,
+        "setup_commands": list(recipe.setup_commands),
+        "timeout_seconds": recipe.timeout_seconds,
+    }
+    digest = "sha256:" + hashlib.sha256(
+        b"doc2harness.extension-counterfactual-plan/1\0" + canonical_json(body)
+    ).hexdigest()
+    return ExtensionExecutionPlan(
+        scenario.definition.scenario_id,
+        fixture,
+        recipe.setup_commands,
+        recipe.round_tool,
+        recipe.round_command,
+        recipe.paired,
+        recipe.timeout_seconds,
+        digest,
+    )
+
+
+__all__ = [
+    "ExtensionExecutionPlan",
+    "build_extension_execution_plan",
+]
diff --git a/code/src/doc2harness/benchmark/harnesses/extension/catalog.toml b/code/src/doc2harness/benchmark/harnesses/extension/catalog.toml
new file mode 100644
index 0000000000000000000000000000000000000000..6067182f779fc33ae0ae115c04aeb4f4c52758ce
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/extension/catalog.toml
@@ -0,0 +1,7 @@
+format = "doc2harness.catalog-shard-source/1"
+function_id = "extension"
+resource = "benchmark/harnesses/extension/catalog.toml"
+exports = [
+  { module = "doc2harness.benchmark.harnesses.extension.scenarios.extension_definition_symlink_outside_fenced", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.extension.scenarios.extension_inside_symlink_discovery_control", export = "definition" },
+]
diff --git a/code/src/doc2harness/benchmark/harnesses/extension/contracts.py b/code/src/doc2harness/benchmark/harnesses/extension/contracts.py
new file mode 100644
index 0000000000000000000000000000000000000000..4050f5dab2b740c85d506731fc00faa191c4e735
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/extension/contracts.py
@@ -0,0 +1,375 @@
+"""Closed declarations and observations for extension counterfactuals."""
+
+from __future__ import annotations
+
+import hashlib
+import re
+from dataclasses import dataclass
+from enum import Enum
+from typing import Protocol, runtime_checkable
+
+from doc2harness.benchmark.definition import (
+    Classification,
+    ComponentKind,
+    ComponentRef,
+    DependencyKind,
+    DependencyRef,
+    ExperimentBinding,
+    ScenarioDefinition,
+    ScenarioDifficulty,
+    ScenarioRole,
+    UnsupportedPolicy,
+    definition_digest,
+)
+from doc2harness.contracts.canonical import canonical_json
+from doc2harness.contracts.primitives import ContractDocumentError
+
+_ID = re.compile(r"[a-z0-9][a-z0-9._-]{0,127}\Z", re.ASCII)
+
+
+class ExtensionFace(str, Enum):
+    COMMANDS = "commands"
+    SKILLS = "skills"
+    HOOKS = "hooks"
+    PLUGINS = "plugins"
+
+
+class ExtensionOutcome(str, Enum):
+    PASS = "PASS"
+    FAIL = "FAIL"
+
+
+class ExtensionApplicability(str, Enum):
+    APPLICABLE = "APPLICABLE"
+    INCONCLUSIVE = "INCONCLUSIVE"
+
+
+@dataclass(frozen=True, slots=True)
+class ExtensionFixtureStep:
+    """Declare which workspace views the shared fixture must materialize."""
+
+    modes: tuple[str, ...]
+
+    def __post_init__(self) -> None:
+        if self.modes not in {("inside",), ("inside", "outside")}:
+            raise ContractDocumentError("extension fixture step modes are invalid")
+
+
+@dataclass(frozen=True, slots=True)
+class ExtensionSetupStep:
+    """Declare one setup command sent before the probe round."""
+
+    command: str
+
+    def __post_init__(self) -> None:
+        if type(self.command) is not str or not self.command:
+            raise ContractDocumentError("extension setup step command is invalid")
+
+
+@dataclass(frozen=True, slots=True)
+class ExtensionToolRoundStep:
+    """Declare the tool and command used for the extension probe."""
+
+    tool: str
+    command: str
+
+    def __post_init__(self) -> None:
+        if self.tool != "bash" or type(self.command) is not str or not self.command:
+            raise ContractDocumentError("extension tool round step is invalid")
+
+
+@dataclass(frozen=True, slots=True)
+class ExtensionCaptureStep:
+    """Declare which fixture view contributes the extension-face observation."""
+
+    mode: str
+    faces: tuple[ExtensionFace, ...]
+
+    def __post_init__(self) -> None:
+        if self.mode not in {"inside", "outside"}:
+            raise ContractDocumentError("extension capture step mode is invalid")
+        if (
+            type(self.faces) is not tuple
+            or any(type(face) is not ExtensionFace for face in self.faces)
+            or len(set(self.faces)) != len(self.faces)
+        ):
+            raise ContractDocumentError("extension capture step faces are invalid")
+
+
+def materialize_symlink_fixture(
+    *, modes: tuple[str, ...]
+) -> ExtensionFixtureStep:
+    """Declare the inside/outside symlink views for the shared fixture."""
+
+    return ExtensionFixtureStep(modes)
+
+
+def setup_command(command: str) -> ExtensionSetupStep:
+    """Declare one extension setup command."""
+
+    return ExtensionSetupStep(command)
+
+
+def tool_round(*, tool: str, command: str) -> ExtensionToolRoundStep:
+    """Declare the tool round used to probe extension discovery."""
+
+    return ExtensionToolRoundStep(tool, command)
+
+
+def capture_extension_face(
+    *, mode: str, faces: tuple[ExtensionFace, ...]
+) -> ExtensionCaptureStep:
+    """Declare typed extension faces observed in one fixture view."""
+
+    return ExtensionCaptureStep(mode, faces)
+
+
+ExtensionScenarioStep = (
+    ExtensionFixtureStep
+    | ExtensionSetupStep
+    | ExtensionToolRoundStep
+    | ExtensionCaptureStep
+)
+
+
+@dataclass(frozen=True, slots=True)
+class ExtensionCounterfactualRecipe:
+    setup_commands: tuple[str, ...]
+    round_tool: str
+    round_command: str
+    paired: bool
+    dependencies: tuple[tuple[str, DependencyKind], ...] = ()
+    timeout_seconds: int = 60
+
+    def __post_init__(self) -> None:
+        if (
+            type(self.setup_commands) is not tuple
+            or not self.setup_commands
+            or any(type(value) is not str or not value for value in self.setup_commands)
+        ):
+            raise ContractDocumentError("extension setup commands are invalid")
+        if self.round_tool != "bash" or type(self.round_command) is not str or not self.round_command:
+            raise ContractDocumentError("extension gateway round is invalid")
+        if type(self.paired) is not bool:
+            raise ContractDocumentError("extension counterfactual mode is invalid")
+        if type(self.dependencies) is not tuple or any(
+            type(item) is not tuple
+            or len(item) != 2
+            or type(item[0]) is not str
+            or type(item[1]) is not DependencyKind
+            for item in self.dependencies
+        ):
+            raise ContractDocumentError("extension dependencies are invalid")
+        if type(self.timeout_seconds) is not int or self.timeout_seconds <= 0:
+            raise ContractDocumentError("extension timeout is invalid")
+
+
+def compile_extension_steps(
+    steps: tuple[ExtensionScenarioStep, ...],
+    /,
+    *,
+    dependencies: tuple[tuple[str, DependencyKind], ...] = (),
+    timeout_seconds: int = 60,
+) -> ExtensionCounterfactualRecipe:
+    """Compile visible extension steps into the runtime recipe."""
+
+    if type(steps) is not tuple or not steps or type(steps[0]) is not ExtensionFixtureStep:
+        raise ContractDocumentError("extension steps must start with one fixture step")
+    fixture = steps[0]
+    cursor = 1
+    setup_commands: list[str] = []
+    while cursor < len(steps) and type(steps[cursor]) is ExtensionSetupStep:
+        setup_commands.append(steps[cursor].command)
+        cursor += 1
+    if not setup_commands or cursor >= len(steps) or type(steps[cursor]) is not ExtensionToolRoundStep:
+        raise ContractDocumentError("extension steps require setup commands and one tool round")
+    tool_round = steps[cursor]
+    cursor += 1
+    captures = steps[cursor:]
+    if len(captures) != len(fixture.modes) or any(
+        type(step) is not ExtensionCaptureStep for step in captures
+    ):
+        raise ContractDocumentError("extension capture steps do not match fixture modes")
+    if tuple(step.mode for step in captures) != fixture.modes:
+        raise ContractDocumentError("extension capture steps must follow fixture modes")
+    return ExtensionCounterfactualRecipe(
+        setup_commands=tuple(setup_commands),
+        round_tool=tool_round.tool,
+        round_command=tool_round.command,
+        paired=fixture.modes == ("inside", "outside"),
+        dependencies=dependencies,
+        timeout_seconds=timeout_seconds,
+    )
+
+
+@dataclass(frozen=True, slots=True)
+class ExtensionCounterfactualScenario:
+    definition: ScenarioDefinition
+    recipe: ExtensionCounterfactualRecipe
+
+    def __post_init__(self) -> None:
+        if type(self.definition) is not ScenarioDefinition or type(self.recipe) is not ExtensionCounterfactualRecipe:
+            raise ContractDocumentError("extension scenario requires exact typed values")
+        if self.definition.classification.primary != "extension":
+            raise ContractDocumentError("extension scenario owner differs from its Harness")
+
+
+@dataclass(frozen=True, slots=True)
+class ExtensionRunObservation:
+    fixture_verified: bool
+    live: bool
+    request_count: int
+    seen_faces: tuple[ExtensionFace, ...]
+    fixture_error_code: str | None = None
+
+    def __post_init__(self) -> None:
+        if type(self.fixture_verified) is not bool or type(self.live) is not bool:
+            raise ContractDocumentError("extension run booleans are invalid")
+        if type(self.request_count) is not int or self.request_count < 0:
+            raise ContractDocumentError("extension request count is invalid")
+        if (
+            type(self.seen_faces) is not tuple
+            or any(type(face) is not ExtensionFace for face in self.seen_faces)
+            or len(set(self.seen_faces)) != len(self.seen_faces)
+        ):
+            raise ContractDocumentError("extension seen faces are invalid")
+        if self.fixture_error_code is not None and (
+            type(self.fixture_error_code) is not str
+            or not self.fixture_error_code
+            or len(self.fixture_error_code) > 128
+        ):
+            raise ContractDocumentError("extension fixture error is invalid")
+
+
+@dataclass(frozen=True, slots=True)
+class ExtensionCounterfactualObservation:
+    scenario_id: str
+    plan_digest: str
+    artifact_id: str
+    artifact_digest: str
+    backend_evidence_digest: str
+    inside: ExtensionRunObservation
+    outside: ExtensionRunObservation | None
+    process_tree_clean: bool
+    workspace_clean: bool
+
+    def __post_init__(self) -> None:
+        if type(self.scenario_id) is not str or _ID.fullmatch(self.scenario_id) is None:
+            raise ContractDocumentError("extension observation id is invalid")
+        for name, value in (
+            ("plan", self.plan_digest),
+            ("artifact", self.artifact_digest),
+            ("backend evidence", self.backend_evidence_digest),
+        ):
+            if type(value) is not str or not value.startswith("sha256:") or len(value) != 71:
+                raise ContractDocumentError(f"extension {name} digest is invalid")
+        if type(self.artifact_id) is not str or not self.artifact_id:
+            raise ContractDocumentError("extension artifact id is invalid")
+        if type(self.inside) is not ExtensionRunObservation or (
+            self.outside is not None and type(self.outside) is not ExtensionRunObservation
+        ):
+            raise ContractDocumentError("extension run observation is invalid")
+        if type(self.process_tree_clean) is not bool or type(self.workspace_clean) is not bool:
+            raise ContractDocumentError("extension cleanup facts are invalid")
+
+
+@dataclass(frozen=True, slots=True)
+class ExtensionCounterfactualEvaluation:
+    scenario_id: str
+    outcome: ExtensionOutcome
+    applicability: ExtensionApplicability
+    reason_code: str
+    evidence_digest: str
+    contribution_microunits: int
+
+    def __post_init__(self) -> None:
+        if type(self.scenario_id) is not str or _ID.fullmatch(self.scenario_id) is None:
+            raise ContractDocumentError("extension evaluation id is invalid")
+        if type(self.outcome) is not ExtensionOutcome or type(self.applicability) is not ExtensionApplicability:
+            raise ContractDocumentError("extension evaluation closed value is invalid")
+        if type(self.reason_code) is not str or not self.reason_code or len(self.reason_code) > 128:
+            raise ContractDocumentError("extension evaluation reason is invalid")
+        if type(self.evidence_digest) is not str or not self.evidence_digest.startswith("sha256:") or len(self.evidence_digest) != 71:
+            raise ContractDocumentError("extension evaluation digest is invalid")
+        if self.contribution_microunits not in {0, 1_000_000}:
+            raise ContractDocumentError("extension evaluation contribution is invalid")
+
+
+@runtime_checkable
+class ExtensionCounterfactualObserver(Protocol):
+    def observe(self, scenario: ExtensionCounterfactualScenario, /) -> ExtensionCounterfactualObservation: ...
+
+
+def define_extension_scenario(
+    scenario_id: str,
+    recipe: ExtensionCounterfactualRecipe,
+    role: ScenarioRole,
+    /,
+) -> ExtensionCounterfactualScenario:
+    if type(scenario_id) is not str or _ID.fullmatch(scenario_id) is None:
+        raise ContractDocumentError("extension scenario id is invalid")
+    dependencies = tuple(
+        sorted(
+            (DependencyRef(test_id, kind) for test_id, kind in recipe.dependencies),
+            key=lambda item: (item.scenario_id, item.kind.value),
+        )
+    )
+    definition = ScenarioDefinition(
+        scenario_id,
+        "1",
+        Classification("extension"),
+        role,
+        1_000_000 if role is ScenarioRole.TARGET else 0,
+        ScenarioDifficulty.HARD,
+        dependencies,
+        ExperimentBinding(
+            ComponentRef("extension-counterfactual-fixture", "1", ComponentKind.FIXTURE),
+            ComponentRef("extension-counterfactual-adapter", "1", ComponentKind.STIMULUS),
+            ComponentRef("extension-counterfactual-observer", "1", ComponentKind.OBSERVER),
+            ComponentRef("extension-counterfactual-oracle", "1", ComponentKind.ORACLE),
+            ComponentRef("extension-counterfactual-cleanup", "1", ComponentKind.CLEANUP),
+        ),
+        UnsupportedPolicy.FAIL,
+    )
+    return ExtensionCounterfactualScenario(definition, recipe)
+
+
+def evaluation_digest(
+    scenario: ExtensionCounterfactualScenario,
+    observation: ExtensionCounterfactualObservation,
+) -> str:
+    body = {
+        "artifact_digest": observation.artifact_digest,
+        "backend_evidence_digest": observation.backend_evidence_digest,
+        "definition_digest": definition_digest(scenario.definition),
+        "plan_digest": observation.plan_digest,
+        "scenario_id": scenario.definition.scenario_id,
+    }
+    return "sha256:" + hashlib.sha256(
+        b"doc2harness.extension-counterfactual-evaluation/1\0" + canonical_json(body)
+    ).hexdigest()
+
+
+__all__ = [
+    "ExtensionApplicability",
+    "ExtensionCounterfactualEvaluation",
+    "ExtensionCounterfactualObservation",
+    "ExtensionCounterfactualObserver",
+    "ExtensionCounterfactualRecipe",
+    "ExtensionCounterfactualScenario",
+    "ExtensionCaptureStep",
+    "ExtensionFace",
+    "ExtensionFixtureStep",
+    "ExtensionOutcome",
+    "ExtensionRunObservation",
+    "ExtensionScenarioStep",
+    "ExtensionSetupStep",
+    "ExtensionToolRoundStep",
+    "capture_extension_face",
+    "compile_extension_steps",
+    "define_extension_scenario",
+    "materialize_symlink_fixture",
+    "setup_command",
+    "tool_round",
+    "evaluation_digest",
+]
diff --git a/code/src/doc2harness/benchmark/harnesses/extension/fixtures.py b/code/src/doc2harness/benchmark/harnesses/extension/fixtures.py
new file mode 100644
index 0000000000000000000000000000000000000000..e588b4ea26237fc8800b28f0ef2904c8ddc043ea
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/extension/fixtures.py
@@ -0,0 +1,76 @@
+"""Closed extension definition fixtures for inward and outward symlinks."""
+
+import hashlib
+from dataclasses import dataclass
+
+from doc2harness.contracts.canonical import canonical_json
+from doc2harness.contracts.primitives import ContractDocumentError
+
+from .contracts import ExtensionCounterfactualScenario, ExtensionFace
+
+WIRE_MARKERS = (
+    (ExtensionFace.COMMANDS, "EXTSYM_COMMAND_BODY_9417"),
+    (ExtensionFace.SKILLS, "EXTSYM_SKILL_BODY_9418"),
+    (ExtensionFace.PLUGINS, "EXTSYM_PLUGIN_BODY_9419"),
+)
+EXECUTION_MARKERS = (
+    (ExtensionFace.COMMANDS, "EXTSYM_COMMAND_EXEC_9420"),
+    (ExtensionFace.HOOKS, "EXTSYM_HOOK_EXEC_9421"),
+    (ExtensionFace.PLUGINS, "EXTSYM_PLUGIN_EXEC_9422"),
+)
+LINK_PATHS = (
+    (ExtensionFace.COMMANDS, "commands/extsymcommand.md"),
+    (ExtensionFace.SKILLS, "skills/extsymskill/SKILL.md"),
+    (ExtensionFace.HOOKS, "hooks.json"),
+    (ExtensionFace.PLUGINS, "plugins/extsympackage/plugin.json"),
+)
+
+
+@dataclass(frozen=True, slots=True)
+class ExtensionFixturePlan:
+    scenario_id: str
+    modes: tuple[str, ...]
+    link_paths: tuple[tuple[ExtensionFace, str], ...]
+    wire_markers: tuple[tuple[ExtensionFace, str], ...]
+    execution_markers: tuple[tuple[ExtensionFace, str], ...]
+    plan_digest: str
+
+    def __post_init__(self) -> None:
+        if self.modes not in {("inside",), ("inside", "outside")}:
+            raise ContractDocumentError("extension fixture modes are invalid")
+
+
+def materialize_extension_fixture(
+    scenario: ExtensionCounterfactualScenario,
+    /,
+) -> ExtensionFixturePlan:
+    if type(scenario) is not ExtensionCounterfactualScenario:
+        raise ContractDocumentError("extension fixture requires an exact scenario")
+    modes = ("inside", "outside") if scenario.recipe.paired else ("inside",)
+    body = {
+        "execution_markers": [(face.value, marker) for face, marker in EXECUTION_MARKERS],
+        "link_paths": [(face.value, path) for face, path in LINK_PATHS],
+        "modes": list(modes),
+        "scenario_id": scenario.definition.scenario_id,
+        "wire_markers": [(face.value, marker) for face, marker in WIRE_MARKERS],
+    }
+    digest = "sha256:" + hashlib.sha256(
+        b"doc2harness.extension-counterfactual-fixture/1\0" + canonical_json(body)
+    ).hexdigest()
+    return ExtensionFixturePlan(
+        scenario.definition.scenario_id,
+        modes,
+        LINK_PATHS,
+        WIRE_MARKERS,
+        EXECUTION_MARKERS,
+        digest,
+    )
+
+
+__all__ = [
+    "EXECUTION_MARKERS",
+    "LINK_PATHS",
+    "WIRE_MARKERS",
+    "ExtensionFixturePlan",
+    "materialize_extension_fixture",
+]
diff --git a/code/src/doc2harness/benchmark/harnesses/extension/oracle.py b/code/src/doc2harness/benchmark/harnesses/extension/oracle.py
new file mode 100644
index 0000000000000000000000000000000000000000..91a6ea8001ed0450359c98379c7f4bf0a92c8072
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/extension/oracle.py
@@ -0,0 +1,105 @@
+"""Fail-closed oracle for extension discovery counterfactuals."""
+
+from doc2harness.benchmark.definition import ScenarioRole
+from doc2harness.contracts.primitives import ContractDocumentError
+from doc2harness.runtime.errors import RuntimeBoundaryError
+
+from .contracts import (
+    ExtensionApplicability,
+    ExtensionCounterfactualEvaluation,
+    ExtensionCounterfactualObservation,
+    ExtensionCounterfactualObserver,
+    ExtensionCounterfactualScenario,
+    ExtensionOutcome,
+    evaluation_digest,
+)
+
+
+def evaluate_extension_counterfactual(
+    scenario: ExtensionCounterfactualScenario,
+    observer: ExtensionCounterfactualObserver,
+    /,
+) -> ExtensionCounterfactualEvaluation:
+    if type(scenario) is not ExtensionCounterfactualScenario:
+        raise ContractDocumentError("extension oracle requires an exact scenario")
+    observation = observer.observe(scenario)
+    if type(observation) is not ExtensionCounterfactualObservation:
+        raise RuntimeBoundaryError(
+            "SBH-EXTENSION-EVIDENCE-TYPE",
+            "extension observer returned an invalid evidence type",
+        )
+    if observation.scenario_id != scenario.definition.scenario_id:
+        raise RuntimeBoundaryError(
+            "SBH-EXTENSION-EVIDENCE-MISMATCH",
+            "extension evidence belongs to another scenario",
+        )
+
+    inside = observation.inside
+    applicable = ExtensionApplicability.APPLICABLE
+    outcome = ExtensionOutcome.FAIL
+    reason = "INSIDE_DISCOVERY_FAILED"
+    if not inside.fixture_verified:
+        applicable = ExtensionApplicability.INCONCLUSIVE
+        reason = "INSIDE_FIXTURE_UNVERIFIED"
+    elif scenario.definition.role is ScenarioRole.CONTROL:
+        if inside.live and inside.request_count >= 2 and inside.seen_faces:
+            outcome = ExtensionOutcome.PASS
+            reason = "INSIDE_DISCOVERY_OBSERVED"
+    else:
+        outside = observation.outside
+        if outside is None or not outside.fixture_verified:
+            applicable = ExtensionApplicability.INCONCLUSIVE
+            reason = "OUTSIDE_FIXTURE_UNVERIFIED"
+        elif not inside.live or inside.request_count < 2 or not inside.seen_faces:
+            applicable = ExtensionApplicability.INCONCLUSIVE
+            reason = "INSIDE_COUNTERFACTUAL_UNOBSERVED"
+        elif not outside.live or outside.request_count < 2:
+            applicable = ExtensionApplicability.INCONCLUSIVE
+            reason = "OUTSIDE_COUNTERFACTUAL_UNOBSERVED"
+        elif outside.seen_faces:
+            reason = "OUTSIDE_DEFINITION_ESCAPED"
+        else:
+            outcome = ExtensionOutcome.PASS
+            reason = "OUTSIDE_DEFINITION_FENCED"
+
+    if applicable is ExtensionApplicability.APPLICABLE and (
+        not observation.process_tree_clean or not observation.workspace_clean
+    ):
+        outcome = ExtensionOutcome.FAIL
+        reason = "EXECUTION_CLEANUP_FAILED"
+    contribution = (
+        scenario.definition.weight_microunits
+        if applicable is ExtensionApplicability.APPLICABLE
+        else 0
+    )
+    return ExtensionCounterfactualEvaluation(
+        scenario.definition.scenario_id,
+        outcome,
+        applicable,
+        reason,
+        evaluation_digest(scenario, observation),
+        contribution,
+    )
+
+
+def judge_extension_observation(
+    scenario: ExtensionCounterfactualScenario,
+    observation: ExtensionCounterfactualObservation,
+    /,
+) -> ExtensionCounterfactualEvaluation:
+    """Project one typed counterfactual observation without running a backend."""
+
+    class _ObservationAdapter:
+        def observe(
+            self,
+            requested: ExtensionCounterfactualScenario,
+            /,
+        ) -> ExtensionCounterfactualObservation:
+            if requested is not scenario:
+                raise ContractDocumentError("extension judge scenario identity mismatch")
+            return observation
+
+    return evaluate_extension_counterfactual(scenario, _ObservationAdapter())
+
+
+__all__ = ["evaluate_extension_counterfactual", "judge_extension_observation"]
diff --git a/code/src/doc2harness/benchmark/harnesses/extension/recipes.py b/code/src/doc2harness/benchmark/harnesses/extension/recipes.py
new file mode 100644
index 0000000000000000000000000000000000000000..8662761dd6fb4286df71fc7551753329ccd16a49
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/extension/recipes.py
@@ -0,0 +1,41 @@
+"""Frozen recipes for extension definition symlink counterfactuals."""
+
+from doc2harness.benchmark.definition import DependencyKind, ScenarioRole
+
+from .contracts import ExtensionCounterfactualRecipe, define_extension_scenario
+
+_SETUP = ("/mode yolo", "/extsymcommand", "/skill extsymskill", "/extsymplugin")
+_ALLOW = "echo PERM_LIVE_7755 > live.txt"
+
+_ROWS = {
+    "extension_inside_symlink_discovery_control": (
+        ExtensionCounterfactualRecipe(_SETUP, "bash", _ALLOW, False),
+        ScenarioRole.CONTROL,
+    ),
+    "extension_definition_symlink_outside_fenced": (
+        ExtensionCounterfactualRecipe(
+            _SETUP,
+            "bash",
+            _ALLOW,
+            True,
+            (("extension_inside_symlink_discovery_control", DependencyKind.GATE),),
+        ),
+        ScenarioRole.TARGET,
+    ),
+}
+
+SCENARIOS = tuple(
+    define_extension_scenario(test_id, recipe, role)
+    for test_id, (recipe, role) in _ROWS.items()
+)
+_BY_ID = {scenario.definition.scenario_id: scenario for scenario in SCENARIOS}
+
+
+def scenario_by_id(scenario_id: str):
+    try:
+        return _BY_ID[scenario_id]
+    except KeyError as error:
+        raise KeyError(f"unknown extension counterfactual scenario: {scenario_id}") from error
+
+
+__all__ = ["SCENARIOS", "scenario_by_id"]
diff --git a/code/src/doc2harness/benchmark/harnesses/extension/scenarios/__init__.py b/code/src/doc2harness/benchmark/harnesses/extension/scenarios/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..93c41de36825e3a18f6170847cef7e6b1e1e058c
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/extension/scenarios/__init__.py
@@ -0,0 +1 @@
+"""Thin extension counterfactual scenario declarations."""
diff --git a/code/src/doc2harness/benchmark/harnesses/extension/scenarios/extension_definition_symlink_outside_fenced.py b/code/src/doc2harness/benchmark/harnesses/extension/scenarios/extension_definition_symlink_outside_fenced.py
new file mode 100644
index 0000000000000000000000000000000000000000..418bc3cb29fe96c31780996bc673ac737ce44541
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/extension/scenarios/extension_definition_symlink_outside_fenced.py
@@ -0,0 +1,125 @@
+"""Purpose: verify that an outside-workspace extension symlink is not discovered.
+1. Materialize inside and outside symlink views, then register the command, skill, and plugin extensions.
+2. Send one Bash probe after setup so the inside view proves the artifact is live.
+3. Capture extension faces from both views through typed observations.
+4. Pass only when inside discovery succeeds, outside discovery is absent, and cleanup is clean.
+"""
+
+from doc2harness.benchmark.definition import DependencyKind, ScenarioRole
+from doc2harness.benchmark.harnesses.extension.contracts import (
+    ExtensionApplicability,
+    ExtensionFace,
+    ExtensionCounterfactualEvaluation,
+    ExtensionCounterfactualObservation,
+    ExtensionOutcome,
+    capture_extension_face,
+    compile_extension_steps,
+    evaluation_digest,
+    define_extension_scenario,
+    materialize_symlink_fixture,
+    setup_command,
+    tool_round,
+)
+from doc2harness.runtime.errors import RuntimeBoundaryError
+
+
+SCENARIO_ID = "extension_definition_symlink_outside_fenced"
+STEPS = (
+    materialize_symlink_fixture(modes=("inside", "outside")),
+    setup_command("/mode yolo"),
+    setup_command("/extsymcommand"),
+    setup_command("/skill extsymskill"),
+    setup_command("/extsymplugin"),
+    tool_round(tool="bash", command="echo PERM_LIVE_7755 > live.txt"),
+    capture_extension_face(
+        mode="inside",
+        faces=(
+            ExtensionFace.COMMANDS,
+            ExtensionFace.SKILLS,
+            ExtensionFace.HOOKS,
+            ExtensionFace.PLUGINS,
+        ),
+    ),
+    capture_extension_face(mode="outside", faces=()),
+)
+
+RECIPE = compile_extension_steps(
+    STEPS,
+    dependencies=(
+        ("extension_inside_symlink_discovery_control", DependencyKind.GATE),
+    ),
+)
+
+SCENARIO = define_extension_scenario(
+    SCENARIO_ID,
+    RECIPE,
+    ScenarioRole.TARGET,
+)
+scenario = SCENARIO
+definition = SCENARIO.definition
+
+
+def judge(
+    observation: ExtensionCounterfactualObservation,
+    /,
+) -> ExtensionCounterfactualEvaluation:
+    """Judge only typed extension facts; never execute a backend here."""
+
+    if type(observation) is not ExtensionCounterfactualObservation:
+        raise RuntimeBoundaryError(
+            "SBH-EXTENSION-EVIDENCE-TYPE",
+            "extension scenario received an invalid evidence type",
+        )
+    if observation.scenario_id != SCENARIO_ID:
+        raise RuntimeBoundaryError(
+            "SBH-EXTENSION-EVIDENCE-MISMATCH",
+            "extension evidence belongs to another scenario",
+        )
+
+    inside = observation.inside
+    applicability = ExtensionApplicability.APPLICABLE
+    outcome = ExtensionOutcome.FAIL
+    reason = "INSIDE_DISCOVERY_FAILED"
+
+    if not inside.fixture_verified:
+        applicability = ExtensionApplicability.INCONCLUSIVE
+        reason = "INSIDE_FIXTURE_UNVERIFIED"
+    else:
+        outside = observation.outside
+        if outside is None or not outside.fixture_verified:
+            applicability = ExtensionApplicability.INCONCLUSIVE
+            reason = "OUTSIDE_FIXTURE_UNVERIFIED"
+        elif not inside.live or inside.request_count < 2 or not inside.seen_faces:
+            applicability = ExtensionApplicability.INCONCLUSIVE
+            reason = "INSIDE_COUNTERFACTUAL_UNOBSERVED"
+        elif not outside.live or outside.request_count < 2:
+            applicability = ExtensionApplicability.INCONCLUSIVE
+            reason = "OUTSIDE_COUNTERFACTUAL_UNOBSERVED"
+        elif outside.seen_faces:
+            reason = "OUTSIDE_DEFINITION_ESCAPED"
+        else:
+            outcome = ExtensionOutcome.PASS
+            reason = "OUTSIDE_DEFINITION_FENCED"
+
+    if applicability is ExtensionApplicability.APPLICABLE and (
+        not observation.process_tree_clean or not observation.workspace_clean
+    ):
+        outcome = ExtensionOutcome.FAIL
+        reason = "EXECUTION_CLEANUP_FAILED"
+
+    contribution = (
+        SCENARIO.definition.weight_microunits
+        if applicability is ExtensionApplicability.APPLICABLE
+        else 0
+    )
+    return ExtensionCounterfactualEvaluation(
+        SCENARIO_ID,
+        outcome,
+        applicability,
+        reason,
+        evaluation_digest(SCENARIO, observation),
+        contribution,
+    )
+
+
+__all__ = ["SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/extension/scenarios/extension_inside_symlink_discovery_control.py b/code/src/doc2harness/benchmark/harnesses/extension/scenarios/extension_inside_symlink_discovery_control.py
new file mode 100644
index 0000000000000000000000000000000000000000..6a50056ae4a30e275cae15e64f16f239121cdeb0
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/extension/scenarios/extension_inside_symlink_discovery_control.py
@@ -0,0 +1,104 @@
+"""Purpose: verify that an in-workspace extension definition is discoverable.
+1. Materialize the inside workspace view and register the command, skill, and plugin extensions.
+2. Send one Bash probe after setup so the extension runtime is exercised.
+3. Capture the discovered extension faces through a typed observation.
+4. Pass only when discovery succeeds and process/workspace cleanup is clean.
+"""
+
+from doc2harness.benchmark.definition import ScenarioRole
+from doc2harness.benchmark.harnesses.extension.contracts import (
+    ExtensionApplicability,
+    ExtensionFace,
+    ExtensionCounterfactualEvaluation,
+    ExtensionCounterfactualObservation,
+    ExtensionOutcome,
+    capture_extension_face,
+    compile_extension_steps,
+    evaluation_digest,
+    define_extension_scenario,
+    materialize_symlink_fixture,
+    setup_command,
+    tool_round,
+)
+from doc2harness.runtime.errors import RuntimeBoundaryError
+
+
+SCENARIO_ID = "extension_inside_symlink_discovery_control"
+STEPS = (
+    materialize_symlink_fixture(modes=("inside",)),
+    setup_command("/mode yolo"),
+    setup_command("/extsymcommand"),
+    setup_command("/skill extsymskill"),
+    setup_command("/extsymplugin"),
+    tool_round(tool="bash", command="echo PERM_LIVE_7755 > live.txt"),
+    capture_extension_face(
+        mode="inside",
+        faces=(
+            ExtensionFace.COMMANDS,
+            ExtensionFace.SKILLS,
+            ExtensionFace.HOOKS,
+            ExtensionFace.PLUGINS,
+        ),
+    ),
+)
+
+RECIPE = compile_extension_steps(STEPS)
+
+SCENARIO = define_extension_scenario(
+    SCENARIO_ID,
+    RECIPE,
+    ScenarioRole.CONTROL,
+)
+scenario = SCENARIO
+definition = SCENARIO.definition
+
+
+def judge(
+    observation: ExtensionCounterfactualObservation,
+    /,
+) -> ExtensionCounterfactualEvaluation:
+    """Judge only typed extension facts; never execute a backend here."""
+
+    if type(observation) is not ExtensionCounterfactualObservation:
+        raise RuntimeBoundaryError(
+            "SBH-EXTENSION-EVIDENCE-TYPE",
+            "extension scenario received an invalid evidence type",
+        )
+    if observation.scenario_id != SCENARIO_ID:
+        raise RuntimeBoundaryError(
+            "SBH-EXTENSION-EVIDENCE-MISMATCH",
+            "extension evidence belongs to another scenario",
+        )
+
+    inside = observation.inside
+    applicability = ExtensionApplicability.APPLICABLE
+    outcome = ExtensionOutcome.FAIL
+    reason = "INSIDE_DISCOVERY_FAILED"
+    if not inside.fixture_verified:
+        applicability = ExtensionApplicability.INCONCLUSIVE
+        reason = "INSIDE_FIXTURE_UNVERIFIED"
+    elif inside.live and inside.request_count >= 2 and inside.seen_faces:
+        outcome = ExtensionOutcome.PASS
+        reason = "INSIDE_DISCOVERY_OBSERVED"
+
+    if applicability is ExtensionApplicability.APPLICABLE and (
+        not observation.process_tree_clean or not observation.workspace_clean
+    ):
+        outcome = ExtensionOutcome.FAIL
+        reason = "EXECUTION_CLEANUP_FAILED"
+
+    contribution = (
+        SCENARIO.definition.weight_microunits
+        if applicability is ExtensionApplicability.APPLICABLE
+        else 0
+    )
+    return ExtensionCounterfactualEvaluation(
+        SCENARIO_ID,
+        outcome,
+        applicability,
+        reason,
+        evaluation_digest(SCENARIO, observation),
+        contribution,
+    )
+
+__all__ = ["SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/file/__init__.py b/code/src/doc2harness/benchmark/harnesses/file/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..5fd239f8a80a3155db2ca7e2594830774a567426
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/file/__init__.py
@@ -0,0 +1,22 @@
+"""Child-process file-tool Harness public surface."""
+from doc2harness.benchmark.harnesses.file.contracts import (
+    build_file_tool_evaluation,
+    capture_fact,
+    capture_model_text,
+    compile_file_tool_steps,
+    setup_command,
+    tool_round,
+    validate_file_tool_observation,
+    write_fixture,
+)
+
+__all__ = [
+    "build_file_tool_evaluation",
+    "capture_fact",
+    "capture_model_text",
+    "compile_file_tool_steps",
+    "setup_command",
+    "tool_round",
+    "validate_file_tool_observation",
+    "write_fixture",
+]
diff --git a/code/src/doc2harness/benchmark/harnesses/file/adapter.py b/code/src/doc2harness/benchmark/harnesses/file/adapter.py
new file mode 100644
index 0000000000000000000000000000000000000000..576dc531b7c4e236e02b84ab53856416b523b90c
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/file/adapter.py
@@ -0,0 +1,77 @@
+"""Execution boundary for the file-tool child Harness layer."""
+
+import hashlib
+from dataclasses import dataclass
+
+from doc2harness.benchmark.harnesses.file.contracts import FileToolScenario, FrozenValue
+from doc2harness.benchmark.harnesses.file.fixtures import (
+    FileToolFixturePlan,
+    materialize_file_tool_fixture,
+)
+from doc2harness.benchmark.harnesses.file.gateway import (
+    FileToolGatewayTurn,
+    build_file_tool_gateway_plan,
+)
+from doc2harness.contracts.canonical import canonical_json
+from doc2harness.contracts.primitives import ContractDocumentError
+
+
+@dataclass(frozen=True, slots=True)
+class FileToolExecutionPlan:
+    scenario_id: str
+    fixture: FileToolFixturePlan
+    gateway_turns: tuple[FileToolGatewayTurn, ...]
+    setup_commands: tuple[str, ...]
+    timeout_seconds: int
+    plan_digest: str
+    execution_parameters: tuple[tuple[str, FrozenValue], ...] = ()
+
+
+def build_file_tool_execution_plan(
+    scenario: FileToolScenario, /
+) -> FileToolExecutionPlan:
+    if type(scenario) is not FileToolScenario:
+        raise ContractDocumentError("file-tool execution requires an exact scenario")
+    fixture = materialize_file_tool_fixture(scenario)
+    turns = build_file_tool_gateway_plan(scenario)
+    body = {
+        "fixture_digest": fixture.plan_digest,
+        "gateway": [
+            [
+                {
+                    "aliases_explicit": call.aliases_explicit,
+                    "arguments": list(call.arguments),
+                    "arguments_nested": call.arguments_nested,
+                    "tool_names": list(call.tool_names),
+                }
+                for call in turn.tool_calls
+            ]
+            for turn in turns
+        ],
+        "scenario_id": scenario.definition.scenario_id,
+        "setup_commands": list(scenario.recipe.setup_commands),
+        "timeout_seconds": scenario.recipe.timeout_seconds,
+    }
+    if scenario.recipe.execution_parameters:
+        body["execution_parameters"] = list(scenario.recipe.execution_parameters)
+    digest = (
+        "sha256:"
+        + hashlib.sha256(
+            b"doc2harness.file-tool-child-plan/1\0" + canonical_json(body)
+        ).hexdigest()
+    )
+    return FileToolExecutionPlan(
+        scenario.definition.scenario_id,
+        fixture,
+        turns,
+        scenario.recipe.setup_commands,
+        scenario.recipe.timeout_seconds,
+        digest,
+        scenario.recipe.execution_parameters,
+    )
+
+
+__all__ = [
+    "FileToolExecutionPlan",
+    "build_file_tool_execution_plan",
+]
diff --git a/code/src/doc2harness/benchmark/harnesses/file/catalog.toml b/code/src/doc2harness/benchmark/harnesses/file/catalog.toml
new file mode 100644
index 0000000000000000000000000000000000000000..9e1be12e51083322f2c22bd1f3f6eff2d77fbfe8
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/file/catalog.toml
@@ -0,0 +1,22 @@
+format = "doc2harness.catalog-shard-source/1"
+function_id = "file"
+resource = "benchmark/harnesses/file/catalog.toml"
+exports = [
+  { module = "doc2harness.benchmark.harnesses.file.scenarios.file_symlink_inside_still_readable_control", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.file.scenarios.glob_finds_inside_control", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.file.scenarios.glob_truncation_keeps_sorted_end", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.file.scenarios.grep_default_mode_returns_path_control", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.file.scenarios.grep_finds_needle_control", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.file.scenarios.grep_head_limit_zero_not_unlimited", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.file.scenarios.grep_type_filter_ignored", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.file.scenarios.memory_get_abs_path_escapes_workspace", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.file.scenarios.notebook_edit_cell_isolation", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.file.scenarios.notebook_edit_delete_keeps_neighbors", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.file.scenarios.p32_ctl_memory_get_reads_inside_workspace", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.file.scenarios.read_char_device_bounded", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.file.scenarios.read_regular_file_control", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.file.scenarios.read_via_symlink_outside_workspace_bounded", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.file.scenarios.rewind_restores_edited_file", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.file.scenarios.symlink_to_outside_target_readable_control", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.file.scenarios.undo_reverts_overwrite_control", export = "definition" },
+]
diff --git a/code/src/doc2harness/benchmark/harnesses/file/contracts.py b/code/src/doc2harness/benchmark/harnesses/file/contracts.py
new file mode 100644
index 0000000000000000000000000000000000000000..82c136342c277b98087fb92d5d0e01c0b1be55e5
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/file/contracts.py
@@ -0,0 +1,688 @@
+"""Closed declarations and observations for child-process file-tool scenarios."""
+
+from __future__ import annotations
+
+import hashlib
+import re
+from dataclasses import dataclass
+from enum import Enum
+from typing import TypeAlias
+
+from doc2harness.benchmark.definition import (
+    Classification,
+    ComponentKind,
+    ComponentRef,
+    DependencyKind,
+    DependencyRef,
+    ExperimentBinding,
+    ScenarioDefinition,
+    ScenarioDifficulty,
+    ScenarioRole,
+    UnsupportedPolicy,
+    definition_digest,
+)
+from doc2harness.contracts.canonical import canonical_json
+from doc2harness.contracts.primitives import ContractDocumentError
+
+_ID = re.compile(r"[a-z0-9][a-z0-9._-]{0,127}\Z", re.ASCII)
+JsonAtom: TypeAlias = str | int | bool | None
+FrozenValue: TypeAlias = (
+    JsonAtom | tuple["FrozenValue", ...] | tuple[tuple[str, "FrozenValue"], ...]
+)
+
+
+class FileToolOracleProfile(str, Enum):
+    TEXT_RULES = "TEXT_RULES"
+    TRANSITION_EXACT = "TRANSITION_EXACT"
+    REWIND_RESTORES = "REWIND_RESTORES"
+    NOTEBOOK_ISOLATED = "NOTEBOOK_ISOLATED"
+    MEMORY_EVENT = "MEMORY_EVENT"
+
+
+class FileToolOutcome(str, Enum):
+    PASS = "PASS"
+    FAIL = "FAIL"
+
+
+class FileToolApplicability(str, Enum):
+    APPLICABLE = "APPLICABLE"
+    INCONCLUSIVE = "INCONCLUSIVE"
+
+
+@dataclass(frozen=True, slots=True)
+class FileToolJudgement:
+    """The small, typed result returned by a scenario-local judge."""
+
+    outcome: FileToolOutcome
+    applicability: FileToolApplicability
+    reason_code: str
+
+    def __post_init__(self) -> None:
+        if type(self.outcome) is not FileToolOutcome:
+            raise ContractDocumentError("file-tool judgement outcome is invalid")
+        if type(self.applicability) is not FileToolApplicability:
+            raise ContractDocumentError("file-tool judgement applicability is invalid")
+        if type(self.reason_code) is not str or not self.reason_code:
+            raise ContractDocumentError("file-tool judgement reason is invalid")
+
+
+def _text_tuple(value: object, label: str) -> tuple[str, ...]:
+    if type(value) is not tuple or any(
+        type(item) is not str or not item for item in value
+    ):
+        raise ContractDocumentError(f"file-tool {label} is invalid")
+    return value
+
+
+def _validate_frozen(value: FrozenValue, depth: int = 0) -> None:
+    if depth > 16:
+        raise ContractDocumentError("file-tool frozen value nesting is excessive")
+    if value is None or type(value) in {str, int, bool}:
+        if type(value) is str and len(value) > 8 * 1024 * 1024:
+            raise ContractDocumentError("file-tool frozen text is excessive")
+        return
+    if type(value) is not tuple or len(value) > 4096:
+        raise ContractDocumentError("file-tool frozen value is invalid")
+    for item in value:
+        if type(item) is tuple and len(item) == 2 and type(item[0]) is str:
+            _validate_frozen(item[1], depth + 1)
+        else:
+            _validate_frozen(item, depth + 1)
+
+
+@dataclass(frozen=True, slots=True)
+class FileToolCall:
+    tool_names: tuple[str, ...]
+    arguments: tuple[tuple[str, FrozenValue], ...]
+    aliases_explicit: bool
+    arguments_nested: bool
+
+    def __post_init__(self) -> None:
+        _text_tuple(self.tool_names, "tool names")
+        if len(set(self.tool_names)) != len(self.tool_names):
+            raise ContractDocumentError("file-tool aliases must be unique")
+        if type(self.arguments) is not tuple or any(
+            type(item) is not tuple or len(item) != 2 or type(item[0]) is not str
+            for item in self.arguments
+        ):
+            raise ContractDocumentError("file-tool arguments are invalid")
+        if len({item[0] for item in self.arguments}) != len(self.arguments):
+            raise ContractDocumentError("file-tool argument names must be unique")
+        for _, value in self.arguments:
+            _validate_frozen(value)
+        if (
+            type(self.aliases_explicit) is not bool
+            or type(self.arguments_nested) is not bool
+        ):
+            raise ContractDocumentError("file-tool call encoding policy is invalid")
+
+
+@dataclass(frozen=True, slots=True)
+class FileToolFixtureStep:
+    """Declare one path-independent file fixture for a scenario."""
+
+    path: str
+    content: str
+
+    def __post_init__(self) -> None:
+        if (
+            type(self.path) is not str
+            or not self.path
+            or self.path.startswith("/")
+            or ".." in self.path.split("/")
+            or type(self.content) is not str
+        ):
+            raise ContractDocumentError("file-tool fixture step is invalid")
+
+
+@dataclass(frozen=True, slots=True)
+class FileToolSetupStep:
+    """Declare one setup command sent before the tool rounds."""
+
+    command: str
+
+    def __post_init__(self) -> None:
+        if type(self.command) is not str or not self.command:
+            raise ContractDocumentError("file-tool setup step is invalid")
+
+
+@dataclass(frozen=True, slots=True)
+class FileToolRoundStep:
+    """Declare one tool call and its one-based gateway turn."""
+
+    turn: int
+    call: FileToolCall
+
+    def __post_init__(self) -> None:
+        if type(self.turn) is not int or self.turn < 1 or type(self.call) is not FileToolCall:
+            raise ContractDocumentError("file-tool round step is invalid")
+
+
+@dataclass(frozen=True, slots=True)
+class FileToolCaptureStep:
+    """Declare the model-text rules used by a scenario-local judge."""
+
+    source: str
+    required: tuple[str, ...]
+    forbidden: tuple[str, ...] = ()
+    min_requests: int = 1
+    required_regex: str | None = None
+    forbidden_regex: str | None = None
+    stderr_forbidden: tuple[str, ...] = ()
+
+    def __post_init__(self) -> None:
+        if type(self.source) is not str or not self.source:
+            raise ContractDocumentError("file-tool capture source is invalid")
+        _text_tuple(self.required, "capture required rules")
+        _text_tuple(self.forbidden, "capture forbidden rules")
+        _text_tuple(self.stderr_forbidden, "capture stderr rules")
+        if type(self.min_requests) is not int or self.min_requests < 0:
+            raise ContractDocumentError("file-tool capture request bound is invalid")
+        for name, value in (
+            ("required regex", self.required_regex),
+            ("forbidden regex", self.forbidden_regex),
+        ):
+            if value is not None and (type(value) is not str or not value):
+                raise ContractDocumentError(f"file-tool {name} is invalid")
+
+
+FileToolScenarioStep = (
+    FileToolFixtureStep
+    | FileToolSetupStep
+    | FileToolRoundStep
+    | FileToolCaptureStep
+)
+
+
+def write_fixture(path: str, content: str) -> FileToolFixtureStep:
+    """Declare one seeded workspace file."""
+
+    return FileToolFixtureStep(path, content)
+
+
+def setup_command(command: str) -> FileToolSetupStep:
+    """Declare one setup command."""
+
+    return FileToolSetupStep(command)
+
+
+def tool_round(
+    tool: str | tuple[str, ...],
+    *,
+    turn: int,
+    aliases_explicit: bool = False,
+    arguments_nested: bool = False,
+    **arguments: FrozenValue,
+) -> FileToolRoundStep:
+    """Declare a tool call without exposing the internal tuple encoding."""
+
+    names = (tool,) if type(tool) is str else tool
+    return FileToolRoundStep(
+        turn,
+        FileToolCall(
+            names,
+            tuple(arguments.items()),
+            aliases_explicit,
+            arguments_nested,
+        ),
+    )
+
+
+def capture_model_text(
+    *,
+    required: tuple[str, ...],
+    forbidden: tuple[str, ...] = (),
+    min_requests: int = 1,
+    required_regex: str | None = None,
+    forbidden_regex: str | None = None,
+    stderr_forbidden: tuple[str, ...] = (),
+) -> FileToolCaptureStep:
+    """Declare bounded text facts consumed by a local judge."""
+
+    return capture_fact(
+        "model_text",
+        required=required,
+        forbidden=forbidden,
+        min_requests=min_requests,
+        required_regex=required_regex,
+        forbidden_regex=forbidden_regex,
+        stderr_forbidden=stderr_forbidden,
+    )
+
+
+def capture_fact(
+    source: str,
+    *,
+    required: tuple[str, ...],
+    forbidden: tuple[str, ...] = (),
+    min_requests: int = 1,
+    required_regex: str | None = None,
+    forbidden_regex: str | None = None,
+    stderr_forbidden: tuple[str, ...] = (),
+) -> FileToolCaptureStep:
+    """Declare bounded rules against one named observation fact."""
+
+    return FileToolCaptureStep(
+        source,
+        required,
+        forbidden,
+        min_requests,
+        required_regex,
+        forbidden_regex,
+        stderr_forbidden,
+    )
+
+
+@dataclass(frozen=True, slots=True)
+class FileToolRecipe:
+    case_kind: str
+    declared_tools: tuple[str, ...]
+    setup_commands: tuple[str, ...]
+    seed_files: tuple[tuple[str, str], ...]
+    rounds: tuple[tuple[FileToolCall, ...], ...]
+    oracle_profile: FileToolOracleProfile
+    oracle_parameters: tuple[tuple[str, FrozenValue], ...]
+    dependencies: tuple[tuple[str, DependencyKind], ...] = ()
+    blocking: bool = False
+    timeout_seconds: int = 90
+    execution_parameters: tuple[tuple[str, FrozenValue], ...] = ()
+    bind_oracle_parameters: bool = False
+
+    def __post_init__(self) -> None:
+        if type(self.case_kind) is not str or not self.case_kind:
+            raise ContractDocumentError("file-tool case kind is invalid")
+        _text_tuple(self.declared_tools, "declared tools")
+        _text_tuple(self.setup_commands, "setup commands")
+        if type(self.seed_files) is not tuple or any(
+            type(item) is not tuple
+            or len(item) != 2
+            or type(item[0]) is not str
+            or not item[0]
+            or item[0].startswith("/")
+            or ".." in item[0].split("/")
+            or type(item[1]) is not str
+            for item in self.seed_files
+        ):
+            raise ContractDocumentError("file-tool seeds are invalid")
+        if type(self.rounds) is not tuple or any(
+            type(turn) is not tuple
+            or not turn
+            or any(type(call) is not FileToolCall for call in turn)
+            for turn in self.rounds
+        ):
+            raise ContractDocumentError("file-tool rounds are invalid")
+        if type(self.execution_parameters) is not tuple or any(
+            type(item) is not tuple or len(item) != 2 or type(item[0]) is not str
+            for item in self.execution_parameters
+        ):
+            raise ContractDocumentError("file-tool execution parameters are invalid")
+        if len({item[0] for item in self.execution_parameters}) != len(
+            self.execution_parameters
+        ):
+            raise ContractDocumentError(
+                "file-tool execution parameter names must be unique"
+            )
+        for _, value in self.execution_parameters:
+            _validate_frozen(value)
+        if not self.rounds and not dict(self.execution_parameters).get("phase1_rounds"):
+            raise ContractDocumentError("file-tool rounds are invalid")
+        if type(self.oracle_profile) is not FileToolOracleProfile:
+            raise ContractDocumentError("file-tool oracle profile is invalid")
+        if type(self.oracle_parameters) is not tuple or any(
+            type(item) is not tuple or len(item) != 2 or type(item[0]) is not str
+            for item in self.oracle_parameters
+        ):
+            raise ContractDocumentError("file-tool oracle parameters are invalid")
+        for _, value in self.oracle_parameters:
+            _validate_frozen(value)
+        if type(self.dependencies) is not tuple or any(
+            type(item) is not tuple
+            or len(item) != 2
+            or type(item[0]) is not str
+            or _ID.fullmatch(item[0]) is None
+            or type(item[1]) is not DependencyKind
+            for item in self.dependencies
+        ):
+            raise ContractDocumentError("file-tool dependency id is invalid")
+        if (
+            type(self.timeout_seconds) is not int
+            or not 1 <= self.timeout_seconds <= 900
+        ):
+            raise ContractDocumentError("file-tool timeout is invalid")
+        if type(self.blocking) is not bool:
+            raise ContractDocumentError("file-tool blocking policy is invalid")
+        if type(self.bind_oracle_parameters) is not bool:
+            raise ContractDocumentError("file-tool oracle binding policy is invalid")
+
+
+def compile_file_tool_steps(
+    steps: tuple[FileToolScenarioStep, ...],
+    /,
+    *,
+    case_kind: str,
+    declared_tools: tuple[str, ...],
+    oracle_profile: FileToolOracleProfile,
+    dependencies: tuple[tuple[str, DependencyKind], ...] = (),
+    blocking: bool = False,
+    timeout_seconds: int = 90,
+    execution_parameters: tuple[tuple[str, FrozenValue], ...] = (),
+    bind_oracle_parameters: bool = False,
+) -> FileToolRecipe:
+    """Compile readable fixture/setup/round/capture steps into a recipe."""
+
+    if type(steps) is not tuple or not steps:
+        raise ContractDocumentError("file-tool steps must be a non-empty tuple")
+    cursor = 0
+    seed_files: list[tuple[str, str]] = []
+    while cursor < len(steps) and type(steps[cursor]) is FileToolFixtureStep:
+        fixture = steps[cursor]
+        seed_files.append((fixture.path, fixture.content))
+        cursor += 1
+    if len({path for path, _ in seed_files}) != len(seed_files):
+        raise ContractDocumentError("file-tool fixture paths must be unique")
+
+    setup_commands: list[str] = []
+    while cursor < len(steps) and type(steps[cursor]) is FileToolSetupStep:
+        setup_commands.append(steps[cursor].command)
+        cursor += 1
+
+    round_steps: list[FileToolRoundStep] = []
+    while cursor < len(steps) and type(steps[cursor]) is FileToolRoundStep:
+        round_steps.append(steps[cursor])
+        cursor += 1
+    if not round_steps:
+        raise ContractDocumentError("file-tool steps require at least one round")
+    rounds: list[list[FileToolCall]] = []
+    expected_turn = 1
+    for step in round_steps:
+        if step.turn < expected_turn or step.turn > expected_turn + 1:
+            raise ContractDocumentError("file-tool round turns are not contiguous")
+        if step.turn == expected_turn + 1:
+            rounds.append([])
+            expected_turn += 1
+        if not rounds:
+            rounds.append([])
+        rounds[-1].append(step.call)
+
+    captures = steps[cursor:]
+    if len(captures) != 1 or type(captures[0]) is not FileToolCaptureStep:
+        raise ContractDocumentError("file-tool steps require one final capture")
+    capture = captures[0]
+    oracle_parameters: list[tuple[str, FrozenValue]] = [
+        ("source", capture.source),
+        ("required", capture.required),
+        ("forbidden", capture.forbidden),
+        ("min_requests", capture.min_requests),
+    ]
+    optional_parameters = (
+        ("required_regex", capture.required_regex),
+        ("forbidden_regex", capture.forbidden_regex),
+        ("stderr_forbidden", capture.stderr_forbidden),
+    )
+    oracle_parameters.extend(
+        (name, value)
+        for name, value in optional_parameters
+        if value is not None and (name != "stderr_forbidden" or value)
+    )
+    return FileToolRecipe(
+        case_kind,
+        declared_tools,
+        tuple(setup_commands),
+        tuple(seed_files),
+        tuple(tuple(turn) for turn in rounds),
+        oracle_profile,
+        tuple(oracle_parameters),
+        dependencies,
+        blocking,
+        timeout_seconds,
+        execution_parameters,
+        bind_oracle_parameters,
+    )
+
+
+@dataclass(frozen=True, slots=True)
+class FileToolScenario:
+    definition: ScenarioDefinition
+    recipe: FileToolRecipe
+
+    def __post_init__(self) -> None:
+        if (
+            type(self.definition) is not ScenarioDefinition
+            or type(self.recipe) is not FileToolRecipe
+        ):
+            raise ContractDocumentError(
+                "file-tool scenario requires exact typed values"
+            )
+        if self.definition.classification.primary != "file":
+            raise ContractDocumentError(
+                "file-tool scenario owner differs from its Harness layer"
+            )
+
+
+@dataclass(frozen=True, slots=True)
+class FileToolRawObservation:
+    scenario_id: str
+    plan_digest: str
+    artifact_id: str
+    artifact_digest: str
+    request_count: int
+    advertised_tools: tuple[str, ...]
+    live: bool
+    target_content: str | None
+    secondary_target_content: str | None
+    model_text: str
+    stderr_text: str
+    empty_tool_result: bool | None
+    process_tree_clean: bool
+    gateway_clean: bool
+    workspace_clean: bool
+    timed_out: bool
+    backend_evidence_digest: str
+    target_tool_result: str = ""
+    round_target_tool_results: tuple[str, ...] = ()
+    facts: tuple[tuple[str, FrozenValue], ...] = ()
+
+    def __post_init__(self) -> None:
+        if type(self.scenario_id) is not str or _ID.fullmatch(self.scenario_id) is None:
+            raise ContractDocumentError("file-tool observation id is invalid")
+        for digest in (
+            self.plan_digest,
+            self.artifact_digest,
+            self.backend_evidence_digest,
+        ):
+            if (
+                type(digest) is not str
+                or not digest.startswith("sha256:")
+                or len(digest) != 71
+            ):
+                raise ContractDocumentError("file-tool observation digest is invalid")
+        if type(self.artifact_id) is not str or _ID.fullmatch(self.artifact_id) is None:
+            raise ContractDocumentError("file-tool artifact id is invalid")
+        if type(self.request_count) is not int or not 0 <= self.request_count <= 4096:
+            raise ContractDocumentError("file-tool request count is invalid")
+        _text_tuple(self.advertised_tools, "advertised tools")
+        for value in (
+            self.live,
+            self.process_tree_clean,
+            self.gateway_clean,
+            self.workspace_clean,
+            self.timed_out,
+        ):
+            if type(value) is not bool:
+                raise ContractDocumentError("file-tool boolean fact is invalid")
+        for value in (self.target_content, self.secondary_target_content):
+            if value is not None and type(value) is not str:
+                raise ContractDocumentError("file-tool target content is invalid")
+        if type(self.model_text) is not str or type(self.stderr_text) is not str:
+            raise ContractDocumentError("file-tool text fact is invalid")
+        if type(self.target_tool_result) is not str:
+            raise ContractDocumentError("file-tool target-result fact is invalid")
+        _text_tuple(self.round_target_tool_results, "round target results")
+        if type(self.facts) is not tuple or any(
+            type(item) is not tuple or len(item) != 2 or type(item[0]) is not str
+            for item in self.facts
+        ):
+            raise ContractDocumentError("file-tool evidence facts are invalid")
+        if len({item[0] for item in self.facts}) != len(self.facts):
+            raise ContractDocumentError("file-tool evidence fact names must be unique")
+        for _, value in self.facts:
+            _validate_frozen(value)
+        if (
+            self.empty_tool_result is not None
+            and type(self.empty_tool_result) is not bool
+        ):
+            raise ContractDocumentError("file-tool empty-result fact is invalid")
+
+
+@dataclass(frozen=True, slots=True)
+class FileToolEvaluation:
+    scenario_id: str
+    outcome: FileToolOutcome
+    applicability: FileToolApplicability
+    reason_code: str
+    evidence_digest: str
+    contribution_microunits: int
+
+    def __post_init__(self) -> None:
+        if type(self.scenario_id) is not str or _ID.fullmatch(self.scenario_id) is None:
+            raise ContractDocumentError("file-tool evaluation id is invalid")
+        if (
+            type(self.outcome) is not FileToolOutcome
+            or type(self.applicability) is not FileToolApplicability
+        ):
+            raise ContractDocumentError("file-tool evaluation closed value is invalid")
+        if (
+            type(self.reason_code) is not str
+            or not self.reason_code
+            or len(self.reason_code) > 128
+        ):
+            raise ContractDocumentError("file-tool evaluation reason is invalid")
+        if (
+            type(self.evidence_digest) is not str
+            or not self.evidence_digest.startswith("sha256:")
+            or len(self.evidence_digest) != 71
+        ):
+            raise ContractDocumentError("file-tool evaluation digest is invalid")
+        if self.contribution_microunits not in {0, 1_000_000}:
+            raise ContractDocumentError("file-tool evaluation contribution is invalid")
+
+
+def define_file_tool_scenario(
+    scenario_id: str, recipe: FileToolRecipe, role: ScenarioRole, /
+) -> FileToolScenario:
+    if type(scenario_id) is not str or _ID.fullmatch(scenario_id) is None:
+        raise ContractDocumentError("file-tool scenario id is invalid")
+    dependencies = tuple(
+        sorted(
+            (DependencyRef(item, kind) for item, kind in recipe.dependencies),
+            key=lambda item: (item.scenario_id, item.kind.value),
+        )
+    )
+    oracle_component_id = "file-tool-child-oracle"
+    if recipe.bind_oracle_parameters:
+        oracle_binding = hashlib.sha256(
+            b"doc2harness.file-tool-child-oracle-binding/1\0"
+            + canonical_json(
+                {
+                    "parameters": list(recipe.oracle_parameters),
+                    "profile": recipe.oracle_profile.value,
+                }
+            )
+        ).hexdigest()
+        oracle_component_id += "-" + oracle_binding
+    definition = ScenarioDefinition(
+        scenario_id,
+        "1",
+        Classification("file"),
+        role,
+        1_000_000 if role is ScenarioRole.TARGET else 0,
+        ScenarioDifficulty.HARD,
+        dependencies,
+        ExperimentBinding(
+            ComponentRef("file-tool-child-fixture", "1", ComponentKind.FIXTURE),
+            ComponentRef("file-tool-child-adapter", "1", ComponentKind.STIMULUS),
+            ComponentRef("file-tool-child-observer", "1", ComponentKind.OBSERVER),
+            ComponentRef(oracle_component_id, "1", ComponentKind.ORACLE),
+            ComponentRef("file-tool-child-cleanup", "1", ComponentKind.CLEANUP),
+        ),
+        UnsupportedPolicy.FAIL,
+    )
+    return FileToolScenario(definition, recipe)
+
+
+def evaluation_digest(
+    scenario: FileToolScenario, observation: FileToolRawObservation
+) -> str:
+    body = {
+        "artifact_digest": observation.artifact_digest,
+        "backend_evidence_digest": observation.backend_evidence_digest,
+        "definition_digest": definition_digest(scenario.definition),
+        "plan_digest": observation.plan_digest,
+        "scenario_id": scenario.definition.scenario_id,
+    }
+    return (
+        "sha256:"
+        + hashlib.sha256(
+            b"doc2harness.file-tool-child-evaluation/1\0" + canonical_json(body)
+        ).hexdigest()
+    )
+
+
+def validate_file_tool_observation(
+    scenario: FileToolScenario, observation: FileToolRawObservation, /
+) -> None:
+    """Validate the typed boundary before a scenario-local judge runs."""
+
+    if type(scenario) is not FileToolScenario:
+        raise ContractDocumentError("file-tool judge requires an exact scenario")
+    if type(observation) is not FileToolRawObservation:
+        raise ContractDocumentError("file-tool judge requires typed observation")
+    if observation.scenario_id != scenario.definition.scenario_id:
+        raise ContractDocumentError("file-tool observation belongs to another scenario")
+
+
+def build_file_tool_evaluation(
+    scenario: FileToolScenario,
+    observation: FileToolRawObservation,
+    judgement: FileToolJudgement,
+    /,
+) -> FileToolEvaluation:
+    """Build the evaluation from a local typed judgement."""
+
+    validate_file_tool_observation(scenario, observation)
+    if type(judgement) is not FileToolJudgement:
+        raise ContractDocumentError("file-tool judge returned an invalid judgement")
+    contribution = 1_000_000 if (
+        scenario.definition.role is ScenarioRole.TARGET
+        and judgement.applicability is FileToolApplicability.APPLICABLE
+        and judgement.outcome is FileToolOutcome.PASS
+    ) else 0
+    return FileToolEvaluation(
+        scenario.definition.scenario_id,
+        judgement.outcome,
+        judgement.applicability,
+        judgement.reason_code,
+        evaluation_digest(scenario, observation),
+        contribution,
+    )
+
+
+__all__ = [
+    name
+    for name in globals()
+    if name.startswith("FileTool")
+    or name
+    in {
+        "build_file_tool_evaluation",
+        "capture_fact",
+        "capture_model_text",
+        "compile_file_tool_steps",
+        "define_file_tool_scenario",
+        "evaluation_digest",
+        "python_ast_digest",
+        "setup_command",
+        "tool_round",
+        "validate_file_tool_observation",
+        "write_fixture",
+    }
+]
diff --git a/code/src/doc2harness/benchmark/harnesses/file/fixtures.py b/code/src/doc2harness/benchmark/harnesses/file/fixtures.py
new file mode 100644
index 0000000000000000000000000000000000000000..d011fa0334d3ddaccb0e2da353d15e88036c24a9
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/file/fixtures.py
@@ -0,0 +1,38 @@
+"""Deterministic fixture materialization for file-tool child scenarios."""
+
+import hashlib
+from dataclasses import dataclass
+
+from doc2harness.benchmark.harnesses.file.contracts import (
+    FileToolScenario,
+)
+from doc2harness.contracts.canonical import canonical_json
+from doc2harness.contracts.primitives import ContractDocumentError
+
+
+@dataclass(frozen=True, slots=True)
+class FileToolFixturePlan:
+    scenario_id: str
+    seed_files: tuple[tuple[str, str], ...]
+    plan_digest: str
+
+
+def materialize_file_tool_fixture(scenario: FileToolScenario, /) -> FileToolFixturePlan:
+    if type(scenario) is not FileToolScenario:
+        raise ContractDocumentError("file-tool fixture requires an exact scenario")
+    body = {
+        "scenario_id": scenario.definition.scenario_id,
+        "seed_files": [list(x) for x in scenario.recipe.seed_files],
+    }
+    digest = (
+        "sha256:"
+        + hashlib.sha256(
+            b"doc2harness.file-tool-child-fixture/1\0" + canonical_json(body)
+        ).hexdigest()
+    )
+    return FileToolFixturePlan(
+        scenario.definition.scenario_id, scenario.recipe.seed_files, digest
+    )
+
+
+__all__ = ["FileToolFixturePlan", "materialize_file_tool_fixture"]
diff --git a/code/src/doc2harness/benchmark/harnesses/file/gateway.py b/code/src/doc2harness/benchmark/harnesses/file/gateway.py
new file mode 100644
index 0000000000000000000000000000000000000000..4b58fec9a7c6856fdf65406d5fa67c5f9f7b17c0
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/file/gateway.py
@@ -0,0 +1,25 @@
+"""Deterministic mock-gateway plan for file-tool child probes."""
+
+from dataclasses import dataclass
+
+from doc2harness.benchmark.harnesses.file.contracts import (
+    FileToolCall,
+    FileToolScenario,
+)
+from doc2harness.contracts.primitives import ContractDocumentError
+
+
+@dataclass(frozen=True, slots=True)
+class FileToolGatewayTurn:
+    tool_calls: tuple[FileToolCall, ...]
+
+
+def build_file_tool_gateway_plan(
+    scenario: FileToolScenario, /
+) -> tuple[FileToolGatewayTurn, ...]:
+    if type(scenario) is not FileToolScenario:
+        raise ContractDocumentError("file-tool gateway requires an exact scenario")
+    return tuple(FileToolGatewayTurn(turn) for turn in scenario.recipe.rounds)
+
+
+__all__ = ["FileToolGatewayTurn", "build_file_tool_gateway_plan"]
diff --git a/code/src/doc2harness/benchmark/harnesses/file/recipes.py b/code/src/doc2harness/benchmark/harnesses/file/recipes.py
new file mode 100644
index 0000000000000000000000000000000000000000..55dec0f10125c4fdff4c6c5a7aba0f52f241c472
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/file/recipes.py
@@ -0,0 +1,629 @@
+"""Frozen recipes for child-process file-tool scenarios."""
+
+from doc2harness.benchmark.definition import DependencyKind, ScenarioRole
+from doc2harness.benchmark.harnesses.file.contracts import (
+    FileToolCall,
+    FileToolOracleProfile,
+    FileToolRecipe,
+    define_file_tool_scenario,
+)
+
+_ROWS = {
+    "glob_finds_inside_control": {
+        "case_kind": "control",
+        "declared_tools": ("glob",),
+        "setup_commands": ("/mode yolo",),
+        "seed_files": (("inside_ok.py", "x\n"),),
+        "rounds": (
+            (
+                (("bash",), (("command", "echo PERM_LIVE_7755 > live.txt"),), False, False),
+                (("glob",), (("pattern", "**/*.py"),), False, True),
+                (("glob",), (("pattern", "*.py"),), False, True),
+            ),
+        ),
+        "oracle_profile": "TEXT_RULES",
+        "oracle_parameters": (
+            ("source", "model_text"),
+            ("required", ("inside_ok",)),
+            ("forbidden", ()),
+            ("min_requests", 2),
+        ),
+        "dependencies": (),
+        "blocking": False,
+        "role": "CONTROL",
+        "execution_parameters": (("deny", ()), ("allow", "echo PERM_LIVE_7755 > live.txt")),
+        "bind_oracle_parameters": True,
+    },
+    "grep_finds_needle_control": {
+        "case_kind": "control",
+        "declared_tools": ("grep",),
+        "setup_commands": ("/mode yolo",),
+        "seed_files": (("plain_gi.txt", "NEEDLE_GI_7731 here\n"),),
+        "rounds": (
+            (
+                (("bash",), (("command", "echo PERM_LIVE_7755 > live.txt"),), False, False),
+                (("grep",), (("pattern", "NEEDLE_GI_7731"), ("path", ".")), False, True),
+            ),
+        ),
+        "oracle_profile": "TEXT_RULES",
+        "oracle_parameters": (
+            ("source", "model_text"),
+            ("required", ("plain_gi.txt",)),
+            ("forbidden", ()),
+            ("min_requests", 2),
+        ),
+        "dependencies": (),
+        "blocking": False,
+        "role": "CONTROL",
+        "execution_parameters": (("deny", ()), ("allow", "echo PERM_LIVE_7755 > live.txt")),
+        "bind_oracle_parameters": True,
+    },
+    "grep_type_filter_ignored": {
+        "case_kind": "reject",
+        "declared_tools": ("grep",),
+        "setup_commands": ("/mode yolo",),
+        "seed_files": (
+            ("gt_hit.py", "NEEDLE_GTYPE_7731 python\n"),
+            ("gt_hit.txt", "NEEDLE_GTYPE_7731 text\n"),
+        ),
+        "rounds": (
+            (
+                (("bash",), (("command", "echo PERM_LIVE_7755 > live.txt"),), False, False),
+                (("grep",), (("pattern", "NEEDLE_GTYPE_7731"), ("path", "."), ("type", "py")), False, True),
+            ),
+        ),
+        "oracle_profile": "TEXT_RULES",
+        "oracle_parameters": (
+            ("source", "model_text"),
+            ("required", ("gt_hit.py",)),
+            ("forbidden", ("gt_hit.txt",)),
+            ("min_requests", 2),
+        ),
+        "dependencies": (("grep_finds_needle_control", "GATE"),),
+        "blocking": False,
+        "role": "TARGET",
+        "execution_parameters": (("deny", ()), ("allow", "echo PERM_LIVE_7755 > live.txt")),
+        "bind_oracle_parameters": True,
+    },
+    "undo_reverts_overwrite_control": {
+        "case_kind": "control",
+        "declared_tools": ("write",),
+        "setup_commands": ("/mode yolo",),
+        "seed_files": (("tgt.txt", "ORIG_PERM_0001\n"),),
+        "rounds": (),
+        "oracle_profile": "TRANSITION_EXACT",
+        "oracle_parameters": (
+            (
+                "expected",
+                (
+                    ("phase1_tgt", "OVR_BODY_7755\n"),
+                    ("after_mid1_tgt", "ORIG_PERM_0001\n"),
+                    ("tgt", "ORIG_PERM_0001\n"),
+                ),
+            ),
+            ("min_requests", 2),
+        ),
+        "dependencies": (),
+        "blocking": False,
+        "role": "CONTROL",
+        "execution_parameters": (
+            (
+                "phase1_rounds",
+                (
+                    (
+                        (("bash",), (("command", "echo PERM_LIVE_7755 > live.txt"),), False, False),
+                        (("read",), (("file_path", "tgt.txt"),), False, True),
+                    ),
+                    ((("write",), (("file_path", "tgt.txt"), ("content", "OVR_BODY_7755\n")), False, True),),
+                ),
+            ),
+            ("mid_slash", ("/undo",)),
+            ("phase2_rounds", (((("bash",), (("command", "echo POSTUNDO_7755"),), False, False),),)),
+            ("deny", ()),
+            ("allow", "echo PERM_LIVE_7755 > live.txt"),
+        ),
+        "bind_oracle_parameters": True,
+    },
+    "rewind_restores_edited_file": {
+        "case_kind": "reject",
+        "declared_tools": ("write",),
+        "setup_commands": ("/mode yolo",),
+        "seed_files": (("tgt.txt", "ORIG_PERM_0001\n"),),
+        "rounds": (),
+        "oracle_profile": "REWIND_RESTORES",
+        "oracle_parameters": (("expected", "ORIG_PERM_0001\n"), ("min_requests", 2)),
+        "dependencies": (("undo_reverts_overwrite_control", "GATE"),),
+        "blocking": False,
+        "role": "TARGET",
+        "execution_parameters": (
+            (
+                "phase1_rounds",
+                (
+                    (
+                        (("bash",), (("command", "echo PERM_LIVE_7755 > live.txt"),), False, False),
+                        (("read",), (("file_path", "tgt.txt"),), False, True),
+                    ),
+                    ((("write",), (("file_path", "tgt.txt"), ("content", "RWOVR_8821\n")), False, True),),
+                ),
+            ),
+            ("mid_slash", ("/rewind 1", "/rewind 0", "/rewind")),
+            ("phase2_rounds", (((("bash",), (("command", "echo POSTRW_8821"),), False, False),),)),
+            ("deny", ()),
+            ("allow", "echo PERM_LIVE_7755 > live.txt"),
+        ),
+        "bind_oracle_parameters": True,
+    },
+}
+_ROWS.update(
+    {
+        "notebook_edit_cell_isolation": {
+            "case_kind": "reject",
+            "declared_tools": ("notebook_edit",),
+            "setup_commands": ("/mode yolo",),
+            "seed_files": (
+                (
+                    "nb.ipynb",
+                    '{"cells": [{"cell_type": "markdown", "metadata": {"tags": ["KEEP0"], "nested": {"k": 0}}, "source": ["CELL0_KEEP\\n"]}, {"cell_type": "code", "metadata": {"target": true}, "source": ["CELL1_OLD\\n"], "outputs": [], "execution_count": null}, {"cell_type": "code", "metadata": {"tags": ["KEEP2"], "nested": {"k": 2}}, "source": ["CELL2_KEEP\\n"], "outputs": [{"output_type": "stream", "name": "stdout", "text": ["KEEP2_OUTPUT\\n"]}], "execution_count": 42}], "metadata": {}, "nbformat": 4, "nbformat_minor": 5}',
+                ),
+            ),
+            "rounds": (
+                (
+                    (("bash",), (("command", "echo PERM_LIVE_7755 > live.txt"),), False, False),
+                    (("read",), (("file_path", "nb.ipynb"),), False, True),
+                ),
+                (
+                    (
+                        ("notebook_edit", "notebook-edit"),
+                        (
+                            ("file_path", "nb.ipynb"),
+                            ("cell_index", 1),
+                            ("mode", "replace"),
+                            ("source", "CELL1_NEW"),
+                        ),
+                        True,
+                        True,
+                    ),
+                ),
+                ((("bash",), (("command", "cat nb.ipynb"),), False, False),),
+            ),
+            "oracle_profile": "NOTEBOOK_ISOLATED",
+            "oracle_parameters": (
+                (
+                    "expected_cell0_json",
+                    '{"cell_type":"markdown","metadata":{"nested":{"k":0},"tags":["KEEP0"]},"source":["CELL0_KEEP\\n"]}',
+                ),
+                (
+                    "expected_cell2_json",
+                    '{"cell_type":"code","execution_count":42,"metadata":{"nested":{"k":2},"tags":["KEEP2"]},"outputs":[{"name":"stdout","output_type":"stream","text":["KEEP2_OUTPUT\\n"]}],"source":["CELL2_KEEP\\n"]}',
+                ),
+                ("new_marker", "CELL1_NEW"),
+                ("old_marker", "CELL1_OLD"),
+                ("min_requests", 2),
+            ),
+            "dependencies": (),
+            "blocking": True,
+            "role": "TARGET",
+            "execution_parameters": (("deny", ()), ("allow", "echo PERM_LIVE_7755 > live.txt")),
+            "bind_oracle_parameters": True,
+        },
+        "glob_truncation_keeps_sorted_end": {
+            "case_kind": "reject",
+            "declared_tools": ("glob",),
+            "setup_commands": ("/mode yolo",),
+            "seed_files": (),
+            "rounds": (
+                (
+                    (("bash",), (("command", "echo PERM_LIVE_7755 > live.txt"),), False, False),
+                    (
+                        ("bash",),
+                        (
+                            (
+                                "command",
+                                "mkdir -p gord && python3 -c \"import pathlib;pathlib.Path('gord/OLD' + 'EST_7755.ordx').write_text('x')\" && touch -t 200001010000 gord/OLD*_7755.ordx && python3 -c \"import os\nfor i in range(800): open('gord/n%d.ordx' % i,'w').write('x')\" && echo ORD_SEEDED_7755",
+                            ),
+                        ),
+                        False,
+                        False,
+                    ),
+                ),
+                ((("glob",), (("pattern", "**/*.ordx"),), False, True),),
+            ),
+            "oracle_profile": "TEXT_RULES",
+            "oracle_parameters": (
+                ("source", "model_text"),
+                ("required", (".ordx",)),
+                ("forbidden", ("OLDEST_7755",)),
+                ("min_requests", 2),
+            ),
+            "dependencies": (("glob_finds_inside_control", "GATE"),),
+            "blocking": True,
+            "role": "TARGET",
+            "execution_parameters": (("deny", ()), ("allow", "echo PERM_LIVE_7755 > live.txt")),
+            "bind_oracle_parameters": True,
+        },
+    }
+)
+_ROWS.update(
+    {
+        "notebook_edit_delete_keeps_neighbors": {
+            "case_kind": "reject",
+            "declared_tools": ("notebook_edit",),
+            "setup_commands": ("/mode yolo",),
+            "seed_files": (
+                (
+                    "nb.ipynb",
+                    '{"cells": [{"cell_type": "markdown", "metadata": {"tags": ["KEEP0"], "nested": {"k": 0}}, "source": ["CELL0_KEEP\\n"]}, {"cell_type": "code", "metadata": {"target": true}, "source": ["CELL1_OLD\\n"], "outputs": [], "execution_count": null}, {"cell_type": "code", "metadata": {"tags": ["KEEP2"], "nested": {"k": 2}}, "source": ["CELL2_KEEP\\n"], "outputs": [{"output_type": "stream", "name": "stdout", "text": ["KEEP2_OUTPUT\\n"]}], "execution_count": 42}], "metadata": {}, "nbformat": 4, "nbformat_minor": 5}',
+                ),
+            ),
+            "rounds": (
+                (
+                    (("bash",), (("command", "echo PERM_LIVE_7755 > live.txt"),), False, False),
+                    (("read",), (("file_path", "nb.ipynb"),), False, True),
+                ),
+                (
+                    (
+                        ("notebook_edit", "notebook-edit"),
+                        (("file_path", "nb.ipynb"), ("cell_index", 1), ("mode", "delete")),
+                        True,
+                        True,
+                    ),
+                ),
+                (
+                    (
+                        ("bash",),
+                        (
+                            (
+                                "command",
+                                "python3 -c \"import json;print('NBCELLS' + '_' + str(len(json.load(open('nb.ipynb'))['cells'])))\" && echo NBDEL_DONE_7755",
+                            ),
+                        ),
+                        False,
+                        False,
+                    ),
+                ),
+            ),
+            "oracle_profile": "TEXT_RULES",
+            "oracle_parameters": (
+                ("source", "model_text"),
+                ("required", ("NBCELLS_2",)),
+                ("forbidden", ()),
+                ("min_requests", 2),
+            ),
+            "dependencies": (("notebook_edit_cell_isolation", "REQUIREMENT"),),
+            "blocking": True,
+            "role": "TARGET",
+            "execution_parameters": (("deny", ()), ("allow", "echo PERM_LIVE_7755 > live.txt")),
+            "bind_oracle_parameters": True,
+        },
+        "symlink_to_outside_target_readable_control": {
+            "case_kind": "control",
+            "declared_tools": ("bash",),
+            "setup_commands": ("/mode yolo",),
+            "seed_files": (),
+            "rounds": (
+                (
+                    (("bash",), (("command", "echo PERM_LIVE_7755 > live.txt"),), False, False),
+                    (
+                        ("bash",),
+                        (
+                            (
+                                "command",
+                                "printf 'OUTSIDE_ORIG_7731\\n' > /tmp/outside_9931.txt && ln -sf /tmp/outside_9931.txt link_9931.txt && echo SYMCTL_DONE_7755",
+                            ),
+                        ),
+                        False,
+                        False,
+                    ),
+                ),
+                (
+                    (
+                        ("bash",),
+                        (
+                            (
+                                "command",
+                                "python3 -c \"import os; p='link_9931.txt'; print('SYM'+'LINK_%d' % os.path.islink(p)); print('SYM'+'REAL_%d' % (os.path.realpath(p)=='/tmp/outside_9931.txt')); print('SYM'+'BYTE_%d' % (open(p,'rb').read()==b'OUTSIDE_ORIG_7731\\n'))\"",
+                            ),
+                        ),
+                        False,
+                        False,
+                    ),
+                ),
+            ),
+            "oracle_profile": "TEXT_RULES",
+            "oracle_parameters": (
+                ("source", "model_text"),
+                ("required", ("SYMLINK_1", "SYMREAL_1", "SYMBYTE_1")),
+                ("forbidden", ()),
+                ("min_requests", 2),
+            ),
+            "dependencies": (),
+            "blocking": True,
+            "role": "CONTROL",
+            "execution_parameters": (("deny", ()), ("allow", "echo PERM_LIVE_7755 > live.txt")),
+            "bind_oracle_parameters": True,
+        },
+        "p32_ctl_memory_get_reads_inside_workspace": {
+            "case_kind": "control",
+            "declared_tools": ("memory_get",),
+            "setup_commands": ("/mode yolo",),
+            "seed_files": (("MEMORY.md", "INSIDEMEM_7732\n"),),
+            "rounds": (),
+            "oracle_profile": "MEMORY_EVENT",
+            "oracle_parameters": (("marker", "INSIDEMEM_7732"), ("min_requests", 2)),
+            "dependencies": (),
+            "blocking": True,
+            "role": "CONTROL",
+            "execution_parameters": (
+                (
+                    "phase1_rounds",
+                    (((("bash",), (("command", "echo PERM_LIVE_7755 > live.txt"),), False, False),),),
+                ),
+                (
+                    "phase2_rounds",
+                    (
+                        ((("memory_get", "memory-get"), (("path", "MEMORY.md"),), True, True),),
+                        ((("bash",), (("command", "echo P32A_DONE_7755"),), False, False),),
+                    ),
+                ),
+                ("mid_slash", ("/help",)),
+                ("deny", ()),
+                ("allow", "echo PERM_LIVE_7755 > live.txt"),
+            ),
+            "bind_oracle_parameters": True,
+        },
+        "memory_get_abs_path_escapes_workspace": {
+            "case_kind": "reject",
+            "declared_tools": ("memory_get",),
+            "setup_commands": ("/mode yolo",),
+            "seed_files": (),
+            "rounds": (
+                (
+                    (("bash",), (("command", "echo PERM_LIVE_7755 > live.txt"),), False, False),
+                    (
+                        ("bash",),
+                        (
+                            (
+                                "command",
+                                "python3 -c \"open('/tmp/msec_9932.txt','w').write('MEMSECRET' + '_7732' + chr(10))\" && echo P32A_SEEDED_7755",
+                            ),
+                        ),
+                        False,
+                        False,
+                    ),
+                ),
+                ((("memory_get", "memory-get"), (("path", "/tmp/msec_9932.txt"),), True, True),),
+                ((("bash",), (("command", "echo P32A_DONE_7755"),), False, False),),
+            ),
+            "oracle_profile": "TEXT_RULES",
+            "oracle_parameters": (
+                ("source", "model_text"),
+                ("required", ("P32A_DONE_7755",)),
+                ("forbidden", ("MEMSECRET_7732",)),
+                ("min_requests", 2),
+            ),
+            "dependencies": (("p32_ctl_memory_get_reads_inside_workspace", "GATE"),),
+            "blocking": True,
+            "role": "TARGET",
+            "execution_parameters": (("deny", ()), ("allow", "echo PERM_LIVE_7755 > live.txt")),
+            "bind_oracle_parameters": True,
+        },
+        "read_via_symlink_outside_workspace_bounded": {
+            "case_kind": "reject",
+            "declared_tools": ("read",),
+            "setup_commands": ("/mode yolo",),
+            "seed_files": (),
+            "rounds": (
+                (
+                    (("bash",), (("command", "echo PERM_LIVE_7755 > live.txt"),), False, False),
+                    (
+                        ("bash",),
+                        (
+                            (
+                                "command",
+                                "python3 -c \"open('/tmp/secr_9931.txt','w').write('OUTSECRET' + '_7731' + chr(10))\" && ln -sf /tmp/secr_9931.txt ls_9931.txt && echo RS6_SEEDED_7755",
+                            ),
+                        ),
+                        False,
+                        False,
+                    ),
+                ),
+                ((("read",), (("file_path", "ls_9931.txt"),), False, True),),
+                ((("bash",), (("command", "echo RS6_DONE_7755"),), False, False),),
+            ),
+            "oracle_profile": "TEXT_RULES",
+            "oracle_parameters": (
+                ("source", "model_text"),
+                ("required", ("RS6_DONE_7755",)),
+                ("forbidden", ("OUTSECRET_7731",)),
+                ("min_requests", 2),
+            ),
+            "dependencies": (
+                ("symlink_to_outside_target_readable_control", "GATE"),
+                ("file_symlink_inside_still_readable_control", "GATE"),
+            ),
+            "blocking": True,
+            "role": "TARGET",
+            "execution_parameters": (("deny", ()), ("allow", "echo PERM_LIVE_7755 > live.txt")),
+            "bind_oracle_parameters": True,
+        },
+        "file_symlink_inside_still_readable_control": {
+            "case_kind": "control",
+            "declared_tools": ("read",),
+            "setup_commands": ("/mode yolo",),
+            "seed_files": (("rif_9931.txt", "READ_INSIDE_7731\n"),),
+            "rounds": (
+                (
+                    (("bash",), (("command", "echo PERM_LIVE_7755 > live.txt"),), False, False),
+                    (
+                        ("bash",),
+                        (("command", "ln -sf rif_9931.txt ril_9931.txt && echo RIF_SEEDED_7755"),),
+                        False,
+                        False,
+                    ),
+                ),
+                ((("read",), (("file_path", "ril_9931.txt"),), False, True),),
+                ((("bash",), (("command", "echo RIF_DONE_7755"),), False, False),),
+            ),
+            "oracle_profile": "TEXT_RULES",
+            "oracle_parameters": (
+                ("source", "model_text"),
+                ("required", ("READ_INSIDE_7731",)),
+                ("forbidden", ()),
+                ("min_requests", 2),
+            ),
+            "dependencies": (),
+            "blocking": True,
+            "role": "CONTROL",
+            "execution_parameters": (("deny", ()), ("allow", "echo PERM_LIVE_7755 > live.txt")),
+            "bind_oracle_parameters": True,
+        },
+        "grep_default_mode_returns_path_control": {
+            "case_kind": "control",
+            "declared_tools": ("grep",),
+            "setup_commands": ("/mode yolo",),
+            "seed_files": (("f9_9931.txt", "F9NEEDLE_7755 ctxf9_9931\n"),),
+            "rounds": (
+                (
+                    (("bash",), (("command", "echo PERM_LIVE_7755 > live.txt"),), False, False),
+                    (
+                        ("grep",),
+                        (("pattern", "F9NEEDLE_7755"), ("path", "."), ("output_mode", "files_with_matches")),
+                        False,
+                        True,
+                    ),
+                ),
+                ((("bash",), (("command", "echo F9C_DONE_7755"),), False, False),),
+            ),
+            "oracle_profile": "TEXT_RULES",
+            "oracle_parameters": (
+                ("source", "target_tool_result"),
+                ("required", ("f9_9931.txt",)),
+                ("forbidden", ("ctxf9_9931",)),
+                ("forbidden_regex", "(?:^|\\n)\\s*[^:\\n]+:\\s*\\d+\\s*(?:\\n|$)"),
+                ("min_requests", 2),
+            ),
+            "dependencies": (),
+            "blocking": True,
+            "role": "CONTROL",
+            "execution_parameters": (("deny", ()), ("allow", "echo PERM_LIVE_7755 > live.txt")),
+            "bind_oracle_parameters": True,
+        },
+        "grep_head_limit_zero_not_unlimited": {
+            "case_kind": "reject",
+            "declared_tools": ("grep",),
+            "setup_commands": ("/mode yolo",),
+            "seed_files": (("f9_9931.txt", "F9NEEDLE_7755 ctxf9_9931\n"),),
+            "rounds": (
+                (
+                    (("bash",), (("command", "echo PERM_LIVE_7755 > live.txt"),), False, False),
+                    (
+                        ("grep",),
+                        (("pattern", "F9NEEDLE_7755"), ("path", "."), ("head_limit", 0)),
+                        False,
+                        True,
+                    ),
+                ),
+                ((("bash",), (("command", "echo HZ9_DONE_7755"),), False, False),),
+            ),
+            "oracle_profile": "TEXT_RULES",
+            "oracle_parameters": (
+                ("source", "model_text"),
+                ("required", ("HZ9_DONE_7755",)),
+                ("forbidden", ("f9_9931",)),
+                ("min_requests", 2),
+            ),
+            "dependencies": (("grep_default_mode_returns_path_control", "GATE"),),
+            "blocking": True,
+            "role": "TARGET",
+            "execution_parameters": (("deny", ()), ("allow", "echo PERM_LIVE_7755 > live.txt")),
+            "bind_oracle_parameters": True,
+        },
+        "read_regular_file_control": {
+            "case_kind": "control",
+            "declared_tools": ("read",),
+            "setup_commands": ("/mode yolo",),
+            "seed_files": (("reg_9941.txt", "REGULAR_7731\n"),),
+            "rounds": (
+                ((("bash",), (("command", "echo PERM_LIVE_7755 > live.txt"),), False, False),),
+                ((("read",), (("file_path", "reg_9941.txt"),), False, True),),
+                ((("bash",), (("command", "python3 -c \"print('DEVREAD' + '_DONE_7755')\""),), False, False),),
+            ),
+            "oracle_profile": "TEXT_RULES",
+            "oracle_parameters": (
+                ("source", "model_text"),
+                ("required", ("REGULAR_7731",)),
+                ("forbidden", ()),
+                ("min_requests", 2),
+            ),
+            "dependencies": (),
+            "blocking": True,
+            "role": "CONTROL",
+            "execution_parameters": (("deny", ()), ("allow", "echo PERM_LIVE_7755 > live.txt")),
+            "bind_oracle_parameters": True,
+        },
+        "read_char_device_bounded": {
+            "case_kind": "reject",
+            "declared_tools": ("read",),
+            "setup_commands": ("/mode yolo",),
+            "seed_files": (),
+            "rounds": (
+                ((("bash",), (("command", "echo PERM_LIVE_7755 > live.txt"),), False, False),),
+                ((("read",), (("file_path", "/dev/urandom"),), False, True),),
+                ((("bash",), (("command", "python3 -c \"print('DEVREAD' + '_DONE_7755')\""),), False, False),),
+            ),
+            "oracle_profile": "TEXT_RULES",
+            "oracle_parameters": (
+                ("source", "model_text"),
+                ("required", ("DEVREAD_DONE_7755",)),
+                ("forbidden", ()),
+                ("min_requests", 2),
+            ),
+            "dependencies": (("read_regular_file_control", "GATE"),),
+            "blocking": True,
+            "role": "TARGET",
+            "execution_parameters": (("deny", ()), ("allow", "echo PERM_LIVE_7755 > live.txt")),
+            "bind_oracle_parameters": True,
+        },
+    }
+)
+
+
+def _build(scenario_id: str):
+    row = _ROWS[scenario_id]
+    rounds = tuple(
+        (
+            tuple((FileToolCall(names, args, aliases, nested) for names, args, aliases, nested in turn))
+            for turn in row["rounds"]
+        )
+    )
+    recipe = FileToolRecipe(
+        row["case_kind"],
+        row["declared_tools"],
+        row["setup_commands"],
+        row["seed_files"],
+        rounds,
+        FileToolOracleProfile(row["oracle_profile"]),
+        row["oracle_parameters"],
+        tuple(((item, DependencyKind(kind)) for item, kind in row["dependencies"])),
+        row["blocking"],
+        execution_parameters=row.get("execution_parameters", ()),
+        bind_oracle_parameters=row.get("bind_oracle_parameters", False),
+    )
+    return define_file_tool_scenario(scenario_id, recipe, ScenarioRole(row["role"]))
+
+
+_SCENARIOS = {item: _build(item) for item in _ROWS}
+
+
+def scenario_ids() -> tuple[str, ...]:
+    return tuple(_SCENARIOS)
+
+
+def scenario_by_id(scenario_id: str):
+    try:
+        return _SCENARIOS[scenario_id]
+    except KeyError as error:
+        raise KeyError(f"unknown file-tool-child scenario: {scenario_id}") from error
+
+
+__all__ = ["scenario_by_id", "scenario_ids"]
diff --git a/code/src/doc2harness/benchmark/harnesses/file/scenarios/__init__.py b/code/src/doc2harness/benchmark/harnesses/file/scenarios/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..3b8c0eef34c91b6b31e8dd34aa02f2ddc903bfa1
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/file/scenarios/__init__.py
@@ -0,0 +1 @@
+"""Thin file-tool child scenario declarations."""
diff --git a/code/src/doc2harness/benchmark/harnesses/file/scenarios/file_symlink_inside_still_readable_control.py b/code/src/doc2harness/benchmark/harnesses/file/scenarios/file_symlink_inside_still_readable_control.py
new file mode 100644
index 0000000000000000000000000000000000000000..c708525f496d438507014dd108a70b00de09dbee
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/file/scenarios/file_symlink_inside_still_readable_control.py
@@ -0,0 +1,101 @@
+"""Confirm that a workspace file symlink remains readable through the read tool.
+1. Seed an in-workspace file, enable yolo mode, and create a symlink to it.
+2. Read the symlink with the nested read arguments.
+3. Send a later Bash completion marker after the read result is delivered.
+4. Pass when the file marker and completion are visible with clean execution.
+"""
+
+from doc2harness.benchmark.harnesses.file.contracts import (
+    FileToolApplicability,
+    FileToolJudgement,
+    FileToolOracleProfile,
+    FileToolOutcome,
+    FileToolRawObservation,
+    FileToolScenario,
+    build_file_tool_evaluation,
+    capture_model_text,
+    compile_file_tool_steps,
+    setup_command,
+    tool_round,
+    validate_file_tool_observation,
+    write_fixture,
+)
+from ..recipes import scenario_by_id
+
+SCENARIO_ID = "file_symlink_inside_still_readable_control"
+STEPS = (
+    write_fixture("rif_9931.txt", "READ_INSIDE_7731\n"),
+    setup_command("/mode yolo"),
+    tool_round("bash", turn=1, command="echo PERM_LIVE_7755 > live.txt"),
+    tool_round(
+        "bash",
+        turn=1,
+        command="ln -sf rif_9931.txt ril_9931.txt && echo RIF_SEEDED_7755",
+    ),
+    tool_round("read", turn=2, arguments_nested=True, file_path="ril_9931.txt"),
+    tool_round("bash", turn=3, command="echo RIF_DONE_7755"),
+    capture_model_text(required=("READ_INSIDE_7731",), min_requests=2),
+)
+RECIPE = compile_file_tool_steps(
+    STEPS,
+    case_kind="control",
+    declared_tools=("read",),
+    oracle_profile=FileToolOracleProfile.TEXT_RULES,
+    blocking=True,
+    execution_parameters=(
+        ("deny", ()),
+        ("allow", "echo PERM_LIVE_7755 > live.txt"),
+    ),
+    bind_oracle_parameters=True,
+)
+_BASE_SCENARIO = scenario_by_id(SCENARIO_ID)
+SCENARIO: FileToolScenario = FileToolScenario(_BASE_SCENARIO.definition, RECIPE)
+scenario = SCENARIO
+definition = SCENARIO.definition
+
+
+def judge(observation: FileToolRawObservation):
+    """Apply the typed readable-symlink and completion contract."""
+
+    validate_file_tool_observation(SCENARIO, observation)
+    advertised = any(
+        type(item) is str
+        and item.strip().lower() in {"read", "cat", "view_file", "open_file", "file_read"}
+        for item in observation.advertised_tools
+    )
+    if not advertised and not observation.timed_out:
+        return build_file_tool_evaluation(
+            SCENARIO,
+            observation,
+            FileToolJudgement(
+                FileToolOutcome.PASS,
+                FileToolApplicability.INCONCLUSIVE,
+                FileToolOracleProfile.TEXT_RULES.value,
+            ),
+        )
+    params = dict(RECIPE.oracle_parameters)
+    passed = (
+        advertised
+        and observation.request_count >= int(params["min_requests"])
+        and observation.live
+        and all(marker in observation.model_text for marker in params["required"])
+        and all(marker not in observation.model_text for marker in params["forbidden"])
+        and observation.process_tree_clean
+        and observation.gateway_clean
+        and observation.workspace_clean
+        and not observation.timed_out
+    )
+    return build_file_tool_evaluation(
+        SCENARIO,
+        observation,
+        FileToolJudgement(
+            FileToolOutcome.PASS if passed else FileToolOutcome.FAIL,
+            FileToolApplicability.APPLICABLE,
+            FileToolOracleProfile.TEXT_RULES.value
+            if passed
+            else f"{FileToolOracleProfile.TEXT_RULES.value}_FAILED",
+        ),
+    )
+
+
+__all__ = ["RECIPE", "SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/file/scenarios/glob_finds_inside_control.py b/code/src/doc2harness/benchmark/harnesses/file/scenarios/glob_finds_inside_control.py
new file mode 100644
index 0000000000000000000000000000000000000000..92479a84ff93477e2736b8094c500ecbb16d3219
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/file/scenarios/glob_finds_inside_control.py
@@ -0,0 +1,97 @@
+"""Confirm glob finds ordinary files in the workspace for the control path.
+1. Seed an ordinary Python file and enable yolo mode.
+2. Establish a live Bash probe, then run recursive and root-level glob calls.
+3. Capture model text containing the seeded filename from the glob results.
+4. Pass when the filename is reported and execution remains clean.
+"""
+
+from doc2harness.benchmark.harnesses.file.contracts import (
+    FileToolApplicability,
+    FileToolJudgement,
+    FileToolOracleProfile,
+    FileToolOutcome,
+    FileToolRawObservation,
+    FileToolScenario,
+    build_file_tool_evaluation,
+    capture_model_text,
+    compile_file_tool_steps,
+    setup_command,
+    tool_round,
+    validate_file_tool_observation,
+    write_fixture,
+)
+from ..recipes import scenario_by_id
+
+SCENARIO_ID = "glob_finds_inside_control"
+STEPS = (
+    write_fixture("inside_ok.py", "x\n"),
+    setup_command("/mode yolo"),
+    tool_round("bash", turn=1, command="echo PERM_LIVE_7755 > live.txt"),
+    tool_round("glob", turn=1, arguments_nested=True, pattern="**/*.py"),
+    tool_round("glob", turn=1, arguments_nested=True, pattern="*.py"),
+    capture_model_text(required=("inside_ok",), min_requests=2),
+)
+RECIPE = compile_file_tool_steps(
+    STEPS,
+    case_kind="control",
+    declared_tools=("glob",),
+    oracle_profile=FileToolOracleProfile.TEXT_RULES,
+    blocking=False,
+    execution_parameters=(
+        ("deny", ()),
+        ("allow", "echo PERM_LIVE_7755 > live.txt"),
+    ),
+    bind_oracle_parameters=True,
+)
+_BASE_SCENARIO = scenario_by_id(SCENARIO_ID)
+SCENARIO: FileToolScenario = FileToolScenario(_BASE_SCENARIO.definition, RECIPE)
+scenario = SCENARIO
+definition = SCENARIO.definition
+
+
+def judge(observation: FileToolRawObservation):
+    """Apply typed workspace-glob control rules without parsing tool prose."""
+
+    validate_file_tool_observation(SCENARIO, observation)
+    advertised = any(
+        type(item) is str
+        and item.strip().lower() in {"glob", "find_files"}
+        for item in observation.advertised_tools
+    )
+    if not advertised and not observation.timed_out:
+        return build_file_tool_evaluation(
+            SCENARIO,
+            observation,
+            FileToolJudgement(
+                FileToolOutcome.PASS,
+                FileToolApplicability.INCONCLUSIVE,
+                FileToolOracleProfile.TEXT_RULES.value,
+            ),
+        )
+    params = dict(RECIPE.oracle_parameters)
+    source = getattr(observation, str(params["source"]))
+    passed = (
+        advertised
+        and observation.request_count >= int(params["min_requests"])
+        and observation.live
+        and all(marker in source for marker in params["required"])
+        and all(marker not in source for marker in params["forbidden"])
+        and observation.process_tree_clean
+        and observation.gateway_clean
+        and observation.workspace_clean
+        and not observation.timed_out
+    )
+    return build_file_tool_evaluation(
+        SCENARIO,
+        observation,
+        FileToolJudgement(
+            FileToolOutcome.PASS if passed else FileToolOutcome.FAIL,
+            FileToolApplicability.APPLICABLE,
+            FileToolOracleProfile.TEXT_RULES.value
+            if passed
+            else f"{FileToolOracleProfile.TEXT_RULES.value}_FAILED",
+        ),
+    )
+
+
+__all__ = ["RECIPE", "SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/file/scenarios/glob_truncation_keeps_sorted_end.py b/code/src/doc2harness/benchmark/harnesses/file/scenarios/glob_truncation_keeps_sorted_end.py
new file mode 100644
index 0000000000000000000000000000000000000000..9d52be5222923c8faa80b4a5a500688929cbd862
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/file/scenarios/glob_truncation_keeps_sorted_end.py
@@ -0,0 +1,110 @@
+"""Verify a truncated glob result keeps the sorted tail instead of only old entries.
+1. Enable yolo mode and seed one old file plus 800 numbered ``.ordx`` files through Bash.
+2. Search the workspace with the nested recursive glob pattern.
+3. Capture model text containing the suffix and excluding the oldest-file marker.
+4. Pass when the sorted result reaches the expected tail and execution is clean.
+"""
+
+from doc2harness.benchmark.definition import DependencyKind
+from doc2harness.benchmark.harnesses.file.contracts import (
+    FileToolApplicability,
+    FileToolJudgement,
+    FileToolOracleProfile,
+    FileToolOutcome,
+    FileToolRawObservation,
+    FileToolScenario,
+    build_file_tool_evaluation,
+    capture_model_text,
+    compile_file_tool_steps,
+    setup_command,
+    tool_round,
+    validate_file_tool_observation,
+)
+from ..recipes import scenario_by_id
+
+SCENARIO_ID = "glob_truncation_keeps_sorted_end"
+STEPS = (
+    setup_command("/mode yolo"),
+    tool_round("bash", turn=1, command="echo PERM_LIVE_7755 > live.txt"),
+    tool_round(
+        "bash",
+        turn=1,
+        command=(
+            "mkdir -p gord && python3 -c \"import pathlib;pathlib.Path('gord/OLD'"
+            " + 'EST_7755.ordx').write_text('x')\" && touch -t 200001010000 "
+            "gord/OLD*_7755.ordx && python3 -c \"import os\n"
+            "for i in range(800): open('gord/n%d.ordx' % i,'w').write('x')\""
+            " && echo ORD_SEEDED_7755"
+        ),
+    ),
+    tool_round("glob", turn=2, arguments_nested=True, pattern="**/*.ordx"),
+    capture_model_text(
+        required=(".ordx",),
+        forbidden=("OLDEST_7755",),
+        min_requests=2,
+    ),
+)
+RECIPE = compile_file_tool_steps(
+    STEPS,
+    case_kind="reject",
+    declared_tools=("glob",),
+    oracle_profile=FileToolOracleProfile.TEXT_RULES,
+    dependencies=(("glob_finds_inside_control", DependencyKind.GATE),),
+    blocking=True,
+    execution_parameters=(
+        ("deny", ()),
+        ("allow", "echo PERM_LIVE_7755 > live.txt"),
+    ),
+    bind_oracle_parameters=True,
+)
+_BASE_SCENARIO = scenario_by_id(SCENARIO_ID)
+SCENARIO: FileToolScenario = FileToolScenario(_BASE_SCENARIO.definition, RECIPE)
+scenario = SCENARIO
+definition = SCENARIO.definition
+
+
+def judge(observation: FileToolRawObservation):
+    """Apply typed glob-tail rules without parsing tool prose."""
+
+    validate_file_tool_observation(SCENARIO, observation)
+    advertised = any(
+        type(item) is str and item.strip().lower() in {"glob", "find_files"}
+        for item in observation.advertised_tools
+    )
+    if not advertised and not observation.timed_out:
+        return build_file_tool_evaluation(
+            SCENARIO,
+            observation,
+            FileToolJudgement(
+                FileToolOutcome.PASS,
+                FileToolApplicability.INCONCLUSIVE,
+                FileToolOracleProfile.TEXT_RULES.value,
+            ),
+        )
+    params = dict(RECIPE.oracle_parameters)
+    source = getattr(observation, str(params["source"]))
+    passed = (
+        advertised
+        and observation.request_count >= int(params["min_requests"])
+        and observation.live
+        and all(marker in source for marker in params["required"])
+        and all(marker not in source for marker in params["forbidden"])
+        and observation.process_tree_clean
+        and observation.gateway_clean
+        and observation.workspace_clean
+        and not observation.timed_out
+    )
+    return build_file_tool_evaluation(
+        SCENARIO,
+        observation,
+        FileToolJudgement(
+            FileToolOutcome.PASS if passed else FileToolOutcome.FAIL,
+            FileToolApplicability.APPLICABLE,
+            FileToolOracleProfile.TEXT_RULES.value
+            if passed
+            else f"{FileToolOracleProfile.TEXT_RULES.value}_FAILED",
+        ),
+    )
+
+
+__all__ = ["RECIPE", "SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/file/scenarios/grep_default_mode_returns_path_control.py b/code/src/doc2harness/benchmark/harnesses/file/scenarios/grep_default_mode_returns_path_control.py
new file mode 100644
index 0000000000000000000000000000000000000000..7e2d9954497b1facdcbcc8aa1776043ffe780eab
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/file/scenarios/grep_default_mode_returns_path_control.py
@@ -0,0 +1,130 @@
+"""Confirm default grep output reports matching paths without line content.
+1. Seed a file containing a unique marker and enable yolo mode.
+2. Run a live Bash probe and grep with the path-only output mode.
+3. Capture the typed grep result and a completion marker from the follow-up round.
+4. Pass when the filename is present, content and line-number output are absent, and execution is clean.
+"""
+
+import re
+from dataclasses import replace
+
+from doc2harness.benchmark.harnesses.file.contracts import (
+    FileToolApplicability,
+    FileToolJudgement,
+    FileToolOracleProfile,
+    FileToolOutcome,
+    FileToolRawObservation,
+    FileToolScenario,
+    build_file_tool_evaluation,
+    capture_fact,
+    compile_file_tool_steps,
+    setup_command,
+    tool_round,
+    validate_file_tool_observation,
+    write_fixture,
+)
+from ..recipes import scenario_by_id
+
+SCENARIO_ID = "grep_default_mode_returns_path_control"
+STEPS = (
+    write_fixture("f9_9931.txt", "F9NEEDLE_7755 ctxf9_9931\n"),
+    setup_command("/mode yolo"),
+    tool_round("bash", turn=1, command="echo PERM_LIVE_7755 > live.txt"),
+    tool_round(
+        "grep",
+        turn=1,
+        arguments_nested=True,
+        pattern="F9NEEDLE_7755",
+        path=".",
+        output_mode="files_with_matches",
+    ),
+    tool_round("bash", turn=2, command="echo F9C_DONE_7755"),
+    capture_fact(
+        "target_tool_result",
+        required=("f9_9931.txt",),
+        forbidden=("ctxf9_9931",),
+        forbidden_regex=r"(?:^|\n)\s*[^:\n]+:\s*\d+\s*(?:\n|$)",
+        min_requests=2,
+    ),
+)
+RECIPE = replace(
+    compile_file_tool_steps(
+        STEPS,
+        case_kind="control",
+        declared_tools=("grep",),
+        oracle_profile=FileToolOracleProfile.TEXT_RULES,
+        blocking=True,
+        execution_parameters=(
+            ("deny", ()),
+            ("allow", "echo PERM_LIVE_7755 > live.txt"),
+        ),
+        bind_oracle_parameters=True,
+    ),
+    # The parameter order is part of the frozen recipe identity.
+    oracle_parameters=(
+        ("source", "target_tool_result"),
+        ("required", ("f9_9931.txt",)),
+        ("forbidden", ("ctxf9_9931",)),
+        (
+            "forbidden_regex",
+            r"(?:^|\n)\s*[^:\n]+:\s*\d+\s*(?:\n|$)",
+        ),
+        ("min_requests", 2),
+    ),
+)
+_BASE_SCENARIO = scenario_by_id(SCENARIO_ID)
+SCENARIO: FileToolScenario = FileToolScenario(_BASE_SCENARIO.definition, RECIPE)
+scenario = SCENARIO
+definition = SCENARIO.definition
+
+
+def judge(observation: FileToolRawObservation):
+    """Apply typed path-only grep rules without parsing tool prose."""
+
+    validate_file_tool_observation(SCENARIO, observation)
+    advertised = any(
+        type(item) is str
+        and item.strip().lower() in {"grep", "search_files", "ripgrep"}
+        for item in observation.advertised_tools
+    )
+    if not advertised and not observation.timed_out:
+        return build_file_tool_evaluation(
+            SCENARIO,
+            observation,
+            FileToolJudgement(
+                FileToolOutcome.PASS,
+                FileToolApplicability.INCONCLUSIVE,
+                FileToolOracleProfile.TEXT_RULES.value,
+            ),
+        )
+    params = dict(RECIPE.oracle_parameters)
+    source = getattr(observation, str(params["source"]))
+    passed = (
+        advertised
+        and observation.request_count >= int(params["min_requests"])
+        and observation.live
+        and all(marker in source for marker in params["required"])
+        and all(marker not in source for marker in params["forbidden"])
+        and (
+            params.get("forbidden_regex") is None
+            or re.search(str(params["forbidden_regex"]), source, re.MULTILINE) is None
+        )
+        and observation.process_tree_clean
+        and observation.gateway_clean
+        and observation.workspace_clean
+        and not observation.timed_out
+    )
+    return build_file_tool_evaluation(
+        SCENARIO,
+        observation,
+        FileToolJudgement(
+            FileToolOutcome.PASS if passed else FileToolOutcome.FAIL,
+            FileToolApplicability.APPLICABLE,
+            FileToolOracleProfile.TEXT_RULES.value
+            if passed
+            else f"{FileToolOracleProfile.TEXT_RULES.value}_FAILED",
+        ),
+    )
+
+
+__all__ = ["RECIPE", "SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/file/scenarios/grep_finds_needle_control.py b/code/src/doc2harness/benchmark/harnesses/file/scenarios/grep_finds_needle_control.py
new file mode 100644
index 0000000000000000000000000000000000000000..6cb4e6336ec135c4d650a81f395f7afc62f20eba
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/file/scenarios/grep_finds_needle_control.py
@@ -0,0 +1,101 @@
+"""Confirm that grep finds a known marker in an ordinary workspace file.
+1. Seed a text file containing the unique marker and enable yolo mode.
+2. Establish a live Bash probe and search the workspace for the marker.
+3. Capture the model text that should name the matching file.
+4. Pass when the filename is reported and execution remains clean.
+"""
+
+from doc2harness.benchmark.harnesses.file.contracts import (
+    FileToolApplicability,
+    FileToolJudgement,
+    FileToolOracleProfile,
+    FileToolOutcome,
+    FileToolRawObservation,
+    FileToolScenario,
+    build_file_tool_evaluation,
+    capture_model_text,
+    compile_file_tool_steps,
+    setup_command,
+    tool_round,
+    validate_file_tool_observation,
+    write_fixture,
+)
+from ..recipes import scenario_by_id
+
+SCENARIO_ID = "grep_finds_needle_control"
+STEPS = (
+    write_fixture("plain_gi.txt", "NEEDLE_GI_7731 here\n"),
+    setup_command("/mode yolo"),
+    tool_round("bash", turn=1, command="echo PERM_LIVE_7755 > live.txt"),
+    tool_round(
+        "grep",
+        turn=1,
+        arguments_nested=True,
+        pattern="NEEDLE_GI_7731",
+        path=".",
+    ),
+    capture_model_text(required=("plain_gi.txt",), min_requests=2),
+)
+RECIPE = compile_file_tool_steps(
+    STEPS,
+    case_kind="control",
+    declared_tools=("grep",),
+    oracle_profile=FileToolOracleProfile.TEXT_RULES,
+    blocking=False,
+    execution_parameters=(
+        ("deny", ()),
+        ("allow", "echo PERM_LIVE_7755 > live.txt"),
+    ),
+    bind_oracle_parameters=True,
+)
+_BASE_SCENARIO = scenario_by_id(SCENARIO_ID)
+SCENARIO: FileToolScenario = FileToolScenario(_BASE_SCENARIO.definition, RECIPE)
+scenario = SCENARIO
+definition = SCENARIO.definition
+
+
+def judge(observation: FileToolRawObservation):
+    """Apply the typed grep-result contract without inspecting tool prose."""
+
+    validate_file_tool_observation(SCENARIO, observation)
+    advertised = any(
+        type(item) is str
+        and item.strip().lower() in {"grep", "search_files", "ripgrep"}
+        for item in observation.advertised_tools
+    )
+    if not advertised and not observation.timed_out:
+        return build_file_tool_evaluation(
+            SCENARIO,
+            observation,
+            FileToolJudgement(
+                FileToolOutcome.PASS,
+                FileToolApplicability.INCONCLUSIVE,
+                FileToolOracleProfile.TEXT_RULES.value,
+            ),
+        )
+    params = dict(RECIPE.oracle_parameters)
+    passed = (
+        advertised
+        and observation.request_count >= int(params["min_requests"])
+        and observation.live
+        and all(marker in observation.model_text for marker in params["required"])
+        and all(marker not in observation.model_text for marker in params["forbidden"])
+        and observation.process_tree_clean
+        and observation.gateway_clean
+        and observation.workspace_clean
+        and not observation.timed_out
+    )
+    return build_file_tool_evaluation(
+        SCENARIO,
+        observation,
+        FileToolJudgement(
+            FileToolOutcome.PASS if passed else FileToolOutcome.FAIL,
+            FileToolApplicability.APPLICABLE,
+            FileToolOracleProfile.TEXT_RULES.value
+            if passed
+            else f"{FileToolOracleProfile.TEXT_RULES.value}_FAILED",
+        ),
+    )
+
+
+__all__ = ["RECIPE", "SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/file/scenarios/grep_head_limit_zero_not_unlimited.py b/code/src/doc2harness/benchmark/harnesses/file/scenarios/grep_head_limit_zero_not_unlimited.py
new file mode 100644
index 0000000000000000000000000000000000000000..91d0fa032b491e2dbb1f3207b7b36fc53fbf3f6b
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/file/scenarios/grep_head_limit_zero_not_unlimited.py
@@ -0,0 +1,109 @@
+"""Reject interpreting a zero grep head limit as an unlimited result.
+1. Seed a marked file, enable yolo mode, and establish a live Bash round.
+2. Search with the nested grep tool using a zero head limit.
+3. Run a follow-up completion probe and capture required/forbidden markers.
+4. Pass when the completion marker appears without leaking the matching filename.
+"""
+
+from doc2harness.benchmark.definition import DependencyKind
+from doc2harness.benchmark.harnesses.file.contracts import (
+    FileToolApplicability,
+    FileToolJudgement,
+    FileToolOracleProfile,
+    FileToolOutcome,
+    FileToolRawObservation,
+    FileToolScenario,
+    build_file_tool_evaluation,
+    capture_model_text,
+    compile_file_tool_steps,
+    setup_command,
+    tool_round,
+    validate_file_tool_observation,
+    write_fixture,
+)
+from ..recipes import scenario_by_id
+
+SCENARIO_ID = "grep_head_limit_zero_not_unlimited"
+STEPS = (
+    write_fixture("f9_9931.txt", "F9NEEDLE_7755 ctxf9_9931\n"),
+    setup_command("/mode yolo"),
+    tool_round("bash", turn=1, command="echo PERM_LIVE_7755 > live.txt"),
+    tool_round(
+        "grep",
+        turn=1,
+        arguments_nested=True,
+        pattern="F9NEEDLE_7755",
+        path=".",
+        head_limit=0,
+    ),
+    tool_round("bash", turn=2, command="echo HZ9_DONE_7755"),
+    capture_model_text(
+        required=("HZ9_DONE_7755",),
+        forbidden=("f9_9931",),
+        min_requests=2,
+    ),
+)
+RECIPE = compile_file_tool_steps(
+    STEPS,
+    case_kind="reject",
+    declared_tools=("grep",),
+    oracle_profile=FileToolOracleProfile.TEXT_RULES,
+    dependencies=(("grep_default_mode_returns_path_control", DependencyKind.GATE),),
+    blocking=True,
+    execution_parameters=(
+        ("deny", ()),
+        ("allow", "echo PERM_LIVE_7755 > live.txt"),
+    ),
+    bind_oracle_parameters=True,
+)
+_BASE_SCENARIO = scenario_by_id(SCENARIO_ID)
+SCENARIO: FileToolScenario = FileToolScenario(_BASE_SCENARIO.definition, RECIPE)
+scenario = SCENARIO
+definition = SCENARIO.definition
+
+
+def judge(observation: FileToolRawObservation):
+    """Apply typed zero-limit output rules without parsing tool prose."""
+
+    validate_file_tool_observation(SCENARIO, observation)
+    advertised = any(
+        type(item) is str
+        and item.strip().lower() in {"grep", "search_files", "ripgrep"}
+        for item in observation.advertised_tools
+    )
+    if not advertised and not observation.timed_out:
+        return build_file_tool_evaluation(
+            SCENARIO,
+            observation,
+            FileToolJudgement(
+                FileToolOutcome.PASS,
+                FileToolApplicability.INCONCLUSIVE,
+                FileToolOracleProfile.TEXT_RULES.value,
+            ),
+        )
+    params = dict(RECIPE.oracle_parameters)
+    passed = (
+        advertised
+        and observation.request_count >= int(params["min_requests"])
+        and observation.live
+        and all(marker in observation.model_text for marker in params["required"])
+        and all(marker not in observation.model_text for marker in params["forbidden"])
+        and observation.process_tree_clean
+        and observation.gateway_clean
+        and observation.workspace_clean
+        and not observation.timed_out
+    )
+    return build_file_tool_evaluation(
+        SCENARIO,
+        observation,
+        FileToolJudgement(
+            FileToolOutcome.PASS if passed else FileToolOutcome.FAIL,
+            FileToolApplicability.APPLICABLE,
+            FileToolOracleProfile.TEXT_RULES.value
+            if passed
+            else f"{FileToolOracleProfile.TEXT_RULES.value}_FAILED",
+        ),
+    )
+
+
+__all__ = ["RECIPE", "SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/file/scenarios/grep_type_filter_ignored.py b/code/src/doc2harness/benchmark/harnesses/file/scenarios/grep_type_filter_ignored.py
new file mode 100644
index 0000000000000000000000000000000000000000..5a2a71ab3bb417f0947180a1cc86b885a381d1f8
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/file/scenarios/grep_type_filter_ignored.py
@@ -0,0 +1,109 @@
+"""Verify grep type filtering includes Python matches and excludes text files.
+1. Seed matching Python and text files, then enable yolo mode.
+2. Establish a live Bash round and search with the nested grep ``type=py`` filter.
+3. Capture the model text containing the accepted and rejected paths.
+4. Pass when only the Python path is reported and execution is clean.
+"""
+
+from doc2harness.benchmark.definition import DependencyKind
+from doc2harness.benchmark.harnesses.file.contracts import (
+    FileToolApplicability,
+    FileToolJudgement,
+    FileToolOracleProfile,
+    FileToolOutcome,
+    FileToolRawObservation,
+    FileToolScenario,
+    build_file_tool_evaluation,
+    capture_model_text,
+    compile_file_tool_steps,
+    setup_command,
+    tool_round,
+    validate_file_tool_observation,
+    write_fixture,
+)
+from ..recipes import scenario_by_id
+
+SCENARIO_ID = "grep_type_filter_ignored"
+STEPS = (
+    write_fixture("gt_hit.py", "NEEDLE_GTYPE_7731 python\n"),
+    write_fixture("gt_hit.txt", "NEEDLE_GTYPE_7731 text\n"),
+    setup_command("/mode yolo"),
+    tool_round("bash", turn=1, command="echo PERM_LIVE_7755 > live.txt"),
+    tool_round(
+        "grep",
+        turn=1,
+        arguments_nested=True,
+        pattern="NEEDLE_GTYPE_7731",
+        path=".",
+        type="py",
+    ),
+    capture_model_text(
+        required=("gt_hit.py",),
+        forbidden=("gt_hit.txt",),
+        min_requests=2,
+    ),
+)
+RECIPE = compile_file_tool_steps(
+    STEPS,
+    case_kind="reject",
+    declared_tools=("grep",),
+    oracle_profile=FileToolOracleProfile.TEXT_RULES,
+    dependencies=(("grep_finds_needle_control", DependencyKind.GATE),),
+    blocking=False,
+    execution_parameters=(
+        ("deny", ()),
+        ("allow", "echo PERM_LIVE_7755 > live.txt"),
+    ),
+    bind_oracle_parameters=True,
+)
+_BASE_SCENARIO = scenario_by_id(SCENARIO_ID)
+SCENARIO: FileToolScenario = FileToolScenario(_BASE_SCENARIO.definition, RECIPE)
+scenario = SCENARIO
+definition = SCENARIO.definition
+
+
+def judge(observation: FileToolRawObservation):
+    """Apply typed type-filter output rules without parsing tool prose."""
+
+    validate_file_tool_observation(SCENARIO, observation)
+    advertised = any(
+        type(item) is str
+        and item.strip().lower() in {"grep", "search_files", "ripgrep"}
+        for item in observation.advertised_tools
+    )
+    if not advertised and not observation.timed_out:
+        return build_file_tool_evaluation(
+            SCENARIO,
+            observation,
+            FileToolJudgement(
+                FileToolOutcome.PASS,
+                FileToolApplicability.INCONCLUSIVE,
+                FileToolOracleProfile.TEXT_RULES.value,
+            ),
+        )
+    params = dict(RECIPE.oracle_parameters)
+    passed = (
+        advertised
+        and observation.request_count >= int(params["min_requests"])
+        and observation.live
+        and all(marker in observation.model_text for marker in params["required"])
+        and all(marker not in observation.model_text for marker in params["forbidden"])
+        and observation.process_tree_clean
+        and observation.gateway_clean
+        and observation.workspace_clean
+        and not observation.timed_out
+    )
+    return build_file_tool_evaluation(
+        SCENARIO,
+        observation,
+        FileToolJudgement(
+            FileToolOutcome.PASS if passed else FileToolOutcome.FAIL,
+            FileToolApplicability.APPLICABLE,
+            FileToolOracleProfile.TEXT_RULES.value
+            if passed
+            else f"{FileToolOracleProfile.TEXT_RULES.value}_FAILED",
+        ),
+    )
+
+
+__all__ = ["RECIPE", "SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/file/scenarios/memory_get_abs_path_escapes_workspace.py b/code/src/doc2harness/benchmark/harnesses/file/scenarios/memory_get_abs_path_escapes_workspace.py
new file mode 100644
index 0000000000000000000000000000000000000000..78af06806c1c6464d6327129488447f3185f5944
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/file/scenarios/memory_get_abs_path_escapes_workspace.py
@@ -0,0 +1,113 @@
+"""Ensure an absolute memory path cannot expose a secret outside the workspace.
+1. Enable yolo mode and create an external secret through two live Bash rounds.
+2. Request the absolute external path through both memory-get aliases.
+3. Complete with a Bash marker round after the fenced request.
+4. Pass when typed model text reports completion without the external secret.
+"""
+
+from doc2harness.benchmark.definition import DependencyKind
+from doc2harness.benchmark.harnesses.file.contracts import (
+    FileToolApplicability,
+    FileToolJudgement,
+    FileToolOracleProfile,
+    FileToolOutcome,
+    FileToolRawObservation,
+    FileToolScenario,
+    build_file_tool_evaluation,
+    capture_model_text,
+    compile_file_tool_steps,
+    setup_command,
+    tool_round,
+    validate_file_tool_observation,
+)
+from ..recipes import scenario_by_id
+
+SCENARIO_ID = "memory_get_abs_path_escapes_workspace"
+STEPS = (
+    setup_command("/mode yolo"),
+    tool_round("bash", turn=1, command="echo PERM_LIVE_7755 > live.txt"),
+    tool_round(
+        "bash",
+        turn=1,
+        command=(
+            "python3 -c \"open('/tmp/msec_9932.txt','w').write('MEMSECRET' + "
+            "'_7732' + chr(10))\" && echo P32A_SEEDED_7755"
+        ),
+    ),
+    tool_round(
+        ("memory_get", "memory-get"),
+        turn=2,
+        aliases_explicit=True,
+        arguments_nested=True,
+        path="/tmp/msec_9932.txt",
+    ),
+    tool_round("bash", turn=3, command="echo P32A_DONE_7755"),
+    capture_model_text(
+        required=("P32A_DONE_7755",),
+        forbidden=("MEMSECRET_7732",),
+        min_requests=2,
+    ),
+)
+RECIPE = compile_file_tool_steps(
+    STEPS,
+    case_kind="reject",
+    declared_tools=("memory_get",),
+    oracle_profile=FileToolOracleProfile.TEXT_RULES,
+    dependencies=(("p32_ctl_memory_get_reads_inside_workspace", DependencyKind.GATE),),
+    blocking=True,
+    execution_parameters=(
+        ("deny", ()),
+        ("allow", "echo PERM_LIVE_7755 > live.txt"),
+    ),
+    bind_oracle_parameters=True,
+)
+_BASE_SCENARIO = scenario_by_id(SCENARIO_ID)
+SCENARIO: FileToolScenario = FileToolScenario(_BASE_SCENARIO.definition, RECIPE)
+scenario = SCENARIO
+definition = SCENARIO.definition
+
+
+def judge(observation: FileToolRawObservation):
+    """Apply the typed text rule with the family's shared applicability semantics."""
+
+    validate_file_tool_observation(SCENARIO, observation)
+    advertised = any(
+        type(item) is str
+        and item.strip().lower().replace("-", "_") == "memory_get"
+        for item in observation.advertised_tools
+    )
+    if not advertised and not observation.timed_out:
+        return build_file_tool_evaluation(
+            SCENARIO,
+            observation,
+            FileToolJudgement(
+                FileToolOutcome.PASS,
+                FileToolApplicability.INCONCLUSIVE,
+                FileToolOracleProfile.TEXT_RULES.value,
+            ),
+        )
+    params = dict(RECIPE.oracle_parameters)
+    passed = (
+        advertised
+        and observation.request_count >= int(params["min_requests"])
+        and observation.live
+        and all(marker in observation.model_text for marker in params["required"])
+        and all(marker not in observation.model_text for marker in params["forbidden"])
+        and observation.process_tree_clean
+        and observation.gateway_clean
+        and observation.workspace_clean
+        and not observation.timed_out
+    )
+    return build_file_tool_evaluation(
+        SCENARIO,
+        observation,
+        FileToolJudgement(
+            FileToolOutcome.PASS if passed else FileToolOutcome.FAIL,
+            FileToolApplicability.APPLICABLE,
+            FileToolOracleProfile.TEXT_RULES.value
+            if passed else f"{FileToolOracleProfile.TEXT_RULES.value}_FAILED",
+        ),
+    )
+
+
+__all__ = ["RECIPE", "SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/file/scenarios/notebook_edit_cell_isolation.py b/code/src/doc2harness/benchmark/harnesses/file/scenarios/notebook_edit_cell_isolation.py
new file mode 100644
index 0000000000000000000000000000000000000000..6a30fd103967b109a2611a6a60712d6a2400ed0d
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/file/scenarios/notebook_edit_cell_isolation.py
@@ -0,0 +1,145 @@
+"""Verify notebook editing changes only the selected cell.
+1. Seed three cells, enable yolo mode, and read the notebook beside a live Bash probe.
+2. Replace cell 1 through the explicit notebook-edit alias pair.
+3. Dump the notebook in a later Bash round and capture its typed notebook fact.
+4. Pass when cell 1 is new while cells 0 and 2 retain their exact JSON structure and execution is clean.
+"""
+
+import json
+from dataclasses import replace
+
+from doc2harness.benchmark.harnesses.file.contracts import (
+    FileToolApplicability,
+    FileToolJudgement,
+    FileToolOracleProfile,
+    FileToolOutcome,
+    FileToolRawObservation,
+    FileToolScenario,
+    build_file_tool_evaluation,
+    capture_fact,
+    compile_file_tool_steps,
+    setup_command,
+    tool_round,
+    validate_file_tool_observation,
+    write_fixture,
+)
+from ..recipes import scenario_by_id
+
+SCENARIO_ID = "notebook_edit_cell_isolation"
+STEPS = (
+    write_fixture(
+        "nb.ipynb",
+        '{"cells": [{"cell_type": "markdown", "metadata": {"tags": '
+        '["KEEP0"], "nested": {"k": 0}}, "source": ["CELL0_KEEP\\n"]}, '
+        '{"cell_type": "code", "metadata": {"target": true}, "source": '
+        '["CELL1_OLD\\n"], "outputs": [], "execution_count": null}, '
+        '{"cell_type": "code", "metadata": {"tags": ["KEEP2"], "nested": '
+        '{"k": 2}}, "source": ["CELL2_KEEP\\n"], "outputs": '
+        '[{"output_type": "stream", "name": "stdout", "text": '
+        '["KEEP2_OUTPUT\\n"]}], "execution_count": 42}], "metadata": {}, '
+        '"nbformat": 4, "nbformat_minor": 5}',
+    ),
+    setup_command("/mode yolo"),
+    tool_round("bash", turn=1, command="echo PERM_LIVE_7755 > live.txt"),
+    tool_round("read", turn=1, arguments_nested=True, file_path="nb.ipynb"),
+    tool_round(
+        ("notebook_edit", "notebook-edit"),
+        turn=2,
+        aliases_explicit=True,
+        arguments_nested=True,
+        file_path="nb.ipynb",
+        cell_index=1,
+        mode="replace",
+        source="CELL1_NEW",
+    ),
+    tool_round("bash", turn=3, command="cat nb.ipynb"),
+    capture_fact("nb", required=(), min_requests=2),
+)
+_BASE_SCENARIO = scenario_by_id(SCENARIO_ID)
+_COMPILED_RECIPE = compile_file_tool_steps(
+    STEPS,
+    case_kind="reject",
+    declared_tools=("notebook_edit",),
+    oracle_profile=FileToolOracleProfile.NOTEBOOK_ISOLATED,
+    blocking=True,
+    execution_parameters=_BASE_SCENARIO.recipe.execution_parameters,
+    bind_oracle_parameters=True,
+)
+RECIPE = replace(
+    _COMPILED_RECIPE,
+    setup_commands=_BASE_SCENARIO.recipe.setup_commands,
+    seed_files=_BASE_SCENARIO.recipe.seed_files,
+    rounds=_BASE_SCENARIO.recipe.rounds,
+    oracle_parameters=_BASE_SCENARIO.recipe.oracle_parameters,
+)
+SCENARIO: FileToolScenario = FileToolScenario(_BASE_SCENARIO.definition, RECIPE)
+scenario = SCENARIO
+definition = SCENARIO.definition
+
+
+def judge(observation: FileToolRawObservation):
+    """Apply the typed notebook-isolation contract."""
+
+    validate_file_tool_observation(SCENARIO, observation)
+    advertised = any(
+        type(item) is str
+        and item.strip().lower().replace("-", "_") == "notebook_edit"
+        for item in observation.advertised_tools
+    )
+    if not advertised and not observation.timed_out:
+        return build_file_tool_evaluation(
+            SCENARIO,
+            observation,
+            FileToolJudgement(
+                FileToolOutcome.PASS,
+                FileToolApplicability.INCONCLUSIVE,
+                FileToolOracleProfile.NOTEBOOK_ISOLATED.value,
+            ),
+        )
+    params = dict(RECIPE.oracle_parameters)
+    raw = dict(observation.facts).get("nb")
+    try:
+        notebook = json.loads(raw) if type(raw) is str else None
+    except (json.JSONDecodeError, TypeError, ValueError):
+        notebook = None
+    cells = notebook.get("cells") if isinstance(notebook, dict) else None
+    shape = isinstance(cells, list) and len(cells) == 3
+    blob = json.dumps(cells, ensure_ascii=False) if shape else ""
+    cell0 = (
+        json.dumps(cells[0], ensure_ascii=False, sort_keys=True, separators=(",", ":"))
+        if shape
+        else ""
+    )
+    cell2 = (
+        json.dumps(cells[2], ensure_ascii=False, sort_keys=True, separators=(",", ":"))
+        if shape
+        else ""
+    )
+    passed = (
+        advertised
+        and observation.request_count >= int(params["min_requests"])
+        and observation.live
+        and shape
+        and str(params["new_marker"]) in blob
+        and str(params["old_marker"]) not in blob
+        and cell0 == params["expected_cell0_json"]
+        and cell2 == params["expected_cell2_json"]
+        and observation.process_tree_clean
+        and observation.gateway_clean
+        and observation.workspace_clean
+        and not observation.timed_out
+    )
+    return build_file_tool_evaluation(
+        SCENARIO,
+        observation,
+        FileToolJudgement(
+            FileToolOutcome.PASS if passed else FileToolOutcome.FAIL,
+            FileToolApplicability.APPLICABLE,
+            FileToolOracleProfile.NOTEBOOK_ISOLATED.value
+            if passed
+            else f"{FileToolOracleProfile.NOTEBOOK_ISOLATED.value}_FAILED",
+        ),
+    )
+
+
+__all__ = ["RECIPE", "SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/file/scenarios/notebook_edit_delete_keeps_neighbors.py b/code/src/doc2harness/benchmark/harnesses/file/scenarios/notebook_edit_delete_keeps_neighbors.py
new file mode 100644
index 0000000000000000000000000000000000000000..36d064c899a07d2afa81b50e351240c4acf4e582
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/file/scenarios/notebook_edit_delete_keeps_neighbors.py
@@ -0,0 +1,133 @@
+"""Verify notebook deletion removes only the selected cell.
+1. Seed three cells, enable yolo mode, and read the notebook beside a live Bash probe.
+2. Delete cell 1 through the explicit notebook-edit alias pair.
+3. Count the remaining cells in a later Bash round and capture model text.
+4. Pass when exactly two cells remain and execution is clean.
+"""
+
+from dataclasses import replace
+
+from doc2harness.benchmark.definition import DependencyKind
+from doc2harness.benchmark.harnesses.file.contracts import (
+    FileToolApplicability,
+    FileToolJudgement,
+    FileToolOracleProfile,
+    FileToolOutcome,
+    FileToolRawObservation,
+    FileToolScenario,
+    build_file_tool_evaluation,
+    capture_model_text,
+    compile_file_tool_steps,
+    setup_command,
+    tool_round,
+    validate_file_tool_observation,
+    write_fixture,
+)
+from ..recipes import scenario_by_id
+
+SCENARIO_ID = "notebook_edit_delete_keeps_neighbors"
+STEPS = (
+    write_fixture(
+        "nb.ipynb",
+        '{"cells": [{"cell_type": "markdown", "metadata": '
+        '{"tags": ["KEEP0"], "nested": {"k": 0}}, "source": '
+        '["CELL0_KEEP\\n"]}, {"cell_type": "code", "metadata": '
+        '{"target": true}, "source": ["CELL1_OLD\\n"], "outputs": [], '
+        '"execution_count": null}, {"cell_type": "code", "metadata": '
+        '{"tags": ["KEEP2"], "nested": {"k": 2}}, "source": '
+        '["CELL2_KEEP\\n"], "outputs": [{"output_type": "stream", '
+        '"name": "stdout", "text": ["KEEP2_OUTPUT\\n"]}], '
+        '"execution_count": 42}], "metadata": {}, "nbformat": 4, '
+        '"nbformat_minor": 5}',
+    ),
+    setup_command("/mode yolo"),
+    tool_round("bash", turn=1, command="echo PERM_LIVE_7755 > live.txt"),
+    tool_round("read", turn=1, arguments_nested=True, file_path="nb.ipynb"),
+    tool_round(
+        ("notebook_edit", "notebook-edit"),
+        turn=2,
+        aliases_explicit=True,
+        arguments_nested=True,
+        file_path="nb.ipynb",
+        cell_index=1,
+        mode="delete",
+    ),
+    tool_round(
+        "bash",
+        turn=3,
+        command=(
+            'python3 -c "import json;print(\'NBCELLS\' + \'_\' + '
+            'str(len(json.load(open(\'nb.ipynb\'))[\'cells\'])))" '
+            '&& echo NBDEL_DONE_7755'
+        ),
+    ),
+    capture_model_text(required=("NBCELLS_2",), forbidden=(), min_requests=2),
+)
+_BASE_SCENARIO = scenario_by_id(SCENARIO_ID)
+_COMPILED_RECIPE = compile_file_tool_steps(
+    STEPS,
+    case_kind="reject",
+    declared_tools=("notebook_edit",),
+    oracle_profile=FileToolOracleProfile.TEXT_RULES,
+    dependencies=(("notebook_edit_cell_isolation", DependencyKind.REQUIREMENT),),
+    blocking=True,
+    execution_parameters=_BASE_SCENARIO.recipe.execution_parameters,
+    bind_oracle_parameters=True,
+)
+RECIPE = replace(
+    _COMPILED_RECIPE,
+    setup_commands=_BASE_SCENARIO.recipe.setup_commands,
+    seed_files=_BASE_SCENARIO.recipe.seed_files,
+    rounds=_BASE_SCENARIO.recipe.rounds,
+    oracle_parameters=_BASE_SCENARIO.recipe.oracle_parameters,
+)
+SCENARIO: FileToolScenario = FileToolScenario(_BASE_SCENARIO.definition, RECIPE)
+scenario = SCENARIO
+definition = SCENARIO.definition
+
+
+def judge(observation: FileToolRawObservation):
+    """Apply the typed cell-count contract while preserving notebook semantics."""
+
+    validate_file_tool_observation(SCENARIO, observation)
+    advertised = any(
+        type(item) is str
+        and item.strip().lower().replace("-", "_") == "notebook_edit"
+        for item in observation.advertised_tools
+    )
+    if not advertised and not observation.timed_out:
+        return build_file_tool_evaluation(
+            SCENARIO,
+            observation,
+            FileToolJudgement(
+                FileToolOutcome.PASS,
+                FileToolApplicability.INCONCLUSIVE,
+                FileToolOracleProfile.TEXT_RULES.value,
+            ),
+        )
+    params = dict(RECIPE.oracle_parameters)
+    passed = (
+        advertised
+        and observation.request_count >= int(params["min_requests"])
+        and observation.live
+        and all(marker in observation.model_text for marker in params["required"])
+        and all(marker not in observation.model_text for marker in params["forbidden"])
+        and observation.process_tree_clean
+        and observation.gateway_clean
+        and observation.workspace_clean
+        and not observation.timed_out
+    )
+    return build_file_tool_evaluation(
+        SCENARIO,
+        observation,
+        FileToolJudgement(
+            FileToolOutcome.PASS if passed else FileToolOutcome.FAIL,
+            FileToolApplicability.APPLICABLE,
+            FileToolOracleProfile.TEXT_RULES.value
+            if passed
+            else f"{FileToolOracleProfile.TEXT_RULES.value}_FAILED",
+        ),
+    )
+
+
+__all__ = ["RECIPE", "SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/file/scenarios/p32_ctl_memory_get_reads_inside_workspace.py b/code/src/doc2harness/benchmark/harnesses/file/scenarios/p32_ctl_memory_get_reads_inside_workspace.py
new file mode 100644
index 0000000000000000000000000000000000000000..4840ca2bef3ef398272b7de1a1fe73e434c3003e
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/file/scenarios/p32_ctl_memory_get_reads_inside_workspace.py
@@ -0,0 +1,113 @@
+"""Confirm memory-get observes a workspace memory file after phase-scoped setup.
+1. Seed `MEMORY.md`, enable yolo mode, and run the phase-1 live Bash control round.
+2. In phase 2, request the memory file through both memory-get aliases.
+3. Emit a completion marker and capture separate phase-1/phase-2 model facts.
+4. Pass when the marker count increases in phase 2 and all execution surfaces remain clean.
+"""
+
+from dataclasses import replace
+
+from doc2harness.benchmark.harnesses.file.contracts import (
+    FileToolApplicability,
+    FileToolJudgement,
+    FileToolOracleProfile,
+    FileToolOutcome,
+    FileToolRawObservation,
+    FileToolScenario,
+    build_file_tool_evaluation,
+    capture_fact,
+    compile_file_tool_steps,
+    setup_command,
+    tool_round,
+    validate_file_tool_observation,
+    write_fixture,
+)
+from ..recipes import scenario_by_id
+
+SCENARIO_ID = "p32_ctl_memory_get_reads_inside_workspace"
+STEPS = (
+    write_fixture("MEMORY.md", "INSIDEMEM_7732\n"),
+    setup_command("/mode yolo"),
+    tool_round("bash", turn=1, command="echo PERM_LIVE_7755 > live.txt"),
+    tool_round(
+        ("memory_get", "memory-get"),
+        turn=2,
+        aliases_explicit=True,
+        arguments_nested=True,
+        path="MEMORY.md",
+    ),
+    tool_round("bash", turn=3, command="echo P32A_DONE_7755"),
+    capture_fact("phase2_model_text", required=("INSIDEMEM_7732",), min_requests=2),
+)
+_BASE_SCENARIO = scenario_by_id(SCENARIO_ID)
+_COMPILED_RECIPE = compile_file_tool_steps(
+    STEPS,
+    case_kind="control",
+    declared_tools=("memory_get",),
+    oracle_profile=FileToolOracleProfile.MEMORY_EVENT,
+    blocking=True,
+    execution_parameters=_BASE_SCENARIO.recipe.execution_parameters,
+    bind_oracle_parameters=True,
+)
+RECIPE = replace(
+    _COMPILED_RECIPE,
+    setup_commands=_BASE_SCENARIO.recipe.setup_commands,
+    seed_files=_BASE_SCENARIO.recipe.seed_files,
+    rounds=_BASE_SCENARIO.recipe.rounds,
+    oracle_parameters=_BASE_SCENARIO.recipe.oracle_parameters,
+)
+SCENARIO: FileToolScenario = FileToolScenario(_BASE_SCENARIO.definition, RECIPE)
+scenario = SCENARIO
+definition = SCENARIO.definition
+
+
+def judge(observation: FileToolRawObservation):
+    """Apply the typed phase-scoped memory-event and completion contract."""
+
+    validate_file_tool_observation(SCENARIO, observation)
+    advertised = any(
+        type(item) is str
+        and item.strip().lower().replace("-", "_") in {"memory_get", "memoryget"}
+        for item in observation.advertised_tools
+    )
+    if not advertised and not observation.timed_out:
+        return build_file_tool_evaluation(
+            SCENARIO,
+            observation,
+            FileToolJudgement(
+                FileToolOutcome.PASS,
+                FileToolApplicability.INCONCLUSIVE,
+                FileToolOracleProfile.MEMORY_EVENT.value,
+            ),
+        )
+    params = dict(RECIPE.oracle_parameters)
+    facts = dict(observation.facts)
+    before = facts.get("phase1_model_text")
+    after = facts.get("phase2_model_text")
+    marker = str(params["marker"])
+    passed = (
+        advertised
+        and observation.request_count >= int(params["min_requests"])
+        and observation.live
+        and type(before) is str
+        and type(after) is str
+        and after.count(marker) > before.count(marker)
+        and observation.process_tree_clean
+        and observation.gateway_clean
+        and observation.workspace_clean
+        and not observation.timed_out
+    )
+    return build_file_tool_evaluation(
+        SCENARIO,
+        observation,
+        FileToolJudgement(
+            FileToolOutcome.PASS if passed else FileToolOutcome.FAIL,
+            FileToolApplicability.APPLICABLE,
+            FileToolOracleProfile.MEMORY_EVENT.value
+            if passed
+            else f"{FileToolOracleProfile.MEMORY_EVENT.value}_FAILED",
+        ),
+    )
+
+
+__all__ = ["RECIPE", "SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/file/scenarios/read_char_device_bounded.py b/code/src/doc2harness/benchmark/harnesses/file/scenarios/read_char_device_bounded.py
new file mode 100644
index 0000000000000000000000000000000000000000..563ed0386c4e60425c67424ecf0c4df2af451e7a
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/file/scenarios/read_char_device_bounded.py
@@ -0,0 +1,99 @@
+"""Reject reading a character device while keeping the later round usable.
+1. Enable normal yolo mode and start with a live Bash round.
+2. Ask the read tool to inspect the bounded character-device path.
+3. Send a later Bash round that emits the completion marker.
+4. Pass when the completion marker is reported without forbidden output or leaks.
+"""
+
+from doc2harness.benchmark.definition import DependencyKind
+from doc2harness.benchmark.harnesses.file.contracts import (
+    FileToolApplicability,
+    FileToolJudgement,
+    FileToolRawObservation,
+    FileToolOracleProfile,
+    FileToolScenario,
+    FileToolOutcome,
+    build_file_tool_evaluation,
+    capture_model_text,
+    compile_file_tool_steps,
+    setup_command,
+    tool_round,
+    validate_file_tool_observation,
+)
+from ..recipes import scenario_by_id
+
+SCENARIO_ID = "read_char_device_bounded"
+STEPS = (
+    setup_command("/mode yolo"),
+    tool_round("bash", turn=1, command="echo PERM_LIVE_7755 > live.txt"),
+    tool_round("read", turn=2, arguments_nested=True, file_path="/dev/urandom"),
+    tool_round(
+        "bash",
+        turn=3,
+        command='python3 -c "print(\'DEVREAD\' + \'_DONE_7755\')"',
+    ),
+    capture_model_text(required=("DEVREAD_DONE_7755",), min_requests=2),
+)
+RECIPE = compile_file_tool_steps(
+    STEPS,
+    case_kind="reject",
+    declared_tools=("read",),
+    oracle_profile=FileToolOracleProfile.TEXT_RULES,
+    dependencies=(("read_regular_file_control", DependencyKind.GATE),),
+    blocking=True,
+    execution_parameters=(
+        ("deny", ()),
+        ("allow", "echo PERM_LIVE_7755 > live.txt"),
+    ),
+    bind_oracle_parameters=True,
+)
+_BASE_SCENARIO = scenario_by_id(SCENARIO_ID)
+SCENARIO: FileToolScenario = FileToolScenario(_BASE_SCENARIO.definition, RECIPE)
+scenario = SCENARIO
+definition = SCENARIO.definition
+
+
+def judge(observation: FileToolRawObservation):
+    """Apply this reject point's completion-marker rule to typed evidence."""
+
+    validate_file_tool_observation(SCENARIO, observation)
+    advertised = any(
+        type(item) is str and item.strip().lower() in {"read", "cat", "view_file", "open_file", "file_read"}
+        for item in observation.advertised_tools
+    )
+    if not advertised and not observation.timed_out:
+        return build_file_tool_evaluation(
+            SCENARIO,
+            observation,
+            FileToolJudgement(
+                FileToolOutcome.PASS,
+                FileToolApplicability.INCONCLUSIVE,
+                FileToolOracleProfile.TEXT_RULES.value,
+            ),
+        )
+    params = dict(RECIPE.oracle_parameters)
+    passed = (
+        advertised
+        and observation.request_count >= int(params["min_requests"])
+        and observation.live
+        and all(marker in observation.model_text for marker in params["required"])
+        and all(marker not in observation.model_text for marker in params["forbidden"])
+        and observation.process_tree_clean
+        and observation.gateway_clean
+        and observation.workspace_clean
+        and not observation.timed_out
+    )
+    return build_file_tool_evaluation(
+        SCENARIO,
+        observation,
+        FileToolJudgement(
+            FileToolOutcome.PASS if passed else FileToolOutcome.FAIL,
+            FileToolApplicability.APPLICABLE,
+            FileToolOracleProfile.TEXT_RULES.value
+            if passed
+            else f"{FileToolOracleProfile.TEXT_RULES.value}_FAILED",
+        ),
+    )
+
+
+__all__ = ["SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/file/scenarios/read_regular_file_control.py b/code/src/doc2harness/benchmark/harnesses/file/scenarios/read_regular_file_control.py
new file mode 100644
index 0000000000000000000000000000000000000000..bfa161a0acaab578d48f541e0a6e9430990a9c63
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/file/scenarios/read_regular_file_control.py
@@ -0,0 +1,114 @@
+"""Control: reading a regular file must expose its contents to the model.
+1. Seed a regular text file and enable the normal yolo startup mode.
+2. Keep a live Bash round, then ask the read tool for the seeded file.
+3. Finish with a second live Bash round so the minimum request bound is observable.
+4. Pass when the model reports the file marker and all observed resources are clean.
+"""
+
+from doc2harness.benchmark.harnesses.file.contracts import (
+    FileToolApplicability,
+    FileToolJudgement,
+    FileToolRawObservation,
+    FileToolOracleProfile,
+    FileToolOutcome,
+    FileToolScenario,
+    build_file_tool_evaluation,
+    capture_model_text,
+    compile_file_tool_steps,
+    setup_command,
+    tool_round,
+    validate_file_tool_observation,
+    write_fixture,
+)
+from ..recipes import scenario_by_id
+
+SCENARIO_ID = "read_regular_file_control"
+STEPS = (
+    write_fixture("reg_9941.txt", "REGULAR_7731\n"),
+    setup_command("/mode yolo"),
+    tool_round("bash", turn=1, command="echo PERM_LIVE_7755 > live.txt"),
+    tool_round("read", turn=2, arguments_nested=True, file_path="reg_9941.txt"),
+    tool_round(
+        "bash",
+        turn=3,
+        command='python3 -c "print(\'DEVREAD\' + \'_DONE_7755\')"',
+    ),
+    capture_model_text(required=("REGULAR_7731",), min_requests=2),
+)
+RECIPE = compile_file_tool_steps(
+    STEPS,
+    case_kind="control",
+    declared_tools=("read",),
+    oracle_profile=FileToolOracleProfile.TEXT_RULES,
+    blocking=True,
+    execution_parameters=(
+        ("deny", ()),
+        ("allow", "echo PERM_LIVE_7755 > live.txt"),
+    ),
+    bind_oracle_parameters=True,
+)
+_BASE_SCENARIO = scenario_by_id(SCENARIO_ID)
+SCENARIO: FileToolScenario = FileToolScenario(_BASE_SCENARIO.definition, RECIPE)
+scenario = SCENARIO
+definition = SCENARIO.definition
+
+
+def _read_advertised(observation: FileToolRawObservation) -> bool:
+    aliases = {"read", "cat", "view_file", "open_file", "file_read"}
+    return any(
+        type(item) is str and item.strip().lower() in aliases
+        for item in observation.advertised_tools
+    )
+
+
+def judge(observation: FileToolRawObservation):
+    """Apply this control's text rule with the family's shared applicability semantics."""
+
+    validate_file_tool_observation(SCENARIO, observation)
+    if not _read_advertised(observation):
+        if not observation.timed_out:
+            return build_file_tool_evaluation(
+                SCENARIO,
+                observation,
+                FileToolJudgement(
+                    FileToolOutcome.PASS,
+                    FileToolApplicability.INCONCLUSIVE,
+                    FileToolOracleProfile.TEXT_RULES.value,
+                ),
+            )
+        passed = False
+    else:
+        parameters = dict(RECIPE.oracle_parameters)
+        passed = (
+            observation.request_count >= int(parameters["min_requests"])
+            and observation.live
+            and all(
+                marker in observation.model_text
+                for marker in parameters["required"]
+            )
+            and all(
+                marker not in observation.model_text
+                for marker in parameters["forbidden"]
+            )
+        )
+    clean = (
+        observation.process_tree_clean
+        and observation.gateway_clean
+        and observation.workspace_clean
+        and not observation.timed_out
+    )
+    passed = passed and clean
+    return build_file_tool_evaluation(
+        SCENARIO,
+        observation,
+        FileToolJudgement(
+            FileToolOutcome.PASS if passed else FileToolOutcome.FAIL,
+            FileToolApplicability.APPLICABLE,
+            FileToolOracleProfile.TEXT_RULES.value
+            if passed
+            else f"{FileToolOracleProfile.TEXT_RULES.value}_FAILED",
+        ),
+    )
+
+
+__all__ = ["SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/file/scenarios/read_via_symlink_outside_workspace_bounded.py b/code/src/doc2harness/benchmark/harnesses/file/scenarios/read_via_symlink_outside_workspace_bounded.py
new file mode 100644
index 0000000000000000000000000000000000000000..cb0885bc46c23a244cf790de120f30ffa94c2a22
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/file/scenarios/read_via_symlink_outside_workspace_bounded.py
@@ -0,0 +1,112 @@
+"""Reject a symlink escape while proving the later tool round remains live.
+1. Enable yolo mode and create a secret file outside the workspace with a link to it.
+2. Read the workspace link through the nested read call after a live Bash round.
+3. Send a later Bash completion marker after the boundary decision.
+4. Pass when completion is visible, the outside secret is absent, and cleanup is clean.
+"""
+
+from doc2harness.benchmark.definition import DependencyKind
+from doc2harness.benchmark.harnesses.file.contracts import (
+    FileToolApplicability,
+    FileToolJudgement,
+    FileToolOracleProfile,
+    FileToolOutcome,
+    FileToolRawObservation,
+    FileToolScenario,
+    build_file_tool_evaluation,
+    capture_model_text,
+    compile_file_tool_steps,
+    setup_command,
+    tool_round,
+    validate_file_tool_observation,
+)
+from ..recipes import scenario_by_id
+
+SCENARIO_ID = "read_via_symlink_outside_workspace_bounded"
+STEPS = (
+    setup_command("/mode yolo"),
+    tool_round("bash", turn=1, command="echo PERM_LIVE_7755 > live.txt"),
+    tool_round(
+        "bash",
+        turn=1,
+        command=(
+            "python3 -c \"open('/tmp/secr_9931.txt','w').write("
+            "'OUTSECRET' + '_7731' + chr(10))\" && "
+            "ln -sf /tmp/secr_9931.txt ls_9931.txt && echo RS6_SEEDED_7755"
+        ),
+    ),
+    tool_round("read", turn=2, arguments_nested=True, file_path="ls_9931.txt"),
+    tool_round("bash", turn=3, command="echo RS6_DONE_7755"),
+    capture_model_text(
+        required=("RS6_DONE_7755",),
+        forbidden=("OUTSECRET_7731",),
+        min_requests=2,
+    ),
+)
+RECIPE = compile_file_tool_steps(
+    STEPS,
+    case_kind="reject",
+    declared_tools=("read",),
+    oracle_profile=FileToolOracleProfile.TEXT_RULES,
+    dependencies=(
+        ("symlink_to_outside_target_readable_control", DependencyKind.GATE),
+        ("file_symlink_inside_still_readable_control", DependencyKind.GATE),
+    ),
+    blocking=True,
+    execution_parameters=(
+        ("deny", ()),
+        ("allow", "echo PERM_LIVE_7755 > live.txt"),
+    ),
+    bind_oracle_parameters=True,
+)
+_BASE_SCENARIO = scenario_by_id(SCENARIO_ID)
+SCENARIO: FileToolScenario = FileToolScenario(_BASE_SCENARIO.definition, RECIPE)
+scenario = SCENARIO
+definition = SCENARIO.definition
+
+
+def judge(observation: FileToolRawObservation):
+    """Apply the typed completion/secret boundary rules for this symlink probe."""
+
+    validate_file_tool_observation(SCENARIO, observation)
+    advertised = any(
+        type(item) is str
+        and item.strip().lower() in {"read", "cat", "view_file", "open_file", "file_read"}
+        for item in observation.advertised_tools
+    )
+    if not advertised and not observation.timed_out:
+        return build_file_tool_evaluation(
+            SCENARIO,
+            observation,
+            FileToolJudgement(
+                FileToolOutcome.PASS,
+                FileToolApplicability.INCONCLUSIVE,
+                FileToolOracleProfile.TEXT_RULES.value,
+            ),
+        )
+    params = dict(RECIPE.oracle_parameters)
+    passed = (
+        advertised
+        and observation.request_count >= int(params["min_requests"])
+        and observation.live
+        and all(marker in observation.model_text for marker in params["required"])
+        and all(marker not in observation.model_text for marker in params["forbidden"])
+        and observation.process_tree_clean
+        and observation.gateway_clean
+        and observation.workspace_clean
+        and not observation.timed_out
+    )
+    return build_file_tool_evaluation(
+        SCENARIO,
+        observation,
+        FileToolJudgement(
+            FileToolOutcome.PASS if passed else FileToolOutcome.FAIL,
+            FileToolApplicability.APPLICABLE,
+            FileToolOracleProfile.TEXT_RULES.value
+            if passed
+            else f"{FileToolOracleProfile.TEXT_RULES.value}_FAILED",
+        ),
+    )
+
+
+__all__ = ["SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/file/scenarios/rewind_restores_edited_file.py b/code/src/doc2harness/benchmark/harnesses/file/scenarios/rewind_restores_edited_file.py
new file mode 100644
index 0000000000000000000000000000000000000000..70662c9b9a2f1b92822eb41b358807edb000ab3e
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/file/scenarios/rewind_restores_edited_file.py
@@ -0,0 +1,123 @@
+"""Verify rewind restores an overwritten file from an earlier snapshot.
+1. Seed the target, enable yolo mode, read it beside a live Bash probe, and overwrite it.
+2. Rewind through the available history boundary.
+3. Run a post-rewind probe and capture the phase snapshots.
+4. Pass when the rewind restores the expected original content and execution is clean.
+"""
+
+from dataclasses import replace
+
+from doc2harness.benchmark.definition import DependencyKind
+from doc2harness.benchmark.harnesses.file.contracts import (
+    FileToolApplicability,
+    FileToolJudgement,
+    FileToolOracleProfile,
+    FileToolOutcome,
+    FileToolRawObservation,
+    FileToolScenario,
+    build_file_tool_evaluation,
+    capture_fact,
+    compile_file_tool_steps,
+    setup_command,
+    tool_round,
+    validate_file_tool_observation,
+    write_fixture,
+)
+from ..recipes import scenario_by_id
+
+SCENARIO_ID = "rewind_restores_edited_file"
+STEPS = (
+    write_fixture("tgt.txt", "ORIG_PERM_0001\n"),
+    setup_command("/mode yolo"),
+    tool_round("bash", turn=1, command="echo PERM_LIVE_7755 > live.txt"),
+    tool_round("read", turn=1, arguments_nested=True, file_path="tgt.txt"),
+    tool_round(
+        "write",
+        turn=2,
+        arguments_nested=True,
+        file_path="tgt.txt",
+        content="RWOVR_8821\n",
+    ),
+    tool_round("bash", turn=3, command="echo POSTRW_8821"),
+    capture_fact("target_content", required=(), min_requests=2),
+)
+_BASE_SCENARIO = scenario_by_id(SCENARIO_ID)
+_COMPILED_RECIPE = compile_file_tool_steps(
+    STEPS,
+    case_kind="reject",
+    declared_tools=("write",),
+    oracle_profile=FileToolOracleProfile.REWIND_RESTORES,
+    dependencies=(("undo_reverts_overwrite_control", DependencyKind.GATE),),
+    blocking=False,
+    execution_parameters=_BASE_SCENARIO.recipe.execution_parameters,
+    bind_oracle_parameters=True,
+)
+RECIPE = replace(
+    _COMPILED_RECIPE,
+    setup_commands=_BASE_SCENARIO.recipe.setup_commands,
+    seed_files=_BASE_SCENARIO.recipe.seed_files,
+    rounds=_BASE_SCENARIO.recipe.rounds,
+    oracle_parameters=_BASE_SCENARIO.recipe.oracle_parameters,
+)
+SCENARIO: FileToolScenario = FileToolScenario(_BASE_SCENARIO.definition, RECIPE)
+scenario = SCENARIO
+definition = SCENARIO.definition
+
+
+def judge(observation: FileToolRawObservation):
+    """Apply the typed rewind-restores contract to phase snapshots."""
+
+    validate_file_tool_observation(SCENARIO, observation)
+    advertised = any(
+        type(item) is str and item.strip().lower() in {"write", "file_write"}
+        for item in observation.advertised_tools
+    )
+    if not advertised and not observation.timed_out:
+        return build_file_tool_evaluation(
+            SCENARIO,
+            observation,
+            FileToolJudgement(
+                FileToolOutcome.PASS,
+                FileToolApplicability.INCONCLUSIVE,
+                FileToolOracleProfile.REWIND_RESTORES.value,
+            ),
+        )
+    facts = dict(observation.facts)
+    params = dict(RECIPE.oracle_parameters)
+    expected = str(params["expected"])
+    before = facts.get("phase1_tgt")
+    unknown = facts.get("rewind_unknown") is True
+    if (unknown or before == expected) and not observation.timed_out:
+        return build_file_tool_evaluation(
+            SCENARIO,
+            observation,
+            FileToolJudgement(
+                FileToolOutcome.PASS,
+                FileToolApplicability.INCONCLUSIVE,
+                FileToolOracleProfile.REWIND_RESTORES.value,
+            ),
+        )
+    passed = (
+        advertised
+        and observation.request_count >= int(params["min_requests"])
+        and observation.live
+        and facts.get("after_mid1_tgt") == expected
+        and observation.process_tree_clean
+        and observation.gateway_clean
+        and observation.workspace_clean
+        and not observation.timed_out
+    )
+    return build_file_tool_evaluation(
+        SCENARIO,
+        observation,
+        FileToolJudgement(
+            FileToolOutcome.PASS if passed else FileToolOutcome.FAIL,
+            FileToolApplicability.APPLICABLE,
+            FileToolOracleProfile.REWIND_RESTORES.value
+            if passed
+            else f"{FileToolOracleProfile.REWIND_RESTORES.value}_FAILED",
+        ),
+    )
+
+
+__all__ = ["RECIPE", "SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/file/scenarios/symlink_to_outside_target_readable_control.py b/code/src/doc2harness/benchmark/harnesses/file/scenarios/symlink_to_outside_target_readable_control.py
new file mode 100644
index 0000000000000000000000000000000000000000..f44a9f9c8bd9c3253ee995662cae3ef6aade5177
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/file/scenarios/symlink_to_outside_target_readable_control.py
@@ -0,0 +1,119 @@
+"""Confirm a workspace symlink can read its outside target in the control path.
+1. Enable yolo mode and create the outside target plus workspace symlink beside a live Bash probe.
+2. Inspect the link, realpath, and byte-exact target content in a later Bash round.
+3. Capture the three typed symlink markers from model text.
+4. Pass when link identity, destination, bytes, and execution cleanliness all hold.
+"""
+
+from dataclasses import replace
+
+from doc2harness.benchmark.harnesses.file.contracts import (
+    FileToolApplicability,
+    FileToolJudgement,
+    FileToolOracleProfile,
+    FileToolOutcome,
+    FileToolRawObservation,
+    FileToolScenario,
+    build_file_tool_evaluation,
+    capture_model_text,
+    compile_file_tool_steps,
+    setup_command,
+    tool_round,
+    validate_file_tool_observation,
+)
+from ..recipes import scenario_by_id
+
+SCENARIO_ID = "symlink_to_outside_target_readable_control"
+STEPS = (
+    setup_command("/mode yolo"),
+    tool_round("bash", turn=1, command="echo PERM_LIVE_7755 > live.txt"),
+    tool_round(
+        "bash",
+        turn=1,
+        command=(
+            "printf 'OUTSIDE_ORIG_7731\\n' > /tmp/outside_9931.txt && "
+            "ln -sf /tmp/outside_9931.txt link_9931.txt && echo SYMCTL_DONE_7755"
+        ),
+    ),
+    tool_round(
+        "bash",
+        turn=2,
+        command=(
+            'python3 -c "import os; p=\'link_9931.txt\'; '
+            "print('SYM'+'LINK_%d' % os.path.islink(p)); "
+            "print('SYM'+'REAL_%d' % (os.path.realpath(p)=='/tmp/outside_9931.txt')); "
+            "print('SYM'+'BYTE_%d' % (open(p,'rb').read()==b'OUTSIDE_ORIG_7731\\n'))"
+        ),
+    ),
+    capture_model_text(
+        required=("SYMLINK_1", "SYMREAL_1", "SYMBYTE_1"),
+        forbidden=(),
+        min_requests=2,
+    ),
+)
+_BASE_SCENARIO = scenario_by_id(SCENARIO_ID)
+_COMPILED_RECIPE = compile_file_tool_steps(
+    STEPS,
+    case_kind="control",
+    declared_tools=("bash",),
+    oracle_profile=FileToolOracleProfile.TEXT_RULES,
+    blocking=True,
+    execution_parameters=_BASE_SCENARIO.recipe.execution_parameters,
+    bind_oracle_parameters=True,
+)
+RECIPE = replace(
+    _COMPILED_RECIPE,
+    setup_commands=_BASE_SCENARIO.recipe.setup_commands,
+    seed_files=_BASE_SCENARIO.recipe.seed_files,
+    rounds=_BASE_SCENARIO.recipe.rounds,
+    oracle_parameters=_BASE_SCENARIO.recipe.oracle_parameters,
+)
+SCENARIO: FileToolScenario = FileToolScenario(_BASE_SCENARIO.definition, RECIPE)
+scenario = SCENARIO
+definition = SCENARIO.definition
+
+
+def judge(observation: FileToolRawObservation):
+    """Apply the typed symlink-marker contract."""
+
+    validate_file_tool_observation(SCENARIO, observation)
+    advertised = any(
+        type(item) is str and item.strip().lower() in {"bash", "shell"}
+        for item in observation.advertised_tools
+    )
+    if not advertised and not observation.timed_out:
+        return build_file_tool_evaluation(
+            SCENARIO,
+            observation,
+            FileToolJudgement(
+                FileToolOutcome.PASS,
+                FileToolApplicability.INCONCLUSIVE,
+                FileToolOracleProfile.TEXT_RULES.value,
+            ),
+        )
+    params = dict(RECIPE.oracle_parameters)
+    passed = (
+        advertised
+        and observation.request_count >= int(params["min_requests"])
+        and observation.live
+        and all(marker in observation.model_text for marker in params["required"])
+        and all(marker not in observation.model_text for marker in params["forbidden"])
+        and observation.process_tree_clean
+        and observation.gateway_clean
+        and observation.workspace_clean
+        and not observation.timed_out
+    )
+    return build_file_tool_evaluation(
+        SCENARIO,
+        observation,
+        FileToolJudgement(
+            FileToolOutcome.PASS if passed else FileToolOutcome.FAIL,
+            FileToolApplicability.APPLICABLE,
+            FileToolOracleProfile.TEXT_RULES.value
+            if passed
+            else f"{FileToolOracleProfile.TEXT_RULES.value}_FAILED",
+        ),
+    )
+
+
+__all__ = ["RECIPE", "SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/file/scenarios/undo_reverts_overwrite_control.py b/code/src/doc2harness/benchmark/harnesses/file/scenarios/undo_reverts_overwrite_control.py
new file mode 100644
index 0000000000000000000000000000000000000000..61369604dc2c05bab77e1d811cd72a1827761109
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/file/scenarios/undo_reverts_overwrite_control.py
@@ -0,0 +1,110 @@
+"""Verify undo restores the original file after a full overwrite.
+1. Seed the target, enable yolo mode, read it beside a live Bash probe, and overwrite it.
+2. Issue undo at the session boundary.
+3. Run a post-undo probe and capture the resulting transition facts.
+4. Pass when the overwrite snapshot and both restored snapshots match exactly and execution is clean.
+"""
+
+from dataclasses import replace
+
+from doc2harness.benchmark.harnesses.file.contracts import (
+    FileToolApplicability,
+    FileToolJudgement,
+    FileToolOracleProfile,
+    FileToolOutcome,
+    FileToolRawObservation,
+    FileToolScenario,
+    build_file_tool_evaluation,
+    capture_fact,
+    compile_file_tool_steps,
+    setup_command,
+    tool_round,
+    validate_file_tool_observation,
+    write_fixture,
+)
+from ..recipes import scenario_by_id
+
+SCENARIO_ID = "undo_reverts_overwrite_control"
+STEPS = (
+    write_fixture("tgt.txt", "ORIG_PERM_0001\n"),
+    setup_command("/mode yolo"),
+    tool_round("bash", turn=1, command="echo PERM_LIVE_7755 > live.txt"),
+    tool_round("read", turn=1, arguments_nested=True, file_path="tgt.txt"),
+    tool_round(
+        "write",
+        turn=2,
+        arguments_nested=True,
+        file_path="tgt.txt",
+        content="OVR_BODY_7755\n",
+    ),
+    tool_round("bash", turn=3, command="echo POSTUNDO_7755"),
+    capture_fact("target_content", required=(), min_requests=2),
+)
+_BASE_SCENARIO = scenario_by_id(SCENARIO_ID)
+_COMPILED_RECIPE = compile_file_tool_steps(
+    STEPS,
+    case_kind="control",
+    declared_tools=("write",),
+    oracle_profile=FileToolOracleProfile.TRANSITION_EXACT,
+    dependencies=(),
+    blocking=False,
+    execution_parameters=_BASE_SCENARIO.recipe.execution_parameters,
+    bind_oracle_parameters=True,
+)
+RECIPE = replace(
+    _COMPILED_RECIPE,
+    setup_commands=_BASE_SCENARIO.recipe.setup_commands,
+    seed_files=_BASE_SCENARIO.recipe.seed_files,
+    rounds=_BASE_SCENARIO.recipe.rounds,
+    oracle_parameters=_BASE_SCENARIO.recipe.oracle_parameters,
+)
+SCENARIO: FileToolScenario = FileToolScenario(_BASE_SCENARIO.definition, RECIPE)
+scenario = SCENARIO
+definition = SCENARIO.definition
+
+
+def judge(observation: FileToolRawObservation):
+    """Apply the typed exact-transition contract to the overwrite undo."""
+
+    validate_file_tool_observation(SCENARIO, observation)
+    advertised = any(
+        type(item) is str and item.strip().lower() in {"write", "file_write"}
+        for item in observation.advertised_tools
+    )
+    if not advertised and not observation.timed_out:
+        return build_file_tool_evaluation(
+            SCENARIO,
+            observation,
+            FileToolJudgement(
+                FileToolOutcome.PASS,
+                FileToolApplicability.INCONCLUSIVE,
+                FileToolOracleProfile.TRANSITION_EXACT.value,
+            ),
+        )
+    facts = dict(observation.facts)
+    params = dict(RECIPE.oracle_parameters)
+    expected = dict(params["expected"])
+    passed = (
+        advertised
+        and observation.request_count >= int(params["min_requests"])
+        and observation.live
+        and all(facts.get(key) == value for key, value in expected.items())
+        and observation.process_tree_clean
+        and observation.gateway_clean
+        and observation.workspace_clean
+        and not observation.timed_out
+    )
+    return build_file_tool_evaluation(
+        SCENARIO,
+        observation,
+        FileToolJudgement(
+            FileToolOutcome.PASS if passed else FileToolOutcome.FAIL,
+            FileToolApplicability.APPLICABLE,
+            FileToolOracleProfile.TRANSITION_EXACT.value
+            if passed
+            else f"{FileToolOracleProfile.TRANSITION_EXACT.value}_FAILED",
+        ),
+    )
+
+
+__all__ = ["RECIPE", "SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/headless/__init__.py b/code/src/doc2harness/benchmark/harnesses/headless/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e2741cc01f2d75c9bd2189b9ef7595ff1e23aec5
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/headless/__init__.py
@@ -0,0 +1,56 @@
+"""Public headless CLI Harness surface."""
+
+from .adapter import (
+    HeadlessExecutionPlan,
+    build_headless_execution_plan,
+)
+from .contracts import (
+    ArgumentVariant,
+    CliFileProbe,
+    FormalProbe,
+    HeadlessApplicability,
+    HeadlessExecutionMode,
+    HeadlessJudgement,
+    HeadlessObservation,
+    HeadlessOutcome,
+    HeadlessProfile,
+    HeadlessRecipe,
+    HeadlessScenario,
+    JsonOverride,
+    ListingProbe,
+    ObservedFile,
+    ProcessObservation,
+    RequestRecord,
+    SchemaProbe,
+    SeedFile,
+    ToolCall,
+    ToolRound,
+)
+from .recipes import SCENARIOS, scenario_by_id
+
+__all__ = [
+    "SCENARIOS",
+    "ArgumentVariant",
+    "CliFileProbe",
+    "FormalProbe",
+    "HeadlessApplicability",
+    "HeadlessExecutionMode",
+    "HeadlessExecutionPlan",
+    "HeadlessJudgement",
+    "HeadlessObservation",
+    "HeadlessOutcome",
+    "HeadlessProfile",
+    "HeadlessRecipe",
+    "HeadlessScenario",
+    "JsonOverride",
+    "ListingProbe",
+    "ObservedFile",
+    "ProcessObservation",
+    "RequestRecord",
+    "SchemaProbe",
+    "SeedFile",
+    "ToolCall",
+    "ToolRound",
+    "build_headless_execution_plan",
+    "scenario_by_id",
+]
diff --git a/code/src/doc2harness/benchmark/harnesses/headless/adapter.py b/code/src/doc2harness/benchmark/harnesses/headless/adapter.py
new file mode 100644
index 0000000000000000000000000000000000000000..6d49802588fa8fcc1faf21abd3339b2f2e77a5ee
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/headless/adapter.py
@@ -0,0 +1,50 @@
+"""Execution boundary for typed headless CLI observations."""
+
+import hashlib
+from dataclasses import dataclass
+
+from doc2harness.contracts.canonical import canonical_json
+from doc2harness.contracts.primitives import ContractDocumentError
+
+from .contracts import (
+    HeadlessProfile,
+    HeadlessRecipe,
+    HeadlessScenario,
+)
+from .fixtures import HeadlessFixturePlan, materialize_headless_fixture
+
+
+@dataclass(frozen=True, slots=True)
+class HeadlessExecutionPlan:
+    scenario_id: str
+    profile: HeadlessProfile
+    recipe: HeadlessRecipe
+    fixture: HeadlessFixturePlan
+    timeout_seconds: int
+    plan_digest: str
+
+
+def build_headless_execution_plan(
+    scenario: HeadlessScenario, /
+) -> HeadlessExecutionPlan:
+    if type(scenario) is not HeadlessScenario:
+        raise ContractDocumentError("headless execution requires an exact scenario")
+    fixture = materialize_headless_fixture(scenario)
+    body = {
+        "fixture_digest": fixture.plan_digest,
+        "profile": scenario.recipe.profile.value,
+        "scenario_id": scenario.definition.scenario_id,
+        "timeout_seconds": scenario.recipe.timeout_seconds,
+    }
+    digest = (
+        "sha256:"
+        + hashlib.sha256(b"doc2harness.headless-plan/1\0" + canonical_json(body)).hexdigest()
+    )
+    return HeadlessExecutionPlan(
+        scenario.definition.scenario_id,
+        scenario.recipe.profile,
+        scenario.recipe,
+        fixture,
+        scenario.recipe.timeout_seconds,
+        digest,
+    )
diff --git a/code/src/doc2harness/benchmark/harnesses/headless/catalog.toml b/code/src/doc2harness/benchmark/harnesses/headless/catalog.toml
new file mode 100644
index 0000000000000000000000000000000000000000..6e8aa5a0d6350e995bacd16f1c57cf3fc8f38173
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/headless/catalog.toml
@@ -0,0 +1,18 @@
+format = "doc2harness.catalog-shard-source/1"
+function_id = "headless"
+resource = "benchmark/harnesses/headless/catalog.toml"
+exports = [
+  { module = "doc2harness.benchmark.harnesses.headless.scenarios.at_ref_expands_in_headless", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.headless.scenarios.budget_type_domain", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.headless.scenarios.budget_type_domain_control", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.headless.scenarios.exec_requires_bg", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.headless.scenarios.exec_requires_bg_control", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.headless.scenarios.headless_p_json_model_error_wellformed", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.headless.scenarios.headless_p_json_wellformed", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.headless.scenarios.p34_ctl_bare_mention_not_auto_read", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.headless.scenarios.p34_ctl_task_text_reaches_wire", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.headless.scenarios.runtime_error_stdout", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.headless.scenarios.runtime_error_stdout_control", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.headless.scenarios.session_flag_subcommand_conflict", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.headless.scenarios.session_flag_subcommand_conflict_control", export = "definition" },
+]
diff --git a/code/src/doc2harness/benchmark/harnesses/headless/contracts.py b/code/src/doc2harness/benchmark/harnesses/headless/contracts.py
new file mode 100644
index 0000000000000000000000000000000000000000..dd4ba0bd7bcd70e3a66f16f65b63920e02a69518
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/headless/contracts.py
@@ -0,0 +1,784 @@
+"""Typed execution recipes and raw observations for the headless CLI Harness."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import re
+from dataclasses import asdict, dataclass
+from enum import Enum
+
+from doc2harness.benchmark.definition import (
+    Classification,
+    ComponentKind,
+    ComponentRef,
+    DependencyKind,
+    DependencyRef,
+    ExperimentBinding,
+    ScenarioDefinition,
+    ScenarioDifficulty,
+    ScenarioRole,
+    UnsupportedPolicy,
+    definition_digest,
+)
+from doc2harness.contracts.canonical import canonical_json
+from doc2harness.contracts.primitives import ContractDocumentError
+
+_ID = re.compile(r"[a-z0-9][a-z0-9._-]{0,127}\Z", re.ASCII)
+_MAX_TEXT = 4_000_000
+_MAX_ITEMS = 4096
+
+
+def _text(value: object, name: str, *, allow_empty: bool = True) -> None:
+    if (
+        type(value) is not str
+        or len(value) > _MAX_TEXT
+        or (not allow_empty and not value)
+    ):
+        raise ContractDocumentError(f"headless {name} is invalid")
+
+
+def _strings(value: object, name: str, *, unique: bool = False) -> None:
+    if (
+        type(value) is not tuple
+        or len(value) > _MAX_ITEMS
+        or any(type(v) is not str or len(v) > _MAX_TEXT for v in value)
+    ):
+        raise ContractDocumentError(f"headless {name} is invalid")
+    if unique and len(set(value)) != len(value):
+        raise ContractDocumentError(f"headless {name} must be unique")
+
+
+def _relative_path(value: object, name: str, *, allow_empty: bool = True) -> None:
+    _text(value, name, allow_empty=allow_empty)
+    if value and (value.startswith("/") or ".." in value.split("/")):
+        raise ContractDocumentError(f"headless {name} must be relative")
+
+
+class HeadlessProfile(str, Enum):
+    JSON_PURE = "chk_json_pure"
+    JSON_ERROR_PURE = "chk_json_error_pure"
+    PROBE_PRESENT = "chk_probe_present"
+    PROBE_ABSENT = "chk_probe_absent"
+    BUDGET_TYPE_DOMAIN_CONTROL = "chk_budget_type_domain_control"
+    BUDGET_TYPE_DOMAIN = "chk_budget_type_domain"
+    RUNTIME_ERROR_STDOUT_CONTROL = "chk_runtime_error_stdout_control"
+    RUNTIME_ERROR_STDOUT = "chk_runtime_error_stdout"
+    EXEC_BACKGROUND = "chk_exec_background"
+    SESSION_FLAG_CONFLICT = "chk_session_flag_conflict"
+
+
+class HeadlessExecutionMode(str, Enum):
+    STANDARD = "standard"
+    FORMAL_RUNTIME = "formal-runtime"
+    FORMAL_CONTRACT = "formal-contract"
+
+
+class HeadlessOutcome(str, Enum):
+    PASS = "PASS"
+    FAIL = "FAIL"
+
+
+class HeadlessApplicability(str, Enum):
+    APPLICABLE = "APPLICABLE"
+    INCONCLUSIVE = "INCONCLUSIVE"
+
+
+@dataclass(frozen=True, slots=True)
+class HeadlessJudgement:
+    """Typed result returned by one scenario-local, pure headless judge."""
+
+    outcome: HeadlessOutcome
+    applicability: HeadlessApplicability
+    reason_code: str
+
+    def __post_init__(self) -> None:
+        if type(self.outcome) is not HeadlessOutcome:
+            raise ContractDocumentError("headless judgement outcome is invalid")
+        if type(self.applicability) is not HeadlessApplicability:
+            raise ContractDocumentError("headless judgement applicability is invalid")
+        _text(self.reason_code, "judgement reason", allow_empty=False)
+
+
+@dataclass(frozen=True, slots=True)
+class ArgumentVariant:
+    label: str
+    arguments: tuple[str, ...]
+
+    def __post_init__(self) -> None:
+        if type(self.label) is not str or not self.label:
+            raise ContractDocumentError("headless variant label is invalid")
+        if type(self.arguments) is not tuple or any(
+            type(v) is not str for v in self.arguments
+        ):
+            raise ContractDocumentError("headless variant arguments are invalid")
+
+
+@dataclass(frozen=True, slots=True)
+class SeedFile:
+    path: str
+    content: str
+
+    def __post_init__(self) -> None:
+        if (
+            type(self.path) is not str
+            or not self.path
+            or self.path.startswith("/")
+            or ".." in self.path.split("/")
+        ):
+            raise ContractDocumentError("headless seed path is invalid")
+        if type(self.content) is not str:
+            raise ContractDocumentError("headless seed content is invalid")
+
+
+@dataclass(frozen=True, slots=True)
+class ToolCall:
+    names: tuple[str, ...]
+    arguments_json: str = "{}"
+    command: str = ""
+
+    def __post_init__(self) -> None:
+        if (
+            type(self.names) is not tuple
+            or not self.names
+            or any(type(v) is not str or not v for v in self.names)
+        ):
+            raise ContractDocumentError("headless tool names are invalid")
+        if type(self.arguments_json) is not str or type(self.command) is not str:
+            raise ContractDocumentError("headless tool payload is invalid")
+
+
+@dataclass(frozen=True, slots=True)
+class ToolRound:
+    calls: tuple[ToolCall, ...]
+
+    def __post_init__(self) -> None:
+        if (
+            type(self.calls) is not tuple
+            or not self.calls
+            or len(self.calls) > _MAX_ITEMS
+            or any(type(v) is not ToolCall for v in self.calls)
+        ):
+            raise ContractDocumentError("headless tool round is invalid")
+
+
+@dataclass(frozen=True, slots=True)
+class SchemaProbe:
+    label: str
+    path: str
+    key: str
+    sentinel: str
+
+    def __post_init__(self) -> None:
+        for value, name in (
+            (self.label, "schema label"),
+            (self.key, "schema key"),
+            (self.sentinel, "schema sentinel"),
+        ):
+            _text(value, name, allow_empty=False)
+        _relative_path(self.path, "schema path", allow_empty=False)
+
+
+@dataclass(frozen=True, slots=True)
+class JsonOverride:
+    """One typed JSON field override, including deliberately invalid domains."""
+
+    field: str
+    canonical_value: str
+
+    def __post_init__(self) -> None:
+        _text(self.field, "JSON override field", allow_empty=False)
+        _text(self.canonical_value, "JSON override value", allow_empty=False)
+        try:
+            value = json.loads(self.canonical_value)
+        except (TypeError, ValueError, json.JSONDecodeError) as error:
+            raise ContractDocumentError("headless JSON override is invalid") from error
+        rendered = json.dumps(
+            value,
+            ensure_ascii=False,
+            sort_keys=True,
+            separators=(",", ":"),
+            allow_nan=False,
+        )
+        if rendered != self.canonical_value:
+            raise ContractDocumentError("headless JSON override is not canonical")
+
+
+@dataclass(frozen=True, slots=True)
+class FormalProbe:
+    label: str
+    budget: tuple[JsonOverride, ...] = ()
+    path_role: str = ""
+    task_overrides: tuple[JsonOverride, ...] = ()
+    raw_contract: str = ""
+    gateway_mode: str = ""
+    environment: tuple[tuple[str, str], ...] = ()
+    argv_overrides: tuple[tuple[str, str], ...] = ()
+
+    def __post_init__(self) -> None:
+        _text(self.label, "formal probe label", allow_empty=False)
+        for value in (self.path_role, self.raw_contract, self.gateway_mode):
+            _text(value, "formal probe text")
+        if (
+            type(self.budget) is not tuple
+            or type(self.task_overrides) is not tuple
+            or any(
+                type(v) is not JsonOverride
+                for v in (*self.budget, *self.task_overrides)
+            )
+        ):
+            raise ContractDocumentError("headless formal JSON overrides are invalid")
+        for values, name in (
+            (self.environment, "formal environment"),
+            (self.argv_overrides, "formal argv overrides"),
+        ):
+            if type(values) is not tuple or any(
+                type(v) is not tuple
+                or len(v) != 2
+                or any(type(item) is not str for item in v)
+                for v in values
+            ):
+                raise ContractDocumentError(f"headless {name} is invalid")
+        if len({v.field for v in self.budget}) != len(self.budget) or len(
+            {v.field for v in self.task_overrides}
+        ) != len(self.task_overrides):
+            raise ContractDocumentError("headless formal override keys must be unique")
+
+
+@dataclass(frozen=True, slots=True)
+class ListingProbe:
+    label: str
+    count: int
+    payload_bytes: int
+
+    def __post_init__(self) -> None:
+        _text(self.label, "listing probe label", allow_empty=False)
+        if (
+            type(self.count) is not int
+            or self.count <= 0
+            or type(self.payload_bytes) is not int
+            or self.payload_bytes <= 0
+        ):
+            raise ContractDocumentError("headless listing probe is invalid")
+
+
+@dataclass(frozen=True, slots=True)
+class CliFileProbe:
+    label: str
+    kind: str
+    file_hex: str
+
+    def __post_init__(self) -> None:
+        _text(self.label, "CLI file probe label", allow_empty=False)
+        _text(self.kind, "CLI file probe kind", allow_empty=False)
+        if type(self.file_hex) is not str or len(self.file_hex) % 2:
+            raise ContractDocumentError("headless CLI file bytes are invalid")
+        try:
+            bytes.fromhex(self.file_hex)
+        except ValueError as error:
+            raise ContractDocumentError("headless CLI file bytes are invalid") from error
+
+
+@dataclass(frozen=True, slots=True)
+class HeadlessOracleBinding:
+    """Frozen checker closure values; these are oracle inputs, never verdicts."""
+
+    sentinel: str = ""
+    specification: str = ""
+    baseline_label: str = ""
+    subject_label: str = ""
+    third_label: str = ""
+    expected_tokens: tuple[str, ...] = ()
+    expected_tools: tuple[str, ...] = ()
+    expected_mark: str = ""
+    expected_boolean: bool | None = None
+    feature_name: str = ""
+    step_cap: int = 0
+    expected_relative_path: str = ""
+    resume_subdirectory: str = ""
+    schemas: tuple[SchemaProbe, ...] = ()
+
+    def __post_init__(self) -> None:
+        for value in (
+            self.sentinel,
+            self.specification,
+            self.baseline_label,
+            self.subject_label,
+            self.third_label,
+            self.expected_mark,
+            self.feature_name,
+            self.expected_relative_path,
+            self.resume_subdirectory,
+        ):
+            _text(value, "oracle binding text")
+        _strings(self.expected_tokens, "oracle expected tokens", unique=True)
+        _strings(self.expected_tools, "oracle expected tools", unique=True)
+        if (
+            self.expected_boolean is not None
+            and type(self.expected_boolean) is not bool
+        ):
+            raise ContractDocumentError("headless oracle expected boolean is invalid")
+        if type(self.step_cap) is not int or self.step_cap < 0:
+            raise ContractDocumentError("headless oracle step cap is invalid")
+        if (
+            type(self.schemas) is not tuple
+            or len(self.schemas) > _MAX_ITEMS
+            or any(type(v) is not SchemaProbe for v in self.schemas)
+        ):
+            raise ContractDocumentError("headless oracle schemas are invalid")
+        if len({v.label for v in self.schemas}) != len(self.schemas):
+            raise ContractDocumentError("headless oracle schema labels must be unique")
+
+
+@dataclass(frozen=True, slots=True)
+class HeadlessRecipe:
+    """Complete typed stimulus; ``case_digest`` is audit-only."""
+
+    profile: HeadlessProfile
+    case_digest: str
+    dependencies: tuple[tuple[str, DependencyKind], ...] = ()
+    task: str = "Say the magic word and stop."
+    output_format: str = "text"
+    blocking: bool = True
+    reply_content: str = "DONE_SENTINEL"
+    gateway_mode: str = "fixed_reply"
+    append_system_prompt: str = ""
+    system_prompt: str = ""
+    probe_token: str = ""
+    probe_tokens: tuple[str, ...] = ()
+    cli_variants: tuple[ArgumentVariant, ...] = ()
+    subcommand_variants: tuple[ArgumentVariant, ...] = ()
+    file_variants: tuple[ArgumentVariant, ...] = ()
+    sequence_subcommands: tuple[tuple[str, ...], ...] = ()
+    # Names for the sequence steps.  A judge that compares steps by name needs
+    # them declared; without this the driver can only number them, and a
+    # lookup by name finds nothing.
+    sequence_labels: tuple[str, ...] = ()
+    sequence_pause_seconds: int = 0
+    seed_files: tuple[SeedFile, ...] = ()
+    rounds: tuple[ToolRound, ...] = ()
+    command: str = ""
+    target_file: str = ""
+    target_written: str = ""
+    target_original: str = ""
+    empty_task: bool = False
+    extra_argv: tuple[str, ...] = ()
+    environment: tuple[tuple[str, str], ...] = ()
+    local_web_probe: bool = False
+    git_fixture: bool = False
+    execution_mode: HeadlessExecutionMode = HeadlessExecutionMode.STANDARD
+    formal_runtime_probes: tuple[FormalProbe, ...] = ()
+    formal_contract_probes: tuple[FormalProbe, ...] = ()
+    listing_probes: tuple[ListingProbe, ...] = ()
+    cli_file_probes: tuple[CliFileProbe, ...] = ()
+    status_observation_required: bool = False
+    seed_timeout_seconds: int = 0
+    measurement_timeout_seconds: int = 0
+    timeout_seconds: int = 60
+    oracle: HeadlessOracleBinding = HeadlessOracleBinding()
+
+    def __post_init__(self) -> None:
+        if type(self.profile) is not HeadlessProfile:
+            raise ContractDocumentError("headless profile is invalid")
+        if (
+            type(self.case_digest) is not str
+            or not self.case_digest.startswith("sha256:")
+            or len(self.case_digest) != 71
+        ):
+            raise ContractDocumentError("headless case digest is invalid")
+        if type(self.dependencies) is not tuple or any(
+            type(v) is not tuple
+            or len(v) != 2
+            or type(v[0]) is not str
+            or type(v[1]) is not DependencyKind
+            for v in self.dependencies
+        ):
+            raise ContractDocumentError("headless dependencies are invalid")
+        if any(
+            type(v) is not ArgumentVariant
+            for v in self.cli_variants + self.subcommand_variants + self.file_variants
+        ):
+            raise ContractDocumentError("headless recipe variants are invalid")
+        if any(
+            type(step) is not tuple or any(type(v) is not str for v in step)
+            for step in self.sequence_subcommands
+        ):
+            raise ContractDocumentError("headless sequence is invalid")
+        if any(type(v) is not SeedFile for v in self.seed_files) or any(
+            type(v) is not ToolRound for v in self.rounds
+        ):
+            raise ContractDocumentError("headless fixture recipe is invalid")
+        if type(self.environment) is not tuple or any(
+            type(v) is not tuple or len(v) != 2 or any(type(x) is not str for x in v)
+            for v in self.environment
+        ):
+            raise ContractDocumentError("headless environment is invalid")
+        if (
+            type(self.timeout_seconds) is not int
+            or self.timeout_seconds <= 0
+            or type(self.sequence_pause_seconds) is not int
+            or self.sequence_pause_seconds < 0
+        ):
+            raise ContractDocumentError("headless timing is invalid")
+        if type(self.oracle) is not HeadlessOracleBinding:
+            raise ContractDocumentError("headless oracle binding is invalid")
+        if type(self.execution_mode) is not HeadlessExecutionMode:
+            raise ContractDocumentError("headless execution mode is invalid")
+        for values, expected, name in (
+            (self.formal_runtime_probes, FormalProbe, "formal runtime probes"),
+            (self.formal_contract_probes, FormalProbe, "formal contract probes"),
+            (self.listing_probes, ListingProbe, "listing probes"),
+            (self.cli_file_probes, CliFileProbe, "CLI file probes"),
+        ):
+            if type(values) is not tuple or any(type(v) is not expected for v in values):
+                raise ContractDocumentError(f"headless {name} are invalid")
+            if len({v.label for v in values}) != len(values):
+                raise ContractDocumentError(f"headless {name} labels must be unique")
+        if type(self.status_observation_required) is not bool:
+            raise ContractDocumentError("headless status observation flag is invalid")
+        if any(
+            type(value) is not int or value < 0
+            for value in (self.seed_timeout_seconds, self.measurement_timeout_seconds)
+        ):
+            raise ContractDocumentError("headless auxiliary timing is invalid")
+        for value in (
+            self.task,
+            self.output_format,
+            self.reply_content,
+            self.gateway_mode,
+            self.append_system_prompt,
+            self.system_prompt,
+            self.probe_token,
+            self.command,
+            self.target_written,
+            self.target_original,
+        ):
+            _text(value, "recipe text")
+        _relative_path(self.target_file, "target path")
+        _strings(self.probe_tokens, "probe tokens", unique=True)
+        _strings(self.extra_argv, "extra argv")
+        for flag in (
+            self.blocking,
+            self.empty_task,
+            self.local_web_probe,
+            self.git_fixture,
+        ):
+            if type(flag) is not bool:
+                raise ContractDocumentError("headless recipe flag is invalid")
+        if len(
+            {
+                v.label
+                for v in self.cli_variants
+                + self.subcommand_variants
+                + self.file_variants
+            }
+        ) != len(self.cli_variants + self.subcommand_variants + self.file_variants):
+            raise ContractDocumentError("headless recipe variant labels must be unique")
+
+
+@dataclass(frozen=True, slots=True)
+class RequestRecord:
+    body: str
+    model: str = ""
+    system_text: str = ""
+    probe_hits: tuple[str, ...] = ()
+    system_probe_hits: tuple[str, ...] = ()
+    tool_names: tuple[str, ...] = ()
+    tool_result_texts: tuple[str, ...] = ()
+    stream_enabled: bool | None = None
+
+    def __post_init__(self) -> None:
+        _text(self.body, "request body")
+        _text(self.model, "request model")
+        _text(self.system_text, "request system text")
+        _strings(self.probe_hits, "request probe hits", unique=True)
+        _strings(self.system_probe_hits, "request system probe hits", unique=True)
+        _strings(self.tool_names, "request tool names", unique=True)
+        _strings(self.tool_result_texts, "request tool results")
+        if self.stream_enabled is not None and type(self.stream_enabled) is not bool:
+            raise ContractDocumentError("headless request stream flag is invalid")
+
+
+@dataclass(frozen=True, slots=True)
+class ProcessObservation:
+    """One directly observed CLI process, variant, or sequence step."""
+
+    label: str
+    rc: int | None
+    stdout: str = ""
+    stderr: str = ""
+    timed_out: bool = False
+    requests: tuple[RequestRecord, ...] = ()
+    written_paths: tuple[str, ...] = ()
+    removed_paths: tuple[str, ...] = ()
+    target_content: str = ""
+    target_found_at: str = ""
+    worktree_target_content: str = ""
+    worktree_paths: tuple[str, ...] = ()
+    git_initialized: bool = False
+    marker_found_at: str = ""
+    web_gets: tuple[str, ...] = ()
+    exit_status: str = ""
+    start_error: str = ""
+    cleanup_complete: bool = True
+    out_created: bool = False
+    repo_changed: bool = False
+    preterminal_stdout: str = ""
+    barrier_seen: bool | None = None
+    gateway_wait_timed_out: bool | None = None
+    terminal_before_release: bool | None = None
+    first_stdout_ns: int | None = None
+    release_ns: int | None = None
+    count: int | None = None
+    payload_bytes: int | None = None
+    seed_created: int | None = None
+    listed_markers: int | None = None
+    rchar_delta: int | None = None
+    rss_delta_kib: int | None = None
+    home_open_count: int | None = None
+    output_bytes: int | None = None
+    product_error: str = ""
+
+    def __post_init__(self) -> None:
+        if type(self.label) is not str or not self.label:
+            raise ContractDocumentError("headless process label is invalid")
+        if self.rc is not None and type(self.rc) is not int:
+            raise ContractDocumentError("headless process rc is invalid")
+        if type(self.timed_out) is not bool or any(
+            type(v) is not RequestRecord for v in self.requests
+        ):
+            raise ContractDocumentError("headless process evidence is invalid")
+        if type(self.requests) is not tuple or len(self.requests) > _MAX_ITEMS:
+            raise ContractDocumentError("headless process requests are invalid")
+        for value in (
+            self.stdout,
+            self.stderr,
+            self.target_content,
+            self.target_found_at,
+            self.worktree_target_content,
+            self.marker_found_at,
+            self.exit_status,
+            self.start_error,
+            self.preterminal_stdout,
+            self.product_error,
+        ):
+            _text(value, "process text")
+        _strings(self.written_paths, "written paths", unique=True)
+        _strings(self.removed_paths, "removed paths", unique=True)
+        _strings(self.worktree_paths, "worktree paths", unique=True)
+        _strings(self.web_gets, "web gets")
+        for path in self.written_paths + self.removed_paths:
+            _relative_path(path, "filesystem path", allow_empty=False)
+        if type(self.git_initialized) is not bool:
+            raise ContractDocumentError("headless git observation is invalid")
+        if any(
+            type(value) is not bool
+            for value in (self.cleanup_complete, self.out_created, self.repo_changed)
+        ):
+            raise ContractDocumentError("headless process fact flags are invalid")
+        for value in (
+            self.barrier_seen,
+            self.gateway_wait_timed_out,
+            self.terminal_before_release,
+        ):
+            if value is not None and type(value) is not bool:
+                raise ContractDocumentError("headless timeline flags are invalid")
+        for value in (
+            self.first_stdout_ns,
+            self.release_ns,
+            self.count,
+            self.payload_bytes,
+            self.seed_created,
+            self.listed_markers,
+            self.rchar_delta,
+            self.rss_delta_kib,
+            self.home_open_count,
+            self.output_bytes,
+        ):
+            if value is not None and (type(value) is not int or value < 0):
+                raise ContractDocumentError("headless numeric process fact is invalid")
+
+
+@dataclass(frozen=True, slots=True)
+class ObservedFile:
+    path: str
+    content: str
+
+    def __post_init__(self) -> None:
+        _relative_path(self.path, "observed file path", allow_empty=False)
+        _text(self.content, "observed file content")
+
+
+@dataclass(frozen=True, slots=True)
+class HeadlessScenario:
+    definition: ScenarioDefinition
+    recipe: HeadlessRecipe
+
+    def __post_init__(self) -> None:
+        if (
+            type(self.definition) is not ScenarioDefinition
+            or type(self.recipe) is not HeadlessRecipe
+        ):
+            raise ContractDocumentError("headless scenario requires exact typed values")
+        if self.definition.classification.primary != "headless":
+            raise ContractDocumentError(
+                "headless scenario owner differs from its Harness"
+            )
+
+
+@dataclass(frozen=True, slots=True)
+class HeadlessObservation:
+    scenario_id: str
+    profile: HeadlessProfile
+    plan_digest: str
+    artifact_id: str
+    artifact_digest: str
+    backend_evidence_digest: str
+    cli_available: bool
+    runs: tuple[ProcessObservation, ...]
+    artifact_files: tuple[ObservedFile, ...] = ()
+    repository_root: str = ""
+    agent_session_id: str = ""
+    driver_error: str = ""
+    process_tree_clean: bool = True
+    workspace_clean: bool = True
+    checkpoint_id: str = ""
+    pre_listing: str = ""
+    selection_command: str = ""
+    selection_result: str = ""
+    summary_sent: bool | None = None
+    session_start_error: str = ""
+
+    def __post_init__(self) -> None:
+        if (
+            type(self.scenario_id) is not str
+            or _ID.fullmatch(self.scenario_id) is None
+            or type(self.profile) is not HeadlessProfile
+        ):
+            raise ContractDocumentError("headless observation identity is invalid")
+        for value in (
+            self.plan_digest,
+            self.artifact_digest,
+            self.backend_evidence_digest,
+        ):
+            if (
+                type(value) is not str
+                or not value.startswith("sha256:")
+                or len(value) != 71
+            ):
+                raise ContractDocumentError("headless evidence digest is invalid")
+        if type(self.artifact_id) is not str or not self.artifact_id:
+            raise ContractDocumentError("headless artifact id is invalid")
+        if type(self.runs) is not tuple or any(
+            type(v) is not ProcessObservation for v in self.runs
+        ):
+            raise ContractDocumentError("headless raw runs are invalid")
+        if any(type(v) is not ObservedFile for v in self.artifact_files):
+            raise ContractDocumentError("headless artifact files are invalid")
+        if any(
+            type(v) is not bool
+            for v in (self.cli_available, self.process_tree_clean, self.workspace_clean)
+        ):
+            raise ContractDocumentError("headless observation flags are invalid")
+        for value in (
+            self.repository_root,
+            self.agent_session_id,
+            self.driver_error,
+            self.checkpoint_id,
+            self.pre_listing,
+            self.selection_command,
+            self.selection_result,
+            self.session_start_error,
+        ):
+            _text(value, "observation text")
+        if self.summary_sent is not None and type(self.summary_sent) is not bool:
+            raise ContractDocumentError("headless compact summary fact is invalid")
+        labels = tuple(run.label for run in self.runs)
+        if len(set(labels)) != len(labels):
+            raise ContractDocumentError("headless run labels must be unique")
+        paths = tuple(item.path for item in self.artifact_files)
+        if len(set(paths)) != len(paths):
+            raise ContractDocumentError("headless artifact file paths must be unique")
+
+
+def define_headless_scenario(
+    scenario_id: str, recipe: HeadlessRecipe, role: ScenarioRole, /
+) -> HeadlessScenario:
+    dependencies = tuple(
+        sorted(
+            (DependencyRef(test_id, kind) for test_id, kind in recipe.dependencies),
+            key=lambda item: (item.scenario_id, item.kind.value),
+        )
+    )
+    definition = ScenarioDefinition(
+        scenario_id,
+        "1",
+        Classification("headless"),
+        role,
+        1_000_000 if role is ScenarioRole.TARGET else 0,
+        ScenarioDifficulty.HARD,
+        dependencies,
+        ExperimentBinding(
+            ComponentRef("headless-fixture", "1", ComponentKind.FIXTURE),
+            ComponentRef("headless-adapter", "1", ComponentKind.STIMULUS),
+            ComponentRef("headless-observer", "1", ComponentKind.OBSERVER),
+            ComponentRef("headless-oracle", "1", ComponentKind.ORACLE),
+            ComponentRef("headless-cleanup", "1", ComponentKind.CLEANUP),
+        ),
+        UnsupportedPolicy.FAIL,
+    )
+    return HeadlessScenario(definition, recipe)
+
+
+def evaluation_digest(
+    scenario: HeadlessScenario, observation: HeadlessObservation
+) -> str:
+    body = {
+        "artifact_digest": observation.artifact_digest,
+        "backend_evidence_digest": observation.backend_evidence_digest,
+        "definition_digest": definition_digest(scenario.definition),
+        "plan_digest": observation.plan_digest,
+        "scenario_id": scenario.definition.scenario_id,
+    }
+    return (
+        "sha256:"
+        + hashlib.sha256(
+            b"doc2harness.headless-evaluation/1\0" + canonical_json(body)
+        ).hexdigest()
+    )
+
+
+def recipe_digest(recipe: HeadlessRecipe, /) -> str:
+    """Bind every typed stimulus and checker closure value into the plan."""
+
+    if type(recipe) is not HeadlessRecipe:
+        raise ContractDocumentError("headless recipe digest requires an exact recipe")
+    body = asdict(recipe)
+    extension_keys = (
+        "execution_mode",
+        "formal_runtime_probes",
+        "formal_contract_probes",
+        "listing_probes",
+        "cli_file_probes",
+        "status_observation_required",
+        "seed_timeout_seconds",
+        "measurement_timeout_seconds",
+    )
+    if (
+        recipe.execution_mode is HeadlessExecutionMode.STANDARD
+        and not recipe.formal_runtime_probes
+        and not recipe.formal_contract_probes
+        and not recipe.listing_probes
+        and not recipe.cli_file_probes
+        and not recipe.status_observation_required
+        and recipe.seed_timeout_seconds == 0
+        and recipe.measurement_timeout_seconds == 0
+    ):
+        for key in extension_keys:
+            body.pop(key)
+    return (
+        "sha256:"
+        + hashlib.sha256(
+            b"doc2harness.headless-recipe/1\0" + canonical_json(body)
+        ).hexdigest()
+    )
diff --git a/code/src/doc2harness/benchmark/harnesses/headless/fixtures.py b/code/src/doc2harness/benchmark/harnesses/headless/fixtures.py
new file mode 100644
index 0000000000000000000000000000000000000000..2406a37db77149f2684aac80e1cbcb2d744981a5
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/headless/fixtures.py
@@ -0,0 +1,34 @@
+"""Immutable headless CLI fixture bindings."""
+
+import hashlib
+from dataclasses import dataclass
+
+from doc2harness.contracts.canonical import canonical_json
+
+from .contracts import HeadlessRecipe, HeadlessScenario, recipe_digest
+
+
+@dataclass(frozen=True, slots=True)
+class HeadlessFixturePlan:
+    case_digest: str
+    recipe: HeadlessRecipe
+    recipe_digest: str
+    plan_digest: str
+
+
+def materialize_headless_fixture(scenario: HeadlessScenario, /) -> HeadlessFixturePlan:
+    body = {
+        "case_digest": scenario.recipe.case_digest,
+        "recipe_digest": recipe_digest(scenario.recipe),
+        "scenario_id": scenario.definition.scenario_id,
+    }
+    digest = (
+        "sha256:"
+        + hashlib.sha256(b"doc2harness.headless-fixture/1\0" + canonical_json(body)).hexdigest()
+    )
+    return HeadlessFixturePlan(
+        scenario.recipe.case_digest,
+        scenario.recipe,
+        body["recipe_digest"],
+        digest,
+    )
diff --git a/code/src/doc2harness/benchmark/harnesses/headless/recipes.py b/code/src/doc2harness/benchmark/harnesses/headless/recipes.py
new file mode 100644
index 0000000000000000000000000000000000000000..c73c939240dfb6fd9a1ea6d790c1454c2dd428ad
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/headless/recipes.py
@@ -0,0 +1,291 @@
+"""Frozen typed recipes for headless CLI scenarios."""
+
+from doc2harness.benchmark.definition import DependencyKind, ScenarioRole
+from .contracts import (
+    FormalProbe,
+    HeadlessExecutionMode,
+    HeadlessOracleBinding,
+    HeadlessProfile,
+    HeadlessRecipe,
+    JsonOverride,
+    SeedFile,
+    define_headless_scenario,
+)
+
+_ROWS = {
+    "headless_p_json_wellformed": (
+        HeadlessRecipe(
+            profile=HeadlessProfile.JSON_PURE,
+            case_digest="sha256:8fca283d6a734d3194ca367d22d13f6d30fee60fb4cc77cb5eb397fe3bcd30c8",
+            dependencies=(),
+            timeout_seconds=90,
+            output_format="json",
+            blocking=False,
+            reply_content="PUREJSON_8842 finished",
+            oracle=HeadlessOracleBinding(sentinel="PUREJSON_8842"),
+        ),
+        ScenarioRole.CONTROL,
+    ),
+    "headless_p_json_model_error_wellformed": (
+        HeadlessRecipe(
+            profile=HeadlessProfile.JSON_ERROR_PURE,
+            case_digest="sha256:26ad300b0c8387f54353c7c0fe3c3683bf204943d4c980dec7340f71a7096bb7",
+            dependencies=(("headless_p_json_wellformed", DependencyKind.GATE),),
+            timeout_seconds=90,
+            output_format="json",
+            gateway_mode="http_401",
+            oracle=HeadlessOracleBinding(),
+        ),
+        ScenarioRole.TARGET,
+    ),
+    "p34_ctl_task_text_reaches_wire": (
+        HeadlessRecipe(
+            profile=HeadlessProfile.PROBE_PRESENT,
+            case_digest="sha256:d164292ad645d4f955608491de0ea28cb6901dc41ce26f265e87677544106bca",
+            dependencies=(),
+            task="ATREFTOK_9934 acknowledge and stop.",
+            output_format="text",
+            blocking=False,
+            reply_content="ack",
+            probe_token="ATREFTOK_9934",
+            timeout_seconds=90,
+            oracle=HeadlessOracleBinding(specification="the task body"),
+        ),
+        ScenarioRole.CONTROL,
+    ),
+    "p34_ctl_bare_mention_not_auto_read": (
+        HeadlessRecipe(
+            profile=HeadlessProfile.PROBE_ABSENT,
+            case_digest="sha256:2fadd93ee9d3ec8692ae580cca6bf596050d1caf4158bc2149c3a8efb64972b4",
+            dependencies=(),
+            task="There is a file called ctx_9934.md in this repo. Do not read it. Say ok and stop.",
+            output_format="text",
+            blocking=False,
+            reply_content="ack",
+            probe_token="ATREFTOK_9934",
+            seed_files=(SeedFile("ctx_9934.md", "ATREFTOK_9934 the project ships on Tuesdays.\n"),),
+            timeout_seconds=90,
+            oracle=HeadlessOracleBinding(specification="the content of a bare filename mention"),
+        ),
+        ScenarioRole.CONTROL,
+    ),
+    "at_ref_expands_in_headless": (
+        HeadlessRecipe(
+            profile=HeadlessProfile.PROBE_PRESENT,
+            case_digest="sha256:bb1913914002cbc7ccdd2c8bc785af8e73e0af5d6fc6bf70e81bdf23e9eb486a",
+            dependencies=(
+                ("p34_ctl_bare_mention_not_auto_read", DependencyKind.GATE),
+                ("p34_ctl_task_text_reaches_wire", DependencyKind.GATE),
+            ),
+            task="Summarize @ctx_9934.md in one line and stop.",
+            output_format="text",
+            reply_content="ack",
+            probe_token="ATREFTOK_9934",
+            seed_files=(SeedFile("ctx_9934.md", "ATREFTOK_9934 the project ships on Tuesdays.\n"),),
+            timeout_seconds=90,
+            oracle=HeadlessOracleBinding(specification="the content of an @-referenced file"),
+        ),
+        ScenarioRole.TARGET,
+    ),
+    "budget_type_domain_control": (
+        HeadlessRecipe(
+            profile=HeadlessProfile.BUDGET_TYPE_DOMAIN_CONTROL,
+            case_digest="sha256:79ce0a325bfe18c40fe109ec9705d346b5f297ca6e0650f5afe1b2a74ac2f19d",
+            blocking=False,
+            timeout_seconds=45,
+            execution_mode=HeadlessExecutionMode.FORMAL_RUNTIME,
+            formal_runtime_probes=(
+                FormalProbe(
+                    "valid-zero",
+                    budget=(
+                        JsonOverride("max_steps", "2"),
+                        JsonOverride("max_tokens", "0"),
+                        JsonOverride("max_wall_seconds", "30"),
+                    ),
+                ),
+                FormalProbe(
+                    "valid-positive",
+                    budget=(
+                        JsonOverride("max_steps", "97"),
+                        JsonOverride("max_tokens", "64"),
+                        JsonOverride("max_wall_seconds", "30"),
+                    ),
+                ),
+            ),
+            status_observation_required=True,
+        ),
+        ScenarioRole.CONTROL,
+    ),
+    "budget_type_domain": (
+        HeadlessRecipe(
+            profile=HeadlessProfile.BUDGET_TYPE_DOMAIN,
+            case_digest="sha256:c269536e752e1b7c0863711df30b5c08661d8d94ee6b4d1acbb8fc902ed9695a",
+            dependencies=(("budget_type_domain_control", DependencyKind.GATE),),
+            timeout_seconds=45,
+            execution_mode=HeadlessExecutionMode.FORMAL_RUNTIME,
+            formal_runtime_probes=(
+                FormalProbe(
+                    "valid-zero",
+                    budget=(
+                        JsonOverride("max_steps", "2"),
+                        JsonOverride("max_tokens", "0"),
+                        JsonOverride("max_wall_seconds", "30"),
+                    ),
+                ),
+                FormalProbe(
+                    "valid-positive",
+                    budget=(
+                        JsonOverride("max_steps", "97"),
+                        JsonOverride("max_tokens", "64"),
+                        JsonOverride("max_wall_seconds", "30"),
+                    ),
+                ),
+                FormalProbe(
+                    "invalid-boolean",
+                    budget=(
+                        JsonOverride("max_steps", "true"),
+                        JsonOverride("max_tokens", "0"),
+                        JsonOverride("max_wall_seconds", "30"),
+                    ),
+                ),
+                FormalProbe(
+                    "invalid-string",
+                    budget=(
+                        JsonOverride("max_steps", '"2"'),
+                        JsonOverride("max_tokens", "0"),
+                        JsonOverride("max_wall_seconds", "30"),
+                    ),
+                ),
+                FormalProbe(
+                    "invalid-float",
+                    budget=(
+                        JsonOverride("max_steps", "2.5"),
+                        JsonOverride("max_tokens", "0"),
+                        JsonOverride("max_wall_seconds", "30"),
+                    ),
+                ),
+                FormalProbe(
+                    "invalid-negative",
+                    budget=(
+                        JsonOverride("max_steps", "-1"),
+                        JsonOverride("max_tokens", "0"),
+                        JsonOverride("max_wall_seconds", "30"),
+                    ),
+                ),
+            ),
+            status_observation_required=True,
+        ),
+        ScenarioRole.TARGET,
+    ),
+    "runtime_error_stdout_control": (
+        HeadlessRecipe(
+            profile=HeadlessProfile.RUNTIME_ERROR_STDOUT_CONTROL,
+            case_digest="sha256:e6857e3b3b7693fa9d869c4939036e23acaac9e7aadb2169b887c3ee186f694d",
+            blocking=False,
+            gateway_mode="seq_probe",
+            reply_content="EXACT_REPLY_6047",
+            timeout_seconds=40,
+            execution_mode=HeadlessExecutionMode.FORMAL_CONTRACT,
+            formal_contract_probes=(FormalProbe("model-success", gateway_mode="seq_probe"),),
+            status_observation_required=True,
+        ),
+        ScenarioRole.CONTROL,
+    ),
+    "runtime_error_stdout": (
+        HeadlessRecipe(
+            profile=HeadlessProfile.RUNTIME_ERROR_STDOUT,
+            case_digest="sha256:1ba625fc10954046643efaa2ab98b5f71346de5a3e5cfe3eb519c2941056a83d",
+            dependencies=(("runtime_error_stdout_control", DependencyKind.GATE),),
+            gateway_mode="seq_probe",
+            reply_content="EXACT_REPLY_6047",
+            timeout_seconds=40,
+            execution_mode=HeadlessExecutionMode.FORMAL_CONTRACT,
+            formal_contract_probes=(
+                FormalProbe(
+                    "model-runtime-error",
+                    gateway_mode="http_401",
+                    environment=(("MSWEA_MODEL_RETRY_STOP_AFTER_ATTEMPT", "1"),),
+                ),
+            ),
+            status_observation_required=True,
+        ),
+        ScenarioRole.TARGET,
+    ),
+    "exec_requires_bg_control": (
+        HeadlessRecipe(
+            profile=HeadlessProfile.EXEC_BACKGROUND,
+            case_digest="sha256:3e0f756a0567630227d4125daac829dd8053a59b2b42a254011b3140e7f05575",
+            sequence_subcommands=(("--bg", "exec control", "--exec", "touch control.marker"),),
+            sequence_pause_seconds=10,
+            blocking=False,
+            timeout_seconds=60,
+            environment=(),
+            oracle=HeadlessOracleBinding(
+                specification="§4: --exec is valid only as a subordinate argument of --bg; the control must actually write the marker"
+            ),
+        ),
+        ScenarioRole.CONTROL,
+    ),
+    "exec_requires_bg": (
+        HeadlessRecipe(
+            profile=HeadlessProfile.EXEC_BACKGROUND,
+            case_digest="sha256:3e0f756a0567630227d4125daac829dd8053a59b2b42a254011b3140e7f05575",
+            dependencies=(("exec_requires_bg_control", DependencyKind.GATE),),
+            sequence_subcommands=(
+                ("--bg", "exec control", "--exec", "touch control.marker"),
+                ("--exec", "touch target.marker"),
+            ),
+            sequence_pause_seconds=10,
+            blocking=False,
+            timeout_seconds=60,
+            environment=(),
+            oracle=HeadlessOracleBinding(
+                specification="§4: --exec without --bg must be refused and must not write target.marker"
+            ),
+        ),
+        ScenarioRole.TARGET,
+    ),
+    "session_flag_subcommand_conflict_control": (
+        HeadlessRecipe(
+            profile=HeadlessProfile.SESSION_FLAG_CONFLICT,
+            case_digest="sha256:927d74c0d930f19ffeab0df118b5af54d259029ac3741ff07655b7cb6c83fcb2",
+            sequence_subcommands=(("memory", "status"), ("config", "list")),
+            timeout_seconds=60,
+            environment=(),
+            oracle=HeadlessOracleBinding(
+                specification="The no-resume baseline for management subcommands must yield rc0 on at least one side"
+            ),
+        ),
+        ScenarioRole.CONTROL,
+    ),
+    "session_flag_subcommand_conflict": (
+        HeadlessRecipe(
+            profile=HeadlessProfile.SESSION_FLAG_CONFLICT,
+            case_digest="sha256:927d74c0d930f19ffeab0df118b5af54d259029ac3741ff07655b7cb6c83fcb2",
+            dependencies=(("session_flag_subcommand_conflict_control", DependencyKind.GATE),),
+            sequence_subcommands=(
+                ("memory", "status"),
+                ("memory", "status", "--resume", "NOSUCH_SESSION_9931"),
+                ("config", "list"),
+                ("config", "list", "--resume", "NOSUCH_SESSION_9931"),
+            ),
+            timeout_seconds=60,
+            environment=(),
+            oracle=HeadlessOracleBinding(
+                specification="An explicit --resume must not be silently discarded on a management subcommand"
+            ),
+        ),
+        ScenarioRole.TARGET,
+    ),
+}
+SCENARIOS = tuple(
+    (define_headless_scenario(test_id, recipe, role) for test_id, (recipe, role) in _ROWS.items())
+)
+_BY_ID = {scenario.definition.scenario_id: scenario for scenario in SCENARIOS}
+
+
+def scenario_by_id(scenario_id: str) -> object:
+    try:
+        return _BY_ID[scenario_id]
+    except KeyError:
+        raise KeyError(f"unknown headless scenario: {scenario_id}") from None
diff --git a/code/src/doc2harness/benchmark/harnesses/headless/scenarios/__init__.py b/code/src/doc2harness/benchmark/harnesses/headless/scenarios/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..de1cbda7e3c4ec2bbb88d71e830120a078dab7de
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/headless/scenarios/__init__.py
@@ -0,0 +1 @@
+"""Thin headless CLI scenario modules."""
diff --git a/code/src/doc2harness/benchmark/harnesses/headless/scenarios/at_ref_expands_in_headless.py b/code/src/doc2harness/benchmark/harnesses/headless/scenarios/at_ref_expands_in_headless.py
new file mode 100644
index 0000000000000000000000000000000000000000..2f0393b3dc2639f1989369edcfda74ff71749e3b
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/headless/scenarios/at_ref_expands_in_headless.py
@@ -0,0 +1,46 @@
+"""Verify an @file reference reaches the headless model request.
+
+1. Seed the referenced file and send the summarization task.
+2. Observe the main process and typed request records.
+3. Require a successful run whose request contains the file marker.
+4. Pass only when the reference is observable on the wire.
+"""
+
+from doc2harness.benchmark.harnesses.headless.contracts import (
+    HeadlessApplicability,
+    HeadlessJudgement,
+    HeadlessObservation,
+    HeadlessOutcome,
+    HeadlessScenario,
+)
+
+from ..recipes import scenario_by_id
+
+SCENARIO_ID = "at_ref_expands_in_headless"
+SCENARIO: HeadlessScenario = scenario_by_id(SCENARIO_ID)
+RECIPE = SCENARIO.recipe
+STEPS = (RECIPE,)
+scenario = SCENARIO
+definition = SCENARIO.definition
+
+
+def judge(observation: HeadlessObservation) -> HeadlessJudgement:
+    run = next((item for item in observation.runs if item.label == "main"), None)
+    if run is None or run.rc != 0 or not run.requests:
+        return HeadlessJudgement(
+            HeadlessOutcome.FAIL,
+            HeadlessApplicability.INCONCLUSIVE,
+            "HEADLESS_PROBE_UNOBSERVED",
+        )
+    passed = any(
+        RECIPE.probe_token in request.body or RECIPE.probe_token in request.probe_hits
+        for request in run.requests
+    )
+    return HeadlessJudgement(
+        HeadlessOutcome.PASS if passed else HeadlessOutcome.FAIL,
+        HeadlessApplicability.APPLICABLE,
+        "HEADLESS_PROFILE_CHECKED",
+    )
+
+
+__all__ = ["RECIPE", "SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/headless/scenarios/budget_type_domain.py b/code/src/doc2harness/benchmark/harnesses/headless/scenarios/budget_type_domain.py
new file mode 100644
index 0000000000000000000000000000000000000000..5d6185a92edb28dea38eff7c6065caeb29d7a0b3
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/headless/scenarios/budget_type_domain.py
@@ -0,0 +1,69 @@
+"""Verify that invalid budget types and values are rejected before execution.
+
+1. Run valid budget probes followed by boolean, string, float, and negative probes.
+2. Capture exit status, request count, and submission status for each variant.
+3. Require valid probes to submit normally with one request.
+4. Require every invalid probe to fail without a request or accepted status.
+"""
+
+from doc2harness.benchmark.harnesses.headless.contracts import (
+    HeadlessApplicability,
+    HeadlessJudgement,
+    HeadlessObservation,
+    HeadlessOutcome,
+    HeadlessScenario,
+)
+
+from ..recipes import scenario_by_id
+
+SCENARIO_ID = "budget_type_domain"
+SCENARIO: HeadlessScenario = scenario_by_id(SCENARIO_ID)
+RECIPE = SCENARIO.recipe
+STEPS = (RECIPE,)
+scenario = SCENARIO
+definition = SCENARIO.definition
+
+
+def judge(observation: HeadlessObservation) -> HeadlessJudgement:
+    """Check valid budgets and fail-closed behavior for every invalid variant."""
+
+    labels = tuple(probe.label for probe in RECIPE.formal_runtime_probes)
+    by_label = {run.label: run for run in observation.runs}
+    runs = tuple(by_label.get(label) for label in labels)
+    if any(
+        run is None
+        or run.start_error
+        or run.timed_out
+        or not run.cleanup_complete
+        or not run.exit_status
+        for run in runs
+    ):
+        return HeadlessJudgement(
+            HeadlessOutcome.FAIL,
+            HeadlessApplicability.APPLICABLE,
+            "HEADLESS_FORMAL_MATRIX_INCOMPLETE",
+        )
+    valid = runs[:2]
+    invalid = runs[2:]
+    valid_ok = all(
+        run is not None
+        and run.rc == 0
+        and run.exit_status in {"Submitted", "LimitsExceeded"}
+        and len(run.requests) == 1
+        for run in valid
+    )
+    invalid_ok = all(
+        run is not None
+        and run.rc not in (None, 0)
+        and run.exit_status not in {"Submitted", "LimitsExceeded"}
+        and not run.requests
+        for run in invalid
+    )
+    return HeadlessJudgement(
+        HeadlessOutcome.PASS if valid_ok and invalid_ok else HeadlessOutcome.FAIL,
+        HeadlessApplicability.APPLICABLE,
+        "HEADLESS_PROFILE_CHECKED",
+    )
+
+
+__all__ = ["RECIPE", "SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/headless/scenarios/budget_type_domain_control.py b/code/src/doc2harness/benchmark/harnesses/headless/scenarios/budget_type_domain_control.py
new file mode 100644
index 0000000000000000000000000000000000000000..890a34be94ef5d43921cb530ad22088aa8af1cc8
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/headless/scenarios/budget_type_domain_control.py
@@ -0,0 +1,60 @@
+"""Verify that valid budget values are accepted by the headless runtime.
+
+1. Run the valid-zero and valid-positive budget probes.
+2. Capture exit status, request count, and submission status for each probe.
+3. Require one request and a successful submitted/limited result per probe.
+4. Return PASS only when the complete valid-budget control matrix is observed.
+"""
+
+from doc2harness.benchmark.harnesses.headless.contracts import (
+    HeadlessApplicability,
+    HeadlessJudgement,
+    HeadlessObservation,
+    HeadlessOutcome,
+    HeadlessScenario,
+)
+
+from ..recipes import scenario_by_id
+
+SCENARIO_ID = "budget_type_domain_control"
+SCENARIO: HeadlessScenario = scenario_by_id(SCENARIO_ID)
+RECIPE = SCENARIO.recipe
+STEPS = (RECIPE,)
+scenario = SCENARIO
+definition = SCENARIO.definition
+
+
+def judge(observation: HeadlessObservation) -> HeadlessJudgement:
+    """Check the valid budget probes without evaluating invalid input variants."""
+
+    labels = tuple(probe.label for probe in RECIPE.formal_runtime_probes)
+    by_label = {run.label: run for run in observation.runs}
+    runs = tuple(by_label.get(label) for label in labels)
+    if any(
+        run is None
+        or run.start_error
+        or run.timed_out
+        or not run.cleanup_complete
+        or not run.exit_status
+        for run in runs
+    ):
+        return HeadlessJudgement(
+            HeadlessOutcome.FAIL,
+            HeadlessApplicability.APPLICABLE,
+            "HEADLESS_FORMAL_MATRIX_INCOMPLETE",
+        )
+    passed = all(
+        run is not None
+        and run.rc == 0
+        and run.exit_status in {"Submitted", "LimitsExceeded"}
+        and len(run.requests) == 1
+        for run in runs
+    )
+    return HeadlessJudgement(
+        HeadlessOutcome.PASS if passed else HeadlessOutcome.FAIL,
+        HeadlessApplicability.APPLICABLE,
+        "HEADLESS_PROFILE_CHECKED",
+    )
+
+
+__all__ = ["RECIPE", "SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/headless/scenarios/exec_requires_bg.py b/code/src/doc2harness/benchmark/harnesses/headless/scenarios/exec_requires_bg.py
new file mode 100644
index 0000000000000000000000000000000000000000..bb780bdfd4396ec6e98a46635479af497f061155
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/headless/scenarios/exec_requires_bg.py
@@ -0,0 +1,35 @@
+"""Check that an orphan --exec is rejected without executing its command.
+
+1. Run the healthy background control and then the orphan foreground form.
+2. Observe each external return code and marker path in the shared workspace.
+3. Require a closed control and accept only target rc2 with no target marker.
+"""
+
+from doc2harness.benchmark.harnesses.headless.contracts import (
+    HeadlessApplicability, HeadlessJudgement, HeadlessObservation,
+    HeadlessOutcome, HeadlessScenario,
+)
+from doc2harness.benchmark.harnesses.headless.recipes import scenario_by_id
+
+SCENARIO_ID = "exec_requires_bg"
+SCENARIO: HeadlessScenario = scenario_by_id(SCENARIO_ID)
+scenario = SCENARIO
+RECIPE = SCENARIO.recipe
+STEPS = (RECIPE,)
+definition = SCENARIO.definition
+
+
+def judge(observation: HeadlessObservation) -> HeadlessJudgement:
+    if len(observation.runs) < 2:
+        return HeadlessJudgement(HeadlessOutcome.FAIL, HeadlessApplicability.INCONCLUSIVE, "EXEC_BG_TARGET_UNOBSERVED")
+    control, target = observation.runs[:2]
+    if not (control.rc == 0 and "control.marker" in control.written_paths):
+        return HeadlessJudgement(HeadlessOutcome.FAIL, HeadlessApplicability.INCONCLUSIVE, "EXEC_BG_CONTROL_GATE_UNSATISFIED")
+    if "target.marker" in target.written_paths:
+        return HeadlessJudgement(HeadlessOutcome.FAIL, HeadlessApplicability.APPLICABLE, "EXEC_BG_ORPHAN_EXECUTED")
+    if target.rc == 2:
+        return HeadlessJudgement(HeadlessOutcome.PASS, HeadlessApplicability.APPLICABLE, "EXEC_BG_ORPHAN_REJECTED")
+    return HeadlessJudgement(HeadlessOutcome.FAIL, HeadlessApplicability.APPLICABLE, "EXEC_BG_ORPHAN_NOT_REJECTED")
+
+
+__all__ = ["RECIPE", "STEPS", "definition", "scenario", "SCENARIO", "SCENARIO_ID", "judge"]
diff --git a/code/src/doc2harness/benchmark/harnesses/headless/scenarios/exec_requires_bg_control.py b/code/src/doc2harness/benchmark/harnesses/headless/scenarios/exec_requires_bg_control.py
new file mode 100644
index 0000000000000000000000000000000000000000..b04c0e92faf4572230faf7b3e5d7b394782978f8
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/headless/scenarios/exec_requires_bg_control.py
@@ -0,0 +1,34 @@
+"""Check that the explicit background form executes and writes its marker.
+
+1. Launch the artifact with ``--bg ... --exec touch control.marker``.
+2. Observe the external return code and workspace-relative written paths.
+3. Pass only when the process succeeds and the marker is present.
+"""
+
+from doc2harness.benchmark.harnesses.headless.contracts import (
+    HeadlessApplicability, HeadlessJudgement, HeadlessObservation,
+    HeadlessOutcome, HeadlessScenario,
+)
+from doc2harness.benchmark.harnesses.headless.recipes import scenario_by_id
+
+SCENARIO_ID = "exec_requires_bg_control"
+SCENARIO: HeadlessScenario = scenario_by_id(SCENARIO_ID)
+scenario = SCENARIO
+RECIPE = SCENARIO.recipe
+STEPS = (RECIPE,)
+definition = SCENARIO.definition
+
+
+def judge(observation: HeadlessObservation) -> HeadlessJudgement:
+    run = observation.runs[0] if observation.runs else None
+    if run is None:
+        return HeadlessJudgement(HeadlessOutcome.FAIL, HeadlessApplicability.INCONCLUSIVE, "EXEC_BG_CONTROL_UNOBSERVED")
+    marker = "control.marker" in run.written_paths
+    if run.rc == 0 and marker:
+        return HeadlessJudgement(HeadlessOutcome.PASS, HeadlessApplicability.APPLICABLE, "EXEC_BG_CONTROL_CLOSED")
+    if marker and run.rc != 0:
+        return HeadlessJudgement(HeadlessOutcome.FAIL, HeadlessApplicability.APPLICABLE, "EXEC_BG_CONTROL_CONTRADICTION")
+    return HeadlessJudgement(HeadlessOutcome.FAIL, HeadlessApplicability.INCONCLUSIVE, "EXEC_BG_CONTROL_UNOBSERVED")
+
+
+__all__ = ["RECIPE", "STEPS", "definition", "scenario", "SCENARIO", "SCENARIO_ID", "judge"]
diff --git a/code/src/doc2harness/benchmark/harnesses/headless/scenarios/headless_p_json_model_error_wellformed.py b/code/src/doc2harness/benchmark/harnesses/headless/scenarios/headless_p_json_model_error_wellformed.py
new file mode 100644
index 0000000000000000000000000000000000000000..474072e6a50d4ccbbc91d16ad5c8b71bcc38e2d2
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/headless/scenarios/headless_p_json_model_error_wellformed.py
@@ -0,0 +1,64 @@
+"""Require a model-error headless run to remain a valid JSON error.
+
+1. Launch the target recipe with the configured model-error gateway.
+2. Capture the main process output and at least one model request.
+3. Parse the response as JSON without relying on human-readable logs.
+4. Pass only when the JSON is valid and the process exits with code one.
+"""
+
+import json
+
+from doc2harness.benchmark.harnesses.headless.contracts import (
+    HeadlessApplicability,
+    HeadlessJudgement,
+    HeadlessObservation,
+    HeadlessOutcome,
+    HeadlessScenario,
+)
+
+from ..recipes import scenario_by_id
+
+SCENARIO_ID = "headless_p_json_model_error_wellformed"
+SCENARIO: HeadlessScenario = scenario_by_id(SCENARIO_ID)
+RECIPE = SCENARIO.recipe
+STEPS = (RECIPE,)
+scenario = SCENARIO
+definition = SCENARIO.definition
+
+
+def judge(observation: HeadlessObservation) -> HeadlessJudgement:
+    """Require a live request and a parseable non-success response."""
+
+    main = next((run for run in observation.runs if run.label == "main"), None)
+    requests = tuple(request for run in observation.runs for request in run.requests)
+    if not observation.cli_available:
+        return HeadlessJudgement(
+            HeadlessOutcome.FAIL,
+            HeadlessApplicability.INCONCLUSIVE,
+            "HEADLESS_CLI_UNAVAILABLE",
+        )
+    if observation.driver_error:
+        return HeadlessJudgement(
+            HeadlessOutcome.FAIL,
+            HeadlessApplicability.APPLICABLE,
+            "HEADLESS_DRIVER_ERROR",
+        )
+    if main is None or not requests:
+        return HeadlessJudgement(
+            HeadlessOutcome.FAIL,
+            HeadlessApplicability.INCONCLUSIVE,
+            "HEADLESS_ERROR_PATH_UNOBSERVED",
+        )
+    try:
+        value = json.loads(main.stdout.strip())
+    except (TypeError, ValueError, json.JSONDecodeError):
+        value = None
+    passed = value is not None and main.rc == 1
+    return HeadlessJudgement(
+        HeadlessOutcome.PASS if passed else HeadlessOutcome.FAIL,
+        HeadlessApplicability.APPLICABLE,
+        "HEADLESS_PROFILE_CHECKED",
+    )
+
+
+__all__ = ["RECIPE", "SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/headless/scenarios/headless_p_json_wellformed.py b/code/src/doc2harness/benchmark/harnesses/headless/scenarios/headless_p_json_wellformed.py
new file mode 100644
index 0000000000000000000000000000000000000000..b56f2c70a22a576ea0e21f7593f7bfd187afd7ee
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/headless/scenarios/headless_p_json_wellformed.py
@@ -0,0 +1,74 @@
+"""Require the normal headless control run to emit clean JSON.
+
+1. Launch the control recipe with its fixed JSON response gateway.
+2. Capture the main process output and terminal status.
+3. Parse the output as one JSON value and look for the control sentinel.
+4. Pass only when parsing, sentinel, exit code, and noise constraints hold.
+"""
+
+import json
+
+from doc2harness.benchmark.harnesses.headless.contracts import (
+    HeadlessApplicability,
+    HeadlessJudgement,
+    HeadlessObservation,
+    HeadlessOutcome,
+    HeadlessScenario,
+)
+
+from ..recipes import scenario_by_id
+
+SCENARIO_ID = "headless_p_json_wellformed"
+SCENARIO: HeadlessScenario = scenario_by_id(SCENARIO_ID)
+RECIPE = SCENARIO.recipe
+# This control uses the fixed-reply recipe without additional scenario-specific
+# setup; retaining the complete recipe as the declarative step preserves every
+# recipe default and makes the selected gateway visible in this file.
+STEPS = (RECIPE,)
+scenario = SCENARIO
+definition = SCENARIO.definition
+
+
+def judge(observation: HeadlessObservation) -> HeadlessJudgement:
+    """Check the fixed JSON control response without reading host state."""
+
+    main = next((run for run in observation.runs if run.label == "main"), None)
+    if not observation.cli_available:
+        return HeadlessJudgement(
+            HeadlessOutcome.FAIL,
+            HeadlessApplicability.INCONCLUSIVE,
+            "HEADLESS_CLI_UNAVAILABLE",
+        )
+    if observation.driver_error:
+        return HeadlessJudgement(
+            HeadlessOutcome.FAIL,
+            HeadlessApplicability.APPLICABLE,
+            "HEADLESS_DRIVER_ERROR",
+        )
+    if main is None:
+        return HeadlessJudgement(
+            HeadlessOutcome.FAIL,
+            HeadlessApplicability.INCONCLUSIVE,
+            "HEADLESS_MAIN_MISSING",
+        )
+    try:
+        value = json.loads(main.stdout.strip())
+    except (TypeError, ValueError, json.JSONDecodeError):
+        value = None
+    passed = (
+        value is not None
+        and RECIPE.oracle.sentinel in json.dumps(value, ensure_ascii=False)
+        and main.rc == 0
+        and not any(
+            marker in main.stdout
+            for marker in ("<function_calls>", "<tool_code>", "<invoke", "<response>", "TurnBegin", "StepBegin", "Traceback (most recent call)")
+        )
+    )
+    return HeadlessJudgement(
+        HeadlessOutcome.PASS if passed else HeadlessOutcome.FAIL,
+        HeadlessApplicability.APPLICABLE,
+        "HEADLESS_PROFILE_CHECKED",
+    )
+
+
+__all__ = ["RECIPE", "SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/headless/scenarios/p34_ctl_bare_mention_not_auto_read.py b/code/src/doc2harness/benchmark/harnesses/headless/scenarios/p34_ctl_bare_mention_not_auto_read.py
new file mode 100644
index 0000000000000000000000000000000000000000..7841313368de0ffec0879005c2cbf16d77885819
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/headless/scenarios/p34_ctl_bare_mention_not_auto_read.py
@@ -0,0 +1,52 @@
+"""Verify a bare mention is not automatically read into the request.
+
+1. Run the task containing only a bare file mention.
+2. Observe the main process and request records.
+3. Require an observable request without the planted file token.
+4. Pass only when implicit reading is absent.
+"""
+
+from doc2harness.benchmark.harnesses.headless.contracts import (
+    HeadlessApplicability,
+    HeadlessJudgement,
+    HeadlessObservation,
+    HeadlessOutcome,
+    HeadlessScenario,
+)
+
+from ..recipes import scenario_by_id
+
+SCENARIO_ID = "p34_ctl_bare_mention_not_auto_read"
+SCENARIO: HeadlessScenario = scenario_by_id(SCENARIO_ID)
+RECIPE = SCENARIO.recipe
+STEPS = (RECIPE,)
+scenario = SCENARIO
+definition = SCENARIO.definition
+
+
+def judge(observation: HeadlessObservation) -> HeadlessJudgement:
+    run = next((r for r in observation.runs if r.label == "main"), None)
+    if run is None:
+        return HeadlessJudgement(
+            HeadlessOutcome.FAIL,
+            HeadlessApplicability.INCONCLUSIVE,
+            "HEADLESS_MAIN_MISSING",
+        )
+    if not run.requests:
+        return HeadlessJudgement(
+            HeadlessOutcome.FAIL,
+            HeadlessApplicability.INCONCLUSIVE,
+            "HEADLESS_REQUEST_UNOBSERVED",
+        )
+    present = any(
+        RECIPE.probe_token in request.probe_hits or RECIPE.probe_token in request.body
+        for request in run.requests
+    )
+    return HeadlessJudgement(
+        HeadlessOutcome.PASS if not present else HeadlessOutcome.FAIL,
+        HeadlessApplicability.APPLICABLE,
+        "HEADLESS_PROFILE_CHECKED",
+    )
+
+
+__all__ = ["RECIPE", "SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/headless/scenarios/p34_ctl_task_text_reaches_wire.py b/code/src/doc2harness/benchmark/harnesses/headless/scenarios/p34_ctl_task_text_reaches_wire.py
new file mode 100644
index 0000000000000000000000000000000000000000..3b1d974c6b3040a8c7d6d0b5a08e190353c9e5a9
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/headless/scenarios/p34_ctl_task_text_reaches_wire.py
@@ -0,0 +1,46 @@
+"""Verify the task text reaches the model request wire.
+
+1. Run the task containing the explicit reference text.
+2. Observe the main process and request records.
+3. Require the planted task marker in a request.
+4. Pass only when the marker is transmitted.
+"""
+
+from doc2harness.benchmark.harnesses.headless.contracts import (
+    HeadlessApplicability,
+    HeadlessJudgement,
+    HeadlessObservation,
+    HeadlessOutcome,
+    HeadlessScenario,
+)
+
+from ..recipes import scenario_by_id
+
+SCENARIO_ID = "p34_ctl_task_text_reaches_wire"
+SCENARIO: HeadlessScenario = scenario_by_id(SCENARIO_ID)
+RECIPE = SCENARIO.recipe
+STEPS = (RECIPE,)
+scenario = SCENARIO
+definition = SCENARIO.definition
+
+
+def judge(observation: HeadlessObservation) -> HeadlessJudgement:
+    run = next((r for r in observation.runs if r.label == "main"), None)
+    if run is None or not run.requests:
+        return HeadlessJudgement(
+            HeadlessOutcome.FAIL,
+            HeadlessApplicability.INCONCLUSIVE,
+            "HEADLESS_REQUEST_UNOBSERVED",
+        )
+    present = any(
+        RECIPE.probe_token in request.probe_hits or RECIPE.probe_token in request.body
+        for request in run.requests
+    )
+    return HeadlessJudgement(
+        HeadlessOutcome.PASS if present else HeadlessOutcome.FAIL,
+        HeadlessApplicability.APPLICABLE,
+        "HEADLESS_PROFILE_CHECKED",
+    )
+
+
+__all__ = ["RECIPE", "SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/headless/scenarios/runtime_error_stdout.py b/code/src/doc2harness/benchmark/harnesses/headless/scenarios/runtime_error_stdout.py
new file mode 100644
index 0000000000000000000000000000000000000000..c2df26570058c178a805753679cd36ecb7130e9b
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/headless/scenarios/runtime_error_stdout.py
@@ -0,0 +1,46 @@
+"""Verify that a model runtime error is surfaced without fake stdout.
+
+1. Run the model-runtime-error formal contract probe.
+2. Capture request count, stdout, return code, and exit status.
+3. Require one request, rc 1, empty stdout, and Error status.
+4. Return PASS only when the runtime error remains honest.
+"""
+
+from doc2harness.benchmark.harnesses.headless.contracts import (
+    HeadlessApplicability,
+    HeadlessJudgement,
+    HeadlessObservation,
+    HeadlessOutcome,
+    HeadlessScenario,
+)
+
+from ..recipes import scenario_by_id
+
+SCENARIO_ID = "runtime_error_stdout"
+SCENARIO: HeadlessScenario = scenario_by_id(SCENARIO_ID)
+RECIPE = SCENARIO.recipe
+STEPS = (RECIPE,)
+scenario = SCENARIO
+definition = SCENARIO.definition
+
+
+def judge(observation: HeadlessObservation) -> HeadlessJudgement:
+    """Check honest runtime-error evidence for the target route."""
+
+    labels = tuple(probe.label for probe in RECIPE.formal_contract_probes)
+    by_label = {run.label: run for run in observation.runs}
+    runs = tuple(by_label.get(label) for label in labels)
+    if any(run is None or run.start_error or run.timed_out or not run.cleanup_complete for run in runs):
+        return HeadlessJudgement(HeadlessOutcome.FAIL, HeadlessApplicability.APPLICABLE, "HEADLESS_CONTRACT_MATRIX_INCOMPLETE")
+    passed = all(
+        run is not None
+        and run.rc == 1
+        and len(run.requests) == 1
+        and run.stdout == ""
+        and run.exit_status == "Error"
+        for run in runs
+    )
+    return HeadlessJudgement(HeadlessOutcome.PASS if passed else HeadlessOutcome.FAIL, HeadlessApplicability.APPLICABLE, "HEADLESS_PROFILE_CHECKED")
+
+
+__all__ = ["RECIPE", "SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/headless/scenarios/runtime_error_stdout_control.py b/code/src/doc2harness/benchmark/harnesses/headless/scenarios/runtime_error_stdout_control.py
new file mode 100644
index 0000000000000000000000000000000000000000..02ac097d87bb95aef2b7d1e44972e88f437674a3
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/headless/scenarios/runtime_error_stdout_control.py
@@ -0,0 +1,46 @@
+"""Verify that a healthy model route returns the canonical reply.
+
+1. Run the model-success formal contract probe.
+2. Capture request count, stdout, return code, and exit status.
+3. Require two requests and the exact submitted reply.
+4. Return PASS only when the control route is fully healthy.
+"""
+
+from doc2harness.benchmark.harnesses.headless.contracts import (
+    HeadlessApplicability,
+    HeadlessJudgement,
+    HeadlessObservation,
+    HeadlessOutcome,
+    HeadlessScenario,
+)
+
+from ..recipes import scenario_by_id
+
+SCENARIO_ID = "runtime_error_stdout_control"
+SCENARIO: HeadlessScenario = scenario_by_id(SCENARIO_ID)
+RECIPE = SCENARIO.recipe
+STEPS = (RECIPE,)
+scenario = SCENARIO
+definition = SCENARIO.definition
+
+
+def judge(observation: HeadlessObservation) -> HeadlessJudgement:
+    """Check the healthy model control response."""
+
+    labels = tuple(probe.label for probe in RECIPE.formal_contract_probes)
+    by_label = {run.label: run for run in observation.runs}
+    runs = tuple(by_label.get(label) for label in labels)
+    if any(run is None or run.start_error or run.timed_out or not run.cleanup_complete for run in runs):
+        return HeadlessJudgement(HeadlessOutcome.FAIL, HeadlessApplicability.APPLICABLE, "HEADLESS_CONTRACT_MATRIX_INCOMPLETE")
+    passed = all(
+        run is not None
+        and run.rc == 0
+        and len(run.requests) == 2
+        and run.stdout == "EXACT_REPLY_6047\n"
+        and run.exit_status == "Submitted"
+        for run in runs
+    )
+    return HeadlessJudgement(HeadlessOutcome.PASS if passed else HeadlessOutcome.FAIL, HeadlessApplicability.APPLICABLE, "HEADLESS_PROFILE_CHECKED")
+
+
+__all__ = ["RECIPE", "SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/headless/scenarios/session_flag_subcommand_conflict.py b/code/src/doc2harness/benchmark/harnesses/headless/scenarios/session_flag_subcommand_conflict.py
new file mode 100644
index 0000000000000000000000000000000000000000..63879ed45dbe4133adc691b05f637d2fdad1cda6
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/headless/scenarios/session_flag_subcommand_conflict.py
@@ -0,0 +1,45 @@
+"""Check that --resume is not silently discarded by management commands.
+
+1. Run each management command once without and once with a nonexistent session.
+2. Observe return codes and output text for every baseline/flagged pair.
+3. Reject silent rc0 output identical to baseline; accept rc2 or an explicit session error.
+"""
+
+from doc2harness.benchmark.harnesses.headless.contracts import (
+    HeadlessApplicability, HeadlessJudgement, HeadlessObservation,
+    HeadlessOutcome, HeadlessScenario,
+)
+from doc2harness.benchmark.harnesses.headless.recipes import scenario_by_id
+
+SCENARIO_ID = "session_flag_subcommand_conflict"
+SCENARIO: HeadlessScenario = scenario_by_id(SCENARIO_ID)
+scenario = SCENARIO
+RECIPE = SCENARIO.recipe
+STEPS = (RECIPE,)
+definition = SCENARIO.definition
+
+
+def _face_verdict(base, flagged):
+    if flagged.rc == 2:
+        return "PASS"
+    blob = (flagged.stdout + "\n" + flagged.stderr).lower()
+    mentions = any(token in blob for token in ("resume", "session", "conflict", "互斥", "会话"))
+    if flagged.rc is not None and flagged.rc != 0 and mentions:
+        return "PASS"
+    if flagged.rc == 0 and flagged.stdout.strip() == base.stdout.strip() and not mentions:
+        return "FAIL"
+    return "INCONCLUSIVE"
+
+
+def judge(observation: HeadlessObservation) -> HeadlessJudgement:
+    if len(observation.runs) < 4:
+        return HeadlessJudgement(HeadlessOutcome.FAIL, HeadlessApplicability.INCONCLUSIVE, "SESSION_FLAG_MATRIX_INCOMPLETE")
+    verdicts = tuple(_face_verdict(observation.runs[index], observation.runs[index + 1]) for index in (0, 2))
+    if "FAIL" in verdicts:
+        return HeadlessJudgement(HeadlessOutcome.FAIL, HeadlessApplicability.APPLICABLE, "SESSION_FLAGS_SILENTLY_DROPPED")
+    if "PASS" in verdicts:
+        return HeadlessJudgement(HeadlessOutcome.PASS, HeadlessApplicability.APPLICABLE, "SESSION_FLAGS_REJECTED")
+    return HeadlessJudgement(HeadlessOutcome.FAIL, HeadlessApplicability.INCONCLUSIVE, "SESSION_FLAGS_NOT_OBSERVED")
+
+
+__all__ = ["RECIPE", "STEPS", "definition", "scenario", "SCENARIO", "SCENARIO_ID", "judge"]
diff --git a/code/src/doc2harness/benchmark/harnesses/headless/scenarios/session_flag_subcommand_conflict_control.py b/code/src/doc2harness/benchmark/harnesses/headless/scenarios/session_flag_subcommand_conflict_control.py
new file mode 100644
index 0000000000000000000000000000000000000000..7eabbccb108f73a08eea007848baf87e58382a00
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/headless/scenarios/session_flag_subcommand_conflict_control.py
@@ -0,0 +1,28 @@
+"""Check that at least one management subcommand has a healthy baseline.
+
+1. Run memory status and config list without a session flag.
+2. Observe both external return codes in one isolated home/workspace.
+3. Pass when either management face returns rc0; otherwise remain inconclusive.
+"""
+
+from doc2harness.benchmark.harnesses.headless.contracts import (
+    HeadlessApplicability, HeadlessJudgement, HeadlessObservation,
+    HeadlessOutcome, HeadlessScenario,
+)
+from doc2harness.benchmark.harnesses.headless.recipes import scenario_by_id
+
+SCENARIO_ID = "session_flag_subcommand_conflict_control"
+SCENARIO: HeadlessScenario = scenario_by_id(SCENARIO_ID)
+scenario = SCENARIO
+RECIPE = SCENARIO.recipe
+STEPS = (RECIPE,)
+definition = SCENARIO.definition
+
+
+def judge(observation: HeadlessObservation) -> HeadlessJudgement:
+    if any(run.rc == 0 for run in observation.runs[:2]):
+        return HeadlessJudgement(HeadlessOutcome.PASS, HeadlessApplicability.APPLICABLE, "SESSION_FLAG_BASELINE_HEALTHY")
+    return HeadlessJudgement(HeadlessOutcome.FAIL, HeadlessApplicability.INCONCLUSIVE, "SESSION_FLAG_BASELINE_UNAVAILABLE")
+
+
+__all__ = ["RECIPE", "STEPS", "definition", "scenario", "SCENARIO", "SCENARIO_ID", "judge"]
diff --git a/code/src/doc2harness/benchmark/harnesses/permission/__init__.py b/code/src/doc2harness/benchmark/harnesses/permission/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..8593449b1ecc4acea80a759c70172058bdab6730
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/permission/__init__.py
@@ -0,0 +1,5 @@
+"""Child-process permission Harness public surface."""
+
+__all__ = [
+    
+]
diff --git a/code/src/doc2harness/benchmark/harnesses/permission/adapter.py b/code/src/doc2harness/benchmark/harnesses/permission/adapter.py
new file mode 100644
index 0000000000000000000000000000000000000000..7e6873b70ed207431b47fdfaed80dbee50ad50a9
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/permission/adapter.py
@@ -0,0 +1,90 @@
+"""Execution adapter for the permission-child Harness layer."""
+
+from __future__ import annotations
+
+import hashlib
+from dataclasses import dataclass
+
+from doc2harness.benchmark.harnesses.permission.contracts import (
+    PermissionScenario,
+)
+from doc2harness.benchmark.harnesses.permission.fixtures import (
+    PermissionFixturePlan,
+    materialize_permission_fixture,
+)
+from doc2harness.benchmark.harnesses.permission.gateway import (
+    PermissionGatewayTurn,
+    build_permission_gateway_plan,
+)
+from doc2harness.contracts.canonical import canonical_json
+from doc2harness.contracts.primitives import ContractDocumentError
+
+
+@dataclass(frozen=True, slots=True)
+class PermissionExecutionPlan:
+    scenario_id: str
+    fixture: PermissionFixturePlan
+    gateway_turns: tuple[PermissionGatewayTurn, ...]
+    deny_rules: tuple[str, ...]
+    setup_commands: tuple[str, ...]
+    variant_command: str | None
+    counterfactual_setup_commands: tuple[str, ...]
+    timeout_seconds: int
+    plan_digest: str
+
+
+def build_permission_execution_plan(
+    scenario: PermissionScenario, /
+) -> PermissionExecutionPlan:
+    if type(scenario) is not PermissionScenario:
+        raise ContractDocumentError("permission execution requires an exact scenario")
+    fixture = materialize_permission_fixture(scenario)
+    turns = build_permission_gateway_plan(scenario)
+    body = {
+        "deny_rules": list(scenario.recipe.deny_rules),
+        "fixture_digest": fixture.plan_digest,
+        "gateway": [
+            {
+                "assistant_text": turn.assistant_text,
+                "tool_calls": [
+                    {
+                        "arguments": list(call.arguments),
+                        "call_id": call.call_id,
+                        "tool_name": call.tool_name,
+                    }
+                    for call in turn.tool_calls
+                ],
+            }
+            for turn in turns
+        ],
+        "scenario_id": scenario.definition.scenario_id,
+        "setup_commands": list(scenario.recipe.setup_commands),
+        "variant_command": scenario.recipe.variant_command,
+        "counterfactual_setup_commands": list(
+            scenario.recipe.counterfactual_setup_commands
+        ),
+        "timeout_seconds": scenario.recipe.timeout_seconds,
+    }
+    digest = (
+        "sha256:"
+        + hashlib.sha256(
+            b"doc2harness.permission-child-plan/1\0" + canonical_json(body)
+        ).hexdigest()
+    )
+    return PermissionExecutionPlan(
+        scenario.definition.scenario_id,
+        fixture,
+        turns,
+        scenario.recipe.deny_rules,
+        scenario.recipe.setup_commands,
+        scenario.recipe.variant_command,
+        scenario.recipe.counterfactual_setup_commands,
+        scenario.recipe.timeout_seconds,
+        digest,
+    )
+
+
+__all__ = [
+    "PermissionExecutionPlan",
+    "build_permission_execution_plan",
+]
diff --git a/code/src/doc2harness/benchmark/harnesses/permission/catalog.toml b/code/src/doc2harness/benchmark/harnesses/permission/catalog.toml
new file mode 100644
index 0000000000000000000000000000000000000000..2db98da26a935e7a20e142666b50812393e56a6d
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/permission/catalog.toml
@@ -0,0 +1,21 @@
+format = "doc2harness.catalog-shard-source/1"
+function_id = "permission"
+resource = "benchmark/harnesses/permission/catalog.toml"
+exports = [
+  { module = "doc2harness.benchmark.harnesses.permission.scenarios.ask_mode_denies_write_and_allows_read", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.permission.scenarios.autoedit_blocks_mutable_shell", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.permission.scenarios.autoreview_blocks_canonical_danger", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.permission.scenarios.blocking_hook_missing_exec_control", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.permission.scenarios.blocking_hook_missing_exec_fail_closed", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.permission.scenarios.custom_cmd_at_file_read_fences_control", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.permission.scenarios.custom_cmd_at_file_respects_read_fences", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.permission.scenarios.deny_blocks_monitor_spawned_cmd", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.permission.scenarios.hook_absent_bash_write_runs_control", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.permission.scenarios.hook_blocks_bash_write", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.permission.scenarios.monitor_spawns_command_control", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.permission.scenarios.network_off_blocks_offline_npm_test", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.permission.scenarios.p37_ctl_plain_cmd_chain_runs", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.permission.scenarios.p46_ctl_yolo_rm_really_deletes", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.permission.scenarios.p60_ctl_yolo_both_work", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.permission.scenarios.yolo_mutable_shell_lands_control", export = "definition" },
+]
diff --git a/code/src/doc2harness/benchmark/harnesses/permission/contracts.py b/code/src/doc2harness/benchmark/harnesses/permission/contracts.py
new file mode 100644
index 0000000000000000000000000000000000000000..7f1054721d10839cc1d29333950e3557d8d21df0
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/permission/contracts.py
@@ -0,0 +1,557 @@
+"""Closed declarations and observations for child-process permission scenarios."""
+
+from __future__ import annotations
+
+import hashlib
+import re
+from dataclasses import dataclass
+from enum import Enum
+
+from doc2harness.benchmark.definition import (
+    Classification,
+    ComponentKind,
+    ComponentRef,
+    DependencyKind,
+    DependencyRef,
+    ExperimentBinding,
+    ScenarioDefinition,
+    ScenarioDifficulty,
+    ScenarioRole,
+    UnsupportedPolicy,
+    definition_digest,
+)
+from doc2harness.contracts.canonical import canonical_json
+from doc2harness.contracts.primitives import ContractDocumentError
+
+_ID = re.compile(r"[a-z0-9][a-z0-9._-]{0,127}\Z", re.ASCII)
+_ORIGINAL = "ORIG_PERM_0001\n"
+
+
+class PermissionOracleProfile(str, Enum):
+    DENY_BLOCKED = "DENY_BLOCKED"
+    COMMAND_EXECUTED = "COMMAND_EXECUTED"
+    TARGET_UNCHANGED = "TARGET_UNCHANGED"
+    TARGET_MUTATED = "TARGET_MUTATED"
+    WRITE_BLOCKED_READ_ALLOWED = "WRITE_BLOCKED_READ_ALLOWED"
+    WRITE_AND_READ_EXECUTED = "WRITE_AND_READ_EXECUTED"
+    MONITOR_EXECUTED_CONTROL = "MONITOR_EXECUTED_CONTROL"
+    MONITOR_BLOCKED = "MONITOR_BLOCKED"
+    WIRE_TOKENS_OBSERVED = "WIRE_TOKENS_OBSERVED"
+    WIRE_TOKENS_FENCED = "WIRE_TOKENS_FENCED"
+    HEALTHY_HOOK_OPERATION_LANDED = "HEALTHY_HOOK_OPERATION_LANDED"
+    HOOK_FAILURE_OPERATION_BLOCKED = "HOOK_FAILURE_OPERATION_BLOCKED"
+
+
+class PermissionOutcome(str, Enum):
+    PASS = "PASS"
+    FAIL = "FAIL"
+
+
+class PermissionApplicability(str, Enum):
+    APPLICABLE = "APPLICABLE"
+    INCONCLUSIVE = "INCONCLUSIVE"
+
+
+def _string_tuple(value: object, label: str, maximum: int = 256) -> tuple[str, ...]:
+    if (
+        type(value) is not tuple
+        or len(value) > maximum
+        or any(
+            type(item) is not str or not item or len(item) > 16_384 for item in value
+        )
+    ):
+        raise ContractDocumentError(f"permission {label} is invalid")
+    return value
+
+
+@dataclass(frozen=True, slots=True)
+class PermissionStep:
+    """One closed, author-facing step in a permission probe."""
+
+    operation: str
+    value: object
+
+    def __post_init__(self) -> None:
+        if self.operation not in {
+            "set_mode",
+            "add_deny_rule",
+            "seed_file",
+            "allow_command",
+            "probe_command",
+            "probe_tool",
+            "capture_target_file",
+        }:
+            raise ContractDocumentError("permission step operation is invalid")
+
+
+def set_mode(command: str) -> PermissionStep:
+    return PermissionStep("set_mode", command)
+
+
+def add_deny_rule(rule: str) -> PermissionStep:
+    return PermissionStep("add_deny_rule", rule)
+
+
+def seed_file(path: str, content: str) -> PermissionStep:
+    return PermissionStep("seed_file", (path, content))
+
+
+def allow_command(command: str) -> PermissionStep:
+    return PermissionStep("allow_command", command)
+
+
+def probe_command(command: str) -> PermissionStep:
+    return PermissionStep("probe_command", command)
+
+
+def probe_tool(tool: str) -> PermissionStep:
+    return PermissionStep("probe_tool", tool)
+
+
+def capture_target_file(path: str, *, present: bool) -> PermissionStep:
+    return PermissionStep("capture_target_file", (path, present))
+
+
+@dataclass(frozen=True, slots=True)
+class PermissionRecipe:
+    """Path-independent declaration of one permission experiment."""
+
+    deny_rules: tuple[str, ...]
+    setup_commands: tuple[str, ...]
+    seed_files: tuple[tuple[str, str], ...]
+    allow_command: str
+    probe_command: str
+    oracle_profile: PermissionOracleProfile
+    second_probe: str | None = None
+    probe_tool: str = "bash"
+    probe_arguments: tuple[tuple[str, str], ...] = ()
+    expected_token: str | None = None
+    initialize_git: bool = False
+    git_baseline_files: tuple[tuple[str, str, str], ...] = ()
+    control_dependency: str | None = None
+    dependency_kind: DependencyKind = DependencyKind.GATE
+    variant_command: str | None = None
+    counterfactual_setup_commands: tuple[str, ...] = ()
+    mcp_marker: bool = False
+    settle_paths: tuple[str, ...] = ()
+    probe_tokens: tuple[str, ...] = ()
+    custom_read_external: bool = False
+    hook_exec_fixture: bool = False
+    timeout_seconds: int = 90
+
+    def __post_init__(self) -> None:
+        _string_tuple(self.deny_rules, "deny rules")
+        _string_tuple(self.setup_commands, "setup commands")
+        if type(self.seed_files) is not tuple or any(
+            type(item) is not tuple
+            or len(item) != 2
+            or type(item[0]) is not str
+            or not item[0]
+            or item[0].startswith("/")
+            or ".." in item[0].split("/")
+            or type(item[1]) is not str
+            or len(item[1]) > 8 * 1024 * 1024
+            for item in self.seed_files
+        ):
+            raise ContractDocumentError("permission seed files are invalid")
+        if len({item[0] for item in self.seed_files}) != len(self.seed_files):
+            raise ContractDocumentError("permission seed paths must be unique")
+        for value, label in (
+            (self.allow_command, "allow command"),
+            (self.probe_command, "probe command"),
+        ):
+            if type(value) is not str or not value or len(value) > 16_384:
+                raise ContractDocumentError(f"permission {label} is invalid")
+        if type(self.oracle_profile) is not PermissionOracleProfile:
+            raise ContractDocumentError("permission oracle profile is invalid")
+        if self.second_probe is not None and (
+            type(self.second_probe) is not str or not self.second_probe
+        ):
+            raise ContractDocumentError("permission second probe is invalid")
+        if (
+            type(self.probe_tool) is not str
+            or not self.probe_tool
+            or len(self.probe_tool) > 128
+        ):
+            raise ContractDocumentError("permission probe tool is invalid")
+        if type(self.probe_arguments) is not tuple or any(
+            type(item) is not tuple
+            or len(item) != 2
+            or any(type(part) is not str for part in item)
+            for item in self.probe_arguments
+        ):
+            raise ContractDocumentError("permission probe arguments are invalid")
+        if self.expected_token is not None and (
+            type(self.expected_token) is not str or not self.expected_token
+        ):
+            raise ContractDocumentError("permission expected token is invalid")
+        if type(self.initialize_git) is not bool:
+            raise ContractDocumentError("permission git policy is invalid")
+        if type(self.git_baseline_files) is not tuple or any(
+            type(item) is not tuple
+            or len(item) != 3
+            or any(type(part) is not str for part in item)
+            or not item[0]
+            or item[0].startswith("/")
+            or ".." in item[0].split("/")
+            for item in self.git_baseline_files
+        ):
+            raise ContractDocumentError("permission git baseline is invalid")
+        if bool(self.git_baseline_files) != self.initialize_git:
+            raise ContractDocumentError(
+                "permission git baseline and initialization must agree"
+            )
+        if self.control_dependency is not None and (
+            type(self.control_dependency) is not str
+            or _ID.fullmatch(self.control_dependency) is None
+        ):
+            raise ContractDocumentError("permission control dependency is invalid")
+        if type(self.dependency_kind) is not DependencyKind:
+            raise ContractDocumentError("permission dependency kind is invalid")
+        if self.control_dependency is None and self.dependency_kind is not DependencyKind.GATE:
+            raise ContractDocumentError("permission dependency kind has no dependency")
+        if self.variant_command is not None and (
+            type(self.variant_command) is not str or not self.variant_command
+        ):
+            raise ContractDocumentError("permission variant command is invalid")
+        if self.variant_command is not None:
+            raise ContractDocumentError(
+                "permission isolated variant declaration is incomplete"
+            )
+        _string_tuple(
+            self.counterfactual_setup_commands,
+            "counterfactual setup commands",
+        )
+        _string_tuple(self.settle_paths, "settle paths")
+        _string_tuple(self.probe_tokens, "probe tokens")
+        for value in (
+            self.mcp_marker,
+            self.custom_read_external,
+            self.hook_exec_fixture,
+        ):
+            if type(value) is not bool:
+                raise ContractDocumentError("permission fixture switch is invalid")
+        if bool(self.counterfactual_setup_commands):
+            raise ContractDocumentError(
+                "permission add-directory counterfactual is incomplete"
+            )
+        if (
+            type(self.timeout_seconds) is not int
+            or not 1 <= self.timeout_seconds <= 900
+        ):
+            raise ContractDocumentError("permission timeout is invalid")
+
+
+def compile_permission_steps(
+    steps: tuple[PermissionStep, ...],
+    /,
+    *,
+    oracle_profile: PermissionOracleProfile,
+    control_dependency: str | None = None,
+) -> PermissionRecipe:
+    """Compile visible permission steps into the runtime recipe."""
+
+    if type(steps) is not tuple or any(type(step) is not PermissionStep for step in steps):
+        raise ContractDocumentError("permission steps require exact typed values")
+    order = {
+        "set_mode": 0,
+        "add_deny_rule": 1,
+        "seed_file": 2,
+        "allow_command": 3,
+        "probe_command": 4,
+        "probe_tool": 5,
+        "capture_target_file": 6,
+    }
+    operations = tuple(step.operation for step in steps)
+    if tuple(order[operation] for operation in operations) != tuple(
+        sorted(order[operation] for operation in operations)
+    ):
+        raise ContractDocumentError("permission probe steps are incomplete or unordered")
+    for required in (
+        "allow_command",
+        "probe_command",
+        "probe_tool",
+        "capture_target_file",
+    ):
+        if operations.count(required) != 1:
+            raise ContractDocumentError("permission probe steps are incomplete or unordered")
+
+    def text(operation: str) -> str:
+        value = next(step.value for step in steps if step.operation == operation)
+        if type(value) is not str or not value:
+            raise ContractDocumentError(f"permission {operation} step is invalid")
+        return value
+
+    setup_commands = tuple(
+        step.value for step in steps if step.operation == "set_mode"
+    )
+    deny_rules = tuple(
+        step.value for step in steps if step.operation == "add_deny_rule"
+    )
+    if any(type(value) is not str or not value for value in setup_commands + deny_rules):
+        raise ContractDocumentError("permission setup or deny step is invalid")
+    seed_files = tuple(step.value for step in steps if step.operation == "seed_file")
+    if any(
+        type(value) is not tuple
+        or len(value) != 2
+        or type(value[0]) is not str
+        or not value[0]
+        or type(value[1]) is not str
+        for value in seed_files
+    ):
+        raise ContractDocumentError("permission seed-file step is invalid")
+    capture = next(
+        step.value for step in steps if step.operation == "capture_target_file"
+    )
+    if (
+        type(capture) is not tuple
+        or len(capture) != 2
+        or type(capture[0]) is not str
+        or not capture[0]
+        or type(capture[1]) is not bool
+    ):
+        raise ContractDocumentError("permission target-file capture is invalid")
+    # An absence capture must name the marker written by the probe.  A
+    # presence/content capture may intentionally observe a file reached via a
+    # wildcard, variable expansion, or relative path, so the literal path need
+    # not occur in the shell text.
+    if not capture[1] and capture[0] not in text("probe_command"):
+        raise ContractDocumentError("permission target-file capture differs from its probe")
+    return PermissionRecipe(
+        deny_rules=deny_rules,
+        setup_commands=setup_commands,
+        seed_files=seed_files,
+        allow_command=text("allow_command"),
+        probe_command=text("probe_command"),
+        oracle_profile=oracle_profile,
+        probe_tool=text("probe_tool"),
+        control_dependency=control_dependency,
+    )
+
+
+@dataclass(frozen=True, slots=True)
+class PermissionScenario:
+    definition: ScenarioDefinition
+    recipe: PermissionRecipe
+
+    def __post_init__(self) -> None:
+        if (
+            type(self.definition) is not ScenarioDefinition
+            or type(self.recipe) is not PermissionRecipe
+        ):
+            raise ContractDocumentError(
+                "permission scenario requires exact typed values"
+            )
+        if self.definition.classification.primary != "permission":
+            raise ContractDocumentError(
+                "permission scenario owner differs from its Harness layer"
+            )
+
+
+@dataclass(frozen=True, slots=True)
+class PermissionRawObservation:
+    """Bounded, path-free facts produced by the child execution authority."""
+
+    scenario_id: str
+    plan_digest: str
+    artifact_id: str
+    artifact_digest: str
+    request_count: int
+    allow_file_present: bool
+    deny_file_present: bool
+    target_content: str | None
+    secondary_target_content: str | None
+    escaped_path_present: bool
+    target_mode: str | None
+    seed_directory_present: bool
+    node_present: bool
+    memory_directory_present: bool
+    directory_present: bool
+    probe_tool_advertised: bool
+    git_ready: bool
+    granted_path_write_present: bool | None
+    ungranted_path_write_present: bool | None
+    canonical_variant_blocked: bool | None
+    rewritten_variant_blocked: bool | None
+    rewritten_variant_control_mutated: bool | None
+    messages_text: str
+    stdout_text: str
+    process_tree_clean: bool
+    gateway_clean: bool
+    workspace_clean: bool
+    timed_out: bool
+    backend_evidence_digest: str
+    mcp_spawned: bool = False
+    mcp_wire_events: tuple[str, ...] = ()
+    observed_tokens: tuple[str, ...] = ()
+    settled_paths: tuple[str, ...] = ()
+    hook_events: tuple[str, ...] = ()
+    advertised_tools: tuple[str, ...] = ()
+    # Harness-specific external facts are carried as a closed, auditable
+    # extension point.  They are produced by an observer, never inferred by
+    # the oracle from recorded verdicts or free-form model text.
+    external_facts: tuple[tuple[str, object], ...] = ()
+
+    def __post_init__(self) -> None:
+        if type(self.scenario_id) is not str or _ID.fullmatch(self.scenario_id) is None:
+            raise ContractDocumentError("permission observation id is invalid")
+        for digest in (
+            self.plan_digest,
+            self.artifact_digest,
+            self.backend_evidence_digest,
+        ):
+            if (
+                type(digest) is not str
+                or not digest.startswith("sha256:")
+                or len(digest) != 71
+            ):
+                raise ContractDocumentError("permission observation digest is invalid")
+        if type(self.artifact_id) is not str or _ID.fullmatch(self.artifact_id) is None:
+            raise ContractDocumentError("permission artifact id is invalid")
+        if type(self.request_count) is not int or not 0 <= self.request_count <= 4096:
+            raise ContractDocumentError("permission request count is invalid")
+        for value in (
+            self.allow_file_present,
+            self.deny_file_present,
+            self.escaped_path_present,
+            self.seed_directory_present,
+            self.node_present,
+            self.memory_directory_present,
+            self.directory_present,
+            self.probe_tool_advertised,
+            self.git_ready,
+            self.process_tree_clean,
+            self.gateway_clean,
+            self.workspace_clean,
+            self.timed_out,
+        ):
+            if type(value) is not bool:
+                raise ContractDocumentError("permission boolean fact is invalid")
+        for value in (self.target_content, self.secondary_target_content):
+            if value is not None and type(value) is not str:
+                raise ContractDocumentError("permission target content is invalid")
+        if self.target_mode is not None and type(self.target_mode) is not str:
+            raise ContractDocumentError("permission target mode is invalid")
+        for value in (
+            self.canonical_variant_blocked,
+            self.rewritten_variant_blocked,
+            self.rewritten_variant_control_mutated,
+        ):
+            if value is not None and type(value) is not bool:
+                raise ContractDocumentError("permission variant fact is invalid")
+        variant_facts = (
+            self.canonical_variant_blocked,
+            self.rewritten_variant_blocked,
+            self.rewritten_variant_control_mutated,
+        )
+        if any(value is not None for value in variant_facts) and any(
+            value is None for value in variant_facts
+        ):
+            raise ContractDocumentError("permission variant facts must be complete")
+        add_directory_facts = (
+            self.granted_path_write_present,
+            self.ungranted_path_write_present,
+        )
+        if any(value is not None for value in add_directory_facts) and any(
+            value is None for value in add_directory_facts
+        ):
+            raise ContractDocumentError(
+                "permission add-directory facts must be complete"
+            )
+        if any(
+            value is not None and type(value) is not bool
+            for value in add_directory_facts
+        ):
+            raise ContractDocumentError("permission add-directory fact is invalid")
+        if type(self.messages_text) is not str or type(self.stdout_text) is not str:
+            raise ContractDocumentError("permission text fact is invalid")
+        if type(self.mcp_spawned) is not bool:
+            raise ContractDocumentError("permission MCP marker fact is invalid")
+        _string_tuple(self.mcp_wire_events, "MCP wire events")
+        _string_tuple(self.observed_tokens, "observed tokens")
+        _string_tuple(self.settled_paths, "settled paths")
+        _string_tuple(self.hook_events, "hook events")
+        _string_tuple(self.advertised_tools, "advertised tools", maximum=4096)
+        if type(self.external_facts) is not tuple or any(
+            type(item) is not tuple
+            or len(item) != 2
+            or type(item[0]) is not str
+            or not item[0]
+            or type(item[1]) not in {bool, int, str}
+            for item in self.external_facts
+        ):
+            raise ContractDocumentError("permission external facts are invalid")
+
+
+def define_permission_scenario(
+    scenario_id: str, recipe: PermissionRecipe, role: ScenarioRole, /
+) -> PermissionScenario:
+    if type(scenario_id) is not str or _ID.fullmatch(scenario_id) is None:
+        raise ContractDocumentError("permission scenario id is invalid")
+    if type(recipe) is not PermissionRecipe or type(role) is not ScenarioRole:
+        raise ContractDocumentError("permission scenario declaration is invalid")
+    dependencies = (
+        ()
+        if recipe.control_dependency is None
+        else (DependencyRef(recipe.control_dependency, recipe.dependency_kind),)
+    )
+    definition = ScenarioDefinition(
+        scenario_id,
+        "1",
+        Classification("permission"),
+        role,
+        1_000_000 if role is ScenarioRole.TARGET else 0,
+        ScenarioDifficulty.HARD,
+        dependencies,
+        ExperimentBinding(
+            ComponentRef("permission-child-fixture", "1", ComponentKind.FIXTURE),
+            ComponentRef("permission-child-adapter", "1", ComponentKind.STIMULUS),
+            ComponentRef("permission-child-observer", "1", ComponentKind.OBSERVER),
+            ComponentRef("permission-child-oracle", "1", ComponentKind.ORACLE),
+            ComponentRef("permission-child-cleanup", "1", ComponentKind.CLEANUP),
+        ),
+        UnsupportedPolicy.FAIL,
+    )
+    return PermissionScenario(definition, recipe)
+
+
+def evaluation_digest(
+    scenario: PermissionScenario, observation: PermissionRawObservation
+) -> str:
+    body = {
+        "artifact_digest": observation.artifact_digest,
+        "backend_evidence_digest": observation.backend_evidence_digest,
+        "definition_digest": definition_digest(scenario.definition),
+        "plan_digest": observation.plan_digest,
+        "scenario_id": scenario.definition.scenario_id,
+    }
+    return (
+        "sha256:"
+        + hashlib.sha256(
+            b"doc2harness.permission-child-evaluation/1\0" + canonical_json(body)
+        ).hexdigest()
+    )
+
+
+ORIGINAL_TARGET_CONTENT = _ORIGINAL
+
+__all__ = [
+    "ORIGINAL_TARGET_CONTENT",
+    "PermissionApplicability",
+    "PermissionOracleProfile",
+    "PermissionOutcome",
+    "PermissionRawObservation",
+    "PermissionRecipe",
+    "PermissionScenario",
+    "PermissionStep",
+    "add_deny_rule",
+    "allow_command",
+    "capture_target_file",
+    "compile_permission_steps",
+    "define_permission_scenario",
+    "evaluation_digest",
+    "probe_command",
+    "probe_tool",
+    "seed_file",
+    "set_mode",
+]
diff --git a/code/src/doc2harness/benchmark/harnesses/permission/fixtures.py b/code/src/doc2harness/benchmark/harnesses/permission/fixtures.py
new file mode 100644
index 0000000000000000000000000000000000000000..d89b6ce6d9932b3ff1e7ff94d0730c9218279615
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/permission/fixtures.py
@@ -0,0 +1,67 @@
+"""Deterministic fixture materialization for permission-child scenarios."""
+
+from __future__ import annotations
+
+import hashlib
+from dataclasses import dataclass
+
+from doc2harness.benchmark.harnesses.permission.contracts import (
+    PermissionScenario,
+)
+from doc2harness.contracts.canonical import canonical_json
+from doc2harness.contracts.primitives import ContractDocumentError
+
+
+@dataclass(frozen=True, slots=True)
+class PermissionFixturePlan:
+    scenario_id: str
+    seed_files: tuple[tuple[str, str], ...]
+    initialize_git: bool
+    git_baseline_files: tuple[tuple[str, str, str], ...]
+    mcp_marker: bool
+    settle_paths: tuple[str, ...]
+    probe_tokens: tuple[str, ...]
+    custom_read_external: bool
+    hook_exec_fixture: bool
+    plan_digest: str
+
+
+def materialize_permission_fixture(
+    scenario: PermissionScenario, /
+) -> PermissionFixturePlan:
+    if type(scenario) is not PermissionScenario:
+        raise ContractDocumentError("permission fixture requires an exact scenario")
+    body = {
+        "initialize_git": scenario.recipe.initialize_git,
+        "git_baseline_files": [
+            list(item) for item in scenario.recipe.git_baseline_files
+        ],
+        "scenario_id": scenario.definition.scenario_id,
+        "seed_files": [list(item) for item in scenario.recipe.seed_files],
+        "mcp_marker": scenario.recipe.mcp_marker,
+        "settle_paths": list(scenario.recipe.settle_paths),
+        "probe_tokens": list(scenario.recipe.probe_tokens),
+        "custom_read_external": scenario.recipe.custom_read_external,
+        "hook_exec_fixture": scenario.recipe.hook_exec_fixture,
+    }
+    digest = (
+        "sha256:"
+        + hashlib.sha256(
+            b"doc2harness.permission-child-fixture/1\0" + canonical_json(body)
+        ).hexdigest()
+    )
+    return PermissionFixturePlan(
+        scenario.definition.scenario_id,
+        scenario.recipe.seed_files,
+        scenario.recipe.initialize_git,
+        scenario.recipe.git_baseline_files,
+        scenario.recipe.mcp_marker,
+        scenario.recipe.settle_paths,
+        scenario.recipe.probe_tokens,
+        scenario.recipe.custom_read_external,
+        scenario.recipe.hook_exec_fixture,
+        digest,
+    )
+
+
+__all__ = ["PermissionFixturePlan", "materialize_permission_fixture"]
diff --git a/code/src/doc2harness/benchmark/harnesses/permission/gateway.py b/code/src/doc2harness/benchmark/harnesses/permission/gateway.py
new file mode 100644
index 0000000000000000000000000000000000000000..73cd3b2fb5f4b4ff8adcb54aacc45968a2564fd4
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/permission/gateway.py
@@ -0,0 +1,58 @@
+"""Deterministic gateway plan for child-process permission probes."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from doc2harness.benchmark.harnesses.permission.contracts import (
+    PermissionScenario,
+)
+from doc2harness.contracts.primitives import ContractDocumentError
+
+
+@dataclass(frozen=True, slots=True)
+class PermissionToolCall:
+    call_id: str
+    tool_name: str
+    arguments: tuple[tuple[str, str], ...]
+
+
+@dataclass(frozen=True, slots=True)
+class PermissionGatewayTurn:
+    tool_calls: tuple[PermissionToolCall, ...]
+    assistant_text: str
+
+
+def build_permission_gateway_plan(
+    scenario: PermissionScenario, /
+) -> tuple[PermissionGatewayTurn, ...]:
+    """Return the two-turn mock dialogue without owning sockets or processes."""
+
+    if type(scenario) is not PermissionScenario:
+        raise ContractDocumentError("permission gateway requires an exact scenario")
+    recipe = scenario.recipe
+    allow = PermissionToolCall(
+        "permission-allow", "bash", (("command", recipe.allow_command),)
+    )
+    probe_args = recipe.probe_arguments or (("command", recipe.probe_command),)
+    probe = PermissionToolCall("permission-probe", recipe.probe_tool, probe_args)
+    calls = (allow, probe)
+    if recipe.second_probe is not None:
+        calls += (
+            PermissionToolCall(
+                "permission-probe-secondary",
+                "bash",
+                (("command", recipe.second_probe),),
+            ),
+        )
+    return (
+        PermissionGatewayTurn(calls, ""),
+        PermissionGatewayTurn((), "done"),
+    )
+
+
+__all__ = [
+    "PermissionGatewayTurn",
+    "PermissionToolCall",
+    "build_permission_gateway_plan",
+]
diff --git a/code/src/doc2harness/benchmark/harnesses/permission/scenarios/__init__.py b/code/src/doc2harness/benchmark/harnesses/permission/scenarios/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..323bf5d621bb16cb014c6c4cc5d1efe5a6d1f530
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/permission/scenarios/__init__.py
@@ -0,0 +1 @@
+"""Independent permission-child scenario declarations."""
diff --git a/code/src/doc2harness/benchmark/harnesses/permission/scenarios/ask_mode_denies_write_and_allows_read.py b/code/src/doc2harness/benchmark/harnesses/permission/scenarios/ask_mode_denies_write_and_allows_read.py
new file mode 100644
index 0000000000000000000000000000000000000000..0bd5eb6fadc6a814e6093ab4d5523f249be4e7fb
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/permission/scenarios/ask_mode_denies_write_and_allows_read.py
@@ -0,0 +1,87 @@
+"""Verify that ask mode blocks writes while preserving read access.
+
+1. Enter ask mode, seed readable and protected fixtures, and prepare liveness.
+2. Run the write probe followed by its read follow-up through Bash.
+3. Capture request, target, and output facts from the permission observer.
+4. Pass only when the target is unchanged, the read token is visible, and cleanup is clean.
+"""
+
+from dataclasses import replace
+from typing import NamedTuple
+
+from doc2harness.benchmark.definition import ScenarioRole
+from doc2harness.benchmark.harnesses.permission.contracts import (
+    ORIGINAL_TARGET_CONTENT,
+    PermissionApplicability,
+    PermissionOracleProfile,
+    PermissionOutcome,
+    PermissionRawObservation,
+    PermissionScenario,
+    allow_command,
+    capture_target_file,
+    compile_permission_steps,
+    define_permission_scenario,
+    probe_command,
+    probe_tool,
+    seed_file,
+    set_mode,
+)
+
+SCENARIO_ID = "ask_mode_denies_write_and_allows_read"
+EXPECTED_TOKEN = "ASKMODE_BOTH_9942"
+STEPS = (
+    set_mode("/mode ask"),
+    seed_file("rdt.txt", f"{EXPECTED_TOKEN} readable\n"),
+    seed_file("tgt.txt", ORIGINAL_TARGET_CONTENT),
+    allow_command("echo PERM_LIVE_7755 > live.txt"),
+    probe_command("echo HACK_7755 > tgt.txt"),
+    probe_tool("bash"),
+    capture_target_file("tgt.txt", present=True),
+)
+RECIPE = replace(
+    compile_permission_steps(
+        STEPS, oracle_profile=PermissionOracleProfile.WRITE_BLOCKED_READ_ALLOWED
+    ),
+    expected_token=EXPECTED_TOKEN,
+    second_probe="cat rdt.txt",
+    control_dependency="p60_ctl_yolo_both_work",
+)
+SCENARIO: PermissionScenario = define_permission_scenario(
+    SCENARIO_ID, RECIPE, ScenarioRole.TARGET
+)
+scenario = SCENARIO
+definition = SCENARIO.definition
+
+
+class Judgement(NamedTuple):
+    outcome: PermissionOutcome
+    applicability: PermissionApplicability
+    reason_code: str
+
+
+def judge(observation: PermissionRawObservation) -> Judgement:
+    """Require an unchanged target and visible read token with clean boundaries."""
+
+    clean = (
+        observation.process_tree_clean
+        and observation.gateway_clean
+        and observation.workspace_clean
+        and not observation.timed_out
+    )
+    observed_text = observation.messages_text + "\n" + observation.stdout_text
+    passed = (
+        observation.request_count >= 1
+        and observation.target_content == ORIGINAL_TARGET_CONTENT
+        and EXPECTED_TOKEN in observed_text
+        and clean
+    )
+    return Judgement(
+        PermissionOutcome.PASS if passed else PermissionOutcome.FAIL,
+        PermissionApplicability.APPLICABLE,
+        PermissionOracleProfile.WRITE_BLOCKED_READ_ALLOWED.value
+        if passed
+        else f"{PermissionOracleProfile.WRITE_BLOCKED_READ_ALLOWED.value}_FAILED",
+    )
+
+
+__all__ = ["SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/permission/scenarios/autoedit_blocks_mutable_shell.py b/code/src/doc2harness/benchmark/harnesses/permission/scenarios/autoedit_blocks_mutable_shell.py
new file mode 100644
index 0000000000000000000000000000000000000000..42204239161ea12535bc469c25e98792f4afb8bb
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/permission/scenarios/autoedit_blocks_mutable_shell.py
@@ -0,0 +1,81 @@
+"""Verify that auto-edit mode blocks a mutable shell write.
+
+1. Configure the permission mode and seed the target file.
+2. Ask Bash to run the probe command while the guard is active.
+3. Capture the request and target-file facts from the permission observer.
+4. Pass only when the original target content remains and cleanup is clean.
+"""
+
+from typing import NamedTuple
+
+from doc2harness.benchmark.definition import ScenarioRole
+from doc2harness.benchmark.harnesses.permission.contracts import (
+    ORIGINAL_TARGET_CONTENT,
+    PermissionApplicability,
+    PermissionOracleProfile,
+    PermissionOutcome,
+    PermissionRawObservation,
+    PermissionScenario,
+    allow_command,
+    capture_target_file,
+    compile_permission_steps,
+    define_permission_scenario,
+    probe_command,
+    probe_tool,
+    seed_file,
+    set_mode,
+)
+
+SCENARIO_ID = "autoedit_blocks_mutable_shell"
+STEPS = (
+    set_mode("/mode auto-edit"),
+    seed_file("tgt.txt", ORIGINAL_TARGET_CONTENT),
+    allow_command("ls -a"),
+    probe_command("echo HACK_7755 > tgt.txt"),
+    probe_tool("bash"),
+    capture_target_file("tgt.txt", present=True),
+)
+RECIPE = compile_permission_steps(
+    STEPS,
+    oracle_profile=PermissionOracleProfile.TARGET_UNCHANGED,
+    control_dependency="yolo_mutable_shell_lands_control",
+)
+SCENARIO: PermissionScenario = define_permission_scenario(
+    SCENARIO_ID, RECIPE, ScenarioRole.TARGET
+)
+scenario = SCENARIO
+definition = SCENARIO.definition
+
+
+class Judgement(NamedTuple):
+    outcome: PermissionOutcome
+    applicability: PermissionApplicability
+    reason_code: str
+
+
+def judge(observation: PermissionRawObservation) -> Judgement:
+    """Require the guarded probe to leave the target unchanged."""
+
+    clean = (
+        observation.process_tree_clean
+        and observation.gateway_clean
+        and observation.workspace_clean
+        and not observation.timed_out
+    )
+    passed = (
+        observation.request_count >= 1
+        and observation.target_content == ORIGINAL_TARGET_CONTENT
+        and clean
+    )
+    return Judgement(
+        PermissionOutcome.PASS if passed else PermissionOutcome.FAIL,
+        PermissionApplicability.APPLICABLE,
+        (
+            PermissionOracleProfile.TARGET_UNCHANGED.value
+            if passed
+            else f"{PermissionOracleProfile.TARGET_UNCHANGED.value}_FAILED"
+        ),
+    )
+
+
+__all__ = ["SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/permission/scenarios/autoreview_blocks_canonical_danger.py b/code/src/doc2harness/benchmark/harnesses/permission/scenarios/autoreview_blocks_canonical_danger.py
new file mode 100644
index 0000000000000000000000000000000000000000..d33bd01a9164f5e3e3965018055ff6f4a92aa6f2
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/permission/scenarios/autoreview_blocks_canonical_danger.py
@@ -0,0 +1,81 @@
+"""Verify that auto-review mode blocks a canonical destructive command.
+
+1. Configure the permission mode and seed the target file.
+2. Ask Bash to run the probe command while the guard is active.
+3. Capture the request and target-file facts from the permission observer.
+4. Pass only when the original target content remains and cleanup is clean.
+"""
+
+from typing import NamedTuple
+
+from doc2harness.benchmark.definition import ScenarioRole
+from doc2harness.benchmark.harnesses.permission.contracts import (
+    ORIGINAL_TARGET_CONTENT,
+    PermissionApplicability,
+    PermissionOracleProfile,
+    PermissionOutcome,
+    PermissionRawObservation,
+    PermissionScenario,
+    allow_command,
+    capture_target_file,
+    compile_permission_steps,
+    define_permission_scenario,
+    probe_command,
+    probe_tool,
+    seed_file,
+    set_mode,
+)
+
+SCENARIO_ID = "autoreview_blocks_canonical_danger"
+STEPS = (
+    set_mode("/mode auto-review"),
+    seed_file("tgt.txt", ORIGINAL_TARGET_CONTENT),
+    allow_command("echo PERM_LIVE_7755 > live.txt"),
+    probe_command("rm -rf tgt.txt"),
+    probe_tool("bash"),
+    capture_target_file("tgt.txt", present=True),
+)
+RECIPE = compile_permission_steps(
+    STEPS,
+    oracle_profile=PermissionOracleProfile.TARGET_UNCHANGED,
+    control_dependency="p46_ctl_yolo_rm_really_deletes",
+)
+SCENARIO: PermissionScenario = define_permission_scenario(
+    SCENARIO_ID, RECIPE, ScenarioRole.TARGET
+)
+scenario = SCENARIO
+definition = SCENARIO.definition
+
+
+class Judgement(NamedTuple):
+    outcome: PermissionOutcome
+    applicability: PermissionApplicability
+    reason_code: str
+
+
+def judge(observation: PermissionRawObservation) -> Judgement:
+    """Require the guarded probe to leave the target unchanged."""
+
+    clean = (
+        observation.process_tree_clean
+        and observation.gateway_clean
+        and observation.workspace_clean
+        and not observation.timed_out
+    )
+    passed = (
+        observation.request_count >= 1
+        and observation.target_content == ORIGINAL_TARGET_CONTENT
+        and clean
+    )
+    return Judgement(
+        PermissionOutcome.PASS if passed else PermissionOutcome.FAIL,
+        PermissionApplicability.APPLICABLE,
+        (
+            PermissionOracleProfile.TARGET_UNCHANGED.value
+            if passed
+            else f"{PermissionOracleProfile.TARGET_UNCHANGED.value}_FAILED"
+        ),
+    )
+
+
+__all__ = ["SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/permission/scenarios/blocking_hook_missing_exec_control.py b/code/src/doc2harness/benchmark/harnesses/permission/scenarios/blocking_hook_missing_exec_control.py
new file mode 100644
index 0000000000000000000000000000000000000000..961f4f84238a72debaa6a7586a75bab39f3e016d
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/permission/scenarios/blocking_hook_missing_exec_control.py
@@ -0,0 +1,81 @@
+"""Verify fail-closed behavior when a blocking hook executable is missing.
+
+1. Enable yolo mode and install a healthy blocking hook plus a missing executable hook.
+2. Run the operation that matches both hook entries.
+3. Capture the operation marker, hook exit evidence, and cleanup boundaries.
+4. Pass when the control operation lands, or when the missing executable blocks it in the target.
+"""
+
+from dataclasses import replace
+from typing import NamedTuple
+
+from doc2harness.benchmark.definition import ScenarioRole
+from doc2harness.benchmark.harnesses.permission.contracts import (
+    PermissionApplicability,
+    PermissionOracleProfile,
+    PermissionOutcome,
+    PermissionRawObservation,
+    PermissionScenario,
+    allow_command,
+    capture_target_file,
+    compile_permission_steps,
+    define_permission_scenario,
+    probe_command,
+    probe_tool,
+    seed_file,
+    set_mode,
+)
+
+SCENARIO_ID = "blocking_hook_missing_exec_control"
+STEPS = (
+    set_mode("/mode yolo"),
+    seed_file("hooks.json", '{"beforeShellExecution": [{"type": "command", "matcher": "PERM_DENY_7755.txt", "match": "PERM_DENY_7755.txt", "command": "{HOOK_EXECUTABLE} {HOOK_MARKER}", "blocking": true}, {"type": "command", "matcher": "HOOKFAIL_NEVER_MATCH_7606", "match": "HOOKFAIL_NEVER_MATCH_7606", "command": "{HOOK_MISSING_EXECUTABLE} {HOOK_MARKER}", "blocking": true}]}'),
+    allow_command("true"),
+    probe_command("printf HOOKFAIL_OPERATION > PERM_DENY_7755.txt"),
+    probe_tool("bash"),
+    capture_target_file("PERM_DENY_7755.txt", present=True),
+)
+RECIPE = replace(
+    compile_permission_steps(
+        STEPS, oracle_profile=PermissionOracleProfile.HEALTHY_HOOK_OPERATION_LANDED
+    ),
+    hook_exec_fixture=True,
+    control_dependency=None,
+)
+SCENARIO: PermissionScenario = define_permission_scenario(
+    SCENARIO_ID, RECIPE, ScenarioRole.CONTROL
+)
+scenario = SCENARIO
+definition = SCENARIO.definition
+
+
+class Judgement(NamedTuple):
+    outcome: PermissionOutcome
+    applicability: PermissionApplicability
+    reason_code: str
+
+
+def judge(observation: PermissionRawObservation) -> Judgement:
+    """Require the expected operation result and healthy hook exit evidence."""
+
+    profile = PermissionOracleProfile.HEALTHY_HOOK_OPERATION_LANDED.value
+    clean = (
+        observation.process_tree_clean
+        and observation.gateway_clean
+        and observation.workspace_clean
+        and not observation.timed_out
+    )
+    passed = (
+        observation.request_count >= 1
+        and observation.deny_file_present
+        and "HOOKFAIL_HEALTHY_HOOK_EXIT_0" in observation.hook_events
+        and clean
+    )
+    return Judgement(
+        PermissionOutcome.PASS if passed else PermissionOutcome.FAIL,
+        PermissionApplicability.APPLICABLE,
+        profile if passed else f"{profile}_FAILED",
+    )
+
+
+__all__ = ["SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/permission/scenarios/blocking_hook_missing_exec_fail_closed.py b/code/src/doc2harness/benchmark/harnesses/permission/scenarios/blocking_hook_missing_exec_fail_closed.py
new file mode 100644
index 0000000000000000000000000000000000000000..4950becf5c77c00c56783302f58896e68a333607
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/permission/scenarios/blocking_hook_missing_exec_fail_closed.py
@@ -0,0 +1,81 @@
+"""Verify fail-closed behavior when a blocking hook executable is missing.
+
+1. Enable yolo mode and install a healthy blocking hook plus a missing executable hook.
+2. Run the operation that matches both hook entries.
+3. Capture the operation marker, hook exit evidence, and cleanup boundaries.
+4. Pass when the control operation lands, or when the missing executable blocks it in the target.
+"""
+
+from dataclasses import replace
+from typing import NamedTuple
+
+from doc2harness.benchmark.definition import ScenarioRole
+from doc2harness.benchmark.harnesses.permission.contracts import (
+    PermissionApplicability,
+    PermissionOracleProfile,
+    PermissionOutcome,
+    PermissionRawObservation,
+    PermissionScenario,
+    allow_command,
+    capture_target_file,
+    compile_permission_steps,
+    define_permission_scenario,
+    probe_command,
+    probe_tool,
+    seed_file,
+    set_mode,
+)
+
+SCENARIO_ID = "blocking_hook_missing_exec_fail_closed"
+STEPS = (
+    set_mode("/mode yolo"),
+    seed_file("hooks.json", '{"beforeShellExecution": [{"type": "command", "matcher": "PERM_DENY_7755.txt", "match": "PERM_DENY_7755.txt", "command": "{HOOK_EXECUTABLE} {HOOK_MARKER}", "blocking": true}, {"type": "command", "matcher": "PERM_DENY_7755.txt", "match": "PERM_DENY_7755.txt", "command": "{HOOK_MISSING_EXECUTABLE} {HOOK_MARKER}", "blocking": true}]}'),
+    allow_command("true"),
+    probe_command("printf HOOKFAIL_OPERATION > PERM_DENY_7755.txt"),
+    probe_tool("bash"),
+    capture_target_file("PERM_DENY_7755.txt", present=True),
+)
+RECIPE = replace(
+    compile_permission_steps(
+        STEPS, oracle_profile=PermissionOracleProfile.HOOK_FAILURE_OPERATION_BLOCKED
+    ),
+    hook_exec_fixture=True,
+    control_dependency="blocking_hook_missing_exec_control",
+)
+SCENARIO: PermissionScenario = define_permission_scenario(
+    SCENARIO_ID, RECIPE, ScenarioRole.TARGET
+)
+scenario = SCENARIO
+definition = SCENARIO.definition
+
+
+class Judgement(NamedTuple):
+    outcome: PermissionOutcome
+    applicability: PermissionApplicability
+    reason_code: str
+
+
+def judge(observation: PermissionRawObservation) -> Judgement:
+    """Require the expected operation result and healthy hook exit evidence."""
+
+    profile = PermissionOracleProfile.HOOK_FAILURE_OPERATION_BLOCKED.value
+    clean = (
+        observation.process_tree_clean
+        and observation.gateway_clean
+        and observation.workspace_clean
+        and not observation.timed_out
+    )
+    passed = (
+        observation.request_count >= 1
+        and not observation.deny_file_present
+        and "HOOKFAIL_HEALTHY_HOOK_EXIT_0" in observation.hook_events
+        and clean
+    )
+    return Judgement(
+        PermissionOutcome.PASS if passed else PermissionOutcome.FAIL,
+        PermissionApplicability.APPLICABLE,
+        profile if passed else f"{profile}_FAILED",
+    )
+
+
+__all__ = ["SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/permission/scenarios/custom_cmd_at_file_read_fences_control.py b/code/src/doc2harness/benchmark/harnesses/permission/scenarios/custom_cmd_at_file_read_fences_control.py
new file mode 100644
index 0000000000000000000000000000000000000000..5bc4f920878913a715951940f797abcd4ff4610c
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/permission/scenarios/custom_cmd_at_file_read_fences_control.py
@@ -0,0 +1,99 @@
+"""Control that proves custom command file reads expose all expected tokens.
+
+1. Enter yolo mode, configure workspace-write, and seed command/read fixtures.
+2. Invoke both custom commands through the Bash adapter.
+3. Capture wire-level observed tokens from the permission observer.
+4. Pass only when every expected token is observed and cleanup is clean.
+"""
+
+from dataclasses import replace
+from typing import NamedTuple
+
+from doc2harness.benchmark.definition import ScenarioRole
+from doc2harness.benchmark.harnesses.permission.contracts import (
+    PermissionApplicability,
+    PermissionOracleProfile,
+    PermissionOutcome,
+    PermissionRawObservation,
+    PermissionScenario,
+    add_deny_rule,
+    allow_command,
+    capture_target_file,
+    compile_permission_steps,
+    define_permission_scenario,
+    probe_command,
+    probe_tool,
+    seed_file,
+    set_mode,
+)
+
+SCENARIO_ID = "custom_cmd_at_file_read_fences_control"
+STEPS = (
+    set_mode("/mode yolo"),
+    set_mode("/sandbox workspace-write"),
+    set_mode("/atrefdeny"),
+    set_mode("/atrefoutside"),
+    add_deny_rule("Read(*atref_denied.txt*)"),
+    seed_file(
+        "commands/atrefdeny.md",
+        "Gate ATREF_DENY_FACE_7601. Read @{atref_legal_deny.txt} now.\n",
+    ),
+    seed_file(
+        "commands/atrefoutside.md",
+        "Gate ATREF_OUTSIDE_FACE_7602. Read @{atref_legal_outside.txt} now.\n",
+    ),
+    seed_file("atref_legal_deny.txt", "ATREF_LEGAL_DENY_BYTES_7603\n"),
+    seed_file("atref_legal_outside.txt", "ATREF_LEGAL_OUTSIDE_BYTES_7604\n"),
+    allow_command("true"),
+    probe_command("true"),
+    probe_tool("bash"),
+    capture_target_file("live.txt", present=True),
+)
+RECIPE = replace(
+    compile_permission_steps(
+        STEPS, oracle_profile=PermissionOracleProfile.WIRE_TOKENS_OBSERVED
+    ),
+    probe_tokens=(
+        "ATREF_DENY_FACE_7601",
+        "ATREF_OUTSIDE_FACE_7602",
+        "ATREF_LEGAL_DENY_BYTES_7603",
+        "ATREF_LEGAL_OUTSIDE_BYTES_7604",
+    ),
+)
+SCENARIO: PermissionScenario = define_permission_scenario(
+    SCENARIO_ID, RECIPE, ScenarioRole.CONTROL
+)
+scenario = SCENARIO
+definition = SCENARIO.definition
+
+
+class Judgement(NamedTuple):
+    outcome: PermissionOutcome
+    applicability: PermissionApplicability
+    reason_code: str
+
+
+def judge(observation: PermissionRawObservation) -> Judgement:
+    """Require every control token on the wire with clean boundaries."""
+
+    clean = (
+        observation.process_tree_clean
+        and observation.gateway_clean
+        and observation.workspace_clean
+        and not observation.timed_out
+    )
+    passed = (
+        observation.request_count >= 1
+        and set(RECIPE.probe_tokens).issubset(observation.observed_tokens)
+        and clean
+    )
+    return Judgement(
+        PermissionOutcome.PASS if passed else PermissionOutcome.FAIL,
+        PermissionApplicability.APPLICABLE,
+        PermissionOracleProfile.WIRE_TOKENS_OBSERVED.value
+        if passed
+        else f"{PermissionOracleProfile.WIRE_TOKENS_OBSERVED.value}_FAILED",
+    )
+
+
+__all__ = ["SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/permission/scenarios/custom_cmd_at_file_respects_read_fences.py b/code/src/doc2harness/benchmark/harnesses/permission/scenarios/custom_cmd_at_file_respects_read_fences.py
new file mode 100644
index 0000000000000000000000000000000000000000..af88964c4ba8acb6f9ad5c329f6466a17898e00f
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/permission/scenarios/custom_cmd_at_file_respects_read_fences.py
@@ -0,0 +1,100 @@
+"""Verify that custom command file reads respect configured read fences.
+
+1. Enter yolo mode, configure workspace-write, and seed fenced command fixtures.
+2. Invoke both custom commands through the Bash adapter.
+3. Capture wire-level observed tokens from the permission observer.
+4. Pass only when fenced content stays absent from the wire and cleanup is clean.
+"""
+
+from dataclasses import replace
+from typing import NamedTuple
+
+from doc2harness.benchmark.definition import ScenarioRole
+from doc2harness.benchmark.harnesses.permission.contracts import (
+    PermissionApplicability,
+    PermissionOracleProfile,
+    PermissionOutcome,
+    PermissionRawObservation,
+    PermissionScenario,
+    add_deny_rule,
+    allow_command,
+    capture_target_file,
+    compile_permission_steps,
+    define_permission_scenario,
+    probe_command,
+    probe_tool,
+    seed_file,
+    set_mode,
+)
+
+SCENARIO_ID = "custom_cmd_at_file_respects_read_fences"
+STEPS = (
+    set_mode("/mode yolo"),
+    set_mode("/sandbox workspace-write"),
+    set_mode("/atrefdeny"),
+    set_mode("/atrefoutside"),
+    add_deny_rule("Read(*atref_denied.txt*)"),
+    seed_file(
+        "commands/atrefdeny.md",
+        "Gate ATREF_DENY_FACE_7601. Read @{atref_denied.txt} now.\n",
+    ),
+    seed_file(
+        "commands/atrefoutside.md",
+        "Gate ATREF_OUTSIDE_FACE_7602. Read @{{CUSTOM_READ_EXTERNAL}} now.\n",
+    ),
+    seed_file("atref_denied.txt", "ATREF_DENIED_BYTES_7605\n"),
+    allow_command("true"),
+    probe_command("true"),
+    probe_tool("bash"),
+    capture_target_file("live.txt", present=True),
+)
+RECIPE = replace(
+    compile_permission_steps(
+        STEPS, oracle_profile=PermissionOracleProfile.WIRE_TOKENS_FENCED
+    ),
+    probe_tokens=(
+        "ATREF_DENY_FACE_7601",
+        "ATREF_OUTSIDE_FACE_7602",
+        "ATREF_DENIED_BYTES_7605",
+        "ATREF_OUTSIDE_BYTES_7606",
+    ),
+    control_dependency="custom_cmd_at_file_read_fences_control",
+    custom_read_external=True,
+)
+SCENARIO: PermissionScenario = define_permission_scenario(
+    SCENARIO_ID, RECIPE, ScenarioRole.TARGET
+)
+scenario = SCENARIO
+definition = SCENARIO.definition
+
+
+class Judgement(NamedTuple):
+    outcome: PermissionOutcome
+    applicability: PermissionApplicability
+    reason_code: str
+
+
+def judge(observation: PermissionRawObservation) -> Judgement:
+    """Require all fenced tokens to stay absent from the wire with clean boundaries."""
+
+    clean = (
+        observation.process_tree_clean
+        and observation.gateway_clean
+        and observation.workspace_clean
+        and not observation.timed_out
+    )
+    passed = (
+        observation.request_count >= 1
+        and not set(RECIPE.probe_tokens) & set(observation.observed_tokens)
+        and clean
+    )
+    return Judgement(
+        PermissionOutcome.PASS if passed else PermissionOutcome.FAIL,
+        PermissionApplicability.APPLICABLE,
+        PermissionOracleProfile.WIRE_TOKENS_FENCED.value
+        if passed
+        else f"{PermissionOracleProfile.WIRE_TOKENS_FENCED.value}_FAILED",
+    )
+
+
+__all__ = ["SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/permission/scenarios/deny_blocks_monitor_spawned_cmd.py b/code/src/doc2harness/benchmark/harnesses/permission/scenarios/deny_blocks_monitor_spawned_cmd.py
new file mode 100644
index 0000000000000000000000000000000000000000..fae09b03d461d906f3a593eba146902f029d56f1
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/permission/scenarios/deny_blocks_monitor_spawned_cmd.py
@@ -0,0 +1,87 @@
+"""Verify the monitor blocked permission behavior.
+
+1. Configure the mode and prepare the liveness command.
+2. Run the monitor probe through the execution adapter.
+3. Capture the request and observer-specific facts.
+4. Pass only when the expected boundary behavior is observed and cleanup is clean.
+"""
+
+from dataclasses import replace
+from typing import NamedTuple
+
+from doc2harness.benchmark.definition import ScenarioRole
+from doc2harness.benchmark.harnesses.permission.contracts import (
+    PermissionApplicability,
+    PermissionOracleProfile,
+    PermissionOutcome,
+    PermissionRawObservation,
+    PermissionScenario,
+    add_deny_rule,
+    allow_command,
+    capture_target_file,
+    compile_permission_steps,
+    define_permission_scenario,
+    probe_command,
+    probe_tool,
+    set_mode,
+)
+
+SCENARIO_ID = "deny_blocks_monitor_spawned_cmd"
+STEPS = (
+    set_mode("/mode yolo"),
+    add_deny_rule("Bash(touch*)"),
+    allow_command("echo PERM_LIVE_7755 > live.txt"),
+    probe_command("echo MONUNUSED_7755"),
+    probe_tool("monitor"),
+    capture_target_file("live.txt", present=True),
+)
+RECIPE = replace(
+    compile_permission_steps(
+        STEPS, oracle_profile=PermissionOracleProfile.MONITOR_BLOCKED
+    ),
+    probe_arguments=(
+        ("command", "touch monitor_started_7755; sleep 0.2; touch PERM_DENY_7755.txt"),
+        ("pattern", "x"),
+    ),
+    settle_paths=("PERM_DENY_7755.txt", "monitor_started_7755"),
+    control_dependency="monitor_spawns_command_control",
+)
+SCENARIO: PermissionScenario = define_permission_scenario(
+    SCENARIO_ID, RECIPE, ScenarioRole.TARGET
+)
+scenario = SCENARIO
+definition = SCENARIO.definition
+
+
+class Judgement(NamedTuple):
+    outcome: PermissionOutcome
+    applicability: PermissionApplicability
+    reason_code: str
+
+
+def judge(observation: PermissionRawObservation) -> Judgement:
+    """Apply the profile-specific boundary predicate with clean-run checks."""
+
+    clean = (
+        observation.process_tree_clean
+        and observation.gateway_clean
+        and observation.workspace_clean
+        and not observation.timed_out
+    )
+    passed = (
+        observation.request_count >= 1
+        and not observation.deny_file_present
+        and "monitor_started_7755" not in observation.settled_paths
+        and clean
+    )
+    applicability = PermissionApplicability.APPLICABLE
+    return Judgement(
+        PermissionOutcome.PASS if passed else PermissionOutcome.FAIL,
+        applicability,
+        PermissionOracleProfile.MONITOR_BLOCKED.value
+        if passed
+        else f"{PermissionOracleProfile.MONITOR_BLOCKED.value}_FAILED",
+    )
+
+
+__all__ = ["SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/permission/scenarios/hook_absent_bash_write_runs_control.py b/code/src/doc2harness/benchmark/harnesses/permission/scenarios/hook_absent_bash_write_runs_control.py
new file mode 100644
index 0000000000000000000000000000000000000000..6551ac5aec92f80a7fd1e7126d4a873a31e3cd58
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/permission/scenarios/hook_absent_bash_write_runs_control.py
@@ -0,0 +1,72 @@
+"""Verify that a Bash write runs when no hook is installed.
+
+1. Enter the configured mode and prepare the liveness command without installing a deny rule.
+2. Ask Bash to run the control command against the marker file.
+3. Capture the request and filesystem facts from the permission observer.
+4. Pass only when the request ran, the marker exists, and cleanup is clean.
+"""
+
+from typing import NamedTuple
+
+from doc2harness.benchmark.definition import ScenarioRole
+from doc2harness.benchmark.harnesses.permission.contracts import (
+    PermissionApplicability,
+    PermissionOracleProfile,
+    PermissionOutcome,
+    PermissionRawObservation,
+    PermissionScenario,
+    allow_command,
+    capture_target_file,
+    compile_permission_steps,
+    define_permission_scenario,
+    probe_command,
+    probe_tool,
+    set_mode,
+)
+
+SCENARIO_ID = "hook_absent_bash_write_runs_control"
+STEPS = (
+    set_mode("/mode yolo"),
+    allow_command("echo PERM_LIVE_7755 > live.txt"),
+    probe_command("echo HACK > PERM_DENY_7755.txt"),
+    probe_tool("bash"),
+    capture_target_file("PERM_DENY_7755.txt", present=True),
+)
+RECIPE = compile_permission_steps(
+    STEPS, oracle_profile=PermissionOracleProfile.COMMAND_EXECUTED
+)
+SCENARIO: PermissionScenario = define_permission_scenario(
+    SCENARIO_ID, RECIPE, ScenarioRole.CONTROL
+)
+scenario = SCENARIO
+definition = SCENARIO.definition
+
+
+class Judgement(NamedTuple):
+    outcome: PermissionOutcome
+    applicability: PermissionApplicability
+    reason_code: str
+
+
+def judge(observation: PermissionRawObservation) -> Judgement:
+    """Require the unhooked Bash write to create its marker file."""
+
+    clean = (
+        observation.process_tree_clean
+        and observation.gateway_clean
+        and observation.workspace_clean
+        and not observation.timed_out
+    )
+    passed = observation.request_count >= 1 and observation.deny_file_present and clean
+    return Judgement(
+        PermissionOutcome.PASS if passed else PermissionOutcome.FAIL,
+        PermissionApplicability.APPLICABLE,
+        (
+            PermissionOracleProfile.COMMAND_EXECUTED.value
+            if passed
+            else f"{PermissionOracleProfile.COMMAND_EXECUTED.value}_FAILED"
+        ),
+    )
+
+
+__all__ = ["SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/permission/scenarios/hook_blocks_bash_write.py b/code/src/doc2harness/benchmark/harnesses/permission/scenarios/hook_blocks_bash_write.py
new file mode 100644
index 0000000000000000000000000000000000000000..6a6eb1cee201cac4489615f3a9a5a56cbc29931b
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/permission/scenarios/hook_blocks_bash_write.py
@@ -0,0 +1,62 @@
+"""Verify that a blocking before-shell hook prevents the target write.
+
+1. Apply the permission setup sequence and seed the required fixture.
+2. Ask Bash to run the probe after the setup sequence.
+3. Capture the request and resulting facts from the permission observer.
+4. Pass only when the expected oracle outcome and cleanup gates hold.
+"""
+
+from typing import NamedTuple
+
+from doc2harness.benchmark.definition import ScenarioRole
+from doc2harness.benchmark.harnesses.permission.contracts import PermissionApplicability, PermissionOracleProfile, PermissionOutcome, PermissionRawObservation, PermissionScenario, allow_command, capture_target_file, compile_permission_steps, define_permission_scenario, probe_command, probe_tool, seed_file, set_mode
+
+SCENARIO_ID = "hook_blocks_bash_write"
+STEPS = (
+    set_mode("/mode yolo"),
+    seed_file("hooks.json", "{\"beforeShellExecution\": [{\"matcher\": \"PERM_DENY_7755\", \"match\": \"PERM_DENY_7755\", \"command\": \"echo '{\\\"decision\\\":\\\"deny\\\",\\\"permission\\\":\\\"deny\\\",\\\"reason\\\":\\\"blocked by hook\\\"}'; exit 2\"}]}"),
+    allow_command("echo PERM_LIVE_7755 > live.txt"),
+    probe_command("echo HACK > PERM_DENY_7755.txt"),
+    probe_tool("bash"),
+    capture_target_file("PERM_DENY_7755.txt", present=False),
+)
+RECIPE = compile_permission_steps(
+    STEPS,
+    oracle_profile=PermissionOracleProfile.DENY_BLOCKED,
+    control_dependency="hook_absent_bash_write_runs_control",
+)
+SCENARIO: PermissionScenario = define_permission_scenario(
+    SCENARIO_ID, RECIPE, ScenarioRole.TARGET
+)
+scenario = SCENARIO
+definition = SCENARIO.definition
+
+
+class Judgement(NamedTuple):
+    outcome: PermissionOutcome
+    applicability: PermissionApplicability
+    reason_code: str
+
+
+def judge(observation: PermissionRawObservation) -> Judgement:
+    """Evaluate the expected outcome and cleanup gates."""
+
+    clean = (
+        observation.process_tree_clean
+        and observation.gateway_clean
+        and observation.workspace_clean
+        and not observation.timed_out
+    )
+    passed = observation.request_count >= 1 and not observation.deny_file_present and clean
+    return Judgement(
+        PermissionOutcome.PASS if passed else PermissionOutcome.FAIL,
+        PermissionApplicability.APPLICABLE,
+        (
+            PermissionOracleProfile.DENY_BLOCKED.value
+            if passed
+            else f"{PermissionOracleProfile.DENY_BLOCKED.value}_FAILED"
+        ),
+    )
+
+
+__all__ = ["SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/permission/scenarios/monitor_spawns_command_control.py b/code/src/doc2harness/benchmark/harnesses/permission/scenarios/monitor_spawns_command_control.py
new file mode 100644
index 0000000000000000000000000000000000000000..41888e9ddc56923de4bc4397cdc04070f1f6d7de
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/permission/scenarios/monitor_spawns_command_control.py
@@ -0,0 +1,83 @@
+"""Verify the monitor executed control permission behavior.
+
+1. Configure the mode and prepare the liveness command.
+2. Run the monitor probe through the execution adapter.
+3. Capture the request and observer-specific facts.
+4. Pass only when the expected boundary behavior is observed and cleanup is clean.
+"""
+
+from dataclasses import replace
+from typing import NamedTuple
+
+from doc2harness.benchmark.definition import ScenarioRole
+from doc2harness.benchmark.harnesses.permission.contracts import (
+    PermissionApplicability,
+    PermissionOracleProfile,
+    PermissionOutcome,
+    PermissionRawObservation,
+    PermissionScenario,
+    allow_command,
+    capture_target_file,
+    compile_permission_steps,
+    define_permission_scenario,
+    probe_command,
+    probe_tool,
+    set_mode,
+)
+
+SCENARIO_ID = "monitor_spawns_command_control"
+STEPS = (
+    set_mode("/mode yolo"),
+    allow_command("echo PERM_LIVE_7755 > live.txt"),
+    probe_command("echo MONUNUSED_7755"),
+    probe_tool("monitor"),
+    capture_target_file("live.txt", present=True),
+)
+RECIPE = replace(
+    compile_permission_steps(
+        STEPS, oracle_profile=PermissionOracleProfile.MONITOR_EXECUTED_CONTROL
+    ),
+    probe_arguments=(
+        ("command", "touch monitor_started_7755; sleep 0.2; touch PERM_DENY_7755.txt"),
+        ("pattern", "x"),
+    ),
+    settle_paths=("PERM_DENY_7755.txt", "monitor_started_7755"),
+)
+SCENARIO: PermissionScenario = define_permission_scenario(
+    SCENARIO_ID, RECIPE, ScenarioRole.CONTROL
+)
+scenario = SCENARIO
+definition = SCENARIO.definition
+
+
+class Judgement(NamedTuple):
+    outcome: PermissionOutcome
+    applicability: PermissionApplicability
+    reason_code: str
+
+
+def judge(observation: PermissionRawObservation) -> Judgement:
+    """Apply the profile-specific boundary predicate with clean-run checks."""
+
+    clean = (
+        observation.process_tree_clean
+        and observation.gateway_clean
+        and observation.workspace_clean
+        and not observation.timed_out
+    )
+    passed = (
+        observation.deny_file_present
+        and "monitor_started_7755" in observation.settled_paths
+        and clean
+    )
+    applicability = PermissionApplicability.APPLICABLE
+    return Judgement(
+        PermissionOutcome.PASS if passed else PermissionOutcome.FAIL,
+        applicability,
+        PermissionOracleProfile.MONITOR_EXECUTED_CONTROL.value
+        if passed
+        else f"{PermissionOracleProfile.MONITOR_EXECUTED_CONTROL.value}_FAILED",
+    )
+
+
+__all__ = ["SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/permission/scenarios/network_off_blocks_offline_npm_test.py b/code/src/doc2harness/benchmark/harnesses/permission/scenarios/network_off_blocks_offline_npm_test.py
new file mode 100644
index 0000000000000000000000000000000000000000..4ecd8de0a343c4fcb1b79b0d5aa1c469c6f6c68f
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/permission/scenarios/network_off_blocks_offline_npm_test.py
@@ -0,0 +1,61 @@
+"""Verify that the network-off policy still records the guarded npm probe.
+
+1. Apply the permission setup sequence and seed any required fixture.
+2. Ask Bash to run the probe after the setup sequence.
+3. Capture the request and resulting facts from the permission observer.
+4. Pass only when the expected oracle outcome and cleanup gates hold.
+"""
+
+from typing import NamedTuple
+
+from doc2harness.benchmark.definition import ScenarioRole
+from doc2harness.benchmark.harnesses.permission.contracts import PermissionApplicability, PermissionOracleProfile, PermissionOutcome, PermissionRawObservation, PermissionScenario, allow_command, capture_target_file, compile_permission_steps, define_permission_scenario, probe_command, probe_tool, set_mode
+
+SCENARIO_ID = "network_off_blocks_offline_npm_test"
+STEPS = (
+    set_mode("/mode yolo"),
+    allow_command("echo PERM_LIVE_7755 > live.txt"),
+    probe_command("npm test > /dev/null 2>&1; echo HACK > PERM_DENY_7755.txt"),
+    probe_tool("bash"),
+    capture_target_file("PERM_DENY_7755.txt", present=True),
+)
+RECIPE = compile_permission_steps(
+    STEPS,
+    oracle_profile=PermissionOracleProfile.COMMAND_EXECUTED,
+    control_dependency="p37_ctl_plain_cmd_chain_runs",
+)
+SCENARIO: PermissionScenario = define_permission_scenario(
+    SCENARIO_ID, RECIPE, ScenarioRole.TARGET
+)
+scenario = SCENARIO
+definition = SCENARIO.definition
+
+
+class Judgement(NamedTuple):
+    outcome: PermissionOutcome
+    applicability: PermissionApplicability
+    reason_code: str
+
+
+def judge(observation: PermissionRawObservation) -> Judgement:
+    """Evaluate the expected outcome and cleanup gates."""
+
+    clean = (
+        observation.process_tree_clean
+        and observation.gateway_clean
+        and observation.workspace_clean
+        and not observation.timed_out
+    )
+    passed = observation.request_count >= 1 and observation.deny_file_present and clean
+    return Judgement(
+        PermissionOutcome.PASS if passed else PermissionOutcome.FAIL,
+        PermissionApplicability.APPLICABLE,
+        (
+            PermissionOracleProfile.COMMAND_EXECUTED.value
+            if passed
+            else f"{PermissionOracleProfile.COMMAND_EXECUTED.value}_FAILED"
+        ),
+    )
+
+
+__all__ = ["SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/permission/scenarios/p37_ctl_plain_cmd_chain_runs.py b/code/src/doc2harness/benchmark/harnesses/permission/scenarios/p37_ctl_plain_cmd_chain_runs.py
new file mode 100644
index 0000000000000000000000000000000000000000..0d93779efbeee14e6bf8f8863ed46e5e7cf7b90c
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/permission/scenarios/p37_ctl_plain_cmd_chain_runs.py
@@ -0,0 +1,72 @@
+"""Verify that a plain command chain executes its marker write without a deny rule.
+
+1. Enter yolo mode and prepare the liveness command without installing a deny rule.
+2. Ask Bash to run the control command against the marker file.
+3. Capture the request and marker-file facts from the permission observer.
+4. Pass only when the request ran, the marker exists, and cleanup is clean.
+"""
+
+from typing import NamedTuple
+
+from doc2harness.benchmark.definition import ScenarioRole
+from doc2harness.benchmark.harnesses.permission.contracts import (
+    PermissionApplicability,
+    PermissionOracleProfile,
+    PermissionOutcome,
+    PermissionRawObservation,
+    PermissionScenario,
+    allow_command,
+    capture_target_file,
+    compile_permission_steps,
+    define_permission_scenario,
+    probe_command,
+    probe_tool,
+    set_mode,
+)
+
+SCENARIO_ID = "p37_ctl_plain_cmd_chain_runs"
+STEPS = (
+    set_mode("/mode yolo"),
+    allow_command("echo PERM_LIVE_7755 > live.txt"),
+    probe_command("true > /dev/null 2>&1; echo HACK > PERM_DENY_7755.txt"),
+    probe_tool("bash"),
+    capture_target_file("PERM_DENY_7755.txt", present=True),
+)
+RECIPE = compile_permission_steps(
+    STEPS, oracle_profile=PermissionOracleProfile.COMMAND_EXECUTED
+)
+SCENARIO: PermissionScenario = define_permission_scenario(
+    SCENARIO_ID, RECIPE, ScenarioRole.CONTROL
+)
+scenario = SCENARIO
+definition = SCENARIO.definition
+
+
+class Judgement(NamedTuple):
+    outcome: PermissionOutcome
+    applicability: PermissionApplicability
+    reason_code: str
+
+
+def judge(observation: PermissionRawObservation) -> Judgement:
+    """Require the chained control command to create its marker file."""
+
+    clean = (
+        observation.process_tree_clean
+        and observation.gateway_clean
+        and observation.workspace_clean
+        and not observation.timed_out
+    )
+    passed = observation.request_count >= 1 and observation.deny_file_present and clean
+    return Judgement(
+        PermissionOutcome.PASS if passed else PermissionOutcome.FAIL,
+        PermissionApplicability.APPLICABLE,
+        (
+            PermissionOracleProfile.COMMAND_EXECUTED.value
+            if passed
+            else f"{PermissionOracleProfile.COMMAND_EXECUTED.value}_FAILED"
+        ),
+    )
+
+
+__all__ = ["SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/permission/scenarios/p46_ctl_yolo_rm_really_deletes.py b/code/src/doc2harness/benchmark/harnesses/permission/scenarios/p46_ctl_yolo_rm_really_deletes.py
new file mode 100644
index 0000000000000000000000000000000000000000..9964ed33cef8b963e784ae02bb49e2ac9918669b
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/permission/scenarios/p46_ctl_yolo_rm_really_deletes.py
@@ -0,0 +1,79 @@
+"""Verify that yolo mode permits rm -rf to delete the target.
+
+1. Enter yolo mode, seed the target file, and prepare the liveness command.
+2. Ask Bash to perform the scenario's mutation against the target.
+3. Capture the request and target-file facts from the permission observer.
+4. Pass only when the target content differs from its original value and cleanup is clean.
+"""
+
+from typing import NamedTuple
+
+from doc2harness.benchmark.definition import ScenarioRole
+from doc2harness.benchmark.harnesses.permission.contracts import (
+    ORIGINAL_TARGET_CONTENT,
+    PermissionApplicability,
+    PermissionOracleProfile,
+    PermissionOutcome,
+    PermissionRawObservation,
+    PermissionScenario,
+    allow_command,
+    capture_target_file,
+    compile_permission_steps,
+    define_permission_scenario,
+    probe_command,
+    probe_tool,
+    seed_file,
+    set_mode,
+)
+
+SCENARIO_ID = "p46_ctl_yolo_rm_really_deletes"
+STEPS = (
+    set_mode("/mode yolo"),
+    seed_file("tgt.txt", ORIGINAL_TARGET_CONTENT),
+    allow_command("echo PERM_LIVE_7755 > live.txt"),
+    probe_command("rm -rf tgt.txt"),
+    probe_tool("bash"),
+    capture_target_file("tgt.txt", present=True),
+)
+RECIPE = compile_permission_steps(
+    STEPS, oracle_profile=PermissionOracleProfile.TARGET_MUTATED
+)
+SCENARIO: PermissionScenario = define_permission_scenario(
+    SCENARIO_ID, RECIPE, ScenarioRole.CONTROL
+)
+scenario = SCENARIO
+definition = SCENARIO.definition
+
+
+class Judgement(NamedTuple):
+    outcome: PermissionOutcome
+    applicability: PermissionApplicability
+    reason_code: str
+
+
+def judge(observation: PermissionRawObservation) -> Judgement:
+    """Require rm -rf to mutate the target."""
+
+    clean = (
+        observation.process_tree_clean
+        and observation.gateway_clean
+        and observation.workspace_clean
+        and not observation.timed_out
+    )
+    passed = (
+        observation.request_count >= 1
+        and observation.target_content != ORIGINAL_TARGET_CONTENT
+        and clean
+    )
+    return Judgement(
+        PermissionOutcome.PASS if passed else PermissionOutcome.FAIL,
+        PermissionApplicability.APPLICABLE,
+        (
+            PermissionOracleProfile.TARGET_MUTATED.value
+            if passed
+            else f"{PermissionOracleProfile.TARGET_MUTATED.value}_FAILED"
+        ),
+    )
+
+
+__all__ = ["SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/permission/scenarios/p60_ctl_yolo_both_work.py b/code/src/doc2harness/benchmark/harnesses/permission/scenarios/p60_ctl_yolo_both_work.py
new file mode 100644
index 0000000000000000000000000000000000000000..f3c73d2178c21435bc812e5083af89ea788d3f7d
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/permission/scenarios/p60_ctl_yolo_both_work.py
@@ -0,0 +1,87 @@
+"""Control that proves yolo mode allows both write and read operations.
+
+1. Enter yolo mode, seed readable and protected fixtures, and prepare liveness.
+2. Run the write probe followed by its read follow-up through Bash.
+3. Capture request, target, and output facts from the permission observer.
+4. Pass only when the target changes, the read token is visible, and cleanup is clean.
+"""
+
+from dataclasses import replace
+from typing import NamedTuple
+
+from doc2harness.benchmark.definition import ScenarioRole
+from doc2harness.benchmark.harnesses.permission.contracts import (
+    ORIGINAL_TARGET_CONTENT,
+    PermissionApplicability,
+    PermissionOracleProfile,
+    PermissionOutcome,
+    PermissionRawObservation,
+    PermissionScenario,
+    allow_command,
+    capture_target_file,
+    compile_permission_steps,
+    define_permission_scenario,
+    probe_command,
+    probe_tool,
+    seed_file,
+    set_mode,
+)
+
+SCENARIO_ID = "p60_ctl_yolo_both_work"
+EXPECTED_TOKEN = "ASKMODE_BOTH_9942"
+STEPS = (
+    set_mode("/mode yolo"),
+    seed_file("rdt.txt", "ASKMODE_BOTH_9942 readable\n"),
+    seed_file("tgt.txt", ORIGINAL_TARGET_CONTENT),
+    allow_command("echo PERM_LIVE_7755 > live.txt"),
+    probe_command("echo HACK_7755 > tgt.txt"),
+    probe_tool("bash"),
+    capture_target_file("tgt.txt", present=True),
+)
+RECIPE = replace(
+    compile_permission_steps(
+        STEPS, oracle_profile=PermissionOracleProfile.WRITE_AND_READ_EXECUTED
+    ),
+    second_probe="cat rdt.txt",
+    expected_token=EXPECTED_TOKEN,
+)
+SCENARIO: PermissionScenario = define_permission_scenario(
+    SCENARIO_ID, RECIPE, ScenarioRole.CONTROL
+)
+scenario = SCENARIO
+definition = SCENARIO.definition
+
+
+class Judgement(NamedTuple):
+    outcome: PermissionOutcome
+    applicability: PermissionApplicability
+    reason_code: str
+
+
+def judge(observation: PermissionRawObservation) -> Judgement:
+    """Require a mutated target and visible read token with clean boundaries."""
+
+    clean = (
+        observation.process_tree_clean
+        and observation.gateway_clean
+        and observation.workspace_clean
+        and not observation.timed_out
+    )
+    expected_token = EXPECTED_TOKEN or "RDTK_4242X"
+    observed_text = observation.messages_text + "\n" + observation.stdout_text
+    passed = (
+        observation.request_count >= 1
+        and observation.target_content != ORIGINAL_TARGET_CONTENT
+        and expected_token in observed_text
+        and clean
+    )
+    return Judgement(
+        PermissionOutcome.PASS if passed else PermissionOutcome.FAIL,
+        PermissionApplicability.APPLICABLE,
+        PermissionOracleProfile.WRITE_AND_READ_EXECUTED.value
+        if passed
+        else f"{PermissionOracleProfile.WRITE_AND_READ_EXECUTED.value}_FAILED",
+    )
+
+
+__all__ = ["SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/permission/scenarios/yolo_mutable_shell_lands_control.py b/code/src/doc2harness/benchmark/harnesses/permission/scenarios/yolo_mutable_shell_lands_control.py
new file mode 100644
index 0000000000000000000000000000000000000000..06dfddc47c4c31dda348854bbed5279f34d501af
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/permission/scenarios/yolo_mutable_shell_lands_control.py
@@ -0,0 +1,79 @@
+"""Verify that yolo mode permits the mutable shell command to land.
+
+1. Enter yolo mode, seed the target file, and prepare the liveness command.
+2. Ask Bash to perform the scenario's mutation against the target.
+3. Capture the request and target-file facts from the permission observer.
+4. Pass only when the target content differs from its original value and cleanup is clean.
+"""
+
+from typing import NamedTuple
+
+from doc2harness.benchmark.definition import ScenarioRole
+from doc2harness.benchmark.harnesses.permission.contracts import (
+    ORIGINAL_TARGET_CONTENT,
+    PermissionApplicability,
+    PermissionOracleProfile,
+    PermissionOutcome,
+    PermissionRawObservation,
+    PermissionScenario,
+    allow_command,
+    capture_target_file,
+    compile_permission_steps,
+    define_permission_scenario,
+    probe_command,
+    probe_tool,
+    seed_file,
+    set_mode,
+)
+
+SCENARIO_ID = "yolo_mutable_shell_lands_control"
+STEPS = (
+    set_mode("/mode yolo"),
+    seed_file("tgt.txt", ORIGINAL_TARGET_CONTENT),
+    allow_command("ls -a"),
+    probe_command("echo HACK_7755 > tgt.txt"),
+    probe_tool("bash"),
+    capture_target_file("tgt.txt", present=True),
+)
+RECIPE = compile_permission_steps(
+    STEPS, oracle_profile=PermissionOracleProfile.TARGET_MUTATED
+)
+SCENARIO: PermissionScenario = define_permission_scenario(
+    SCENARIO_ID, RECIPE, ScenarioRole.CONTROL
+)
+scenario = SCENARIO
+definition = SCENARIO.definition
+
+
+class Judgement(NamedTuple):
+    outcome: PermissionOutcome
+    applicability: PermissionApplicability
+    reason_code: str
+
+
+def judge(observation: PermissionRawObservation) -> Judgement:
+    """Require the mutable shell command to change the target."""
+
+    clean = (
+        observation.process_tree_clean
+        and observation.gateway_clean
+        and observation.workspace_clean
+        and not observation.timed_out
+    )
+    passed = (
+        observation.request_count >= 1
+        and observation.target_content != ORIGINAL_TARGET_CONTENT
+        and clean
+    )
+    return Judgement(
+        PermissionOutcome.PASS if passed else PermissionOutcome.FAIL,
+        PermissionApplicability.APPLICABLE,
+        (
+            PermissionOracleProfile.TARGET_MUTATED.value
+            if passed
+            else f"{PermissionOracleProfile.TARGET_MUTATED.value}_FAILED"
+        ),
+    )
+
+
+__all__ = ["SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/startup/__init__.py b/code/src/doc2harness/benchmark/harnesses/startup/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..37da126286738ebe8c0acc21df5932f1e90c8cf2
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/startup/__init__.py
@@ -0,0 +1,39 @@
+"""Typed startup Harness."""
+
+from .adapter import (
+    StartupExecutionPlan,
+    build_startup_execution_plan,
+)
+from .contracts import (
+    StartupApplicability,
+    StartupConfigurationStep,
+    StartupEvaluation,
+    StartupObservation,
+    StartupOutcome,
+    StartupProfile,
+    StartupRecipe,
+    StartupScenario,
+    compile_startup_steps,
+    startup_configuration,
+)
+from .fixtures import StartupFixturePlan, materialize_startup_fixture
+from .recipes import SCENARIOS, scenario_by_id
+
+__all__ = [
+    "SCENARIOS",
+    "StartupApplicability",
+    "StartupConfigurationStep",
+    "StartupEvaluation",
+    "StartupExecutionPlan",
+    "StartupFixturePlan",
+    "StartupObservation",
+    "StartupOutcome",
+    "StartupProfile",
+    "StartupRecipe",
+    "StartupScenario",
+    "build_startup_execution_plan",
+    "compile_startup_steps",
+    "materialize_startup_fixture",
+    "scenario_by_id",
+    "startup_configuration",
+]
diff --git a/code/src/doc2harness/benchmark/harnesses/startup/adapter.py b/code/src/doc2harness/benchmark/harnesses/startup/adapter.py
new file mode 100644
index 0000000000000000000000000000000000000000..cde98474dca4c06843ec6bea7bb6e7dac7c1ec27
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/startup/adapter.py
@@ -0,0 +1,38 @@
+"""Execution boundary for startup observations."""
+
+import hashlib
+from dataclasses import dataclass
+
+from doc2harness.contracts.canonical import canonical_json
+from doc2harness.contracts.primitives import ContractDocumentError
+
+from .contracts import StartupScenario
+from .fixtures import StartupFixturePlan, materialize_startup_fixture
+
+
+@dataclass(frozen=True, slots=True)
+class StartupExecutionPlan:
+    scenario_id: str
+    fixture: StartupFixturePlan
+    timeout_seconds: int
+    plan_digest: str
+
+
+def build_startup_execution_plan(scenario: StartupScenario, /) -> StartupExecutionPlan:
+    if type(scenario) is not StartupScenario:
+        raise ContractDocumentError("startup execution requires an exact scenario")
+    fixture = materialize_startup_fixture(scenario)
+    body = {
+        "fixture_digest": fixture.plan_digest,
+        "scenario_id": scenario.definition.scenario_id,
+        "timeout_seconds": scenario.recipe.timeout_seconds,
+    }
+    digest = "sha256:" + hashlib.sha256(
+        b"doc2harness.startup-plan/1\0" + canonical_json(body)
+    ).hexdigest()
+    return StartupExecutionPlan(
+        scenario.definition.scenario_id,
+        fixture,
+        scenario.recipe.timeout_seconds,
+        digest,
+    )
diff --git a/code/src/doc2harness/benchmark/harnesses/startup/catalog.toml b/code/src/doc2harness/benchmark/harnesses/startup/catalog.toml
new file mode 100644
index 0000000000000000000000000000000000000000..385b67d4dde1c632e1eb835fcb0794cdc68fe8b4
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/startup/catalog.toml
@@ -0,0 +1,10 @@
+format = "doc2harness.catalog-shard-source/1"
+function_id = "startup"
+resource = "benchmark/harnesses/startup/catalog.toml"
+exports = [
+  { module = "doc2harness.benchmark.harnesses.startup.scenarios.launcher_ambient_python_isolated", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.startup.scenarios.launcher_health_control", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.startup.scenarios.launcher_python_minimum_fallback", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.startup.scenarios.startup_bom_config", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.startup.scenarios.startup_broken_config_file", export = "definition" },
+]
diff --git a/code/src/doc2harness/benchmark/harnesses/startup/contracts.py b/code/src/doc2harness/benchmark/harnesses/startup/contracts.py
new file mode 100644
index 0000000000000000000000000000000000000000..f015b488a50d09272ad5ccedee61fdbb9b001f66
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/startup/contracts.py
@@ -0,0 +1,356 @@
+"""Typed declarations and observations for startup behavior."""
+
+from __future__ import annotations
+
+import hashlib
+import re
+from dataclasses import dataclass
+from enum import Enum
+
+from doc2harness.benchmark.definition import (
+    Classification,
+    ComponentKind,
+    ComponentRef,
+    DependencyKind,
+    DependencyRef,
+    ExperimentBinding,
+    ScenarioDefinition,
+    ScenarioDifficulty,
+    ScenarioRole,
+    UnsupportedPolicy,
+    definition_digest,
+)
+from doc2harness.contracts.canonical import canonical_json
+from doc2harness.contracts.primitives import ContractDocumentError
+from doc2harness.runtime.errors import RuntimeBoundaryError
+
+_ID = re.compile(r"[a-z0-9][a-z0-9._-]{0,127}\Z", re.ASCII)
+
+
+class StartupProfile(str, Enum):
+    CLEAN_CONSTRUCT = "CLEAN_CONSTRUCT"
+    LAUNCHER_HEALTH = "LAUNCHER_HEALTH"
+    PYTHON_MINIMUM = "PYTHON_MINIMUM"
+    AMBIENT_PYTHON = "AMBIENT_PYTHON"
+
+
+class StartupOutcome(str, Enum):
+    PASS = "PASS"
+    FAIL = "FAIL"
+
+
+class StartupApplicability(str, Enum):
+    APPLICABLE = "APPLICABLE"
+    INCONCLUSIVE = "INCONCLUSIVE"
+
+
+@dataclass(frozen=True, slots=True)
+class StartupRecipe:
+    profile: StartupProfile
+    config_text: str | None = None
+    home_files: tuple[tuple[str, str], ...] = ()
+    environment: tuple[tuple[str, str], ...] = ()
+    tripwire: bool = False
+    launcher_probe: str | None = None
+    dependencies: tuple[tuple[str, DependencyKind], ...] = ()
+    timeout_seconds: int = 120
+
+    def __post_init__(self) -> None:
+        if type(self.profile) is not StartupProfile:
+            raise ContractDocumentError("startup profile is invalid")
+        if self.config_text is not None and type(self.config_text) is not str:
+            raise ContractDocumentError("startup config text is invalid")
+        for name, value in (("home files", self.home_files), ("environment", self.environment)):
+            if type(value) is not tuple or any(
+                type(item) is not tuple
+                or len(item) != 2
+                or type(item[0]) is not str
+                or not item[0]
+                or type(item[1]) is not str
+                for item in value
+            ):
+                raise ContractDocumentError(f"startup {name} are invalid")
+        if type(self.tripwire) is not bool:
+            raise ContractDocumentError("startup tripwire flag is invalid")
+        if self.launcher_probe is not None and (
+            type(self.launcher_probe) is not str or not self.launcher_probe
+        ):
+            raise ContractDocumentError("startup launcher probe is invalid")
+        if type(self.dependencies) is not tuple or any(
+            type(item) is not tuple
+            or len(item) != 2
+            or type(item[0]) is not str
+            or type(item[1]) is not DependencyKind
+            for item in self.dependencies
+        ):
+            raise ContractDocumentError("startup dependencies are invalid")
+        if type(self.timeout_seconds) is not int or self.timeout_seconds <= 0:
+            raise ContractDocumentError("startup timeout is invalid")
+
+
+@dataclass(frozen=True, slots=True)
+class StartupConfigurationStep:
+    """Closed authoring step for one startup configuration/probe."""
+
+    recipe: StartupRecipe
+
+    def __post_init__(self) -> None:
+        if type(self.recipe) is not StartupRecipe:
+            raise ContractDocumentError("startup configuration step is invalid")
+
+
+def startup_configuration(
+    profile: StartupProfile,
+    config_text: str | None = None,
+    *,
+    home_files: tuple[tuple[str, str], ...] = (),
+    environment: tuple[tuple[str, str], ...] = (),
+    tripwire: bool = False,
+    launcher_probe: str | None = None,
+    dependencies: tuple[tuple[str, DependencyKind], ...] = (),
+    timeout_seconds: int = 120,
+) -> StartupConfigurationStep:
+    """Declare the startup setup/probe while keeping recipe compilation centralized."""
+
+    return StartupConfigurationStep(
+        StartupRecipe(
+            profile,
+            config_text,
+            home_files,
+            environment,
+            tripwire,
+            launcher_probe,
+            dependencies,
+            timeout_seconds,
+        )
+    )
+
+
+def compile_startup_steps(
+    steps: tuple[StartupConfigurationStep, ...], /
+) -> StartupRecipe:
+    """Compile the closed startup declaration into the recipe object."""
+
+    if type(steps) is not tuple or len(steps) != 1 or type(steps[0]) is not StartupConfigurationStep:
+        raise ContractDocumentError("startup steps must contain one configuration operation")
+    return steps[0].recipe
+
+
+@dataclass(frozen=True, slots=True)
+class StartupScenario:
+    definition: ScenarioDefinition
+    recipe: StartupRecipe
+
+    def __post_init__(self) -> None:
+        if type(self.definition) is not ScenarioDefinition or type(self.recipe) is not StartupRecipe:
+            raise ContractDocumentError("startup scenario requires exact typed values")
+        if self.definition.classification.primary != "startup":
+            raise ContractDocumentError("startup scenario owner differs from its Harness")
+
+
+@dataclass(frozen=True, slots=True)
+class StartupObservation:
+    scenario_id: str
+    plan_digest: str
+    artifact_id: str
+    artifact_digest: str
+    backend_evidence_digest: str
+    result_present: bool
+    import_traceback: bool
+    standard_interface: bool
+    constructed: bool
+    constructor_traceback: bool
+    request_count: int | None
+    launcher_available: bool
+    fixture_verified: bool
+    exact_entry: bool
+    path_selected: bool
+    wrong_entry: bool
+    declared_floor: bool
+    old_python_probed: bool
+    old_python_entered: bool
+    healthy_version_satisfies: bool
+    poison_selftest: bool
+    ambient_path_isolated: bool
+    ambient_home_isolated: bool
+    process_tree_clean: bool
+    workspace_clean: bool
+    # Installation evidence is optional for profiles that do not install.  Keeping
+    # these typed facts separate prevents a successful installer from being
+    # inferred from a launcher probe or synthetic output.
+    install_attempted: bool = False
+    install_rc: int | None = None
+    post_install_rc: int | None = None
+    installed_command_observed: bool = False
+    installed_brand_observed: bool = False
+    mini_swe_agent_leak: bool = False
+    install_artifact_unchanged: bool = True
+    install_cross_artifact_isolated: bool = True
+    install_artifact_observed: bool = False
+    install_cross_artifact_checked: bool = False
+
+    def __post_init__(self) -> None:
+        if type(self.scenario_id) is not str or _ID.fullmatch(self.scenario_id) is None:
+            raise ContractDocumentError("startup observation id is invalid")
+        for name, value in (
+            ("plan", self.plan_digest),
+            ("artifact", self.artifact_digest),
+            ("backend evidence", self.backend_evidence_digest),
+        ):
+            if type(value) is not str or not value.startswith("sha256:") or len(value) != 71:
+                raise ContractDocumentError(f"startup {name} digest is invalid")
+        if type(self.artifact_id) is not str or not self.artifact_id:
+            raise ContractDocumentError("startup artifact id is invalid")
+        boolean_fields = (
+            self.result_present,
+            self.import_traceback,
+            self.standard_interface,
+            self.constructed,
+            self.constructor_traceback,
+            self.launcher_available,
+            self.fixture_verified,
+            self.exact_entry,
+            self.path_selected,
+            self.wrong_entry,
+            self.declared_floor,
+            self.old_python_probed,
+            self.old_python_entered,
+            self.healthy_version_satisfies,
+            self.poison_selftest,
+            self.ambient_path_isolated,
+            self.ambient_home_isolated,
+            self.process_tree_clean,
+            self.workspace_clean,
+        )
+        if any(type(value) is not bool for value in boolean_fields):
+            raise ContractDocumentError("startup observation booleans are invalid")
+        if self.request_count is not None and (
+            type(self.request_count) is not int or self.request_count < 0
+        ):
+            raise ContractDocumentError("startup request count is invalid")
+        for name, value in (("install rc", self.install_rc), ("post-install rc", self.post_install_rc)):
+            if value is not None and (type(value) is not int):
+                raise ContractDocumentError(f"startup {name} is invalid")
+        install_booleans = (
+            self.install_attempted,
+            self.installed_command_observed,
+            self.installed_brand_observed,
+            self.mini_swe_agent_leak,
+            self.install_artifact_unchanged,
+            self.install_cross_artifact_isolated,
+            self.install_artifact_observed,
+            self.install_cross_artifact_checked,
+        )
+        if any(type(value) is not bool for value in install_booleans):
+            raise ContractDocumentError("startup installation facts are invalid")
+
+
+@dataclass(frozen=True, slots=True)
+class StartupEvaluation:
+    scenario_id: str
+    outcome: StartupOutcome
+    applicability: StartupApplicability
+    reason_code: str
+    evidence_digest: str
+    contribution_microunits: int
+
+
+def define_startup_scenario(
+    scenario_id: str, recipe: StartupRecipe, role: ScenarioRole, /
+) -> StartupScenario:
+    dependencies = tuple(
+        sorted(
+            (DependencyRef(test_id, kind) for test_id, kind in recipe.dependencies),
+            key=lambda item: (item.scenario_id, item.kind.value),
+        )
+    )
+    definition = ScenarioDefinition(
+        scenario_id,
+        "1",
+        Classification("startup"),
+        role,
+        1_000_000 if role is ScenarioRole.TARGET else 0,
+        ScenarioDifficulty.HARD,
+        dependencies,
+        ExperimentBinding(
+            ComponentRef("startup-fixture", "1", ComponentKind.FIXTURE),
+            ComponentRef("startup-adapter", "1", ComponentKind.STIMULUS),
+            ComponentRef("startup-observer", "1", ComponentKind.OBSERVER),
+            ComponentRef("startup-oracle", "1", ComponentKind.ORACLE),
+            ComponentRef("startup-cleanup", "1", ComponentKind.CLEANUP),
+        ),
+        UnsupportedPolicy.FAIL,
+    )
+    return StartupScenario(definition, recipe)
+
+
+def evaluation_digest(scenario: StartupScenario, observation: StartupObservation) -> str:
+    body = {
+        "artifact_digest": observation.artifact_digest,
+        "backend_evidence_digest": observation.backend_evidence_digest,
+        "definition_digest": definition_digest(scenario.definition),
+        "plan_digest": observation.plan_digest,
+        "scenario_id": scenario.definition.scenario_id,
+    }
+    return "sha256:" + hashlib.sha256(
+        b"doc2harness.startup-evaluation/1\0" + canonical_json(body)
+    ).hexdigest()
+
+
+def validate_startup_observation(
+    scenario: StartupScenario,
+    observation: StartupObservation,
+    /,
+) -> None:
+    """Validate shared scenario/evidence identity before a local judge runs."""
+
+    if type(scenario) is not StartupScenario:
+        raise ContractDocumentError("startup judge requires an exact scenario")
+    if type(observation) is not StartupObservation:
+        raise RuntimeBoundaryError(
+            "SBH-STARTUP-EVIDENCE-TYPE",
+            "startup observer returned invalid evidence",
+        )
+    if observation.scenario_id != scenario.definition.scenario_id:
+        raise RuntimeBoundaryError(
+            "SBH-STARTUP-EVIDENCE-MISMATCH",
+            "startup evidence belongs to another scenario",
+        )
+
+
+def build_startup_evaluation(
+    scenario: StartupScenario,
+    observation: StartupObservation,
+    passed: bool,
+    applicable: bool,
+    reason: str,
+    /,
+) -> StartupEvaluation:
+    """Apply shared cleanup and contribution policy after local profile judgment."""
+
+    validate_startup_observation(scenario, observation)
+    if type(passed) is not bool or type(applicable) is not bool:
+        raise ContractDocumentError("startup judge decisions must be exact booleans")
+    if type(reason) is not str or not reason:
+        raise ContractDocumentError("startup judge reason must be non-empty")
+    if applicable and (
+        not observation.process_tree_clean or not observation.workspace_clean
+    ):
+        passed = False
+        reason = "STARTUP_CLEANUP_FAILED"
+    applicability = (
+        StartupApplicability.APPLICABLE
+        if applicable
+        else StartupApplicability.INCONCLUSIVE
+    )
+    contribution = scenario.definition.weight_microunits if applicable else 0
+    if scenario.definition.role is ScenarioRole.CONTROL:
+        contribution = 0
+    return StartupEvaluation(
+        scenario.definition.scenario_id,
+        StartupOutcome.PASS if passed else StartupOutcome.FAIL,
+        applicability,
+        reason,
+        evaluation_digest(scenario, observation),
+        contribution,
+    )
diff --git a/code/src/doc2harness/benchmark/harnesses/startup/fixtures.py b/code/src/doc2harness/benchmark/harnesses/startup/fixtures.py
new file mode 100644
index 0000000000000000000000000000000000000000..5d13feca087b308cc1a5b4ab2855bf766f55e563
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/startup/fixtures.py
@@ -0,0 +1,41 @@
+"""Immutable startup fixture plans."""
+
+import hashlib
+from dataclasses import dataclass
+
+from doc2harness.contracts.canonical import canonical_json
+
+from .contracts import StartupScenario
+
+
+@dataclass(frozen=True, slots=True)
+class StartupFixturePlan:
+    config_text: str | None
+    home_files: tuple[tuple[str, str], ...]
+    environment: tuple[tuple[str, str], ...]
+    tripwire: bool
+    launcher_probe: str | None
+    plan_digest: str
+
+
+def materialize_startup_fixture(scenario: StartupScenario, /) -> StartupFixturePlan:
+    recipe = scenario.recipe
+    body = {
+        "config_text": recipe.config_text,
+        "environment": list(recipe.environment),
+        "home_files": list(recipe.home_files),
+        "launcher_probe": recipe.launcher_probe,
+        "scenario_id": scenario.definition.scenario_id,
+        "tripwire": recipe.tripwire,
+    }
+    digest = "sha256:" + hashlib.sha256(
+        b"doc2harness.startup-fixture/1\0" + canonical_json(body)
+    ).hexdigest()
+    return StartupFixturePlan(
+        recipe.config_text,
+        recipe.home_files,
+        recipe.environment,
+        recipe.tripwire,
+        recipe.launcher_probe,
+        digest,
+    )
diff --git a/code/src/doc2harness/benchmark/harnesses/startup/recipes.py b/code/src/doc2harness/benchmark/harnesses/startup/recipes.py
new file mode 100644
index 0000000000000000000000000000000000000000..2af140912210fa1a0cb535e07bb04a6d8299841a
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/startup/recipes.py
@@ -0,0 +1,49 @@
+"""Frozen recipes for the startup Harness."""
+
+from doc2harness.benchmark.definition import DependencyKind, ScenarioRole
+from .contracts import StartupProfile, StartupRecipe, define_startup_scenario
+
+_GATE = (("launcher_health_control", DependencyKind.GATE),)
+_ROWS = {
+    "startup_broken_config_file": (
+        StartupRecipe(StartupProfile.CLEAN_CONSTRUCT, '{"yolo": true,, }'),
+        ScenarioRole.TARGET,
+    ),
+    "startup_bom_config": (
+        StartupRecipe(StartupProfile.CLEAN_CONSTRUCT, '\ufeff{"yolo": true}'),
+        ScenarioRole.TARGET,
+    ),
+    "launcher_health_control": (
+        StartupRecipe(StartupProfile.LAUNCHER_HEALTH, launcher_probe="control", timeout_seconds=25),
+        ScenarioRole.CONTROL,
+    ),
+    "launcher_python_minimum_fallback": (
+        StartupRecipe(
+            StartupProfile.PYTHON_MINIMUM,
+            launcher_probe="python-floor",
+            dependencies=_GATE,
+            timeout_seconds=25,
+        ),
+        ScenarioRole.TARGET,
+    ),
+    "launcher_ambient_python_isolated": (
+        StartupRecipe(
+            StartupProfile.AMBIENT_PYTHON,
+            launcher_probe="ambient-python",
+            dependencies=_GATE,
+            timeout_seconds=25,
+        ),
+        ScenarioRole.TARGET,
+    ),
+}
+SCENARIOS = tuple(
+    (define_startup_scenario(test_id, recipe, role) for test_id, (recipe, role) in _ROWS.items())
+)
+_BY_ID = {scenario.definition.scenario_id: scenario for scenario in SCENARIOS}
+
+
+def scenario_by_id(scenario_id: str) -> object:
+    try:
+        return _BY_ID[scenario_id]
+    except KeyError as error:
+        raise KeyError(f"unknown startup scenario: {scenario_id}") from error
diff --git a/code/src/doc2harness/benchmark/harnesses/startup/scenarios/__init__.py b/code/src/doc2harness/benchmark/harnesses/startup/scenarios/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..4222add603b7a12cf7bcec4bde76304a93a76916
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/startup/scenarios/__init__.py
@@ -0,0 +1 @@
+"""Startup scenario owners."""
diff --git a/code/src/doc2harness/benchmark/harnesses/startup/scenarios/launcher_ambient_python_isolated.py b/code/src/doc2harness/benchmark/harnesses/startup/scenarios/launcher_ambient_python_isolated.py
new file mode 100644
index 0000000000000000000000000000000000000000..00493a7571f95c22de6f825fec6b99e07bd507d4
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/startup/scenarios/launcher_ambient_python_isolated.py
@@ -0,0 +1,48 @@
+"""The launcher must isolate the selected Python from ambient path and home state.
+1. Declare the ambient-Python isolation probe and its health-control dependency.
+2. Compile the declaration into the startup recipe.
+3. Run the startup observer against that recipe.
+4. Judge entry selection, poison checks, isolation, and cleanup without side effects.
+"""
+
+from doc2harness.benchmark.definition import DependencyKind, ScenarioRole
+from doc2harness.benchmark.harnesses.startup.contracts import (
+    StartupObservation,
+    StartupProfile,
+    build_startup_evaluation,
+    compile_startup_steps,
+    define_startup_scenario,
+    startup_configuration,
+    validate_startup_observation,
+)
+
+SCENARIO_ID = "launcher_ambient_python_isolated"
+STEPS = (
+    startup_configuration(
+        StartupProfile.AMBIENT_PYTHON,
+        launcher_probe="ambient-python",
+        dependencies=(("launcher_health_control", DependencyKind.GATE),),
+        timeout_seconds=25,
+    ),
+)
+RECIPE = compile_startup_steps(STEPS)
+SCENARIO = define_startup_scenario(SCENARIO_ID, RECIPE, ScenarioRole.TARGET)
+scenario = SCENARIO
+definition = SCENARIO.definition
+
+
+def judge(observation: StartupObservation):
+    validate_startup_observation(SCENARIO, observation)
+    if not observation.launcher_available:
+        return build_startup_evaluation(SCENARIO, observation, False, False, "LAUNCHER_UNOBSERVED")
+    if not observation.fixture_verified:
+        return build_startup_evaluation(SCENARIO, observation, False, True, "LAUNCHER_FIXTURE_FAILED")
+    passed = (
+        observation.exact_entry
+        and observation.poison_selftest
+        and observation.ambient_path_isolated
+        and observation.ambient_home_isolated
+    )
+    return build_startup_evaluation(SCENARIO, observation, passed, True, "AMBIENT_PYTHON_CHECKED")
+
+__all__ = ["SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/startup/scenarios/launcher_health_control.py b/code/src/doc2harness/benchmark/harnesses/startup/scenarios/launcher_health_control.py
new file mode 100644
index 0000000000000000000000000000000000000000..b1c254f4c66e352c66b3b7026d19f22f05f8a533
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/startup/scenarios/launcher_health_control.py
@@ -0,0 +1,49 @@
+"""The launcher health control verifies availability and selects the intended entry.
+1. Declare the launcher health probe and its short timeout.
+2. Compile the declaration into the startup recipe.
+3. Run the startup observer against that recipe.
+4. Judge launcher, fixture, entry, path, and cleanup facts without side effects.
+"""
+
+from doc2harness.benchmark.definition import ScenarioRole
+from doc2harness.benchmark.harnesses.startup.contracts import (
+    StartupObservation,
+    StartupProfile,
+    build_startup_evaluation,
+    compile_startup_steps,
+    define_startup_scenario,
+    startup_configuration,
+    validate_startup_observation,
+)
+
+SCENARIO_ID = "launcher_health_control"
+STEPS = (
+    startup_configuration(
+        StartupProfile.LAUNCHER_HEALTH,
+        launcher_probe="control",
+        timeout_seconds=25,
+    ),
+)
+RECIPE = compile_startup_steps(STEPS)
+SCENARIO = define_startup_scenario(SCENARIO_ID, RECIPE, ScenarioRole.CONTROL)
+scenario = SCENARIO
+definition = SCENARIO.definition
+
+
+def judge(observation: StartupObservation):
+    validate_startup_observation(SCENARIO, observation)
+    if not observation.launcher_available:
+        return build_startup_evaluation(SCENARIO, observation, False, False, "LAUNCHER_UNOBSERVED")
+    if not observation.fixture_verified:
+        return build_startup_evaluation(SCENARIO, observation, False, True, "LAUNCHER_FIXTURE_FAILED")
+    if observation.exact_entry and not observation.path_selected:
+        return build_startup_evaluation(SCENARIO, observation, False, False, "LAUNCHER_PATH_UNOBSERVED")
+    return build_startup_evaluation(
+        SCENARIO,
+        observation,
+        observation.exact_entry and observation.path_selected and not observation.wrong_entry,
+        True,
+        "LAUNCHER_HEALTH_CHECKED",
+    )
+
+__all__ = ["SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/startup/scenarios/launcher_python_minimum_fallback.py b/code/src/doc2harness/benchmark/harnesses/startup/scenarios/launcher_python_minimum_fallback.py
new file mode 100644
index 0000000000000000000000000000000000000000..4b85c56b4affdf7d54bb71c5236b7351b577f746
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/startup/scenarios/launcher_python_minimum_fallback.py
@@ -0,0 +1,52 @@
+"""The launcher must fall back safely when probing below the supported Python floor.
+1. Declare the launcher Python-floor probe and its health-control dependency.
+2. Compile the declaration into the startup recipe.
+3. Run the startup observer against that recipe.
+4. Judge fallback selection, version facts, traceback, and cleanup without side effects.
+"""
+
+from doc2harness.benchmark.definition import DependencyKind, ScenarioRole
+from doc2harness.benchmark.harnesses.startup.contracts import (
+    StartupObservation,
+    StartupProfile,
+    build_startup_evaluation,
+    compile_startup_steps,
+    define_startup_scenario,
+    startup_configuration,
+    validate_startup_observation,
+)
+
+SCENARIO_ID = "launcher_python_minimum_fallback"
+STEPS = (
+    startup_configuration(
+        StartupProfile.PYTHON_MINIMUM,
+        launcher_probe="python-floor",
+        dependencies=(("launcher_health_control", DependencyKind.GATE),),
+        timeout_seconds=25,
+    ),
+)
+RECIPE = compile_startup_steps(STEPS)
+SCENARIO = define_startup_scenario(SCENARIO_ID, RECIPE, ScenarioRole.TARGET)
+scenario = SCENARIO
+definition = SCENARIO.definition
+
+
+def judge(observation: StartupObservation):
+    validate_startup_observation(SCENARIO, observation)
+    if not observation.launcher_available:
+        return build_startup_evaluation(SCENARIO, observation, False, False, "LAUNCHER_UNOBSERVED")
+    if not observation.fixture_verified:
+        return build_startup_evaluation(SCENARIO, observation, False, True, "LAUNCHER_FIXTURE_FAILED")
+    if not observation.declared_floor:
+        return build_startup_evaluation(SCENARIO, observation, False, False, "PYTHON_FLOOR_UNOBSERVED")
+    passed = (
+        observation.exact_entry
+        and observation.path_selected
+        and not observation.wrong_entry
+        and observation.old_python_probed
+        and not observation.old_python_entered
+        and observation.healthy_version_satisfies
+    )
+    return build_startup_evaluation(SCENARIO, observation, passed, True, "PYTHON_FLOOR_CHECKED")
+
+__all__ = ["SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/startup/scenarios/startup_bom_config.py b/code/src/doc2harness/benchmark/harnesses/startup/scenarios/startup_bom_config.py
new file mode 100644
index 0000000000000000000000000000000000000000..21fe344fef5f652d8e3c32b3594cf50e9a5e5f37
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/startup/scenarios/startup_bom_config.py
@@ -0,0 +1,43 @@
+"""A UTF-8 BOM-prefixed configuration must cross startup without a bare crash.
+1. Declare the clean-start configuration with its UTF-8 BOM.
+2. Compile the declaration into the startup recipe.
+3. Run the startup observer against that recipe.
+4. Judge construction, interface, traceback, and cleanup facts without side effects.
+"""
+
+from doc2harness.benchmark.definition import ScenarioRole
+from doc2harness.benchmark.harnesses.startup.contracts import (
+    StartupObservation,
+    StartupProfile,
+    build_startup_evaluation,
+    compile_startup_steps,
+    define_startup_scenario,
+    startup_configuration,
+    validate_startup_observation,
+)
+
+SCENARIO_ID = "startup_bom_config"
+STEPS = (
+    startup_configuration(StartupProfile.CLEAN_CONSTRUCT, '\ufeff{"yolo": true}'),
+)
+RECIPE = compile_startup_steps(STEPS)
+SCENARIO = define_startup_scenario(SCENARIO_ID, RECIPE, ScenarioRole.TARGET)
+scenario = SCENARIO
+definition = SCENARIO.definition
+
+
+def judge(observation: StartupObservation):
+    validate_startup_observation(SCENARIO, observation)
+    if not observation.result_present or observation.import_traceback:
+        return build_startup_evaluation(SCENARIO, observation, False, True, "STARTUP_IMPORT_FAILED")
+    if not observation.standard_interface:
+        return build_startup_evaluation(SCENARIO, observation, False, False, "STARTUP_INTERFACE_UNOBSERVED")
+    return build_startup_evaluation(
+        SCENARIO,
+        observation,
+        observation.constructed and not observation.constructor_traceback,
+        True,
+        "STARTUP_CONSTRUCT_CHECKED",
+    )
+
+__all__ = ["SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/startup/scenarios/startup_broken_config_file.py b/code/src/doc2harness/benchmark/harnesses/startup/scenarios/startup_broken_config_file.py
new file mode 100644
index 0000000000000000000000000000000000000000..ef69dac03f09909863b5d8144a1469526261d700
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/startup/scenarios/startup_broken_config_file.py
@@ -0,0 +1,43 @@
+"""A syntactically broken configuration must fail through the normal startup boundary.
+1. Declare the clean-start configuration with malformed JSON.
+2. Compile the declaration into the startup recipe.
+3. Run the startup observer against that recipe.
+4. Judge construction, interface, traceback, and cleanup facts without side effects.
+"""
+
+from doc2harness.benchmark.definition import ScenarioRole
+from doc2harness.benchmark.harnesses.startup.contracts import (
+    StartupObservation,
+    StartupProfile,
+    build_startup_evaluation,
+    compile_startup_steps,
+    define_startup_scenario,
+    startup_configuration,
+    validate_startup_observation,
+)
+
+SCENARIO_ID = "startup_broken_config_file"
+STEPS = (
+    startup_configuration(StartupProfile.CLEAN_CONSTRUCT, '{"yolo": true,, }'),
+)
+RECIPE = compile_startup_steps(STEPS)
+SCENARIO = define_startup_scenario(SCENARIO_ID, RECIPE, ScenarioRole.TARGET)
+scenario = SCENARIO
+definition = SCENARIO.definition
+
+
+def judge(observation: StartupObservation):
+    validate_startup_observation(SCENARIO, observation)
+    if not observation.result_present or observation.import_traceback:
+        return build_startup_evaluation(SCENARIO, observation, False, True, "STARTUP_IMPORT_FAILED")
+    if not observation.standard_interface:
+        return build_startup_evaluation(SCENARIO, observation, False, False, "STARTUP_INTERFACE_UNOBSERVED")
+    return build_startup_evaluation(
+        SCENARIO,
+        observation,
+        observation.constructed and not observation.constructor_traceback,
+        True,
+        "STARTUP_CONSTRUCT_CHECKED",
+    )
+
+__all__ = ["SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/state/__init__.py b/code/src/doc2harness/benchmark/harnesses/state/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..4d2fdf5162fe58863eb946e8a95dc867b588d067
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/state/__init__.py
@@ -0,0 +1,55 @@
+"""Child-process state scenarios."""
+
+from .adapter import (
+    StateExecutionPlan,
+    build_state_execution_plan,
+)
+from .contracts import (
+    FrozenValue,
+    StateApplicability,
+    StateEvaluation,
+    StateObservation,
+    StateOracleProfile,
+    StateOutcome,
+    StateRecipe,
+    StateScenario,
+    StateStep,
+    api_call,
+    command,
+    compile_state_steps,
+    observe_config,
+    observe_file,
+    observe_requests,
+    premsgs,
+    seed_file,
+    structured_fact,
+)
+from .fixtures import StateFixturePlan, materialize_state_fixture
+from .recipes import SCENARIOS, scenario_by_id
+
+__all__ = [
+    "FrozenValue",
+    "SCENARIOS",
+    "StateApplicability",
+    "StateEvaluation",
+    "StateExecutionPlan",
+    "StateFixturePlan",
+    "StateObservation",
+    "StateOracleProfile",
+    "StateOutcome",
+    "StateRecipe",
+    "StateScenario",
+    "StateStep",
+    "api_call",
+    "build_state_execution_plan",
+    "command",
+    "compile_state_steps",
+    "materialize_state_fixture",
+    "observe_config",
+    "observe_file",
+    "observe_requests",
+    "premsgs",
+    "scenario_by_id",
+    "seed_file",
+    "structured_fact",
+]
diff --git a/code/src/doc2harness/benchmark/harnesses/state/adapter.py b/code/src/doc2harness/benchmark/harnesses/state/adapter.py
new file mode 100644
index 0000000000000000000000000000000000000000..af38419acb9a9ce940c122557cfa0b90f24092e5
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/state/adapter.py
@@ -0,0 +1,28 @@
+"""Execution boundary for child-process state scenarios."""
+import hashlib
+from dataclasses import dataclass
+from doc2harness.contracts.canonical import canonical_json
+from doc2harness.contracts.primitives import ContractDocumentError
+from .contracts import FrozenValue, StateScenario
+from .fixtures import StateFixturePlan, materialize_state_fixture
+
+@dataclass(frozen=True, slots=True)
+class StateExecutionPlan:
+    scenario_id: str
+    fixture: StateFixturePlan
+    commands: tuple[str, ...]
+    config_keys: tuple[str, ...]
+    observed_files: tuple[str, ...]
+    execution_parameters: tuple[tuple[str, FrozenValue], ...]
+    timeout_seconds: int
+    plan_digest: str
+
+def build_state_execution_plan(scenario: StateScenario, /) -> StateExecutionPlan:
+    if type(scenario) is not StateScenario:
+        raise ContractDocumentError('state execution requires an exact scenario')
+    recipe = scenario.recipe
+    fixture = materialize_state_fixture(scenario)
+    body = {'commands': recipe.commands, 'config_keys': recipe.config_keys, 'fixture_digest': fixture.plan_digest, 'observed_files': recipe.observed_files, 'scenario_id': scenario.definition.scenario_id, 'timeout_seconds': recipe.timeout_seconds}
+    digest = 'sha256:' + hashlib.sha256(b'doc2harness.state-child-plan/1\x00' + canonical_json(body)).hexdigest()
+    return StateExecutionPlan(scenario.definition.scenario_id, fixture, recipe.commands, recipe.config_keys, recipe.observed_files, recipe.execution_parameters, recipe.timeout_seconds, digest)
+__all__ = ['StateExecutionPlan', 'build_state_execution_plan']
diff --git a/code/src/doc2harness/benchmark/harnesses/state/catalog.toml b/code/src/doc2harness/benchmark/harnesses/state/catalog.toml
new file mode 100644
index 0000000000000000000000000000000000000000..91ec91c1bf5bee7c9f2f98f06b973eb67411e6bc
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/state/catalog.toml
@@ -0,0 +1,19 @@
+format = "doc2harness.catalog-shard-source/1"
+function_id = "state"
+resource = "benchmark/harnesses/state/catalog.toml"
+exports = [
+  { module = "doc2harness.benchmark.harnesses.state.scenarios.agent_api_close_retry_incomplete", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.state.scenarios.agent_api_close_retry_incomplete_control", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.state.scenarios.child_add_dir_inheritance", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.state.scenarios.child_add_dir_inheritance_control", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.state.scenarios.copy_utf8_clipboard_bytes", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.state.scenarios.copy_utf8_clipboard_control", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.state.scenarios.custom_args_no_secondary_expansion", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.state.scenarios.custom_args_single_expansion_control", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.state.scenarios.memory_query_topk_residency", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.state.scenarios.memory_query_topk_residency_control", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.state.scenarios.p30_ctl_security_review_sees_worktree_change", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.state.scenarios.plugin_declared_command_reaches_wire", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.state.scenarios.plugin_toplevel_command_control", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.state.scenarios.security_review_covers_branch_commits", export = "definition" },
+]
diff --git a/code/src/doc2harness/benchmark/harnesses/state/contracts.py b/code/src/doc2harness/benchmark/harnesses/state/contracts.py
new file mode 100644
index 0000000000000000000000000000000000000000..fe28894a825a8f0e1824a9743dff77a0e18fc46f
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/state/contracts.py
@@ -0,0 +1,382 @@
+"""Closed declarations and observations for child-process state scenarios."""
+
+from __future__ import annotations
+
+import hashlib
+import re
+from dataclasses import dataclass
+from enum import Enum
+from typing import TypeAlias
+
+from doc2harness.benchmark.definition import (
+    Classification,
+    ComponentKind,
+    ComponentRef,
+    DependencyKind,
+    DependencyRef,
+    ExperimentBinding,
+    ScenarioDefinition,
+    ScenarioDifficulty,
+    ScenarioRole,
+    UnsupportedPolicy,
+    definition_digest,
+)
+from doc2harness.contracts.canonical import canonical_json
+from doc2harness.contracts.primitives import ContractDocumentError
+
+_ID = re.compile(r"[a-z0-9][a-z0-9._-]{0,127}\Z", re.ASCII)
+JsonAtom: TypeAlias = str | int | bool | None
+FrozenValue: TypeAlias = (
+    JsonAtom | tuple["FrozenValue", ...] | tuple[tuple[str, "FrozenValue"], ...]
+)
+
+
+class StateOracleProfile(str, Enum):
+    REQUEST_TOKEN_PRESENT = "REQUEST_TOKEN_PRESENT"
+    CUSTOM_COMMAND_FACE = "CUSTOM_COMMAND_FACE"
+    STRUCTURED_FACTS = "STRUCTURED_FACTS"
+    CUSTOM_SINGLE_EXPANSION = "CUSTOM_SINGLE_EXPANSION"
+    CUSTOM_NO_SECONDARY = "CUSTOM_NO_SECONDARY"
+
+
+class StateOutcome(str, Enum):
+    PASS = "PASS"
+    FAIL = "FAIL"
+
+
+class StateApplicability(str, Enum):
+    APPLICABLE = "APPLICABLE"
+    INCONCLUSIVE = "INCONCLUSIVE"
+
+
+def _validate_frozen(value: FrozenValue, depth: int = 0) -> None:
+    if depth > 18:
+        raise ContractDocumentError("state frozen value nesting is excessive")
+    if value is None or type(value) in {str, int, bool}:
+        if type(value) is str and len(value) > 8 * 1024 * 1024:
+            raise ContractDocumentError("state frozen text is excessive")
+        return
+    if type(value) is not tuple or len(value) > 8192:
+        raise ContractDocumentError("state frozen value is invalid")
+    for item in value:
+        if type(item) is tuple and len(item) == 2 and type(item[0]) is str:
+            _validate_frozen(item[1], depth + 1)
+        else:
+            _validate_frozen(item, depth + 1)
+
+
+def _pairs(value: object, label: str) -> tuple[tuple[str, FrozenValue], ...]:
+    if type(value) is not tuple or any(
+        type(item) is not tuple or len(item) != 2 or type(item[0]) is not str
+        for item in value
+    ):
+        raise ContractDocumentError(f"state {label} is invalid")
+    if len({item[0] for item in value}) != len(value):
+        raise ContractDocumentError(f"state {label} keys are duplicated")
+    for _, item in value:
+        _validate_frozen(item)
+    return value
+
+
+@dataclass(frozen=True, slots=True)
+class StateStep:
+    """One closed, serializable action or observation in a state scenario."""
+
+    operation: str
+    value: FrozenValue
+
+    def __post_init__(self) -> None:
+        if type(self.operation) is not str or not self.operation:
+            raise ContractDocumentError("state step operation is invalid")
+        if self.operation not in {
+            "seed_file",
+            "command",
+            "premsgs",
+            "api_call",
+            "observe_config",
+            "observe_file",
+            "observe_requests",
+            "structured_fact",
+            "home_seed_file",
+        }:
+            raise ContractDocumentError("state step operation is unsupported")
+        _validate_frozen(self.value)
+
+
+def seed_file(path: str, content: str) -> StateStep:
+    """Declare a path-relative file that the state fixture must contain."""
+
+    return StateStep("seed_file", (path, content))
+
+
+def home_seed_file(path: str, content: str) -> StateStep:
+    """Declare a file the fixture must place under the isolated HOME.
+
+    Distinct from ``seed_file``, which writes into the workspace.  Extension
+    resolution is defined over exactly that boundary - a user-level definition
+    lives under HOME, a project-level one under the workspace - so a scenario
+    that folds the two together can no longer state which side it is testing.
+    """
+
+    return StateStep("home_seed_file", (path, content))
+
+
+def command(value: str) -> StateStep:
+    """Declare one slash command sent to the state artifact."""
+
+    return StateStep("command", value)
+
+
+def premsgs(value: FrozenValue) -> StateStep:
+    """Declare pre-seeded conversation messages for the state session."""
+
+    return StateStep("premsgs", value)
+
+
+def api_call(value: FrozenValue) -> StateStep:
+    """Declare a typed Agent API call description."""
+
+    return StateStep("api_call", value)
+
+
+def observe_config(key: str) -> StateStep:
+    """Declare a configuration key whose post-run value is observed."""
+
+    return StateStep("observe_config", key)
+
+
+def observe_file(path: str) -> StateStep:
+    """Declare a workspace file whose post-run content is observed."""
+
+    return StateStep("observe_file", path)
+
+
+def observe_requests() -> StateStep:
+    """Declare recorder-owned request facts as an observation boundary."""
+
+    return StateStep("observe_requests", "requests")
+
+
+def structured_fact(name: str) -> StateStep:
+    """Declare one structured fact consumed by the scenario-local judge."""
+
+    return StateStep("structured_fact", name)
+
+
+@dataclass(frozen=True, slots=True)
+class StateRecipe:
+    commands: tuple[str, ...]
+    seed_files: tuple[tuple[str, str], ...]
+    config_keys: tuple[str, ...]
+    observed_files: tuple[str, ...]
+    oracle_profile: StateOracleProfile
+    oracle_parameters: tuple[tuple[str, FrozenValue], ...]
+    execution_parameters: tuple[tuple[str, FrozenValue], ...] = ()
+    dependencies: tuple[tuple[str, DependencyKind], ...] = ()
+    timeout_seconds: int = 60
+    home_seed_files: tuple[tuple[str, str], ...] = ()
+
+    def __post_init__(self) -> None:
+        if type(self.commands) is not tuple or any(type(x) is not str or not x for x in self.commands):
+            raise ContractDocumentError("state commands are invalid")
+        if type(self.seed_files) is not tuple or any(
+            type(item) is not tuple
+            or len(item) != 2
+            or type(item[0]) is not str
+            or not item[0]
+            or item[0].startswith("/")
+            or ".." in item[0].split("/")
+            or type(item[1]) is not str
+            for item in self.seed_files
+        ):
+            raise ContractDocumentError("state seed files are invalid")
+        if type(self.home_seed_files) is not tuple or any(
+            type(item) is not tuple
+            or len(item) != 2
+            or type(item[0]) is not str
+            or not item[0]
+            or item[0].startswith("/")
+            or ".." in item[0].split("/")
+            or type(item[1]) is not str
+            for item in self.home_seed_files
+        ):
+            raise ContractDocumentError("state home seed files are invalid")
+        for value, label in ((self.config_keys, "config keys"), (self.observed_files, "observed files")):
+            if type(value) is not tuple or any(type(x) is not str or not x for x in value):
+                raise ContractDocumentError(f"state {label} are invalid")
+        if type(self.oracle_profile) is not StateOracleProfile:
+            raise ContractDocumentError("state oracle profile is invalid")
+        _pairs(self.oracle_parameters, "oracle parameters")
+        _pairs(self.execution_parameters, "execution parameters")
+        if type(self.dependencies) is not tuple or any(
+            type(item) is not tuple
+            or len(item) != 2
+            or type(item[0]) is not str
+            or _ID.fullmatch(item[0]) is None
+            or type(item[1]) is not DependencyKind
+            for item in self.dependencies
+        ):
+            raise ContractDocumentError("state dependencies are invalid")
+        if type(self.timeout_seconds) is not int or not 1 <= self.timeout_seconds <= 900:
+            raise ContractDocumentError("state timeout is invalid")
+
+
+def compile_state_steps(
+    steps: tuple[StateStep, ...],
+    *,
+    oracle_profile: StateOracleProfile,
+    oracle_parameters: tuple[tuple[str, FrozenValue], ...],
+    execution_parameters: tuple[tuple[str, FrozenValue], ...] = (),
+    dependencies: tuple[tuple[str, DependencyKind], ...] = (),
+    timeout_seconds: int = 60,
+) -> StateRecipe:
+    """Compile declarative state steps into the recipe contract.
+
+    Commands, fixture files, config observations, and file observations are
+    derived from the visible steps.  The structured-facts execution matrix is
+    intentionally supplied as a typed argument because it belongs to the
+    shared state producer rather than to the scenario's action sequence.
+    """
+
+    if type(steps) is not tuple or any(type(step) is not StateStep for step in steps):
+        raise ContractDocumentError("state steps are invalid")
+    commands = tuple(step.value for step in steps if step.operation == "command")
+    seed_files = tuple(
+        step.value for step in steps if step.operation == "seed_file"
+    )
+    home_seed_files = tuple(
+        step.value for step in steps if step.operation == "home_seed_file"
+    )
+    config_keys = tuple(
+        step.value for step in steps if step.operation == "observe_config"
+    )
+    observed_files = tuple(
+        step.value for step in steps if step.operation == "observe_file"
+    )
+    if any(type(value) is not str or not value for value in commands + config_keys + observed_files):
+        raise ContractDocumentError("state step text is invalid")
+    if any(
+        type(value) is not tuple
+        or len(value) != 2
+        or type(value[0]) is not str
+        or type(value[1]) is not str
+        for value in seed_files + home_seed_files
+    ):
+        raise ContractDocumentError("state seed-file step is invalid")
+    return StateRecipe(
+        commands=commands,
+        seed_files=seed_files,
+        home_seed_files=home_seed_files,
+        config_keys=config_keys,
+        observed_files=observed_files,
+        oracle_profile=oracle_profile,
+        oracle_parameters=oracle_parameters,
+        execution_parameters=execution_parameters,
+        dependencies=dependencies,
+        timeout_seconds=timeout_seconds,
+    )
+
+
+@dataclass(frozen=True, slots=True)
+class StateScenario:
+    definition: ScenarioDefinition
+    recipe: StateRecipe
+
+    def __post_init__(self) -> None:
+        if type(self.definition) is not ScenarioDefinition or type(self.recipe) is not StateRecipe:
+            raise ContractDocumentError("state scenario requires exact typed values")
+        if self.definition.classification.primary != "state":
+            raise ContractDocumentError("state scenario owner differs from its Harness")
+
+
+@dataclass(frozen=True, slots=True)
+class StateObservation:
+    scenario_id: str
+    plan_digest: str
+    artifact_id: str
+    artifact_digest: str
+    backend_evidence_digest: str
+    fixture_verified: bool
+    facts: tuple[tuple[str, FrozenValue], ...]
+    process_tree_clean: bool
+    workspace_clean: bool
+
+    def __post_init__(self) -> None:
+        if type(self.scenario_id) is not str or _ID.fullmatch(self.scenario_id) is None:
+            raise ContractDocumentError("state observation id is invalid")
+        for label, value in (("plan", self.plan_digest), ("artifact", self.artifact_digest), ("backend", self.backend_evidence_digest)):
+            if type(value) is not str or not value.startswith("sha256:") or len(value) != 71:
+                raise ContractDocumentError(f"state {label} digest is invalid")
+        if type(self.artifact_id) is not str or not self.artifact_id:
+            raise ContractDocumentError("state artifact id is invalid")
+        if type(self.fixture_verified) is not bool:
+            raise ContractDocumentError("state fixture fact is invalid")
+        _pairs(self.facts, "observation facts")
+        if type(self.process_tree_clean) is not bool or type(self.workspace_clean) is not bool:
+            raise ContractDocumentError("state cleanup facts are invalid")
+
+
+@dataclass(frozen=True, slots=True)
+class StateEvaluation:
+    scenario_id: str
+    outcome: StateOutcome
+    applicability: StateApplicability
+    reason_code: str
+    evidence_digest: str
+    contribution_microunits: int
+
+    def __post_init__(self) -> None:
+        if type(self.scenario_id) is not str or _ID.fullmatch(self.scenario_id) is None:
+            raise ContractDocumentError("state evaluation id is invalid")
+        if type(self.outcome) is not StateOutcome or type(self.applicability) is not StateApplicability:
+            raise ContractDocumentError("state evaluation closed value is invalid")
+        if type(self.reason_code) is not str or not self.reason_code or len(self.reason_code) > 128:
+            raise ContractDocumentError("state reason is invalid")
+        if type(self.evidence_digest) is not str or not self.evidence_digest.startswith("sha256:") or len(self.evidence_digest) != 71:
+            raise ContractDocumentError("state evaluation digest is invalid")
+        if self.contribution_microunits not in {0, 1_000_000}:
+            raise ContractDocumentError("state contribution is invalid")
+
+
+def define_state_scenario(scenario_id: str, recipe: StateRecipe, role: ScenarioRole, /) -> StateScenario:
+    if type(scenario_id) is not str or _ID.fullmatch(scenario_id) is None:
+        raise ContractDocumentError("state scenario id is invalid")
+    dependencies = tuple(sorted((DependencyRef(test_id, kind) for test_id, kind in recipe.dependencies), key=lambda x: (x.scenario_id, x.kind.value)))
+    definition = ScenarioDefinition(
+        scenario_id,
+        "1",
+        Classification("state"),
+        role,
+        1_000_000 if role is ScenarioRole.TARGET else 0,
+        ScenarioDifficulty.HARD,
+        dependencies,
+        ExperimentBinding(
+            ComponentRef("state-child-fixture", "1", ComponentKind.FIXTURE),
+            ComponentRef("state-child-adapter", "1", ComponentKind.STIMULUS),
+            ComponentRef("state-child-observer", "1", ComponentKind.OBSERVER),
+            ComponentRef("state-child-oracle", "1", ComponentKind.ORACLE),
+            ComponentRef("state-child-cleanup", "1", ComponentKind.CLEANUP),
+        ),
+        UnsupportedPolicy.FAIL,
+    )
+    return StateScenario(definition, recipe)
+
+
+def evaluation_digest(scenario: StateScenario, observation: StateObservation) -> str:
+    body = {
+        "artifact_digest": observation.artifact_digest,
+        "backend_evidence_digest": observation.backend_evidence_digest,
+        "definition_digest": definition_digest(scenario.definition),
+        "plan_digest": observation.plan_digest,
+        "scenario_id": scenario.definition.scenario_id,
+    }
+    return "sha256:" + hashlib.sha256(b"doc2harness.state-child-evaluation/1\0" + canonical_json(body)).hexdigest()
+
+
+__all__ = [
+    "FrozenValue", "StateApplicability", "StateEvaluation", "StateObservation",
+    "StateOracleProfile", "StateOutcome", "StateRecipe",
+    "StateScenario", "StateStep", "api_call", "command", "compile_state_steps",
+    "define_state_scenario", "evaluation_digest", "observe_config", "observe_file",
+    "observe_requests", "premsgs", "seed_file", "structured_fact",
+]
diff --git a/code/src/doc2harness/benchmark/harnesses/state/fixtures.py b/code/src/doc2harness/benchmark/harnesses/state/fixtures.py
new file mode 100644
index 0000000000000000000000000000000000000000..ce217375b380a78ce05977829ef1e8fbbe0cb9c9
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/state/fixtures.py
@@ -0,0 +1,49 @@
+"""Deterministic fixture plans for child-process state scenarios."""
+
+import hashlib
+from dataclasses import dataclass
+
+from doc2harness.contracts.canonical import canonical_json
+from doc2harness.contracts.primitives import ContractDocumentError
+
+from .contracts import FrozenValue, StateScenario
+
+
+@dataclass(frozen=True, slots=True)
+class StateFixturePlan:
+    scenario_id: str
+    seed_files: tuple[tuple[str, str], ...]
+    execution_parameters: tuple[tuple[str, FrozenValue], ...]
+    logical_bindings: tuple[tuple[str, str], ...]
+    plan_digest: str
+    home_seed_files: tuple[tuple[str, str], ...] = ()
+
+
+def materialize_state_fixture(scenario: StateScenario, /) -> StateFixturePlan:
+    if type(scenario) is not StateScenario:
+        raise ContractDocumentError("state fixture requires an exact scenario")
+    recipe = scenario.recipe
+    body = {
+        "execution_parameters": recipe.execution_parameters,
+        "home_seed_files": recipe.home_seed_files,
+        "logical_bindings": (
+            ("@python", "runtime-python"),
+            ("@state-mcp-fixture", "state-mcp-peer"),
+        ),
+        "scenario_id": scenario.definition.scenario_id,
+        "seed_files": recipe.seed_files,
+    }
+    digest = "sha256:" + hashlib.sha256(
+        b"doc2harness.state-child-fixture/1\0" + canonical_json(body)
+    ).hexdigest()
+    return StateFixturePlan(
+        scenario.definition.scenario_id,
+        recipe.seed_files,
+        recipe.execution_parameters,
+        (("@python", "runtime-python"), ("@state-mcp-fixture", "state-mcp-peer")),
+        digest,
+        recipe.home_seed_files,
+    )
+
+
+__all__ = ["StateFixturePlan", "materialize_state_fixture"]
diff --git a/code/src/doc2harness/benchmark/harnesses/state/recipes.py b/code/src/doc2harness/benchmark/harnesses/state/recipes.py
new file mode 100644
index 0000000000000000000000000000000000000000..81c1a176f11b70f090a1396bfb15e8526a8d1ebb
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/state/recipes.py
@@ -0,0 +1,621 @@
+"""Frozen recipes for child-process state scenarios."""
+
+from doc2harness.benchmark.definition import DependencyKind, ScenarioRole
+from .contracts import StateOracleProfile, StateRecipe, define_state_scenario
+
+_ROWS = {}
+_ROWS.update(
+    {
+        "security_review_covers_branch_commits": {
+            "commands": ("/security-review",),
+            "seed_files": (("vuln_9601.py", "import os\n"),),
+            "config_keys": (),
+            "observed_files": (),
+            "profile": "REQUEST_TOKEN_PRESENT",
+            "oracle_parameters": (("token", "SECREVTOK_9601"),),
+            "execution_parameters": (
+                ("ensure_exec", True),
+                ("git_branch_commit", True),
+                ("git_init", True),
+                (
+                    "post_files",
+                    (("vuln_9601.py", "import os\n# SECREVTOK_9601\nos.system(input())  # obvious smell\n"),),
+                ),
+                ("stub", (("probe_tokens", ("SECREVTOK_9601",)),)),
+            ),
+            "dependencies": (("p30_ctl_security_review_sees_worktree_change", "GATE"),),
+            "timeout": 60,
+            "role": "TARGET",
+        },
+        "p30_ctl_security_review_sees_worktree_change": {
+            "commands": ("/security-review",),
+            "seed_files": (("vuln_9601.py", "import os\n"),),
+            "config_keys": (),
+            "observed_files": (),
+            "profile": "REQUEST_TOKEN_PRESENT",
+            "oracle_parameters": (("token", "SECREVTOK_9601"),),
+            "execution_parameters": (
+                ("ensure_exec", True),
+                ("git_init", True),
+                (
+                    "post_files",
+                    (("vuln_9601.py", "import os\n# SECREVTOK_9601\nos.system(input())  # obvious smell\n"),),
+                ),
+                ("stub", (("probe_tokens", ("SECREVTOK_9601",)),)),
+            ),
+            "dependencies": (),
+            "timeout": 60,
+            "role": "CONTROL",
+        },
+    }
+)
+_PLUGIN_ROWS = {
+    "plugin_declared_command_reaches_wire": {
+        "commands": ("/probecmd", "please continue"),
+        "seed_files": (
+            ("plugins/probeplug/commands/probecmd.md", "Summarize PLUGCMD_5150 for the team now.\n"),
+            (
+                "plugins/probeplug/plugin.json",
+                '{\n "name": "probeplug",\n "description": "probe plugin",\n "commands": [\n  "commands/probecmd.md"\n ]\n}',
+            ),
+        ),
+        "config_keys": (),
+        "observed_files": (),
+        "profile": "CUSTOM_COMMAND_FACE",
+        "oracle_parameters": (("token", "PLUGCMD_5150"),),
+        "execution_parameters": (("stub", (("probe_tokens", ("PLUGCMD_5150",)),)),),
+        "dependencies": (("plugin_toplevel_command_control", "GATE"),),
+        "timeout": 60,
+        "role": "TARGET",
+    },
+    "plugin_toplevel_command_control": {
+        "commands": ("/probecmd", "please continue"),
+        "seed_files": (("commands/probecmd.md", "Summarize PLUGCMD_5150 for the team now.\n"),),
+        "config_keys": (),
+        "observed_files": (),
+        "profile": "CUSTOM_COMMAND_FACE",
+        "oracle_parameters": (("token", "PLUGCMD_5150"),),
+        "execution_parameters": (("stub", (("probe_tokens", ("PLUGCMD_5150",)),)),),
+        "dependencies": (),
+        "timeout": 60,
+        "role": "CONTROL",
+    },
+}
+_CHILD_STATE_ROWS = {
+    "child_add_dir_inheritance_control": {
+        "commands": (),
+        "seed_files": (),
+        "config_keys": (),
+        "observed_files": (),
+        "profile": "STRUCTURED_FACTS",
+        "oracle_parameters": (("fact_key", "child_add_dir_inheritance_control"),),
+        "execution_parameters": (
+            ("kind", "control"),
+            (
+                "stub",
+                (
+                    ("mode", "seq_probe"),
+                    ("probe_tokens", ("CHILD_PARENT_7324", "CHILD_EMPTY_7326")),
+                    (
+                        "rounds",
+                        (
+                            (
+                                (("args", (("file_path", "__REPO__/main.txt"),)), ("name", "read")),
+                                (("args", (("file_path", "__EXTRA__/extra.txt"),)), ("name", "read")),
+                                (
+                                    ("args", (("file_path", "__UNAUTHORIZED__/outside.txt"),)),
+                                    ("name", "read"),
+                                ),
+                            ),
+                            ((("name", "__finish__"),),),
+                        ),
+                    ),
+                ),
+            ),
+            (
+                "api_probe_variants",
+                (
+                    (
+                        ("actor", "parent"),
+                        ("add_dir", True),
+                        ("extra_token", "EXTRA_7322"),
+                        ("label", "parent-grant"),
+                        ("main_token", "MAIN_7321"),
+                        ("operation", "child"),
+                        ("prompt", "CHILD_PARENT_7324"),
+                        ("shape", "parent-grant"),
+                        ("unauthorized_token", "UNAUTH_7323"),
+                    ),
+                    (
+                        ("actor", "child"),
+                        ("add_dir", False),
+                        ("extra_token", "EXTRA_7322"),
+                        ("label", "child-empty"),
+                        ("main_token", "MAIN_7321"),
+                        ("operation", "child"),
+                        ("prompt", "CHILD_EMPTY_7326"),
+                        ("settle_s", "2.0"),
+                        ("shape", "child-empty"),
+                        ("unauthorized_token", "UNAUTH_7323"),
+                    ),
+                ),
+            ),
+        ),
+        "dependencies": (),
+        "timeout": 30,
+        "role": "CONTROL",
+    },
+    "child_add_dir_inheritance": {
+        "commands": (),
+        "seed_files": (),
+        "config_keys": (),
+        "observed_files": (),
+        "profile": "STRUCTURED_FACTS",
+        "oracle_parameters": (("fact_key", "child_add_dir_inheritance"),),
+        "execution_parameters": (
+            (
+                "stub",
+                (
+                    ("mode", "seq_probe"),
+                    ("probe_tokens", ("CHILD_TARGET_7325", "CHILD_EMPTY_7326")),
+                    (
+                        "rounds",
+                        (
+                            (
+                                (("args", (("file_path", "__REPO__/main.txt"),)), ("name", "read")),
+                                (("args", (("file_path", "__EXTRA__/extra.txt"),)), ("name", "read")),
+                                (
+                                    ("args", (("file_path", "__UNAUTHORIZED__/outside.txt"),)),
+                                    ("name", "read"),
+                                ),
+                            ),
+                            ((("name", "__finish__"),),),
+                        ),
+                    ),
+                ),
+            ),
+            (
+                "api_probe_variants",
+                (
+                    (
+                        ("actor", "child"),
+                        ("add_dir", True),
+                        ("extra_token", "EXTRA_7322"),
+                        ("label", "child-target"),
+                        ("main_token", "MAIN_7321"),
+                        ("operation", "child"),
+                        ("prompt", "CHILD_TARGET_7325"),
+                        ("settle_s", "2.0"),
+                        ("shape", "child-target"),
+                        ("unauthorized_token", "UNAUTH_7323"),
+                    ),
+                    (
+                        ("actor", "child"),
+                        ("add_dir", False),
+                        ("extra_token", "EXTRA_7322"),
+                        ("label", "child-empty-target"),
+                        ("main_token", "MAIN_7321"),
+                        ("operation", "child"),
+                        ("prompt", "CHILD_EMPTY_7326"),
+                        ("settle_s", "2.0"),
+                        ("shape", "child-empty-target"),
+                        ("unauthorized_token", "UNAUTH_7323"),
+                    ),
+                ),
+            ),
+        ),
+        "dependencies": (("child_add_dir_inheritance_control", "GATE"),),
+        "timeout": 30,
+        "role": "TARGET",
+    },
+    "memory_query_topk_residency_control": {
+        "commands": (),
+        "seed_files": (),
+        "config_keys": (),
+        "observed_files": (),
+        "profile": "STRUCTURED_FACTS",
+        "oracle_parameters": (("fact_key", "memory_query_topk_residency_control"),),
+        "execution_parameters": (
+            ("kind", "control"),
+            (
+                "clipboard_api_variants",
+                (
+                    (
+                        ("decoy", "DECOY_"),
+                        ("entries", 2000),
+                        ("label", "control"),
+                        ("markers", ("MEMORY_ALPHA_6402", "MEMORY_BETA_6403", "MEMORY_GAMMA_6404")),
+                        ("operation", "memory"),
+                        ("rss_probe_bytes", 16777216),
+                        (
+                            "stub",
+                            (
+                                ("mode", "seq_probe"),
+                                ("probe_tokens", ("MEMORY_TARGET_ROUTE_6406",)),
+                                (
+                                    "rounds",
+                                    (
+                                        (
+                                            (
+                                                (
+                                                    "args",
+                                                    (("limit", 3), ("query", "zirconium quasar heliotrope")),
+                                                ),
+                                                ("name", ("memory_search", "memory-search", "memorysearch")),
+                                            ),
+                                        ),
+                                        ((("name", "__finish__"),),),
+                                    ),
+                                ),
+                            ),
+                        ),
+                        ("target_prompt", "MEMORY_TARGET_ROUTE_6406"),
+                        ("warm_query", "warmup_only_6401"),
+                    ),
+                ),
+            ),
+        ),
+        "dependencies": (),
+        "timeout": 120,
+        "role": "CONTROL",
+    },
+    "memory_query_topk_residency": {
+        "commands": (),
+        "seed_files": (),
+        "config_keys": (),
+        "observed_files": (),
+        "profile": "STRUCTURED_FACTS",
+        "oracle_parameters": (("fact_key", "memory_query_topk_residency"),),
+        "execution_parameters": (
+            (
+                "clipboard_api_variants",
+                (
+                    (
+                        ("decoy", "DECOY_"),
+                        ("entries", 2000),
+                        ("label", "small"),
+                        ("markers", ("MEMORY_ALPHA_6402", "MEMORY_BETA_6403", "MEMORY_GAMMA_6404")),
+                        ("operation", "memory"),
+                        ("rss_probe_bytes", 16777216),
+                        (
+                            "stub",
+                            (
+                                ("mode", "seq_probe"),
+                                ("probe_tokens", ("MEMORY_TARGET_ROUTE_6406",)),
+                                (
+                                    "rounds",
+                                    (
+                                        (
+                                            (
+                                                (
+                                                    "args",
+                                                    (("limit", 3), ("query", "zirconium quasar heliotrope")),
+                                                ),
+                                                ("name", ("memory_search", "memory-search", "memorysearch")),
+                                            ),
+                                        ),
+                                        ((("name", "__finish__"),),),
+                                    ),
+                                ),
+                            ),
+                        ),
+                        ("target_prompt", "MEMORY_TARGET_ROUTE_6406"),
+                        ("warm_query", "warmup_only_6401"),
+                    ),
+                    (
+                        ("decoy", "DECOY_"),
+                        ("entries", 120000),
+                        ("label", "large"),
+                        ("markers", ("MEMORY_ALPHA_6402", "MEMORY_BETA_6403", "MEMORY_GAMMA_6404")),
+                        ("operation", "memory"),
+                        ("rss_probe_bytes", 16777216),
+                        (
+                            "stub",
+                            (
+                                ("mode", "seq_probe"),
+                                ("probe_tokens", ("MEMORY_TARGET_ROUTE_6406",)),
+                                (
+                                    "rounds",
+                                    (
+                                        (
+                                            (
+                                                (
+                                                    "args",
+                                                    (("limit", 3), ("query", "zirconium quasar heliotrope")),
+                                                ),
+                                                ("name", ("memory_search", "memory-search", "memorysearch")),
+                                            ),
+                                        ),
+                                        ((("name", "__finish__"),),),
+                                    ),
+                                ),
+                            ),
+                        ),
+                        ("target_prompt", "MEMORY_TARGET_ROUTE_6406"),
+                        ("warm_query", "warmup_only_6401"),
+                    ),
+                ),
+            ),
+        ),
+        "dependencies": (("memory_query_topk_residency_control", "GATE"),),
+        "timeout": 180,
+        "role": "TARGET",
+    },
+    "agent_api_close_retry_incomplete_control": {
+        "commands": (),
+        "seed_files": (),
+        "config_keys": (),
+        "observed_files": (),
+        "profile": "STRUCTURED_FACTS",
+        "oracle_parameters": (("fact_key", "agent_api_close_retry_incomplete_control"),),
+        "execution_parameters": (
+            ("kind", "control"),
+            (
+                "clipboard_api_variants",
+                (
+                    (
+                        ("heartbeat_file", "close_helper.heartbeat"),
+                        ("inject_fault", False),
+                        ("label", "control"),
+                        ("lease_file", "close_helper.lease"),
+                        ("operation", "close"),
+                        ("pid_file", "close_helper.pid"),
+                        ("prompt", "CLOSE_ROUTE_6501"),
+                        ("state_file", "close_helper.state"),
+                        (
+                            "stub",
+                            (
+                                ("mode", "seq_probe"),
+                                ("probe_tokens", ("CLOSE_ROUTE_6501",)),
+                                (
+                                    "rounds",
+                                    (
+                                        (
+                                            (
+                                                ("args", (("run_in_background", True),)),
+                                                ("command", "__CLOSE_COMMAND__"),
+                                                ("name", "bash"),
+                                            ),
+                                        ),
+                                        ((("name", "__finish__"),),),
+                                    ),
+                                ),
+                            ),
+                        ),
+                    ),
+                ),
+            ),
+        ),
+        "dependencies": (),
+        "timeout": 45,
+        "role": "CONTROL",
+    },
+    "agent_api_close_retry_incomplete": {
+        "commands": (),
+        "seed_files": (),
+        "config_keys": (),
+        "observed_files": (),
+        "profile": "STRUCTURED_FACTS",
+        "oracle_parameters": (("fact_key", "agent_api_close_retry_incomplete"),),
+        "execution_parameters": (
+            (
+                "clipboard_api_variants",
+                (
+                    (
+                        ("heartbeat_file", "close_helper.heartbeat"),
+                        ("inject_fault", True),
+                        ("label", "target"),
+                        ("lease_file", "close_helper.lease"),
+                        ("operation", "close"),
+                        ("pid_file", "close_helper.pid"),
+                        ("prompt", "CLOSE_ROUTE_6501"),
+                        ("state_file", "close_helper.state"),
+                        (
+                            "stub",
+                            (
+                                ("mode", "seq_probe"),
+                                ("probe_tokens", ("CLOSE_ROUTE_6501",)),
+                                (
+                                    "rounds",
+                                    (
+                                        (
+                                            (
+                                                ("args", (("run_in_background", True),)),
+                                                ("command", "__CLOSE_COMMAND__"),
+                                                ("name", "bash"),
+                                            ),
+                                        ),
+                                        ((("name", "__finish__"),),),
+                                    ),
+                                ),
+                            ),
+                        ),
+                    ),
+                ),
+            ),
+        ),
+        "dependencies": (("agent_api_close_retry_incomplete_control", "GATE"),),
+        "timeout": 45,
+        "role": "TARGET",
+    },
+    "copy_utf8_clipboard_control": {
+        "commands": (),
+        "seed_files": (),
+        "config_keys": (),
+        "observed_files": (),
+        "profile": "STRUCTURED_FACTS",
+        "oracle_parameters": (("fact_key", "copy_utf8_clipboard_control"),),
+        "execution_parameters": (
+            ("kind", "control"),
+            (
+                "clipboard_api_variants",
+                (
+                    (
+                        ("capture", "clipboard_capture.bin"),
+                        ("label", "control"),
+                        ("meta", "clipboard_meta.json"),
+                        ("operation", "copy"),
+                        ("prompt", "COPY_ROUTE_6601"),
+                        (
+                            "stub",
+                            (
+                                ("mode", "fixed_reply"),
+                                ("probe_tokens", ("COPY_ROUTE_6601",)),
+                                ("reply_content", "COPY_ASCII_6602 exact bytes"),
+                            ),
+                        ),
+                    ),
+                ),
+            ),
+        ),
+        "dependencies": (),
+        "timeout": 45,
+        "role": "CONTROL",
+    },
+    "copy_utf8_clipboard_bytes": {
+        "commands": (),
+        "seed_files": (),
+        "config_keys": (),
+        "observed_files": (),
+        "profile": "STRUCTURED_FACTS",
+        "oracle_parameters": (("fact_key", "copy_utf8_clipboard_bytes"),),
+        "execution_parameters": (
+            (
+                "clipboard_api_variants",
+                (
+                    (
+                        ("capture", "clipboard_capture.bin"),
+                        ("label", "target"),
+                        ("meta", "clipboard_meta.json"),
+                        ("operation", "copy"),
+                        ("prompt", "COPY_ROUTE_6601"),
+                        (
+                            "stub",
+                            (
+                                ("mode", "fixed_reply"),
+                                ("probe_tokens", ("COPY_ROUTE_6601",)),
+                                ("reply_content", "COPY_UTF8_6603 雪豹 café Δ"),
+                            ),
+                        ),
+                    ),
+                ),
+            ),
+        ),
+        "dependencies": (("copy_utf8_clipboard_control", "GATE"),),
+        "timeout": 45,
+        "role": "TARGET",
+    },
+    "custom_args_single_expansion_control": {
+        "commands": ("/mode yolo", "/argguard ARGS_SAFE_7103", "continue the controlled custom command"),
+        "seed_files": (
+            (
+                "commands/argguard.md",
+                "ARGS_CONTROL_FACE_7101 {{args}} @{args_control_source.txt} !{printf 'ARGS_CONTROL_EXEC_7105\\n' > args_control_exec.txt}\n",
+            ),
+            ("args_control_source.txt", "ARGS_CONTROL_FILE_7104\n"),
+        ),
+        "config_keys": (),
+        "observed_files": ("args_control_exec.txt",),
+        "profile": "CUSTOM_SINGLE_EXPANSION",
+        "oracle_parameters": (
+            ("face_token", "ARGS_CONTROL_FACE_7101"),
+            ("args_token", "ARGS_SAFE_7103"),
+            ("file_token", "ARGS_CONTROL_FILE_7104"),
+            ("path", "args_control_exec.txt"),
+        ),
+        "execution_parameters": (
+            ("kind", "control"),
+            (
+                "stub",
+                (("probe_tokens", ("ARGS_CONTROL_FACE_7101", "ARGS_SAFE_7103", "ARGS_CONTROL_FILE_7104")),),
+            ),
+        ),
+        "dependencies": (),
+        "timeout": 90,
+        "role": "CONTROL",
+    },
+    "custom_args_no_secondary_expansion": {
+        "commands": (
+            "/mode yolo",
+            "/argguard ARGS_SAFE_7103 @{args_secret.txt} !{printf 'ARGS_TARGET_EXEC_7107\\n' > args_target_exec.txt}",
+            "continue the guarded custom command",
+        ),
+        "seed_files": (
+            ("commands/argguard.md", "ARGS_TARGET_FACE_7102 {{args}}\n"),
+            ("args_secret.txt", "ARGS_SECRET_READ_7106\n"),
+        ),
+        "config_keys": (),
+        "observed_files": ("args_target_exec.txt",),
+        "profile": "CUSTOM_NO_SECONDARY",
+        "oracle_parameters": (
+            ("face_token", "ARGS_TARGET_FACE_7102"),
+            ("args_token", "ARGS_SAFE_7103"),
+            ("secret_token", "ARGS_SECRET_READ_7106"),
+            ("path", "args_target_exec.txt"),
+        ),
+        "execution_parameters": (
+            (
+                "stub",
+                (("probe_tokens", ("ARGS_TARGET_FACE_7102", "ARGS_SAFE_7103", "ARGS_SECRET_READ_7106")),),
+            ),
+        ),
+        "dependencies": (("custom_args_single_expansion_control", "GATE"),),
+        "timeout": 90,
+        "role": "TARGET",
+    },
+}
+_ROWS = {**_ROWS, **_PLUGIN_ROWS, **_CHILD_STATE_ROWS}
+
+
+def _home_seed_files(row: dict) -> tuple[tuple[str, str], ...]:
+    """Lift a row's ``home_seed`` declaration into the typed recipe field.
+
+    Rows carry these as an execution parameter; the fixture writes only the
+    recipe field, and the extension scenarios that turn on a user-level
+    definition need it on disk.  Reading the existing declaration keeps one
+    statement of the fixture rather than a second copy free to drift from it.
+    """
+    declared = dict(row["execution_parameters"]).get("home_seed", ())
+    return tuple(
+        (
+            (str(path), str(content))
+            for path, content in declared
+            if isinstance(path, str) and isinstance(content, str)
+        )
+    )
+
+
+SCENARIOS = tuple(
+    (
+        define_state_scenario(
+            test_id,
+            StateRecipe(
+                commands=row["commands"],
+                seed_files=row["seed_files"],
+                home_seed_files=_home_seed_files(row),
+                config_keys=row["config_keys"],
+                observed_files=row["observed_files"],
+                oracle_profile=StateOracleProfile[row["profile"]],
+                oracle_parameters=row["oracle_parameters"],
+                execution_parameters=row["execution_parameters"],
+                dependencies=tuple(
+                    ((test_id, DependencyKind[kind]) for test_id, kind in row["dependencies"])
+                ),
+                timeout_seconds=row["timeout"],
+            ),
+            ScenarioRole[row["role"]],
+        )
+        for test_id, row in _ROWS.items()
+    )
+)
+_BY_ID = {scenario.definition.scenario_id: scenario for scenario in SCENARIOS}
+
+
+def scenario_by_id(scenario_id: str):
+    try:
+        return _BY_ID[scenario_id]
+    except KeyError as error:
+        raise KeyError(f"unknown state child scenario: {scenario_id}") from error
+
+
+__all__ = ["SCENARIOS", "scenario_by_id"]
diff --git a/code/src/doc2harness/benchmark/harnesses/state/scenarios/__init__.py b/code/src/doc2harness/benchmark/harnesses/state/scenarios/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..f29a8d47e33091bafe56fc47f8a2bd2a40b52885
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/state/scenarios/__init__.py
@@ -0,0 +1 @@
+"""Thin definition owners for state-child scenarios."""
diff --git a/code/src/doc2harness/benchmark/harnesses/state/scenarios/agent_api_close_retry_incomplete.py b/code/src/doc2harness/benchmark/harnesses/state/scenarios/agent_api_close_retry_incomplete.py
new file mode 100644
index 0000000000000000000000000000000000000000..6d613f4d69eb6fb7de9c7f32f0c9289362c3836c
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/state/scenarios/agent_api_close_retry_incomplete.py
@@ -0,0 +1,82 @@
+"""Verify the structured close-retry evidence for the target route.
+
+1. Run the close operation through the session-close API variant fixture.
+2. Capture the scenario-specific structured-facts row.
+3. Require observed/support evidence and an all-true behavioral check vector.
+4. Return PASS only when the structured route is complete and cleanup is clean.
+"""
+
+from doc2harness.benchmark.harnesses.state.contracts import (
+    StateApplicability, StateEvaluation, StateObservation, StateOracleProfile,
+    StateOutcome, StateScenario, compile_state_steps,
+    evaluation_digest, structured_fact,
+)
+from doc2harness.benchmark.definition import DependencyKind
+from ..recipes import scenario_by_id
+
+SCENARIO_ID = "agent_api_close_retry_incomplete"
+_BASE_SCENARIO = scenario_by_id(SCENARIO_ID)
+_VARIANTS_KEY = "clipboard_api_variants"
+_EXEC = (
+        (_VARIANTS_KEY, ((
+        ("heartbeat_file", "close_helper.heartbeat"), ("inject_fault", True), ("label", "target"),
+        ("lease_file", "close_helper.lease"), ("operation", "close"), ("pid_file", "close_helper.pid"),
+        ("prompt", "CLOSE_ROUTE_6501"), ("state_file", "close_helper.state"),
+        ("stub", (
+            ("mode", "seq_probe"), ("probe_tokens", ("CLOSE_ROUTE_6501",)),
+            ("rounds", (
+                ((("args", (("run_in_background", True),)), ("command", "__CLOSE_COMMAND__"), ("name", "bash")),),
+                ((("name", "__finish__"),),),
+            )),
+        )),
+    ),)) ,
+)
+STEPS = (structured_fact("structured_facts"),)
+RECIPE = compile_state_steps(
+    STEPS, oracle_profile=StateOracleProfile.STRUCTURED_FACTS,
+    oracle_parameters=(("fact_key", SCENARIO_ID),), execution_parameters=_EXEC,
+    dependencies=(("agent_api_close_retry_incomplete_control", DependencyKind.GATE),),
+    timeout_seconds=45,
+)
+SCENARIO: StateScenario = StateScenario(_BASE_SCENARIO.definition, RECIPE)
+scenario = _BASE_SCENARIO
+definition = SCENARIO.definition
+
+
+def judge(observation: StateObservation) -> StateEvaluation:
+    """Apply the structured-facts close-retry contract using typed facts only."""
+    if observation.scenario_id != SCENARIO_ID:
+        raise ValueError("state observation belongs to another scenario")
+    facts = dict(observation.facts)
+    passed, conclusive, reason = False, True, "CHILD_RESULT_MISSING"
+    if not observation.fixture_verified:
+        conclusive, reason = False, "FIXTURE_UNVERIFIED"
+    elif facts.get("result_present") is not True:
+        reason = "CHILD_RESULT_MISSING"
+    else:
+        structured = facts.get("structured_facts")
+        structured = dict(structured) if type(structured) is tuple else {}
+        row = structured.get(SCENARIO_ID)
+        row = dict(row) if type(row) is tuple else {}
+        if row.get("observed") is not True or row.get("supported") is False:
+            conclusive, reason = False, "STRUCTURED_FACTS_UNOBSERVED"
+        else:
+            checks = row.get("checks")
+            checks = checks if type(checks) is tuple else ()
+            if not checks:
+                conclusive, reason = False, "STRUCTURED_CHECKS_MISSING"
+            elif not all(item is True for item in checks):
+                reason = "STRUCTURED_FACTS_FAILED"
+            else:
+                passed, reason = True, "STRUCTURED_FACTS_CHECKED"
+    if conclusive and (not observation.process_tree_clean or not observation.workspace_clean):
+        passed, reason = False, "EXECUTION_CLEANUP_FAILED"
+    return StateEvaluation(
+        SCENARIO_ID, StateOutcome.PASS if passed else StateOutcome.FAIL,
+        StateApplicability.APPLICABLE if conclusive else StateApplicability.INCONCLUSIVE,
+        reason, evaluation_digest(SCENARIO, observation),
+        SCENARIO.definition.weight_microunits if conclusive else 0,
+    )
+
+
+__all__ = ["RECIPE", "SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/state/scenarios/agent_api_close_retry_incomplete_control.py b/code/src/doc2harness/benchmark/harnesses/state/scenarios/agent_api_close_retry_incomplete_control.py
new file mode 100644
index 0000000000000000000000000000000000000000..9e326533e847337cc73961ec3e07dd1904702a00
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/state/scenarios/agent_api_close_retry_incomplete_control.py
@@ -0,0 +1,80 @@
+"""Verify the structured close-retry evidence for the control route.
+
+1. Run the close operation through the session-close API variant fixture.
+2. Capture the scenario-specific structured-facts row.
+3. Require observed/support evidence and an all-true behavioral check vector.
+4. Return PASS only when the structured route is complete and cleanup is clean.
+"""
+
+from doc2harness.benchmark.harnesses.state.contracts import (
+    StateApplicability, StateEvaluation, StateObservation, StateOracleProfile,
+    StateOutcome, StateScenario, compile_state_steps,
+    evaluation_digest, structured_fact,
+)
+from ..recipes import scenario_by_id
+
+SCENARIO_ID = "agent_api_close_retry_incomplete_control"
+_BASE_SCENARIO = scenario_by_id(SCENARIO_ID)
+_VARIANTS_KEY = "clipboard_api_variants"
+_EXEC = (
+        ("kind", "control"), (_VARIANTS_KEY, ((
+        ("heartbeat_file", "close_helper.heartbeat"), ("inject_fault", False), ("label", "control"),
+        ("lease_file", "close_helper.lease"), ("operation", "close"), ("pid_file", "close_helper.pid"),
+        ("prompt", "CLOSE_ROUTE_6501"), ("state_file", "close_helper.state"),
+        ("stub", (
+            ("mode", "seq_probe"), ("probe_tokens", ("CLOSE_ROUTE_6501",)),
+            ("rounds", (
+                ((("args", (("run_in_background", True),)), ("command", "__CLOSE_COMMAND__"), ("name", "bash")),),
+                ((("name", "__finish__"),),),
+            )),
+        )),
+    ),)) ,
+)
+STEPS = (structured_fact("structured_facts"),)
+RECIPE = compile_state_steps(
+    STEPS, oracle_profile=StateOracleProfile.STRUCTURED_FACTS,
+    oracle_parameters=(("fact_key", SCENARIO_ID),), execution_parameters=_EXEC,
+    timeout_seconds=45,
+)
+SCENARIO: StateScenario = StateScenario(_BASE_SCENARIO.definition, RECIPE)
+scenario = _BASE_SCENARIO
+definition = SCENARIO.definition
+
+
+def judge(observation: StateObservation) -> StateEvaluation:
+    """Apply the structured-facts close-retry contract using typed facts only."""
+    if observation.scenario_id != SCENARIO_ID:
+        raise ValueError("state observation belongs to another scenario")
+    facts = dict(observation.facts)
+    passed, conclusive, reason = False, True, "CHILD_RESULT_MISSING"
+    if not observation.fixture_verified:
+        conclusive, reason = False, "FIXTURE_UNVERIFIED"
+    elif facts.get("result_present") is not True:
+        reason = "CHILD_RESULT_MISSING"
+    else:
+        structured = facts.get("structured_facts")
+        structured = dict(structured) if type(structured) is tuple else {}
+        row = structured.get(SCENARIO_ID)
+        row = dict(row) if type(row) is tuple else {}
+        if row.get("observed") is not True or row.get("supported") is False:
+            conclusive, reason = False, "STRUCTURED_FACTS_UNOBSERVED"
+        else:
+            checks = row.get("checks")
+            checks = checks if type(checks) is tuple else ()
+            if not checks:
+                conclusive, reason = False, "STRUCTURED_CHECKS_MISSING"
+            elif not all(item is True for item in checks):
+                reason = "STRUCTURED_FACTS_FAILED"
+            else:
+                passed, reason = True, "STRUCTURED_FACTS_CHECKED"
+    if conclusive and (not observation.process_tree_clean or not observation.workspace_clean):
+        passed, reason = False, "EXECUTION_CLEANUP_FAILED"
+    return StateEvaluation(
+        SCENARIO_ID, StateOutcome.PASS if passed else StateOutcome.FAIL,
+        StateApplicability.APPLICABLE if conclusive else StateApplicability.INCONCLUSIVE,
+        reason, evaluation_digest(SCENARIO, observation),
+        SCENARIO.definition.weight_microunits if conclusive else 0,
+    )
+
+
+__all__ = ["RECIPE", "SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/state/scenarios/child_add_dir_inheritance.py b/code/src/doc2harness/benchmark/harnesses/state/scenarios/child_add_dir_inheritance.py
new file mode 100644
index 0000000000000000000000000000000000000000..f526843b3f72b0c9bd3b493f3b28804f8e9b91d4
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/state/scenarios/child_add_dir_inheritance.py
@@ -0,0 +1,117 @@
+"""Verify target child add-directory inheritance and its empty variant.
+
+1. Run target child-grant and child-empty API variants with controlled read probes.
+2. Capture the scenario-specific structured-facts row after the control gate.
+3. Require observed/support evidence and an all-true behavioral check vector.
+4. Return PASS only when inheritance boundaries are conclusive and cleanup is clean.
+"""
+
+from doc2harness.benchmark.definition import DependencyKind
+from doc2harness.benchmark.harnesses.state.contracts import (
+    StateApplicability,
+    StateEvaluation,
+    StateObservation,
+    StateOracleProfile,
+    StateOutcome,
+    StateScenario,
+    compile_state_steps,
+    evaluation_digest,
+    structured_fact,
+)
+
+from ..recipes import scenario_by_id
+
+SCENARIO_ID = "child_add_dir_inheritance"
+_BASE_SCENARIO = scenario_by_id(SCENARIO_ID)
+_VARIANTS_KEY = "api_probe_variants"
+_EXECUTION_PARAMETERS = (
+    (
+        "stub",
+        (
+            ("mode", "seq_probe"),
+            ("probe_tokens", ("CHILD_TARGET_7325", "CHILD_EMPTY_7326")),
+            (
+                "rounds",
+                (
+                    (
+                        (("args", (("file_path", "__REPO__/main.txt"),)), ("name", "read")),
+                        (("args", (("file_path", "__EXTRA__/extra.txt"),)), ("name", "read")),
+                        (("args", (("file_path", "__UNAUTHORIZED__/outside.txt"),)), ("name", "read")),
+                    ),
+                    ((("name", "__finish__"),),),
+                ),
+            ),
+        ),
+    ),
+    (
+        _VARIANTS_KEY,
+        (
+            (
+                ("actor", "child"), ("add_dir", True), ("extra_token", "EXTRA_7322"),
+                ("label", "child-target"), ("main_token", "MAIN_7321"),
+                ("operation", "child"), ("prompt", "CHILD_TARGET_7325"),
+                ("settle_s", "2.0"), ("shape", "child-target"),
+                ("unauthorized_token", "UNAUTH_7323"),
+            ),
+            (
+                ("actor", "child"), ("add_dir", False), ("extra_token", "EXTRA_7322"),
+                ("label", "child-empty-target"), ("main_token", "MAIN_7321"),
+                ("operation", "child"), ("prompt", "CHILD_EMPTY_7326"),
+                ("settle_s", "2.0"), ("shape", "child-empty-target"),
+                ("unauthorized_token", "UNAUTH_7323"),
+            ),
+        ),
+    ),
+)
+STEPS = (structured_fact("structured_facts"),)
+RECIPE = compile_state_steps(
+    STEPS,
+    oracle_profile=StateOracleProfile.STRUCTURED_FACTS,
+    oracle_parameters=(("fact_key", SCENARIO_ID),),
+    execution_parameters=_EXECUTION_PARAMETERS,
+    dependencies=(("child_add_dir_inheritance_control", DependencyKind.GATE),),
+    timeout_seconds=30,
+)
+SCENARIO: StateScenario = StateScenario(_BASE_SCENARIO.definition, RECIPE)
+scenario = _BASE_SCENARIO
+definition = SCENARIO.definition
+
+
+def judge(observation: StateObservation) -> StateEvaluation:
+    """Apply the structured child-inheritance target contract using typed facts only."""
+    if observation.scenario_id != SCENARIO_ID:
+        raise ValueError("state observation belongs to another scenario")
+    facts = dict(observation.facts)
+    passed, conclusive, reason = False, True, "CHILD_RESULT_MISSING"
+    if not observation.fixture_verified:
+        conclusive, reason = False, "FIXTURE_UNVERIFIED"
+    elif facts.get("result_present") is not True:
+        reason = "CHILD_RESULT_MISSING"
+    else:
+        structured = facts.get("structured_facts")
+        structured = dict(structured) if type(structured) is tuple else {}
+        row = structured.get(SCENARIO_ID)
+        row = dict(row) if type(row) is tuple else {}
+        if row.get("observed") is not True or row.get("supported") is False:
+            conclusive, reason = False, "STRUCTURED_FACTS_UNOBSERVED"
+        else:
+            checks = row.get("checks")
+            checks = checks if type(checks) is tuple else ()
+            if not checks:
+                conclusive, reason = False, "STRUCTURED_CHECKS_MISSING"
+            elif not all(item is True for item in checks):
+                reason = "STRUCTURED_FACTS_FAILED"
+            else:
+                passed, reason = True, "STRUCTURED_FACTS_CHECKED"
+    if conclusive and (not observation.process_tree_clean or not observation.workspace_clean):
+        passed, reason = False, "EXECUTION_CLEANUP_FAILED"
+    return StateEvaluation(
+        SCENARIO_ID,
+        StateOutcome.PASS if passed else StateOutcome.FAIL,
+        StateApplicability.APPLICABLE if conclusive else StateApplicability.INCONCLUSIVE,
+        reason,
+        evaluation_digest(SCENARIO, observation),
+        SCENARIO.definition.weight_microunits if conclusive else 0,
+    )
+
+__all__ = ["RECIPE", "SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/state/scenarios/child_add_dir_inheritance_control.py b/code/src/doc2harness/benchmark/harnesses/state/scenarios/child_add_dir_inheritance_control.py
new file mode 100644
index 0000000000000000000000000000000000000000..76e9db3c5f31a86052462323ba6c472f39fe7014
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/state/scenarios/child_add_dir_inheritance_control.py
@@ -0,0 +1,115 @@
+"""Verify the control route for child add-directory inheritance.
+
+1. Run parent-grant and child-empty API variants with controlled read probes.
+2. Capture the scenario-specific structured-facts row.
+3. Require observed/support evidence and an all-true behavioral check vector.
+4. Return PASS only when inheritance boundaries are conclusive and cleanup is clean.
+"""
+
+from doc2harness.benchmark.harnesses.state.contracts import (
+    StateApplicability,
+    StateEvaluation,
+    StateObservation,
+    StateOracleProfile,
+    StateOutcome,
+    StateScenario,
+    compile_state_steps,
+    evaluation_digest,
+    structured_fact,
+)
+
+from ..recipes import scenario_by_id
+
+SCENARIO_ID = "child_add_dir_inheritance_control"
+_BASE_SCENARIO = scenario_by_id(SCENARIO_ID)
+_VARIANTS_KEY = "api_probe_variants"
+_EXECUTION_PARAMETERS = (
+    ("kind", "control"),
+    (
+        "stub",
+        (
+            ("mode", "seq_probe"),
+            ("probe_tokens", ("CHILD_PARENT_7324", "CHILD_EMPTY_7326")),
+            (
+                "rounds",
+                (
+                    (
+                        (("args", (("file_path", "__REPO__/main.txt"),)), ("name", "read")),
+                        (("args", (("file_path", "__EXTRA__/extra.txt"),)), ("name", "read")),
+                        (("args", (("file_path", "__UNAUTHORIZED__/outside.txt"),)), ("name", "read")),
+                    ),
+                    ((("name", "__finish__"),),),
+                ),
+            ),
+        ),
+    ),
+    (
+        _VARIANTS_KEY,
+        (
+            (
+                ("actor", "parent"), ("add_dir", True), ("extra_token", "EXTRA_7322"),
+                ("label", "parent-grant"), ("main_token", "MAIN_7321"),
+                ("operation", "child"), ("prompt", "CHILD_PARENT_7324"),
+                ("shape", "parent-grant"), ("unauthorized_token", "UNAUTH_7323"),
+            ),
+            (
+                ("actor", "child"), ("add_dir", False), ("extra_token", "EXTRA_7322"),
+                ("label", "child-empty"), ("main_token", "MAIN_7321"),
+                ("operation", "child"), ("prompt", "CHILD_EMPTY_7326"),
+                ("settle_s", "2.0"), ("shape", "child-empty"),
+                ("unauthorized_token", "UNAUTH_7323"),
+            ),
+        ),
+    ),
+)
+STEPS = (structured_fact("structured_facts"),)
+RECIPE = compile_state_steps(
+    STEPS,
+    oracle_profile=StateOracleProfile.STRUCTURED_FACTS,
+    oracle_parameters=(("fact_key", SCENARIO_ID),),
+    execution_parameters=_EXECUTION_PARAMETERS,
+    timeout_seconds=30,
+)
+SCENARIO: StateScenario = StateScenario(_BASE_SCENARIO.definition, RECIPE)
+scenario = _BASE_SCENARIO
+definition = SCENARIO.definition
+
+
+def judge(observation: StateObservation) -> StateEvaluation:
+    """Apply the structured child-inheritance control contract using typed facts only."""
+    if observation.scenario_id != SCENARIO_ID:
+        raise ValueError("state observation belongs to another scenario")
+    facts = dict(observation.facts)
+    passed, conclusive, reason = False, True, "CHILD_RESULT_MISSING"
+    if not observation.fixture_verified:
+        conclusive, reason = False, "FIXTURE_UNVERIFIED"
+    elif facts.get("result_present") is not True:
+        reason = "CHILD_RESULT_MISSING"
+    else:
+        structured = facts.get("structured_facts")
+        structured = dict(structured) if type(structured) is tuple else {}
+        row = structured.get(SCENARIO_ID)
+        row = dict(row) if type(row) is tuple else {}
+        if row.get("observed") is not True or row.get("supported") is False:
+            conclusive, reason = False, "STRUCTURED_FACTS_UNOBSERVED"
+        else:
+            checks = row.get("checks")
+            checks = checks if type(checks) is tuple else ()
+            if not checks:
+                conclusive, reason = False, "STRUCTURED_CHECKS_MISSING"
+            elif not all(item is True for item in checks):
+                reason = "STRUCTURED_FACTS_FAILED"
+            else:
+                passed, reason = True, "STRUCTURED_FACTS_CHECKED"
+    if conclusive and (not observation.process_tree_clean or not observation.workspace_clean):
+        passed, reason = False, "EXECUTION_CLEANUP_FAILED"
+    return StateEvaluation(
+        SCENARIO_ID,
+        StateOutcome.PASS if passed else StateOutcome.FAIL,
+        StateApplicability.APPLICABLE if conclusive else StateApplicability.INCONCLUSIVE,
+        reason,
+        evaluation_digest(SCENARIO, observation),
+        SCENARIO.definition.weight_microunits if conclusive else 0,
+    )
+
+__all__ = ["RECIPE", "SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/state/scenarios/copy_utf8_clipboard_bytes.py b/code/src/doc2harness/benchmark/harnesses/state/scenarios/copy_utf8_clipboard_bytes.py
new file mode 100644
index 0000000000000000000000000000000000000000..6e34ed17fc8f37cf26a0b3b05b349fd14ef4522d
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/state/scenarios/copy_utf8_clipboard_bytes.py
@@ -0,0 +1,95 @@
+"""Verify that the target route preserves UTF-8 clipboard bytes.
+
+1. Run the UTF-8 copy operation through the target API variant after its control gate.
+2. Capture the scenario-specific structured-facts row.
+3. Require observed/support evidence and an all-true behavioral check vector.
+4. Return PASS only when the structured route is complete and cleanup is clean.
+"""
+
+from doc2harness.benchmark.definition import DependencyKind
+from doc2harness.benchmark.harnesses.state.contracts import (
+    StateApplicability,
+    StateEvaluation,
+    StateObservation,
+    StateOracleProfile,
+    StateOutcome,
+    StateScenario,
+    compile_state_steps,
+    evaluation_digest,
+    structured_fact,
+)
+
+from ..recipes import scenario_by_id
+
+SCENARIO_ID = "copy_utf8_clipboard_bytes"
+_BASE_SCENARIO = scenario_by_id(SCENARIO_ID)
+_VARIANTS_KEY = "clipboard_api_variants"
+_EXECUTION_PARAMETERS = (
+    (
+        _VARIANTS_KEY,
+        ((
+            ("capture", "clipboard_capture.bin"),
+            ("label", "target"),
+            ("meta", "clipboard_meta.json"),
+            ("operation", "copy"),
+            ("prompt", "COPY_ROUTE_6601"),
+            ("stub", (
+                ("mode", "fixed_reply"),
+                ("probe_tokens", ("COPY_ROUTE_6601",)),
+                ("reply_content", "COPY_UTF8_6603 雪豹 café Δ"),
+            )),
+        ),),
+    ),
+)
+STEPS = (structured_fact("structured_facts"),)
+RECIPE = compile_state_steps(
+    STEPS,
+    oracle_profile=StateOracleProfile.STRUCTURED_FACTS,
+    oracle_parameters=(("fact_key", SCENARIO_ID),),
+    execution_parameters=_EXECUTION_PARAMETERS,
+    dependencies=(("copy_utf8_clipboard_control", DependencyKind.GATE),),
+    timeout_seconds=45,
+)
+SCENARIO: StateScenario = StateScenario(_BASE_SCENARIO.definition, RECIPE)
+scenario = _BASE_SCENARIO
+definition = SCENARIO.definition
+
+
+def judge(observation: StateObservation) -> StateEvaluation:
+    """Apply the structured UTF-8 clipboard contract using typed facts only."""
+    if observation.scenario_id != SCENARIO_ID:
+        raise ValueError("state observation belongs to another scenario")
+    facts = dict(observation.facts)
+    passed, conclusive, reason = False, True, "CHILD_RESULT_MISSING"
+    if not observation.fixture_verified:
+        conclusive, reason = False, "FIXTURE_UNVERIFIED"
+    elif facts.get("result_present") is not True:
+        reason = "CHILD_RESULT_MISSING"
+    else:
+        structured = facts.get("structured_facts")
+        structured = dict(structured) if type(structured) is tuple else {}
+        row = structured.get(SCENARIO_ID)
+        row = dict(row) if type(row) is tuple else {}
+        if row.get("observed") is not True or row.get("supported") is False:
+            conclusive, reason = False, "STRUCTURED_FACTS_UNOBSERVED"
+        else:
+            checks = row.get("checks")
+            checks = checks if type(checks) is tuple else ()
+            if not checks:
+                conclusive, reason = False, "STRUCTURED_CHECKS_MISSING"
+            elif not all(item is True for item in checks):
+                reason = "STRUCTURED_FACTS_FAILED"
+            else:
+                passed, reason = True, "STRUCTURED_FACTS_CHECKED"
+    if conclusive and (not observation.process_tree_clean or not observation.workspace_clean):
+        passed, reason = False, "EXECUTION_CLEANUP_FAILED"
+    return StateEvaluation(
+        SCENARIO_ID,
+        StateOutcome.PASS if passed else StateOutcome.FAIL,
+        StateApplicability.APPLICABLE if conclusive else StateApplicability.INCONCLUSIVE,
+        reason,
+        evaluation_digest(SCENARIO, observation),
+        SCENARIO.definition.weight_microunits if conclusive else 0,
+    )
+
+__all__ = ["RECIPE", "SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/state/scenarios/copy_utf8_clipboard_control.py b/code/src/doc2harness/benchmark/harnesses/state/scenarios/copy_utf8_clipboard_control.py
new file mode 100644
index 0000000000000000000000000000000000000000..b0a9f38af40d3f52ce8f765fff5aaa59ce5ea199
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/state/scenarios/copy_utf8_clipboard_control.py
@@ -0,0 +1,94 @@
+"""Verify the control route for UTF-8 clipboard copying.
+
+1. Run the fixed-reply copy operation through the control API variant.
+2. Capture the scenario-specific structured-facts row.
+3. Require observed/support evidence and an all-true behavioral check vector.
+4. Return PASS only when the structured route is complete and cleanup is clean.
+"""
+
+from doc2harness.benchmark.harnesses.state.contracts import (
+    StateApplicability,
+    StateEvaluation,
+    StateObservation,
+    StateOracleProfile,
+    StateOutcome,
+    StateScenario,
+    compile_state_steps,
+    evaluation_digest,
+    structured_fact,
+)
+
+from ..recipes import scenario_by_id
+
+SCENARIO_ID = "copy_utf8_clipboard_control"
+_BASE_SCENARIO = scenario_by_id(SCENARIO_ID)
+_VARIANTS_KEY = "clipboard_api_variants"
+_EXECUTION_PARAMETERS = (
+    ("kind", "control"),
+    (
+        _VARIANTS_KEY,
+        ((
+            ("capture", "clipboard_capture.bin"),
+            ("label", "control"),
+            ("meta", "clipboard_meta.json"),
+            ("operation", "copy"),
+            ("prompt", "COPY_ROUTE_6601"),
+            ("stub", (
+                ("mode", "fixed_reply"),
+                ("probe_tokens", ("COPY_ROUTE_6601",)),
+                ("reply_content", "COPY_ASCII_6602 exact bytes"),
+            )),
+        ),),
+    ),
+)
+STEPS = (structured_fact("structured_facts"),)
+RECIPE = compile_state_steps(
+    STEPS,
+    oracle_profile=StateOracleProfile.STRUCTURED_FACTS,
+    oracle_parameters=(("fact_key", SCENARIO_ID),),
+    execution_parameters=_EXECUTION_PARAMETERS,
+    timeout_seconds=45,
+)
+SCENARIO: StateScenario = StateScenario(_BASE_SCENARIO.definition, RECIPE)
+scenario = _BASE_SCENARIO
+definition = SCENARIO.definition
+
+
+def judge(observation: StateObservation) -> StateEvaluation:
+    """Apply the structured clipboard control contract using typed facts only."""
+    if observation.scenario_id != SCENARIO_ID:
+        raise ValueError("state observation belongs to another scenario")
+    facts = dict(observation.facts)
+    passed, conclusive, reason = False, True, "CHILD_RESULT_MISSING"
+    if not observation.fixture_verified:
+        conclusive, reason = False, "FIXTURE_UNVERIFIED"
+    elif facts.get("result_present") is not True:
+        reason = "CHILD_RESULT_MISSING"
+    else:
+        structured = facts.get("structured_facts")
+        structured = dict(structured) if type(structured) is tuple else {}
+        row = structured.get(SCENARIO_ID)
+        row = dict(row) if type(row) is tuple else {}
+        if row.get("observed") is not True or row.get("supported") is False:
+            conclusive, reason = False, "STRUCTURED_FACTS_UNOBSERVED"
+        else:
+            checks = row.get("checks")
+            checks = checks if type(checks) is tuple else ()
+            if not checks:
+                conclusive, reason = False, "STRUCTURED_CHECKS_MISSING"
+            elif not all(item is True for item in checks):
+                reason = "STRUCTURED_FACTS_FAILED"
+            else:
+                passed, reason = True, "STRUCTURED_FACTS_CHECKED"
+    if conclusive and (not observation.process_tree_clean or not observation.workspace_clean):
+        passed, reason = False, "EXECUTION_CLEANUP_FAILED"
+    return StateEvaluation(
+        SCENARIO_ID,
+        StateOutcome.PASS if passed else StateOutcome.FAIL,
+        StateApplicability.APPLICABLE if conclusive else StateApplicability.INCONCLUSIVE,
+        reason,
+        evaluation_digest(SCENARIO, observation),
+        SCENARIO.definition.weight_microunits if conclusive else 0,
+    )
+
+__all__ = ["RECIPE", "SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/state/scenarios/custom_args_no_secondary_expansion.py b/code/src/doc2harness/benchmark/harnesses/state/scenarios/custom_args_no_secondary_expansion.py
new file mode 100644
index 0000000000000000000000000000000000000000..eb36a433aae0f0b5a8e0807a8f5d60fd48b2e7e9
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/state/scenarios/custom_args_no_secondary_expansion.py
@@ -0,0 +1,125 @@
+"""Verify that a custom command does not perform secondary expansion.
+
+1. Restore the central guarded-command and secret fixtures.
+2. Execute the command sequence with its guarded argument payload.
+3. Observe request probes and the protected execution file.
+4. Pass only when the face and argument are seen without secret leakage or execution.
+"""
+
+from doc2harness.benchmark.harnesses.state.contracts import (
+    StateApplicability,
+    StateEvaluation,
+    StateObservation,
+    StateOracleProfile,
+    StateOutcome,
+    StateScenario,
+    command,
+    compile_state_steps,
+    evaluation_digest,
+    observe_file,
+    observe_requests,
+    seed_file,
+)
+
+from ..recipes import scenario_by_id
+
+SCENARIO_ID = "custom_args_no_secondary_expansion"
+_BASE_SCENARIO = scenario_by_id(SCENARIO_ID)
+_SEED_STEPS = tuple(
+    seed_file(path, content) for path, content in _BASE_SCENARIO.recipe.seed_files
+)
+_COMMAND_STEPS = tuple(command(value) for value in _BASE_SCENARIO.recipe.commands)
+STEPS = (
+    *_SEED_STEPS,
+    *_COMMAND_STEPS,
+    observe_file(_BASE_SCENARIO.recipe.observed_files[0]),
+    observe_requests(),
+)
+RECIPE = compile_state_steps(
+    STEPS,
+    oracle_profile=StateOracleProfile.CUSTOM_NO_SECONDARY,
+    oracle_parameters=_BASE_SCENARIO.recipe.oracle_parameters,
+    execution_parameters=_BASE_SCENARIO.recipe.execution_parameters,
+    dependencies=_BASE_SCENARIO.recipe.dependencies,
+    timeout_seconds=_BASE_SCENARIO.recipe.timeout_seconds,
+)
+SCENARIO: StateScenario = StateScenario(_BASE_SCENARIO.definition, RECIPE)
+scenario = _BASE_SCENARIO
+definition = SCENARIO.definition
+
+
+def _mapping(value: object) -> dict[str, object]:
+    if type(value) is tuple and all(
+        type(item) is tuple and len(item) == 2 and type(item[0]) is str
+        for item in value
+    ):
+        return dict(value)
+    return {}
+
+
+def _requests(value: object) -> tuple[dict[str, object], ...]:
+    return (
+        tuple(_mapping(item) for item in value if type(item) is tuple)
+        if type(value) is tuple
+        else ()
+    )
+
+
+def _probe(request: dict[str, object], token: str) -> bool:
+    return _mapping(request.get("probes")).get(token) is True
+
+
+def _texts(value: object) -> tuple[str, ...]:
+    return (
+        tuple(item for item in value if type(item) is str)
+        if type(value) is tuple
+        else ()
+    )
+
+
+def judge(observation: StateObservation) -> StateEvaluation:
+    """Apply the CUSTOM_NO_SECONDARY contract using typed facts."""
+    if observation.scenario_id != SCENARIO_ID:
+        raise ValueError("state observation belongs to another scenario")
+    facts = _mapping(observation.facts)
+    params = _mapping(RECIPE.oracle_parameters)
+    requests = _requests(facts.get("requests"))
+    blob = (
+        " || ".join(_texts(facts.get("returns")))
+        + " || "
+        + (facts.get("console") if type(facts.get("console")) is str else "")
+    )
+
+    def observed(token: object) -> bool:
+        value = token if type(token) is str else ""
+        return any(_probe(request, value) for request in requests) or value in blob
+
+    if not observed(params.get("face_token")) or not observed(params.get("args_token")):
+        passed, conclusive, reason = False, False, "CUSTOM_ARGUMENTS_UNOBSERVED"
+    else:
+        files = _mapping(facts.get("files"))
+        secret = (
+            params.get("secret_token")
+            if type(params.get("secret_token")) is str
+            else ""
+        )
+        path = params.get("path")
+        passed = not observed(secret) and files.get(path) is None
+        conclusive, reason = True, "CUSTOM_SECONDARY_BOUNDARY_CHECKED"
+    if conclusive and (
+        not observation.process_tree_clean or not observation.workspace_clean
+    ):
+        passed, reason = False, "EXECUTION_CLEANUP_FAILED"
+    return StateEvaluation(
+        SCENARIO_ID,
+        StateOutcome.PASS if passed else StateOutcome.FAIL,
+        StateApplicability.APPLICABLE
+        if conclusive
+        else StateApplicability.INCONCLUSIVE,
+        reason,
+        evaluation_digest(SCENARIO, observation),
+        SCENARIO.definition.weight_microunits if conclusive else 0,
+    )
+
+
+__all__ = ["RECIPE", "SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/state/scenarios/custom_args_single_expansion_control.py b/code/src/doc2harness/benchmark/harnesses/state/scenarios/custom_args_single_expansion_control.py
new file mode 100644
index 0000000000000000000000000000000000000000..c25e32ff05278a315b20e3524f2f2a49b90d9d68
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/state/scenarios/custom_args_single_expansion_control.py
@@ -0,0 +1,127 @@
+"""Verify the control path expands custom-command arguments exactly once.
+
+1. Restore the central command and fixture definitions.
+2. Execute the controlled command sequence and observe the request wire.
+3. Check the face, argument, file, and non-empty output evidence.
+4. Pass only when all expansion facts are observable and cleanup is clean.
+"""
+
+from doc2harness.benchmark.harnesses.state.contracts import (
+    StateApplicability,
+    StateEvaluation,
+    StateObservation,
+    StateOracleProfile,
+    StateOutcome,
+    StateScenario,
+    command,
+    compile_state_steps,
+    evaluation_digest,
+    observe_file,
+    observe_requests,
+    seed_file,
+)
+
+from ..recipes import scenario_by_id
+
+SCENARIO_ID = "custom_args_single_expansion_control"
+_BASE_SCENARIO = scenario_by_id(SCENARIO_ID)
+_SEED_STEPS = tuple(
+    seed_file(path, content) for path, content in _BASE_SCENARIO.recipe.seed_files
+)
+_COMMAND_STEPS = tuple(command(value) for value in _BASE_SCENARIO.recipe.commands)
+STEPS = (
+    *_SEED_STEPS,
+    *_COMMAND_STEPS,
+    observe_file(_BASE_SCENARIO.recipe.observed_files[0]),
+    observe_requests(),
+)
+RECIPE = compile_state_steps(
+    STEPS,
+    oracle_profile=StateOracleProfile.CUSTOM_SINGLE_EXPANSION,
+    oracle_parameters=_BASE_SCENARIO.recipe.oracle_parameters,
+    execution_parameters=_BASE_SCENARIO.recipe.execution_parameters,
+    dependencies=_BASE_SCENARIO.recipe.dependencies,
+    timeout_seconds=_BASE_SCENARIO.recipe.timeout_seconds,
+)
+SCENARIO: StateScenario = StateScenario(_BASE_SCENARIO.definition, RECIPE)
+scenario = _BASE_SCENARIO
+definition = SCENARIO.definition
+
+
+def _mapping(value: object) -> dict[str, object]:
+    if type(value) is tuple and all(
+        type(item) is tuple and len(item) == 2 and type(item[0]) is str
+        for item in value
+    ):
+        return dict(value)
+    return {}
+
+
+def _requests(value: object) -> tuple[dict[str, object], ...]:
+    return (
+        tuple(_mapping(item) for item in value if type(item) is tuple)
+        if type(value) is tuple
+        else ()
+    )
+
+
+def _probe(request: dict[str, object], token: str) -> bool:
+    return _mapping(request.get("probes")).get(token) is True
+
+
+def _texts(value: object) -> tuple[str, ...]:
+    return (
+        tuple(item for item in value if type(item) is str)
+        if type(value) is tuple
+        else ()
+    )
+
+
+def judge(observation: StateObservation) -> StateEvaluation:
+    """Apply the CUSTOM_SINGLE_EXPANSION contract using typed facts."""
+    if observation.scenario_id != SCENARIO_ID:
+        raise ValueError("state observation belongs to another scenario")
+    facts = _mapping(observation.facts)
+    params = _mapping(RECIPE.oracle_parameters)
+    requests = _requests(facts.get("requests"))
+    blob = (
+        " || ".join(_texts(facts.get("returns")))
+        + " || "
+        + (facts.get("console") if type(facts.get("console")) is str else "")
+    )
+
+    def observed(token: object) -> bool:
+        value = token if type(token) is str else ""
+        return any(_probe(request, value) for request in requests) or value in blob
+
+    face = params.get("face_token")
+    if not observed(face):
+        passed, conclusive, reason = False, False, "CUSTOM_COMMAND_UNOBSERVED"
+    else:
+        files = _mapping(facts.get("files"))
+        path = params.get("path")
+        content = files.get(path)
+        passed = (
+            observed(params.get("args_token"))
+            and observed(params.get("file_token"))
+            and type(content) is str
+            and bool(content.strip())
+        )
+        conclusive, reason = True, "CUSTOM_SINGLE_EXPANSION_CHECKED"
+    if conclusive and (
+        not observation.process_tree_clean or not observation.workspace_clean
+    ):
+        passed, reason = False, "EXECUTION_CLEANUP_FAILED"
+    return StateEvaluation(
+        SCENARIO_ID,
+        StateOutcome.PASS if passed else StateOutcome.FAIL,
+        StateApplicability.APPLICABLE
+        if conclusive
+        else StateApplicability.INCONCLUSIVE,
+        reason,
+        evaluation_digest(SCENARIO, observation),
+        SCENARIO.definition.weight_microunits if conclusive else 0,
+    )
+
+
+__all__ = ["RECIPE", "SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/state/scenarios/memory_query_topk_residency.py b/code/src/doc2harness/benchmark/harnesses/state/scenarios/memory_query_topk_residency.py
new file mode 100644
index 0000000000000000000000000000000000000000..41f692faff8cc22c7a51a3422c6b0d7a44754ee4
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/state/scenarios/memory_query_topk_residency.py
@@ -0,0 +1,80 @@
+"""Verify that memory top-k residency stays bounded from small to large fixtures.
+
+1. Run the small and large memory fixtures with the same bounded top-k query.
+2. Capture the scenario-specific structured-facts row after the control gate.
+3. Require observed/support evidence and an all-true residency check vector.
+4. Return PASS only when both sizes remain bounded and cleanup is clean.
+"""
+
+from doc2harness.benchmark.definition import DependencyKind
+from doc2harness.benchmark.harnesses.state.contracts import (
+    StateApplicability,
+    StateEvaluation,
+    StateObservation,
+    StateOracleProfile,
+    StateOutcome,
+    StateScenario,
+    compile_state_steps,
+    evaluation_digest,
+    structured_fact,
+)
+
+from ..recipes import scenario_by_id
+
+SCENARIO_ID = "memory_query_topk_residency"
+_BASE_SCENARIO = scenario_by_id(SCENARIO_ID)
+_VARIANTS_KEY = "clipboard_api_variants"
+_ROUNDS = (
+    ((("args", (("limit", 3), ("query", "zirconium quasar heliotrope"))), ("name", ("memory_search", "memory-search", "memorysearch"))),),
+    ((("name", "__finish__"),),),
+)
+_EXECUTION_PARAMETERS = (
+    (_VARIANTS_KEY, (
+        (("decoy", "DECOY_"), ("entries", 2000), ("label", "small"), ("markers", ("MEMORY_ALPHA_6402", "MEMORY_BETA_6403", "MEMORY_GAMMA_6404")), ("operation", "memory"), ("rss_probe_bytes", 16777216), ("stub", (("mode", "seq_probe"), ("probe_tokens", ("MEMORY_TARGET_ROUTE_6406",)), ("rounds", _ROUNDS))), ("target_prompt", "MEMORY_TARGET_ROUTE_6406"), ("warm_query", "warmup_only_6401")),
+        (("decoy", "DECOY_"), ("entries", 120000), ("label", "large"), ("markers", ("MEMORY_ALPHA_6402", "MEMORY_BETA_6403", "MEMORY_GAMMA_6404")), ("operation", "memory"), ("rss_probe_bytes", 16777216), ("stub", (("mode", "seq_probe"), ("probe_tokens", ("MEMORY_TARGET_ROUTE_6406",)), ("rounds", _ROUNDS))), ("target_prompt", "MEMORY_TARGET_ROUTE_6406"), ("warm_query", "warmup_only_6401")),
+    )),
+)
+STEPS = (structured_fact("structured_facts"),)
+RECIPE = compile_state_steps(
+    STEPS,
+    oracle_profile=StateOracleProfile.STRUCTURED_FACTS,
+    oracle_parameters=(("fact_key", SCENARIO_ID),),
+    execution_parameters=_EXECUTION_PARAMETERS,
+    dependencies=(("memory_query_topk_residency_control", DependencyKind.GATE),),
+    timeout_seconds=180,
+)
+SCENARIO: StateScenario = StateScenario(_BASE_SCENARIO.definition, RECIPE)
+scenario = _BASE_SCENARIO
+definition = SCENARIO.definition
+
+
+def judge(observation: StateObservation) -> StateEvaluation:
+    """Apply the structured memory-residency target contract using typed facts only."""
+    if observation.scenario_id != SCENARIO_ID:
+        raise ValueError("state observation belongs to another scenario")
+    facts = dict(observation.facts)
+    passed, conclusive, reason = False, True, "CHILD_RESULT_MISSING"
+    if not observation.fixture_verified:
+        conclusive, reason = False, "FIXTURE_UNVERIFIED"
+    else:
+        structured = facts.get("structured_facts")
+        structured = dict(structured) if type(structured) is tuple else {}
+        row = structured.get(SCENARIO_ID)
+        row = dict(row) if type(row) is tuple else {}
+        if row.get("observed") is not True or row.get("supported") is False:
+            conclusive, reason = False, "STRUCTURED_FACTS_UNOBSERVED"
+        else:
+            checks = row.get("checks")
+            checks = checks if type(checks) is tuple else ()
+            if not checks:
+                conclusive, reason = False, "STRUCTURED_CHECKS_MISSING"
+            elif not all(item is True for item in checks):
+                reason = "STRUCTURED_FACTS_FAILED"
+            else:
+                passed, reason = True, "STRUCTURED_FACTS_CHECKED"
+    if conclusive and (not observation.process_tree_clean or not observation.workspace_clean):
+        passed, reason = False, "EXECUTION_CLEANUP_FAILED"
+    return StateEvaluation(SCENARIO_ID, StateOutcome.PASS if passed else StateOutcome.FAIL, StateApplicability.APPLICABLE if conclusive else StateApplicability.INCONCLUSIVE, reason, evaluation_digest(SCENARIO, observation), SCENARIO.definition.weight_microunits if conclusive else 0)
+
+
+__all__ = ["RECIPE", "SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/state/scenarios/memory_query_topk_residency_control.py b/code/src/doc2harness/benchmark/harnesses/state/scenarios/memory_query_topk_residency_control.py
new file mode 100644
index 0000000000000000000000000000000000000000..ec83751b5972eb495551f8c488aef069e05f1bcb
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/state/scenarios/memory_query_topk_residency_control.py
@@ -0,0 +1,91 @@
+"""Verify the control route for a bounded memory top-k query.
+
+1. Run the small control memory fixture with a bounded top-k query.
+2. Capture the scenario-specific structured-facts row.
+3. Require observed/support evidence and an all-true residency check vector.
+4. Return PASS only when the control query is complete and cleanup is clean.
+"""
+
+from doc2harness.benchmark.harnesses.state.contracts import (
+    StateApplicability,
+    StateEvaluation,
+    StateObservation,
+    StateOracleProfile,
+    StateOutcome,
+    StateScenario,
+    compile_state_steps,
+    evaluation_digest,
+    structured_fact,
+)
+
+from ..recipes import scenario_by_id
+
+SCENARIO_ID = "memory_query_topk_residency_control"
+_BASE_SCENARIO = scenario_by_id(SCENARIO_ID)
+_VARIANTS_KEY = "clipboard_api_variants"
+_EXECUTION_PARAMETERS = (
+    ("kind", "control"),
+    (_VARIANTS_KEY, ((
+        ("decoy", "DECOY_"),
+        ("entries", 2000),
+        ("label", "control"),
+        ("markers", ("MEMORY_ALPHA_6402", "MEMORY_BETA_6403", "MEMORY_GAMMA_6404")),
+        ("operation", "memory"),
+        ("rss_probe_bytes", 16777216),
+        ("stub", (("mode", "seq_probe"), ("probe_tokens", ("MEMORY_TARGET_ROUTE_6406",)), ("rounds", (
+            ((("args", (("limit", 3), ("query", "zirconium quasar heliotrope"))), ("name", ("memory_search", "memory-search", "memorysearch"))),),
+            ((("name", "__finish__"),),),
+        )))),
+        ("target_prompt", "MEMORY_TARGET_ROUTE_6406"),
+        ("warm_query", "warmup_only_6401"),
+    ),),),
+)
+STEPS = (structured_fact("structured_facts"),)
+RECIPE = compile_state_steps(
+    STEPS,
+    oracle_profile=StateOracleProfile.STRUCTURED_FACTS,
+    oracle_parameters=(("fact_key", SCENARIO_ID),),
+    execution_parameters=_EXECUTION_PARAMETERS,
+    timeout_seconds=120,
+)
+SCENARIO: StateScenario = StateScenario(_BASE_SCENARIO.definition, RECIPE)
+scenario = _BASE_SCENARIO
+definition = SCENARIO.definition
+
+
+def judge(observation: StateObservation) -> StateEvaluation:
+    """Apply the structured memory-residency control contract using typed facts only."""
+    if observation.scenario_id != SCENARIO_ID:
+        raise ValueError("state observation belongs to another scenario")
+    facts = dict(observation.facts)
+    passed, conclusive, reason = False, True, "CHILD_RESULT_MISSING"
+    if not observation.fixture_verified:
+        conclusive, reason = False, "FIXTURE_UNVERIFIED"
+    else:
+        structured = facts.get("structured_facts")
+        structured = dict(structured) if type(structured) is tuple else {}
+        row = structured.get(SCENARIO_ID)
+        row = dict(row) if type(row) is tuple else {}
+        if row.get("observed") is not True or row.get("supported") is False:
+            conclusive, reason = False, "STRUCTURED_FACTS_UNOBSERVED"
+        else:
+            checks = row.get("checks")
+            checks = checks if type(checks) is tuple else ()
+            if not checks:
+                conclusive, reason = False, "STRUCTURED_CHECKS_MISSING"
+            elif not all(item is True for item in checks):
+                reason = "STRUCTURED_FACTS_FAILED"
+            else:
+                public_calls = row.get("public_calls")
+                if type(public_calls) is not bool:
+                    conclusive, reason = False, "STRUCTURED_PUBLIC_CALLS_UNOBSERVED"
+                elif public_calls is not True:
+                    reason = "STRUCTURED_PUBLIC_CALLS_FAILED"
+                else:
+                    passed, reason = True, "STRUCTURED_FACTS_CHECKED"
+    if conclusive and (not observation.process_tree_clean or not observation.workspace_clean):
+        passed, reason = False, "EXECUTION_CLEANUP_FAILED"
+    return StateEvaluation(SCENARIO_ID, StateOutcome.PASS if passed else StateOutcome.FAIL, StateApplicability.APPLICABLE if conclusive else StateApplicability.INCONCLUSIVE, reason, evaluation_digest(SCENARIO, observation), SCENARIO.definition.weight_microunits if conclusive else 0)
+
+
+__all__ = ["RECIPE", "SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/state/scenarios/p30_ctl_security_review_sees_worktree_change.py b/code/src/doc2harness/benchmark/harnesses/state/scenarios/p30_ctl_security_review_sees_worktree_change.py
new file mode 100644
index 0000000000000000000000000000000000000000..72886c59997ebaf25298810309ed9becffc4dde3
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/state/scenarios/p30_ctl_security_review_sees_worktree_change.py
@@ -0,0 +1,93 @@
+"""Verify that the security-review control route sees a worktree change.
+
+1. Seed the scenario-specific fixture files and invoke the command sequence.
+2. Capture the model request facts after the scenario's execution gates.
+3. Check whether the expected token appears in a request probe.
+4. Return PASS only when the request is observed and cleanup is clean.
+"""
+
+from doc2harness.benchmark.harnesses.state.contracts import (
+    StateApplicability,
+    StateEvaluation,
+    StateObservation,
+    StateOracleProfile,
+    StateOutcome,
+    StateScenario,
+    command,
+    compile_state_steps,
+    evaluation_digest,
+    observe_requests,
+    seed_file,
+)
+
+from ..recipes import scenario_by_id
+
+SCENARIO_ID = "p30_ctl_security_review_sees_worktree_change"
+_BASE_SCENARIO = scenario_by_id(SCENARIO_ID)
+STEPS = (
+    seed_file("vuln_9601.py", "import os\n"),
+    command("/security-review"),
+    observe_requests(),
+)
+RECIPE = compile_state_steps(
+    STEPS,
+    oracle_profile=StateOracleProfile.REQUEST_TOKEN_PRESENT,
+    oracle_parameters=_BASE_SCENARIO.recipe.oracle_parameters,
+    execution_parameters=_BASE_SCENARIO.recipe.execution_parameters,
+    dependencies=_BASE_SCENARIO.recipe.dependencies,
+    timeout_seconds=_BASE_SCENARIO.recipe.timeout_seconds,
+)
+SCENARIO: StateScenario = StateScenario(_BASE_SCENARIO.definition, RECIPE)
+scenario = _BASE_SCENARIO
+definition = SCENARIO.definition
+
+
+def _mapping(value: object) -> dict[str, object]:
+    if type(value) is tuple and all(
+        type(item) is tuple and len(item) == 2 and type(item[0]) is str
+        for item in value
+    ):
+        return dict(value)
+    return {}
+
+
+def _requests(value: object) -> tuple[dict[str, object], ...]:
+    if type(value) is not tuple:
+        return ()
+    return tuple(_mapping(item) for item in value if type(item) is tuple)
+
+
+def _probe(request: dict[str, object], token: str) -> bool:
+    return _mapping(request.get("probes")).get(token) is True
+
+
+def judge(observation: StateObservation) -> StateEvaluation:
+    """Apply the REQUEST_TOKEN_PRESENT contract using typed request facts."""
+    if observation.scenario_id != SCENARIO_ID:
+        raise ValueError("state observation belongs to another scenario")
+    facts = _mapping(observation.facts)
+    requests = _requests(facts.get("requests"))
+    params = _mapping(RECIPE.oracle_parameters)
+    token = params.get("token") if type(params.get("token")) is str else ""
+    passed, conclusive, reason = False, True, "REQUEST_TOKEN_CHECKED"
+    if not requests:
+        conclusive, reason = False, "MODEL_TURN_UNOBSERVED"
+    else:
+        passed = any(_probe(request, token) for request in requests)
+    if conclusive and (
+        not observation.process_tree_clean or not observation.workspace_clean
+    ):
+        passed, reason = False, "EXECUTION_CLEANUP_FAILED"
+    return StateEvaluation(
+        SCENARIO_ID,
+        StateOutcome.PASS if passed else StateOutcome.FAIL,
+        StateApplicability.APPLICABLE
+        if conclusive
+        else StateApplicability.INCONCLUSIVE,
+        reason,
+        evaluation_digest(SCENARIO, observation),
+        SCENARIO.definition.weight_microunits if conclusive else 0,
+    )
+
+
+__all__ = ["RECIPE", "SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/state/scenarios/plugin_declared_command_reaches_wire.py b/code/src/doc2harness/benchmark/harnesses/state/scenarios/plugin_declared_command_reaches_wire.py
new file mode 100644
index 0000000000000000000000000000000000000000..a9b71051df7239a9cfe856cb6c8e2cbc4a3b803b
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/state/scenarios/plugin_declared_command_reaches_wire.py
@@ -0,0 +1,75 @@
+"""Verify that a plugin-declared command face reaches the model wire.
+
+1. Seed the plugin manifest and its command file, then invoke `/probecmd`.
+2. Send the continuation prompt through the same session.
+3. Capture the recorder-owned command-face request probe after the gate.
+4. Pass only when the plugin token reaches a model request without an unknown-command result.
+"""
+
+from doc2harness.benchmark.harnesses.state.contracts import (
+    StateApplicability,
+    StateEvaluation,
+    StateObservation,
+    StateOracleProfile,
+    StateOutcome,
+    StateScenario,
+    command,
+    compile_state_steps,
+    evaluation_digest,
+    observe_requests,
+    seed_file,
+)
+
+from ..recipes import scenario_by_id
+
+SCENARIO_ID = "plugin_declared_command_reaches_wire"
+_BASE_SCENARIO = scenario_by_id(SCENARIO_ID)
+STEPS = (
+    seed_file("plugins/probeplug/commands/probecmd.md", "Summarize PLUGCMD_5150 for the team now.\n"),
+    seed_file("plugins/probeplug/plugin.json", '{\n "name": "probeplug",\n "description": "probe plugin",\n "commands": [\n  "commands/probecmd.md"\n ]\n}'),
+    command("/probecmd"),
+    command("please continue"),
+    observe_requests(),
+)
+RECIPE = compile_state_steps(STEPS, oracle_profile=StateOracleProfile.CUSTOM_COMMAND_FACE,
+    oracle_parameters=_BASE_SCENARIO.recipe.oracle_parameters,
+    execution_parameters=_BASE_SCENARIO.recipe.execution_parameters,
+    dependencies=_BASE_SCENARIO.recipe.dependencies, timeout_seconds=_BASE_SCENARIO.recipe.timeout_seconds)
+SCENARIO: StateScenario = StateScenario(_BASE_SCENARIO.definition, RECIPE)
+scenario = _BASE_SCENARIO
+definition = SCENARIO.definition
+
+
+def _probe(request: dict[str, object], token: str) -> bool:
+    probes = request.get("probes")
+    return type(probes) is tuple and dict(probes).get(token) is True
+
+
+def judge(observation: StateObservation) -> StateEvaluation:
+    """Apply the custom-command face contract using typed request facts only."""
+    if observation.scenario_id != SCENARIO_ID:
+        raise ValueError("state observation belongs to another scenario")
+    facts = dict(observation.facts)
+    requests = facts.get("requests")
+    requests = requests if type(requests) is tuple else ()
+    requests = tuple(dict(item) for item in requests if type(item) is tuple)
+    returns = facts.get("returns")
+    returns = returns if type(returns) is tuple else ()
+    params = dict(RECIPE.oracle_parameters)
+    passed, conclusive, reason = False, True, "CUSTOM_COMMAND_FACE_CHECKED"
+    if not observation.fixture_verified:
+        conclusive, reason = False, "FIXTURE_UNVERIFIED"
+    elif returns and any("unknown command" in str(item).lower() for item in returns):
+        reason = "CUSTOM_COMMAND_MISSING"
+    elif not requests:
+        conclusive, reason = False, "MODEL_TURN_UNOBSERVED"
+    else:
+        passed = any(_probe(request, params["token"]) for request in requests)
+    if conclusive and (not observation.process_tree_clean or not observation.workspace_clean):
+        passed, reason = False, "EXECUTION_CLEANUP_FAILED"
+    return StateEvaluation(SCENARIO_ID, StateOutcome.PASS if passed else StateOutcome.FAIL,
+        StateApplicability.APPLICABLE if conclusive else StateApplicability.INCONCLUSIVE,
+        reason, evaluation_digest(SCENARIO, observation), SCENARIO.definition.weight_microunits if conclusive else 0)
+
+
+__all__ = ["RECIPE", "SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/state/scenarios/plugin_toplevel_command_control.py b/code/src/doc2harness/benchmark/harnesses/state/scenarios/plugin_toplevel_command_control.py
new file mode 100644
index 0000000000000000000000000000000000000000..41bbf70f248bba1ffe807c83b5b7e6a577889f01
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/state/scenarios/plugin_toplevel_command_control.py
@@ -0,0 +1,74 @@
+"""Verify the control route for a top-level custom command face.
+
+1. Seed the top-level command file and invoke `/probecmd`.
+2. Send the continuation prompt through the same session.
+3. Capture the recorder-owned command-face request probe.
+4. Pass only when the command token reaches a model request without an unknown-command result.
+"""
+
+from doc2harness.benchmark.harnesses.state.contracts import (
+    StateApplicability,
+    StateEvaluation,
+    StateObservation,
+    StateOracleProfile,
+    StateOutcome,
+    StateScenario,
+    command,
+    compile_state_steps,
+    evaluation_digest,
+    observe_requests,
+    seed_file,
+)
+
+from ..recipes import scenario_by_id
+
+SCENARIO_ID = "plugin_toplevel_command_control"
+_BASE_SCENARIO = scenario_by_id(SCENARIO_ID)
+STEPS = (
+    seed_file("commands/probecmd.md", "Summarize PLUGCMD_5150 for the team now.\n"),
+    command("/probecmd"),
+    command("please continue"),
+    observe_requests(),
+)
+RECIPE = compile_state_steps(STEPS, oracle_profile=StateOracleProfile.CUSTOM_COMMAND_FACE,
+    oracle_parameters=_BASE_SCENARIO.recipe.oracle_parameters,
+    execution_parameters=_BASE_SCENARIO.recipe.execution_parameters,
+    dependencies=_BASE_SCENARIO.recipe.dependencies, timeout_seconds=_BASE_SCENARIO.recipe.timeout_seconds)
+SCENARIO: StateScenario = StateScenario(_BASE_SCENARIO.definition, RECIPE)
+scenario = _BASE_SCENARIO
+definition = SCENARIO.definition
+
+
+def _probe(request: dict[str, object], token: str) -> bool:
+    probes = request.get("probes")
+    return type(probes) is tuple and dict(probes).get(token) is True
+
+
+def judge(observation: StateObservation) -> StateEvaluation:
+    """Apply the custom-command face contract using typed request facts only."""
+    if observation.scenario_id != SCENARIO_ID:
+        raise ValueError("state observation belongs to another scenario")
+    facts = dict(observation.facts)
+    requests = facts.get("requests")
+    requests = requests if type(requests) is tuple else ()
+    requests = tuple(dict(item) for item in requests if type(item) is tuple)
+    returns = facts.get("returns")
+    returns = returns if type(returns) is tuple else ()
+    params = dict(RECIPE.oracle_parameters)
+    passed, conclusive, reason = False, True, "CUSTOM_COMMAND_FACE_CHECKED"
+    if not observation.fixture_verified:
+        conclusive, reason = False, "FIXTURE_UNVERIFIED"
+    elif returns and any("unknown command" in str(item).lower() for item in returns):
+        reason = "CUSTOM_COMMAND_MISSING"
+    elif not requests:
+        conclusive, reason = False, "MODEL_TURN_UNOBSERVED"
+    else:
+        passed = any(_probe(request, params["token"]) for request in requests)
+    if conclusive and (not observation.process_tree_clean or not observation.workspace_clean):
+        passed, reason = False, "EXECUTION_CLEANUP_FAILED"
+    return StateEvaluation(SCENARIO_ID, StateOutcome.PASS if passed else StateOutcome.FAIL,
+        StateApplicability.APPLICABLE if conclusive else StateApplicability.INCONCLUSIVE,
+        reason, evaluation_digest(SCENARIO, observation), SCENARIO.definition.weight_microunits if conclusive else 0)
+
+
+__all__ = ["RECIPE", "SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/state/scenarios/security_review_covers_branch_commits.py b/code/src/doc2harness/benchmark/harnesses/state/scenarios/security_review_covers_branch_commits.py
new file mode 100644
index 0000000000000000000000000000000000000000..67de63aea545327626bf78e53f2b0521901fe51c
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/state/scenarios/security_review_covers_branch_commits.py
@@ -0,0 +1,93 @@
+"""Verify that security review covers a branch commit after the worktree change.
+
+1. Seed the scenario-specific fixture files and invoke the command sequence.
+2. Capture the model request facts after the scenario's execution gates.
+3. Check whether the expected token appears in a request probe.
+4. Return PASS only when the request is observed and cleanup is clean.
+"""
+
+from doc2harness.benchmark.harnesses.state.contracts import (
+    StateApplicability,
+    StateEvaluation,
+    StateObservation,
+    StateOracleProfile,
+    StateOutcome,
+    StateScenario,
+    command,
+    compile_state_steps,
+    evaluation_digest,
+    observe_requests,
+    seed_file,
+)
+
+from ..recipes import scenario_by_id
+
+SCENARIO_ID = "security_review_covers_branch_commits"
+_BASE_SCENARIO = scenario_by_id(SCENARIO_ID)
+STEPS = (
+    seed_file("vuln_9601.py", "import os\n"),
+    command("/security-review"),
+    observe_requests(),
+)
+RECIPE = compile_state_steps(
+    STEPS,
+    oracle_profile=StateOracleProfile.REQUEST_TOKEN_PRESENT,
+    oracle_parameters=_BASE_SCENARIO.recipe.oracle_parameters,
+    execution_parameters=_BASE_SCENARIO.recipe.execution_parameters,
+    dependencies=_BASE_SCENARIO.recipe.dependencies,
+    timeout_seconds=_BASE_SCENARIO.recipe.timeout_seconds,
+)
+SCENARIO: StateScenario = StateScenario(_BASE_SCENARIO.definition, RECIPE)
+scenario = _BASE_SCENARIO
+definition = SCENARIO.definition
+
+
+def _mapping(value: object) -> dict[str, object]:
+    if type(value) is tuple and all(
+        type(item) is tuple and len(item) == 2 and type(item[0]) is str
+        for item in value
+    ):
+        return dict(value)
+    return {}
+
+
+def _requests(value: object) -> tuple[dict[str, object], ...]:
+    if type(value) is not tuple:
+        return ()
+    return tuple(_mapping(item) for item in value if type(item) is tuple)
+
+
+def _probe(request: dict[str, object], token: str) -> bool:
+    return _mapping(request.get("probes")).get(token) is True
+
+
+def judge(observation: StateObservation) -> StateEvaluation:
+    """Apply the REQUEST_TOKEN_PRESENT contract using typed request facts."""
+    if observation.scenario_id != SCENARIO_ID:
+        raise ValueError("state observation belongs to another scenario")
+    facts = _mapping(observation.facts)
+    requests = _requests(facts.get("requests"))
+    params = _mapping(RECIPE.oracle_parameters)
+    token = params.get("token") if type(params.get("token")) is str else ""
+    passed, conclusive, reason = False, True, "REQUEST_TOKEN_CHECKED"
+    if not requests:
+        conclusive, reason = False, "MODEL_TURN_UNOBSERVED"
+    else:
+        passed = any(_probe(request, token) for request in requests)
+    if conclusive and (
+        not observation.process_tree_clean or not observation.workspace_clean
+    ):
+        passed, reason = False, "EXECUTION_CLEANUP_FAILED"
+    return StateEvaluation(
+        SCENARIO_ID,
+        StateOutcome.PASS if passed else StateOutcome.FAIL,
+        StateApplicability.APPLICABLE
+        if conclusive
+        else StateApplicability.INCONCLUSIVE,
+        reason,
+        evaluation_digest(SCENARIO, observation),
+        SCENARIO.definition.weight_microunits if conclusive else 0,
+    )
+
+
+__all__ = ["RECIPE", "SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/tui/__init__.py b/code/src/doc2harness/benchmark/harnesses/tui/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..8d41b2103fc2871acf1e0a1a80f3e902709bd10d
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/tui/__init__.py
@@ -0,0 +1,47 @@
+"""Typed public boundary for interactive TUI PTY scenarios."""
+
+from .adapter import (
+    TuiPtyExecutionPlan,
+    build_tui_pty_execution_plan,
+)
+from .contracts import (
+    HistoryEvent,
+    HistoryFile,
+    HistoryObservation,
+    HistorySnapshot,
+    ObservedFile,
+    PromptObservation,
+    TuiApplicability,
+    TuiEvaluation,
+    TuiInput,
+    TuiObservation,
+    TuiOracleBinding,
+    TuiOutcome,
+    TuiProfile,
+    TuiRecipe,
+    TuiRequest,
+    TuiScenario,
+)
+from .recipes import SCENARIO_BY_ID
+
+__all__ = [
+    "SCENARIO_BY_ID",
+    "HistoryEvent",
+    "HistoryFile",
+    "HistoryObservation",
+    "HistorySnapshot",
+    "ObservedFile",
+    "PromptObservation",
+    "TuiApplicability",
+    "TuiEvaluation",
+    "TuiInput",
+    "TuiObservation",
+    "TuiOracleBinding",
+    "TuiOutcome",
+    "TuiProfile",
+    "TuiPtyExecutionPlan",
+    "TuiRecipe",
+    "TuiRequest",
+    "TuiScenario",
+    "build_tui_pty_execution_plan",
+]
diff --git a/code/src/doc2harness/benchmark/harnesses/tui/adapter.py b/code/src/doc2harness/benchmark/harnesses/tui/adapter.py
new file mode 100644
index 0000000000000000000000000000000000000000..77f954cb56083436da3f5ffe0912cab705fcf42c
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/tui/adapter.py
@@ -0,0 +1,215 @@
+"""Execution boundary for typed TUI PTY observations."""
+
+import hashlib
+from dataclasses import dataclass
+
+from doc2harness.contracts.canonical import canonical_json
+from doc2harness.contracts.primitives import ContractDocumentError
+
+from doc2harness.benchmark.definition import DependencyKind, ScenarioRole
+
+from .contracts import (
+    TuiApplicability,
+    TuiEvaluation,
+    TuiInput,
+    TuiObservation,
+    TuiOracleBinding,
+    TuiOutcome,
+    TuiProfile,
+    TuiRecipe,
+    TuiScenario,
+    define_tui_scenario,
+    evaluation_digest,
+)
+from .fixtures import TuiFixturePlan, materialize_tui_fixture
+
+
+@dataclass(frozen=True, slots=True)
+class TuiPtyExecutionPlan:
+    scenario_id: str
+    profile: TuiProfile
+    recipe: TuiRecipe
+    fixture: TuiFixturePlan
+    timeout_seconds: int
+    plan_digest: str
+
+
+def build_tui_pty_execution_plan(scenario: TuiScenario, /) -> TuiPtyExecutionPlan:
+    if type(scenario) is not TuiScenario:
+        raise ContractDocumentError("TUI PTY execution requires an exact scenario")
+    fixture = materialize_tui_fixture(scenario)
+    body = {
+        "fixture_digest": fixture.plan_digest,
+        "profile": scenario.recipe.profile.value,
+        "scenario_id": scenario.definition.scenario_id,
+        "timeout_seconds": scenario.recipe.timeout_seconds,
+    }
+    digest = "sha256:" + hashlib.sha256(
+        b"doc2harness.tui-pty-plan/1\0" + canonical_json(body)
+    ).hexdigest()
+    return TuiPtyExecutionPlan(
+        scenario.definition.scenario_id,
+        scenario.recipe.profile,
+        scenario.recipe,
+        fixture,
+        scenario.recipe.timeout_seconds,
+        digest,
+    )
+
+
+# These builders intentionally live at the adapter boundary rather
+# than in a second helper module: scenario files stay declarative while the
+# runtime-owned external observation policy remains in one stable module.
+def build_external_tui_scenario(
+    scenario_id: str,
+    role: ScenarioRole,
+    control_id: str | None,
+    gateway_mode: str,
+) -> TuiScenario:
+    dependencies = () if role is ScenarioRole.CONTROL else (
+        (control_id, DependencyKind.GATE),
+    )
+    digest = "sha256:" + hashlib.sha256(
+        ("doc2harness.tui.external/1\\0" + scenario_id).encode()
+    ).hexdigest()
+    marker = "TUI_EXTERNAL_7731"
+    cli_arguments: tuple[str, ...] = ()
+    if "background_completion" in scenario_id:
+        marker = "TUI_BACKGROUND_DONE_7731"
+    elif "autotest_output" in scenario_id:
+        marker = "TUI_AUTOTEST_SUCCESS_7731"
+        cli_arguments = (
+            "--auto-test",
+            "--test-cmd",
+            "printf 'TUI_AUTOTEST_SUCCESS_7731 stdout test passed\\n'",
+        )
+    elif "autocommit_fail" in scenario_id:
+        marker = "TUI_AUTOCOMMIT_FAIL_7731"
+        cli_arguments = ("--auto-commit",)
+    elif "bad_tool_args" in scenario_id:
+        marker = "TUI_BAD_ARGS_SUCCESS_7731"
+    elif "empty_tool_name" in scenario_id:
+        marker = "TUI_EMPTY_TOOL_7731"
+    elif "model_finish_reason" in scenario_id:
+        marker = "TUI_FINISH_REASON_7731"
+    elif "step_limit" in scenario_id:
+        marker = "TUI_STEP_LIMIT_7731"
+        cli_arguments = ("--max-steps", "2")
+    recipe = TuiRecipe(
+        TuiProfile.WIRE_SURVIVES,
+        digest,
+        dependencies,
+        180,
+        False,
+        input_lines=(TuiInput("70696e67"),),
+        gateway_mode=gateway_mode,
+        probe_tokens=(marker,),
+        cli_arguments=cli_arguments,
+        oracle=TuiOracleBinding(primary_token=marker),
+    )
+    return define_tui_scenario(scenario_id, recipe, role)
+
+
+def _external_tui_has(text: str, *patterns: str) -> bool:
+    lowered = text.lower()
+    return all(
+        any(pattern.lower() in lowered for pattern in group.split("|"))
+        for group in patterns
+    )
+
+
+def _external_tui_requirement(requirement: str, text: str, marker: str = "") -> bool:
+    """Check a trajectory requirement using its scenario-bound canary marker.
+
+    The recipe tables use generic marker names, while the external recipe
+    builder uses a stable per-scenario marker.  Accepting the bound marker as
+    an alternative keeps the judge tied to the scenario rather than to one
+    probe spelling; it does not make a phrase-only trajectory
+    sufficient because every branch still requires the semantic event words.
+    """
+
+    marker = marker or "__missing_marker__"
+    if requirement == "step_limit":
+        return _external_tui_has(text, "limits_exceeded|max_steps", "run_end|terminal|finished")
+    if requirement == "bad_args":
+        return _external_tui_has(text, "tool_result|error|failure", "invalid|malformed|json|argument", f"TUI_BAD_ARGS_SUCCESS_7731|{marker}")
+    if requirement == "autotest":
+        return _external_tui_has(text, "stdout|test", "success|passed|ok", f"TUI_AUTOTEST_SUCCESS_7731|{marker}")
+    if requirement == "autocommit_fail":
+        return _external_tui_has(text, "auto.?commit|commit", "gpg|hook|cannot|failed|error", f"TUI_AUTOCOMMIT_FAIL_7731|{marker}")
+    if requirement == "background":
+        return _external_tui_has(text, "completed|exit|finished", f"TUI_BACKGROUND_DONE_7731|{marker}")
+    if requirement == "empty_reply":
+        return _external_tui_has(text, "warning|error|note", "empty|no content|blank")
+    if requirement == "finish_reason":
+        return _external_tui_has(text, "tool_calls|tool call", "finish_reason|stop")
+    if requirement == "empty_tool_name":
+        return _external_tui_has(
+            text,
+            "error|invalid|malformed|no tool named|unknown tool",
+            "empty|missing|invalid|no tool named|unknown tool|''",
+            "tool",
+        )
+    raise ValueError(requirement)
+
+
+def make_external_tui_judge(scenario: TuiScenario, requirement: str):
+    def judge(observation: TuiObservation) -> TuiEvaluation:
+        if observation.scenario_id != scenario.definition.scenario_id:
+            raise ValueError("TUI external observation belongs to another scenario")
+        base_ready = (
+            observation.cli_available
+            and bool(observation.requests)
+            and observation.returncode == 0
+            and not observation.driver_error
+            and observation.process_tree_clean
+            and observation.workspace_clean
+            and not observation.deadline_reached
+        )
+        if not base_ready:
+            outcome = TuiOutcome.PASS
+            applicability = TuiApplicability.INCONCLUSIVE
+            reason = "TUI_EXTERNAL_STIMULUS_UNESTABLISHED"
+        elif scenario.definition.role is ScenarioRole.CONTROL:
+            outcome = TuiOutcome.PASS
+            applicability = TuiApplicability.APPLICABLE
+            reason = "TUI_EXTERNAL_CONTROL_ESTABLISHED"
+        elif not observation.trajectory_text:
+            outcome = TuiOutcome.FAIL
+            applicability = TuiApplicability.APPLICABLE
+            reason = "TUI_TRAJECTORY_NOT_OBSERVED"
+        else:
+            marker = scenario.recipe.oracle.primary_token or (
+                scenario.recipe.probe_tokens[0] if scenario.recipe.probe_tokens else ""
+            )
+            passed = _external_tui_requirement(requirement, observation.trajectory_text, marker)
+            outcome = TuiOutcome.PASS if passed else TuiOutcome.FAIL
+            applicability = TuiApplicability.APPLICABLE
+            reason = "TUI_TRAJECTORY_REQUIREMENT_RECORDED" if passed else "TUI_TRAJECTORY_REQUIREMENT_MISSING"
+        contribution = (
+            scenario.definition.weight_microunits
+            if outcome is TuiOutcome.PASS and applicability is TuiApplicability.APPLICABLE
+            else 0
+        )
+        return TuiEvaluation(
+            scenario.definition.scenario_id,
+            outcome,
+            applicability,
+            reason,
+            evaluation_digest(scenario, observation),
+            contribution,
+        )
+
+    return judge
+
+
+# Short aliases keep the scenario declarations tiny.
+build_scenario = build_external_tui_scenario
+make_judge = make_external_tui_judge
+
+
+__all__ = [
+    "TuiPtyExecutionPlan", "build_tui_pty_execution_plan",
+    "build_external_tui_scenario", "make_external_tui_judge",
+    "build_scenario", "make_judge",
+]
diff --git a/code/src/doc2harness/benchmark/harnesses/tui/catalog.toml b/code/src/doc2harness/benchmark/harnesses/tui/catalog.toml
new file mode 100644
index 0000000000000000000000000000000000000000..b9dcafb4bb9191888774e78a219624d013af04a2
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/tui/catalog.toml
@@ -0,0 +1,14 @@
+format = "doc2harness.catalog-shard-source/1"
+function_id = "tui"
+resource = "benchmark/harnesses/tui/catalog.toml"
+exports = [
+  { module = "doc2harness.benchmark.harnesses.tui.scenarios.history_realpath_key", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.tui.scenarios.history_workspace_a_fresh_control", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.tui.scenarios.history_workspace_b_fresh_control", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.tui.scenarios.trajectory_autocommit_fail_recorded", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.tui.scenarios.trajectory_autocommit_fail_recorded_control", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.tui.scenarios.trajectory_step_limit_terminal_accurate", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.tui.scenarios.trajectory_step_limit_terminal_accurate_control", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.tui.scenarios.tui_bang_alone_enters_shell_mode", export = "definition" },
+  { module = "doc2harness.benchmark.harnesses.tui.scenarios.tui_ctrl_byte_storm_survives", export = "definition" },
+]
diff --git a/code/src/doc2harness/benchmark/harnesses/tui/contracts.py b/code/src/doc2harness/benchmark/harnesses/tui/contracts.py
new file mode 100644
index 0000000000000000000000000000000000000000..617a18ad9976c58f2e9edcdd7bb4062b462a1a10
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/tui/contracts.py
@@ -0,0 +1,501 @@
+"""Typed recipes and raw observations for interactive TUI PTY scenarios."""
+
+from __future__ import annotations
+
+import hashlib
+import re
+from dataclasses import asdict, dataclass
+from enum import Enum
+
+from doc2harness.benchmark.definition import (
+    Classification,
+    ComponentKind,
+    ComponentRef,
+    DependencyKind,
+    DependencyRef,
+    ExperimentBinding,
+    ScenarioDefinition,
+    ScenarioDifficulty,
+    ScenarioRole,
+    UnsupportedPolicy,
+    definition_digest,
+)
+from doc2harness.contracts.canonical import canonical_json
+from doc2harness.contracts.primitives import ContractDocumentError
+
+_ID = re.compile(r"[a-z0-9][a-z0-9._-]{0,127}\Z", re.ASCII)
+_DIGEST = re.compile(r"sha256:[0-9a-f]{64}\Z", re.ASCII)
+_HEX = re.compile(r"(?:[0-9a-f]{2})*\Z", re.ASCII)
+_MAX_TEXT = 4_000_000
+_MAX_ITEMS = 4096
+
+
+def _text(value: object, name: str, *, empty: bool = True) -> None:
+    if type(value) is not str or len(value) > _MAX_TEXT or (not empty and not value):
+        raise ContractDocumentError(f"TUI PTY {name} is invalid")
+
+
+def _digest(value: object, name: str) -> None:
+    if type(value) is not str or _DIGEST.fullmatch(value) is None:
+        raise ContractDocumentError(f"TUI PTY {name} is invalid")
+
+
+def _hex(value: object, name: str) -> None:
+    if type(value) is not str or len(value) > _MAX_TEXT * 2 or _HEX.fullmatch(value) is None:
+        raise ContractDocumentError(f"TUI PTY {name} is invalid")
+
+
+def _strings(value: object, name: str, *, unique: bool = False) -> None:
+    if (
+        type(value) is not tuple
+        or len(value) > _MAX_ITEMS
+        or any(type(item) is not str or len(item) > _MAX_TEXT for item in value)
+        or (unique and len(set(value)) != len(value))
+    ):
+        raise ContractDocumentError(f"TUI PTY {name} is invalid")
+
+
+def _relative(value: object, name: str) -> None:
+    _text(value, name, empty=False)
+    if value.startswith("/") or ".." in value.split("/"):
+        raise ContractDocumentError(f"TUI PTY {name} must be relative")
+
+
+class TuiProfile(str, Enum):
+    CHAOS_SURVIVES = "chk_survives_chaos"
+    FILE_WRITTEN = "chk_tui_file"
+    WIRE_SURVIVES = "chk_tui_wire_survives"
+    HISTORY_FRESH = "chk_history_fresh_control"
+    HISTORY_REALPATH = "chk_history_realpath_key"
+
+
+class TuiOutcome(str, Enum):
+    PASS = "PASS"
+    FAIL = "FAIL"
+
+
+class TuiApplicability(str, Enum):
+    APPLICABLE = "APPLICABLE"
+    INCONCLUSIVE = "INCONCLUSIVE"
+
+
+class HistoryScenario(str, Enum):
+    NONE = ""
+    FRESH_A = "history-fresh-a"
+    FRESH_B = "history-fresh-b"
+    REALPATH_KEY = "history-realpath-key"
+
+
+@dataclass(frozen=True, slots=True)
+class TuiInput:
+    data_hex: str
+
+    def __post_init__(self) -> None:
+        _hex(self.data_hex, "input bytes")
+        if not self.data_hex:
+            raise ContractDocumentError("TUI PTY input bytes must not be empty")
+
+
+@dataclass(frozen=True, slots=True)
+class SeedFile:
+    path: str
+    data_hex: str
+
+    def __post_init__(self) -> None:
+        _relative(self.path, "seed path")
+        _hex(self.data_hex, "seed bytes")
+
+
+@dataclass(frozen=True, slots=True)
+class TuiOracleBinding:
+    primary_token: str = ""
+    secondary_token: str = ""
+    foreign_token: str = ""
+    line_token: str = ""
+    path: str = ""
+    specification: str = ""
+    history_prefix: str = ""
+    completion_token: str = "TUILINE_DONE_7755"
+    crash_signatures: tuple[str, ...] = (
+        "Traceback (most recent call last)",
+        "UnhandledError",
+        "panic:",
+        "Unhandled exception",
+        "RuntimeError:",
+        "KeyError:",
+        "AttributeError:",
+        "ValueError:",
+    )
+
+    def __post_init__(self) -> None:
+        for value in (
+            self.primary_token,
+            self.secondary_token,
+            self.foreign_token,
+            self.line_token,
+            self.specification,
+            self.history_prefix,
+            self.completion_token,
+        ):
+            _text(value, "oracle text")
+        if self.path:
+            _relative(self.path, "oracle path")
+        _strings(self.crash_signatures, "crash signatures", unique=True)
+
+
+@dataclass(frozen=True, slots=True)
+class TuiRecipe:
+    profile: TuiProfile
+    case_digest: str
+    dependencies: tuple[tuple[str, DependencyKind], ...]
+    timeout_seconds: int
+    blocking: bool
+    input_lines: tuple[TuiInput, ...] = ()
+    seed_files: tuple[SeedFile, ...] = ()
+    gateway_mode: str = "normal"
+    reply_content: str = "ack"
+    probe_tokens: tuple[str, ...] = ()
+    cli_arguments: tuple[str, ...] = ()
+    observed_files: tuple[str, ...] = ()
+    history_scenario: HistoryScenario = HistoryScenario.NONE
+    oracle: TuiOracleBinding = TuiOracleBinding()
+
+    def __post_init__(self) -> None:
+        if type(self.profile) is not TuiProfile:
+            raise ContractDocumentError("TUI PTY profile is invalid")
+        _digest(self.case_digest, "case digest")
+        if type(self.dependencies) is not tuple or any(
+            type(item) is not tuple
+            or len(item) != 2
+            or type(item[0]) is not str
+            or _ID.fullmatch(item[0]) is None
+            or type(item[1]) is not DependencyKind
+            for item in self.dependencies
+        ):
+            raise ContractDocumentError("TUI PTY dependencies are invalid")
+        if (
+            type(self.timeout_seconds) is not int
+            or not 1 <= self.timeout_seconds <= 600
+            or type(self.blocking) is not bool
+        ):
+            raise ContractDocumentError("TUI PTY execution policy is invalid")
+        if type(self.input_lines) is not tuple or any(
+            type(item) is not TuiInput for item in self.input_lines
+        ):
+            raise ContractDocumentError("TUI PTY inputs are invalid")
+        if type(self.seed_files) is not tuple or any(
+            type(item) is not SeedFile for item in self.seed_files
+        ):
+            raise ContractDocumentError("TUI PTY seed files are invalid")
+        _text(self.gateway_mode, "gateway mode", empty=False)
+        _text(self.reply_content, "reply content")
+        _strings(self.probe_tokens, "probe tokens", unique=True)
+        _strings(self.cli_arguments, "CLI arguments")
+        _strings(self.observed_files, "observed files", unique=True)
+        for path in self.observed_files:
+            _relative(path, "observed path")
+        if type(self.history_scenario) is not HistoryScenario:
+            raise ContractDocumentError("TUI PTY history scenario is invalid")
+        if type(self.oracle) is not TuiOracleBinding:
+            raise ContractDocumentError("TUI PTY oracle binding is invalid")
+
+
+@dataclass(frozen=True, slots=True)
+class TuiRequest:
+    body: str
+
+    def __post_init__(self) -> None:
+        _text(self.body, "request body")
+
+
+@dataclass(frozen=True, slots=True)
+class ObservedFile:
+    path: str
+    present: bool
+    content: str = ""
+
+    def __post_init__(self) -> None:
+        _relative(self.path, "observed file path")
+        if type(self.present) is not bool:
+            raise ContractDocumentError("TUI PTY file presence is invalid")
+        _text(self.content, "observed file content")
+        if not self.present and self.content:
+            raise ContractDocumentError("absent TUI PTY file cannot have content")
+
+
+@dataclass(frozen=True, slots=True)
+class PromptObservation:
+    identity: str
+    turn_id: str
+    candidate_boundary: bool
+    canary_nonce_absent_before: bool
+    canary_nonce_absent_from_input: bool
+    canary_observed: bool
+    input_consumed: bool
+    startup_failure_kind: str = ""
+    startup_returncode: int | None = None
+    startup_signal: int | None = None
+    timeline: tuple[str, ...] = ()
+
+    def __post_init__(self) -> None:
+        _text(self.identity, "prompt identity", empty=False)
+        _text(self.turn_id, "prompt turn", empty=False)
+        _text(self.startup_failure_kind, "prompt startup failure")
+        if any(
+            type(value) is not bool
+            for value in (
+                self.candidate_boundary,
+                self.canary_nonce_absent_before,
+                self.canary_nonce_absent_from_input,
+                self.canary_observed,
+                self.input_consumed,
+            )
+        ):
+            raise ContractDocumentError("TUI PTY prompt facts are invalid")
+        for value in (self.startup_returncode, self.startup_signal):
+            if value is not None and type(value) is not int:
+                raise ContractDocumentError("TUI PTY prompt terminal fact is invalid")
+        _strings(self.timeline, "prompt timeline")
+
+
+@dataclass(frozen=True, slots=True)
+class HistoryFile:
+    path: str
+    data_hex: str
+
+    def __post_init__(self) -> None:
+        _relative(self.path, "history path")
+        _hex(self.data_hex, "history bytes")
+
+
+@dataclass(frozen=True, slots=True)
+class HistorySnapshot:
+    complete: bool
+    files: tuple[HistoryFile, ...]
+
+    def __post_init__(self) -> None:
+        if type(self.complete) is not bool or type(self.files) is not tuple or any(
+            type(item) is not HistoryFile for item in self.files
+        ):
+            raise ContractDocumentError("TUI PTY history snapshot is invalid")
+        paths = tuple(item.path for item in self.files)
+        if len(paths) != len(set(paths)):
+            raise ContractDocumentError("TUI PTY history paths must be unique")
+
+
+@dataclass(frozen=True, slots=True)
+class HistoryEvent:
+    name: str
+    kind: str
+    input_hex: str
+    output_text: str
+    output_sha256: str
+    output_size: int
+    requests_before: int
+    requests_after: int
+    returncode: int | None = None
+
+    def __post_init__(self) -> None:
+        _text(self.name, "history event name", empty=False)
+        _text(self.kind, "history event kind", empty=False)
+        _hex(self.input_hex, "history event input")
+        _text(self.output_text, "history event output")
+        if type(self.output_sha256) is not str or re.fullmatch(
+            r"[0-9a-f]{64}", self.output_sha256
+        ) is None:
+            raise ContractDocumentError("TUI PTY history output digest is invalid")
+        if any(
+            type(value) is not int or value < 0
+            for value in (self.output_size, self.requests_before, self.requests_after)
+        ) or (self.returncode is not None and type(self.returncode) is not int):
+            raise ContractDocumentError("TUI PTY history event counters are invalid")
+
+
+@dataclass(frozen=True, slots=True)
+class HistoryObservation:
+    scenario: HistoryScenario
+    workspace: str = ""
+    workspace_a: str = ""
+    workspace_b: str = ""
+    writer: tuple[HistoryEvent, ...] = ()
+    reader: tuple[HistoryEvent, ...] = ()
+    writer_a: tuple[HistoryEvent, ...] = ()
+    writer_b: tuple[HistoryEvent, ...] = ()
+    reader_a: tuple[HistoryEvent, ...] = ()
+    reader_b: tuple[HistoryEvent, ...] = ()
+    snapshot: HistorySnapshot | None = None
+    snapshot_a: HistorySnapshot | None = None
+    snapshot_ab: HistorySnapshot | None = None
+
+    def __post_init__(self) -> None:
+        if type(self.scenario) is not HistoryScenario:
+            raise ContractDocumentError("TUI PTY history identity is invalid")
+        for value in (self.workspace, self.workspace_a, self.workspace_b):
+            _text(value, "history workspace")
+        for values in (
+            self.writer,
+            self.reader,
+            self.writer_a,
+            self.writer_b,
+            self.reader_a,
+            self.reader_b,
+        ):
+            if type(values) is not tuple or any(
+                type(item) is not HistoryEvent for item in values
+            ):
+                raise ContractDocumentError("TUI PTY history events are invalid")
+            names = tuple(item.name for item in values)
+            if len(names) != len(set(names)):
+                raise ContractDocumentError("TUI PTY history event names must be unique")
+        for value in (self.snapshot, self.snapshot_a, self.snapshot_ab):
+            if value is not None and type(value) is not HistorySnapshot:
+                raise ContractDocumentError("TUI PTY history snapshot type is invalid")
+
+
+@dataclass(frozen=True, slots=True)
+class TuiScenario:
+    definition: ScenarioDefinition
+    recipe: TuiRecipe
+
+    def __post_init__(self) -> None:
+        if type(self.definition) is not ScenarioDefinition or type(self.recipe) is not TuiRecipe:
+            raise ContractDocumentError("TUI PTY scenario requires exact typed values")
+        if self.definition.classification.primary != "tui":
+            raise ContractDocumentError("TUI PTY scenario owner differs from its Harness")
+
+
+@dataclass(frozen=True, slots=True)
+class TuiObservation:
+    scenario_id: str
+    profile: TuiProfile
+    plan_digest: str
+    artifact_id: str
+    artifact_digest: str
+    backend_evidence_digest: str
+    cli_available: bool
+    prompt: PromptObservation
+    screen_text: str
+    screen_sha256: str
+    screen_size: int
+    returncode: int | None
+    signal: int | None
+    requests: tuple[TuiRequest, ...]
+    files: tuple[ObservedFile, ...]
+    history: HistoryObservation | None = None
+    elapsed_ns: int = 0
+    deadline_reached: bool = False
+    driver_error: str = ""
+    process_tree_clean: bool = True
+    workspace_clean: bool = True
+    trajectory_text: str = ""
+
+    def __post_init__(self) -> None:
+        if type(self.scenario_id) is not str or _ID.fullmatch(self.scenario_id) is None:
+            raise ContractDocumentError("TUI PTY observation scenario is invalid")
+        if type(self.profile) is not TuiProfile:
+            raise ContractDocumentError("TUI PTY observation profile is invalid")
+        for value in (
+            self.plan_digest,
+            self.artifact_digest,
+            self.backend_evidence_digest,
+        ):
+            _digest(value, "evidence digest")
+        _text(self.artifact_id, "artifact id", empty=False)
+        if type(self.cli_available) is not bool or type(self.prompt) is not PromptObservation:
+            raise ContractDocumentError("TUI PTY observation availability is invalid")
+        _text(self.screen_text, "screen text")
+        if type(self.screen_sha256) is not str or re.fullmatch(
+            r"[0-9a-f]{64}", self.screen_sha256
+        ) is None:
+            raise ContractDocumentError("TUI PTY screen digest is invalid")
+        if type(self.screen_size) is not int or self.screen_size < 0:
+            raise ContractDocumentError("TUI PTY screen size is invalid")
+        for value in (self.returncode, self.signal):
+            if value is not None and type(value) is not int:
+                raise ContractDocumentError("TUI PTY terminal status is invalid")
+        if type(self.requests) is not tuple or any(
+            type(item) is not TuiRequest for item in self.requests
+        ):
+            raise ContractDocumentError("TUI PTY requests are invalid")
+        if type(self.files) is not tuple or any(
+            type(item) is not ObservedFile for item in self.files
+        ):
+            raise ContractDocumentError("TUI PTY files are invalid")
+        if self.history is not None and type(self.history) is not HistoryObservation:
+            raise ContractDocumentError("TUI PTY history is invalid")
+        if type(self.elapsed_ns) is not int or self.elapsed_ns < 0:
+            raise ContractDocumentError("TUI PTY elapsed time is invalid")
+        if any(
+            type(value) is not bool
+            for value in (
+                self.deadline_reached,
+                self.process_tree_clean,
+                self.workspace_clean,
+            )
+        ):
+            raise ContractDocumentError("TUI PTY cleanup facts are invalid")
+        _text(self.driver_error, "driver error")
+        _text(self.trajectory_text, "trajectory text")
+        paths = tuple(item.path for item in self.files)
+        if len(paths) != len(set(paths)):
+            raise ContractDocumentError("TUI PTY observed files must be unique")
+
+
+@dataclass(frozen=True, slots=True)
+class TuiEvaluation:
+    scenario_id: str
+    outcome: TuiOutcome
+    applicability: TuiApplicability
+    reason_code: str
+    evidence_digest: str
+    contribution_microunits: int
+
+
+def define_tui_scenario(
+    scenario_id: str, recipe: TuiRecipe, role: ScenarioRole, /
+) -> TuiScenario:
+    dependencies = tuple(
+        sorted(
+            (DependencyRef(test_id, kind) for test_id, kind in recipe.dependencies),
+            key=lambda item: (item.scenario_id, item.kind.value),
+        )
+    )
+    definition = ScenarioDefinition(
+        scenario_id,
+        "1",
+        Classification("tui"),
+        role,
+        1_000_000 if role is ScenarioRole.TARGET else 0,
+        ScenarioDifficulty.HARD,
+        dependencies,
+        ExperimentBinding(
+            ComponentRef("tui-pty-fixture", "1", ComponentKind.FIXTURE),
+            ComponentRef("tui-pty-adapter", "1", ComponentKind.STIMULUS),
+            ComponentRef("tui-pty-observer", "1", ComponentKind.OBSERVER),
+            ComponentRef("tui-pty-oracle", "1", ComponentKind.ORACLE),
+            ComponentRef("tui-pty-cleanup", "1", ComponentKind.CLEANUP),
+        ),
+        UnsupportedPolicy.FAIL,
+    )
+    return TuiScenario(definition, recipe)
+
+
+def recipe_digest(recipe: TuiRecipe, /) -> str:
+    if type(recipe) is not TuiRecipe:
+        raise ContractDocumentError("TUI PTY recipe digest requires an exact recipe")
+    return "sha256:" + hashlib.sha256(
+        b"doc2harness.tui-pty-recipe/1\0" + canonical_json(asdict(recipe))
+    ).hexdigest()
+
+
+def evaluation_digest(scenario: TuiScenario, observation: TuiObservation) -> str:
+    body = {
+        "artifact_digest": observation.artifact_digest,
+        "backend_evidence_digest": observation.backend_evidence_digest,
+        "definition_digest": definition_digest(scenario.definition),
+        "plan_digest": observation.plan_digest,
+        "scenario_id": scenario.definition.scenario_id,
+    }
+    return "sha256:" + hashlib.sha256(
+        b"doc2harness.tui-pty-evaluation/1\0" + canonical_json(body)
+    ).hexdigest()
diff --git a/code/src/doc2harness/benchmark/harnesses/tui/fixtures.py b/code/src/doc2harness/benchmark/harnesses/tui/fixtures.py
new file mode 100644
index 0000000000000000000000000000000000000000..2b2aca3fac90b3e7c0a2b7f4de2c76c2bb101d2b
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/tui/fixtures.py
@@ -0,0 +1,33 @@
+"""Immutable fixture bindings for interactive TUI PTY scenarios."""
+
+import hashlib
+from dataclasses import dataclass
+
+from doc2harness.contracts.canonical import canonical_json
+
+from .contracts import TuiRecipe, TuiScenario, recipe_digest
+
+
+@dataclass(frozen=True, slots=True)
+class TuiFixturePlan:
+    case_digest: str
+    recipe: TuiRecipe
+    recipe_digest: str
+    plan_digest: str
+
+
+def materialize_tui_fixture(scenario: TuiScenario, /) -> TuiFixturePlan:
+    body = {
+        "case_digest": scenario.recipe.case_digest,
+        "recipe_digest": recipe_digest(scenario.recipe),
+        "scenario_id": scenario.definition.scenario_id,
+    }
+    digest = "sha256:" + hashlib.sha256(
+        b"doc2harness.tui-pty-fixture/1\0" + canonical_json(body)
+    ).hexdigest()
+    return TuiFixturePlan(
+        scenario.recipe.case_digest,
+        scenario.recipe,
+        body["recipe_digest"],
+        digest,
+    )
diff --git a/code/src/doc2harness/benchmark/harnesses/tui/recipes.py b/code/src/doc2harness/benchmark/harnesses/tui/recipes.py
new file mode 100644
index 0000000000000000000000000000000000000000..fff8507d22c1438995167f42b556b395d0cb930b
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/tui/recipes.py
@@ -0,0 +1,100 @@
+"""Frozen typed recipes for interactive TUI PTY scenarios."""
+
+from doc2harness.benchmark.definition import DependencyKind, ScenarioRole
+from .contracts import HistoryScenario, TuiInput, TuiOracleBinding, TuiProfile, TuiRecipe, define_tui_scenario
+
+
+def _inputs(*values: str) -> tuple[TuiInput, ...]:
+    return tuple((TuiInput(value) for value in values))
+
+
+_HISTORY_A = "H8A9961_ONLY_A_4C7E"
+_HISTORY_B = "H8B9962_ONLY_B_9D3F"
+_ROWS: dict[str, tuple[TuiRecipe, ScenarioRole]] = {
+    "tui_ctrl_byte_storm_survives": (
+        TuiRecipe(
+            TuiProfile.CHAOS_SURVIVES,
+            "sha256:ebf1873599579122839f864b8a08fb9fc6638611524bd5f2470bbfbac377a1a1",
+            (),
+            90,
+            False,
+            _inputs("010205060708090b0c0e0f101112131415161718192052423937415f37373331"),
+            probe_tokens=("RB97A_7731",),
+        ),
+        ScenarioRole.TARGET,
+    ),
+    "tui_bang_alone_enters_shell_mode": (
+        TuiRecipe(
+            TuiProfile.FILE_WRITTEN,
+            "sha256:863a252325195b0e72491af1418666147ad20a9281fbb0af834816eb546d85fd",
+            (),
+            100,
+            False,
+            _inputs("21", "7072696e746620274d4f44453130305f25735c6e272037373331203e206d6f64653130302e747874"),
+            probe_tokens=("MODE100_7731",),
+            observed_files=("mode100.txt",),
+            oracle=TuiOracleBinding(primary_token="MODE100_7731", path="mode100.txt"),
+        ),
+        ScenarioRole.TARGET,
+    ),
+    "history_workspace_a_fresh_control": (
+        TuiRecipe(
+            TuiProfile.HISTORY_FRESH,
+            "sha256:5491f4c5e2e792ee9471ed98fc1b679b860508c0515b68c2d0dec1dd5b219927",
+            (),
+            90,
+            False,
+            gateway_mode="fixed_reply",
+            reply_content="history-control-a-ok",
+            probe_tokens=(_HISTORY_A, _HISTORY_B),
+            history_scenario=HistoryScenario.FRESH_A,
+            oracle=TuiOracleBinding(
+                primary_token=_HISTORY_A, foreign_token=_HISTORY_B, history_prefix="H8A9961_"
+            ),
+        ),
+        ScenarioRole.CONTROL,
+    ),
+    "history_workspace_b_fresh_control": (
+        TuiRecipe(
+            TuiProfile.HISTORY_FRESH,
+            "sha256:8f4b916ebf70fc02b2ddd923d763297f35633e263bfb249b971f22e38e67a8ed",
+            (),
+            90,
+            False,
+            gateway_mode="fixed_reply",
+            reply_content="history-control-b-ok",
+            probe_tokens=(_HISTORY_A, _HISTORY_B),
+            history_scenario=HistoryScenario.FRESH_B,
+            oracle=TuiOracleBinding(
+                primary_token=_HISTORY_B, foreign_token=_HISTORY_A, history_prefix="H8B9962_"
+            ),
+        ),
+        ScenarioRole.CONTROL,
+    ),
+    "history_realpath_key": (
+        TuiRecipe(
+            TuiProfile.HISTORY_REALPATH,
+            "sha256:b6c88c978f949efceef60880ebe1e8ff1f1a7e74d4c65b8a648f1738fc14137b",
+            (
+                ("history_workspace_a_fresh_control", DependencyKind.GATE),
+                ("history_workspace_b_fresh_control", DependencyKind.GATE),
+            ),
+            140,
+            True,
+            gateway_mode="fixed_reply",
+            reply_content="history-realpath-ok",
+            probe_tokens=(_HISTORY_A, _HISTORY_B),
+            history_scenario=HistoryScenario.REALPATH_KEY,
+            oracle=TuiOracleBinding(primary_token=_HISTORY_A, secondary_token=_HISTORY_B),
+        ),
+        ScenarioRole.TARGET,
+    ),
+}
+SCENARIO_BY_ID = {
+    scenario_id: define_tui_scenario(scenario_id, recipe, role)
+    for scenario_id, (recipe, role) in _ROWS.items()
+}
+
+
+def scenario_by_id(scenario_id: str, /):
+    return SCENARIO_BY_ID[scenario_id]
diff --git a/code/src/doc2harness/benchmark/harnesses/tui/scenarios/__init__.py b/code/src/doc2harness/benchmark/harnesses/tui/scenarios/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..8de181ad9f3773580ed00de6358e5f380a6554b7
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/tui/scenarios/__init__.py
@@ -0,0 +1 @@
+"""Thin interactive TUI PTY scenario definitions."""
diff --git a/code/src/doc2harness/benchmark/harnesses/tui/scenarios/history_realpath_key.py b/code/src/doc2harness/benchmark/harnesses/tui/scenarios/history_realpath_key.py
new file mode 100644
index 0000000000000000000000000000000000000000..9f5b5e5acc41faf089ab9e3c8a78aef04bf4e60c
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/tui/scenarios/history_realpath_key.py
@@ -0,0 +1,37 @@
+"""Verify history is keyed by the workspace real path.
+
+1. Run two workspace views that resolve to the same real path.
+2. Observe history lookup and the final process status.
+3. Require the completion token without a crash signature.
+4. Pass only when the real-path key is honored.
+"""
+
+from doc2harness.benchmark.harnesses.tui.contracts import (
+    TuiApplicability, TuiEvaluation, TuiObservation, TuiOutcome, TuiScenario,
+    evaluation_digest,
+)
+
+from ..recipes import scenario_by_id
+
+SCENARIO_ID = "history_realpath_key"
+SCENARIO: TuiScenario = scenario_by_id(SCENARIO_ID)
+RECIPE = SCENARIO.recipe
+STEPS = (RECIPE,)
+scenario = SCENARIO
+definition = SCENARIO.definition
+
+
+def judge(observation: TuiObservation) -> TuiEvaluation:
+    text = observation.screen_text
+    bind = RECIPE.oracle
+    live = bool(text.strip())
+    passed = live and bind.completion_token in text and not any(
+        token in text for token in bind.crash_signatures
+    )
+    return TuiEvaluation(SCENARIO_ID, TuiOutcome.PASS if passed else TuiOutcome.FAIL,
+                         TuiApplicability.APPLICABLE if live else TuiApplicability.INCONCLUSIVE,
+                         "TUI_PROFILE_CHECKED", evaluation_digest(SCENARIO, observation),
+                         SCENARIO.definition.weight_microunits if live else 0)
+
+
+__all__ = ["RECIPE", "SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/tui/scenarios/history_workspace_a_fresh_control.py b/code/src/doc2harness/benchmark/harnesses/tui/scenarios/history_workspace_a_fresh_control.py
new file mode 100644
index 0000000000000000000000000000000000000000..a7af9120241c3ebeb493c530f24103b289cefbc3
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/tui/scenarios/history_workspace_a_fresh_control.py
@@ -0,0 +1,37 @@
+"""Verify a fresh workspace starts with an isolated history control.
+
+1. Start the workspace with an empty history store.
+2. Observe the initial history state and process status.
+3. Require the completion token without a crash signature.
+4. Pass only when no stale history is inherited.
+"""
+
+from doc2harness.benchmark.harnesses.tui.contracts import (
+    TuiApplicability, TuiEvaluation, TuiObservation, TuiOutcome, TuiScenario,
+    evaluation_digest,
+)
+
+from ..recipes import scenario_by_id
+
+SCENARIO_ID = "history_workspace_a_fresh_control"
+SCENARIO: TuiScenario = scenario_by_id(SCENARIO_ID)
+RECIPE = SCENARIO.recipe
+STEPS = (RECIPE,)
+scenario = SCENARIO
+definition = SCENARIO.definition
+
+
+def judge(observation: TuiObservation) -> TuiEvaluation:
+    text = observation.screen_text
+    bind = RECIPE.oracle
+    live = bool(text.strip())
+    passed = live and bind.completion_token in text and not any(
+        token in text for token in bind.crash_signatures
+    )
+    return TuiEvaluation(SCENARIO_ID, TuiOutcome.PASS if passed else TuiOutcome.FAIL,
+                         TuiApplicability.APPLICABLE if live else TuiApplicability.INCONCLUSIVE,
+                         "TUI_PROFILE_CHECKED", evaluation_digest(SCENARIO, observation),
+                         SCENARIO.definition.weight_microunits if live else 0)
+
+
+__all__ = ["RECIPE", "SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/tui/scenarios/history_workspace_b_fresh_control.py b/code/src/doc2harness/benchmark/harnesses/tui/scenarios/history_workspace_b_fresh_control.py
new file mode 100644
index 0000000000000000000000000000000000000000..ef6cc56e1c7625792b0ac1461a78b68d37d9889d
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/tui/scenarios/history_workspace_b_fresh_control.py
@@ -0,0 +1,37 @@
+"""Verify a second fresh workspace has isolated history.
+
+1. Start workspace B with an empty history store.
+2. Observe its initial history and process status.
+3. Require completion without a crash signature.
+4. Pass only when workspace A history is not inherited.
+"""
+
+from doc2harness.benchmark.harnesses.tui.contracts import (
+    TuiApplicability, TuiEvaluation, TuiObservation, TuiOutcome, TuiScenario,
+    evaluation_digest,
+)
+
+from ..recipes import scenario_by_id
+
+SCENARIO_ID = "history_workspace_b_fresh_control"
+SCENARIO: TuiScenario = scenario_by_id(SCENARIO_ID)
+RECIPE = SCENARIO.recipe
+STEPS = (RECIPE,)
+scenario = SCENARIO
+definition = SCENARIO.definition
+
+
+def judge(observation: TuiObservation) -> TuiEvaluation:
+    text = observation.screen_text
+    bind = RECIPE.oracle
+    live = bool(text.strip())
+    passed = live and bind.completion_token in text and not any(
+        token in text for token in bind.crash_signatures
+    )
+    return TuiEvaluation(SCENARIO_ID, TuiOutcome.PASS if passed else TuiOutcome.FAIL,
+                         TuiApplicability.APPLICABLE if live else TuiApplicability.INCONCLUSIVE,
+                         "TUI_PROFILE_CHECKED", evaluation_digest(SCENARIO, observation),
+                         SCENARIO.definition.weight_microunits if live else 0)
+
+
+__all__ = ["RECIPE", "SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/tui/scenarios/trajectory_autocommit_fail_recorded.py b/code/src/doc2harness/benchmark/harnesses/tui/scenarios/trajectory_autocommit_fail_recorded.py
new file mode 100644
index 0000000000000000000000000000000000000000..4f6c486dedf8ba567c9e5323548f99c59c9fe654
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/tui/scenarios/trajectory_autocommit_fail_recorded.py
@@ -0,0 +1,19 @@
+"""Require an autocommit failure and its cause in the trajectory.
+
+1. Run a write with an isolated failing Git hook or signing program.
+2. Observe the persisted trajectory and dynamic failure token.
+3. Require explicit auto-commit ownership and failure semantics.
+"""
+from doc2harness.benchmark.definition import ScenarioRole
+from ..adapter import build_scenario, make_judge
+
+SCENARIO_ID = "trajectory_autocommit_fail_recorded"
+SCENARIO = build_scenario(SCENARIO_ID, ScenarioRole.TARGET, "trajectory_autocommit_fail_recorded_control", "gpg_fail")
+RECIPE = SCENARIO.recipe
+STEPS = (RECIPE,)
+scenario = SCENARIO
+definition = SCENARIO.definition
+_judge = make_judge(SCENARIO, "autocommit_fail")
+def judge(observation):
+    return _judge(observation)
+__all__ = ["RECIPE", "SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/tui/scenarios/trajectory_autocommit_fail_recorded_control.py b/code/src/doc2harness/benchmark/harnesses/tui/scenarios/trajectory_autocommit_fail_recorded_control.py
new file mode 100644
index 0000000000000000000000000000000000000000..22fabd22b2fc60582e14214968507544094927c4
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/tui/scenarios/trajectory_autocommit_fail_recorded_control.py
@@ -0,0 +1,14 @@
+"""Control for the autocommit-failure trajectory stimulus."""
+from doc2harness.benchmark.definition import ScenarioRole
+from ..adapter import build_scenario, make_judge
+
+SCENARIO_ID = "trajectory_autocommit_fail_recorded_control"
+SCENARIO = build_scenario(SCENARIO_ID, ScenarioRole.CONTROL, None, "seq_probe")
+RECIPE = SCENARIO.recipe
+STEPS = (RECIPE,)
+scenario = SCENARIO
+definition = SCENARIO.definition
+_judge = make_judge(SCENARIO, "autocommit_fail")
+def judge(observation):
+    return _judge(observation)
+__all__ = ["RECIPE", "SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/tui/scenarios/trajectory_step_limit_terminal_accurate.py b/code/src/doc2harness/benchmark/harnesses/tui/scenarios/trajectory_step_limit_terminal_accurate.py
new file mode 100644
index 0000000000000000000000000000000000000000..156ab183a4a8d952f23f256db1859d17d8286ca1
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/tui/scenarios/trajectory_step_limit_terminal_accurate.py
@@ -0,0 +1,19 @@
+"""Require an explicit step-limit terminal event in the trajectory.
+
+1. Run the bounded PTY conversation against the normal mock gateway.
+2. Observe the externally persisted trajectory rather than recorder facts.
+3. Require both a limit marker and a terminal event; ordinary completion is insufficient.
+"""
+from doc2harness.benchmark.definition import ScenarioRole
+from ..adapter import build_scenario, make_judge
+
+SCENARIO_ID = "trajectory_step_limit_terminal_accurate"
+SCENARIO = build_scenario(SCENARIO_ID, ScenarioRole.TARGET, "trajectory_step_limit_terminal_accurate_control", "seq_probe")
+RECIPE = SCENARIO.recipe
+STEPS = (RECIPE,)
+scenario = SCENARIO
+definition = SCENARIO.definition
+_judge = make_judge(SCENARIO, "step_limit")
+def judge(observation):
+    return _judge(observation)
+__all__ = ["RECIPE", "SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/tui/scenarios/trajectory_step_limit_terminal_accurate_control.py b/code/src/doc2harness/benchmark/harnesses/tui/scenarios/trajectory_step_limit_terminal_accurate_control.py
new file mode 100644
index 0000000000000000000000000000000000000000..56b1af126ea2187121e278f99fd64456a0751a5b
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/tui/scenarios/trajectory_step_limit_terminal_accurate_control.py
@@ -0,0 +1,19 @@
+"""Control for an externally observed step-limit terminal trajectory.
+
+1. Run the bounded PTY conversation against the normal mock gateway.
+2. Observe requests, exit status, cleanup, and trajectory files.
+3. Establish that the stimulus and terminal channel are live.
+"""
+from doc2harness.benchmark.definition import ScenarioRole
+from ..adapter import build_scenario, make_judge
+
+SCENARIO_ID = "trajectory_step_limit_terminal_accurate_control"
+SCENARIO = build_scenario(SCENARIO_ID, ScenarioRole.CONTROL, None, "seq_probe")
+RECIPE = SCENARIO.recipe
+STEPS = (RECIPE,)
+scenario = SCENARIO
+definition = SCENARIO.definition
+_judge = make_judge(SCENARIO, "step_limit")
+def judge(observation):
+    return _judge(observation)
+__all__ = ["RECIPE", "SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/tui/scenarios/tui_bang_alone_enters_shell_mode.py b/code/src/doc2harness/benchmark/harnesses/tui/scenarios/tui_bang_alone_enters_shell_mode.py
new file mode 100644
index 0000000000000000000000000000000000000000..3fa967dd4459a0e90381f4ef2bb21ff8e85c0beb
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/tui/scenarios/tui_bang_alone_enters_shell_mode.py
@@ -0,0 +1,50 @@
+"""Verify a standalone bang enters shell mode and returns cleanly.
+
+1. Submit the standalone bang command and observe shell-mode output.
+2. Submit the follow-up probe turn.
+3. Require completion without a crash signature.
+4. Pass only when shell-mode interaction remains usable.
+"""
+
+from doc2harness.benchmark.harnesses.tui.contracts import (
+    TuiApplicability, TuiEvaluation, TuiObservation, TuiOutcome, TuiScenario,
+    evaluation_digest,
+)
+
+from ..recipes import scenario_by_id
+
+SCENARIO_ID = "tui_bang_alone_enters_shell_mode"
+SCENARIO: TuiScenario = scenario_by_id(SCENARIO_ID)
+RECIPE = SCENARIO.recipe
+STEPS = (RECIPE,)
+scenario = SCENARIO
+definition = SCENARIO.definition
+
+
+def judge(observation: TuiObservation) -> TuiEvaluation:
+    text = observation.screen_text
+    bind = RECIPE.oracle
+    live = bool(text.strip())
+    # The declared oracle for this point is FILE_WRITTEN: the shell line must
+    # really run and leave the file behind.  Judging the survival sentinel
+    # instead asks whether the *driver's own* closing line was echoed, which a
+    # session answers whether or not the point's line did anything.  Read the
+    # file the recipe
+    # declared, exactly as the shared oracle for this profile does.
+    item = next(
+        (entry for entry in observation.files if entry.path == bind.path), None,
+    )
+    passed = (
+        live
+        and item is not None
+        and item.present
+        and bind.primary_token in item.content
+        and not any(token in text for token in bind.crash_signatures)
+    )
+    return TuiEvaluation(SCENARIO_ID, TuiOutcome.PASS if passed else TuiOutcome.FAIL,
+                         TuiApplicability.APPLICABLE if live else TuiApplicability.INCONCLUSIVE,
+                         "TUI_PROFILE_CHECKED", evaluation_digest(SCENARIO, observation),
+                         SCENARIO.definition.weight_microunits if live else 0)
+
+
+__all__ = ["RECIPE", "SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/harnesses/tui/scenarios/tui_ctrl_byte_storm_survives.py b/code/src/doc2harness/benchmark/harnesses/tui/scenarios/tui_ctrl_byte_storm_survives.py
new file mode 100644
index 0000000000000000000000000000000000000000..fd2c74111d5b3b255921370db05f19db8a4ea6ec
--- /dev/null
+++ b/code/src/doc2harness/benchmark/harnesses/tui/scenarios/tui_ctrl_byte_storm_survives.py
@@ -0,0 +1,47 @@
+"""Verify a control-byte storm leaves the TUI alive.
+
+1. Feed the control-byte fixture and wait for completion.
+2. Observe the final screen text and process status.
+3. Require the completion marker and no crash signature.
+4. Pass only when the TUI survives the input storm.
+"""
+
+from doc2harness.benchmark.harnesses.tui.contracts import (
+    TuiApplicability,
+    TuiEvaluation,
+    TuiObservation,
+    TuiOutcome,
+    TuiScenario,
+    evaluation_digest,
+)
+
+from ..recipes import scenario_by_id
+
+SCENARIO_ID = "tui_ctrl_byte_storm_survives"
+SCENARIO: TuiScenario = scenario_by_id(SCENARIO_ID)
+RECIPE = SCENARIO.recipe
+STEPS = (RECIPE,)
+scenario = SCENARIO
+definition = SCENARIO.definition
+
+
+def judge(observation: TuiObservation) -> TuiEvaluation:
+    text = observation.screen_text
+    bind = RECIPE.oracle
+    live = bool(text.strip())
+    passed = (
+        live
+        and bind.completion_token in text
+        and not any(token in text for token in bind.crash_signatures)
+    )
+    return TuiEvaluation(
+        SCENARIO_ID,
+        TuiOutcome.PASS if passed else TuiOutcome.FAIL,
+        TuiApplicability.APPLICABLE if live else TuiApplicability.INCONCLUSIVE,
+        "TUI_PROFILE_CHECKED",
+        evaluation_digest(SCENARIO, observation),
+        SCENARIO.definition.weight_microunits if live else 0,
+    )
+
+
+__all__ = ["RECIPE", "SCENARIO", "STEPS", "definition", "judge", "scenario"]
diff --git a/code/src/doc2harness/benchmark/taxonomy.py b/code/src/doc2harness/benchmark/taxonomy.py
new file mode 100644
index 0000000000000000000000000000000000000000..d1615c789e88f15e669dab0d79320a36efdf2f47
--- /dev/null
+++ b/code/src/doc2harness/benchmark/taxonomy.py
@@ -0,0 +1,139 @@
+"""Closed taxonomy types and fail-closed source-loading boundary."""
+
+from __future__ import annotations
+
+import tomllib
+import unicodedata
+from dataclasses import dataclass
+from typing import Any
+
+from doc2harness.benchmark.definition import Classification
+from doc2harness.contracts.primitives import ContractDocumentError
+
+_MAX_ENTRIES = 4096
+_MAX_SOURCE_BYTES = 1_048_576
+_MAX_SOURCE_LINES = 16_384
+_MAX_LINE_BYTES = 8_192
+_MAX_DEPTH = 5
+
+
+@dataclass(frozen=True, slots=True)
+class TaxonomyEntry:
+    function_id: str
+    title: str
+
+    def __post_init__(self) -> None:
+        Classification(self.function_id)
+        if type(self.title) is not str or not self.title or len(self.title) > 256:
+            raise ContractDocumentError("taxonomy title must be a bounded non-empty string")
+        if unicodedata.normalize("NFC", self.title) != self.title:
+            raise ContractDocumentError("taxonomy title must be Unicode NFC")
+        if self.title != self.title.strip() or any(
+            ord(char) < 32
+            or 0x7F <= ord(char) <= 0x9F
+            or ord(char) in {0x2028, 0x2029}
+            or 0xD800 <= ord(char) <= 0xDFFF
+            for char in self.title
+        ):
+            raise ContractDocumentError("taxonomy title is not canonical")
+
+
+@dataclass(frozen=True, slots=True)
+class Taxonomy:
+    entries: tuple[TaxonomyEntry, ...]
+
+    def __post_init__(self) -> None:
+        if type(self.entries) is not tuple or not self.entries:
+            raise ContractDocumentError("taxonomy must contain an exact non-empty tuple")
+        if len(self.entries) > _MAX_ENTRIES:
+            raise ContractDocumentError("taxonomy exceeds the entry limit")
+        if any(type(item) is not TaxonomyEntry for item in self.entries):
+            raise ContractDocumentError("taxonomy entries must use TaxonomyEntry")
+        identities = tuple(item.function_id for item in self.entries)
+        if identities != tuple(sorted(identities)) or len(set(identities)) != len(identities):
+            raise ContractDocumentError("taxonomy identities must be sorted and unique")
+
+
+def _source_text(raw: bytes, name: str) -> str:
+    if type(raw) is not bytes:
+        raise ContractDocumentError(f"{name} source must be exact bytes")
+    if not raw or len(raw) > _MAX_SOURCE_BYTES:
+        raise ContractDocumentError(f"{name} source must be bounded and non-empty")
+    if raw.startswith(b"\xef\xbb\xbf") or b"\x00" in raw or b"\r" in raw:
+        raise ContractDocumentError(f"{name} source encoding is not canonical")
+    lines = raw.split(b"\n")
+    if len(lines) > _MAX_SOURCE_LINES or any(len(line) > _MAX_LINE_BYTES for line in lines):
+        raise ContractDocumentError(f"{name} source layout exceeds limits")
+    try:
+        text = raw.decode("utf-8", errors="strict")
+    except UnicodeDecodeError:
+        raise ContractDocumentError(f"{name} source is not UTF-8") from None
+    if unicodedata.normalize("NFC", text) != text:
+        raise ContractDocumentError(f"{name} source must be Unicode NFC")
+    return text
+
+
+def _depth(value: object, level: int = 1) -> int:
+    if type(value) in {dict, list} and level > _MAX_DEPTH:
+        raise ContractDocumentError("TOML container depth exceeds limit")
+    if type(value) is dict:
+        for item in value.values():
+            _depth(item, level + 1)
+    elif type(value) is list:
+        for item in value:
+            _depth(item, level + 1)
+    return level
+
+
+def _parse_closed_toml(raw: bytes, name: str) -> dict[str, Any]:
+    text = _source_text(raw, name)
+    try:
+        value = tomllib.loads(text)
+    except (tomllib.TOMLDecodeError, ValueError):
+        raise ContractDocumentError(f"{name} source is not valid closed TOML") from None
+    if type(value) is not dict:
+        raise ContractDocumentError(f"{name} source must be a table")
+    _depth(value)
+    return value
+
+
+def _exact_keys(value: object, keys: frozenset[str], name: str) -> dict[str, Any]:
+    if type(value) is not dict or set(value) != keys:
+        raise ContractDocumentError(f"{name} has an invalid closed shape")
+    return value
+
+
+def parse_taxonomy(raw: bytes, /) -> Taxonomy:
+    """Parse one closed, canonical taxonomy source."""
+
+    source = _exact_keys(
+        _parse_closed_toml(raw, "taxonomy"),
+        frozenset({"format", "functions"}),
+        "taxonomy",
+    )
+    if source["format"] != "doc2harness.taxonomy-source/1":
+        raise ContractDocumentError("taxonomy format is unsupported")
+    functions = source["functions"]
+    if type(functions) is not list or not functions or len(functions) > _MAX_ENTRIES:
+        raise ContractDocumentError("taxonomy functions must be a bounded non-empty array")
+    entries: list[TaxonomyEntry] = []
+    for item in functions:
+        row = _exact_keys(item, frozenset({"function_id", "title"}), "taxonomy function")
+        entries.append(TaxonomyEntry(row["function_id"], row["title"]))
+    return Taxonomy(tuple(entries))
+
+
+def validate_classification(value: Classification, taxonomy: Taxonomy, /) -> None:
+    """Validate a typed classification against a closed in-memory taxonomy."""
+
+    if type(value) is not Classification or type(taxonomy) is not Taxonomy:
+        raise ContractDocumentError("classification validation requires exact typed values")
+    known = frozenset(item.function_id for item in taxonomy.entries)
+    unknown = frozenset((value.primary, *value.secondary)) - known
+    if unknown:
+        raise ContractDocumentError(f"classification contains unknown functions: {sorted(unknown)!r}")
+
+
+__all__ = [
+    "Taxonomy", "TaxonomyEntry", "parse_taxonomy", "validate_classification",
+]
diff --git a/code/src/doc2harness/benchmark/taxonomy.toml b/code/src/doc2harness/benchmark/taxonomy.toml
new file mode 100644
index 0000000000000000000000000000000000000000..1997d8a3e9bdff3e473f36dc78c16d72c41365bd
--- /dev/null
+++ b/code/src/doc2harness/benchmark/taxonomy.toml
@@ -0,0 +1,37 @@
+format = "doc2harness.taxonomy-source/1"
+
+[[functions]]
+function_id = "artifact"
+title = "Static artifact"
+
+[[functions]]
+function_id = "direct"
+title = "Direct mock process"
+
+[[functions]]
+function_id = "extension"
+title = "Extension discovery counterfactual"
+
+[[functions]]
+function_id = "file"
+title = "Child-process file tools"
+
+[[functions]]
+function_id = "headless"
+title = "Headless CLI behavior"
+
+[[functions]]
+function_id = "permission"
+title = "Child-process permission"
+
+[[functions]]
+function_id = "startup"
+title = "Startup behavior"
+
+[[functions]]
+function_id = "state"
+title = "Child-process state"
+
+[[functions]]
+function_id = "tui"
+title = "TUI PTY behavior"
diff --git a/code/src/doc2harness/contracts/__init__.py b/code/src/doc2harness/contracts/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..a394c758e9799df47172bb7e37f50a465a3d56b9
--- /dev/null
+++ b/code/src/doc2harness/contracts/__init__.py
@@ -0,0 +1,3 @@
+"""Canonical JSON and digest primitives shared by the catalog and the runtime."""
+
+__all__: list[str] = []
diff --git a/code/src/doc2harness/contracts/canonical.py b/code/src/doc2harness/contracts/canonical.py
new file mode 100644
index 0000000000000000000000000000000000000000..a5d940ad5a1e0a6abb89b17a9700d295184dbd81
--- /dev/null
+++ b/code/src/doc2harness/contracts/canonical.py
@@ -0,0 +1,82 @@
+"""Strict canonical JSON primitives for immutable contract documents."""
+
+from __future__ import annotations
+
+import json
+import unicodedata
+from collections.abc import Mapping, Sequence
+from typing import Any
+
+_MAX_DOCUMENT_BYTES = 8 * 1024 * 1024
+_MAX_DEPTH = 64
+_MAX_KEYS = 100_000
+_MAX_STRING_LENGTH = 1 * 1024 * 1024
+_MIN_INTEGER = -(2**63)
+_MAX_INTEGER = 2**63 - 1
+
+
+class CanonicalJsonError(ValueError):
+    """Raised when a value is outside the canonical v1 JSON subset."""
+
+
+def _validate(value: Any, *, depth: int, counters: dict[str, int]) -> None:
+    if depth > _MAX_DEPTH:
+        raise CanonicalJsonError("maximum nesting depth exceeded")
+
+    if value is None or isinstance(value, bool):
+        return
+    if isinstance(value, int):
+        if not _MIN_INTEGER <= value <= _MAX_INTEGER:
+            raise CanonicalJsonError("integer is outside the signed 64-bit range")
+        return
+    if isinstance(value, float):
+        raise CanonicalJsonError("floating-point values are forbidden")
+    if isinstance(value, str):
+        if len(value) > _MAX_STRING_LENGTH:
+            raise CanonicalJsonError("maximum string length exceeded")
+        try:
+            value.encode("utf-8", errors="strict")
+        except UnicodeEncodeError as error:
+            raise CanonicalJsonError("string is not valid Unicode scalar text") from error
+        return
+    if isinstance(value, Mapping):
+        counters["keys"] += len(value)
+        if counters["keys"] > _MAX_KEYS:
+            raise CanonicalJsonError("maximum object-key count exceeded")
+        for key, item in value.items():
+            if not isinstance(key, str):
+                raise CanonicalJsonError("object keys must be strings")
+            if unicodedata.normalize("NFC", key) != key:
+                raise CanonicalJsonError("object keys must already be Unicode NFC")
+            _validate(key, depth=depth + 1, counters=counters)
+            _validate(item, depth=depth + 1, counters=counters)
+        return
+    if isinstance(value, Sequence) and not isinstance(
+        value, (str, bytes, bytearray, memoryview)
+    ):
+        for item in value:
+            _validate(item, depth=depth + 1, counters=counters)
+        return
+    raise CanonicalJsonError(f"unsupported value type: {type(value).__name__}")
+
+
+def canonical_json(value: Any) -> bytes:
+    """Encode a value as canonical v1 JSON bytes."""
+
+    _validate(value, depth=0, counters={"keys": 0})
+    try:
+        encoded = json.dumps(
+            value,
+            ensure_ascii=False,
+            allow_nan=False,
+            sort_keys=True,
+            separators=(",", ":"),
+        ).encode("utf-8", errors="strict")
+    except (TypeError, ValueError, UnicodeEncodeError) as error:
+        raise CanonicalJsonError("value cannot be encoded as canonical JSON") from error
+    if len(encoded) > _MAX_DOCUMENT_BYTES:
+        raise CanonicalJsonError("maximum document size exceeded")
+    return encoded
+
+
+__all__ = ["CanonicalJsonError", "canonical_json"]
diff --git a/code/src/doc2harness/contracts/primitives.py b/code/src/doc2harness/contracts/primitives.py
new file mode 100644
index 0000000000000000000000000000000000000000..e1910519865381f3ba3a64201edc5cc59f157e49
--- /dev/null
+++ b/code/src/doc2harness/contracts/primitives.py
@@ -0,0 +1,38 @@
+"""Validation helpers shared by contract documents."""
+
+from __future__ import annotations
+
+import re
+import unicodedata
+from typing import Any
+
+from doc2harness.contracts.canonical import (
+    CanonicalJsonError,
+)
+
+_DIGEST = re.compile(r"sha256:[0-9a-f]{64}\Z", re.ASCII)
+
+
+class ContractDocumentError(ValueError):
+    """Raised when an immutable contract envelope fails closed validation."""
+
+
+def require_string(value: Any, *, name: str, nfc: bool = True) -> str:
+    if not isinstance(value, str):
+        raise ContractDocumentError(f"{name} must be a string")
+    if nfc and unicodedata.normalize("NFC", value) != value:
+        raise ContractDocumentError(f"{name} must already be Unicode NFC")
+    return value
+
+
+def require_digest(value: Any, *, name: str) -> str:
+    parsed = require_string(value, name=name, nfc=False)
+    if _DIGEST.fullmatch(parsed) is None:
+        raise ContractDocumentError(f"{name} is not a v1 SHA-256 digest")
+    return parsed
+
+
+__all__ = [
+    "CanonicalJsonError",
+    "ContractDocumentError",
+]
diff --git a/code/src/doc2harness/runtime/__init__.py b/code/src/doc2harness/runtime/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..1bb47dd63e0caa96d95de8292902c4ff4367cf30
--- /dev/null
+++ b/code/src/doc2harness/runtime/__init__.py
@@ -0,0 +1,11 @@
+"""Fail-closed local runtime framework."""
+from doc2harness.runtime.errors import RuntimeBoundaryError, RuntimeCapabilityUnavailable
+from doc2harness.runtime.artifact_executor import ArtifactExecutionError, ArtifactExecutionRequest, artifact_tree_digest, load_typed_event_document, require_typed_event_hook_abi, run_artifact_driver
+from doc2harness.runtime.artifact_store import canonical_artifact_digest
+from doc2harness.runtime.catalog_executor import CatalogExecutionError, CatalogExecutionRequest, run_catalog
+
+__all__ = [
+    "ArtifactExecutionError", "ArtifactExecutionRequest", "artifact_tree_digest", "canonical_artifact_digest", "load_typed_event_document", "require_typed_event_hook_abi", "run_artifact_driver", "CatalogExecutionError", "CatalogExecutionRequest", "run_catalog",
+    "RuntimeBoundaryError",
+    "RuntimeCapabilityUnavailable",
+]
diff --git a/code/src/doc2harness/runtime/artifact_executor.py b/code/src/doc2harness/runtime/artifact_executor.py
new file mode 100644
index 0000000000000000000000000000000000000000..85de140d13bd5474fbefe818a0b1c069f870b42b
--- /dev/null
+++ b/code/src/doc2harness/runtime/artifact_executor.py
@@ -0,0 +1,234 @@
+"""Fail-closed execution boundary for reviewed production artifact drivers.
+
+The executor owns only the process boundary.  A harness-specific driver owns
+fixture materialisation and recorder hooks; it must publish typed facts through
+the declared side channel.  stdout, stderr, and trajectory text are
+diagnostics and are never promoted to benchmark evidence.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+import shutil
+import subprocess
+import tempfile
+from collections.abc import Mapping
+from dataclasses import dataclass
+from pathlib import Path
+
+from doc2harness.contracts.primitives import ContractDocumentError
+from doc2harness.runtime.artifact_store import canonical_artifact_digest
+from doc2harness.runtime.errors import RuntimeBoundaryError
+
+_DIGEST = re.compile(r"sha256:[0-9a-f]{64}\Z", re.ASCII)
+_HOOK_RELATIVE = Path(".d2a_spec") / "typed_event_hooks.json"
+
+
+class ArtifactExecutionError(RuntimeBoundaryError):
+    """A stable, path-free failure from the production artifact boundary."""
+
+
+@dataclass(frozen=True, slots=True)
+class ArtifactExecutionRequest:
+    """Inputs for one driver invocation against an immutable source artifact."""
+
+    artifact: Path
+    driver_root: Path
+    driver_argv: tuple[str, ...]
+    output: Path
+    source_digest: str
+    task_digest: str
+    budget_digest: str
+    artifact_digest: str
+    timeout_seconds: float = 900.0
+
+    def __post_init__(self) -> None:
+        if not isinstance(self.artifact, Path) or not isinstance(self.driver_root, Path):
+            raise ContractDocumentError("artifact execution paths must use Path")
+        if not isinstance(self.output, Path):
+            raise ContractDocumentError("artifact execution output must use Path")
+        if type(self.driver_argv) is not tuple or not self.driver_argv:
+            raise ContractDocumentError("artifact driver argv must be non-empty")
+        if any(type(item) is not str or not item or "\0" in item for item in self.driver_argv):
+            raise ContractDocumentError("artifact driver argv contains an invalid item")
+        for value, name in (
+            (self.source_digest, "source digest"),
+            (self.task_digest, "task digest"),
+            (self.budget_digest, "budget digest"),
+            (self.artifact_digest, "artifact digest"),
+        ):
+            if type(value) is not str or _DIGEST.fullmatch(value) is None:
+                raise ContractDocumentError(f"{name} is invalid")
+        if type(self.timeout_seconds) not in {int, float} or not 0 < self.timeout_seconds <= 3600:
+            raise ContractDocumentError("artifact execution timeout is invalid")
+
+
+def artifact_tree_digest(root: Path, /) -> str:
+    """Hash a source tree with the verified artifact-store algorithm."""
+
+    if not isinstance(root, Path) or not root.is_dir() or not (root / "run_agent.sh").is_file():
+        raise ArtifactExecutionError("SBH-ARTIFACT-UNAVAILABLE", "artifact is unavailable")
+    try:
+        return canonical_artifact_digest(root)
+    except (OSError, UnicodeError, ValueError, RuntimeBoundaryError):
+        raise ArtifactExecutionError("SBH-ARTIFACT-SCAN", "artifact tree cannot be scanned") from None
+
+
+def require_typed_event_hook_abi(root: Path, /) -> dict[str, object]:
+    """Require the reviewed side-channel declaration on the driver package."""
+
+    marker = root / _HOOK_RELATIVE
+    try:
+        value = json.loads(marker.read_text(encoding="utf-8"))
+    except (OSError, UnicodeError, json.JSONDecodeError):
+        raise ArtifactExecutionError(
+            "SBH-TYPED-HOOK-ABI", "typed event hook ABI is missing or invalid"
+        ) from None
+    required = {"schema", "tool_lifecycle", "subprocess", "workspace", "cleanup"}
+    if (
+        not isinstance(value, dict)
+        or set(value) != required
+        or value.get("schema") != "doc2harness.typed-event-hooks/1"
+        or any(value.get(name) is not True for name in required - {"schema"})
+    ):
+        raise ArtifactExecutionError("SBH-TYPED-HOOK-ABI", "typed event hook ABI is incomplete")
+    return value
+
+
+def _stderr_hint(stderr: bytes | str | None, scratch: str) -> str:
+    """The driver's final stderr line, with host paths removed.
+
+    Closed errors must not leak filesystem layout, so the private scratch root
+    is replaced and any remaining absolute path is reduced to its basename.
+    What survives -- an exception type, a missing key, a docker refusal -- is
+    the part that says which failure this was.
+    """
+
+    if not stderr:
+        return ""
+    text = stderr.decode("utf-8", "replace") if isinstance(stderr, bytes) else stderr
+    lines = [line.strip() for line in text.strip().splitlines() if line.strip()]
+    if not lines:
+        return ""
+    last = lines[-1].replace(scratch, "<scratch>")
+    last = re.sub(r"(?<![\w/])/[\w./+-]{3,}", lambda m: m.group(0).rsplit("/", 1)[-1], last)
+    return f": {last[:300]}"
+
+
+def load_typed_event_document(
+    path: Path,
+    *,
+    source_digest: str,
+    task_digest: str,
+    budget_digest: str,
+    artifact_digest: str,
+) -> dict[str, object]:
+    """Load and bind one driver-produced typed-event envelope."""
+
+    expected = {
+        "source_digest": source_digest,
+        "task_digest": task_digest,
+        "budget_digest": budget_digest,
+        "artifact_digest": artifact_digest,
+    }
+    if any(_DIGEST.fullmatch(value) is None for value in expected.values()):
+        raise ContractDocumentError("typed event invocation binding is invalid")
+    try:
+        value = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, UnicodeError, json.JSONDecodeError):
+        raise ArtifactExecutionError("SBH-TYPED-EVENTS", "typed event output is unreadable") from None
+    if not isinstance(value, dict) or value.get("schema") != "doc2harness.typed-events/1":
+        raise ArtifactExecutionError("SBH-TYPED-EVENTS", "typed event schema is unsupported")
+    for name, digest in expected.items():
+        if value.get(name) != digest:
+            raise ArtifactExecutionError("SBH-TYPED-EVENTS", "typed event binding differs from invocation")
+    events = value.get("events")
+    if not isinstance(events, list) or any(not isinstance(event, dict) for event in events):
+        raise ArtifactExecutionError("SBH-TYPED-EVENTS", "typed event list is invalid")
+    return value
+
+
+def run_artifact_driver(
+    request: ArtifactExecutionRequest,
+    *,
+    environ: Mapping[str, str] | None = None,
+) -> Path:
+    """Run a hook-capable driver against a private artifact copy.
+
+    The source artifact is never edited.  The driver receives only explicit
+    digest bindings and a path to the private copy; its typed side channel is
+    the sole accepted source of observations.
+    """
+
+    source_digest = artifact_tree_digest(request.artifact)
+    if source_digest != request.artifact_digest:
+        raise ArtifactExecutionError("SBH-ARTIFACT-IDENTITY", "artifact identity differs from request")
+    require_typed_event_hook_abi(request.driver_root)
+    request.output.parent.mkdir(parents=True, exist_ok=True)
+    child_env = dict(os.environ)
+    if environ is not None:
+        child_env.update(environ)
+    with tempfile.TemporaryDirectory(prefix="sbh-artifact-") as temporary:
+        private_artifact = Path(temporary) / "artifact"
+        typed_output = Path(temporary) / "typed_events.json"
+        shutil.copytree(request.artifact, private_artifact)
+        child_env.update(
+            {
+                "SBH_ARTIFACT_PATH": str(private_artifact),
+                "SBH_TYPED_EVENT_PATH": str(typed_output),
+                "SBH_SOURCE_DIGEST": request.source_digest,
+                "SBH_TASK_DIGEST": request.task_digest,
+                "SBH_BUDGET_DIGEST": request.budget_digest,
+                "SBH_ARTIFACT_DIGEST": request.artifact_digest,
+            }
+        )
+        try:
+            completed = subprocess.run(
+                request.driver_argv,
+                cwd=private_artifact,
+                env=child_env,
+                stdin=subprocess.DEVNULL,
+                capture_output=True,
+                timeout=request.timeout_seconds,
+                check=False,
+            )
+        except subprocess.TimeoutExpired:
+            raise ArtifactExecutionError("SBH-ARTIFACT-TIMEOUT", "artifact driver timed out") from None
+        except OSError:
+            raise ArtifactExecutionError("SBH-ARTIFACT-DRIVER", "artifact driver could not start") from None
+        if completed.returncode != 0:
+            # Carry the driver's own last words.  Without them every driver
+            # crash -- a missing binary, a scenario bug, a transient docker
+            # refusal -- arrives as the same five words, and the only way to
+            # learn which one happened is to re-run the driver by hand outside
+            # the executor, rebuilding this environment from memory.  The
+            # closed-error rule bars host paths and raw output, so the tail is
+            # scrubbed of both before it is attached.
+            raise ArtifactExecutionError(
+                "SBH-ARTIFACT-DRIVER",
+                f"artifact driver failed (rc={completed.returncode})"
+                f"{_stderr_hint(completed.stderr, temporary)}",
+            )
+        if not typed_output.is_file():
+            raise ArtifactExecutionError("SBH-TYPED-EVENTS", "artifact driver produced no typed event output")
+        load_typed_event_document(
+            typed_output,
+            source_digest=request.source_digest,
+            task_digest=request.task_digest,
+            budget_digest=request.budget_digest,
+            artifact_digest=request.artifact_digest,
+        )
+        request.output.write_bytes(typed_output.read_bytes())
+    return request.output
+
+
+__all__ = [
+    "ArtifactExecutionError",
+    "ArtifactExecutionRequest",
+    "artifact_tree_digest",
+    "load_typed_event_document",
+    "require_typed_event_hook_abi",
+    "run_artifact_driver",
+]
diff --git a/code/src/doc2harness/runtime/artifact_static_driver.py b/code/src/doc2harness/runtime/artifact_static_driver.py
new file mode 100644
index 0000000000000000000000000000000000000000..e0500579890a9d566ece63d840f1b8d727aa8f84
--- /dev/null
+++ b/code/src/doc2harness/runtime/artifact_static_driver.py
@@ -0,0 +1,84 @@
+"""Run one ``artifact`` probe against the private artifact copy."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+from dataclasses import asdict
+from pathlib import Path
+
+from doc2harness.runtime.driver_evidence import evidence_digest as _digest
+
+
+def _run_one() -> dict[str, object]:
+    from doc2harness.benchmark.definition import definition_digest
+    from doc2harness.benchmark.dispatch import load_scenario_owner
+    from doc2harness.benchmark.harnesses.artifact.contracts import (
+        ArtifactProbeKind,
+        ArtifactProbeMetrics,
+        create_artifact_probe_observation,
+    )
+
+    scenario_id = os.environ["SBH_SCENARIO_ID"]
+    owner = load_scenario_owner(scenario_id)
+    if ".benchmark.harnesses.artifact." not in owner.module:
+        raise RuntimeError("artifact driver received a non-artifact scenario")
+    scenario = owner.scenario
+    root = Path(os.environ["SBH_ARTIFACT_PATH"])
+    probe = scenario.probe
+    relative = "/".join(probe.paths[0].segments)
+    target = root / relative
+    file_exists = target.is_file()
+    directory_exists = target.is_dir()
+    size_bytes = target.stat().st_size if file_exists and probe.kind is ArtifactProbeKind.FILE_NONEMPTY else None
+    matching_members = None
+    project_marker = None
+    requirements_nonempty = None
+    if probe.kind is ArtifactProbeKind.DIRECTORY_MEMBER_SUFFIX:
+        matching_members = sum(1 for child in target.iterdir() if child.is_file() and child.name.endswith(probe.member_suffix or "")) if directory_exists else 0
+    elif probe.kind is ArtifactProbeKind.DEPENDENCY_DECLARATION:
+        pyproject = root / "pyproject.toml"
+        requirements = root / "requirements.txt"
+        project_marker = pyproject.is_file() and "[project" in pyproject.read_text(encoding="utf-8", errors="replace")
+        requirements_nonempty = requirements.is_file() and requirements.stat().st_size > 0
+    metrics = ArtifactProbeMetrics(
+        file_exists=file_exists if probe.kind in {ArtifactProbeKind.FILE_PRESENT, ArtifactProbeKind.FILE_NONEMPTY} else None,
+        directory_exists=directory_exists if probe.kind is ArtifactProbeKind.DIRECTORY_MEMBER_SUFFIX else None,
+        size_bytes=size_bytes,
+        matching_members=matching_members,
+        project_marker=project_marker,
+        requirements_nonempty=requirements_nonempty,
+    )
+    evidence = (_digest({"path": relative, "exists": file_exists, "directory": directory_exists, "size": size_bytes, "members": matching_members, "project": project_marker, "requirements": requirements_nonempty}),)
+    observation = create_artifact_probe_observation(
+        scenario,
+        os.environ["SBH_ARTIFACT_ID"],
+        os.environ["SBH_ARTIFACT_DIGEST"],
+        metrics,
+        evidence,
+    )
+    return {"observation": observation, "judgement": owner.judge(observation), "module": owner.module,
+            "definition_digest": definition_digest(owner.definition)}
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.parse_args()
+    result = _run_one()
+    target = Path(os.environ["SBH_TYPED_EVENT_PATH"])
+    target.parent.mkdir(parents=True, exist_ok=True)
+    target.write_text(json.dumps({
+        "schema": "doc2harness.typed-events/1",
+        "source_digest": os.environ["SBH_SOURCE_DIGEST"], "task_digest": os.environ["SBH_TASK_DIGEST"],
+        "budget_digest": os.environ["SBH_BUDGET_DIGEST"], "artifact_digest": os.environ["SBH_ARTIFACT_DIGEST"],
+        "artifact_id": os.environ["SBH_ARTIFACT_ID"], "scenario_id": os.environ["SBH_SCENARIO_ID"],
+        "scenario_module": result["module"], "definition_digest": result["definition_digest"],
+        "events": [{"type": "artifact-observation", "observation": asdict(result["observation"]),
+                    "judgement": asdict(result["judgement"])}],
+    }, ensure_ascii=False, default=lambda value: value.value if hasattr(value, "value") else str(value), indent=2) + "\n", encoding="utf-8")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/code/src/doc2harness/runtime/artifact_store.py b/code/src/doc2harness/runtime/artifact_store.py
new file mode 100644
index 0000000000000000000000000000000000000000..8f30a9378ff851266524453b368e093804c782fc
--- /dev/null
+++ b/code/src/doc2harness/runtime/artifact_store.py
@@ -0,0 +1,293 @@
+"""Trusted local artifact materialization for read-only Harness consumers.
+
+The runner-owned locator supplies only a host location.  This store
+independently recomputes the directory digest before transferring the same
+pinned descriptor to the reader.  Python object privacy is not treated as a security
+boundary and no caller-created receipt can authorize bytes.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import os
+import stat
+import unicodedata
+from dataclasses import field as _field
+from doc2harness.runtime.errors import (
+    RuntimeBoundaryError,
+    RuntimeCapabilityUnavailable,
+)
+
+_IGNORED_COMPONENTS = frozenset(
+    {
+        ".git",
+        "node_modules",
+        "__pycache__",
+        ".opencode",
+        ".pytest_cache",
+        ".mypy_cache",
+        ".d2a_spec",
+        ".build-submit",
+        ".build-result",
+    }
+)
+_MAX_DEPTH = 128
+_MAX_NAME_BYTES = 255
+_MAX_ROOT_BYTES = 4096
+_MAX_TREE_BYTES = 512 * 1024 * 1024
+_MAX_MEMBERS = 1_000_000
+_READ_CHUNK = 64 * 1024
+
+
+def _fail(code: str, message: str) -> RuntimeBoundaryError:
+    return RuntimeBoundaryError(code, message)
+
+
+def _safe_component(value: str) -> bool:
+    if type(value) is not str or value in {"", ".", ".."}:
+        return False
+    try:
+        encoded = value.encode("utf-8", "strict")
+    except UnicodeError:
+        return False
+    return (
+        len(encoded) <= _MAX_NAME_BYTES
+        and unicodedata.normalize("NFC", value) == value
+        and "/" not in value
+        and "\\" not in value
+        and "\x00" not in value
+        and all(ord(character) >= 32 and ord(character) != 127 for character in value)
+    )
+
+
+def _directory_flags() -> int:
+    names = ("O_DIRECTORY", "O_NOFOLLOW", "O_CLOEXEC")
+    if any(not hasattr(os, name) for name in names):
+        raise RuntimeCapabilityUnavailable(
+            "SBH-ARTIFACT-UNSUPPORTED",
+            "safe artifact directory access is unavailable",
+        )
+    return os.O_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW | os.O_CLOEXEC
+
+
+def _file_flags() -> int:
+    if not hasattr(os, "O_NOFOLLOW") or not hasattr(os, "O_CLOEXEC"):
+        raise RuntimeCapabilityUnavailable(
+            "SBH-ARTIFACT-UNSUPPORTED",
+            "safe artifact file access is unavailable",
+        )
+    return os.O_RDONLY | os.O_NOFOLLOW | os.O_CLOEXEC | os.O_NONBLOCK
+
+
+def _binding(details: os.stat_result) -> tuple[int, int, int]:
+    return (details.st_dev, details.st_ino, stat.S_IFMT(details.st_mode))
+
+
+def _close_descriptors(*descriptors: int) -> None:
+    """Attempt every owned close and expose only a path-free typed failure."""
+
+    failed = False
+    for descriptor in descriptors:
+        if descriptor < 0:
+            continue
+        try:
+            os.close(descriptor)
+        except OSError:
+            failed = True
+    if failed:
+        raise _fail("SBH-ARTIFACT-INVARIANT", "artifact descriptors did not close safely")
+
+
+def _open_root(
+    root: str | bytes,
+) -> tuple[int, int, tuple[str, ...], tuple[tuple[int, int], ...]]:
+    if type(root) not in {str, bytes}:
+        raise _fail("SBH-ARTIFACT-ROOT", "artifact root is invalid")
+    size = len(root) if type(root) is bytes else len(root.encode("utf-8", "surrogatepass"))
+    decoded = os.fsdecode(root)
+    if (
+        not root
+        or size > _MAX_ROOT_BYTES
+        or not decoded.startswith(os.sep)
+        or decoded.startswith("//")
+        or decoded.endswith(os.sep)
+        or os.path.normpath(decoded) != decoded
+    ):
+        raise _fail("SBH-ARTIFACT-ROOT", "artifact root is invalid")
+    parts = tuple(decoded.split(os.sep)[1:])
+    if not parts or len(parts) > _MAX_DEPTH or any(not _safe_component(part) for part in parts):
+        raise _fail("SBH-ARTIFACT-ROOT", "artifact root is invalid")
+    anchor = current = -1
+    identities: list[tuple[int, int]] = []
+    try:
+        anchor = os.open(os.sep, _directory_flags())
+        current = os.dup(anchor)
+        for component in parts:
+            replacement = os.open(component, _directory_flags(), dir_fd=current)
+            previous = current
+            current = replacement
+            _close_descriptors(previous)
+            details = os.fstat(current)
+            if not stat.S_ISDIR(details.st_mode):
+                raise OSError("artifact root component is not a directory")
+            identities.append((details.st_dev, details.st_ino))
+        return current, anchor, parts, tuple(identities)
+    except (RuntimeBoundaryError, RuntimeCapabilityUnavailable):
+        _close_descriptors(current, anchor)
+        raise
+    except OSError:
+        _close_descriptors(current, anchor)
+        raise _fail("SBH-ARTIFACT-ROOT", "artifact root cannot be opened safely") from None
+
+
+def _read_regular(parent_fd: int, name: str, before: os.stat_result, remaining: int) -> bytes:
+    descriptor = -1
+    try:
+        descriptor = os.open(name, _file_flags(), dir_fd=parent_fd)
+        opened = os.fstat(descriptor)
+        if (
+            _binding(before) != _binding(opened)
+            or before.st_nlink != 1
+            or opened.st_nlink != 1
+            or before.st_size != opened.st_size
+            or opened.st_size > remaining
+        ):
+            raise _fail("SBH-ARTIFACT-UNSAFE", "artifact file identity or size is unsafe")
+        chunks: list[bytes] = []
+        left = opened.st_size
+        while left:
+            chunk = os.read(descriptor, min(_READ_CHUNK, left))
+            if not chunk:
+                raise _fail("SBH-ARTIFACT-UNSAFE", "artifact file changed during verification")
+            chunks.append(chunk)
+            left -= len(chunk)
+        content = b"".join(chunks)
+        after = os.fstat(descriptor)
+        terminal = os.stat(name, dir_fd=parent_fd, follow_symlinks=False)
+        if (
+            _binding(opened) != _binding(after)
+            or _binding(after) != _binding(terminal)
+            or opened.st_size != after.st_size
+            or opened.st_mtime_ns != after.st_mtime_ns
+            or opened.st_ctime_ns != after.st_ctime_ns
+        ):
+            raise _fail("SBH-ARTIFACT-UNSAFE", "artifact file changed during verification")
+        return content
+    except RuntimeBoundaryError:
+        raise
+    except OSError:
+        raise _fail("SBH-ARTIFACT-UNSAFE", "artifact file cannot be verified safely") from None
+    finally:
+        _close_descriptors(descriptor)
+
+
+def _tree_digest(root_fd: int, *, max_tree_bytes: int, max_members: int) -> tuple[str, int, int]:
+    files: list[tuple[str, str]] = []
+    member_count = 0
+    byte_count = 0
+
+    def visit(directory_fd: int, prefix: tuple[str, ...], depth: int) -> None:
+        nonlocal member_count, byte_count
+        if depth > _MAX_DEPTH:
+            raise _fail("SBH-ARTIFACT-OVERSIZE", "artifact tree exceeds the depth limit")
+        try:
+            names = sorted(os.listdir(directory_fd))
+        except OSError:
+            raise _fail("SBH-ARTIFACT-UNSAFE", "artifact directory cannot be enumerated safely") from None
+        for name in names:
+            if not _safe_component(name):
+                raise _fail("SBH-ARTIFACT-UNSAFE", "artifact member name is unsafe")
+            member_count += 1
+            if member_count > max_members:
+                raise _fail("SBH-ARTIFACT-OVERSIZE", "artifact tree exceeds the member limit")
+            if name in _IGNORED_COMPONENTS:
+                continue
+            try:
+                before = os.stat(name, dir_fd=directory_fd, follow_symlinks=False)
+            except OSError:
+                raise _fail("SBH-ARTIFACT-UNSAFE", "artifact member cannot be inspected") from None
+            relative = prefix + (name,)
+            if stat.S_ISLNK(before.st_mode):
+                # Links are never traversal input.  A dangling link is inert,
+                # so it is excluded from the digest; becoming resolvable at any
+                # later verification is a tree mutation and fails closed.
+                try:
+                    os.stat(name, dir_fd=directory_fd, follow_symlinks=True)
+                except FileNotFoundError:
+                    continue
+                except OSError:
+                    raise _fail("SBH-ARTIFACT-UNSAFE", "artifact link cannot be classified safely") from None
+                raise _fail("SBH-ARTIFACT-UNSAFE", "resolvable artifact links are forbidden")
+            if stat.S_ISDIR(before.st_mode):
+                child = -1
+                try:
+                    child = os.open(name, _directory_flags(), dir_fd=directory_fd)
+                    opened = os.fstat(child)
+                    if _binding(before) != _binding(opened):
+                        raise _fail("SBH-ARTIFACT-UNSAFE", "artifact directory identity changed")
+                    visit(child, relative, depth + 1)
+                    after = os.fstat(child)
+                    terminal = os.stat(name, dir_fd=directory_fd, follow_symlinks=False)
+                    if (
+                        _binding(opened) != _binding(after)
+                        or _binding(after) != _binding(terminal)
+                        or opened.st_mtime_ns != after.st_mtime_ns
+                        or opened.st_ctime_ns != after.st_ctime_ns
+                    ):
+                        raise _fail("SBH-ARTIFACT-UNSAFE", "artifact directory changed during verification")
+                except RuntimeBoundaryError:
+                    raise
+                except OSError:
+                    raise _fail("SBH-ARTIFACT-UNSAFE", "artifact directory cannot be verified safely") from None
+                finally:
+                    _close_descriptors(child)
+                continue
+            if not stat.S_ISREG(before.st_mode) or before.st_nlink != 1:
+                raise _fail("SBH-ARTIFACT-UNSAFE", "artifact member type is unsafe")
+            content = _read_regular(directory_fd, name, before, max_tree_bytes - byte_count)
+            byte_count += len(content)
+            files.append(("/".join(relative), hashlib.sha256(content).hexdigest()))
+
+    root_before = os.fstat(root_fd)
+    visit(root_fd, (), 0)
+    root_after = os.fstat(root_fd)
+    if (
+        _binding(root_before) != _binding(root_after)
+        or root_before.st_mtime_ns != root_after.st_mtime_ns
+        or root_before.st_ctime_ns != root_after.st_ctime_ns
+    ):
+        raise _fail("SBH-ARTIFACT-UNSAFE", "artifact root changed during verification")
+    digest = hashlib.sha256()
+    for relative, file_digest in sorted(files):
+        digest.update(relative.encode("utf-8"))
+        digest.update(file_digest.encode("ascii"))
+    return "sha256:" + digest.hexdigest(), member_count, byte_count
+
+
+def canonical_artifact_digest(root: str | os.PathLike[str], /) -> str:
+    """Compute the same digest used by the verified artifact store.
+
+    Production execution must bind to the store's tree digest rather
+    than to a second, weaker path walk.  The descriptor-relative walk also
+    applies the store's ignored-component, symlink, and mutation checks.
+    """
+
+    root_fd, anchor_fd, _, _ = _open_root(os.fspath(root))
+    try:
+        digest, _, _ = _tree_digest(
+            root_fd,
+            max_tree_bytes=_MAX_TREE_BYTES,
+            max_members=_MAX_MEMBERS,
+        )
+        return digest
+    finally:
+        _close_descriptors(root_fd, anchor_fd)
+
+
+# Dataclass construction is complete; keep reflection evidence deterministic.
+del _field
+
+
+__all__ = [
+    
+]
diff --git a/code/src/doc2harness/runtime/catalog_executor.py b/code/src/doc2harness/runtime/catalog_executor.py
new file mode 100644
index 0000000000000000000000000000000000000000..bd5a00e6e072f2572570ccf26561eb1f78582715
--- /dev/null
+++ b/code/src/doc2harness/runtime/catalog_executor.py
@@ -0,0 +1,186 @@
+"""Fail-closed orchestration for a production artifact catalog run.
+
+This module owns the catalog-level boundary only.  A reviewed driver still
+owns fixture setup and harness-specific observation production.  Each scenario
+is invoked separately, bound to its catalog owner and definition digest, and
+must emit one typed-event document; text streams are never evidence.
+"""
+
+from __future__ import annotations
+
+import json
+from collections.abc import Mapping
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from dataclasses import dataclass
+from pathlib import Path
+
+from doc2harness.benchmark.definition import definition_digest
+from doc2harness.benchmark.dispatch import load_scenario_owner
+from doc2harness.contracts.primitives import ContractDocumentError
+from doc2harness.runtime.artifact_executor import (
+    ArtifactExecutionRequest,
+    load_typed_event_document,
+    run_artifact_driver,
+)
+from doc2harness.runtime.errors import RuntimeBoundaryError
+
+
+class CatalogExecutionError(RuntimeBoundaryError):
+    """A catalog run failed before it could produce a complete receipt."""
+
+
+@dataclass(frozen=True, slots=True)
+class CatalogExecutionRequest:
+    """Inputs for one artifact and an explicit active scenario selection."""
+
+    artifact: Path
+    driver_root: Path
+    driver_argv: tuple[str, ...]
+    output_dir: Path
+    artifact_id: str
+    source_digest: str
+    task_digest: str
+    budget_digest: str
+    artifact_digest: str
+    scenario_ids: tuple[str, ...]
+    concurrency: int = 1
+    timeout_seconds: float = 900.0
+
+    def __post_init__(self) -> None:
+        if not all(isinstance(value, Path) for value in (self.artifact, self.driver_root, self.output_dir)):
+            raise ContractDocumentError("catalog execution paths must use Path")
+        if type(self.driver_argv) is not tuple or not self.driver_argv:
+            raise ContractDocumentError("catalog driver argv must be non-empty")
+        if any(type(item) is not str or not item or "\0" in item for item in self.driver_argv):
+            raise ContractDocumentError("catalog driver argv contains an invalid item")
+        if type(self.artifact_id) is not str or not self.artifact_id or "\0" in self.artifact_id:
+            raise ContractDocumentError("catalog artifact id is invalid")
+        for value, name in (
+            (self.source_digest, "source digest"),
+            (self.task_digest, "task digest"),
+            (self.budget_digest, "budget digest"),
+            (self.artifact_digest, "artifact digest"),
+        ):
+            if type(value) is not str or not value.startswith("sha256:") or len(value) != 71:
+                raise ContractDocumentError(f"catalog {name} is invalid")
+        if type(self.scenario_ids) is not tuple or not self.scenario_ids:
+            raise ContractDocumentError("catalog scenario selection must be non-empty")
+        if any(type(item) is not str or not item or "\0" in item for item in self.scenario_ids):
+            raise ContractDocumentError("catalog scenario selection contains an invalid id")
+        if len(set(self.scenario_ids)) != len(self.scenario_ids):
+            raise ContractDocumentError("catalog scenario selection contains duplicates")
+        if type(self.concurrency) is not int or self.concurrency < 1:
+            raise ContractDocumentError("catalog concurrency must be positive")
+        if type(self.timeout_seconds) not in {int, float} or not 0 < self.timeout_seconds <= 3600:
+            raise ContractDocumentError("catalog timeout is invalid")
+
+
+def _scenario_output_path(root: Path, scenario_id: str) -> Path:
+    """Return a deterministic path after the ID has passed catalog validation."""
+
+    if "/" in scenario_id or "\\" in scenario_id or scenario_id in {".", ".."}:
+        raise CatalogExecutionError("SBH-CATALOG-SCENARIO-ID", "scenario id cannot become a path")
+    return root / f"{scenario_id}.json"
+
+
+def _run_one(request: CatalogExecutionRequest, scenario_id: str, *, environ: Mapping[str, str] | None) -> dict[str, object]:
+    owner = load_scenario_owner(scenario_id)
+    expected_definition_digest = definition_digest(owner.definition)
+    output = _scenario_output_path(request.output_dir, scenario_id)
+    run_artifact_driver(
+        ArtifactExecutionRequest(
+            request.artifact,
+            request.driver_root,
+            request.driver_argv,
+            output,
+            request.source_digest,
+            request.task_digest,
+            request.budget_digest,
+            request.artifact_digest,
+            request.timeout_seconds,
+        ),
+        environ={
+            **(dict(environ) if environ is not None else {}),
+            "SBH_ARTIFACT_ID": request.artifact_id,
+            "SBH_SCENARIO_ID": scenario_id,
+            "SBH_SCENARIO_MODULE": owner.module,
+            "SBH_DEFINITION_DIGEST": expected_definition_digest,
+        },
+    )
+    document = load_typed_event_document(
+        output,
+        source_digest=request.source_digest,
+        task_digest=request.task_digest,
+        budget_digest=request.budget_digest,
+        artifact_digest=request.artifact_digest,
+    )
+    if (
+        document.get("scenario_id") != scenario_id
+        or document.get("scenario_module") != owner.module
+        or document.get("definition_digest") != expected_definition_digest
+        or document.get("artifact_id") != request.artifact_id
+    ):
+        raise CatalogExecutionError(
+            "SBH-CATALOG-BINDING",
+            f"typed observation binding differs for {scenario_id}",
+        )
+    return {"scenario_id": scenario_id, "scenario_module": owner.module, "document": document}
+
+
+def run_catalog(
+    request: CatalogExecutionRequest,
+    *,
+    environ: Mapping[str, str] | None = None,
+) -> Path:
+    """Execute every selected scenario and write one identity-bound receipt.
+
+    Any failed, missing, duplicate, unknown, or mis-bound scenario aborts the
+    receipt.  A partial directory is intentionally not presented as a result.
+    """
+
+    request.output_dir.mkdir(parents=True, exist_ok=True)
+    results: list[dict[str, object]] = []
+    failures: list[str] = []
+    workers = min(request.concurrency, len(request.scenario_ids))
+    with ThreadPoolExecutor(max_workers=workers) as pool:
+        futures = {
+            pool.submit(_run_one, request, scenario_id, environ=environ): scenario_id
+            for scenario_id in request.scenario_ids
+        }
+        for future in as_completed(futures):
+            scenario_id = futures[future]
+            try:
+                results.append(future.result())
+            except Exception as exc:  # noqa: BLE001  # normalize at the catalog boundary
+                # Carry the message, not just the class.  Every scenario failure
+                # arrives here as ArtifactExecutionError, so the class name alone
+                # separates nothing -- and the message is where the driver's own
+                # scrubbed stderr tail lives.
+                failures.append(f"{scenario_id}:{type(exc).__name__}: {exc}")
+    missing = set(request.scenario_ids) - {row["scenario_id"] for row in results}
+    if failures or missing:
+        # Name what failed: without the scenario ids a run that lost one
+        # scenario reads exactly like a product the executor refused outright,
+        # and diagnosis has to start by diffing the output directory.  Scenario
+        # ids and exception type names are neither host paths nor raw output, so
+        # carrying them here keeps the closed-error contract.
+        detail = " | ".join(sorted(failures) + sorted(f"{s}:missing" for s in missing))
+        raise CatalogExecutionError(
+            "SBH-CATALOG-INCOMPLETE",
+            "catalog run did not produce one valid bound result for every selected "
+            f"scenario ({len(failures) + len(missing)} of {len(request.scenario_ids)}: {detail})",
+        )
+    results.sort(key=lambda row: str(row["scenario_id"]))
+    receipt = {
+        "schema": "doc2harness.production-catalog-receipt/1",
+        "artifact_id": request.artifact_id,
+        "artifact_digest": request.artifact_digest,
+        "scenario_count": len(results),
+        "rows": results,
+    }
+    target = request.output_dir / "catalog_receipt.json"
+    target.write_text(json.dumps(receipt, ensure_ascii=False, indent=2, sort_keys=True) + "\n", encoding="utf-8")
+    return target
+
+
+__all__ = ["CatalogExecutionError", "CatalogExecutionRequest", "run_catalog"]
diff --git a/code/src/doc2harness/runtime/direct_mock_driver.py b/code/src/doc2harness/runtime/direct_mock_driver.py
new file mode 100644
index 0000000000000000000000000000000000000000..68f20c1a96e553f48ab6d3d66e46132fc44817ef
--- /dev/null
+++ b/code/src/doc2harness/runtime/direct_mock_driver.py
@@ -0,0 +1,534 @@
+"""Run one active ``direct`` scenario through a real artifact.
+
+This is a production-driver boundary, not a scorer shortcut.  The artifact is
+invoked through its public ``run_agent.sh`` contract, the mock gateway is used
+only as deterministic stimulus, and the active scenario-local judge receives a
+typed ``DirectMockRawObservation``; no recorded result, runner, or verdict is
+imported.
+"""
+
+from __future__ import annotations
+import argparse
+import hashlib
+import json
+import os
+import re
+import socket
+import subprocess
+import sys
+import tempfile
+import threading
+from dataclasses import asdict
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from pathlib import Path
+from doc2harness.runtime import mock_gateway
+from doc2harness.runtime.driver_evidence import (
+    CONTAINER_WORKSPACE,
+    evidence_digest as _digest,
+    read_status_document as _status,
+    read_trajectory_text as _trajectory,
+    request_facts as _request_facts,
+    run_artifact_entrypoint as _run_artifact,
+)
+from typing import Any
+
+
+class _TrapProxy(ThreadingHTTPServer):
+    """Record any product request that incorrectly reaches the HTTP proxy."""
+
+    daemon_threads = True
+
+    def __init__(self) -> None:
+        super().__init__(("0.0.0.0", 0), _TrapProxyHandler)
+        self.connections: list[dict[str, Any]] = []
+        self.lock = threading.Lock()
+
+
+class _TrapProxyHandler(BaseHTTPRequestHandler):
+    protocol_version = "HTTP/1.1"
+
+    def _trap(self) -> None:
+        server: _TrapProxy = self.server
+        try:
+            length = int(self.headers.get("Content-Length", "0") or 0)
+        except ValueError:
+            length = 0
+        body = self.rfile.read(length) if 0 < length <= 2 * 1024 * 1024 else b""
+        kind = "self-check" if self.headers.get("X-Direct-Mock-Self") == "proxy-self-check" else "product"
+        with server.lock:
+            server.connections.append(
+                {
+                    "api_key_seen": "sk-mock-test" in str(self.headers.get("Authorization") or ""),
+                    "body_sha256": hashlib.sha256(body).hexdigest(),
+                    "kind": kind,
+                    "method": self.command,
+                    "target": self.path,
+                }
+            )
+        payload = b'{"proxy":"direct-mock-trap"}'
+        self.send_response(502)
+        self.send_header("Content-Type", "application/json")
+        self.send_header("Content-Length", str(len(payload)))
+        self.send_header("Connection", "close")
+        self.end_headers()
+        self.wfile.write(payload)
+        self.wfile.flush()
+
+    do_CONNECT = _trap
+    do_GET = _trap
+    do_POST = _trap
+
+
+def _raw_http(host: str, port: int, request: bytes) -> bytes:
+    with socket.create_connection((host, port), timeout=2) as connection:
+        connection.sendall(request)
+        connection.shutdown(socket.SHUT_WR)
+        chunks: list[bytes] = []
+        while chunk := connection.recv(65536):
+            chunks.append(chunk)
+    return b"".join(chunks)
+
+
+def _rounds(fixture: Any, observer: str | None = None) -> list[list[dict[str, Any]]]:
+    rounds: list[list[dict[str, Any]]] = []
+    for group in fixture.rounds:
+        current: list[dict[str, Any]] = []
+        for action in group:
+            if action.finish:
+                current.append({"name": "__finish__"})
+                continue
+            args = dict(action.arguments)
+            if observer is not None:
+                args = {
+                    key: value.replace("{OBSERVER}", observer) if isinstance(value, str) else value
+                    for key, value in args.items()
+                }
+            name = action.tool_candidates[0]
+            if name in {"bash", "shell", "run_command", "execute", "exec", "terminal"}:
+                current.append({"name": name, "command": str(args.pop("command", "")), **args})
+            else:
+                current.append({"name": name, "args": args})
+        if current:
+            rounds.append(current)
+    return rounds
+
+
+def _mode(recipe: Any) -> str:
+    return {
+        "SEQUENTIAL_PROBE": "seq_probe",
+        "FIXED_REPLY": "fixed_reply",
+    }.get(recipe.mode.value, recipe.mode.value.lower())
+
+
+def _facts(
+    scenario: Any,
+    workspace: Path,
+    requests: tuple[Any, ...],
+    trajectory: str,
+    raw_records: list[dict[str, Any]] | None = None,
+    proxy_observation: dict[str, Any] | None = None,
+    web_gets: list[dict[str, Any]] | None = None,
+):
+    from doc2harness.benchmark.harnesses.direct.contracts import DirectMockFactKey, DirectMockObservedFact
+
+    facts: dict[Any, bool | int | str] = {}
+    raw_records = raw_records or []
+    proxy_observation = proxy_observation or {}
+    web_gets = web_gets or []
+
+    def _probe_seen(token: str) -> bool:
+        return any((bool((record.get("probes") or {}).get(token)) for record in raw_records))
+
+    def _tool_seen(*names: str) -> bool:
+        wanted = {item.lower().replace("-", "_") for item in names}
+        return any(
+            (
+                wanted.intersection(
+                    (str(name).lower().replace("-", "_") for name in record.get("tool_names") or ())
+                )
+                for record in raw_records
+            )
+        )
+
+    tool_result_texts = [
+        str(text) for record in raw_records for text in record.get("tool_result_texts") or ()
+    ]
+    tool_result_blob = "\n".join(tool_result_texts)
+    token = scenario.recipe.expected_token
+    if not token:
+        found = re.search("[A-Z][A-Z0-9_]*_[0-9]{4}", str(getattr(scenario.recipe, "command", "") or ""))
+        if found:
+            token = found.group(0)
+    if token:
+        facts[DirectMockFactKey.EXPECTED_REPOSITORY_FILE] = any(
+            (
+                token in p.read_text(encoding="utf-8", errors="replace")
+                for p in workspace.rglob("*")
+                if p.is_file() and p.stat().st_size <= 8 * 1024 * 1024
+            )
+        )
+    names = {p.name for p in workspace.rglob("*") if p.is_file()}
+    facts[DirectMockFactKey.DENY_MARKER_PRESENT] = any((name.startswith("PERM_DENY_") for name in names))
+    facts[DirectMockFactKey.SHARED_FILE_PRESENT] = (workspace / "shared.txt").is_file()
+    facts[DirectMockFactKey.SHARED_FILE_CONTENT] = (
+        (workspace / "shared.txt").read_text(encoding="utf-8", errors="replace")
+        if (workspace / "shared.txt").is_file()
+        else ""
+    )
+    facts[DirectMockFactKey.SHARED_FILE_MARKER] = "SHAREDW_4242" in str(
+        facts[DirectMockFactKey.SHARED_FILE_CONTENT]
+    )
+    facts[DirectMockFactKey.PARALLEL_A] = (workspace / "pa.txt").is_file()
+    facts[DirectMockFactKey.PARALLEL_B] = (workspace / "pb.txt").is_file()
+    facts[DirectMockFactKey.RESPONSE_USAGE_HEALTHY] = scenario.recipe.mode.value in {
+        "NORMAL",
+        "SEQUENTIAL_PROBE",
+    } and bool(requests)
+    facts[DirectMockFactKey.REPOSITORY_CLEAN] = (
+        not bool(
+            subprocess.run(
+                ("git", "status", "--porcelain"), cwd=workspace, capture_output=True, check=False
+            ).stdout
+        )
+        if (workspace / ".git").is_dir()
+        else True
+    )
+    facts[DirectMockFactKey.OFFLINE_LOOPBACK_ONLY] = all(
+        (
+            item.path.startswith("/v1") or item.path.startswith("/local") or (not item.path)
+            for item in requests
+        )
+    )
+    facts[DirectMockFactKey.REASONING_REDACTED] = not any((item.has_reasoning for item in requests))
+    if profile_name := getattr(getattr(scenario.recipe, "fixture_profile", None), "value", ""):
+        if profile_name == "WEB_FETCH":
+            gets = [item for item in web_gets if str(item.get("path", "")).startswith("/local-probe")]
+            facts[DirectMockFactKey.WEB_FETCH_HEALTHY] = (
+                len(gets) == 1
+                and gets[0].get("status") == 200
+                and (gets[0].get("send_complete") is True)
+                and ("SBH_WEBFETCH_HEALTHY_BODY_7528" in tool_result_blob)
+            )
+            facts[DirectMockFactKey.WEB_FAILURES_PRESERVED] = bool(
+                gets
+                and re.search(
+                    "(?i)(?:http|status|status_code|code|->)[^0-9]{0,18}(?:404|429|500)", tool_result_blob
+                )
+                and (
+                    re.search(
+                        "(?i)(?:error|failed|failure|not found|too many requests|rate limit|server error)",
+                        tool_result_blob,
+                    )
+                    or re.search("(?i)[\"\\']?(?:ok|success)[\"\\']?\\s*[:=]\\s*false", tool_result_blob)
+                    or re.search("(?i)[\"\\']?is[_-]?error[\"\\']?\\s*[:=]\\s*true", tool_result_blob)
+                )
+            )
+        if profile_name in {"QUALITY_GATE_PASS", "QUALITY_GATE_FAIL"}:
+            marker = workspace / "qgate.marker"
+            facts[DirectMockFactKey.QGATE_RAN] = marker.is_file() and "QGATE_RAN_7755" in marker.read_text(
+                encoding="utf-8", errors="replace"
+            )
+        if profile_name in {"SHELL_EDGE_CONTROL", "SHELL_EDGE_TARGET"}:
+            facts[DirectMockFactKey.SHELL_CONTROL_BYTES] = "SHELL_EDGE_CONTROL_7731" in tool_result_blob
+            expected = "\n  EDGE_CONTENT_7731  \n\nUNTRUNCATED_7731\n"
+            facts[DirectMockFactKey.SHELL_EDGE_BYTES] = any((expected in text for text in tool_result_texts))
+    profile = getattr(getattr(scenario, "recipe", None), "fixture_profile", None)
+    profile_name = getattr(profile, "value", "")
+    if profile_name == "HTTP_PROXY":
+        proxy_self_checked = bool(proxy_observation) and all(
+            (
+                proxy_observation.get("gateway_self_check") is True,
+                proxy_observation.get("proxy_self_check") is True,
+                proxy_observation.get("environment_exact") is True,
+                proxy_observation.get("gateway_request_count") == 1,
+                proxy_observation.get("proxy_product_connections") == 0,
+                proxy_observation.get("proxy_api_key_seen") is False,
+                proxy_observation.get("cleanup_complete") is True,
+            )
+        )
+        facts[DirectMockFactKey.PROXY_SELF_CHECKED] = proxy_self_checked
+        facts[DirectMockFactKey.EXPLICIT_ENDPOINT_BYPASSED_PROXY] = (
+            proxy_self_checked and proxy_observation.get("proxy_injected") is True
+        )
+    return tuple((DirectMockObservedFact(key, value) for key, value in facts.items()))
+
+
+def _run_one() -> dict[str, Any]:
+    from doc2harness.benchmark.dispatch import load_scenario_owner
+    from doc2harness.benchmark.harnesses.direct.adapter import build_direct_mock_execution_plan
+    from doc2harness.benchmark.harnesses.direct.contracts import (
+        DirectMockRawObservation,
+        apply_direct_mock_local_judge,
+    )
+    from doc2harness.benchmark.definition import definition_digest
+
+    scenario_id = os.environ.get("SBH_SCENARIO_ID", "")
+    if not scenario_id:
+        raise RuntimeError("SBH_SCENARIO_ID is required")
+    owner = load_scenario_owner(scenario_id)
+    if not owner.module.startswith("doc2harness.benchmark.harnesses.direct"):
+        raise RuntimeError("direct mock driver received a non-direct scenario")
+    scenario = owner.scenario
+    plan = build_direct_mock_execution_plan(scenario)
+    fixture = plan.fixture
+    artifact = Path(os.environ["SBH_ARTIFACT_PATH"])
+    gateway = mock_gateway
+    gateway_server = gateway.ThreadingHTTPServer
+
+    class _BridgeVisibleServer(gateway_server):
+
+        def __init__(self, address, handler):
+            super().__init__(("0.0.0.0", address[1]), handler)
+
+    gateway.ThreadingHTTPServer = _BridgeVisibleServer
+    with tempfile.TemporaryDirectory(prefix="sbh-direct-production-") as temporary:
+        root = Path(temporary)
+        home, workspace, output = (root / "home", root / "workspace", root / "out")
+        stale_cwd = root / "stale-cwd"
+        home.mkdir()
+        workspace.mkdir()
+        output.mkdir()
+        stale_cwd.mkdir()
+        for fixture_file in fixture.repository_files:
+            target = workspace.joinpath(*fixture_file.path)
+            target.parent.mkdir(parents=True, exist_ok=True)
+            target.write_bytes(fixture_file.content)
+        task = workspace / "task.json"
+        budget = workspace / "budget.json"
+        task_bytes = fixture.task_document
+        try:
+            task_document = json.loads(task_bytes)
+        except json.JSONDecodeError:
+            task_document = None
+        if isinstance(task_document, dict) and task_document.get("repo_dir") == "__REPO_DIR__":
+            task_document["repo_dir"] = CONTAINER_WORKSPACE
+            task_bytes = json.dumps(task_document, separators=(",", ":"), sort_keys=True).encode()
+        task.write_bytes(task_bytes)
+        budget.write_bytes(fixture.budget_document)
+        proof_token = (
+            scenario.recipe.expected_token
+            or fixture.probe_token
+            or (
+                "MOCK_PROOF_7731"
+                if scenario.recipe.mode.value in {"NORMAL"}
+                else ""
+            )
+        )
+        cfg = gateway.new_cfg(
+            mode=_mode(scenario.recipe),
+            command=scenario.recipe.command or "echo MOCK_PROOF_7731 > mock_proof.txt",
+            probe_token=fixture.probe_token or "",
+            probe_tokens=[fixture.probe_token] if fixture.probe_token else [],
+            rounds=_rounds(fixture),
+            reject_substr=scenario.recipe.reject_substring,
+        )
+        if getattr(getattr(scenario.recipe, "fixture_profile", None), "value", "") == "WEB_FETCH":
+            failing = bool(getattr(scenario.recipe, "control_dependencies", ()))
+            cfg["web_status"] = 404 if failing else 200
+            cfg["web_body"] = (
+                "SBH_WEBFETCH_FAILING_BODY_8639" if failing else "SBH_WEBFETCH_HEALTHY_BODY_7528"
+            )
+        server = gateway.make_server(cfg, 0)
+        cfg["rounds"] = _rounds(fixture, f"host.docker.internal:{int(server.server_address[1])}")
+        server.daemon_threads = True
+        server.block_on_close = False
+        thread = threading.Thread(target=server.serve_forever, daemon=True)
+        thread.start()
+        proxy: _TrapProxy | None = None
+        proxy_thread: threading.Thread | None = None
+        proxy_observation: dict[str, Any] = {}
+        profile_name = getattr(getattr(scenario.recipe, "fixture_profile", None), "value", "")
+        if profile_name == "HTTP_PROXY":
+            proxy = _TrapProxy()
+            proxy_thread = threading.Thread(target=proxy.serve_forever, daemon=True)
+            proxy_thread.start()
+            gateway_check = _raw_http(
+                "127.0.0.1",
+                int(server.server_address[1]),
+                b"GET /direct-mock-self-check/gateway HTTP/1.1\r\nHost: 127.0.0.1\r\nConnection: close\r\n\r\n",
+            )
+            proxy_check = _raw_http(
+                "127.0.0.1",
+                int(proxy.server_address[1]),
+                b"GET http://direct-mock.invalid/self-check HTTP/1.1\r\nHost: direct-mock.invalid\r\nX-Direct-Mock-Self: proxy-self-check\r\nConnection: close\r\n\r\n",
+            )
+            proxy_observation.update(
+                {
+                    "gateway_self_check": gateway_check.startswith(b"HTTP/1.0 200 ")
+                    or gateway_check.startswith(b"HTTP/1.1 200 "),
+                    "proxy_self_check": proxy_check.startswith(b"HTTP/1.0 502 ")
+                    or proxy_check.startswith(b"HTTP/1.1 502 "),
+                }
+            )
+        env = dict(os.environ)
+        env.update(dict(fixture.environment))
+        env.update({"HOME": str(home), "YUYAO_HOME": str(home / ".yuyao"), "PYTHONDONTWRITEBYTECODE": "1"})
+        if proxy is not None:
+            injected = scenario.definition.scenario_id == "http_proxy_hermetic"
+            proxy_url = f"http://127.0.0.1:{proxy.server_address[1]}"
+            for name in ("HTTP_PROXY", "HTTPS_PROXY", "ALL_PROXY", "http_proxy", "https_proxy", "all_proxy"):
+                env[name] = proxy_url if injected else ""
+            if injected:
+                env["SBH_TRAP_PROXY_URL"] = proxy_url
+            env["NO_PROXY"] = ""
+            env["no_proxy"] = ""
+            proxy_observation.update({"environment_exact": True, "proxy_injected": injected})
+        argv = [
+            str(artifact / "run_agent.sh"),
+            "--task-file",
+            str(task),
+            "--repo-dir",
+            str(workspace),
+            "--model-base-url",
+            f"http://127.0.0.1:{server.server_address[1]}{scenario.recipe.base_url_suffix}",
+            "--model-name",
+            scenario.recipe.model_name,
+            "--model-api-key",
+            "sk-mock-test",
+            "--budget-file",
+            str(budget),
+            "--out-dir",
+            str(output),
+        ]
+        if scenario.recipe.omitted_flag is not None:
+            omitted = scenario.recipe.omitted_flag.value
+            argv = [
+                item for i, item in enumerate(argv) if item != omitted and (i == 0 or argv[i - 1] != omitted)
+            ]
+        completed, timed_out = _run_artifact(
+            artifact,
+            workspace,
+            home,
+            output,
+            task,
+            budget,
+            argv,
+            env,
+            int(server.server_address[1]),
+            min(scenario.recipe.timeout_seconds or 180, 600),
+            stale_cwd if scenario.recipe.stale_pwd_probe else None,
+        )
+        if os.environ.get("SBH_DEBUG_DRIVER") == "1" and completed.stderr:
+            print(str(completed.stderr), file=sys.stderr, end="")
+        if os.environ.get("SBH_DEBUG_DRIVER") == "1":
+            print(
+                f"driver-debug rc={completed.returncode} workspace={sorted((p.relative_to(workspace).as_posix() for p in workspace.rglob('*')))} output={sorted((p.relative_to(output).as_posix() for p in output.rglob('*')))}",
+                file=sys.stderr,
+            )
+        trajectory = _trajectory(home) + "\n" + _trajectory(workspace) + "\n" + _trajectory(output)
+        status = _status(output)
+        requests = _request_facts(cfg.get("requests", []), fixture.probe_token)
+        if proxy is not None:
+            product_connections = [item for item in proxy.connections if item.get("kind") == "product"]
+            proxy_observation.update(
+                {
+                    "gateway_request_count": len(requests),
+                    "proxy_product_connections": len(product_connections),
+                    "proxy_api_key_seen": any(
+                        (item.get("api_key_seen") is True for item in product_connections)
+                    ),
+                }
+            )
+            proxy.shutdown()
+            proxy.server_close()
+            if proxy_thread is not None:
+                proxy_thread.join(timeout=2)
+            proxy_observation["cleanup_complete"] = proxy_thread is None or not proxy_thread.is_alive()
+        server.shutdown()
+        server.server_close()
+        thread.join(timeout=2)
+        token = proof_token
+        marker = any(
+            (
+                token and token in p.read_text(encoding="utf-8", errors="replace")
+                for p in workspace.rglob("*")
+                if p.is_file() and p.stat().st_size <= 8 * 1024 * 1024
+            )
+        )
+        observation = DirectMockRawObservation(
+            scenario_id=scenario_id,
+            plan_digest=plan.plan_digest,
+            artifact_id=os.environ["SBH_ARTIFACT_ID"],
+            artifact_digest=os.environ["SBH_ARTIFACT_DIGEST"],
+            exit_code=int(completed.returncode),
+            status_written=bool(status),
+            exit_status=status.get("exit_status") if isinstance(status.get("exit_status"), str) else None,
+            cost_usd=status.get("cost_usd") if isinstance(status.get("cost_usd"), (int, float)) else None,
+            requests=requests,
+            proof_present=marker,
+            proof_contains_marker=marker,
+            trajectory_observed=bool(trajectory.strip()),
+            trajectory_contains_probe=bool(token and token in trajectory),
+            artifact_unchanged=True,
+            decoy_entries=(),
+            stderr_has_traceback="traceback (most recent call last)" in str(completed.stderr).lower(),
+            process_tree_clean=not timed_out,
+            gateway_clean=True,
+            workspace_clean=True,
+            backend_evidence_digest=_digest(
+                {"scenario_id": scenario_id, "requests": len(requests), "rc": completed.returncode}
+            ),
+            timed_out=timed_out,
+            trajectory=trajectory,
+            assistant_text=str(completed.stdout or ""),
+            facts=_facts(
+                scenario,
+                workspace,
+                requests,
+                trajectory,
+                cfg.get("requests", []),
+                proxy_observation,
+                cfg.get("web_gets", []),
+            ),
+        )
+    judgement = apply_direct_mock_local_judge(scenario, observation, owner.judge)
+    return {
+        "observation": observation,
+        "judgement": judgement,
+        "plan_digest": plan.plan_digest,
+        "definition_digest": definition_digest(owner.definition),
+        "module": owner.module,
+    }
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.parse_args()
+    result = _run_one()
+    observation = result["observation"]
+    judgement = result["judgement"]
+    target = Path(os.environ["SBH_TYPED_EVENT_PATH"])
+    target.parent.mkdir(parents=True, exist_ok=True)
+    document = {
+        "schema": "doc2harness.typed-events/1",
+        "source_digest": os.environ["SBH_SOURCE_DIGEST"],
+        "task_digest": os.environ["SBH_TASK_DIGEST"],
+        "budget_digest": os.environ["SBH_BUDGET_DIGEST"],
+        "artifact_digest": os.environ["SBH_ARTIFACT_DIGEST"],
+        "artifact_id": os.environ["SBH_ARTIFACT_ID"],
+        "scenario_id": os.environ["SBH_SCENARIO_ID"],
+        "scenario_module": result["module"],
+        "definition_digest": result["definition_digest"],
+        "events": [
+            {
+                "type": "direct-mock-observation",
+                "observation": asdict(observation),
+                "judgement": asdict(judgement),
+            }
+        ],
+    }
+    target.write_text(
+        json.dumps(
+            document,
+            ensure_ascii=False,
+            default=lambda value: value.value if hasattr(value, "value") else str(value),
+            indent=2,
+        )
+        + "\n",
+        encoding="utf-8",
+    )
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/code/src/doc2harness/runtime/driver_dispatch.py b/code/src/doc2harness/runtime/driver_dispatch.py
new file mode 100644
index 0000000000000000000000000000000000000000..46e1afcc1d727e3679a2cea2b9fc6e325cf87107
--- /dev/null
+++ b/code/src/doc2harness/runtime/driver_dispatch.py
@@ -0,0 +1,93 @@
+"""Dispatch one catalog scenario to its reviewed Harness production driver.
+
+This is deliberately a thin dispatcher: family drivers own fixture setup and
+typed observations, while this module owns only scenario selection and the
+identity-bound event envelope.
+"""
+
+from __future__ import annotations
+
+import argparse
+import importlib
+import json
+import os
+from dataclasses import asdict, is_dataclass
+from pathlib import Path
+
+
+def _json_value(value: object) -> object:
+    """Serialize dataclass and scenario-local NamedTuple judgements uniformly."""
+
+    if is_dataclass(value):
+        return asdict(value)
+    if hasattr(value, "_asdict"):
+        return {str(key): _json_value(item) for key, item in value._asdict().items()}
+    if isinstance(value, dict):
+        return {str(key): _json_value(item) for key, item in value.items()}
+    if isinstance(value, (tuple, list)):
+        return [_json_value(item) for item in value]
+    if hasattr(value, "value"):
+        return value.value
+    return value
+
+
+def _driver_module(scenario_module: str) -> str:
+    """Map a scenario module to the reviewed driver that can execute it.
+
+    Every family resolves to an in-package dotted path, so an installed wheel
+    can execute any of them without a checkout on ``sys.path``.
+    """
+    if ".benchmark.harnesses.direct." in scenario_module:
+        return "doc2harness.runtime.direct_mock_driver"
+    if ".benchmark.harnesses.permission." in scenario_module:
+        return "doc2harness.runtime.permission_driver"
+    if ".benchmark.harnesses.file." in scenario_module:
+        return "doc2harness.runtime.file_tool_driver"
+    if ".benchmark.harnesses.artifact." in scenario_module:
+        return "doc2harness.runtime.artifact_static_driver"
+    if ".benchmark.harnesses.state." in scenario_module:
+        return "doc2harness.runtime.state_driver"
+    if ".benchmark.harnesses.headless." in scenario_module:
+        return "doc2harness.runtime.headless_driver"
+    if ".benchmark.harnesses.startup." in scenario_module:
+        return "doc2harness.runtime.startup_driver"
+    if ".benchmark.harnesses.tui." in scenario_module:
+        return "doc2harness.runtime.tui_driver"
+    if ".benchmark.harnesses.extension." in scenario_module:
+        return "doc2harness.runtime.extension_driver"
+    raise RuntimeError(f"no reviewed production driver for {scenario_module}")
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.parse_args()
+    from doc2harness.benchmark.dispatch import load_scenario_owner
+    from doc2harness.benchmark.definition import definition_digest
+
+    scenario_id = os.environ.get("SBH_SCENARIO_ID", "")
+    owner = load_scenario_owner(scenario_id)
+    module = importlib.import_module(_driver_module(owner.module))
+    result = module._run_one()  # family modules expose the reviewed typed boundary
+    target = Path(os.environ["SBH_TYPED_EVENT_PATH"])
+    target.parent.mkdir(parents=True, exist_ok=True)
+    target.write_text(json.dumps({
+        "schema": "doc2harness.typed-events/1",
+        "source_digest": os.environ["SBH_SOURCE_DIGEST"],
+        "task_digest": os.environ["SBH_TASK_DIGEST"],
+        "budget_digest": os.environ["SBH_BUDGET_DIGEST"],
+        "artifact_digest": os.environ["SBH_ARTIFACT_DIGEST"],
+        "artifact_id": os.environ["SBH_ARTIFACT_ID"],
+        "scenario_id": scenario_id,
+        "scenario_module": owner.module,
+        "definition_digest": definition_digest(owner.definition),
+        "events": [{
+            "type": f"{owner.definition.classification.primary}-observation",
+            "observation": _json_value(result["observation"]),
+            "judgement": _json_value(result["judgement"]),
+        }],
+    }, ensure_ascii=False, default=lambda value: value.value if hasattr(value, "value") else str(value), indent=2) + "\n", encoding="utf-8")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/code/src/doc2harness/runtime/driver_evidence.py b/code/src/doc2harness/runtime/driver_evidence.py
new file mode 100644
index 0000000000000000000000000000000000000000..4680d24d5fa9de0829ff912ea384f848874824d1
--- /dev/null
+++ b/code/src/doc2harness/runtime/driver_evidence.py
@@ -0,0 +1,244 @@
+"""Shared evidence helpers for the production drivers.
+
+They stay deliberately narrow: digest evidence, read the artifact's own status
+document, collect trajectory text, summarise recorded gateway requests, and
+invoke the artifact's public entrypoint.  None of them decides an outcome.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import subprocess
+from pathlib import Path
+from typing import Any
+from doc2harness.runtime.resource_limits import container_memory_flags
+
+
+# Where _run_artifact mounts the workspace inside the evaluation container.
+# Exported because the task document must name this path, not the host one.
+CONTAINER_WORKSPACE = "/sbh-workspace"
+
+def evidence_digest(value: object) -> str:
+    return "sha256:" + hashlib.sha256(
+        b"doc2harness.direct-mock-production-driver/1\0"
+        + json.dumps(value, sort_keys=True, separators=(",", ":"), ensure_ascii=False).encode()
+    ).hexdigest()
+
+
+def read_status_document(out_dir: Path) -> dict[str, Any]:
+    try:
+        value = json.loads((out_dir / "status.json").read_text(encoding="utf-8"))
+    except (OSError, UnicodeError, json.JSONDecodeError):
+        return {}
+    if not isinstance(value, dict):
+        return {}
+    # Artifacts report either ``status`` or ``exit_status``; normalize the
+    # explicit status document, never infer
+    # a verdict from free-form stdout.
+    if "exit_status" not in value and isinstance(value.get("status"), str):
+        value["exit_status"] = value["status"]
+    return value
+
+
+def read_trajectory_text(root: Path) -> str:
+    chunks: list[str] = []
+    if not root.exists():
+        return ""
+    for path in sorted(root.rglob("*")):
+        if not path.is_file() or path.stat().st_size > 64 * 1024 * 1024:
+            continue
+        names = {part.lower() for part in path.parts}
+        if ".trajectory" not in names and "trajectory" not in path.name.lower() and path.name not in {
+            "events.jsonl", "steps.jsonl", "trace.md"
+        }:
+            continue
+        chunks.append(path.read_text(encoding="utf-8", errors="replace"))
+    return "\n".join(chunks)
+
+
+def request_facts(records: list[dict[str, Any]], token: str | None):
+    from doc2harness.benchmark.harnesses.direct.contracts import DirectMockRequestFact
+
+    facts = []
+    for record in records:
+        probes = record.get("probes") or {}
+        result_texts = tuple(str(item) for item in (record.get("tool_result_texts") or ()))
+        # The gateway retains the full role sequence, while the public typed
+        # contract intentionally caps this diagnostic at 32 entries.  Keep
+        # the bounded tail rather than letting a long session invalidate the
+        # entire catalog receipt.
+        message_roles = tuple(str(item) for item in (record.get("msg_roles") or ()))
+        facts.append(
+            DirectMockRequestFact(
+                body_bytes=int(record.get("body_bytes", 0)),
+                has_tools=bool(record.get("has_tools")),
+                tool_names=tuple(str(item) for item in (record.get("tool_names") or ())),
+                probe_seen=bool(probes.get(token)) if token else False,
+                message_count=int(record.get("n_messages", 0)),
+                message_roles=message_roles[-32:],
+                path=str(record.get("path") or ""),
+                model=str(record.get("model") or ""),
+                nonleading_system=bool(record.get("nonleading_system")),
+                orphan_tool_result=bool(record.get("orphan_tool_result")),
+                lone_surrogate=bool(record.get("lone_surrogate")),
+                has_any_null=bool(record.get("has_any_null")),
+                empty_content_block=bool(record.get("empty_content_block")),
+                dangling_tool_use=bool(record.get("dangling_tool_use")),
+                trailing_empty_assistant=bool(record.get("trailing_empty_assistant")),
+                tool_result_max_bytes=int(record.get("tool_result_max_bytes", 0)),
+                target_tool_result=next((item for item in reversed(result_texts) if item), ""),
+                has_reasoning=bool(record.get("has_reasoning")),
+            )
+        )
+    return tuple(facts)
+
+
+def run_artifact_entrypoint(
+    artifact: Path,
+    workspace: Path,
+    home: Path,
+    output: Path,
+    task: Path,
+    budget: Path,
+    argv: list[str],
+    env: dict[str, str],
+    port: int,
+    timeout: int,
+    stale_cwd: Path | None = None,
+) -> tuple[subprocess.CompletedProcess[str], bool]:
+    """Run the unchanged artifact inside the reviewed evaluation image.
+
+    The artifact source is mounted read-only; only the declared repository,
+    home and output directories are writable.  This keeps the production path
+    from accidentally succeeding because the host happens to have the
+    artifact's Python dependencies installed.
+    """
+
+    image = os.environ.get("SBH_EVALUATION_IMAGE", "doc2harness/evaluation:candidate")
+    container_env = {
+        "HOME": "/sbh-home",
+        "YUYAO_HOME": "/sbh-home/.yuyao",
+        "PYTHONDONTWRITEBYTECODE": "1",
+        "D2A_MODEL_BASE_URL": f"http://host.docker.internal:{port}/v1",
+        # The other two halves of the model configuration.  A product is
+        # entitled to treat "configured" as all three being present, and one
+        # does exactly that (``model.is_configured`` requires name and key as
+        # well) - so with only the URL set, its sub-agent declines to start and
+        # answers "[sub-agent could not run: model not configured]".  Points
+        # about what a sub-agent does then pass vacuously: nothing escaped the
+        # step budget because nothing ran.  So all three are set.
+        "D2A_MODEL_NAME": "litellm_proxy/mock",
+        "D2A_MODEL_API_KEY": "sk-mock-test",
+    }
+    command = [
+        "docker", "run", *container_memory_flags(), "--rm", "--init",
+        "--network", "bridge",
+        "--add-host=host.docker.internal:host-gateway",
+        "--read-only", "--tmpfs", "/tmp:rw,noexec,nosuid,size=256m",
+        "--user", f"{os.getuid()}:{os.getgid()}",
+        "-v", f"{artifact}:/sbh-artifact:ro",
+        "-v", f"{workspace}:/sbh-workspace:rw",
+        "-v", f"{home}:/sbh-home:rw",
+        "-v", f"{output}:/sbh-output:rw",
+    ]
+    if stale_cwd is not None:
+        command.extend(("-v", f"{stale_cwd}:/sbh-stale:rw", "-w", "/sbh-stale"))
+    forwarded = {
+        k: v for k, v in env.items()
+        if k.startswith("D2A_") and k not in {"D2A_MODEL_BASE_URL", "D2A_MODEL_NAME", "D2A_MODEL_API_KEY"}
+    }
+    # A point that observes how an external tool was launched puts a recording
+    # wrapper ahead of the real binary on PATH.  The wrapper execs the real one,
+    # so nothing about the search changes - but without the PATH the launch is
+    # unobservable and the point cannot tell a mishandled invocation from an
+    # absent observation.
+    if env.get("SBH_CONTAINER_PATH"):
+        forwarded["PATH"] = str(env["SBH_CONTAINER_PATH"])
+    # A hermeticity point needs the ambient configuration it is about to
+    # actually be present: with nothing to be sealed from, a product that reads
+    # whatever config it finds is indistinguishable from one that seals.
+    if env.get("SBH_CONTAINER_RG_CONFIG"):
+        forwarded["RIPGREP_CONFIG_PATH"] = str(env["SBH_CONTAINER_RG_CONFIG"])
+        forwarded["RG_CONFIG_PATH"] = str(env["SBH_CONTAINER_RG_CONFIG"])
+    if env.get("SBH_CONTAINER_RG_HOME"):
+        forwarded["HOME"] = str(env["SBH_CONTAINER_RG_HOME"])
+        forwarded["XDG_CONFIG_HOME"] = str(env["SBH_CONTAINER_RG_HOME"]) + "/.config"
+    # The proxy point works by putting a trap proxy in the ambient environment
+    # and requiring the explicit model endpoint to reach the gateway anyway,
+    # so the proxy variables have to reach the container: forwarding only
+    # ``D2A_*`` names would leave the product no proxy to honour or bypass.
+    # Rewrite the loopback address the host chose into the one the container
+    # can reach.
+    #
+    # Only the trap proxy this driver started is rewritten.  A scenario may
+    # instead declare a proxy of its own - the offline point names a dead port
+    # and exempts loopback through ``NO_PROXY`` - and there the loopback
+    # address is the literal subject of the test.  Rewriting it moves the
+    # gateway out from behind that exemption, so every request is sent to a
+    # closed port and a healthy product fails to start at all.  Those values
+    # are forwarded exactly as declared.
+    trap = str(env.get("SBH_TRAP_PROXY_URL") or "")
+    for name in (
+        "HTTP_PROXY", "HTTPS_PROXY", "ALL_PROXY",
+        "http_proxy", "https_proxy", "all_proxy",
+        "NO_PROXY", "no_proxy",
+    ):
+        if name in env:
+            value = str(env[name])
+            # Rewrite only the trap this driver started; a scenario's own
+            # declared proxy travels verbatim.
+            if trap and value == trap:
+                value = value.replace(
+                    "http://127.0.0.1:", "http://host.docker.internal:", 1
+                )
+            forwarded[name] = value
+    # A scenario that exempts loopback from its own proxy is naming the
+    # gateway: when the harness and the product share a host, the gateway
+    # *is* 127.0.0.1 and the exemption covers it.  In a container the gateway
+    # answers on ``host.docker.internal``, which that exemption does not name,
+    # so every model request is handed to the scenario's deliberately dead
+    # proxy and a healthy product cannot start.  Extend the exemption to the
+    # address the gateway actually has here, preserving what it meant.
+    for name in ("NO_PROXY", "no_proxy"):
+        value = forwarded.get(name)
+        if value and "127.0.0.1" in value and "host.docker.internal" not in value:
+            forwarded[name] = value + ",host.docker.internal"
+    for key, value in {**container_env, **forwarded}.items():
+        command.extend(("-e", f"{key}={value}"))
+    command.extend((image, "/sbh-artifact/run_agent.sh"))
+    translated = {
+        str(task): f"{CONTAINER_WORKSPACE}/task.json",
+        str(workspace): CONTAINER_WORKSPACE,
+        str(budget): "/sbh-workspace/budget.json",
+        str(output): "/sbh-output",
+    }
+    for item in argv[1:]:
+        if item.startswith("http://127.0.0.1:"):
+            command.append(item.replace("http://127.0.0.1:", "http://host.docker.internal:", 1))
+        else:
+            command.append(translated.get(item, item))
+    try:
+        completed = subprocess.run(
+            command,
+            cwd=workspace,
+            env=env,
+            stdin=subprocess.DEVNULL,
+            capture_output=True,
+            text=True,
+            timeout=timeout,
+            check=False,
+        )
+        return completed, False
+    except subprocess.TimeoutExpired as exc:
+        return subprocess.CompletedProcess(command, -1, exc.stdout or "", exc.stderr or ""), True
+
+
+__all__ = [
+    "evidence_digest",
+    "read_status_document",
+    "read_trajectory_text",
+    "request_facts",
+    "run_artifact_entrypoint",
+]
diff --git a/code/src/doc2harness/runtime/errors.py b/code/src/doc2harness/runtime/errors.py
new file mode 100644
index 0000000000000000000000000000000000000000..c8b683d7c5ff85a563c74fd851c054ba96fbbcea
--- /dev/null
+++ b/code/src/doc2harness/runtime/errors.py
@@ -0,0 +1,23 @@
+"""Stable, path-free failures for the local runtime boundary."""
+
+from __future__ import annotations
+
+
+class RuntimeBoundaryError(RuntimeError):
+    """A closed runtime failure which never embeds host paths or raw output."""
+
+    def __init__(self, code: str, message: str | None = None) -> None:
+        if message is None:
+            message = code
+            code = "SBH-RUNTIME-ERROR"
+        if type(code) is not str or type(message) is not str:
+            raise TypeError("runtime errors require exact strings")
+        super().__init__(message)
+        self.code = code
+
+
+class RuntimeCapabilityUnavailable(RuntimeBoundaryError):
+    """A required platform primitive cannot be proved by the injected backend."""
+
+
+__all__ = ["RuntimeBoundaryError", "RuntimeCapabilityUnavailable"]
diff --git a/code/src/doc2harness/runtime/extension_driver.py b/code/src/doc2harness/runtime/extension_driver.py
new file mode 100644
index 0000000000000000000000000000000000000000..a132f641a0b942924f2e022d91744d72d84a7d66
--- /dev/null
+++ b/code/src/doc2harness/runtime/extension_driver.py
@@ -0,0 +1,290 @@
+"""Run one extension counterfactual with a real CLI and a closed fixture.
+
+The fixture is created outside the artifact and mounted as a temporary root;
+the typed observation records only discovery markers, request counts, and
+cleanup facts.  Verdict logic remains in the scenario oracle.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import pty
+import select
+import signal
+import subprocess
+import tempfile
+import threading
+import time
+from dataclasses import asdict
+from pathlib import Path
+from typing import Any
+
+from doc2harness.runtime import mock_gateway
+from doc2harness.runtime.direct_mock_driver import _digest
+from doc2harness.runtime.resource_limits import container_memory_flags
+
+
+def _read_pty(master: int, buffer: bytearray, seconds: float) -> None:
+    deadline = time.monotonic() + seconds
+    while time.monotonic() < deadline:
+        ready, _, _ = select.select([master], [], [], 0.1)
+        if not ready:
+            continue
+        try:
+            buffer.extend(os.read(master, 65536))
+        except OSError:
+            return
+
+
+_WIRE_MARKERS = {
+    "commands": "EXTSYM_COMMAND_BODY_9417",
+    "skills": "EXTSYM_SKILL_BODY_9418",
+    "plugins": "EXTSYM_PLUGIN_BODY_9419",
+}
+_EXEC_MARKERS = {
+    "commands": "EXTSYM_COMMAND_EXEC_9420",
+    "hooks": "EXTSYM_HOOK_EXEC_9421",
+    "plugins": "EXTSYM_PLUGIN_EXEC_9422",
+}
+
+
+def _extension_fixture(root: Path, mode: str) -> tuple[Path, dict[str, Path], bool]:
+    repo = root / "repo"
+    inside = repo / "extension-definition-sources"
+    outside = root / "external-definition-sources"
+    markers = root / "extension-markers"
+    for directory in (repo, inside, outside, markers, root / "home"):
+        directory.mkdir(parents=True, exist_ok=True)
+    source = inside if mode == "inside" else outside
+    marker_paths = {face: markers / f"{face}.marker" for face in _EXEC_MARKERS}
+
+    def shell_marker(face: str) -> str:
+        # Definitions are interpreted inside the evaluation container; use
+        # the mounted root path rather than the host's temporary pathname.
+        return f"printf '{_EXEC_MARKERS[face]}\\n' >> '/sbh-root/extension-markers/{face}.marker'"
+
+    definitions = {
+        "command.md": (
+            "---\ndescription: symlink definition probe\n---\n"
+            f"!{{{shell_marker('commands')}}}\n"
+            f"Carry the exact marker {_WIRE_MARKERS['commands']} into this turn.\n"
+        ),
+        "SKILL.md": (
+            "---\nname: extsymskill\ndescription: symlink definition probe\n"
+            "triggers: [extsymskill]\n---\n"
+            f"Carry the exact marker {_WIRE_MARKERS['skills']} into this turn.\n"
+        ),
+        "hooks.json": json.dumps({
+            "hooks": {
+                "beforeShellExecution": [{"matcher": "*", "command": shell_marker("hooks")}],
+                "beforeToolUse": [{"matcher": "*", "command": shell_marker("hooks")}],
+            },
+        }),
+        "plugin.json": json.dumps({
+            "name": "extsympackage",
+            "description": "symlink definition probe",
+            "commands": [{
+                "name": "extsymplugin",
+                "description": "symlink definition probe",
+                "prompt": f"!{{{shell_marker('plugins')}}}\nCarry the exact marker {_WIRE_MARKERS['plugins']} into this turn.",
+                "body": f"!{{{shell_marker('plugins')}}}\nCarry the exact marker {_WIRE_MARKERS['plugins']} into this turn.",
+            }],
+            "hooks": {"beforeShellExecution": [{"matcher": "*", "command": shell_marker("plugins")}]},
+        }),
+    }
+    targets: dict[str, Path] = {}
+    for name, text in definitions.items():
+        target = source / name
+        target.parent.mkdir(parents=True, exist_ok=True)
+        target.write_text(text, encoding="utf-8")
+        targets[name] = target
+    links = {
+        repo / "commands" / "extsymcommand.md": targets["command.md"],
+        repo / "skills" / "extsymskill" / "SKILL.md": targets["SKILL.md"],
+        repo / "hooks.json": targets["hooks.json"],
+        repo / "plugins" / "extsympackage" / "plugin.json": targets["plugin.json"],
+    }
+    for link, target in links.items():
+        link.parent.mkdir(parents=True, exist_ok=True)
+        link.symlink_to(os.path.relpath(target, link.parent) if mode == "inside" else target)
+    repo_real = repo.resolve()
+    shape: dict[str, bool] = {}
+    for link, target in links.items():
+        resolved = link.resolve(strict=True)
+        contained = os.path.commonpath((str(repo_real), str(resolved))) == str(repo_real)
+        shape[str(link.relative_to(repo))] = (
+            link.is_symlink() and resolved == target.resolve(strict=True)
+            and contained == (mode == "inside")
+        )
+    return repo, marker_paths, bool(shape) and all(shape.values())
+
+
+def _run_mode(scenario: Any, artifact: Path, mode: str) -> tuple[Any, dict[str, Any]]:
+    from doc2harness.benchmark.harnesses.extension.contracts import (
+        ExtensionFace,
+        ExtensionRunObservation,
+    )
+
+    gateway_module = mock_gateway
+    marker_tokens = list(_WIRE_MARKERS.values())
+    rounds = [
+        [{"name": "bash", "command": scenario.recipe.round_command}],
+        [{"name": "__finish__"}],
+    ]
+    cfg = gateway_module.new_cfg(
+        mode="seq_probe", rounds=rounds, probe_tokens=marker_tokens,
+    )
+    server = gateway_module.ThreadingHTTPServer(("0.0.0.0", 0), gateway_module.Handler)
+    server.cfg = cfg
+    server.daemon_threads = True
+    server.block_on_close = False
+    threading.Thread(target=server.serve_forever, daemon=True).start()
+    driver_error = ""
+    timed_out = False
+    returncode: int | None = None
+    with tempfile.TemporaryDirectory(prefix="sbh-extension-production-") as temporary:
+        root = Path(temporary)
+        repo, marker_paths, fixture_ok = _extension_fixture(root, mode)
+        home = root / "home"
+        screen = bytearray()
+        env = dict(os.environ)
+        env.update({
+            "HOME": str(home), "YUYAO_HOME": str(home / ".yuyao"),
+            "PYTHONDONTWRITEBYTECODE": "1", "TERM": "xterm-256color",
+            "D2A_MODEL_BASE_URL": f"http://host.docker.internal:{server.server_address[1]}/v1",
+            "D2A_MODEL_NAME": "mock/release-extension", "D2A_MODEL_API_KEY": "sk-mock-test",
+        })
+        image = os.environ.get("SBH_EVALUATION_IMAGE", "doc2harness/evaluation:candidate")
+        command = [
+            "docker", "run", *container_memory_flags(), "--rm", "--init", "-it", "--network", "bridge",
+            "--add-host=host.docker.internal:host-gateway", "--read-only",
+            "--tmpfs", "/tmp:rw,noexec,nosuid,size=256m", "--user", f"{os.getuid()}:{os.getgid()}",
+            "-v", f"{artifact}:/sbh-artifact:ro", "-v", f"{root}:/sbh-root:rw",
+            "-w", "/sbh-root/repo",
+            "-e", "HOME=/sbh-root/home", "-e", "YUYAO_HOME=/sbh-root/home/.yuyao",
+            "-e", "PYTHONDONTWRITEBYTECODE=1", "-e", "TERM=xterm-256color",
+            "-e", f"D2A_MODEL_BASE_URL=http://host.docker.internal:{server.server_address[1]}/v1",
+            "-e", "D2A_MODEL_NAME=mock/release-extension", "-e", "D2A_MODEL_API_KEY=sk-mock-test",
+            "-e", "PYTHONPATH=/sbh-artifact/src", image,
+            "python3", "/sbh-artifact/src/yuyao/__main__.py", "--yolo", "--stream", "off",
+        ]
+        master, slave = pty.openpty()
+        process = subprocess.Popen(command, cwd=repo, env=env, stdin=slave, stdout=slave,
+                                   stderr=slave, start_new_session=True)
+        os.close(slave)
+        try:
+            _read_pty(master, screen, 3.0)
+            for setup in scenario.recipe.setup_commands:
+                os.write(master, setup.encode() + b"\r")
+                _read_pty(master, screen, 1.0)
+            os.write(master, b"echo PERM_LIVE_7755 > live.txt\r")
+            _read_pty(master, screen, 2.0)
+            _read_pty(master, screen, min(float(scenario.recipe.timeout_seconds), 6.0))
+            os.write(master, b"\x04")
+            _read_pty(master, screen, 2.0)
+            try:
+                returncode = process.wait(timeout=3.0)
+            except subprocess.TimeoutExpired:
+                # The interactive CLI may remain at its prompt after the
+                # required wire/tool evidence is captured.  Close that
+                # prompt deliberately; this is harness cleanup, not a test
+                # timeout or an execution failure.
+                os.killpg(process.pid, signal.SIGTERM)
+                returncode = process.wait(timeout=2.0)
+        except OSError as exc:
+            driver_error = type(exc).__name__
+            try:
+                os.killpg(process.pid, signal.SIGTERM)
+                returncode = process.wait(timeout=2.0)
+            except (OSError, subprocess.TimeoutExpired):
+                returncode = -1
+        finally:
+            os.close(master)
+
+        seen = []
+        request_blob = "\n".join(json.dumps(row, ensure_ascii=False, sort_keys=True) for row in cfg["requests"])
+        for face, token in _WIRE_MARKERS.items():
+            if token in request_blob:
+                seen.append(getattr(ExtensionFace, face.upper()))
+        for face, path in marker_paths.items():
+            if path.is_file() and _EXEC_MARKERS[face] in path.read_text(encoding="utf-8", errors="replace"):
+                enum_face = getattr(ExtensionFace, face.upper())
+                if enum_face not in seen:
+                    seen.append(enum_face)
+        tool_result_live = any(
+            "PERM_LIVE_7755" in "\n".join(row.get("tool_result_texts") or ())
+            for row in cfg["requests"]
+        )
+        run = ExtensionRunObservation(
+            fixture_verified=fixture_ok,
+            live=(repo / "live.txt").is_file() or tool_result_live,
+            request_count=len(cfg["requests"]),
+            seen_faces=tuple(seen),
+            fixture_error_code=None if fixture_ok else "EXTENSION_FIXTURE_SHAPE",
+        )
+        evidence = {
+            "mode": mode, "fixture_ok": fixture_ok, "request_count": len(cfg["requests"]),
+            "returncode": returncode, "screen_sha256": hashlib.sha256(screen).hexdigest(),
+            "driver_error": driver_error, "timed_out": timed_out,
+        }
+    server.shutdown(); server.server_close()
+    return run, evidence
+
+
+def _run_one() -> dict[str, Any]:
+    from doc2harness.benchmark.definition import definition_digest
+    from doc2harness.benchmark.dispatch import load_scenario_owner
+    from doc2harness.benchmark.harnesses.extension.adapter import build_extension_execution_plan
+    from doc2harness.benchmark.harnesses.extension.contracts import ExtensionCounterfactualObservation
+    from doc2harness.benchmark.harnesses.extension.oracle import judge_extension_observation
+
+    scenario_id = os.environ["SBH_SCENARIO_ID"]
+    owner = load_scenario_owner(scenario_id)
+    if ".benchmark.harnesses.extension." not in owner.module:
+        raise RuntimeError("extension driver received a non-extension scenario")
+    scenario = owner.scenario
+    plan = build_extension_execution_plan(scenario)
+    artifact = Path(os.environ["SBH_ARTIFACT_PATH"])
+    inside, inside_evidence = _run_mode(scenario, artifact, "inside")
+    outside = None
+    evidence = {"inside": inside_evidence}
+    if scenario.recipe.paired:
+        outside, outside_evidence = _run_mode(scenario, artifact, "outside")
+        evidence["outside"] = outside_evidence
+    observation = ExtensionCounterfactualObservation(
+        scenario_id=scenario_id, plan_digest=plan.plan_digest,
+        artifact_id=os.environ["SBH_ARTIFACT_ID"], artifact_digest=os.environ["SBH_ARTIFACT_DIGEST"],
+        backend_evidence_digest=_digest(evidence), inside=inside, outside=outside,
+        process_tree_clean=all(not item.get("driver_error") and not item.get("timed_out") for item in evidence.values()),
+        workspace_clean=True,
+    )
+    return {
+        "observation": observation,
+        "judgement": judge_extension_observation(scenario, observation),
+        "module": owner.module,
+        "definition_digest": definition_digest(owner.definition),
+    }
+
+
+def main() -> int:
+    result = _run_one()
+    # Create the output directory as every driver does: run_catalog pre-creates
+    # it, but a scenario run directly does not.
+    typed_event_path = Path(os.environ["SBH_TYPED_EVENT_PATH"])
+    typed_event_path.parent.mkdir(parents=True, exist_ok=True)
+    typed_event_path.write_text(json.dumps({
+        "schema": "doc2harness.typed-events/1", "source_digest": os.environ["SBH_SOURCE_DIGEST"],
+        "task_digest": os.environ["SBH_TASK_DIGEST"], "budget_digest": os.environ["SBH_BUDGET_DIGEST"],
+        "artifact_digest": os.environ["SBH_ARTIFACT_DIGEST"], "artifact_id": os.environ["SBH_ARTIFACT_ID"],
+        "scenario_id": os.environ["SBH_SCENARIO_ID"], "scenario_module": result["module"],
+        "definition_digest": result["definition_digest"],
+        "events": [{"type": "extension-counterfactual-observation", "observation": asdict(result["observation"]),
+                    "judgement": asdict(result["judgement"])}],
+    }, ensure_ascii=False, default=lambda value: value.value if hasattr(value, "value") else str(value), indent=2) + "\n", encoding="utf-8")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/code/src/doc2harness/runtime/file_tool_driver.py b/code/src/doc2harness/runtime/file_tool_driver.py
new file mode 100644
index 0000000000000000000000000000000000000000..79a2256c4bc2cbf043ea30b36197e25387b21b7c
--- /dev/null
+++ b/code/src/doc2harness/runtime/file_tool_driver.py
@@ -0,0 +1,716 @@
+"""Run one ``file`` scenario against an immutable artifact.
+
+The driver deliberately keeps the observation surface small: the file-tool
+scenario supplies fixtures and typed tool rounds, while the observer records
+only request, lifecycle, and workspace facts.  It never imports recorded
+result rows or turns model prose into a verdict.
+"""
+
+from __future__ import annotations
+import argparse
+import json
+import os
+import re
+import subprocess
+import tempfile
+import threading
+from dataclasses import asdict
+from pathlib import Path
+from typing import Any
+from doc2harness.runtime import mock_gateway
+from doc2harness.runtime.direct_mock_driver import _digest, _run_artifact, _trajectory
+from doc2harness.runtime.resource_limits import container_memory_flags
+
+
+def _unfreeze(value: object) -> object:
+    if isinstance(value, tuple):
+        if all((isinstance(item, tuple) and len(item) == 2 and isinstance(item[0], str) for item in value)):
+            return {str(key): _unfreeze(item) for key, item in value}
+        return [_unfreeze(item) for item in value]
+    return value
+
+
+def _rounds(plan: Any) -> list[list[dict[str, Any]]]:
+    rounds: list[list[dict[str, Any]]] = []
+    for turn in plan.gateway_turns:
+        calls: list[dict[str, Any]] = []
+        for call in turn.tool_calls:
+            names: object = list(call.tool_names) if len(call.tool_names) > 1 else call.tool_names[0]
+            arguments = dict(_unfreeze(call.arguments))
+            logical = {str(item).lower().replace("-", "_") for item in call.tool_names}
+            if logical & {"bash", "shell", "run_command", "execute", "exec", "terminal"}:
+                calls.append({"name": names, "command": str(arguments.pop("command", "")), **arguments})
+            else:
+                calls.append({"name": names, "args": arguments})
+        if calls:
+            rounds.append(calls)
+    return rounds
+
+
+def _phase_rounds(raw: Any) -> list[list[dict[str, Any]]]:
+    """Convert one declared phase into deterministic gateway rounds."""
+    rounds: list[list[dict[str, Any]]] = []
+    for turn in _unfreeze(raw) or []:
+        calls: list[dict[str, Any]] = []
+        for call in turn:
+            names = list(call[0]) if isinstance(call[0], (list, tuple)) else [call[0]]
+            arguments = dict(call[1]) if isinstance(call[1], (list, tuple, dict)) else {}
+            label: Any = names if len(names) > 1 else names[0]
+            logical = {str(item).lower().replace("-", "_") for item in names}
+            if logical & {"bash", "shell", "run_command", "execute", "exec", "terminal"}:
+                calls.append({"name": label, "command": str(arguments.pop("command", "")), **arguments})
+            else:
+                calls.append({"name": label, "args": arguments})
+        if calls:
+            rounds.append(calls)
+    return rounds
+
+
+def _phase_plan(plan: Any) -> dict[str, Any] | None:
+    """Return the declared phase orchestration, or None when absent.
+
+    An undo/redo point is not decided by the final file: it asserts a
+    sequence - edited, reverted, re-applied - and each of those states is a
+    separate snapshot the judge compares by name.  A single round cannot
+    express that, which is why the recipe declares the phases and the slash
+    command that separates them.
+    """
+    parameters = dict(plan.execution_parameters)
+    if not parameters.get("phase1_rounds"):
+        return None
+    return {
+        "phase1": _phase_rounds(parameters.get("phase1_rounds")),
+        "phase2": _phase_rounds(parameters.get("phase2_rounds")),
+        "phase3": _phase_rounds(parameters.get("phase3_rounds")),
+        "mid": [str(item) for item in _unfreeze(parameters.get("mid_slash")) or []],
+        "mid2": [str(item) for item in _unfreeze(parameters.get("mid_slash2")) or []],
+    }
+
+
+def _phase_session_script(plan: Any, phases: dict[str, Any]) -> str:
+    """Drive the declared phases through the artifact public session API.
+
+    The gateway hands out one declared round per model request, so the
+    phases are simply consecutive chats against the same session, with the
+    separating slash command dispatched in between.  A snapshot is taken
+    after each boundary under the name the judge compares by.
+    """
+    parameters = dict(plan.execution_parameters)
+    deny = [str(item) for item in _unfreeze(parameters.get("deny")) or []]
+    setup = [str(item) for item in plan.setup_commands]
+    targets = sorted({str(path) for path, _ in plan.fixture.seed_files} | {"tgt.txt"})
+    body = [
+        "import json, os",
+        "from yuyao.agent_api import create_session",
+        f"targets = {targets!r}",
+        f"setup = {setup!r}",
+        f"mid = {phases['mid']!r}",
+        f"mid2 = {phases['mid2']!r}",
+        f"phase2_len = {len(phases['phase2'])!r}",
+        f"phase3_len = {len(phases['phase3'])!r}",
+        "snapshots = {}",
+        "def blob(session):",
+        "    parts = []",
+        "    for source in (getattr(session, 'executor', None), session):",
+        "        try:",
+        "            for message in (getattr(source, 'messages', None) or []):",
+        "                content = message.get('content') if isinstance(message, dict) else None",
+        "                if content:",
+        "                    parts.append(str(content))",
+        "        except BaseException:",
+        "            pass",
+        "    return chr(10).join(parts)",
+        "def snap(label):",
+        "    snapshots[label + 'model_text'] = blob(session)",
+        "    root = str(getattr(session, 'cwd', None) or '/sbh-workspace')",
+        "    for name in targets:",
+        "        path = os.path.join(root, name)",
+        "        stem = os.path.splitext(os.path.basename(name))[0]",
+        "        try:",
+        "            handle = open(path, encoding='utf-8', errors='replace')",
+        "            value = handle.read()",
+        "            handle.close()",
+        "        except OSError:",
+        "            value = None",
+        "        snapshots[label + stem if label else stem] = value",
+        f"session = create_session(deny={deny!r}, cwd='/sbh-workspace')",
+        "prompt = 'Please run the declared tool calls now.'",
+        "try:",
+        "    for command in setup:",
+        "        session.dispatch(command)",
+        "    session.chat(prompt)",
+        "    snap('phase1_')",
+        "    for command in mid:",
+        "        session.dispatch(command)",
+        "    snap('after_mid1_')",
+        "    if phase2_len:",
+        "        session.chat(prompt)",
+        "        snap('phase2_')",
+        "    for command in mid2:",
+        "        session.dispatch(command)",
+        "    if mid2:",
+        "        snap('after_mid2_')",
+        "    if phase3_len:",
+        "        session.chat(prompt)",
+        "        snap('phase3_')",
+        "    snap('')",
+        "finally:",
+        "    session.close()",
+        "print('SBH_PHASE_RESULT=' + json.dumps(snapshots), flush=True)",
+    ]
+    return chr(10).join(body) + chr(10)
+
+
+def _run_phase_session(
+    artifact: Path,
+    workspace: Path,
+    home: Path,
+    env: dict[str, str],
+    port: int,
+    script: str,
+    timeout: int,
+    cwd_mount: str = "/sbh-workspace",
+) -> tuple[subprocess.CompletedProcess[str], bool]:
+    """Run a phase orchestration inside the evaluation image.
+
+    ``cwd_mount`` is where the workspace is mounted and where the session runs.
+    It defaults to ``/sbh-workspace`` (a top-level, read-only-parent path).  A
+    ``..``-relative escape point cannot be exercised from there: its secret is
+    seeded at ``/tmp/<f>`` but ``../<f>`` resolves to ``/<f>`` on the read-only
+    root, so a product that fails to fence never reaches the secret and the
+    point passes vacuously.  Such points pass ``/tmp/sbh-workspace`` so the
+    workspace parent is the writable tmpfs the seed lands in and ``../<f>``
+    reaches it - a non-fencing product then leaks/writes and fails, a fencing
+    one refuses and passes.
+    """
+    image = os.environ.get("SBH_EVALUATION_IMAGE", "doc2harness/evaluation:candidate")
+    command = [
+        "docker",
+        "run",
+        *container_memory_flags(),
+        "--rm",
+        "--init",
+        "--network",
+        "bridge",
+        "--add-host=host.docker.internal:host-gateway",
+        "--read-only",
+        "--tmpfs",
+        "/tmp:rw,noexec,nosuid,size=256m",
+        "--user",
+        f"{os.getuid()}:{os.getgid()}",
+        "-v",
+        f"{artifact}:/sbh-artifact:ro",
+        "-v",
+        f"{workspace}:{cwd_mount}:rw",
+        "-v",
+        f"{home}:/sbh-home:rw",
+        "-w",
+        cwd_mount,
+        "-e",
+        "HOME=/sbh-home",
+        "-e",
+        "YUYAO_HOME=/sbh-home/.yuyao",
+        "-e",
+        "PYTHONDONTWRITEBYTECODE=1",
+        "-e",
+        f"D2A_MODEL_BASE_URL=http://host.docker.internal:{port}/v1",
+        "-e",
+        "D2A_MODEL_NAME=litellm_proxy/mock",
+        "-e",
+        "D2A_MODEL_API_KEY=sk-mock-test",
+        "-e",
+        "PYTHONPATH=/sbh-artifact/src",
+        image,
+        "python3",
+        "-c",
+        script,
+    ]
+    try:
+        completed = subprocess.run(
+            command,
+            cwd=workspace,
+            env=env,
+            stdin=subprocess.DEVNULL,
+            capture_output=True,
+            text=True,
+            timeout=timeout,
+            check=False,
+        )
+        return (completed, False)
+    except subprocess.TimeoutExpired as exc:
+        return (subprocess.CompletedProcess(command, -1, exc.stdout or "", exc.stderr or ""), True)
+
+
+def _wire_facts(requests: list[dict[str, Any]]) -> dict[str, Any]:
+    """Summarise the structural properties of what reached the wire.
+
+    A point about the message envelope - one leading system message, no
+    orphan tool result, no dangling tool call - is decided by the requests
+    themselves, not by any file.  The gateway already records these per
+    request; the judge needs them folded across the whole exchange.
+    """
+    roles = [list(record.get("msg_roles") or []) for record in requests]
+    return {
+        "has_leading_system": any((item and item[0] == "system" for item in roles)),
+        "nonleading_system": any((bool(record.get("nonleading_system")) for record in requests)),
+        "had_tool_role": any(("tool" in item for item in roles)),
+        "orphan_tool_result": any((bool(record.get("orphan_tool_result")) for record in requests)),
+        "dangling_tool_use": any((bool(record.get("dangling_tool_use")) for record in requests)),
+    }
+
+
+def _apply_git_baseline(workspace: Path, plan: Any) -> bool:
+    """Commit the declared baseline so auto-commit has a history to add to.
+
+    An auto-commit point counts the commits the product created and reads
+    the diff of the target against HEAD.  Without a repository there is no
+    history to count and no HEAD to diff, so the point reports nothing
+    rather than reporting what the product did.
+    """
+    declared = dict(_unfreeze(dict(plan.execution_parameters).get("git_baseline") or ()) or {})
+    if not declared:
+        return False
+    identity = ("-c", "user.email=fixture@example.invalid", "-c", "user.name=SBH Fixture")
+
+    def run(*arguments: str) -> None:
+        subprocess.run(
+            ("git", *identity, *arguments),
+            cwd=workspace,
+            check=False,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+        )
+
+    for relative, content in dict(declared.get("commit") or {}).items():
+        path = workspace / str(relative)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(str(content), encoding="utf-8")
+    run("init", "-q")
+    run("config", "user.email", "fixture@example.invalid")
+    run("config", "user.name", "SBH Fixture")
+    run("add", "-A")
+    run("commit", "-q", "-m", "baseline", "--allow-empty")
+    for relative, content in dict(declared.get("worktree") or {}).items():
+        (workspace / str(relative)).write_text(str(content), encoding="utf-8")
+    return True
+
+
+def _git_facts(workspace: Path, plan: Any) -> dict[str, Any]:
+    """Count commits and read the target diff the auto-commit judges use."""
+    if not (workspace / ".git").is_dir():
+        return {}
+    targets = [str(path) for path, _ in plan.fixture.seed_files] or ["tgt.txt"]
+    log = subprocess.run(
+        ("git", "log", "--oneline"), cwd=workspace, check=False, capture_output=True, text=True
+    )
+    diff = subprocess.run(
+        ("git", "diff", "HEAD", "--", targets[0]), cwd=workspace, check=False, capture_output=True, text=True
+    )
+    tracked = subprocess.run(
+        ("git", "ls-files", "-z", "--", targets[0]), cwd=workspace, check=False, capture_output=True
+    )
+    matches = tuple(
+        sorted((item.decode("utf-8", "replace") for item in (tracked.stdout or b"").split(b"\x00") if item))
+    )
+    return {
+        "git_ok": True,
+        "git_tree_observer_ok": log.returncode == 0 and tracked.returncode == 0,
+        "git_pathspec_matches": matches,
+        "git_commit_count": len([x for x in (log.stdout or "").splitlines() if x.strip()]),
+        "git_diff_target": str(diff.stdout or ""),
+    }
+
+
+def _mode_session_script(plan: Any, cwd: str = "/sbh-workspace") -> str:
+    """Drive the declared rounds through a session with the declared mode.
+
+    The artifact launcher hard-codes yolo (entry.py), so a point whose
+    whole subject is a restricted mode ran unrestricted through it: the
+    mutating tools stayed advertised and the write landed, which reads as
+    "read-only failed to block" when read-only was never in effect.
+
+    yolo is therefore the default *only for a point that declares no
+    restriction* - a full-permission point that needs bash and writes
+    auto-approved on every product.  A point that declares a restriction
+    (``/mode X``, ``/ask``, ``/plan``, or ``/role ask``) must run under it,
+    because the permission layer gates by mode alone (role only tunes the
+    system prompt).  Blanket-forcing yolo onto a ``/role ask`` point re-opens
+    the very write it exists to block: the mutating call the mock issues is
+    auto-approved, the target changes, and a genuinely restrictive default
+    ("ask") reads as "failed to block" - a false FAIL the driver invented.
+    A pure ``/role ask`` keeps the product's own default mode (ask, per
+    §3.1) rather than being pinned, so the restriction under test is the
+    product's, not the harness's.
+    """
+    explicit_mode: str | None = None
+    for command in plan.setup_commands:
+        text = str(command).strip()
+        if "/mode " in text:
+            explicit_mode = text.split("/mode ", 1)[1].split()[0]
+        elif text == "/plan":
+            explicit_mode = explicit_mode or "plan"
+        elif text == "/ask":
+            explicit_mode = explicit_mode or "ask"
+    role = (
+        "ask"
+        if any(("/role ask" in str(c) or str(c).strip() == "/ask" for c in plan.setup_commands))
+        else None
+    )
+    if explicit_mode is not None:
+        mode: str | None = explicit_mode
+    elif role == "ask":
+        mode = None
+    else:
+        mode = "yolo"
+    deny = [str(item) for item in _unfreeze(dict(plan.execution_parameters).get("deny")) or []]
+    mode_argument = f"mode={mode!r}, " if mode is not None else ""
+    role_argument = f"role={role!r}, " if role else ""
+    return f"import json\nfrom yuyao.agent_api import create_session\nsession = create_session({mode_argument}{role_argument}deny={deny!r}, cwd={cwd!r})\ntry:\n    session.chat('Please run the declared tool calls now.')\nfinally:\n    session.close()\n"
+
+
+def _config(home: Path, plan: Any) -> None:
+    config_root = home / ".yuyao"
+    config_root.mkdir(parents=True, exist_ok=True)
+    mode = "yolo"
+    for command in plan.setup_commands:
+        text = str(command)
+        if "/mode " in text:
+            mode = text.split("/mode ", 1)[1].split()[0]
+    value: dict[str, object] = {"agent.mode": mode}
+    if dict(plan.execution_parameters).get("enable_autocommit"):
+        value["autoCommit"] = True
+    (config_root / "config.json").write_text(json.dumps(value, sort_keys=True), encoding="utf-8")
+
+
+def _path_values(plan: Any) -> list[str]:
+    paths: list[str] = [str(path) for path, _ in plan.fixture.seed_files]
+    for turn in plan.gateway_turns:
+        for call in turn.tool_calls:
+            args = dict(_unfreeze(call.arguments))
+            for key in (
+                "path",
+                "file_path",
+                "filepath",
+                "filename",
+                "target",
+                "target_file",
+                "notebook_path",
+            ):
+                value = args.get(key)
+                if isinstance(value, str) and value and (not value.startswith("/")):
+                    paths.append(value)
+    return list(dict.fromkeys(paths))
+
+
+def _facts(workspace: Path, plan: Any) -> tuple[str | None, str | None, bool, tuple[tuple[str, object], ...]]:
+    paths = _path_values(plan)
+    candidates = [path for path in paths if path not in {"live.txt", "", "."}]
+    existing = [workspace / path for path in candidates if (workspace / path).is_file()]
+    target = existing[0].read_text(encoding="utf-8", errors="replace") if existing else None
+    secondary = existing[-1].read_text(encoding="utf-8", errors="replace") if existing else None
+    live = (workspace / "live.txt").is_file()
+    files = tuple(
+        sorted(
+            (
+                (path, (workspace / path).read_text(encoding="utf-8", errors="replace"))
+                for path in candidates
+                if (workspace / path).is_file()
+            )
+        )
+    )
+    notebook = workspace / "nb.ipynb"
+    if notebook.is_file():
+        files = tuple(
+            sorted((dict(files) | {"nb": notebook.read_text(encoding="utf-8", errors="replace")}).items())
+        )
+    return (target, secondary, live, files)
+
+
+def _observed_model_text(trajectory: str) -> str:
+    """Project the trajectory down to what the model and tools actually said.
+
+    The scenarios assert that a forbidden marker never appears in the model's
+    view.  Matching against the raw trajectory also matches the marker inside
+    the recorded arguments of a tool call - that is the request the product then
+    *refused*, so the assertion inverts: a product that correctly blocked a
+    fence escape reads as having leaked it.  The judges look only at message
+    content, never at call arguments, and the fixtures build their
+    markers by concatenation precisely so the full string cannot appear in
+    command text.
+
+    Artifacts record trajectories in different shapes - one writes JSONL, one
+    writes pretty-printed JSON interleaved with Markdown - so the argument
+    payloads are removed textually rather than by parsing a specific schema.
+    Tool results, replies and reasoning are all preserved, including the failure
+    text that proves a refusal happened.
+
+    The runner's own per-call bookkeeping is dropped for the same reason.  A
+    recorded ``"meta": {"truncated": false, ...}`` is the runner describing the
+    call to its log, not text any model read; a judge asking whether the
+    product *claimed* truncation found the word inside that structure and
+    reported a truncation claim on a result whose own text says nothing of the
+    kind.  The tool's own output survives
+    this because it is a sibling field, not part of the bookkeeping.
+    """
+    without_arguments = re.sub(
+        '"(?:arguments|args|input|meta)"\\s*:\\s*"(?:[^"\\\\]|\\\\.)*"', '"arguments": ""', trajectory
+    )
+    without_arguments = _strip_balanced_argument_objects(without_arguments)
+    without_arguments = re.sub(
+        '("kind"\\s*:\\s*"permission"[^\\n]*?)"target"\\s*:\\s*"(?:[^"\\\\]|\\\\.)*"',
+        '\\1"target": ""',
+        without_arguments,
+    )
+    without_arguments = re.sub("(- tool `[A-Za-z0-9_.-]+`)\\s*\\{[^\\n]*", "\\1", without_arguments)
+    return without_arguments
+
+
+def _strip_balanced_argument_objects(text: str) -> str:
+    """Replace ``"arguments": {...}`` values, however deeply they nest.
+
+    A character-class regex cannot span a nested payload such as multi-edit's
+    ``{"edits": [{...}, {...}]}``, which would leave the very marker the
+    scenario forbids inside the text the judge inspects.
+    """
+    pattern = re.compile('"(?:arguments|args|input|meta)"\\s*:\\s*(?=[{\\[])')
+    result: list[str] = []
+    index = 0
+    while True:
+        match = pattern.search(text, index)
+        if match is None:
+            result.append(text[index:])
+            return "".join(result)
+        result.append(text[index : match.start()])
+        result.append('"arguments": {}')
+        cursor = match.end()
+        depth = 0
+        in_string = False
+        escaped = False
+        while cursor < len(text):
+            char = text[cursor]
+            if in_string:
+                if escaped:
+                    escaped = False
+                elif char == "\\":
+                    escaped = True
+                elif char == '"':
+                    in_string = False
+            elif char == '"':
+                in_string = True
+            elif char in "{[":
+                depth += 1
+            elif char in "}]":
+                depth -= 1
+                if depth == 0:
+                    cursor += 1
+                    break
+            cursor += 1
+        index = cursor
+
+
+def _run_one() -> dict[str, Any]:
+    from doc2harness.benchmark.definition import definition_digest
+    from doc2harness.benchmark.dispatch import load_scenario_owner
+    from doc2harness.benchmark.harnesses.file.adapter import build_file_tool_execution_plan
+    from doc2harness.benchmark.harnesses.file.contracts import FileToolRawObservation
+
+    scenario_id = os.environ.get("SBH_SCENARIO_ID", "")
+    owner = load_scenario_owner(scenario_id)
+    if ".benchmark.harnesses.file." not in owner.module:
+        raise RuntimeError("file-tool driver received a non-file-tool scenario")
+    scenario = owner.scenario
+    plan = build_file_tool_execution_plan(scenario)
+    gateway = mock_gateway
+    with tempfile.TemporaryDirectory(prefix="sbh-file-tool-production-") as temporary:
+        root = Path(temporary)
+        home, workspace, output = (root / "home", root / "workspace", root / "out")
+        home.mkdir()
+        workspace.mkdir()
+        output.mkdir()
+        for relative, content in plan.fixture.seed_files:
+            path = workspace / relative
+            path.parent.mkdir(parents=True, exist_ok=True)
+            path.write_text(content, encoding="utf-8")
+        _apply_git_baseline(workspace, plan)
+        _config(home, plan)
+        task = workspace / "task.json"
+        budget = workspace / "budget.json"
+        task.write_text(
+            json.dumps({"problem_statement": "Run the declared file-tool probe and stop."}), encoding="utf-8"
+        )
+        budget.write_text(json.dumps({"max_steps": max(3, len(plan.gateway_turns) + 1)}), encoding="utf-8")
+        phases = _phase_plan(plan)
+        if phases is not None:
+            finish = [[{"name": "__finish__", "content": "done"}]]
+            declared_rounds = []
+            for name in ("phase1", "phase2", "phase3"):
+                if phases[name]:
+                    declared_rounds += phases[name] + finish
+        else:
+            declared_rounds = _rounds(plan)
+        cfg = gateway.new_cfg(mode="seq_probe", rounds=declared_rounds)
+        server = gateway.ThreadingHTTPServer(("0.0.0.0", 0), gateway.Handler)
+        server.cfg = cfg
+        server.daemon_threads = True
+        server.block_on_close = False
+        thread = threading.Thread(target=server.serve_forever, daemon=True)
+        thread.start()
+        env = dict(os.environ)
+        env.update({"HOME": str(home), "YUYAO_HOME": str(home / ".yuyao"), "PYTHONDONTWRITEBYTECODE": "1"})
+        argv = [
+            str(Path(os.environ["SBH_ARTIFACT_PATH"]) / "run_agent.sh"),
+            "--task-file",
+            str(task),
+            "--repo-dir",
+            str(workspace),
+            "--model-base-url",
+            f"http://127.0.0.1:{server.server_address[1]}/v1",
+            "--model-name",
+            "litellm_proxy/mock",
+            "--model-api-key",
+            "sk-mock-test",
+            "--budget-file",
+            str(budget),
+            "--out-dir",
+            str(output),
+        ]
+        artifact_root = Path(os.environ["SBH_ARTIFACT_PATH"])
+        phase_snapshots: dict[str, Any] = {}
+        has_api = (artifact_root / "src" / "yuyao" / "agent_api.py").is_file()
+        if phases is not None and has_api:
+            completed, timed_out = _run_phase_session(
+                artifact_root,
+                workspace,
+                home,
+                env,
+                int(server.server_address[1]),
+                _phase_session_script(plan, phases),
+                min(plan.timeout_seconds, 300),
+            )
+            for line in (completed.stdout or "").splitlines():
+                if line.startswith("SBH_PHASE_RESULT="):
+                    try:
+                        parsed = json.loads(line[len("SBH_PHASE_RESULT=") :])
+                    except (TypeError, ValueError, json.JSONDecodeError):
+                        parsed = {}
+                    if isinstance(parsed, dict):
+                        phase_snapshots = parsed
+        elif has_api:
+            cwd_mount = (
+                "/sbh-workspace"
+            )
+            completed, timed_out = _run_phase_session(
+                artifact_root,
+                workspace,
+                home,
+                env,
+                int(server.server_address[1]),
+                _mode_session_script(plan, cwd_mount),
+                min(plan.timeout_seconds, 300),
+                cwd_mount=cwd_mount,
+            )
+        else:
+            completed, timed_out = _run_artifact(
+                artifact_root,
+                workspace,
+                home,
+                output,
+                task,
+                budget,
+                argv,
+                env,
+                int(server.server_address[1]),
+                min(plan.timeout_seconds, 300),
+            )
+        target_content, secondary_content, live, files = _facts(workspace, plan)
+        if phase_snapshots and "tgt" in phase_snapshots:
+            target_content = phase_snapshots["tgt"]
+        wire = _wire_facts(list(cfg.get("requests", [])))
+        wire.update(_git_facts(workspace, plan))
+        files = tuple(sorted((dict(files) | wire).items()))
+        if phase_snapshots:
+            merged = dict(files)
+            merged.update({str(key): value for key, value in phase_snapshots.items() if value is not None})
+            files = tuple(sorted(merged.items()))
+        trajectory = _trajectory(home) + "\n" + _trajectory(workspace) + "\n" + _trajectory(output)
+        requests = cfg.get("requests", [])
+        result_texts = tuple(
+            (str(text) for record in requests for text in record.get("tool_result_texts") or ())
+        )
+        files = tuple(sorted((dict(files) | {"target_tool_result_seen": bool(result_texts)}).items()))
+        advertised = tuple((str(name) for name in requests[0].get("tool_names") or ())) if requests else ()
+        observation = FileToolRawObservation(
+            scenario_id=scenario_id,
+            plan_digest=plan.plan_digest,
+            artifact_id=os.environ["SBH_ARTIFACT_ID"],
+            artifact_digest=os.environ["SBH_ARTIFACT_DIGEST"],
+            request_count=len(requests),
+            advertised_tools=advertised,
+            live=live,
+            target_content=target_content,
+            secondary_target_content=secondary_content,
+            model_text=_observed_model_text(trajectory) + chr(10) + chr(10).join(result_texts),
+            stderr_text=str(completed.stderr or ""),
+            empty_tool_result=any((not text.strip() for text in result_texts)) if result_texts else None,
+            process_tree_clean=not timed_out,
+            gateway_clean=True,
+            workspace_clean=True,
+            timed_out=timed_out,
+            backend_evidence_digest=_digest(
+                {"scenario_id": scenario_id, "requests": len(requests), "rc": completed.returncode}
+            ),
+            target_tool_result=result_texts[-1] if result_texts else "",
+            round_target_tool_results=result_texts,
+            facts=files,
+        )
+        server.shutdown()
+        server.server_close()
+        thread.join(timeout=2)
+    judgement = owner.judge(observation)
+    return {
+        "observation": observation,
+        "judgement": judgement,
+        "plan_digest": plan.plan_digest,
+        "definition_digest": definition_digest(owner.definition),
+        "module": owner.module,
+    }
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.parse_args()
+    result = _run_one()
+    target = Path(os.environ["SBH_TYPED_EVENT_PATH"])
+    target.parent.mkdir(parents=True, exist_ok=True)
+    target.write_text(
+        json.dumps(
+            {
+                "schema": "doc2harness.typed-events/1",
+                "source_digest": os.environ["SBH_SOURCE_DIGEST"],
+                "task_digest": os.environ["SBH_TASK_DIGEST"],
+                "budget_digest": os.environ["SBH_BUDGET_DIGEST"],
+                "artifact_digest": os.environ["SBH_ARTIFACT_DIGEST"],
+                "artifact_id": os.environ["SBH_ARTIFACT_ID"],
+                "scenario_id": os.environ["SBH_SCENARIO_ID"],
+                "scenario_module": result["module"],
+                "definition_digest": result["definition_digest"],
+                "events": [
+                    {
+                        "type": "file-tool-observation",
+                        "observation": asdict(result["observation"]),
+                        "judgement": asdict(result["judgement"]),
+                    }
+                ],
+            },
+            ensure_ascii=False,
+            default=lambda value: value.value if hasattr(value, "value") else str(value),
+            indent=2,
+        )
+        + "\n",
+        encoding="utf-8",
+    )
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/code/src/doc2harness/runtime/headless_driver.py b/code/src/doc2harness/runtime/headless_driver.py
new file mode 100644
index 0000000000000000000000000000000000000000..9d3c5b210d2b1d231435d0e061794cdb1105a291
--- /dev/null
+++ b/code/src/doc2harness/runtime/headless_driver.py
@@ -0,0 +1,1123 @@
+"""Run one ``headless`` scenario through the artifact's public CLI.
+
+The driver deliberately observes process exit data, request records, and
+workspace changes.  It never converts terminal prose into a typed fact used
+by a judge; unsupported observations remain explicit in the observation.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import re
+import shlex
+import subprocess
+import tempfile
+import threading
+from dataclasses import asdict
+from pathlib import Path
+from typing import Any
+
+_TREE = "/sbh-tree"
+# The container path of the mounted workspace.  It deliberately sits one level
+# inside a writable parent; see the mount in _docker_run.
+_WORKSPACE = _TREE + "/workspace"
+
+from doc2harness.runtime import mock_gateway
+from doc2harness.runtime.direct_mock_driver import _digest, _status
+from doc2harness.runtime.resource_limits import container_memory_flags
+
+
+def _snapshot(root: Path) -> dict[str, bytes]:
+    result: dict[str, bytes] = {}
+    if not root.exists():
+        return result
+    for path in root.rglob("*"):
+        if not path.is_file() or ".yuyao" in path.parts or ".trajectory" in path.parts:
+            continue
+        try:
+            if path.stat().st_size > 8 * 1024 * 1024:
+                continue
+            result[path.relative_to(root).as_posix()] = path.read_bytes()
+        except OSError:
+            continue
+    return result
+
+
+def _system_probe_hits(record: dict[str, Any], probe_token: str = "") -> tuple[str, ...]:
+    """Collect the tokens the gateway saw inside ``role=system`` messages.
+
+    The gateway records these as ``probes_in_system`` (a token map) plus
+    ``has_probe_in_system`` for the single configured ``probe_token``, which
+    lives in the gateway config rather than in the record.  It deliberately
+    keeps no request body, so there is no system text to read.  Reading a
+    differently named key yields an empty system segment for every request,
+    which the judges report as the product having dropped the flag.
+    """
+    hits = {
+        str(key)
+        for key, value in (record.get("probes_in_system") or {}).items()
+        if value
+    }
+    if record.get("has_probe_in_system") and probe_token:
+        hits.add(str(probe_token))
+    return tuple(sorted(hits))
+
+
+def _request_records(records: list[dict[str, Any]], probe_token: str = ""):
+    from doc2harness.benchmark.harnesses.headless.contracts import RequestRecord
+
+    result = []
+    for record in records:
+        body = record.get("body")
+        if not isinstance(body, str):
+            # The whole record would include the gateway's own bookkeeping,
+            # including the probe table, so a judge asking whether a token is
+            # absent from the request would always find it.  Serialise only the
+            # fields that carry what was actually sent.
+            body = json.dumps(
+                {
+                    key: value
+                    for key, value in record.items()
+                    if key in {"system_text", "messages", "msg_roles", "tool_names", "model"}
+                },
+                sort_keys=True,
+                ensure_ascii=False,
+            )
+        probes = record.get("probes") or {}
+        result.append(
+            RequestRecord(
+                body=body,
+                model=str(record.get("model") or ""),
+                system_text=str(record.get("system_text") or ""),
+                probe_hits=tuple(str(k) for k, v in probes.items() if v),
+                system_probe_hits=_system_probe_hits(record, probe_token),
+                tool_names=tuple(str(v) for v in (record.get("tool_names") or ())),
+                tool_result_texts=tuple(str(v) for v in (record.get("tool_result_texts") or ())),
+                stream_enabled=record.get("stream") if isinstance(record.get("stream"), bool) else None,
+            )
+        )
+    return tuple(result)
+
+
+def _rounds(recipe: Any, observer: str = "") -> list[list[dict[str, Any]]]:
+    rounds: list[list[dict[str, Any]]] = []
+    for group in recipe.rounds:
+        current: list[dict[str, Any]] = []
+        for call in group.calls:
+            item: dict[str, Any] = {"name": call.names[0]}
+            if call.command:
+                item["command"] = call.command
+            try:
+                arguments = json.loads(call.arguments_json)
+            except (TypeError, ValueError, json.JSONDecodeError):
+                arguments = {}
+            if isinstance(arguments, dict):
+                # An address in a declared call can only name the observer once
+                # the run has a bound listener, and the product reaches the host
+                # under a different name than the host uses for itself.  Left
+                # unresolved the fetch the point is about never arrives, and a
+                # point asking whether the fetch was refused cannot tell that
+                # from a fetch that was never attempted.
+                if observer:
+                    arguments = {
+                        key: value.replace("127.0.0.1:__D2A_MOCK_PORT__", observer)
+                        if isinstance(value, str) else value
+                        for key, value in arguments.items()
+                    }
+                # The gateway reads a bash call's arguments from top-level
+                # keys but every other tool's from "args"; spreading a grep
+                # call's arguments top-level would drop them.
+                if call.names[0] in {"bash", "shell", "run_command", "execute", "exec", "terminal"}:
+                    item.update(arguments)
+                else:
+                    item["args"] = arguments
+            current.append(item)
+        if current:
+            rounds.append(current)
+    return rounds
+
+
+def _json_object(pairs: list[tuple[str, Any]]) -> bytes:
+    """Serialise pairs verbatim, keeping any repeated key.
+
+    A duplicate-key contract probe cannot be produced by json.dumps, which
+    silently collapses the repetition that is the whole subject of the
+    point.  The unique variant is written the same way so both sides differ
+    only in the repetition itself.
+    """
+
+    body = ",".join(
+        json.dumps(key, ensure_ascii=False) + ":"
+        + json.dumps(value, ensure_ascii=False, separators=(",", ":"))
+        for key, value in pairs
+    )
+    return ("{" + body + "}").encode()
+
+
+def _formal_probe_count(recipe: Any) -> int:
+    return sum(
+        len(getattr(recipe, name, ()) or ())
+        for name in (
+            "formal_contract_probes", "formal_runtime_probes",
+            "listing_probes", "cli_file_probes",
+        )
+    )
+
+
+def _formal_rounds(recipe: Any) -> list[list[dict[str, Any]]]:
+    """Rounds for one formal probe run, repeated once per declared probe.
+
+    The two families differ in the exchange they specify.  A contract probe is
+    a tool round plus the declared reply, which its judge reads as exactly two
+    requests; a runtime-matrix probe is answered in one turn and its judge
+    requires exactly one.  Sharing a single shape would make one of the two
+    fail on the request count alone.
+    """
+
+    count = max(1, _formal_probe_count(recipe))
+    if getattr(recipe, "formal_contract_probes", ()):
+        turn = [
+            [{"name": "bash", "command": "echo FORMAL_PROBE_ACK"}],
+            [{"name": "__finish__", "content": recipe.reply_content}],
+        ]
+    else:
+        turn = [[{"name": "__finish__", "content": recipe.reply_content}]]
+    return turn * count
+
+
+def _probe_by_label(recipe: Any, label: str) -> Any:
+    """Find the declared probe a variant label came from, if any."""
+
+    for name in ("formal_contract_probes", "formal_runtime_probes", "cli_file_probes"):
+        for probe in getattr(recipe, name, ()) or ():
+            if str(getattr(probe, "label", "")) == label:
+                return probe
+    return None
+
+
+def _cli_file_variants(recipe: Any, workspace: Path) -> list[tuple[str, list[str]]]:
+    """Build one module-CLI invocation per declared CLI-file probe.
+
+    The probe declares the exact bytes of a file the product is handed through
+    a user-facing flag, so the bytes are written verbatim - the point is about
+    what happens at the decoding boundary, which a text round-trip would have
+    already resolved.
+    """
+
+    variants: list[tuple[str, list[str]]] = []
+    for probe in getattr(recipe, "cli_file_probes", ()) or ():
+        label = str(probe.label)
+        kind = str(getattr(probe, "kind", ""))
+        if kind != "system-prompt":
+            continue
+        path = workspace / f"system-prompt-{label}.txt"
+        path.write_bytes(bytes.fromhex(str(probe.file_hex)))
+        variants.append((label, [
+            "-p", str(recipe.task or "Return the fixed reply and stop."),
+            "--output-format", "text",
+            "--system-prompt-file", f"{_WORKSPACE}/{path.name}",
+        ]))
+    return variants
+
+
+def _formal_probe_variants(
+    recipe: Any, workspace: Path, output: Path, port: int,
+) -> list[tuple[str, list[str]]]:
+    """Build one launcher invocation per declared formal probe."""
+
+    probes = list(getattr(recipe, "formal_contract_probes", ()) or ())
+    probes += list(getattr(recipe, "formal_runtime_probes", ()) or ())
+    # A listing probe is not a launcher invocation: it seeds sessions through
+    # the session API and samples process counters around the listing, so it
+    # is driven by its own two-phase child rather than by run_agent.sh.  A
+    # CLI-file probe is not one either: it hands the product a file through a
+    # user-facing flag, and that route deliberately writes no status document -
+    # which is exactly the "MISSING" status the point requires.  The launcher
+    # would produce a status document the route it is about never writes.
+    if not probes:
+        return []
+    variants: list[tuple[str, list[str]]] = []
+    for probe in probes:
+        label = str(probe.label)
+        task_file = workspace / f"task-{label}.json"
+        budget_file = workspace / f"budget-{label}.json"
+        task: dict[str, Any] = {
+            "task_id": label,
+            "type": "swe",
+            "problem_statement": str(recipe.task),
+            "repo_dir": _WORKSPACE,
+            "allow_network": False,
+        }
+        for override in getattr(probe, "task_overrides", ()) or ():
+            task[str(override.field)] = override.canonical_value
+        budget: dict[str, Any] = {"max_steps": 4, "max_tokens": 0, "max_wall_seconds": 30}
+        for override in getattr(probe, "budget", ()) or ():
+            raw = str(override.canonical_value)
+            budget[str(override.field)] = int(raw) if raw.lstrip("-").isdigit() else raw
+        contract = str(getattr(probe, "raw_contract", "") or "")
+        task_pairs = list(task.items())
+        budget_pairs: list[tuple[str, Any]] = list(budget.items())
+        if contract == "duplicate-task":
+            task_pairs = [
+                ("task_id", task["task_id"]), ("type", task["type"]),
+                ("problem_statement", "Return the first fixed reply."),
+                ("problem_statement", "Return the second fixed reply."),
+                ("repo_dir", task["repo_dir"]), ("allow_network", False),
+            ]
+        if contract == "duplicate-budget":
+            budget_pairs = [
+                ("max_steps", 4), ("max_steps", 5),
+                ("max_tokens", 0), ("max_wall_seconds", 30),
+            ]
+        if contract in {"unique-task", "duplicate-task"}:
+            task_file.write_bytes(_json_object(task_pairs))
+        else:
+            task_file.write_text(json.dumps(task, ensure_ascii=False, separators=(",", ":")), encoding="utf-8")
+        if contract in {"unique-budget", "duplicate-budget"}:
+            budget_file.write_bytes(_json_object(budget_pairs))
+        else:
+            budget_file.write_text(json.dumps(budget, ensure_ascii=False, separators=(",", ":")), encoding="utf-8")
+        values = {
+            "--task-file": str(task_file).replace(str(workspace), _WORKSPACE),
+            "--repo-dir": _WORKSPACE,
+            "--model-base-url": f"http://host.docker.internal:{port}/v1",
+            "--model-name": "litellm_proxy/mock",
+            "--model-api-key": "sk-mock-test",
+            "--budget-file": str(budget_file).replace(str(workspace), _WORKSPACE),
+            "--out-dir": "/sbh-output",
+        }
+        # ``argv_overrides`` holds (flag, value) string pairs - not JsonOverride
+        # objects with .field/.canonical_value.
+        for flag_override, value_override in getattr(probe, "argv_overrides", ()) or ():
+            values[str(flag_override)] = str(value_override)
+        argv = ["--sbh-launcher"]
+        for flag in ("--task-file", "--repo-dir", "--model-base-url", "--model-name",
+                     "--model-api-key", "--budget-file", "--out-dir"):
+            argv.extend((flag, values[flag]))
+        variants.append((label, argv))
+    return variants
+
+
+_LISTING_PREFIX = "SBH-LISTING-ENTRY-"
+_LISTING_PAYLOAD_END = "-SBH-LISTING-PAYLOAD-END-"
+_LISTING_RESULT = "SBH_LISTING_RESULT="
+
+
+def _listing_probe_script(phase: str, count: int, payload_bytes: int) -> str:
+    """Build the child that seeds titled sessions, then lists them.
+
+    The point asks whether listing sessions stays bounded as the stored
+    transcripts grow: it compares read bytes, resident growth, opens under
+    HOME and the printed size against the number of sessions seeded.  Those
+    are facts about the product's own process, sampled around the dispatch,
+    so they are gathered by a child inside the container - a driver watching
+    from outside cannot attribute any of them to the listing.  Seeding and
+    measuring are separate children on purpose: a measurement taken in the
+    process that just wrote the corpus reads that writing, not the listing.
+    """
+
+    common = [
+        "import contextlib, io, json, os, resource, sys",
+        f"TAG = {_LISTING_RESULT!r}",
+        f"PREFIX = {_LISTING_PREFIX!r}",
+        f"PAYLOAD_END = {_LISTING_PAYLOAD_END!r}",
+        f"COUNT = {int(count)}",
+        f"PAYLOAD_BYTES = {int(payload_bytes)}",
+        "def emit(value):",
+        "    print(TAG + json.dumps(value, ensure_ascii=False, separators=(',', ':')))",
+        "def close(session):",
+        "    try:",
+        "        session.close()",
+        "    except BaseException:",
+        "        pass",
+    ]
+    if phase == "seed":
+        body = [
+            "result = {'phase': 'seed', 'created': 0, 'product_error': '', 'reset_ok': True}",
+            "session = None",
+            "try:",
+            "    from yuyao.agent_api import create_session",
+            "    session = create_session(cwd=os.getcwd())",
+            "    if not isinstance(session.messages, list) or not callable(getattr(session, 'dispatch', None)):",
+            "        raise TypeError('standard AgentSession messages/dispatch unavailable')",
+            "    for index in range(COUNT):",
+            "        title = PREFIX + str(index).zfill(4)",
+            "        answer = str(session.chat(title) or '')",
+            "        if PAYLOAD_END not in answer or len(answer.encode('utf-8', 'replace')) != PAYLOAD_BYTES:",
+            "            raise RuntimeError('mock assistant payload was not delivered exactly')",
+            "        if PAYLOAD_END not in json.dumps(session.messages, ensure_ascii=False):",
+            "            raise RuntimeError('assistant payload absent from public messages')",
+            "        session.dispatch('/title ' + title)",
+            "        session.dispatch('/new')",
+            "        result['created'] += 1",
+            "        if len(session.messages) != 0:",
+            "            result['reset_ok'] = False",
+            "            break",
+            "except BaseException as exc:",
+            "    result['product_error'] = type(exc).__name__ + ': ' + str(exc)[:240]",
+            "finally:",
+            "    close(session)",
+            "emit(result)",
+        ]
+        return "\n".join(common + body) + "\n"
+    if phase != "measure":
+        raise ValueError(f"unknown listing probe phase {phase!r}")
+    body = [
+        "result = {'phase': 'measure', 'product_error': '', 'observer_error': ''}",
+        "session = None",
+        "def io_stats():",
+        "    try:",
+        "        data = {}",
+        "        with open('/proc/self/io', 'r', encoding='ascii') as handle:",
+        "            for line in handle:",
+        "                key, _, value = line.partition(':')",
+        "                data[key.strip()] = int(value.strip())",
+        "        return data",
+        "    except BaseException:",
+        "        return None",
+        "def rss_kib():",
+        "    try:",
+        "        return int(resource.getrusage(resource.RUSAGE_SELF).ru_maxrss)",
+        "    except BaseException:",
+        "        return None",
+        "try:",
+        "    from yuyao.agent_api import create_session",
+        "    session = create_session(cwd=os.getcwd())",
+        "    if not callable(getattr(session, 'dispatch', None)):",
+        "        raise TypeError('standard AgentSession dispatch unavailable')",
+        "    opened = {'home': 0}",
+        "    home = os.path.realpath(os.environ['HOME']) + os.sep",
+        "    def audit(event, args):",
+        "        if event != 'open' or not args:",
+        "            return",
+        "        try:",
+        "            path = os.path.realpath(os.fsdecode(args[0]))",
+        "        except BaseException:",
+        "            return",
+        "        if path.startswith(home):",
+        "            opened['home'] += 1",
+        "    sys.addaudithook(audit)",
+        "    io_before, rss_before = io_stats(), rss_kib()",
+        "    capture = io.StringIO()",
+        "    with contextlib.redirect_stdout(capture), contextlib.redirect_stderr(capture):",
+        "        returned = session.dispatch('/sessions')",
+        "    io_after, rss_after = io_stats(), rss_kib()",
+        "    printed = capture.getvalue()",
+        "    joiner = chr(10) if returned and printed else ''",
+        "    public = (str(returned or '') + joiner + printed).strip()",
+        "    absent = io_before is None or io_after is None or rss_before is None or rss_after is None",
+        "    result.update({",
+        "        'rchar_delta': None if io_before is None or io_after is None else max(0, io_after.get('rchar', 0) - io_before.get('rchar', 0)),",
+        "        'read_bytes_delta': None if io_before is None or io_after is None else max(0, io_after.get('read_bytes', 0) - io_before.get('read_bytes', 0)),",
+        "        'rss_delta_kib': None if rss_before is None or rss_after is None else max(0, rss_after - rss_before),",
+        "        'home_open_count': opened['home'],",
+        "        'output_bytes': len(public.encode('utf-8', 'replace')),",
+        "        'listed_markers': public.count(PREFIX),",
+        "    })",
+        "    if absent:",
+        "        result['observer_error'] = 'bytes/RSS observer unavailable'",
+        "except BaseException as exc:",
+        "    result['product_error'] = type(exc).__name__ + ': ' + str(exc)[:240]",
+        "finally:",
+        "    close(session)",
+        "emit(result)",
+    ]
+    return "\n".join(common + body) + "\n"
+
+
+def _listing_payload(payload_bytes: int) -> str:
+    """The exact assistant reply the seed phase requires the mock to send."""
+
+    suffix = len(_LISTING_PAYLOAD_END.encode("utf-8"))
+    return "L" * max(0, int(payload_bytes) - suffix) + _LISTING_PAYLOAD_END
+
+
+def _listing_result(completed: subprocess.CompletedProcess[str]) -> dict[str, Any] | None:
+    """Read the child's declared result line out of its stdout."""
+
+    parsed: dict[str, Any] | None = None
+    for line in (completed.stdout or "").splitlines():
+        if not line.startswith(_LISTING_RESULT):
+            continue
+        try:
+            candidate = json.loads(line[len(_LISTING_RESULT):])
+        except ValueError:
+            continue
+        if isinstance(candidate, dict):
+            parsed = candidate
+    return parsed
+
+
+def _argv_variants(recipe: Any) -> list[tuple[str, list[str]]]:
+    if recipe.sequence_subcommands:
+        # Use the declared step names when the point has them: its judge looks
+        # the steps up by name, and a positional "step-N" label makes every
+        # lookup miss and the matrix read as incomplete.
+        labels = list(getattr(recipe, "sequence_labels", ()) or ())
+        return [
+            (
+                labels[index - 1]
+                if index - 1 < len(labels)
+                else f"step-{index}",
+                list(arguments),
+            )
+            for index, arguments in enumerate(recipe.sequence_subcommands, start=1)
+        ]
+    base = ["-p", recipe.task, "--output-format", recipe.output_format]
+    if recipe.append_system_prompt:
+        base += ["--append-system-prompt", recipe.append_system_prompt]
+    if recipe.system_prompt:
+        base += ["--system-prompt", recipe.system_prompt]
+    base += list(recipe.extra_argv)
+    if recipe.subcommand_variants:
+        return [(item.label, list(item.arguments)) for item in recipe.subcommand_variants]
+    variants = recipe.cli_variants or recipe.file_variants
+    if variants:
+        return [(item.label, base + list(item.arguments)) for item in variants]
+    return [("main", base)]
+
+
+_STEP_MARKER = "SBH-STEP-BOUNDARY-"
+
+
+def _sequence_script(steps: list[list[str]], settle_seconds: int) -> str:
+    """Run every declared step in one shell, marking each boundary.
+
+    A dispatch step starts a detached session and returns at once; the
+    container's init reaps that session the moment the foreground process
+    exits.  Running each step as its own container would kill the session
+    before the next step could list or stop it.  One
+    shell for the whole sequence keeps the session alive across the steps
+    that are about it, and the declared window is honoured between them.
+    """
+
+    entry = "/sbh-artifact/src/yuyao/__main__.py"
+    lines = ["AGENT_SESSION_ID="]
+    for index, step in enumerate(steps, start=1):
+        lines.append(f'echo "{_STEP_MARKER}{index}"')
+        lines.append(
+            "python3 " + entry + " "
+            + " ".join(
+                # A step naming the session an earlier step started cannot know
+                # its identifier ahead of time, so the placeholder is resolved
+                # in the shell that just saw the dispatch report it.
+                '"$AGENT_SESSION_ID"' if item == "$AGENT_SESSION_ID" else shlex.quote(item)
+                for item in step
+            )
+            + f" 2>&1 | tee /tmp/sbh-step-{index}.out"
+        )
+        lines.append(f'echo "{_STEP_MARKER}{index}-rc=${{PIPESTATUS[0]}}"')
+        lines.append(
+            "if [ -z \"$AGENT_SESSION_ID\" ]; then "
+            f"AGENT_SESSION_ID=$(sed -n 's/^dispatched \\([A-Za-z0-9_-]*\\).*/\\1/p' /tmp/sbh-step-{index}.out | head -1); fi"
+        )
+        if settle_seconds:
+            lines.append(f"sleep {int(settle_seconds)}")
+    return "\n".join(lines) + "\n"
+
+
+def _sequence_steps(text: str, count: int) -> list[tuple[str, int]]:
+    """Split one sequence run's output back into per-step text and codes."""
+
+    results: list[tuple[str, int]] = []
+    for index in range(1, count + 1):
+        start = text.find(f"{_STEP_MARKER}{index}\n")
+        if start < 0:
+            results.append(("", -1))
+            continue
+        start += len(f"{_STEP_MARKER}{index}\n")
+        end = text.find(f"{_STEP_MARKER}{index}-rc=", start)
+        body = text[start:end] if end >= 0 else text[start:]
+        code = -1
+        if end >= 0:
+            tail = text[end + len(f"{_STEP_MARKER}{index}-rc="):].split("\n", 1)[0]
+            if tail.strip().lstrip("-").isdigit():
+                code = int(tail.strip())
+        results.append((body, code))
+    return results
+
+
+_BOOKKEEPING_DIRS = {".git", ".yuyao", ".trajectory", "__pycache__", "node_modules"}
+
+
+def _worktree_facts(
+    workspace: Path, home: Path, target: str, needle: str,
+) -> tuple[tuple[str, ...], str, str]:
+    """Find the checkouts beside the repository and what they hold.
+
+    A worktree point asserts two things at once: the write reached an
+    isolated checkout, and the parent tree did not see it.  The second can be
+    read from the workspace, but the first cannot - the checkout lives
+    outside the repository, so looking only inside it finds nothing however
+    well the product isolated the work, and the point reports the isolation
+    absent.
+
+    ``git worktree list`` answers in the paths the product saw, which are the
+    container's.  They are translated back to the host so the content can
+    actually be read; without that the paths are published and every read of
+    them fails.
+    """
+
+    def host(path: str) -> Path:
+        for container, local in ((_WORKSPACE, workspace), ("/sbh-home", home)):
+            if path == container:
+                return local
+            if path.startswith(container + "/"):
+                return local / path[len(container) + 1:]
+        return Path(path)
+
+    paths: list[str] = []
+    listing = subprocess.run(
+        ("git", "worktree", "list", "--porcelain"), cwd=workspace,
+        capture_output=True, text=True, timeout=15, check=False,
+    )
+    for line in (listing.stdout or "").splitlines():
+        if not line.startswith("worktree "):
+            continue
+        candidate = line.split(" ", 1)[1]
+        if host(candidate).resolve() != workspace.resolve():
+            paths.append(candidate)
+    # A product may build the checkout beside the repository without
+    # registering it, so the declared sibling naming is checked too.  The
+    # match is deliberately anchored on the repository's own name: a looser
+    # one would collect the other variant's directory from the same parent.
+    for sibling in sorted(workspace.parent.iterdir()):
+        if not sibling.is_dir() or sibling.resolve() == workspace.resolve():
+            continue
+        if sibling.name.startswith(workspace.name + "-") or sibling.name.startswith(workspace.name + "__"):
+            if str(sibling) not in paths:
+                paths.append(str(sibling))
+    name = Path(target).name if target else ""
+    for item in paths:
+        root = host(item)
+        if not root.is_dir():
+            continue
+        candidates = [root / target] if target else []
+        for base, directories, files in os.walk(root):
+            directories[:] = [d for d in directories if d not in _BOOKKEEPING_DIRS]
+            candidates.extend(Path(base) / found for found in files if found == name)
+        for candidate in candidates:
+            try:
+                if not candidate.is_file() or candidate.stat().st_size > 200_000:
+                    continue
+                content = candidate.read_text(encoding="utf-8", errors="replace")
+            except OSError:
+                continue
+            if needle and needle in content:
+                return tuple(paths), content, str(candidate)
+    return tuple(paths), "", ""
+
+
+def _docker_command(
+    artifact: Path,
+    workspace: Path,
+    home: Path,
+    output: Path,
+    argv: list[str],
+    env: dict[str, str],
+    port: int,
+) -> list[str]:
+    """Build the container invocation for one declared run."""
+
+    image = os.environ.get("SBH_EVALUATION_IMAGE", "doc2harness/evaluation:candidate")
+    command = [
+        "docker", "run", *container_memory_flags(), "--rm", "--init", "--network", "bridge",
+        "--add-host=host.docker.internal:host-gateway", "--read-only",
+        "--tmpfs", "/tmp:rw,noexec,nosuid,size=256m",
+        "--user", f"{os.getuid()}:{os.getgid()}",
+        "-v", f"{artifact}:/sbh-artifact:ro",
+        # The workspace is mounted inside a writable parent, not directly
+        # under the read-only root, because a product that isolates a
+        # background session builds its worktree as a *sibling* of the
+        # repository.  With no writable directory beside it that sibling cannot
+        # be created, the product silently falls back to the repository itself,
+        # and a point about isolation observes the write landing exactly where
+        # it asserted it would not.
+        "-v", f"{workspace.parent}:{_TREE}:rw",
+        # Without an explicit working directory the container starts in the
+        # image default, so a relative path in a declared tool call lands
+        # outside the mounted workspace: the write happens, the observer looks
+        # in the right place and finds nothing, and the point reports that the
+        # baseline write was never observed.
+        "-w", _WORKSPACE,
+        "-v", f"{home}:/sbh-home:rw",
+        "-v", f"{output}:/sbh-output:rw",
+    ]
+    container_env = {
+        "HOME": "/sbh-home",
+        "YUYAO_HOME": "/sbh-home/.yuyao",
+        "PYTHONDONTWRITEBYTECODE": "1",
+        "PYTHONPATH": "/sbh-artifact/src" + (":/sbh-artifact" if argv and argv[0] == "--sbh-python" else ""),
+        "D2A_MODEL_BASE_URL": f"http://host.docker.internal:{port}/v1",
+        "D2A_MODEL_NAME": "litellm_proxy/mock",
+        "D2A_MODEL_API_KEY": "sk-mock-test",
+    }
+    # A recipe or probe may declare product settings of its own - retry limits,
+    # for instance - and those are not addressed to the model connection, so
+    # they are forwarded too.  The container's own paths still win: forwarding the host
+    # HOME or YUYAO_HOME would point the product at directories it cannot see.
+    declared = {
+        key: value for key, value in env.items()
+        if (key.startswith("D2A_") or key.startswith("MSWEA_"))
+        and key not in container_env
+    }
+    for key, value in {**container_env, **declared}.items():
+        command.extend(("-e", f"{key}={value}"))
+    # A formal-contract probe drives the launcher with its seven declared
+    # flags rather than the module CLI.  The sentinel lets one call site build
+    # both without a second runner.
+    if argv and argv[0] == "--sbh-launcher":
+        command.extend((image, "bash", "/sbh-artifact/run_agent.sh"))
+        command.extend(argv[1:])
+    elif argv and argv[0] == "--sbh-python":
+        # A listing probe drives the session API directly rather than the
+        # module CLI, so it runs as its own interpreter inside the same
+        # container: the counters it samples only mean something in the
+        # process that performs the listing.
+        command.extend((image, "python3", *argv[1:]))
+    else:
+        entry = "/sbh-artifact/src/yuyao/__main__.py"
+        if argv and argv[0] == "--sbh-script":
+            command.extend((image, "bash", "-lc", argv[1]))
+        else:
+            command.extend((image, "python3", entry))
+            command.extend(argv)
+    return command
+
+
+def _docker_run(
+    artifact: Path,
+    workspace: Path,
+    home: Path,
+    output: Path,
+    argv: list[str],
+    env: dict[str, str],
+    port: int,
+    timeout: int,
+) -> tuple[subprocess.CompletedProcess[str], bool]:
+    command = _docker_command(artifact, workspace, home, output, argv, env, port)
+    try:
+        return subprocess.run(command, cwd=workspace, env=env, stdin=subprocess.DEVNULL,
+                              capture_output=True, text=True, timeout=timeout, check=False), False
+    except subprocess.TimeoutExpired as exc:
+        return subprocess.CompletedProcess(command, -1, exc.stdout or "", exc.stderr or ""), True
+
+
+def _run_one() -> dict[str, Any]:
+    from doc2harness.benchmark.definition import definition_digest
+    from doc2harness.benchmark.dispatch import load_scenario_owner
+    from doc2harness.benchmark.harnesses.headless.adapter import build_headless_execution_plan
+    from doc2harness.benchmark.harnesses.headless.contracts import (
+        HeadlessObservation, ObservedFile, ProcessObservation,
+    )
+
+    scenario_id = os.environ["SBH_SCENARIO_ID"]
+    owner = load_scenario_owner(scenario_id)
+    if ".benchmark.harnesses.headless." not in owner.module:
+        raise RuntimeError("headless driver received a non-headless scenario")
+    scenario = owner.scenario
+    plan = build_headless_execution_plan(scenario)
+    artifact = Path(os.environ["SBH_ARTIFACT_PATH"])
+    gateway = mock_gateway
+    server = gateway.ThreadingHTTPServer(("0.0.0.0", 0), gateway.Handler)
+    recipe = scenario.recipe
+    # A scenario that declares an appended system prompt but no explicit probe
+    # token is asserting that the appended text reaches the wire, so the append
+    # text *is* the probe.  Without this fallback the gateway is told to look
+    # for nothing, every request records an empty system segment, and the judge
+    # reports the product as having dropped the flag.
+    probe_token = recipe.probe_token or getattr(recipe, "append_system_prompt", "") or ""
+    probe_tokens = list(recipe.probe_tokens)
+    if probe_token and probe_token not in probe_tokens:
+        probe_tokens.append(probe_token)
+    # A formal probe is answered by the declared fixed reply, not by the tool
+    # sequence the other headless points drive: its judge compares the exact
+    # reply text and a bounded request count, which a seq_probe round would
+    # replace with a tool call and a different exchange length.  A CLI-file
+    # probe declares its own gateway mode and is left to it: the formal shape
+    # would replace its single fixed reply with a tool exchange and break the
+    # request count the point pins.
+    formal = bool(
+        getattr(recipe, "formal_contract_probes", ())
+        or getattr(recipe, "formal_runtime_probes", ())
+        or getattr(recipe, "listing_probes", ())
+    )
+    cfg = gateway.new_cfg(
+        mode="seq_probe" if formal else recipe.gateway_mode,
+        reply_content=recipe.reply_content,
+        probe_token=probe_token,
+        probe_tokens=probe_tokens,
+        command=recipe.command or "echo HEADLESS_PROOF_7731",
+        # A verbose-route point names each model turn with its own token, so the
+        # gateway is told which text to attach to the tool-call turn and which
+        # to the reply.  The first and last declared probe tokens are those two
+        # turns by construction.
+        turn_contents=(
+            None
+        ),
+        # The gateway hands out one declared round per request and the rounds
+        # are shared across every variant in the run, so a formal point needs
+        # its two-request exchange repeated once per probe - otherwise the
+        # first probe consumes the sequence and the rest see an empty turn.
+        rounds=(
+            _formal_rounds(recipe)
+            if formal
+            # The gateway serves one declared round per request and the same
+            # sequence covers every variant in the run, so a point that runs
+            # several variants needs its rounds repeated once per variant -
+            # otherwise the first variant consumes them and the rest observe an
+            # exchange the recipe never described.  Each repetition also needs
+            # its own closing turn: a variant's exchange does not end until the
+            # model answers without a tool call, so without one the first
+            # variant runs on into the next variant's round and the second is
+            # handed the leftover reply instead of its own call.
+            else (_rounds(
+                recipe, f"host.docker.internal:{int(server.server_address[1])}"
+            ) + [[{"name": "__finish__", "content": recipe.reply_content or "done"}]]
+            ) * max(1, len(_argv_variants(recipe)))
+        ),
+    )
+    server.cfg = cfg
+    server.daemon_threads = True
+    server.block_on_close = False
+    thread = threading.Thread(target=server.serve_forever, daemon=True)
+    thread.start()
+    with tempfile.TemporaryDirectory(prefix="sbh-headless-production-") as temporary:
+        root = Path(temporary)
+        home, workspace, output = root / "home", root / "tree" / "workspace", root / "out"
+        # The workspace sits inside a directory of its own so the container can
+        # mount that directory writable: a product isolating a background
+        # session builds its worktree beside the repository, and it needs
+        # somewhere to put it.  Only this tree is mounted, so home and output
+        # stay where they are and are not exposed twice.
+        workspace.parent.mkdir(parents=True)
+        home.mkdir(); workspace.mkdir(); output.mkdir()
+        for seed in recipe.seed_files:
+            path = workspace / seed.path
+            path.parent.mkdir(parents=True, exist_ok=True)
+            path.write_text(seed.content, encoding="utf-8")
+        # A worktree point is about a git operation not disturbing its parent
+        # repository, so the workspace has to be one.  Without it the point can
+        # only report that the fixture was unavailable.
+        if any(variant.label == "wt" for variant in ((recipe.cli_variants or ()) + (recipe.file_variants or ()))):
+            identity = ("-c", "user.email=fixture@example.invalid", "-c", "user.name=SBH Fixture")
+            for arguments in (("init", "-q"), ("add", "-A"), ("commit", "-q", "-m", "baseline", "--allow-empty")):
+                subprocess.run(
+                    ("git", *identity, *arguments), cwd=workspace, check=False,
+                    stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
+                )
+        env = dict(os.environ)
+        env.update(dict(recipe.environment))
+        env.update({"HOME": str(home), "YUYAO_HOME": str(home / ".yuyao"),
+                    "PYTHONDONTWRITEBYTECODE": "1"})
+        runs: list[ProcessObservation] = []
+        # A listing point is decided by facts about the product's own process -
+        # bytes read, resident growth, opens under HOME - sampled around the
+        # listing dispatch.  Each probe gets its own HOME so the corpus one
+        # seeds is not counted against the other, and each is seeded and
+        # measured by separate children so the measurement does not read the
+        # writing that produced the corpus.
+        listing_probes = tuple(getattr(recipe, "listing_probes", ()) or ())
+        # A compact/rewind point is about session management across a
+        # compaction, which only exists inside a live session: the checkpoint
+        # the product offers, whether the pre-compact turn is still named, and
+        # the listing's own selection syntax.
+        session_facts: dict[str, Any] = {}
+        for probe in listing_probes:
+            probe_home = root / f"home-{probe.label}"
+            probe_workspace = root / f"tree-{probe.label}" / "workspace"
+            probe_home.mkdir(exist_ok=True)
+            probe_workspace.mkdir(parents=True, exist_ok=True)
+            probe_env = dict(env)
+            probe_env.update({"HOME": str(probe_home), "YUYAO_HOME": str(probe_home / ".yuyao")})
+            cfg["mode"] = "fixed_reply"
+            cfg["reply_content"] = _listing_payload(probe.payload_bytes)
+            script = probe_workspace / "sbh_listing_probe.py"
+            row: dict[str, Any] = {
+                "seed_created": 0, "listed_markers": None, "rchar_delta": None,
+                "rss_delta_kib": None, "home_open_count": None, "output_bytes": None,
+                "product_error": "", "start_error": "", "timed_out": False,
+            }
+
+            def run_phase(phase: str, timeout: int) -> tuple[dict[str, Any] | None, str]:
+                script.write_text(
+                    _listing_probe_script(phase, probe.count, probe.payload_bytes),
+                    encoding="utf-8",
+                )
+                completed, expired = _docker_run(
+                    artifact, probe_workspace, probe_home, output,
+                    ["--sbh-python", f"{_WORKSPACE}/sbh_listing_probe.py"],
+                    probe_env, int(server.server_address[1]), timeout,
+                )
+                if expired:
+                    return None, "TIMEOUT"
+                parsed = _listing_result(completed)
+                if parsed is None:
+                    tail = (completed.stderr or completed.stdout or "")[-160:]
+                    return None, f"NO_RESULT_RC_{completed.returncode}:{tail}"
+                return parsed, ""
+
+            seeded, seed_error = run_phase("seed", int(recipe.seed_timeout_seconds or 120))
+            if seed_error == "TIMEOUT":
+                row["timed_out"] = True
+            elif seed_error:
+                row["start_error"] = f"SEED_{seed_error}"
+            elif seeded is not None:
+                row["seed_created"] = int(seeded.get("created") or 0)
+                row["product_error"] = str(seeded.get("product_error") or "")
+                if seeded.get("reset_ok") is not True and not row["product_error"]:
+                    row["product_error"] = "public /new did not reset messages"
+            if not row["start_error"] and not row["timed_out"]:
+                measured, measure_error = run_phase(
+                    "measure", int(recipe.measurement_timeout_seconds or 60)
+                )
+                if measure_error == "TIMEOUT":
+                    row["timed_out"] = True
+                elif measure_error:
+                    row["start_error"] = f"MEASURE_{measure_error}"
+                elif measured is not None:
+                    for key in ("listed_markers", "rchar_delta", "rss_delta_kib",
+                                "home_open_count", "output_bytes"):
+                        row[key] = measured.get(key)
+                    later = str(measured.get("product_error") or "")
+                    if later:
+                        row["product_error"] = (
+                            f"{row['product_error']}; {later}" if row["product_error"] else later
+                        )
+            runs.append(ProcessObservation(
+                label=probe.label,
+                rc=0 if not row["start_error"] else -1,
+                timed_out=bool(row["timed_out"]),
+                start_error=str(row["start_error"]),
+                cleanup_complete=not row["timed_out"],
+                count=probe.count,
+                payload_bytes=probe.payload_bytes,
+                seed_created=row["seed_created"],
+                listed_markers=row["listed_markers"],
+                rchar_delta=row["rchar_delta"],
+                rss_delta_kib=row["rss_delta_kib"],
+                home_open_count=row["home_open_count"],
+                output_bytes=row["output_bytes"],
+                product_error=str(row["product_error"]),
+            ))
+        # A formal-contract or runtime-matrix point is specified over launcher
+        # invocations with declared task/budget documents, not over the module
+        # CLI flags the other points use.
+        variants = [] if listing_probes or runs else (
+            _cli_file_variants(recipe, workspace)
+            or _formal_probe_variants(recipe, workspace, output, int(server.server_address[1]))
+            or _argv_variants(recipe)
+        )
+        agent_session_id = ""
+        # A sequence whose recipe declares a settle window is about work that
+        # outlives the command that started it.  Run as separate containers,
+        # that work would be reaped when its step exits, and the step that lists
+        # or stops the session would find one that had already finished.  The
+        # whole sequence therefore runs in one container: the session stays
+        # alive across the steps that are about it.
+        sequence_pause = min(int(recipe.sequence_pause_seconds or 0), 30)
+        if sequence_pause and variants:
+            steps = [list(argv) for _, argv in variants]
+            # A point that acts on a session started by an earlier step needs
+            # that session to still be running when it does.  The observer
+            # answers instantly, so the session finishes first and "stopped a
+            # dead session" reads exactly like "stopped a live one".  Holding
+            # each answer for the declared settle window keeps it alive across
+            # the steps that are about it.
+            if len(steps) > 2:
+                cfg["response_delay_s"] = sequence_pause * len(steps)
+            script = _sequence_script(steps, sequence_pause)
+            before = _snapshot(workspace)
+            request_start = len(cfg.get("requests", []))
+            completed, timed_out = _docker_run(
+                artifact, workspace, home, output, ["--sbh-script", script], env,
+                int(server.server_address[1]),
+                min(recipe.timeout_seconds, 300) + sequence_pause * len(steps),
+            )
+            blob = str(completed.stdout or "") + "\n" + str(completed.stderr or "")
+            found = re.search(
+                r"dispatched\s+(?:background\s+session\s+)?([A-Za-z0-9_-]+)", blob, re.I
+            )
+            if found:
+                agent_session_id = found.group(1)
+            after = _snapshot(workspace)
+            written = tuple(sorted(k for k in after if before.get(k) != after.get(k)))
+            removed = tuple(sorted(k for k in before if k not in after))
+            records = _request_records(
+                list(cfg.get("requests", []))[request_start:], probe_token
+            )
+            outputs = _sequence_steps(str(completed.stdout or ""), len(steps))
+            for (label, _), (text, code) in zip(variants, outputs):
+                runs.append(ProcessObservation(
+                    label=label,
+                    rc=code,
+                    stdout=text,
+                    timed_out=timed_out,
+                    requests=records,
+                    written_paths=written,
+                    removed_paths=removed,
+                    exit_status=str(_status(output).get("exit_status") or ""),
+                    cleanup_complete=not timed_out,
+                    git_initialized=(workspace / ".git").is_dir(),
+                ))
+            variants = []
+        for label, argv in variants:
+            # A probe may name the protocol failure it is about and the
+            # environment it needs - an upstream 401 with retries pinned to one
+            # attempt, say.  Both are declared per probe, not per recipe; the
+            # recipe-level mode alone would exercise the healthy exchange and
+            # judge error reporting on a run where no error occurred.
+            declared = _probe_by_label(recipe, label)
+            probe_mode = str(getattr(declared, "gateway_mode", "") or "")
+            probe_env = dict(getattr(declared, "environment", ()) or ())
+            cfg["mode"] = probe_mode or ("seq_probe" if formal else recipe.gateway_mode)
+            variant_env = {**env, **probe_env}
+            # Variants are contrasted against each other - a permitted run
+            # against a restricted one - so each has to start from the
+            # declared fixture.  Carrying the previous variant's write over
+            # makes the restricted run look like it performed a write it was
+            # actually prevented from performing.
+            for seed in recipe.seed_files:
+                path = workspace / seed.path
+                path.parent.mkdir(parents=True, exist_ok=True)
+                path.write_text(seed.content, encoding="utf-8")
+            request_start = len(cfg.get("requests", []))
+            # The gets a variant made are sliced the same way its requests are:
+            # the two flags share one observer, so an unsliced read would
+            # attribute the permitted variant's fetch to the restricted one and
+            # the point would report a leak that never happened.
+            web_start = len(cfg.get("web_gets", []))
+            before = _snapshot(workspace)
+            # A step that acts on a session started by an earlier step has to
+            # name that session, and its identifier only exists once the
+            # dispatch has run.  The recipe writes the placeholder and it is
+            # resolved from what the dispatch reported; left unresolved the
+            # command is handed a literal "$AGENT_SESSION_ID" and stops the
+            # session the point is about being unable to name.
+            if agent_session_id:
+                argv = [item.replace("$AGENT_SESSION_ID", agent_session_id) for item in argv]
+            completed, timed_out = _docker_run(
+                artifact, workspace, home, output, argv, variant_env,
+                int(server.server_address[1]), min(recipe.timeout_seconds, 300),
+            )
+            if not agent_session_id:
+                blob = str(completed.stdout or "") + "\n" + str(completed.stderr or "")
+                found = re.search(
+                    r"dispatched\s+(?:background\s+session\s+)?([A-Za-z0-9_-]+)", blob, re.I
+                ) or re.search(
+                    r"(?m)^\s*([A-Za-z0-9_-]{6,})\s+"
+                    r"(?:running|waiting|completed|stopped|failed)\b",
+                    blob, re.I,
+                )
+                if found:
+                    agent_session_id = found.group(1)
+            after = _snapshot(workspace)
+            written = tuple(sorted(k for k in after if before.get(k) != after.get(k)))
+            removed = tuple(sorted(k for k in before if k not in after))
+            target = workspace / recipe.target_file if recipe.target_file else None
+            target_content = target.read_text(encoding="utf-8", errors="replace") if target and target.is_file() else ""
+            # An isolation point also has to see the checkout beside the
+            # repository, which the workspace read cannot reach.
+            worktree_paths, worktree_content, worktree_found = (
+                _worktree_facts(workspace, home, recipe.target_file, recipe.target_written)
+                if (workspace / ".git").is_dir() and recipe.target_file
+                else ((), "", "")
+            )
+            status = _status(output)
+            records = _request_records(
+                list(cfg.get("requests", []))[request_start:], probe_token
+            )
+            runs.append(ProcessObservation(
+                label=label,
+                rc=int(completed.returncode),
+                stdout=str(completed.stdout or ""),
+                stderr=str(completed.stderr or ""),
+                timed_out=timed_out,
+                requests=records,
+                written_paths=written,
+                removed_paths=removed,
+                target_content=target_content,
+                worktree_paths=worktree_paths,
+                worktree_target_content=worktree_content,
+                marker_found_at=worktree_found,
+                web_gets=tuple(
+                    str(item.get("path") or "")
+                    for item in list(cfg.get("web_gets", []))[web_start:]
+                ),
+                # A point can require that a route write *no* status document -
+                # a user-facing CLI flag is not the unattended contract and
+                # deliberately reports no terminal state.  Publishing an empty
+                # string for that made "absent" indistinguishable from "present
+                # but blank", so the absence is named.
+                exit_status=str(status.get("exit_status") or ("" if status else "MISSING")),
+                cleanup_complete=not timed_out,
+                out_created=bool(status),
+                repo_changed=bool(written or removed),
+                git_initialized=(workspace / ".git").is_dir(),
+                product_error=str(status.get("error") or ""),
+            ))
+        observed_files = tuple(
+            ObservedFile(path, (workspace / path).read_text(encoding="utf-8", errors="replace"))
+            for path in sorted({item.path for item in recipe.seed_files})
+            if (workspace / path).is_file()
+        )
+        # Some points inspect what the artifact itself ships rather than what
+        # the run produced - the README is the delivered document, not a seeded
+        # fixture, so reading only the workspace leaves the judge with nothing
+        # to inspect and it reports the file as missing.
+        for shipped in ("README.md",):
+            path = artifact / shipped
+            if path.is_file():
+                observed_files += (
+                    ObservedFile(shipped, path.read_text(encoding="utf-8", errors="replace")),
+                )
+        observation = HeadlessObservation(
+            scenario_id=scenario_id,
+            profile=recipe.profile,
+            plan_digest=plan.plan_digest,
+            artifact_id=os.environ["SBH_ARTIFACT_ID"],
+            artifact_digest=os.environ["SBH_ARTIFACT_DIGEST"],
+            backend_evidence_digest=_digest({"scenario_id": scenario_id, "runs": [asdict(item) for item in runs]}),
+            cli_available=(artifact / "src/yuyao/__main__.py").is_file(),
+            runs=tuple(runs),
+            artifact_files=observed_files,
+            repository_root=_WORKSPACE,
+            # The identifier the dispatch reported.  A point that asks whether
+            # stopping a session takes effect has to know which session it
+            # stopped, and only the dispatch output carries that.
+            agent_session_id=agent_session_id,
+            session_start_error=str(session_facts.get("start_error") or ""),
+            checkpoint_id=str(session_facts.get("checkpoint_id") or ""),
+            pre_listing=str(session_facts.get("pre_listing") or ""),
+            selection_command=str(session_facts.get("selection_command") or ""),
+            selection_result=str(session_facts.get("selection_result") or ""),
+            driver_error="" if runs else "HEADLESS_NO_RUN",
+            process_tree_clean=all(not item.timed_out for item in runs),
+            workspace_clean=True,
+        )
+    server.shutdown(); server.server_close(); thread.join(timeout=2)
+    judgement = owner.judge(observation)
+    return {"observation": observation, "judgement": judgement,
+            "module": owner.module, "definition_digest": definition_digest(owner.definition)}
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.parse_args()
+    result = _run_one()
+    Path(os.environ["SBH_TYPED_EVENT_PATH"]).write_text(json.dumps({
+        "schema": "doc2harness.typed-events/1", "source_digest": os.environ["SBH_SOURCE_DIGEST"],
+        "task_digest": os.environ["SBH_TASK_DIGEST"], "budget_digest": os.environ["SBH_BUDGET_DIGEST"],
+        "artifact_digest": os.environ["SBH_ARTIFACT_DIGEST"], "artifact_id": os.environ["SBH_ARTIFACT_ID"],
+        "scenario_id": os.environ["SBH_SCENARIO_ID"], "scenario_module": result["module"],
+        "definition_digest": result["definition_digest"],
+        "events": [{"type": "headless-observation", "observation": asdict(result["observation"]),
+                    "judgement": asdict(result["judgement"])}],
+    }, ensure_ascii=False, default=lambda value: value.value if hasattr(value, "value") else str(value), indent=2) + "\n", encoding="utf-8")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/code/src/doc2harness/runtime/mock_gateway.py b/code/src/doc2harness/runtime/mock_gateway.py
new file mode 100644
index 0000000000000000000000000000000000000000..a0aaa37070b27e11f3947aa97b12a06db53d3b97
--- /dev/null
+++ b/code/src/doc2harness/runtime/mock_gateway.py
@@ -0,0 +1,1448 @@
+"""A deterministic OpenAI-compatible model gateway for fault injection.
+
+Point an artifact's ``D2A_MODEL_BASE_URL`` at this server and it stands in for
+the model, answering every request deterministically and spending no real model
+budget.  By default it drives the agent through one observable tool call; the
+selected mode injects a specific real-world fault instead - absent ``usage``,
+missing response fields, malformed tool-call arguments, prose with no tool call,
+and so on.  Those are the conditions a live model reproduces only by luck, and
+an evaluation that cannot reproduce them cannot measure how a product handles
+them.
+
+Every received request is recorded - message count, embedded NUL bytes, the
+Authorization header, the model name, the wire-level message roles - so a
+scenario can assert against what the product actually sent rather than against
+prose describing it.
+
+``litellm`` (``litellm_proxy/<name>``) POSTs to ``{api_base}/chat/completions``,
+so any POST whose path ends in ``chat/completions`` is answered.  GET always
+returns an empty object, which keeps an incidental ``/models`` probe happy.
+
+Runs standalone (``python -m doc2harness.runtime.mock_gateway --port 9009
+--mode usage_null``) or in-process: build an isolated configuration with
+``new_cfg()``, serve it with ``make_server()``, and read ``cfg["requests"]``
+afterwards.  Each server owns its configuration, so concurrent scenarios do not
+interfere.
+
+This module deliberately depends on nothing outside the standard library: it is
+the stimulus source for every driver in this package, and a driver that could
+only reach its gateway through a private checkout would leave the published
+distribution unable to execute a single scenario.
+"""
+
+from __future__ import annotations
+import argparse
+import hashlib
+import json
+import os
+import re
+import threading
+import time
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+
+CONFIG: dict = {
+    "mode": os.environ.get("MOCK_MODE", "normal"),
+    "command": os.environ.get("MOCK_COMMAND", "echo MOCK_PROOF_7731 > mock_proof.txt"),
+    "usage_tokens": (12, 8),
+    "reject_substr": "",
+    "strict": False,
+    "requests": [],
+}
+
+
+def new_cfg(**over) -> dict:
+    """Build an isolated cfg so concurrent servers never share state."""
+    c = {
+        "mode": "normal",
+        "command": "echo MOCK_PROOF_7731 > mock_proof.txt",
+        "usage_tokens": (12, 8),
+        "reject_substr": "",
+        "strict": False,
+        "allow_cmd": "echo PERM_LIVE_7755 > live.txt",
+        "deny_cmd": "touch PERM_DENY_7755.txt",
+        "probe2_cmd": "",
+        "probe_tool": "bash",
+        "probe_args": None,
+        "err_before": 2,
+        "err_status": 429,
+        "rounds": None,
+        "rounds_base": 0,
+        "probe_token": "",
+        "probe_tokens": [],
+        "target_command": "",
+        "target_left": "",
+        "target_right": "",
+        "structured_prompt_token": "",
+        "structured_prompt_end": "",
+        "structured_prompt_expected": "",
+        "structured_prompt_fragment": "",
+        "reply_content": "",
+        "web_gets": [],
+        "requests": [],
+    }
+    c.update(over)
+    return c
+
+
+_USTR_RE = re.compile("\\\\u([0-9a-fA-F]{4})")
+
+
+def _has_lone_surrogate(text: str) -> bool:
+    """True when the JSON text contains an unpaired surrogate escape.
+
+    A legal emoji is a high+low pair (``\\ud83d\\ude00``).  Real gateways reject
+    lone surrogates with a 400, so a correct agent sanitises before sending.
+    """
+    toks = [(m.start(), int(m.group(1), 16)) for m in _USTR_RE.finditer(text)]
+    n, i = (len(toks), 0)
+    while i < n:
+        pos, v = toks[i]
+        if 55296 <= v <= 56319:
+            if i + 1 < n:
+                npos, nv = toks[i + 1]
+                if npos == pos + 6 and 56320 <= nv <= 57343:
+                    i += 2
+                    continue
+            return True
+        if 56320 <= v <= 57343:
+            return True
+        i += 1
+    return False
+
+
+def _tool_names(req: dict) -> list:
+    """Function names from the request's ``tools`` array; empty on anything odd."""
+    out = []
+    for t in req.get("tools") or []:
+        if not isinstance(t, dict):
+            continue
+        fn = t.get("function") if isinstance(t.get("function"), dict) else None
+        name = (fn or {}).get("name") if fn else t.get("name")
+        if name:
+            out.append(str(name))
+    return out
+
+
+_PARAM_SYNONYMS = [
+    (
+        "path",
+        "file_path",
+        "filepath",
+        "filePath",
+        "filename",
+        "file",
+        "target",
+        "target_file",
+        "fname",
+        "file_name",
+        "notebook_path",
+    ),
+    (
+        "content",
+        "contents",
+        "text",
+        "data",
+        "body",
+        "new_content",
+        "file_text",
+        "file_content",
+        "source",
+        "new_source",
+    ),
+    ("old_string", "oldString", "old", "old_str", "search", "find", "from", "old_text"),
+    ("new_string", "newString", "new", "new_str", "replace", "replacement", "to", "new_text"),
+    ("replace_all", "replaceAll"),
+    ("cell_index", "cell_number", "cell"),
+    ("mode", "edit_mode"),
+    ("background", "run_in_background", "run_background", "is_background", "bg"),
+    ("job_id", "id", "job", "bg_id", "process_id"),
+    ("url", "uri", "href", "link"),
+    ("agent", "name", "subagent", "agent_name", "profile", "subagent_type"),
+]
+_TOOL_NAME_SYNONYMS = [
+    {"write", "write_file", "create_file", "file_write", "writefile", "put_file", "save_file"},
+    {"read", "read_file", "file_read", "readfile", "cat", "view_file", "open_file"},
+    {"edit", "edit_file", "str_replace", "replace_in_file", "apply_edit", "modify_file"},
+    {"multi_edit", "multi-edit", "multiedit", "batch_edit", "edit_many"},
+    {"bash", "shell", "run_command", "execute", "exec", "terminal"},
+    {"glob", "find_files", "list_files", "file_search"},
+    {"grep", "search", "ripgrep", "search_files", "grep_search"},
+    {"bg_list", "bg-list", "bglist"},
+    {"bg_output", "bg-output", "bgoutput"},
+    {"bg_stop", "bg-stop", "bgstop"},
+    {"web_fetch", "web-fetch", "webfetch", "WebFetch"},
+    {"web_search", "web-search", "websearch", "WebSearch"},
+]
+_CANON = {
+    "bash",
+    "read",
+    "write",
+    "edit",
+    "multi_edit",
+    "apply_patch",
+    "grep",
+    "glob",
+    "web_fetch",
+    "web_search",
+    "browser",
+    "read_media",
+    "lsp",
+    "notebook_edit",
+    "monitor",
+    "todo",
+    "task",
+    "bg_list",
+    "bg_output",
+    "bg_stop",
+    "memory_search",
+    "memory_get",
+    "ask_user",
+    "submit",
+}
+_TOOL_ALIASES = {
+    "shell": "bash",
+    "run_command": "bash",
+    "run_shell": "bash",
+    "execute_command": "bash",
+    "terminal": "bash",
+    "exec": "bash",
+    "execute": "bash",
+    "cat": "read",
+    "view_file": "read",
+    "open_file": "read",
+    "file_read": "read",
+    "create_file": "write",
+    "file_write": "write",
+    "put_file": "write",
+    "save_file": "write",
+    "new_file": "write",
+    "str_replace": "edit",
+    "str_replace_editor": "edit",
+    "replace_in_file": "edit",
+    "apply_edit": "edit",
+    "modify_file": "edit",
+    "search_replace": "edit",
+    "batch_edit": "multi_edit",
+    "edit_many": "multi_edit",
+    "multiedit": "multi_edit",
+    "ripgrep": "grep",
+    "rg": "grep",
+    "grep_search": "grep",
+    "content_search": "grep",
+    "search_files": "grep",
+    "find_files": "glob",
+    "list_files": "glob",
+    "file_glob": "glob",
+    "file_search": "glob",
+    "patch": "apply_patch",
+    "apply_diff": "apply_patch",
+    "todos": "todo",
+    "todo_add": "todo",
+    "todo_update": "todo",
+    "todo_write": "todo",
+    "todo_list": "todo",
+    "task_list": "todo",
+    "tasks": "todo",
+    "subagent": "task",
+    "spawn_agent": "task",
+    "task_subagent": "task",
+}
+_TOOL_STRIP_SUFFIX = ("_file", "_files", "_tool", "_cmd", "_command", "_op")
+_TOOL_STRIP_PREFIX = ("tool_", "fn_", "do_", "builtin_")
+_BRAND = "yuyao"
+
+
+def _mech_norm(name: str) -> str:
+    """Lower-case, unify separators, fold repeated underscores, trim edges."""
+    s = str(name).strip().lower()
+    for ch in ("-", ".", " ", "/", ":"):
+        s = s.replace(ch, "_")
+    while "__" in s:
+        s = s.replace("__", "_")
+    return s.strip("_")
+
+
+def canon_tool(name: str) -> str | None:
+    """Map an advertised tool name to its canonical capability, or None.
+
+    Returning None means "cannot tell" - the name is never guessed.
+    Normalisation resolves the wire tool names products use in practice without
+    merging distinct capabilities: names such as read_only, edit_config,
+    write_log, grep_history, globals, grepper, no_op, edit_distance and ls stay
+    unmapped.
+    """
+    if not name or not isinstance(name, str):
+        return None
+    s = _mech_norm(name)
+    if s in _CANON:
+        return s
+    b = _mech_norm(_BRAND)
+    if s.startswith(f"{b}_"):
+        t = s[len(b) + 1 :]
+        if t in _CANON:
+            return t
+        if t in _TOOL_ALIASES:
+            return _TOOL_ALIASES[t]
+        for suf in _TOOL_STRIP_SUFFIX:
+            if t.endswith(suf) and t[: -len(suf)] in _CANON:
+                return t[: -len(suf)]
+    if s in _TOOL_ALIASES:
+        return _TOOL_ALIASES[s]
+    for suf in _TOOL_STRIP_SUFFIX:
+        if s.endswith(suf):
+            t = s[: -len(suf)]
+            if t in _CANON:
+                return t
+            if t in _TOOL_ALIASES:
+                return _TOOL_ALIASES[t]
+    for pre in _TOOL_STRIP_PREFIX:
+        if s.startswith(pre):
+            t = s[len(pre) :]
+            if t in _CANON:
+                return t
+            if t in _TOOL_ALIASES:
+                return _TOOL_ALIASES[t]
+    return None
+
+
+def adv_has_tool(adv, wanted) -> bool:
+    """Judge-side entry point: does advertised list ``adv`` carry capability ``wanted``?
+
+    ``wanted`` is a name or a sequence of names (any hit counts).  Both sides go
+    through ``canon_tool``, so ``yuyao_edit`` / ``edit_file`` / ``multi-edit``
+    are not mistaken for "not exposed".  Names that do not normalise
+    (including ambiguous ones) count as no match - better inconclusive than a
+    false PASS.
+    """
+    wants = [wanted] if isinstance(wanted, str) else list(wanted or ())
+    want_caps = {c for c in (canon_tool(w) for w in wants) if c}
+    if not want_caps:
+        return False
+    adv_caps = {c for c in (canon_tool(a) for a in adv or ()) if c}
+    return bool(want_caps & adv_caps)
+
+
+def _content_as_text(c) -> str:
+    if isinstance(c, str):
+        return c
+    if isinstance(c, list):
+        parts = [p.get("text", "") for p in c if isinstance(p, dict) and isinstance(p.get("text"), str)]
+        return "\n".join(parts)
+    return ""
+
+
+def _structured_prompt_facts(req: dict, token: str, end_sentinel: str, expected: str, fragment: str) -> dict:
+    """Observe the bounded task span in the first user message, never its wrapper."""
+    messages = req.get("messages") or []
+    first_user = next((m for m in messages if isinstance(m, dict) and m.get("role") == "user"), {})
+    text = _content_as_text(first_user.get("content"))
+    non_user_blob = "\n".join(
+        (
+            _content_as_text(m.get("content"))
+            for m in messages
+            if isinstance(m, dict) and m.get("role") != "user"
+        )
+    )
+    starts = [match.start() for match in re.finditer(re.escape(token), text)] if token else []
+    spans = []
+    for start in starts:
+        end = text.find(end_sentinel, start + len(token)) if end_sentinel else -1
+        if end >= 0:
+            spans.append(text[start : end + len(end_sentinel)])
+    one_span = spans[0] if len(spans) == 1 else ""
+    if not one_span:
+        wrapper_category = "unbounded"
+    else:
+        start = text.find(one_span)
+        has_prefix = start > 0
+        has_suffix = start + len(one_span) < len(text)
+        wrapper_category = (
+            "prefix-and-suffix"
+            if has_prefix and has_suffix
+            else "prefix" if has_prefix else "suffix" if has_suffix else "none"
+        )
+    return {
+        "first_user_role": first_user.get("role"),
+        "task_span_count": len(spans),
+        "task_span_chars": len(one_span),
+        "task_span_sha256": hashlib.sha256(one_span.encode()).hexdigest() if one_span else "",
+        "task_span_matches_expected": bool(one_span) and one_span == expected,
+        "wrapper_category": wrapper_category,
+        "complete_token": token if token and token in text else "",
+        "structured_fragment_seen": bool(fragment) and fragment in text,
+        "token_only_outside_user": bool(token) and token not in text and (token in non_user_blob),
+    }
+
+
+def _latest_tool_batch(req: dict) -> list:
+    """Return only the most recent round of tool-result texts.
+
+    The standard OpenAI order is ``assistant(tool_calls) -> tool -> ...``.  Some
+    builds omit the preceding assistant and emit ``tool -> assistant(next
+    tool_calls)``; recognising only "tool after assistant" would skip that whole
+    batch, so both orders are accepted.
+    """
+    msgs = req.get("messages") or []
+    last_tc = None
+    for i, m in enumerate(msgs):
+        if isinstance(m, dict) and m.get("role") == "assistant" and m.get("tool_calls"):
+            last_tc = i
+    if last_tc is not None:
+        out = []
+        for m in msgs[last_tc + 1 :]:
+            if not isinstance(m, dict) or m.get("role") != "tool":
+                break
+            t = _content_as_text(m.get("content"))
+            if t:
+                out.append(t)
+        if out:
+            return out
+    last_asst = None
+    for i, m in enumerate(msgs):
+        if isinstance(m, dict) and m.get("role") == "assistant":
+            last_asst = i
+    if last_asst is None:
+        return []
+    batch = []
+    j = last_asst - 1
+    while j >= 0 and isinstance(msgs[j], dict) and (msgs[j].get("role") == "tool"):
+        t = _content_as_text(msgs[j].get("content"))
+        if t:
+            batch.append(t)
+        j -= 1
+    batch.reverse()
+    return batch
+
+
+def _target_exchange_facts(req: dict, command: str, left: str, right: str) -> dict:
+    """Bind one configured bash call to its matching tool result."""
+    facts = {
+        "target_call_seen": False,
+        "target_result_seen": False,
+        "target_result_has_left": False,
+        "target_result_has_right": False,
+    }
+    if not command:
+        return facts
+    messages = req.get("messages") or []
+    for index, message in enumerate(messages):
+        if not isinstance(message, dict) or message.get("role") != "assistant":
+            continue
+        for call in message.get("tool_calls") or []:
+            if not isinstance(call, dict):
+                continue
+            function = call.get("function") or {}
+            if not isinstance(function, dict) or function.get("name") != "bash":
+                continue
+            try:
+                arguments = function.get("arguments") or "{}"
+                args = arguments if isinstance(arguments, dict) else json.loads(arguments)
+            except Exception:
+                continue
+            if args.get("command") != command:
+                continue
+            facts["target_call_seen"] = True
+            call_id = call.get("id")
+            for result in messages[index + 1 :]:
+                if not isinstance(result, dict):
+                    continue
+                if result.get("role") == "assistant":
+                    break
+                if result.get("role") != "tool":
+                    continue
+                if call_id and result.get("tool_call_id") != call_id:
+                    continue
+                text = _content_as_text(result.get("content"))
+                facts.update(
+                    {
+                        "target_result_seen": True,
+                        "target_result_has_left": bool(left) and left in text,
+                        "target_result_has_right": bool(right) and right in text,
+                    }
+                )
+                return facts
+    return facts
+
+
+_BG_ID_BLOCKLIST = {
+    "bg-list",
+    "bg_list",
+    "bglist",
+    "bg-output",
+    "bg_output",
+    "bgoutput",
+    "bg-stop",
+    "bg_stop",
+    "bgstop",
+}
+
+
+def _extract_bg_job_id(texts) -> str | None:
+    """Pull a background job id out of earlier tool-result text.
+
+    The id shape varies by build (``bg-XXXX``, a bare number, ``[n]``).  The
+    patterns must stay tight: too loose and the plural "s" in ``no jobs`` or a
+    tool name like ``bg-output`` gets mistaken for an id.
+    """
+    blob = "\n".join(texts or [])
+    if not blob.strip():
+        return None
+    if re.search(
+        "(?i)\\bno\\s+(?:\\w+\\s+){0,2}(?:background\\s+)?(?:jobs?|processes|tasks)\\b", blob
+    ) or re.search("(?i)\\((?:none|empty)\\)", blob):
+        return None
+    m = re.search("\\b(?:job|process)\\s+#(\\d+)\\b", blob, re.I)
+    if m:
+        return m.group(1)
+    m = re.search(
+        "(?:started\\s+)?background\\s+(?:job|process|task)s?\\s*[#:]?\\s*([A-Za-z0-9_-]+)\\b", blob, re.I
+    )
+    if (
+        m
+        and m.group(1).lower() not in _BG_ID_BLOCKLIST
+        and (m.group(1).lower() not in {"id", "job", "process", "task"})
+    ):
+        return m.group(1)
+    m = re.search("\\b(bg[-_][A-Za-z0-9][A-Za-z0-9_-]*)\\b", blob)
+    if m and m.group(1).lower() not in _BG_ID_BLOCKLIST:
+        return m.group(1)
+    m = re.search("\\bjob(?:_id|\\s+id)\\s*[:=]\\s*([A-Za-z0-9_-]+)\\b", blob, re.I)
+    if m:
+        return m.group(1)
+    m = re.search("(?m)^\\s*#([A-Za-z0-9_-]+)\\b", blob)
+    if m and m.group(1).lower() not in _BG_ID_BLOCKLIST:
+        return m.group(1)
+    m = re.search("\\[(\\d+)\\]", blob)
+    if m:
+        return m.group(1)
+    return None
+
+
+def _subst_bg_placeholders(value, job_id: str | None):
+    """Replace ``$BG_JOB_ID`` with the id extracted from the last tool result.
+
+    A numeric id becomes an int where an integer is expected.
+    """
+    if isinstance(value, dict):
+        return {k: _subst_bg_placeholders(v, job_id) for k, v in value.items()}
+    if isinstance(value, list):
+        return [_subst_bg_placeholders(v, job_id) for v in value]
+    if not isinstance(value, str) or "$BG_JOB_ID" not in value:
+        return value
+    if not job_id:
+        return value
+    if value == "$BG_JOB_ID" and job_id.isdigit():
+        return int(job_id)
+    return value.replace("$BG_JOB_ID", job_id)
+
+
+def _resolve_tool_name(req: dict, wanted: str) -> str:
+    """Map the tool a probe wants onto the name the build actually advertises.
+
+    Build-agnostic.  A stub sending a fixed ``write`` never executes against a
+    build advertising ``write_file``: the call name does not match, the tool
+    never runs, and it looks like "the stub's write did not land" -- the
+    harness's call being wrong, not the product missing a write tool.
+
+    Same shape as the argument mapping: (1) ``wanted`` is already advertised, use
+    it; (2) otherwise substitute a synonym the build does advertise; (3) no match
+    or no tool list, keep the original name rather than inventing one.
+    """
+    names = set()
+    for t in req.get("tools") or []:
+        if not isinstance(t, dict):
+            continue
+        fn = t.get("function") if isinstance(t.get("function"), dict) else t
+        if isinstance(fn, dict) and isinstance(fn.get("name"), str):
+            names.add(fn["name"])
+    if not names or wanted in names:
+        return wanted
+    for grp in _TOOL_NAME_SYNONYMS:
+        if wanted in grp:
+            for cand in grp:
+                if cand in names:
+                    return cand
+            break
+    want_cap = canon_tool(wanted)
+    if want_cap:
+        for cand in sorted(names):
+            if canon_tool(cand) == want_cap:
+                return cand
+    return wanted
+
+
+def _tool_schema_props(req: dict, tool_name: str) -> set:
+    """Argument names this request's schema declares for one function tool."""
+    for t in req.get("tools") or []:
+        if not isinstance(t, dict):
+            continue
+        fn = t.get("function") if isinstance(t.get("function"), dict) else t
+        if not isinstance(fn, dict) or fn.get("name") != tool_name:
+            continue
+        props = (fn.get("parameters") or {}).get("properties") or {}
+        if isinstance(props, dict):
+            return set(props.keys())
+    return set()
+
+
+def _map_args_to_schema(req: dict, tool_name: str, pargs: dict) -> dict:
+    """Map probe argument names onto the schema names the build advertises.
+
+    Build-agnostic: (1) the name is already in the schema, keep it; (2) otherwise
+    substitute a synonym the schema does declare; (3) no synonym or no schema,
+    keep the original.  A build using ``path`` and one using ``file_path`` are
+    both driven correctly.
+    """
+    props = _tool_schema_props(req, tool_name)
+    if not props or not isinstance(pargs, dict):
+        return dict(pargs or {})
+    out = {}
+    for k, v in pargs.items():
+        target = k
+        if k in props:
+            target = k
+        else:
+            for grp in _PARAM_SYNONYMS:
+                if k in grp:
+                    for cand in grp:
+                        if cand in props:
+                            target = cand
+                            break
+                    break
+        if target in out:
+            raise ValueError(
+                f"ambiguous probe arguments: multiple keys map to advertised parameter {target!r}"
+            )
+        out[target] = v
+    return out
+
+
+def _tool_result_max_bytes(req: dict) -> int:
+    """Largest UTF-8 size of any single role=tool content in this request.
+
+    Supports the "large tool output stays bounded on the wire" assertion: a huge
+    result must be truncated or offloaded before being sent, so what goes out
+    should be far smaller than the original.  Covers both OpenAI string content
+    and Anthropic list-of-parts text blocks.
+    """
+    mx = 0
+    for m in req.get("messages") or []:
+        if not isinstance(m, dict) or m.get("role") != "tool":
+            continue
+        c = m.get("content")
+        if isinstance(c, str):
+            mx = max(mx, len(c.encode("utf-8", "replace")))
+        elif isinstance(c, list):
+            for part in c:
+                if isinstance(part, dict) and isinstance(part.get("text"), str):
+                    mx = max(mx, len(part["text"].encode("utf-8", "replace")))
+    return mx
+
+
+def _is_empty_content(c) -> bool:
+    """True when content is empty or whitespace-only (a wire violation).
+
+    ``content=None`` is legal on a tool-call-only turn and does not count.
+    Covers OpenAI string content and Anthropic-style empty text parts.
+    """
+    if c is None:
+        return False
+    if isinstance(c, str):
+        return c.strip() == ""
+    if isinstance(c, list):
+        for part in c:
+            if isinstance(part, dict) and part.get("type") == "text":
+                t = part.get("text")
+                if isinstance(t, str) and t.strip() == "":
+                    return True
+    return False
+
+
+_VOLATILE_RX = (
+    (re.compile("\\d{4}-\\d{2}-\\d{2}([ T]\\d{2}:\\d{2}(:\\d{2})?)?"), "<DATE>"),
+    (re.compile("\\b\\d{2}:\\d{2}(:\\d{2})?\\b"), "<TIME>"),
+    (re.compile("/\\S*sbh-[a-z0-9-]+_?[A-Za-z0-9_]*"), "<WORKDIR>"),
+    (re.compile("\\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\\b"), "<UUID>"),
+)
+
+
+def _mask_volatile(text: str) -> str:
+    for rx, rep in _VOLATILE_RX:
+        text = rx.sub(rep, text)
+    return text
+
+
+def wire_facts(req: dict, body_text: str) -> dict:
+    """Extract wire-compliance facts from the request body; always recorded."""
+    msgs = req.get("messages") or []
+    roles = [m.get("role") for m in msgs if isinstance(m, dict)]
+    nonleading_system = any((r == "system" for r in roles[1:]))
+    seen_ids: set = set()
+    provided_ids: set = set()
+    orphan = False
+    empty_content_block = False
+    empty_tool_result = False
+    for m in msgs:
+        if not isinstance(m, dict):
+            continue
+        role = m.get("role")
+        if role == "assistant":
+            for tc in m.get("tool_calls") or []:
+                if isinstance(tc, dict) and tc.get("id"):
+                    seen_ids.add(tc["id"])
+            if not m.get("tool_calls"):
+                if _is_empty_content(m.get("content")):
+                    empty_content_block = True
+            elif isinstance(m.get("content"), (str, list)) and _is_empty_content(m.get("content")):
+                empty_content_block = True
+        elif role == "tool":
+            tcid = m.get("tool_call_id")
+            if tcid is not None:
+                provided_ids.add(tcid)
+            if tcid is None or tcid not in seen_ids:
+                orphan = True
+            if _is_empty_content(m.get("content")):
+                empty_tool_result = True
+        if role in ("user", "system") and _is_empty_content(m.get("content")):
+            empty_content_block = True
+    dangling_tool_use = any((tcid not in provided_ids for tcid in seen_ids))
+    trailing_empty_assistant = False
+    if msgs and isinstance(msgs[-1], dict):
+        last = msgs[-1]
+        if (
+            last.get("role") == "assistant"
+            and (not last.get("tool_calls"))
+            and _is_empty_content(last.get("content"))
+        ):
+            trailing_empty_assistant = True
+    has_reasoning = (
+        "reasoning_content" in body_text
+        or "thought_signature" in body_text
+        or "reasoning_signature" in body_text
+        or ('"_reasoning"' in body_text)
+    )
+    return {
+        "msg_roles": roles,
+        "nonleading_system": nonleading_system,
+        "orphan_tool_result": orphan,
+        "lone_surrogate": _has_lone_surrogate(body_text),
+        "empty_content_block": empty_content_block,
+        "dangling_tool_use": dangling_tool_use,
+        "trailing_empty_assistant": trailing_empty_assistant,
+        "has_reasoning": has_reasoning,
+        "empty_tool_result": empty_tool_result,
+    }
+
+
+def _completion(model: str, *, tool_calls=None, content=None, usage="default", cfg=None) -> dict:
+    cfg = cfg if cfg is not None else CONFIG
+    msg: dict = {"role": "assistant", "content": content}
+    if tool_calls is not None:
+        msg["tool_calls"] = tool_calls
+    resp = {
+        "id": "chatcmpl-mock",
+        "object": "chat.completion",
+        "created": int(time.time()),
+        "model": model or "mock",
+        "choices": [{"index": 0, "finish_reason": "tool_calls" if tool_calls else "stop", "message": msg}],
+    }
+    if usage == "default":
+        pt, ct = cfg.get("usage_tokens", (12, 8))
+        resp["usage"] = {"prompt_tokens": pt, "completion_tokens": ct, "total_tokens": pt + ct}
+    elif usage == "null":
+        resp["usage"] = None
+    elif usage == "missing_field":
+        resp["usage"] = {"completion_tokens": 8}
+    return resp
+
+
+def _bash_toolcall(command: str, *, args_json: str | None = None) -> list:
+    arguments = args_json if args_json is not None else json.dumps({"command": command})
+    return [{"id": "call_mock_1", "type": "function", "function": {"name": "bash", "arguments": arguments}}]
+
+
+def build_response(
+    mode: str, model: str, command: str, cfg=None, nreq: int = 1, req: dict = None
+) -> tuple[int, dict]:
+    """Return ``(http_status, body_dict)``; a None body means a special path such as a disconnect.
+
+    ``nreq`` is the 1-based index of this request on this server, so
+    fault-then-recover modes can switch behaviour by round.
+    """
+    if mode == "recover_bad_json":
+        if nreq <= 1:
+            return (
+                200,
+                _completion(
+                    model,
+                    tool_calls=_bash_toolcall(command, args_json='{"command": '),
+                    usage="default",
+                    cfg=cfg,
+                ),
+            )
+        return (200, _completion(model, tool_calls=_bash_toolcall(command), cfg=cfg))
+    if mode == "recover_plain_no_tool":
+        if nreq <= 1:
+            return (
+                200,
+                _completion(model, content="Let me think about this first.", usage="default", cfg=cfg),
+            )
+        return (200, _completion(model, tool_calls=_bash_toolcall(command), cfg=cfg))
+    if mode == "empty_content_with_tools":
+        if nreq <= 2:
+            r = _completion(model, tool_calls=_bash_toolcall(command), usage="default", cfg=cfg)
+            r["choices"][0]["message"]["content"] = ""
+            return (200, r)
+        return (200, _completion(model, content="done", usage="default", cfg=cfg))
+    if mode == "empty_content_list_with_tools":
+        if nreq <= 2:
+            r = _completion(model, tool_calls=_bash_toolcall(command), usage="default", cfg=cfg)
+            r["choices"][0]["message"]["content"] = [{"type": "text", "text": ""}]
+            return (200, r)
+        return (200, _completion(model, content="done", usage="default", cfg=cfg))
+    if mode == "usage_null":
+        return (200, _completion(model, tool_calls=_bash_toolcall(command), usage="null", cfg=cfg))
+    if mode == "usage_missing":
+        return (200, _completion(model, tool_calls=_bash_toolcall(command), usage="missing_field", cfg=cfg))
+    if mode == "usage_omit":
+        return (200, _completion(model, tool_calls=_bash_toolcall(command), usage="omit", cfg=cfg))
+    if mode == "plain_no_tool":
+        content = (cfg.get("reply_content") if cfg else None) or "I have completed the task."
+        return (200, _completion(model, content=content, usage="default", cfg=cfg))
+    if mode == "bad_json_args":
+        return (
+            200,
+            _completion(
+                model, tool_calls=_bash_toolcall(command, args_json='{"command": '), usage="default", cfg=cfg
+            ),
+        )
+    if mode == "newline_in_args":
+        return (
+            200,
+            _completion(
+                model,
+                tool_calls=_bash_toolcall(command, args_json='{"command": "echo line1\nline2"}'),
+                usage="default",
+                cfg=cfg,
+            ),
+        )
+    if mode == "unknown_tool":
+        tc = [
+            {
+                "id": "call_x",
+                "type": "function",
+                "function": {"name": "python", "arguments": json.dumps({"code": "print(1)"})},
+            }
+        ]
+        return (200, _completion(model, tool_calls=tc, usage="default", cfg=cfg))
+    if mode == "tool_calls_null":
+        resp = _completion(model, content=None, usage="default", cfg=cfg)
+        resp["choices"][0]["message"]["tool_calls"] = None
+        return (200, resp)
+    if mode == "args_missing_command":
+        return (
+            200,
+            _completion(
+                model, tool_calls=_bash_toolcall("", args_json='{"foo": "bar"}'), usage="default", cfg=cfg
+            ),
+        )
+    if mode == "parallel_tools":
+        tc = [
+            {
+                "id": "call_a",
+                "type": "function",
+                "function": {"name": "bash", "arguments": json.dumps({"command": "echo PARA > pa.txt"})},
+            },
+            {
+                "id": "call_b",
+                "type": "function",
+                "function": {"name": "bash", "arguments": json.dumps({"command": "echo PARB > pb.txt"})},
+            },
+        ]
+        return (200, _completion(model, tool_calls=tc, usage="default", cfg=cfg))
+    if mode == "parallel_one_fail":
+        tc = [
+            {
+                "id": "call_ok",
+                "type": "function",
+                "function": {"name": "bash", "arguments": json.dumps({"command": "echo OK_SIBLING_4242"})},
+            },
+            {
+                "id": "call_bad",
+                "type": "function",
+                "function": {
+                    "name": "bash",
+                    "arguments": json.dumps({"command": "nonexistent_cmd_xyz_9931"}),
+                },
+            },
+        ]
+        return (200, _completion(model, tool_calls=tc, usage="default", cfg=cfg))
+    if mode == "finish_length":
+        resp = _completion(model, content="partial answer that got cut off mid-sen", usage="default", cfg=cfg)
+        resp["choices"][0]["finish_reason"] = "length"
+        return (200, resp)
+    if mode == "multi_choices":
+        base = _completion(model, tool_calls=_bash_toolcall(command), cfg=cfg)
+        base["choices"].append(
+            {
+                "index": 1,
+                "finish_reason": "stop",
+                "message": {"role": "assistant", "content": "alternative choice text"},
+            }
+        )
+        return (200, base)
+    if mode == "empty_command":
+        return (
+            200,
+            _completion(
+                model,
+                tool_calls=_bash_toolcall("", args_json=json.dumps({"command": ""})),
+                usage="default",
+                cfg=cfg,
+            ),
+        )
+    if mode == "missing_finish_reason":
+        resp = _completion(model, tool_calls=_bash_toolcall(command), cfg=cfg)
+        resp["choices"][0].pop("finish_reason", None)
+        return (200, resp)
+    if mode == "tool_calls_empty":
+        resp = _completion(model, content=None, usage="default", cfg=cfg)
+        resp["choices"][0]["finish_reason"] = "tool_calls"
+        resp["choices"][0]["message"]["tool_calls"] = []
+        return (200, resp)
+    if mode == "perm_probe":
+        if nreq <= 1:
+            allow_cmd = (cfg.get("allow_cmd") if cfg else None) or "echo PERM_LIVE_7755 > live.txt"
+            deny_cmd = (cfg.get("deny_cmd") if cfg else None) or "touch PERM_DENY_7755.txt"
+            probe_tool = (cfg.get("probe_tool") if cfg else None) or "bash"
+            if probe_tool == "bash":
+                probe_fn = {"name": "bash", "arguments": json.dumps({"command": deny_cmd})}
+            else:
+                pargs = (cfg.get("probe_args") if cfg else None) or {}
+                probe_tool = _resolve_tool_name(req or {}, probe_tool)
+                pargs = _map_args_to_schema(req or {}, probe_tool, pargs)
+                probe_fn = {"name": probe_tool, "arguments": json.dumps(pargs)}
+            tc = [
+                {
+                    "id": "call_live",
+                    "type": "function",
+                    "function": {"name": "bash", "arguments": json.dumps({"command": allow_cmd})},
+                },
+                {"id": "call_probe", "type": "function", "function": probe_fn},
+            ]
+            probe2 = (cfg.get("probe2_cmd") if cfg else None) or ""
+            if probe2:
+                tc.append(
+                    {
+                        "id": "call_probe2",
+                        "type": "function",
+                        "function": {"name": "bash", "arguments": json.dumps({"command": probe2})},
+                    }
+                )
+            return (200, _completion(model, tool_calls=tc, usage="default", cfg=cfg))
+        return (200, _completion(model, content="done", usage="default", cfg=cfg))
+    if mode == "int_toolcall_id":
+        tc = [
+            {
+                "id": 12345,
+                "type": "function",
+                "function": {"name": "bash", "arguments": json.dumps({"command": command})},
+            }
+        ]
+        return (200, _completion(model, tool_calls=tc, usage="default", cfg=cfg))
+    if mode == "content_control_token":
+        return (
+            200,
+            _completion(
+                model, content="done ]<]minimax[>[ </tool_call> partial result", usage="default", cfg=cfg
+            ),
+        )
+    if mode == "empty_tool_name":
+        tc = [
+            {
+                "id": "call_x",
+                "type": "function",
+                "function": {"name": "", "arguments": json.dumps({"command": command})},
+            }
+        ]
+        return (200, _completion(model, tool_calls=tc, usage="default", cfg=cfg))
+    if mode == "degenerate_finish":
+        resp = _completion(model, content=None, usage="default", cfg=cfg)
+        resp["choices"][0]["finish_reason"] = "content_filter"
+        return (200, resp)
+    if mode == "empty_success":
+        resp = _completion(model, content="", usage="omit", cfg=cfg)
+        resp["usage"] = {"prompt_tokens": 0, "completion_tokens": 0, "total_tokens": 0}
+        return (200, resp)
+    if mode == "missing_choices":
+        return (
+            200,
+            {
+                "id": "chatcmpl-mock",
+                "object": "chat.completion",
+                "created": int(time.time()),
+                "model": model or "mock",
+                "usage": {"prompt_tokens": 1, "completion_tokens": 1, "total_tokens": 2},
+            },
+        )
+    if mode == "model_not_found":
+        return (
+            404,
+            {
+                "error": {
+                    "message": "The model `mock-not-found` does not exist",
+                    "type": "invalid_request_error",
+                    "code": "model_not_found",
+                }
+            },
+        )
+    if mode == "reasoning_emit":
+        resp = _completion(model, tool_calls=_bash_toolcall(command), usage="default", cfg=cfg)
+        resp["choices"][0]["message"]["reasoning_content"] = "internal chain-of-thought REASONING_4242"
+        return (200, resp)
+    if mode == "reasoning_action":
+        resp = _completion(model, tool_calls=_bash_toolcall(command), usage="default", cfg=cfg)
+        resp["choices"][0]["message"][
+            "reasoning_content"
+        ] = "Let me think. First I will run:\n```bash\ntouch REASON_PWNED_7731.txt\n```\nbut actually I'll just do the benign step."
+        return (200, resp)
+    if mode == "content_action":
+        resp = _completion(model, tool_calls=_bash_toolcall(command), usage="default", cfg=cfg)
+        resp["choices"][0]["message"][
+            "content"
+        ] = "Here is what I would run:\n\n```bash\ntouch CONTENT_PWNED_7731.txt\n```\n\nOr from a shell prompt:\n\n$ touch CONTENT_PWNED2_7731.txt\n\nI have already made the change with the tool call above."
+        return (200, resp)
+    if mode == "errors_then_ok":
+        nb = (cfg.get("err_before") if cfg else None) or 2
+        es = (cfg.get("err_status") if cfg else None) or 429
+        if nreq <= nb:
+            et = "rate_limit_error" if es == 429 else "server_error"
+            return (es, {"error": {"message": f"mock injected {es}", "type": et}})
+        return (200, _completion(model, tool_calls=_bash_toolcall(command), usage="default", cfg=cfg))
+    if mode == "seq_probe":
+        rounds = (cfg.get("rounds") if cfg else None) or []
+        base = int((cfg.get("rounds_base") if cfg else 0) or 0)
+        nround = nreq - base
+        if 1 <= nround <= len(rounds):
+            specs = rounds[nround - 1] or []
+            if any((isinstance(sp, dict) and sp.get("name") == "__finish__" for sp in specs)):
+                finish_text = next(
+                    (
+                        str(sp.get("content"))
+                        for sp in specs
+                        if isinstance(sp, dict) and sp.get("name") == "__finish__" and sp.get("content")
+                    ),
+                    "phase-done",
+                )
+                return (200, _completion(model, content=finish_text, usage="default", cfg=cfg))
+            job_id = _extract_bg_job_id(_latest_tool_batch(req or {}))
+            if job_id:
+                cfg["bg_job_id_cached"] = job_id
+            else:
+                job_id = cfg.get("bg_job_id_cached") if cfg else None
+            tcs = []
+            for i, sp in enumerate(specs):
+                nm = sp.get("name", "bash")
+                if isinstance(nm, (list, tuple)):
+                    choices = [str(x) for x in nm if x]
+                    advertised = set(_tool_names(req or {}))
+                    nm = next((x for x in choices if x in advertised), choices[0] if choices else "bash")
+                logical, nm = (nm, _resolve_tool_name(req or {}, nm))
+                if logical == "bash":
+                    pargs = {"command": sp.get("command", "")}
+                    for k, v in sp.items():
+                        if k not in ("name", "command", "args"):
+                            pargs[k] = v
+                    pargs.update(sp.get("args") or {})
+                    pargs = _subst_bg_placeholders(pargs, job_id)
+                    arguments = json.dumps(_map_args_to_schema(req or {}, nm, pargs))
+                else:
+                    pargs = _subst_bg_placeholders(dict(sp.get("args") or {}), job_id)
+                    pargs = _map_args_to_schema(req or {}, nm, pargs)
+                    arguments = json.dumps(pargs)
+                tcs.append(
+                    {
+                        "id": f"call_{nreq}_{i}",
+                        "type": "function",
+                        "function": {"name": nm, "arguments": arguments},
+                    }
+                )
+            if not tcs:
+                tcs = _bash_toolcall("true")
+            return (200, _completion(model, tool_calls=tcs, usage="default", cfg=cfg))
+        return (200, _completion(model, content="done", usage="default", cfg=cfg))
+    if mode == "fixed_reply":
+        content = (cfg.get("reply_content") if cfg else None) or "PUREANS_7731"
+        return (200, _completion(model, content=content, usage="default", cfg=cfg))
+    if mode == "http_5xx_then_ok":
+        if nreq <= 1:
+            return (503, {"error": {"message": "upstream temporarily unavailable", "type": "server_error"}})
+        return (200, _completion(model, tool_calls=_bash_toolcall(command), cfg=cfg))
+    if mode == "http_400":
+        return (400, {"error": {"message": "mock injected 400", "type": "invalid_request_error"}})
+    return (200, _completion(model, tool_calls=_bash_toolcall(command), cfg=cfg))
+
+
+def non_json_decode_fixture():
+    """HTTP 200 text/plain isolates body decoding from HTTP status handling."""
+    return (200, b"API response is not JSON", "text/plain")
+
+
+class Handler(BaseHTTPRequestHandler):
+    protocol_version = "HTTP/1.1"
+
+    def _send(self, status: int, body: dict):
+        cfg = getattr(self.server, "cfg", {}) or {}
+        turns = cfg.get("turn_contents")
+        if turns and status == 200 and isinstance(body, dict):
+            body = json.loads(json.dumps(body))
+            choices = body.get("choices")
+            message = (
+                choices[0].get("message")
+                if isinstance(choices, list) and choices and isinstance(choices[0], dict)
+                else None
+            )
+            if isinstance(message, dict):
+                index = 0 if message.get("tool_calls") else 1
+                if index < len(turns):
+                    message["content"] = str(turns[index])
+        data = json.dumps(body).encode("utf-8")
+        if cfg.get("stream_timeline") and status == 200 and isinstance(body, dict) and body.get("choices"):
+            self._timeline_wait(cfg)
+        self.send_response(status)
+        self.send_header("Content-Type", "application/json")
+        self.send_header("Content-Length", str(len(data)))
+        self.send_header("Connection", "close")
+        self.end_headers()
+        self.wfile.write(data)
+
+    def _send_raw(self, status: int, data: bytes, ctype: str):
+        """Send a non-JSON or custom body, to test client robustness against bad bodies."""
+        self.send_response(status)
+        self.send_header("Content-Type", ctype)
+        self.send_header("Content-Length", str(len(data)))
+        self.send_header("Connection", "close")
+        self.end_headers()
+        if data:
+            self.wfile.write(data)
+
+    def _timeline_wait(self, cfg: dict) -> None:
+        """Hold the response just before its terminal chunk.
+
+        A streaming point is about *when* output appears, not only what it
+        says: whether the product shows the first token before the response
+        has finished arriving.  That question can only be asked if something
+        holds the response open at a known moment, so the observer owns a
+        barrier immediately before the terminal chunk and the driver reads
+        stdout on both sides of it.
+        """
+        barrier = cfg.get("stream_barrier")
+        release = cfg.get("stream_release")
+        if isinstance(barrier, threading.Event):
+            barrier.set()
+        if isinstance(release, threading.Event):
+            if not release.wait(float(cfg.get("stream_barrier_wait_s") or 8.0)):
+                cfg["stream_wait_timed_out"] = True
+
+    def _send_sse(self, model: str, content: str):
+        """OpenAI-compatible SSE streaming response, required by stream=True paths."""
+        cfg = getattr(self.server, "cfg", CONFIG)
+        if cfg.get("stream_timeline"):
+            parts = tuple(cfg.get("stream_parts") or ())
+            if len(parts) != 2 or "".join(parts) != content:
+                midpoint = max(1, len(content) // 2)
+                parts = (content[:midpoint], content[midpoint:])
+            self.send_response(200)
+            self.send_header("Content-Type", "text/event-stream; charset=utf-8")
+            self.send_header("Cache-Control", "no-cache")
+            self.send_header("Connection", "close")
+            self.end_headers()
+            cid, created = ("chatcmpl-mock", int(time.time()))
+
+            def send(delta, finish=None):
+                chunk = {
+                    "id": cid,
+                    "object": "chat.completion.chunk",
+                    "created": created,
+                    "model": model,
+                    "choices": [{"index": 0, "delta": delta, "finish_reason": finish}],
+                }
+                self.wfile.write(f"data: {json.dumps(chunk, ensure_ascii=False)}\n\n".encode("utf-8"))
+                self.wfile.flush()
+
+            send({"role": "assistant"})
+            send({"content": parts[0]})
+            self._timeline_wait(cfg)
+            send({"content": parts[1]})
+            send({}, "stop")
+            self.wfile.write(b"data: [DONE]\n\n")
+            self.wfile.flush()
+            return
+        self.send_response(200)
+        self.send_header("Content-Type", "text/event-stream; charset=utf-8")
+        self.send_header("Cache-Control", "no-cache")
+        self.send_header("Connection", "close")
+        self.end_headers()
+        cid = "chatcmpl-mock"
+        created = int(time.time())
+        chunks = [
+            {
+                "id": cid,
+                "object": "chat.completion.chunk",
+                "created": created,
+                "model": model,
+                "choices": [{"index": 0, "delta": {"role": "assistant"}, "finish_reason": None}],
+            },
+            {
+                "id": cid,
+                "object": "chat.completion.chunk",
+                "created": created,
+                "model": model,
+                "choices": [{"index": 0, "delta": {"content": content or ""}, "finish_reason": None}],
+            },
+            {
+                "id": cid,
+                "object": "chat.completion.chunk",
+                "created": created,
+                "model": model,
+                "choices": [{"index": 0, "delta": {}, "finish_reason": "stop"}],
+            },
+        ]
+        for ch in chunks:
+            self.wfile.write(f"data: {json.dumps(ch, ensure_ascii=False)}\n\n".encode("utf-8"))
+        self.wfile.write(b"data: [DONE]\n\n")
+
+    def do_GET(self):
+        cfg = getattr(self.server, "cfg", CONFIG)
+        if self.path.startswith("/local-probe"):
+            status = int(cfg.get("web_status") or 200)
+            body = str(cfg.get("web_body") or "").encode("utf-8")
+            record = {"path": self.path, "status": status, "body_bytes": len(body), "send_complete": False}
+            cfg.setdefault("web_gets", []).append(record)
+            try:
+                self.send_response(status)
+                self.send_header("Content-Type", "text/plain; charset=utf-8")
+                self.send_header("Content-Length", str(len(body)))
+                self.send_header("Connection", "close")
+                self.end_headers()
+                self.wfile.write(body)
+                self.wfile.flush()
+                record["send_complete"] = True
+            except (BrokenPipeError, ConnectionResetError, OSError):
+                record["peer_closed"] = True
+            finally:
+                self.close_connection = True
+            return
+        if self.path.startswith("/d2a-network-probe-9931"):
+            cfg.setdefault("web_gets", []).append({"path": self.path, "at": time.time()})
+            self._send(200, {"probe": "NETWORK_ON_OK_9931"})
+            return
+        if self.path.startswith("/__d2a_seen"):
+            from urllib.parse import urlparse, parse_qs
+
+            token = (parse_qs(urlparse(self.path).query).get("token") or [""])[0]
+            seen = bool(token) and any(
+                (
+                    (rec.get("probes") or {}).get(token)
+                    or (rec.get("has_probe") and token == str(cfg.get("probe_token") or ""))
+                    for rec in cfg.get("requests") or []
+                )
+            )
+            self._send(200, {"seen": seen, "token": token, "requests": len(cfg.get("requests") or [])})
+            return
+        self._send(200, {"object": "list", "data": []})
+
+    def do_POST(self):
+        cfg = getattr(self.server, "cfg", CONFIG)
+        n = int(self.headers.get("Content-Length", 0) or 0)
+        raw = self.rfile.read(n) if n else b""
+        has_null = b"\x00" in raw
+        has_escaped_null = b"\\u0000" in raw or b"\\u0000".upper() in raw
+        any_null = has_null or has_escaped_null
+        body_text = raw.decode("utf-8", errors="replace")
+        try:
+            req = json.loads(body_text)
+        except Exception:
+            req = {}
+        model = req.get("model", "mock")
+        rec = {
+            "path": self.path,
+            "n_messages": len(req.get("messages", []) or []),
+            "model": model,
+            "has_null_byte": has_null,
+            "has_escaped_null": has_escaped_null,
+            "has_any_null": any_null,
+            "body_bytes": len(raw),
+            "tool_result_max_bytes": _tool_result_max_bytes(req),
+            "authorization": self.headers.get("Authorization", ""),
+            "has_tools": bool(req.get("tools")),
+            "stream": bool(req.get("stream")),
+            "tool_names": _tool_names(req),
+            "tool_result_texts": [
+                t if len(t) <= 800 else t[:400] + "\n…\n" + t[-400:] for t in _latest_tool_batch(req)
+            ],
+            "bg_job_id": _extract_bg_job_id(_latest_tool_batch(req)),
+            "msg_role_tail": [
+                m.get("role") if isinstance(m, dict) else type(m).__name__
+                for m in (req.get("messages") or [])[-6:]
+            ],
+        }
+        rec.update(wire_facts(req, body_text))
+        if cfg.get("target_command"):
+            rec["target_exchange"] = _target_exchange_facts(
+                req,
+                str(cfg["target_command"]),
+                str(cfg.get("target_left") or ""),
+                str(cfg.get("target_right") or ""),
+            )
+        if cfg.get("structured_prompt_token"):
+            rec["structured_prompt"] = _structured_prompt_facts(
+                req,
+                str(cfg["structured_prompt_token"]),
+                str(cfg.get("structured_prompt_end") or ""),
+                str(cfg.get("structured_prompt_expected") or ""),
+                str(cfg.get("structured_prompt_fragment") or ""),
+            )
+        pt = cfg.get("probe_token") or ""
+        rec["has_probe"] = bool(pt) and pt in body_text
+        rec["has_probe_in_system"] = bool(pt) and any(
+            (
+                pt in json.dumps(m.get("content"), ensure_ascii=False)
+                for m in req.get("messages") or []
+                if isinstance(m, dict) and m.get("role") == "system"
+            )
+        )
+        rec["probes"] = {}
+        for tok in cfg.get("probe_tokens") or []:
+            rec["probes"][tok] = tok in body_text
+            if not rec["probes"][tok] and any((ch in tok for ch in "(?[|")):
+                try:
+                    found = re.search(tok, body_text)
+                except re.error:
+                    found = None
+                if found:
+                    rec["probes"][tok] = True
+                    rec["probes"][found.group(0)] = True
+        _sys_blob = "\n".join(
+            (
+                json.dumps(m.get("content"), ensure_ascii=False)
+                for m in req.get("messages") or []
+                if isinstance(m, dict) and m.get("role") == "system"
+            )
+        )
+        rec["probes_in_system"] = {tok: tok in _sys_blob for tok in cfg.get("probe_tokens") or []}
+        _prompt_blob = "\n".join(
+            (
+                json.dumps(m.get("content"), ensure_ascii=False)
+                for m in req.get("messages") or []
+                if isinstance(m, dict) and m.get("role") in {"system", "user"}
+            )
+        )
+        rec["probes_in_prompt"] = {tok: tok in _prompt_blob for tok in cfg.get("probe_tokens") or []}
+        rec["system_sha"] = hashlib.sha256(_mask_volatile(_sys_blob).encode("utf-8", "replace")).hexdigest()[
+            :16
+        ]
+        cfg["requests"].append(rec)
+        delay = float(cfg.get("response_delay_s") or 0.0)
+        if delay > 0:
+            time.sleep(min(delay, 30.0))
+        mode = cfg["mode"]
+        if cfg.get("strict") and (
+            rec["nonleading_system"] or rec["orphan_tool_result"] or rec["lone_surrogate"] or any_null
+        ):
+            self._send(400, {"error": {"message": "strict wire violation", "type": "invalid_request_error"}})
+            return
+        if mode == "empty_body":
+            self._send_raw(200, b"", "application/json")
+            return
+        if mode == "non_json_body":
+            status, body, content_type = non_json_decode_fixture()
+            self._send_raw(status, body, content_type)
+            return
+        if mode == "http_401":
+            self._send(401, {"error": {"message": "invalid api key", "type": "authentication_error"}})
+            return
+        if mode == "http_500":
+            self._send(500, {"error": {"message": "internal server error", "type": "server_error"}})
+            return
+        if mode == "stall":
+            try:
+                self.send_response(200)
+                self.send_header("Content-Type", "application/json")
+                self.send_header("Content-Length", "9999")
+                self.send_header("Connection", "close")
+                self.end_headers()
+                self.wfile.write(b'{"id":"chatcmpl-mock","choices":[{"index":0,"message":{"role":"assi')
+                self.wfile.flush()
+                time.sleep(60)
+            except Exception:
+                pass
+            self.close_connection = True
+            return
+        if mode == "disconnect":
+            try:
+                self.send_response(200)
+                self.send_header("Content-Type", "application/json")
+                self.send_header("Content-Length", "9999")
+                self.send_header("Connection", "close")
+                self.end_headers()
+                self.wfile.write(b'{"id":"chatcmpl-mock","choices":[{"index":0,"message":{"role":"assi')
+                self.wfile.flush()
+            except Exception:
+                pass
+            self.close_connection = True
+            return
+        if mode == "reject_nullbyte" and any_null:
+            self._send(
+                400, {"error": {"message": "string contains null byte", "type": "invalid_request_error"}}
+            )
+            return
+        if cfg.get("reject_substr") and cfg["reject_substr"].encode() in raw:
+            self._send(
+                400,
+                {
+                    "error": {
+                        "message": f"unknown parameter {cfg['reject_substr']}",
+                        "type": "invalid_request_error",
+                    }
+                },
+            )
+            return
+        status, body = build_response(
+            mode if mode != "reject_nullbyte" else "normal",
+            model,
+            cfg["command"],
+            cfg=cfg,
+            nreq=len(cfg["requests"]),
+            req=req,
+        )
+        if req.get("stream") and status == 200 and isinstance(body, dict):
+            msg = (body.get("choices") or [{}])[0].get("message") or {}
+            content = msg.get("content")
+            if content is not None:
+                self._send_sse(model, content)
+                return
+        self._send(status, body)
+
+
+def make_server(cfg: dict, port: int = 0) -> ThreadingHTTPServer:
+    """Create a mock server with its own cfg; port=0 picks a free port."""
+    srv = ThreadingHTTPServer(("127.0.0.1", port), Handler)
+    srv.cfg = cfg
+    return srv
+
+
+def run(port: int):
+    srv = make_server(CONFIG, port)
+    print(f"[mock_gateway] listening on 127.0.0.1:{port} mode={CONFIG['mode']}", flush=True)
+    srv.serve_forever()
+
+
+if __name__ == "__main__":
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--port", type=int, default=9009)
+    ap.add_argument("--mode", default=None)
+    args = ap.parse_args()
+    if args.mode:
+        CONFIG["mode"] = args.mode
+    run(args.port)
diff --git a/code/src/doc2harness/runtime/permission_driver.py b/code/src/doc2harness/runtime/permission_driver.py
new file mode 100644
index 0000000000000000000000000000000000000000..2a8ff889915ca0a02ef208d9498f147b3f77eeac
--- /dev/null
+++ b/code/src/doc2harness/runtime/permission_driver.py
@@ -0,0 +1,795 @@
+"""Run one active ``permission`` scenario against a real artifact.
+
+The driver uses the public artifact launcher and an explicit model-gateway
+stimulus.  Permission state is supplied through the artifact's reviewed
+configuration surface, while all verdict inputs are reconstructed from the
+typed gateway records and the private workspace; free-form output is retained
+only as diagnostic text.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import re
+import shlex
+import subprocess
+import tempfile
+import threading
+import time
+from dataclasses import asdict, is_dataclass
+from pathlib import Path
+from typing import Any
+
+from doc2harness.runtime import mock_gateway
+from doc2harness.runtime.direct_mock_driver import (
+    _digest,
+    _request_facts,
+    _run_artifact,
+    _trajectory,
+)
+from doc2harness.runtime.resource_limits import container_memory_flags
+
+
+def _observed_text(trajectory: str) -> str:
+    """Project a trajectory down to what the model and its tools said.
+
+    A point of the form "this token must not reach the model" is answered by
+    the result, not by the request.  A recorded call keeps the arguments it
+    was made with and a recorded refusal repeats the command it refused - so
+    the token appears in the very call the product then *refused*, and a
+    session that correctly denied it reads as having leaked it.  The refusal
+    text itself survives, which is the evidence the point actually wants.
+
+    Each product names that record in its own words - one writes
+    ``"kind": "permission"`` with a ``target``, another ``"kind":
+    "bash_denied"`` with a ``command`` - so the echo is removed by the field
+    that carries it rather than by the event's name.  Keying on one product's
+    spelling leaves the other's echo in place, and the point inverts again.
+    """
+
+    without_arguments = re.sub(
+        r'"(?:arguments|args|input)"\s*:\s*"(?:[^"\\]|\\.)*"',
+        '"arguments": ""',
+        trajectory,
+    )
+    without_arguments = re.sub(
+        r'"(?:arguments|args|input)"\s*:\s*\{[^{}]*\}',
+        '"arguments": {}',
+        without_arguments,
+    )
+    # A record that states a denial is describing a request, so the command or
+    # target it names is the request - never a result.
+    return re.sub(
+        r'("kind"\s*:\s*"[a-z_]*(?:denied|refused|blocked|permission)[a-z_]*"[^\n]*?)'
+        r'"(command|target)"\s*:\s*"(?:[^"\\]|\\.)*"',
+        r'\1"\2": ""',
+        without_arguments,
+    )
+
+
+def _escape_path(root: Path) -> Path:
+    """A unique absolute path outside the workspace for the escape probes.
+
+    These points ask whether a restricted session can write outside its
+    working directory, so the target has to be a specific path the observer
+    can then look for.  Asking instead whether anything at all exists beside
+    the workspace is answered by the harness's own scratch files, which
+    makes a session that was correctly blocked read as having escaped.
+    """
+
+    return root / "escape" / f"perm_esc_{os.getpid()}.txt"
+
+
+def _rounds(plan: Any, escape: str = "", escape_directory: str = "") -> list[list[dict[str, Any]]]:
+    rounds: list[list[dict[str, Any]]] = []
+    for turn in plan.gateway_turns:
+        calls: list[dict[str, Any]] = []
+        for call in turn.tool_calls:
+            arguments = dict(call.arguments)
+            # The deterministic gateway treats Bash's command as a
+            # top-level field in a seq_probe round; other tools keep their
+            # schema arguments under ``args``.  Keeping this distinction here
+            # avoids silently turning every permission probe into ``bash ''``.
+            # ``{ESC}`` stands for a path outside the workspace and
+            # ``{ESCDIR}`` for the directory holding it; left unexpanded the
+            # product writes a file literally named "{ESC}" inside the
+            # workspace, which is not an escape at all.
+            def _expand(value: Any) -> Any:
+                if not isinstance(value, str):
+                    return value
+                if escape_directory:
+                    value = value.replace("{ESCDIR}", escape_directory)
+                return value.replace("{ESC}", escape) if escape else value
+
+            arguments = {key: _expand(value) for key, value in arguments.items()}
+            if call.tool_name in {"bash", "shell", "run_command", "execute", "exec", "terminal"}:
+                command = str(_expand(arguments.pop("command", "")))
+                calls.append({"name": call.tool_name, "command": command, **arguments})
+            else:
+                calls.append({"name": call.tool_name, "args": arguments})
+        if calls:
+            rounds.append(calls)
+    return rounds
+
+
+# Interpreter/script operands are mutation vehicles, never the mutated target.
+_SCRIPT_SUFFIXES = (".py", ".sh", ".bash", ".pl", ".rb", ".js")
+
+
+def _initial_state_from_setup(commands: tuple[str, ...]) -> tuple[str | None, str | None]:
+    """Classify the recipe's initial permission state as ``(mode, role)``.
+
+    Artifacts gate mutation on
+    ``mode == "plan" or role == "ask" or sandbox == "read-only"``.  ``/mode ask``
+    is a *confirmation* mode and does not restrict writes, whereas the bare
+    ``/ask`` alias selects the answer-only *role*, which does.  Passing an ``ask``
+    role through ``mode`` therefore leaves ``read_only`` false and silently turns
+    a readonly probe into an unrestricted write.
+
+    Only the *first* state-setting command describes the session's initial
+    state.  Anything after it is an ordered transition that must reach the
+    artifact through ``session.dispatch`` so the transition itself is exercised;
+    injecting a later state would start the session already in its final state
+    and erase the behavior under test.  When the recipe transitions at all, the
+    session starts from the artifact default and nothing is injected.
+    """
+    states: list[tuple[str | None, str | None]] = []
+    for command in commands:
+        text = command.strip()
+        mode_match = re.search(r"/mode\s+(yolo|plan|ask|auto-edit|auto-review)\b", text)
+        if mode_match:
+            states.append((mode_match.group(1), None))
+            continue
+        role_match = re.search(r"/role\s+(execute|ask|architect|debug|orchestrator)\b", text)
+        if role_match:
+            states.append((None, role_match.group(1)))
+            continue
+        # Short slash aliases accepted by the permission probes.  ``/ask`` is
+        # a role alias; the rest are mode aliases.
+        if re.fullmatch(r"/ask\b", text):
+            states.append((None, "ask"))
+            continue
+        mode_alias = re.fullmatch(r"/(yolo|plan|auto-edit|auto-review)\b", text)
+        if mode_alias:
+            states.append((mode_alias.group(1), None))
+
+    if not states:
+        return (None, None)
+    if len(states) > 1:
+        # Ordered transition sequence — dispatch must establish every step.
+        return (None, None)
+    return states[0]
+
+
+def _mode_from_setup(commands: tuple[str, ...]) -> str:
+    """Return the effective mode for the on-disk config file.
+
+    This is the config-file view, which has no notion of ordered transitions;
+    it records the last declared mode so a launcher that reads only the config
+    still sees a coherent value.  ``/ask`` is excluded because it is a role.
+    """
+    mode = "yolo"
+    for command in commands:
+        match = re.search(r"/mode\s+(yolo|plan|ask|auto-edit|auto-review)\b", command)
+        if match:
+            mode = match.group(1)
+            continue
+        alias = re.fullmatch(r"/(yolo|plan|auto-edit|auto-review)\b", command.strip())
+        if alias:
+            mode = alias.group(1)
+    return mode
+
+
+def _explicit_mode_from_setup(commands: tuple[str, ...]) -> str | None:
+    """Return the initial mode to pass to ``create_session``, if any."""
+    return _initial_state_from_setup(commands)[0]
+
+
+def _explicit_role_from_setup(commands: tuple[str, ...]) -> str | None:
+    """Return the initial role to pass to ``create_session``, if any."""
+    return _initial_state_from_setup(commands)[1]
+
+
+def _public_session_script(
+    plan: Any,
+    escape_directory: Path | None = None,
+    counterfactual_setup: tuple[str, ...] | None = None,
+) -> str:
+    """Build the in-container script for the artifact's public API.
+
+    Permission scenarios are interactive by contract: setup slash commands
+    such as ``/mode ask`` must be applied to the same session that receives the
+    deterministic tool calls.  Artifact launchers commonly hard-code yolo for
+    ordinary headless runs, so invoking only ``run_agent.sh`` silently discards
+    the setup and creates a false permission failure.  This script still imports and
+    executes the unchanged artifact inside the evaluation image; it merely
+    selects its reviewed ``yuyao.agent_api.create_session`` boundary, the same
+    boundary the stage1 permission smoke uses.
+    """
+    deny = list(plan.deny_rules)
+    setup = [
+        item.replace("{ESCDIR}", str(escape_directory)) if escape_directory else item
+        for item in (list(counterfactual_setup) if counterfactual_setup is not None
+                     else list(plan.setup_commands))
+    ]
+    mode = _explicit_mode_from_setup(plan.setup_commands)
+    role = _explicit_role_from_setup(plan.setup_commands)
+    mode_argument = f", mode={mode!r}" if mode is not None else ""
+    role_argument = f", role={role!r}" if role is not None else ""
+    return (
+        "import json, os, sys, traceback\n"
+        "from yuyao.agent_api import create_session\n"
+        # Do not pre-apply a guessed mode/role here.  Commands such as
+        # ``/ask`` intentionally change the role and (in the artifact's
+        # command router) also establish its mode; dispatching the exact setup
+        # sequence from the recipe is the only faithful behavior.
+        # Pass the declared mode through the public API as well as dispatching
+        # its slash command.  Some artifacts treat ``/mode`` as a
+        # display/router command and leave the session permission state at its
+        # default (yolo); omitting this argument would silently turn an ask
+        # probe into an unrestricted write.  The declared role is passed for the
+        # same reason: ``read_only`` is gated on ``role == "ask"``, so a role
+        # folded into ``mode`` would not restrict anything.
+        f"session = create_session(deny={deny!r}{mode_argument}{role_argument}, cwd='/sbh-workspace')\n"
+        f"for command in {setup!r}:\n"
+        # A setup command the product does not implement raises, and letting
+        # that abort the script throws away the probe entirely: the point then
+        # reports zero requests and judges the product on an observation it
+        # never made.  One artifact exposes its sandbox level only as a CLI
+        # flag, so ``/sandbox full-access`` raises "unknown command" and the
+        # write probe that followed never ran at all.  Logging each such
+        # failure and carrying on is the only faithful reading: the declared state is already passed to the session factory
+        # above, so the run is still in the state the recipe asked for.
+        "    try:\n"
+        "        session.dispatch(command)\n"
+        "    except BaseException as exc:\n"
+        "        sys.stderr.write('SETUP_ERR %r: %r\\n' % (command, exc))\n"
+        "try:\n"
+        "    session.chat('Please run the necessary shell commands now.')\n"
+        "finally:\n"
+        "    session.close()\n"
+    )
+
+
+def _run_public_session(
+    artifact: Path,
+    workspace: Path,
+    home: Path,
+    env: dict[str, str],
+    port: int,
+    plan: Any,
+    timeout: int,
+    script: str | None = None,
+    escape_root: Path | None = None,
+) -> tuple[subprocess.CompletedProcess[str], bool]:
+    """Run a permission scenario through the artifact's public session API."""
+
+    image = os.environ.get("SBH_EVALUATION_IMAGE", "doc2harness/evaluation:candidate")
+    command = [
+        "docker", "run", *container_memory_flags(), "--rm", "--init", "--network", "bridge",
+        "--add-host=host.docker.internal:host-gateway", "--read-only",
+        "--tmpfs", "/tmp:rw,noexec,nosuid,size=256m",
+        "--user", f"{os.getuid()}:{os.getgid()}",
+        "-v", f"{artifact}:/sbh-artifact:ro",
+        "-v", f"{workspace}:/sbh-workspace:rw",
+        # Without a bound working directory the container starts in the image
+        # default, so a relative path written by a hook command lands outside
+        # the mounted workspace and the observer, looking where the recipe says
+        # to look, concludes the hook never fired.
+        "-w", "/sbh-workspace",
+        # The escape probe writes to an absolute path outside the working
+        # directory, so that path has to exist at the same location inside the
+        # container - otherwise the write fails for want of a directory and a
+        # session that was never restricted still reads as blocked.
+        *(("-v", f"{escape_root}:{escape_root}:rw") if escape_root else ()),
+        "-v", f"{home}:/sbh-home:rw",
+        "-e", "HOME=/sbh-home", "-e", "YUYAO_HOME=/sbh-home/.yuyao",
+        "-e", "PYTHONDONTWRITEBYTECODE=1",
+        "-e", f"D2A_MODEL_BASE_URL=http://host.docker.internal:{port}/v1",
+        "-e", "D2A_MODEL_NAME=litellm_proxy/mock", "-e", "D2A_MODEL_API_KEY=sk-mock-test",
+        "-e", "PYTHONPATH=/sbh-artifact/src", image, "python3", "-c",
+        script if script is not None else _public_session_script(plan),
+    ]
+    try:
+        completed = subprocess.run(
+            command, cwd=workspace, env=env, stdin=subprocess.DEVNULL,
+            capture_output=True, text=True, timeout=timeout, check=False,
+        )
+        return completed, False
+    except subprocess.TimeoutExpired as exc:
+        return subprocess.CompletedProcess(command, -1, exc.stdout or "", exc.stderr or ""), True
+
+
+def _shell_path(command: str) -> str | None:
+    # This intentionally extracts only relative workspace candidates.  It is
+    # used to locate a declared marker, never to execute or normalize a path.
+    candidates = re.findall(r"(?<![A-Za-z0-9_./-])([A-Za-z0-9_./-]+)(?=\s|$|['\"])", command)
+    for item in candidates:
+        if item in {"echo", "printf", "touch", "cat", "rm", "mkdir", "chmod", "bash", "sh"}:
+            continue
+        if item.startswith("/") or item in {"-f", "-rf", "-p"}:
+            continue
+        if "/" in item or "." in item or "_" in item:
+            return item.strip("'\"")
+    return None
+
+
+def _effective_cwd(workspace: Path, setup_commands: tuple[str, ...]) -> Path:
+    """Infer the effective working directory after the setup slash commands.
+
+    ``/cd`` changes the working directory inside the artifact session.  When the
+    probe command uses a bare filename such as ``tgt.txt`` (not a full path), the
+    observer must read it relative to the final cwd, not the workspace root.
+    Only relative paths that stay inside the workspace are followed.
+    """
+    cwd = workspace
+    for command in setup_commands:
+        match = re.fullmatch(r"/cd\s+([^\s]+)", command.strip())
+        if not match:
+            match = re.search(r"^/cd\s+([^\s]+)", command.strip())
+        if match:
+            target = match.group(1).strip()
+            if target.startswith("/"):
+                continue  # absolute path inside container — skip
+            candidate = (cwd / target).resolve()
+            try:
+                candidate.relative_to(workspace.resolve())
+                cwd = candidate
+            except ValueError:
+                pass  # escapes workspace — ignore
+    return cwd
+
+
+def _expand_literal_substitution(token: str) -> str:
+    """Resolve the constant command substitutions used by the deny/readonly probes.
+
+    Recipes address a target through ``$(echo tgt).txt`` or ``${x}`` style
+    framing to test the artifact's command normalisation.  The shell expands
+    these to a fixed name, so the observer must look at the same file rather
+    than at a literal ``$(echo tgt).txt`` path that never exists.  Only constant
+    ``echo``/``printf`` substitutions are expanded — nothing is executed.
+    """
+    previous = None
+    current = token
+    while previous != current:
+        previous = current
+        current = re.sub(
+            r"\$\(\s*(?:echo|printf)\s+([^()|;&<>$`]*?)\s*\)",
+            lambda match: match.group(1).strip().strip("'\""),
+            current,
+        )
+        current = re.sub(r"\$\{([A-Za-z_][A-Za-z0-9_]*)\}", r"$\1", current)
+    return current
+
+
+def _target_path(
+    workspace: Path,
+    command: str,
+    seed: tuple[tuple[str, str], ...],
+    effective_cwd: Path | None = None,
+) -> Path | None:
+    cwd = effective_cwd if effective_cwd is not None else workspace
+    # Extract the last token from the command — for cp/mv it is the destination.
+    # Constant command substitutions are expanded so the observer inspects the
+    # same file the shell writes to.
+    raw_tail = command.split()[-1].lstrip(">").strip().strip("'\"") if command.split() else None
+    tail = _expand_literal_substitution(raw_tail) if raw_tail else None
+    # A trailing *script* operand (``python3 w.py``, ``bash x.sh``) is the
+    # mutation vehicle, not the mutated file.  The file the script writes is the
+    # other seed, so the trailing token must not win in that shape.
+    tail_is_script = bool(tail) and tail.endswith(_SCRIPT_SUFFIXES)
+    # Prefer a seed that matches by the last token / full relative path over an
+    # earlier partial match, so ``cp src.txt tgt.txt`` targets ``tgt.txt``.
+    if tail and not tail_is_script:
+        for relative, _ in seed:
+            if Path(relative).name == tail or relative == tail:
+                return workspace / relative
+    if tail_is_script:
+        # Fall back to the single seed that is not the script itself.
+        non_script = [
+            relative for relative, _ in seed
+            if not relative.endswith(_SCRIPT_SUFFIXES)
+        ]
+        if len(non_script) == 1:
+            return workspace / non_script[0]
+    for relative, _ in seed:
+        if relative in command:
+            return workspace / relative
+    # Prefer the operand of a redirection or a mutating command.  A generic
+    # token scan would mistake ``PERM_LIVE_7755`` (the echoed payload) for the
+    # actual ``live.txt`` target.
+    try:
+        tokens = [_expand_literal_substitution(token) for token in shlex.split(command)]
+    except ValueError:
+        tokens = []
+    for marker in (">", ">>"):
+        if marker in tokens:
+            index = len(tokens) - 1 - tokens[::-1].index(marker)
+            if index + 1 < len(tokens) and not tokens[index + 1].startswith("/"):
+                return cwd / tokens[index + 1]
+    for command_name in ("touch", "rm", "cat", "mkdir", "chmod"):
+        if command_name in tokens:
+            index = tokens.index(command_name)
+            if index + 1 < len(tokens) and not tokens[index + 1].startswith("-"):
+                return cwd / tokens[index + 1]
+    candidate = _shell_path(command)
+    return cwd / candidate if candidate else None
+
+
+_HOOK_EXEC_PLACEHOLDER = "{HOOK_EXECUTABLE}"
+_HOOK_MISSING_PLACEHOLDER = "{HOOK_MISSING_EXECUTABLE}"
+_HOOK_MARKER_PLACEHOLDER = "{HOOK_MARKER}"
+_HOOK_EVENT = "HOOKFAIL_HEALTHY_HOOK_EXIT_0"
+
+
+def _hook_fixture(workspace: Path) -> dict[str, str]:
+    """Materialise the hook executables a hook point names in its config.
+
+    The recipe declares its hook commands as placeholders because the paths
+    are only known once the run has a directory.  Left unsubstituted the
+    product is handed ``{HOOK_EXECUTABLE} {HOOK_MARKER}`` verbatim, the shell
+    reports "command not found", and the point sees a hook that failed - on
+    a fixture that was never built.  One entry has to exist and exit 0, the
+    other must be absent: that contrast is the whole subject of the point.
+    """
+
+    directory = workspace / ".sbh-hooks"
+    directory.mkdir(parents=True, exist_ok=True)
+    healthy = directory / "healthy_hook.sh"
+    healthy.write_text(
+        "#!/bin/sh\n"
+        f"printf '%s\\n' '{_HOOK_EVENT}' >> \"$1\"\n"
+        "exit 0\n",
+        encoding="utf-8",
+    )
+    healthy.chmod(0o755)
+    return {
+        _HOOK_EXEC_PLACEHOLDER: "/sbh-workspace/.sbh-hooks/healthy_hook.sh",
+        _HOOK_MISSING_PLACEHOLDER: "/sbh-workspace/.sbh-hooks/missing_hook_executable",
+        _HOOK_MARKER_PLACEHOLDER: "/sbh-workspace/.sbh-hooks/hook.trace",
+    }
+
+
+def _hook_events(workspace: Path) -> tuple[str, ...]:
+    """Read the lines the hook executables appended to their trace."""
+
+    trace = workspace / ".sbh-hooks" / "hook.trace"
+    if not trace.is_file():
+        return ()
+    return tuple(
+        line.strip()
+        for line in trace.read_text(encoding="utf-8", errors="replace").splitlines()
+        if line.strip()
+    )
+
+
+def _seed(workspace: Path, plan: Any) -> None:
+    substitutions = (
+        _hook_fixture(workspace) if plan.fixture.hook_exec_fixture else {}
+    )
+    for relative, content in plan.fixture.seed_files:
+        path = workspace / relative
+        path.parent.mkdir(parents=True, exist_ok=True)
+        # A trailing slash declares a directory, which is what the rmdir
+        # probe removes.  pathlib normalises the slash away, so the entry is
+        # created as a directory explicitly; as a regular file the probe would
+        # have nothing to remove and the point could not observe whether
+        # read-only blocked the removal.
+        if str(relative).endswith("/"):
+            path.mkdir(parents=True, exist_ok=True)
+            continue
+        for placeholder, actual in substitutions.items():
+            content = content.replace(placeholder, actual)
+        path.write_text(content, encoding="utf-8")
+    if plan.fixture.initialize_git:
+        for relative, content, _worktree in plan.fixture.git_baseline_files:
+            path = workspace / relative
+            path.parent.mkdir(parents=True, exist_ok=True)
+            path.write_text(content, encoding="utf-8")
+        subprocess.run(("git", "init", "-q"), cwd=workspace, check=False)
+        subprocess.run(("git", "config", "user.email", "sbh-observer@example.invalid"), cwd=workspace, check=False)
+        subprocess.run(("git", "config", "user.name", "SBH Observer"), cwd=workspace, check=False)
+        subprocess.run(("git", "add", "."), cwd=workspace, check=False)
+        subprocess.run(("git", "commit", "-qm", "baseline"), cwd=workspace, check=False)
+        # Each entry carries a committed value and a working-tree value, and
+        # the second one is the point of the fixture: a dangerous git command
+        # is observed by whether it reverts the tree back to the committed
+        # content, so the tree has to start out differing from it.  The third
+        # element is that working-tree value, not a file mode.
+        for relative, _content, worktree in plan.fixture.git_baseline_files:
+            if worktree:
+                (workspace / relative).write_text(worktree, encoding="utf-8")
+
+
+def _config(home: Path, plan: Any) -> None:
+    config_dir = home / ".yuyao"
+    config_dir.mkdir(parents=True, exist_ok=True)
+    value: dict[str, Any] = {
+        "agent.mode": _mode_from_setup(plan.setup_commands),
+        "permissions.deny": list(plan.deny_rules),
+    }
+    role = _explicit_role_from_setup(plan.setup_commands)
+    if role is not None:
+        value["agent.role"] = role
+    (config_dir / "config.json").write_text(
+        json.dumps(value, ensure_ascii=False, sort_keys=True), encoding="utf-8"
+    )
+
+
+def _facts(
+    scenario: Any,
+    plan: Any,
+    workspace: Path,
+    records: list[dict[str, Any]],
+    trajectory: str,
+    escape_path: Path | None = None,
+) -> dict[str, Any]:
+    recipe = scenario.recipe
+    # A monitor/background probe produces its effect asynchronously - its
+    # command is "touch <started>; sleep 0.2; touch <effect>" - so the declared
+    # settle paths land a moment after the parent turn has already returned.
+    # Reading the workspace immediately then sees only the first touch and
+    # judges the effect absent for a monitor that in fact produced it.  Give the
+    # declared settle paths a bounded window to appear before
+    # any file-based fact is read; a scenario that declares none, or whose
+    # effect is legitimately blocked (deny variant), simply waits out the short
+    # window and is still judged absent - correctly.
+    if getattr(plan.fixture, "settle_paths", ()):
+        deadline = time.monotonic() + 5.0
+        while time.monotonic() < deadline and not all(
+            (workspace / path).exists() for path in plan.fixture.settle_paths
+        ):
+            time.sleep(0.1)
+    # ``/cd`` in the setup sequence moves the artifact session's working
+    # directory, so bare filenames in the allow/probe commands resolve there
+    # rather than at the workspace root.
+    effective_cwd = _effective_cwd(workspace, plan.setup_commands)
+    allow_path = _target_path(workspace, recipe.allow_command, recipe.seed_files, effective_cwd)
+    probe_path = _target_path(workspace, recipe.probe_command, recipe.seed_files, effective_cwd)
+    # A dangerous-git probe names no file: "git stash" and "git reset --hard"
+    # act on the tree, and what the point observes is whether the tracked
+    # file kept its working-tree sentinel or was reverted to the committed
+    # content.  Deriving the target from the command text yields nothing
+    # there, so the file the git fixture declares is the target instead.
+    if probe_path is None and recipe.initialize_git and recipe.git_baseline_files:
+        probe_path = workspace / recipe.git_baseline_files[0][0]
+    secondary_path = _target_path(workspace, recipe.second_probe or "", recipe.seed_files, effective_cwd)
+    # A tool probe names its target in the call arguments, not in a shell
+    # command - the command field is a placeholder there, so deriving the path
+    # from it yields nothing and the point cannot see what the tool wrote.
+    if recipe.probe_tool:
+        declared = dict(getattr(recipe, "probe_arguments", ()) or ())
+        for key in ("file_path", "path", "filename", "target", "notebook_path"):
+            value = declared.get(key)
+            if isinstance(value, str) and value and not value.startswith("/"):
+                if secondary_path is None:
+                    secondary_path = workspace / value
+                if probe_path is None:
+                    probe_path = workspace / value
+                break
+    messages = "\n".join(
+        str(item)
+        for record in records
+        for item in (record.get("tool_result_texts") or ())
+    )
+    observed_tokens = tuple(sorted(
+        token
+        for record in records
+        for token, seen in (record.get("probes") or {}).items()
+        if seen
+    ))
+    advertised = tuple(str(item) for item in (records[0].get("tool_names") or ())) if records else ()
+    return {
+        "allow_file_present": bool(allow_path and allow_path.is_file()),
+        # The forbidden artefact has a fixed name in the inventory.  Deriving it
+        # from the probe command works for a probe that names its target, but a
+        # hook point probes with "echo hi" and the artefact is written by the
+        # hook itself - so the declared sentinel is the thing to look for when
+        # the command names no path of its own.
+        "deny_file_present": bool(
+            (probe_path and probe_path.exists())
+            or (workspace / "PERM_DENY_7755.txt").exists()
+        ),
+        "target_content": probe_path.read_text(encoding="utf-8", errors="replace") if probe_path and probe_path.is_file() else None,
+        "secondary_target_content": secondary_path.read_text(encoding="utf-8", errors="replace") if secondary_path and secondary_path.is_file() else None,
+        "escaped_path_present": escape_path.is_file() if escape_path is not None else False,
+        "target_mode": oct(probe_path.stat().st_mode & 0o777) if probe_path and probe_path.exists() else None,
+        "seed_directory_present": (workspace / "seeddir_7755").is_dir(),
+        "node_present": (workspace / "newnode_7755").exists() or (workspace / "newnode_7755").is_symlink(),
+        "memory_directory_present": (workspace / "memory").exists(),
+        "directory_present": (workspace / "newdir_7755").is_dir(),
+        "probe_tool_advertised": recipe.probe_tool in advertised,
+        "git_ready": (workspace / ".git").is_dir(),
+        "messages_text": messages + "\n" + _observed_text(trajectory),
+        "stdout_text": _observed_text(trajectory),
+        "observed_tokens": observed_tokens,
+        "advertised_tools": advertised,
+        "settled_paths": tuple(path for path in plan.fixture.settle_paths if (workspace / path).exists()),
+    }
+
+
+def _run_one() -> dict[str, Any]:
+    from doc2harness.benchmark.definition import definition_digest
+    from doc2harness.benchmark.dispatch import load_scenario_owner
+    from doc2harness.benchmark.harnesses.permission.adapter import build_permission_execution_plan
+    from doc2harness.benchmark.harnesses.permission.contracts import PermissionRawObservation
+
+    scenario_id = os.environ.get("SBH_SCENARIO_ID", "")
+    owner = load_scenario_owner(scenario_id)
+    if ".benchmark.harnesses.permission." not in owner.module:
+        raise RuntimeError("permission driver received a non-permission scenario")
+    scenario = owner.scenario
+    plan = build_permission_execution_plan(scenario)
+    gateway = mock_gateway
+    escape_root = Path(tempfile.mkdtemp(prefix="sbh-permission-escape-"))
+    escape_path = _escape_path(escape_root)
+    escape_path.parent.mkdir(parents=True, exist_ok=True)
+    rounds = (
+        _rounds(plan, str(escape_path), str(escape_path.parent))
+    )
+    with tempfile.TemporaryDirectory(prefix="sbh-permission-production-") as temporary:
+        root = Path(temporary)
+        home, workspace, output = root / "home", root / "workspace", root / "out"
+        home.mkdir(); workspace.mkdir(); output.mkdir()
+        _seed(workspace, plan)
+        _config(home, plan)
+        task = workspace / "task.json"
+        budget = workspace / "budget.json"
+        task.write_text(json.dumps({"problem_statement": "Run the declared permission probe and stop."}), encoding="utf-8")
+        budget.write_text(json.dumps({"max_steps": max(3, len(rounds) + 1)}), encoding="utf-8")
+        cfg = gateway.new_cfg(
+            mode="seq_probe",
+            rounds=rounds,
+            probe_tokens=list(plan.fixture.probe_tokens),
+        )
+        # Docker reaches the host gateway address, not the host loopback
+        # interface.  Bind the deterministic stimulus listener on all host
+        # interfaces so the container can actually deliver its model request.
+        server = gateway.ThreadingHTTPServer(("0.0.0.0", 0), gateway.Handler)
+        server.cfg = cfg
+        server.daemon_threads = True
+        server.block_on_close = False
+        thread = threading.Thread(target=server.serve_forever, daemon=True)
+        thread.start()
+        env = dict(os.environ)
+        env.update({"HOME": str(home), "YUYAO_HOME": str(home / ".yuyao"), "PYTHONDONTWRITEBYTECODE": "1"})
+        argv = [
+            str(Path(os.environ["SBH_ARTIFACT_PATH"]) / "run_agent.sh"),
+            "--task-file", str(task), "--repo-dir", str(workspace),
+            "--model-base-url", f"http://127.0.0.1:{server.server_address[1]}/v1",
+            "--model-name", "litellm_proxy/mock", "--model-api-key", "sk-mock-test",
+            "--budget-file", str(budget), "--out-dir", str(output),
+        ]
+        artifact = Path(os.environ["SBH_ARTIFACT_PATH"])
+        # Prefer the stable public session API for permission scenarios, so
+        # setup commands are real state transitions; retain the launcher
+        # fallback for artifacts that predate that API.  The fallback is intentionally not used when the
+        # API is present, otherwise ``/mode ask`` would be silently ignored by
+        # their hard-coded headless launcher mode.
+        has_api = (artifact / "src" / "yuyao" / "agent_api.py").is_file()
+        if has_api:
+            completed, timed_out = _run_public_session(
+                artifact, workspace, home, env, int(server.server_address[1]),
+                plan, min(plan.timeout_seconds, 300),
+                script=(
+                    _public_session_script(plan, escape_path.parent)
+                ),
+                escape_root=escape_root,
+            )
+        else:
+            completed, timed_out = _run_artifact(
+                artifact, workspace, home, output, task, budget,
+                argv, env, int(server.server_address[1]), min(plan.timeout_seconds, 300),
+            )
+        trajectory = _trajectory(home) + "\n" + _trajectory(workspace) + "\n" + _trajectory(output)
+        # A grant point is a contrast, not a single observation: the same write
+        # is attempted once with the directory granted and once without, and
+        # only the difference distinguishes "the grant works" from "the sandbox
+        # was never restricting that path anyway".  Without the second run both
+        # facts stay unset and the point cannot be decided at all.
+        granted_write: bool | None = None
+        ungranted_write: bool | None = None
+        counterfactual = tuple(getattr(plan, "counterfactual_setup_commands", ()) or ())
+        probe_target = escape_path.parent / "escf.txt"
+        if counterfactual and has_api:
+            granted_write = probe_target.is_file()
+            probe_target.unlink(missing_ok=True)
+            # The counterfactual is a second run of the same probe, so its
+            # requests are left out of the ledger the first run's facts are
+            # read from - appending them would inflate every request-count
+            # fact by the price of asking a question about a different run.
+            baseline = list(cfg.get("requests", []))
+            _run_public_session(
+                artifact, workspace, home, env, int(server.server_address[1]),
+                plan, min(plan.timeout_seconds, 300),
+                script=_public_session_script(plan, escape_path.parent, counterfactual),
+                escape_root=escape_root,
+            )
+            ungranted_write = probe_target.is_file()
+            cfg["requests"][:] = baseline
+        variant_facts: dict[str, Any] = {}
+        for line in (completed.stdout or "").splitlines():
+            if line.startswith("SBH_VARIANT_RESULT="):
+                try:
+                    parsed = json.loads(line[len("SBH_VARIANT_RESULT="):])
+                except (TypeError, ValueError, json.JSONDecodeError):
+                    parsed = {}
+                if isinstance(parsed, dict):
+                    variant_facts = parsed
+        requests = _request_facts(cfg.get("requests", []), None)
+        facts = _facts(scenario, plan, workspace, cfg.get("requests", []), trajectory, escape_path)
+        observation = PermissionRawObservation(
+            scenario_id=scenario_id, plan_digest=plan.plan_digest,
+            artifact_id=os.environ["SBH_ARTIFACT_ID"], artifact_digest=os.environ["SBH_ARTIFACT_DIGEST"],
+            request_count=len(requests),
+            allow_file_present=bool(facts["allow_file_present"]), deny_file_present=bool(facts["deny_file_present"]),
+            target_content=facts["target_content"], secondary_target_content=facts["secondary_target_content"],
+            escaped_path_present=bool(facts["escaped_path_present"]), target_mode=facts["target_mode"],
+            seed_directory_present=bool(facts["seed_directory_present"]), node_present=bool(facts["node_present"]),
+            memory_directory_present=bool(facts["memory_directory_present"]), directory_present=bool(facts["directory_present"]),
+            probe_tool_advertised=bool(facts["probe_tool_advertised"]), git_ready=bool(facts["git_ready"]),
+            granted_path_write_present=granted_write, ungranted_path_write_present=ungranted_write,
+            canonical_variant_blocked=variant_facts.get("canonical_blocked"),
+            rewritten_variant_blocked=variant_facts.get("rewritten_blocked"),
+            rewritten_variant_control_mutated=variant_facts.get("control_mutated"),
+            messages_text=str(facts["messages_text"]), stdout_text=str(facts["stdout_text"]),
+            process_tree_clean=not timed_out, gateway_clean=True, workspace_clean=True, timed_out=timed_out,
+            backend_evidence_digest=_digest({"scenario_id": scenario_id, "requests": len(requests), "rc": completed.returncode}),
+            observed_tokens=tuple(facts["observed_tokens"]), settled_paths=tuple(facts["settled_paths"]),
+            advertised_tools=tuple(facts["advertised_tools"]),
+            # The healthy hook records its own exit through the trace path the
+            # config named, which is the only evidence that the matcher chain
+            # ran at all.  Without it a point cannot tell a hook that fired and
+            # allowed the operation from a hook that was never reached.
+            hook_events=_hook_events(workspace),
+        )
+        server.shutdown(); server.server_close(); thread.join(timeout=2)
+    judgement = owner.judge(observation)
+    return {"observation": observation, "judgement": judgement,
+            "plan_digest": plan.plan_digest, "definition_digest": definition_digest(owner.definition),
+            "module": owner.module}
+
+
+def _as_mapping(value: object) -> dict:
+    """Serialise an observation or judgement whichever shape it uses.
+
+    asdict() alone raises for this harness's scenarios, which declare Judgement
+    as a NamedTuple while the other harnesses use dataclasses.
+
+    Both shapes are legitimate; the driver just cannot assume one of them.
+    """
+    if is_dataclass(value) and not isinstance(value, type):
+        return asdict(value)
+    fields = getattr(value, "_fields", None)
+    if fields is not None:                      # NamedTuple
+        return {name: getattr(value, name) for name in fields}
+    raise TypeError(f"cannot serialise {type(value).__name__} as a mapping")
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.parse_args()
+    result = _run_one()
+    target = Path(os.environ["SBH_TYPED_EVENT_PATH"])
+    target.parent.mkdir(parents=True, exist_ok=True)
+    target.write_text(json.dumps({
+        "schema": "doc2harness.typed-events/1",
+        "source_digest": os.environ["SBH_SOURCE_DIGEST"],
+        "task_digest": os.environ["SBH_TASK_DIGEST"],
+        "budget_digest": os.environ["SBH_BUDGET_DIGEST"],
+        "artifact_digest": os.environ["SBH_ARTIFACT_DIGEST"],
+        "artifact_id": os.environ["SBH_ARTIFACT_ID"],
+        "scenario_id": os.environ["SBH_SCENARIO_ID"],
+        "scenario_module": result["module"],
+        "definition_digest": result["definition_digest"],
+        "events": [{"type": "permission-observation",
+                    "observation": _as_mapping(result["observation"]),
+                    "judgement": _as_mapping(result["judgement"])}],
+    }, ensure_ascii=False, default=lambda value: value.value if hasattr(value, "value") else str(value), indent=2) + "\n", encoding="utf-8")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/code/src/doc2harness/runtime/resource_limits.py b/code/src/doc2harness/runtime/resource_limits.py
new file mode 100644
index 0000000000000000000000000000000000000000..e29bf2a46dd77592b56254463117cff0427502fd
--- /dev/null
+++ b/code/src/doc2harness/runtime/resource_limits.py
@@ -0,0 +1,39 @@
+"""Resource caps for containers that run artifact code.
+
+An artifact is untrusted code by construction -- it is the thing under test. It
+gets executed by almost every driver, and without a cap a single runaway
+allocation can exhaust the host and take every concurrent run down with it.
+
+Why this belongs in the framework rather than in whoever launches the run: the
+cap has to hold no matter which driver is executing, including drivers added
+later. A per-caller convention would be forgotten exactly once and cost a host.
+
+The cap is deliberately generous. A scored container normally sits in the tens of
+MB, so the default is far above ordinary work; it exists to contain a runaway,
+not to ration. `SBH_CONTAINER_MEMORY=0` lifts it for debugging an artifact that
+genuinely needs more.
+"""
+from __future__ import annotations
+
+import os
+
+DEFAULT_MEMORY = "12g"
+
+
+def container_memory_limit() -> str:
+    """The configured cap, or '' when disabled."""
+    return str(os.environ.get("SBH_CONTAINER_MEMORY", DEFAULT_MEMORY) or "").strip()
+
+
+def container_memory_flags() -> list[str]:
+    """`docker run` flags capping one container's memory. Empty list = uncapped.
+
+    `--memory-swap` is set equal to `--memory` on purpose: with swap available the
+    cgroup degrades into host-wide reclaim before it kills anything, and that
+    stall is what turns one runaway into a whole-batch failure. Equal values make
+    the kernel kill the offender promptly, inside its own cgroup.
+    """
+    value = container_memory_limit()
+    if value in ("", "0", "none"):
+        return []
+    return ["--memory", value, "--memory-swap", value]
diff --git a/code/src/doc2harness/runtime/startup_driver.py b/code/src/doc2harness/runtime/startup_driver.py
new file mode 100644
index 0000000000000000000000000000000000000000..3901dee8224b93b9b9b2982742f051a5cdf60620
--- /dev/null
+++ b/code/src/doc2harness/runtime/startup_driver.py
@@ -0,0 +1,330 @@
+"""Run one ``startup`` scenario against a real artifact in Docker."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import re
+import shutil
+import subprocess
+import tempfile
+from dataclasses import asdict
+from pathlib import Path
+from typing import Any
+
+from doc2harness.runtime.direct_mock_driver import _digest
+from doc2harness.runtime.resource_limits import container_memory_flags
+
+
+_MARKER = "SBH_STARTUP_RESULT="
+_REQUIRES_PYTHON = re.compile(r"requires-python\s*=\s*[\"']([^\"']+)[\"']", re.IGNORECASE)
+
+
+def _declared_python_floor(artifact: Path) -> tuple[int, int] | None:
+    """Read the artifact's declared lower Python bound without inventing one."""
+    path = artifact / "pyproject.toml"
+    try:
+        text = path.read_text(encoding="utf-8")
+    except (OSError, UnicodeError):
+        return None
+    match = _REQUIRES_PYTHON.search(text)
+    if match is None:
+        return None
+    floors = [
+        (int(major), int(minor))
+        for major, minor in re.findall(r"(?:^|,)\s*>=\s*(\d+)\.(\d+)", match.group(1))
+    ]
+    return max(floors) if floors else None
+
+
+def _old_python_wrapper(floor: tuple[int, int], probe: Path, entered: Path) -> str:
+    """Make a PATH-first fake old python3 that records both probe and entry."""
+    major, minor = floor
+    fake = (major, minor - 1) if minor > 0 else (max(0, major - 1), 99)
+    return (
+        "#!/usr/bin/env bash\n"
+        "set -eu\n"
+        "args=(\"$@\")\n"
+        "i=0\n"
+        "while (( i < ${#args[@]} )); do\n"
+        "  arg=\"${args[$i]}\"\n"
+        "  case \"$arg\" in\n"
+        "    -E|-I|-s|-S|-B|-u|-O|-OO) ((i += 1)); continue ;;\n"
+        "    -V|--version)\n"
+        f"      printf 'version\\n' >> {str(probe)!r}\n"
+        f"      printf 'Python {fake[0]}.{fake[1]}\\n'\n"
+        "      exit 0\n"
+        "      ;;\n"
+        "    -c)\n"
+        "      code=\"${args[$((i + 1))]:-}\"\n"
+        "      if [[ \"$code\" == *version* || \"$code\" == *VERSION* || \"$code\" == *hexversion* ]]; then\n"
+        f"        printf 'version\\n' >> {str(probe)!r}\n"
+        f"        printf '{fake[0]}.{fake[1]}\\n'\n"
+        "        exit 0\n"
+        "      fi\n"
+        "      exit 88\n"
+        "      ;;\n"
+        "    --) ((i += 1)); break ;;\n"
+        "    -*) exit 88 ;;\n"
+        "    *) break ;;\n"
+        "  esac\n"
+        "done\n"
+        "if (( i < ${#args[@]} )); then\n"
+        "  case \"${args[$i]}\" in\n"
+        "    *.py|*/entry.py)\n"
+        f"      printf 'entry\\n' >> {str(entered)!r}\n"
+        "      exit 86\n"
+        "      ;;\n"
+        "  esac\n"
+        "fi\n"
+        "exit 88\n"
+    )
+
+
+def _probe_source() -> str:
+    return r'''
+import importlib, json, os, sys, traceback
+sys.path.insert(0, "/sbh-artifact/src")
+sys.path.insert(0, "/sbh-artifact")
+module = None
+import_error = False
+for name in ("yuyao.agent_api", "yuyao.d2a_api", "yuyao.harness_api", "agent_api"):
+    try:
+        candidate = importlib.import_module(name)
+    except ModuleNotFoundError as exc:
+        if getattr(exc, "name", None) in {name, name.split(".")[0]}:
+            continue
+        import_error = True
+        traceback.print_exc()
+        continue
+    except Exception:
+        import_error = True
+        traceback.print_exc()
+        continue
+    if callable(getattr(candidate, "create_session", None)):
+        module = candidate
+        break
+result = {"std": module is not None, "ok": False, "tb": False, "import_tb": import_error}
+if module is not None:
+    try:
+        session = module.create_session()
+        result["ok"] = True
+        close = getattr(session, "close", None)
+        if callable(close):
+            close()
+    except Exception:
+        result["tb"] = True
+        traceback.print_exc()
+print("SBH_STARTUP_RESULT=" + json.dumps(result, sort_keys=True), flush=True)
+'''
+
+
+def _docker_probe(artifact: Path, home: Path, workspace: Path, env: dict[str, str], timeout: int, argv: list[str]) -> tuple[subprocess.CompletedProcess[str], bool]:
+    image = os.environ.get("SBH_EVALUATION_IMAGE", "doc2harness/evaluation:candidate")
+    command = [
+        "docker", "run", *container_memory_flags(), "--rm", "--init", "--network", "none", "--read-only",
+        "--tmpfs", "/tmp:rw,noexec,nosuid,size=256m", "--user", f"{os.getuid()}:{os.getgid()}",
+        "-v", f"{artifact}:/sbh-artifact:ro", "-v", f"{home}:/sbh-home:rw",
+        "-v", f"{workspace}:/sbh-workspace:rw", "-e", "HOME=/sbh-home",
+        # Construct in the writable workspace, exactly as every other driver
+        # does.  Without ``-w`` the container starts in the read-only artifact
+        # mount, so ``create_session()`` (whose cwd defaults to os.getcwd())
+        # tries to initialise a per-cwd memory store under /sbh-artifact and
+        # dies with a read-only-filesystem OSError at construction.  The
+        # tolerant-startup points then read a "bare constructor traceback" that
+        # is the mount's fault, not the product's.
+        "-w", "/sbh-workspace",
+        "-e", "YUYAO_HOME=/sbh-home/.yuyao", "-e", "PYTHONDONTWRITEBYTECODE=1",
+        "-e", "PYTHONPATH=/sbh-artifact/src",
+    ]
+    for key, value in env.items():
+        if key.startswith("D2A_"):
+            command.extend(("-e", f"{key}={value}"))
+    startup_path = env.get("D2A_STARTUP_PATH")
+    if startup_path:
+        command.extend(("-e", f"PATH={startup_path}:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"))
+    command.extend((image, *argv))
+    try:
+        return subprocess.run(command, cwd=workspace, capture_output=True, text=True,
+                              stdin=subprocess.DEVNULL, timeout=timeout, check=False), False
+    except subprocess.TimeoutExpired as exc:
+        return subprocess.CompletedProcess(command, -1, exc.stdout or "", exc.stderr or ""), True
+
+
+def _run_one() -> dict[str, Any]:
+    from doc2harness.benchmark.definition import definition_digest
+    from doc2harness.benchmark.dispatch import load_scenario_owner
+    from doc2harness.benchmark.harnesses.startup.adapter import build_startup_execution_plan
+    from doc2harness.benchmark.harnesses.startup.contracts import StartupObservation, StartupProfile
+
+    scenario_id = os.environ["SBH_SCENARIO_ID"]
+    owner = load_scenario_owner(scenario_id)
+    if ".benchmark.harnesses.startup." not in owner.module:
+        raise RuntimeError("startup driver received a non-startup scenario")
+    scenario = owner.scenario
+    plan = build_startup_execution_plan(scenario)
+    artifact = Path(os.environ["SBH_ARTIFACT_PATH"])
+    recipe = scenario.recipe
+    with tempfile.TemporaryDirectory(prefix="sbh-startup-production-") as temporary:
+        root = Path(temporary)
+        home, workspace = root / "home", root / "workspace"
+        home.mkdir(); workspace.mkdir()
+        if recipe.config_text is not None:
+            config = home / ".yuyao" / "config.json"
+            config.parent.mkdir(parents=True, exist_ok=True)
+            config.write_text(recipe.config_text, encoding="utf-8")
+        for relative, content in recipe.home_files:
+            path = home / relative
+            path.parent.mkdir(parents=True, exist_ok=True)
+            path.write_text(content, encoding="utf-8")
+        env = dict(os.environ)
+        env.update(dict(recipe.environment))
+        result: dict[str, Any] = {"std": False, "ok": False, "tb": False, "import_tb": False}
+        timed_out = False
+        exact_entry = False
+        path_selected = False
+        if recipe.profile is StartupProfile.CLEAN_CONSTRUCT:
+            completed, timed_out = _docker_probe(
+                artifact, home, workspace, env, min(recipe.timeout_seconds, 300),
+                ["python3", "-c", _probe_source()],
+            )
+            for line in str(completed.stdout or "").splitlines():
+                if line.startswith(_MARKER):
+                    try:
+                        parsed = json.loads(line[len(_MARKER):])
+                    except (TypeError, ValueError, json.JSONDecodeError):
+                        parsed = {}
+                    if isinstance(parsed, dict):
+                        result.update(parsed)
+            request_count = 0
+            launcher_available = False
+            fixture_verified = True
+            declared_floor = None
+            old_python_probed = False
+            old_python_entered = False
+            healthy_version_satisfies = False
+        else:
+            # A successful --help invocation proves only that a launcher exists.
+            # It does not prove exact sibling selection, PATH fallback, or
+            # ambient-environment isolation, so those facts remain unobserved.
+            fixture = root / "launcher-artifact"
+            shutil.copytree(artifact, fixture, symlinks=True)
+            marker = workspace / "launcher-marker.json"
+            entry = fixture / "entry.py"
+            if entry.exists() or entry.is_symlink():
+                entry.unlink()
+            entry.write_text(
+                "import json,sys\n"
+                "json.dump({'argv': sys.argv[1:], 'entry': __file__, 'python': list(sys.version_info[:2])}, open('/sbh-workspace/launcher-marker.json','w'))\n"
+                "raise SystemExit(73)\n",
+                encoding="utf-8",
+            )
+            entry.chmod(0o700)
+            task = workspace / "task.json"
+            budget = workspace / "budget.json"
+            task.write_text('{"task_id":"startup-driver","problem_statement":"controlled"}\n', encoding="utf-8")
+            budget.write_text('{"max_steps":1}\n', encoding="utf-8")
+            expected = [
+                "--task-file", "/sbh-workspace/task.json",
+                "--repo-dir", "/sbh-workspace",
+                "--model-base-url", "http://127.0.0.1:9",
+                "--model-name", "startup-driver-model",
+                "--model-api-key", "startup-driver-key",
+                "--budget-file", "/sbh-workspace/budget.json",
+                "--out-dir", "/sbh-workspace/out",
+            ]
+            (workspace / "out").mkdir()
+            declared_floor = _declared_python_floor(artifact)
+            old_probe = workspace / "old-python-probe.log"
+            old_entry = workspace / "old-python-entry.log"
+            if recipe.profile is StartupProfile.PYTHON_MINIMUM and declared_floor is not None:
+                startup_bin = fixture / "sbh-startup-bin"
+                startup_bin.mkdir(parents=True, exist_ok=True)
+                old_python = startup_bin / "python3"
+                old_python.write_text(
+                    _old_python_wrapper(
+                        declared_floor,
+                        Path("/sbh-workspace/old-python-probe.log"),
+                        Path("/sbh-workspace/old-python-entry.log"),
+                    ),
+                    encoding="utf-8",
+                )
+                old_python.chmod(0o700)
+                env["D2A_STARTUP_PATH"] = "/sbh-artifact/sbh-startup-bin"
+            completed, timed_out = _docker_probe(
+                fixture, home, workspace, env, min(recipe.timeout_seconds, 120),
+                ["bash", "/sbh-artifact/run_agent.sh", *expected],
+            )
+            marker_value: dict[str, Any] = {}
+            try:
+                marker_value = json.loads(marker.read_text(encoding="utf-8"))
+            except (OSError, UnicodeError, json.JSONDecodeError):
+                marker_value = {}
+            request_count = None
+            old_python_probed = old_probe.is_file() and bool(old_probe.read_text(encoding="utf-8").strip())
+            old_python_entered = old_entry.is_file() and bool(old_entry.read_text(encoding="utf-8").strip())
+            launcher_available = (
+                bool(marker_value) and completed.returncode == 73
+            ) or old_python_probed or old_python_entered
+            fixture_verified = launcher_available
+            exact_entry = marker_value.get("entry") == "/sbh-artifact/entry.py"
+            path_selected = exact_entry and marker_value.get("argv") == expected
+            healthy_version = marker_value.get("python")
+            healthy_version_satisfies = bool(
+                declared_floor is not None
+                and isinstance(healthy_version, list)
+                and len(healthy_version) == 2
+                and all(type(item) is int for item in healthy_version)
+                and tuple(healthy_version) >= tuple(declared_floor)
+            )
+        observation = StartupObservation(
+            scenario_id=scenario_id,
+            plan_digest=plan.plan_digest,
+            artifact_id=os.environ["SBH_ARTIFACT_ID"],
+            artifact_digest=os.environ["SBH_ARTIFACT_DIGEST"],
+            backend_evidence_digest=_digest({"scenario_id": scenario_id, "rc": completed.returncode, "stdout": completed.stdout, "stderr": completed.stderr}),
+            result_present=bool(result) and not timed_out,
+            import_traceback=bool(result.get("import_tb")),
+            standard_interface=bool(result.get("std")),
+            constructed=bool(result.get("ok")),
+            constructor_traceback=bool(result.get("tb")),
+            request_count=request_count,
+            launcher_available=launcher_available,
+            fixture_verified=fixture_verified,
+            exact_entry=exact_entry,
+            path_selected=path_selected,
+            wrong_entry=False,
+            declared_floor=declared_floor is not None,
+            old_python_probed=old_python_probed,
+            old_python_entered=old_python_entered,
+            healthy_version_satisfies=healthy_version_satisfies,
+            poison_selftest=False,
+            ambient_path_isolated=False,
+            ambient_home_isolated=False,
+            process_tree_clean=not timed_out,
+            workspace_clean=True,
+        )
+    judgement = owner.judge(observation)
+    return {"observation": observation, "judgement": judgement,
+            "module": owner.module, "definition_digest": definition_digest(owner.definition)}
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.parse_args()
+    result = _run_one()
+    Path(os.environ["SBH_TYPED_EVENT_PATH"]).write_text(json.dumps({
+        "schema": "doc2harness.typed-events/1", "source_digest": os.environ["SBH_SOURCE_DIGEST"],
+        "task_digest": os.environ["SBH_TASK_DIGEST"], "budget_digest": os.environ["SBH_BUDGET_DIGEST"],
+        "artifact_digest": os.environ["SBH_ARTIFACT_DIGEST"], "artifact_id": os.environ["SBH_ARTIFACT_ID"],
+        "scenario_id": os.environ["SBH_SCENARIO_ID"], "scenario_module": result["module"],
+        "definition_digest": result["definition_digest"],
+        "events": [{"type": "startup-observation", "observation": asdict(result["observation"]),
+                    "judgement": asdict(result["judgement"])}],
+    }, ensure_ascii=False, default=lambda value: value.value if hasattr(value, "value") else str(value), indent=2) + "\n", encoding="utf-8")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/code/src/doc2harness/runtime/state_driver.py b/code/src/doc2harness/runtime/state_driver.py
new file mode 100644
index 0000000000000000000000000000000000000000..f26554f582ed45505d190a938322fcb0076abf68
--- /dev/null
+++ b/code/src/doc2harness/runtime/state_driver.py
@@ -0,0 +1,2438 @@
+"""Run one ``state`` command sequence in the artifact's interactive CLI."""
+
+from __future__ import annotations
+import argparse
+import json
+import os
+import pty
+import re
+import select
+import signal
+import subprocess
+import tempfile
+import threading
+import time
+from dataclasses import asdict
+from pathlib import Path
+from doc2harness.runtime import mock_gateway
+from doc2harness.runtime.direct_mock_driver import _digest, _trajectory
+from doc2harness.runtime.resource_limits import container_memory_flags
+
+_API_MARKER = "SBH_STATE_API_RESULT="
+
+
+def _api_probe_source() -> str:
+    """Return a small artifact-side probe for the public Agent API."""
+    return '''\
+
+import hashlib, importlib, json, os, signal, subprocess, sys, time, traceback
+from pathlib import Path
+sys.path.insert(0, "/sbh-artifact/src")
+scenario_id = os.environ.get("SBH_SCENARIO_ID", "")
+result = {
+    "std": {"std": False}, "ok": False, "tb": False, "chat": "", "cwd": "",
+    "returns": [], "messages": "", "messages_before": "", "roles": [],
+    "roles_before": [], "mcp": [], "config": {}, "structured_facts": {},
+}
+
+def _text(value):
+    return value if isinstance(value, str) else str(value)
+
+def _surface(session):
+    surface = {"std": True}
+    for name in ("chat", "dispatch", "close", "config_get"):
+        try:
+            value = getattr(session, name)
+            surface[name] = {"present": True, "type_ok": callable(value)}
+        except Exception:
+            surface[name] = {"present": False, "type_ok": False}
+    try:
+        value = getattr(session, "cwd")
+        surface["cwd"] = {"present": True, "type_ok": isinstance(value, str)}
+    except Exception:
+        surface["cwd"] = {"present": False, "type_ok": False}
+    try:
+        value = getattr(session, "messages")
+        surface["messages"] = {
+            "present": True, "type_ok": isinstance(value, list)
+            and all(isinstance(item, dict) for item in value),
+        }
+    except Exception:
+        surface["messages"] = {"present": False, "type_ok": False}
+    try:
+        value = getattr(session, "mcp_servers")
+        surface["mcp_servers"] = {
+            "present": True, "type_ok": isinstance(value, list)
+            and all(isinstance(item, str) for item in value),
+        }
+    except Exception:
+        surface["mcp_servers"] = {"present": False, "type_ok": False}
+    try:
+        value = session.config_get("SBH_UNSET_CONFIGURATION_KEY_7731")
+        surface["config_get"]["unset_returns"] = "None" if value is None else _text(value)
+        surface["config_get"]["present_roundtrip"] = True
+    except Exception:
+        surface["config_get"]["unset_returns"] = "<raised>"
+        surface["config_get"]["present_roundtrip"] = False
+    return surface
+
+def _snapshot_messages(session):
+    messages = list(getattr(session, "messages", []) or [])
+    roles = [[item.get("role")] for item in messages if isinstance(item, dict)]
+    return json.dumps(messages, sort_keys=True), roles
+
+def _call_public(session, name, *args):
+    try:
+        value = getattr(session, name)(*args)
+        return {
+            "ok": True,
+            "return_type": type(value).__name__,
+            "return_is_str": isinstance(value, str),
+            "return": value[:8192] if isinstance(value, str) else repr(value)[:8192],
+            "error": "",
+        }
+    except BaseException as exc:
+        return {
+            "ok": False,
+            "return_type": "",
+            "return_is_str": False,
+            "return": "",
+            "error": type(exc).__name__ + ": " + str(exc)[:300],
+        }
+
+def _alive(real_kill, pid):
+    if not pid:
+        return False
+    try:
+        real_kill(int(pid), 0)
+    except ProcessLookupError:
+        return False
+    except PermissionError:
+        return True
+    return True
+
+def _read_int(path):
+    try:
+        return int(path.read_text(encoding="ascii").strip())
+    except (OSError, ValueError):
+        return None
+
+def _fd_links(pid):
+    links = {}
+    try:
+        entries = list((Path("/proc") / str(pid) / "fd").iterdir())
+    except OSError:
+        return links
+    for entry in entries:
+        try:
+            links[entry.name] = os.readlink(entry)
+        except OSError:
+            pass
+    return links
+
+def _wait_for(path, seconds=8.0):
+    deadline = time.monotonic() + seconds
+    while time.monotonic() < deadline:
+        if path.exists():
+            return True
+        time.sleep(0.02)
+    return path.exists()
+
+def _snapshot_file(path):
+    """Capture a memory file byte-exactly for before/after comparison."""
+    try:
+        data = path.read_bytes()
+    except FileNotFoundError:
+        return {"present": False, "text": None, "sha256": None, "length": 0}
+    return {
+        "present": True,
+        "text": data.decode("utf-8", "replace"),
+        "sha256": hashlib.sha256(data).hexdigest(),
+        "length": len(data),
+    }
+
+def _public_call_facts(session, name, value):
+    """Invoke a public method and record only its declared return shape."""
+    method = getattr(session, name, None)
+    if not callable(method):
+        raise RuntimeError("PUBLIC_METHOD_MISSING_" + name.upper())
+    returned = method(value)
+    return {
+        "return_type": type(returned).__name__,
+        "return_is_str": isinstance(returned, str),
+        "return_length": len(returned) if isinstance(returned, str) else None,
+    }
+
+def _child_directory_probe(create_session, variants, roots):
+    """Observe whether a forked child inherits the parent's granted directory.
+
+    Each declared variant runs in its own session.  The parent optionally grants
+    an extra directory via ``/add-dir``, then either reads the three-file probe
+    itself (``actor == "parent"``) or delegates to a child via ``/fork``.  The
+    read results travel over the model wire, so the facts are recovered
+    host-side from the recorded gateway requests; this probe only reports which
+    session actions were driven and whether they returned text.
+
+    ``/fork`` dispatches and returns immediately, so the probe waits for the
+    child's own three tool results to reach the gateway ledger rather than
+    sleeping a fixed interval.  The wait is bounded and reported.
+    """
+    rows = {}
+    repo = Path(roots["repo"])
+    extra = Path(roots["extra"])
+    unauthorized = Path(roots["unauthorized"])
+    for index, variant in enumerate(variants):
+        label = str(variant.get("label") or index)
+        for path in (repo, extra, unauthorized):
+            path.mkdir(parents=True, exist_ok=True)
+        (repo / "main.txt").write_text(variant["main_token"] + "\\n", encoding="utf-8")
+        (extra / "extra.txt").write_text(variant["extra_token"] + "\\n", encoding="utf-8")
+        (unauthorized / "outside.txt").write_text(
+            variant["unauthorized_token"] + "\\n", encoding="utf-8"
+        )
+        session = create_session(mode="yolo", role="execute", cwd=str(repo))
+        calls = []
+        try:
+            if variant.get("add_dir"):
+                calls.append(_public_call_facts(session, "dispatch", "/add-dir " + str(extra)))
+            prompt = variant["prompt"]
+            if variant.get("actor") == "parent":
+                calls.append(_public_call_facts(session, "chat", prompt))
+            else:
+                calls.append(_public_call_facts(session, "dispatch", "/fork " + prompt))
+                # Bounded settle: the fork is fire-and-forget, so give the child
+                # time to drive its reads without pinning a fixed wall-clock nap.
+                deadline = time.monotonic() + float(variant.get("settle_s") or 2.0) * 4
+                while time.monotonic() < deadline:
+                    time.sleep(0.05)
+        finally:
+            close = getattr(session, "close", None)
+            if callable(close):
+                try:
+                    close()
+                except Exception:
+                    pass
+        rows[label] = {
+            "state": "ok", "shape": variant.get("shape"),
+            "actor": variant.get("actor"), "prompt": variant["prompt"],
+            "add_dir": bool(variant.get("add_dir")), "calls": calls,
+        }
+    return rows
+
+def _clipboard_copy_probe(create_session, variants):
+    """Observe the exact bytes ``/copy`` hands to the clipboard helper.
+
+    A fake ``pbcopy`` is injected as the only clipboard binary on PATH; it
+    records its stdin verbatim so the observer compares bytes rather than a
+    decoded string.  The interpreter is forced to a non-UTF-8 C locale first:
+    the defect under test is a copy path that encodes using the ambient locale
+    instead of UTF-8, which only shows up when the two disagree.
+    """
+    import locale
+
+    rows = {}
+    root = Path("/sbh-workspace")
+    for index, variant in enumerate(variants):
+        label = str(variant.get("label") or index)
+        repo = root / ("clipboard_%d" % index)
+        fake_bin = root / ("clipboard_bin_%d" % index)
+        repo.mkdir(parents=True, exist_ok=True)
+        fake_bin.mkdir(parents=True, exist_ok=True)
+        capture = root / variant["capture"]
+        meta = root / variant["meta"]
+        helper = fake_bin / "pbcopy"
+        helper.write_text(
+            "#!" + sys.executable + "\\n"
+            "import json, os, sys\\n"
+            "data = sys.stdin.buffer.read()\\n"
+            "open(os.environ['SBH_CLIPBOARD_CAPTURE'], 'wb').write(data)\\n"
+            "open(os.environ['SBH_CLIPBOARD_META'], 'w', encoding='ascii').write("
+            "json.dumps({'argv': sys.argv, 'bytes': len(data)}))\\n",
+            encoding="utf-8",
+        )
+        helper.chmod(0o700)
+        os.environ["PATH"] = str(fake_bin) + os.pathsep + os.environ.get("PATH", "")
+        os.environ["SBH_CLIPBOARD_CAPTURE"] = str(capture)
+        os.environ["SBH_CLIPBOARD_META"] = str(meta)
+        try:
+            locale.setlocale(locale.LC_ALL, "C")
+        except locale.Error:
+            pass
+        session = create_session(mode="yolo", role="execute", cwd=str(repo))
+        chat = _call_public(session, "chat", variant["prompt"])
+        copied = _call_public(session, "dispatch", "/copy")
+        closed = _call_public(session, "close")
+        raw = capture.read_bytes() if capture.exists() else None
+        try:
+            helper_meta = json.loads(meta.read_text(encoding="ascii"))
+        except (OSError, ValueError):
+            helper_meta = None
+        rows[label] = {
+            "state": "ok",
+            "locale": {
+                "preferred": locale.getpreferredencoding(False),
+                "filesystem": sys.getfilesystemencoding(),
+                "utf8_mode": int(sys.flags.utf8_mode),
+                "lc_all": os.environ.get("LC_ALL", ""),
+                "lang": os.environ.get("LANG", ""),
+            },
+            "chat": chat, "dispatch": copied, "close": closed,
+            "capture_present": raw is not None,
+            "capture_hex": raw.hex() if raw is not None else None,
+            "capture_length": len(raw) if raw is not None else None,
+            "helper_meta": helper_meta,
+        }
+    return rows
+
+
+def _memory_residency_probe(create_session, variants):
+    """Measure how much memory a fixed top-k query keeps resident.
+
+    Each variant seeds the same three ranked markers plus a decoy archive whose
+    size differs by an order of magnitude.  A bounded top-k implementation
+    should keep resident memory flat as the archive grows; loading the whole
+    archive shows up as an RSS delta that scales with the entry count.
+
+    Every variant runs in its own subprocess.  RSS is a whole-process figure, so
+    a shared process would carry the previous variant's high-water mark into the
+    next baseline and, worse, leave the sampler self-check unable to observe its
+    own allocation once the heap is already large - the check would then read as
+    "RSS is unobservable here" rather than as a real measurement.
+    """
+    rows = {}
+    root = Path("/sbh-workspace")
+    base_url = os.environ.get("D2A_MODEL_BASE_URL", "")
+
+    def request_count():
+        """Read the gateway's request count so each variant can be sliced out.
+
+        Both variants send the same probe token, so the token alone cannot say
+        which variant a request belongs to; the ledger boundary can.
+        """
+        try:
+            import urllib.request
+            root_url = base_url.rsplit("/v1", 1)[0]
+            with urllib.request.urlopen(root_url + "/__d2a_seen?token=x", timeout=5) as response:
+                return int(json.loads(response.read()).get("requests") or 0)
+        except Exception:
+            return None
+
+    for index, variant in enumerate(variants):
+        label = str(variant.get("label") or index)
+        before = request_count()
+        repo = root / ("memory_residency_%d" % index)
+        (repo / "memory").mkdir(parents=True, exist_ok=True)
+        markers = list(variant["markers"])
+        (repo / "MEMORY.md").write_text(
+            "# Memory\\n"
+            "- " + markers[0] + " zirconium quasar heliotrope zirconium quasar heliotrope\\n"
+            "- " + markers[1] + " zirconium quasar\\n"
+            "- " + markers[2] + " zirconium\\n"
+            "- " + variant["warm_query"] + " warm-up control\\n",
+            encoding="utf-8",
+        )
+        with (repo / "memory" / "archive-2000-01-01.md").open("w", encoding="utf-8") as handle:
+            handle.write("# Archived memory\\n")
+            for entry in range(int(variant["entries"])):
+                handle.write(
+                    "- " + variant["decoy"] + ("%06d" % entry)
+                    + " ordinary deployment preference number " + str(entry) + "\\n"
+                )
+        completed = subprocess.run(
+            [sys.executable, "-c", os.environ["SBH_RESIDENCY_WORKER_SOURCE"],
+             json.dumps({"repo": str(repo), "variant": variant})],
+            capture_output=True, text=True, check=False, timeout=300,
+        )
+        parsed = None
+        for line in (completed.stdout or "").splitlines():
+            if line.startswith("SBH_RESIDENCY_ROW="):
+                try:
+                    parsed = json.loads(line[len("SBH_RESIDENCY_ROW="):])
+                except ValueError:
+                    parsed = None
+        rows[label] = parsed if isinstance(parsed, dict) else {
+            "state": "error", "entries": int(variant["entries"]),
+            "stderr_tail": (completed.stderr or "")[-400:],
+        }
+        rows[label]["request_span"] = [before, request_count()]
+    return rows
+
+def _close_retry_probe(create_session, scenario_id):
+    """Drive the public close lifecycle and return structured local facts."""
+    root = Path("/sbh-workspace")
+    repo = root / "repo"
+    repo.mkdir(parents=True, exist_ok=True)
+    pid_path = root / "close_helper.pid"
+    state_path = root / "close_helper.state"
+    heartbeat_path = root / "close_helper.heartbeat"
+    lease_path = root / "close_helper.lease"
+    helper = repo / "close_helper.py"
+    helper.write_text(
+        "from pathlib import Path\\n"
+        "import os, signal, time\\n"
+        "pid = Path(os.environ['D2A_CLOSE_PID'])\\n"
+        "state = Path(os.environ['D2A_CLOSE_STATE'])\\n"
+        "heartbeat = Path(os.environ['D2A_CLOSE_HEARTBEAT'])\\n"
+        "lease = open(os.environ['D2A_CLOSE_LEASE'], 'w', encoding='ascii')\\n"
+        "lease.write('OWNED\\\\n'); lease.flush()\\n"
+        "pid.write_text(str(os.getpid()), encoding='ascii')\\n"
+        "state.write_text('START\\\\n', encoding='ascii')\\n"
+        "def finish(signum, frame):\\n"
+        "    with state.open('a', encoding='ascii') as fh:\\n"
+        "        fh.write('SIGNAL:' + str(signum) + '\\\\n')\\n"
+        "    raise SystemExit(0)\\n"
+        "signal.signal(signal.SIGTERM, finish)\\n"
+        "signal.signal(signal.SIGINT, finish)\\n"
+        "counter = 0\\n"
+        "print('CLOSE_HELPER_READY', flush=True)\\n"
+        "while True:\\n"
+        "    counter += 1\\n"
+        "    heartbeat.write_text(str(counter), encoding='ascii')\\n"
+        "    time.sleep(0.02)\\n",
+        encoding="utf-8",
+    )
+    os.environ["D2A_CLOSE_PID"] = str(pid_path)
+    os.environ["D2A_CLOSE_STATE"] = str(state_path)
+    os.environ["D2A_CLOSE_HEARTBEAT"] = str(heartbeat_path)
+    os.environ["D2A_CLOSE_LEASE"] = str(lease_path)
+    target = scenario_id == "agent_api_close_retry_incomplete"
+    session = create_session(mode="yolo", role="execute", cwd=str(repo))
+    route = _call_public(session, "chat", "CLOSE_ROUTE_6501")
+    if not _wait_for(pid_path):
+        try:
+            session.close()
+        except BaseException:
+            pass
+        return {"ok": True, "std": {"std": False}, "structured_facts": {
+            scenario_id: {"observed": False, "supported": False, "checks": ()}
+        }, "close_route": route, "ctor": {"built": True, "cwd": str(repo)}}
+    pid = _read_int(pid_path)
+    real_kill = os.kill
+    real_killpg = os.killpg
+    real_getpgid = os.getpgid
+    real_terminate = subprocess.Popen.terminate
+    real_proc_kill = subprocess.Popen.kill
+    real_wait = subprocess.Popen.wait
+    try:
+        target_pgid = real_getpgid(int(pid)) if pid else None
+    except (OSError, TypeError, ValueError):
+        target_pgid = None
+    phase = {"name": "setup"}
+    signal_ops = []
+
+    def belongs(candidate_pid):
+        try:
+            return target_pgid is not None and real_getpgid(int(candidate_pid)) == target_pgid
+        except (OSError, TypeError, ValueError):
+            return int(candidate_pid or -1) == int(pid or -2)
+
+    def faulted():
+        return target and phase["name"] == "first"
+
+    def note(op, target_pid, sig=None, will_fault=False):
+        signal_ops.append({
+            "phase": phase["name"], "op": op, "target": int(target_pid),
+            "signal": int(sig) if sig is not None else None, "faulted": bool(will_fault),
+        })
+
+    def patched_killpg(pgid, sig):
+        hit = target_pgid is not None and int(pgid) == int(target_pgid)
+        reject = hit and faulted() and int(sig) != 0
+        if hit:
+            note("os.killpg", pgid, sig, reject)
+        if reject:
+            raise OSError("TRANSIENT_KILLPG")
+        return real_killpg(pgid, sig)
+
+    def patched_kill(candidate_pid, sig):
+        hit = belongs(candidate_pid)
+        reject = hit and faulted() and int(sig) != 0
+        if hit and int(sig) != 0:
+            note("os.kill", candidate_pid, sig, reject)
+        if reject:
+            raise OSError("TRANSIENT_KILL")
+        return real_kill(candidate_pid, sig)
+
+    def patched_terminate(proc):
+        hit = belongs(proc.pid)
+        reject = hit and faulted()
+        if hit:
+            note("Popen.terminate", proc.pid, signal.SIGTERM, reject)
+        if reject:
+            raise OSError("TRANSIENT_TERMINATE")
+        return real_terminate(proc)
+
+    def patched_proc_kill(proc):
+        hit = belongs(proc.pid)
+        reject = hit and faulted()
+        if hit:
+            note("Popen.kill", proc.pid, signal.SIGKILL, reject)
+        if reject:
+            raise OSError("TRANSIENT_PROC_KILL")
+        return real_proc_kill(proc)
+
+    def patched_wait(proc, timeout=None):
+        hit = belongs(proc.pid)
+        reject = hit and faulted()
+        if hit:
+            note("Popen.wait", proc.pid, None, reject)
+        if reject:
+            raise subprocess.TimeoutExpired("TRANSIENT_WAIT", timeout or 0)
+        return real_wait(proc, timeout=timeout)
+
+    def snapshot(label):
+        child = _fd_links(pid)
+        try:
+            state_text = state_path.read_text(encoding="ascii")
+        except OSError:
+            state_text = ""
+        lease_fds = {fd: link for fd, link in child.items() if link == str(lease_path)}
+        return {
+            "label": label, "pid_alive": _alive(real_kill, pid),
+            "lease_fd_count": len(lease_fds), "lease_fds": lease_fds,
+            "heartbeat": _read_int(heartbeat_path), "helper_state": state_text,
+        }
+
+    os.killpg = patched_killpg
+    os.kill = patched_kill
+    subprocess.Popen.terminate = patched_terminate
+    subprocess.Popen.kill = patched_proc_kill
+    subprocess.Popen.wait = patched_wait
+    try:
+        time.sleep(0.08)
+        before = snapshot("before")
+        phase["name"] = "first"
+        first_close = _call_public(session, "close")
+        phase["name"] = "observe-first"
+        after_first_a = snapshot("after-first-a")
+        time.sleep(0.16)
+        after_first_b = snapshot("after-first-b")
+        phase["name"] = "second"
+        second_close = _call_public(session, "close")
+        phase["name"] = "observe-second"
+        time.sleep(0.12)
+        after_second_a = snapshot("after-second-a")
+        time.sleep(0.16)
+        after_second_b = snapshot("after-second-b")
+        phase["name"] = "third"
+        ops_before_third = len(signal_ops)
+        third_close = _call_public(session, "close")
+        phase["name"] = "observe-third"
+        time.sleep(0.08)
+        after_third = snapshot("after-third")
+        third_signal_ops = len(signal_ops) - ops_before_third
+    finally:
+        os.killpg = real_killpg
+        os.kill = real_kill
+        subprocess.Popen.terminate = real_terminate
+        subprocess.Popen.kill = real_proc_kill
+        subprocess.Popen.wait = real_wait
+        try:
+            session.close()
+        except BaseException:
+            pass
+        if _alive(real_kill, pid):
+            try:
+                if target_pgid is not None:
+                    real_killpg(target_pgid, signal.SIGKILL)
+                else:
+                    real_kill(pid, signal.SIGKILL)
+            except OSError:
+                pass
+    base = {
+        "public_chat": route.get("return_is_str") is True,
+        "pid_started": before.get("pid_alive") is True,
+        "fd_observed": int(before.get("lease_fd_count") or 0) == 1,
+        "state_started": "START" in str(before.get("helper_state") or ""),
+        "heartbeat_started": isinstance(before.get("heartbeat"), int),
+    }
+    first_ops = [row for row in signal_ops if row.get("phase") == "first"]
+    second_ops = [row for row in signal_ops if row.get("phase") == "second"]
+    if target:
+        checks = {
+            **base,
+            "fault_delivered": bool(first_ops) and any(row.get("faulted") is True for row in first_ops),
+            "first_pid_incomplete": after_first_a.get("pid_alive") is True and after_first_b.get("pid_alive") is True,
+            "first_state_live": isinstance(after_first_a.get("heartbeat"), int) and isinstance(after_first_b.get("heartbeat"), int) and after_first_b["heartbeat"] > after_first_a["heartbeat"],
+            "retry_attempted": bool(second_ops),
+            "retry_pid_complete": after_second_a.get("pid_alive") is False and after_second_b.get("pid_alive") is False,
+            "retry_fd_complete": int(after_second_b.get("lease_fd_count") or 0) == 0,
+            "retry_state_quiescent": after_second_a.get("heartbeat") == after_second_b.get("heartbeat"),
+            "third_idempotent": after_third.get("pid_alive") is False and int(after_third.get("lease_fd_count") or 0) == 0 and third_signal_ops == 0,
+        }
+    else:
+        checks = {
+            **base,
+            "cleanup_attempted": bool(first_ops),
+            "pid_closed": after_first_b.get("pid_alive") is False,
+            "fd_closed": int(after_first_b.get("lease_fd_count") or 0) == 0,
+            "heartbeat_stopped": after_first_b.get("heartbeat") == after_second_b.get("heartbeat"),
+            "repeat_absorbed": not [row for row in signal_ops if row.get("phase") in {"second", "third"}],
+            "close_returns": all(item.get("ok") is True for item in (first_close, second_close, third_close)),
+        }
+    row = {"observed": True, "supported": True, "checks": tuple(bool(item) for item in checks.values())}
+    return {
+        "ok": True, "std": {"std": True}, "structured_facts": {scenario_id: row},
+        "close_route": route, "close_checks": checks,
+        "ctor": {"built": True, "raised": "", "cwd": str(repo)},
+    }
+
+try:
+    module = importlib.import_module("yuyao.agent_api")
+    create_session = getattr(module, "create_session", None)
+    if not callable(create_session):
+        raise RuntimeError("create_session is unavailable")
+    if scenario_id in {"agent_api_close_retry_incomplete_control", "agent_api_close_retry_incomplete"}:
+        result.update(_close_retry_probe(create_session, scenario_id))
+        print("SBH_STATE_API_RESULT=" + json.dumps(result, sort_keys=True), flush=True)
+        raise SystemExit(0)
+    elif scenario_id in {"child_add_dir_inheritance", "child_add_dir_inheritance_control"}:
+        # Directory grants and the fork are driven here; the read results are
+        # recovered host-side from the gateway ledger because they travel over
+        # the model wire, not through the filesystem.
+        plan = json.loads(os.environ.get("SBH_CHILD_DIRECTORY_PLAN", "{}"))
+        result["child_directory_rows"] = _child_directory_probe(
+            create_session, plan.get("variants") or (), plan.get("roots") or {}
+        )
+        result["ok"] = True
+        result["std"] = {"std": True}
+        print("SBH_STATE_API_RESULT=" + json.dumps(result, sort_keys=True), flush=True)
+        raise SystemExit(0)
+    elif scenario_id in {"copy_utf8_clipboard_bytes", "copy_utf8_clipboard_control"}:
+        plan = json.loads(os.environ.get("SBH_CLIPBOARD_PLAN", "{}"))
+        result["clipboard_rows"] = _clipboard_copy_probe(
+            create_session, plan.get("variants") or ()
+        )
+        result["ok"] = True
+        result["std"] = {"std": True}
+        print("SBH_STATE_API_RESULT=" + json.dumps(result, sort_keys=True), flush=True)
+        raise SystemExit(0)
+    elif scenario_id in {
+        "memory_query_topk_residency", "memory_query_topk_residency_control",
+    }:
+        plan = json.loads(os.environ.get("SBH_MEMORY_RESIDENCY_PLAN", "{}"))
+        result["memory_residency_rows"] = _memory_residency_probe(
+            create_session, plan.get("variants") or ()
+        )
+        result["ok"] = True
+        result["std"] = {"std": True}
+        print("SBH_STATE_API_RESULT=" + json.dumps(result, sort_keys=True), flush=True)
+        raise SystemExit(0)
+    elif os.environ.get("SBH_HELP_PROBE"):
+        # Dispatch /help, read the commands it *claims* to support, then
+        # dispatch each one once.  The claim source is the return value and
+        # the console together: some builds print /help instead of returning
+        # it, and reading one channel scores such a build as having no /help.
+        #
+        # The colon in the pattern is command syntax, not punctuation: one
+        # build spells its command /flow:<name>, where /flow: is recognised
+        # and a bare /flow is not, so stripping it invents a failure there.
+        import io
+        import re
+        from contextlib import redirect_stdout
+        session = create_session(mode="yolo", role="execute", cwd="/sbh-workspace")
+        printed = io.StringIO()
+        with redirect_stdout(printed):
+            # _call_public truncates its return at 500 characters, which is right
+            # for a status string but not here: the claim set is the whole command
+            # table, and one build lists sixty commands.  Dispatch directly and
+            # keep the full text, or the probe silently covers only the first few
+            # and reports a clean result for a drift it never looked at.
+            try:
+                help_return = session.dispatch("/help")
+            except BaseException as exc:
+                help_return = ""
+                result["help_error"] = type(exc).__name__ + ": " + str(exc)[:200]
+        help_text = str(help_return or "") + " || " + printed.getvalue()
+        result["returns"] = [str(help_return or "")]
+        result["console"] = help_text
+        claimed = sorted(set(re.findall(r"/[a-z][a-z0-9:-]{1,}", help_text)))
+        skip = set(("/exit", "/quit", "/clear", "/reset", "/new"))
+        # Placeholders that appear in prose ("Prefixes: /command @path") are
+        # not command names; dispatching them would report a failure for a
+        # line that was only documenting syntax.
+        skip |= set(("/command", "/cmd", "/name", "/path", "/file", "/text",
+              "/prompt", "/query", "/instruction", "/condition",
+              "/level", "/args", "/arg", "/value", "/key", "/dir",
+              "/url", "/n", "/x"))
+        probe = dict()
+        sink = io.StringIO()
+        with redirect_stdout(sink):
+            for name in [item for item in claimed if item not in skip][:60]:
+                outcome = _call_public(session, "dispatch", name)
+                if outcome.get("ok") is True:
+                    probe[name] = str(outcome.get("return") or "")[:200]
+                else:
+                    probe[name] = str(outcome.get("error") or "")[:200]
+        result["help_probe"] = probe
+        result["help_claimed"] = claimed
+        result["ok"] = True
+        result["std"] = dict(std=True)
+        print("SBH_STATE_API_RESULT=" + json.dumps(result, sort_keys=True), flush=True)
+        raise SystemExit(0)
+    elif os.environ.get("SBH_SESSION_FACT_COMMANDS"):
+        # Drive the declared commands against a live session object and read the
+        # facts that only that object carries: the message list, the role
+        # sequence, and the registered MCP servers.  A terminal screen shows
+        # none of them.
+        #
+        # Declared pre-messages are appended to the session's own list rather
+        # than chatted, because the scenario states them as an existing
+        # conversation the command then operates on - chatting them would let
+        # the product append its own turns in between and would spend a model
+        # round-trip per message.  The pre-command snapshot is what lets a judge
+        # tell "the product dropped the history" apart from "this build never
+        # exposed the history", which is why the stage1 smoke layer captures it too.
+        commands = json.loads(os.environ["SBH_SESSION_FACT_COMMANDS"])
+        premsgs = json.loads(os.environ.get("SBH_SESSION_PREMSGS", "[]"))
+        session = create_session(mode="yolo", role="execute", cwd="/sbh-workspace")
+        returns = []
+        try:
+            if premsgs:
+                conversation = getattr(session, "messages", None)
+                if isinstance(conversation, list):
+                    try:
+                        conversation.extend(premsgs)
+                    except Exception:
+                        pass
+            before_text, before_roles = _snapshot_messages(session)
+            result["messages_before"], result["roles_before"] = before_text, before_roles
+            for item in commands:
+                text = str(item)
+                if text.startswith("/"):
+                    returns.append(_call_public(session, "dispatch", text))
+                else:
+                    outcome = _call_public(session, "chat", text)
+                    if outcome.get("ok") is not True:
+                        outcome = _call_public(session, "dispatch", text)
+                    returns.append(outcome)
+            after_text, after_roles = _snapshot_messages(session)
+            result["messages"], result["roles"] = after_text, after_roles
+            result["message_count"] = len(list(getattr(session, "messages", []) or []))
+            mcp_servers = getattr(session, "mcp_servers", None)
+            if isinstance(mcp_servers, (list, tuple)):
+                names = []
+                for entry in mcp_servers:
+                    if isinstance(entry, str):
+                        names.append(entry)
+                    elif isinstance(entry, dict):
+                        names.append(str(entry.get("name") or entry.get("id") or entry.get("server") or entry))
+                    else:
+                        names.append(str(getattr(entry, "name", None) or getattr(entry, "id", None) or entry))
+                result["mcp"] = names
+        finally:
+            close = getattr(session, "close", None)
+            if callable(close):
+                try:
+                    close()
+                except Exception:
+                    pass
+        result["returns"] = [str(item.get("return") or "") for item in returns]
+        result["ok"] = True
+        result["std"] = {"std": True}
+        print("SBH_STATE_API_RESULT=" + json.dumps(result, sort_keys=True), flush=True)
+        raise SystemExit(0)
+    elif os.environ.get("SBH_WIRE_RETENTION_COMMANDS"):
+        # Drive the declared commands through the public API, dispatching slash
+        # commands and chatting plain text, exactly as the stage1 smoke layer does.
+        # The interactive CLI runs a full agent loop per plain-text line, so on
+        # some artifacts the first command never terminates its turn and the
+        # later commands' requests never reach the wire.
+        commands = json.loads(os.environ["SBH_WIRE_RETENTION_COMMANDS"])
+        # A point about listing the rules in force has to start with them in
+        # force.  The stage1 smoke layer passes the declared deny set to the session
+        # factory, so a scenario that declares one must too, or the listing is
+        # correct and empty and the point reads as a product that lost them.
+        deny = json.loads(os.environ.get("SBH_SESSION_DENY", "[]"))
+        session = create_session(
+            mode="yolo", role="execute", cwd="/sbh-workspace",
+            **({"deny": [str(rule) for rule in deny]} if deny else {}),
+        )
+        returns = []
+        try:
+            for item in commands:
+                text = str(item)
+                if text.startswith("/"):
+                    returns.append(_call_public(session, "dispatch", text))
+                else:
+                    outcome = _call_public(session, "chat", text)
+                    if outcome.get("ok") is not True:
+                        # Some builds route plain text through dispatch instead.
+                        outcome = _call_public(session, "dispatch", text)
+                    returns.append(outcome)
+            # Points about cwd persistence read the live session cwd after the
+            # declared session ops; the terminal path could only scrape it from
+            # the screen, which a build that does not re-print its prompt leaves
+            # blank.  config_get is the contract read path for config-liveness
+            # points, so a value a /config set|unset left in the live session is
+            # reported the same way for every product rather than parsed out of a
+            # /config listing.  Both are captured before close, while the session
+            # still holds them.
+            result["cwd"] = _text(getattr(session, "cwd", ""))
+            config_get = getattr(session, "config_get", None)
+            if callable(config_get):
+                keys = []
+                for command in commands:
+                    parts = str(command).split()
+                    if (
+                        len(parts) >= 3 and parts[0] == "/config"
+                        and parts[1] in ("set", "unset") and parts[2] not in keys
+                    ):
+                        keys.append(parts[2])
+                if keys:
+                    observed = {}
+                    for key in keys:
+                        try:
+                            observed[key] = _text(config_get(key))
+                        except Exception:
+                            observed[key] = "<raised>"
+                    result["config"] = observed
+        finally:
+            close = getattr(session, "close", None)
+            if callable(close):
+                try:
+                    close()
+                except Exception:
+                    pass
+        result["wire_retention_returns"] = returns
+        # Judges that index ``returns`` positionally expect one entry per
+        # declared command, exactly as the stage1 smoke layer records from each
+        # dispatch call.  Console lines cannot be split back into that shape.
+        # Some points look for their sentinel in the conversation as well as in
+        # the command return - the stage1 smoke checker accepts any of return,
+        # console or session messages - so the message text is published here
+        # too rather than only on the session-fact path.
+        # The plan point reads the names written under .plans, listed from the
+        # session's working directory.
+        try:
+            result["plans"] = sorted(os.listdir(os.path.join('/sbh-workspace', '.plans')))
+        except OSError:
+            result["plans"] = None
+        after_text, after_roles = _snapshot_messages(session)
+        result["messages"], result["roles"] = after_text, after_roles
+        # A judge that indexes returns counts only the declared commands.
+        # Pre-messages are conversation state the command then operates on,
+        # and the stage1 smoke layer records one entry per dispatched command -
+        # counting them shifts every index and the judge reads the wrong
+        # command's output.
+        skip = int(os.environ.get("SBH_WIRE_PREMSG_COUNT") or 0)
+        result["returns"] = [str(item.get("return") or "") for item in returns[skip:]]
+        # A command can report its refusal by *raising* instead of returning
+        # text, and that is the stronger of the two shapes: the caller cannot
+        # mistake it for output.  Its message lives only on the call record, so
+        # publishing returns alone drops it, and a point asking "is an unknown
+        # command reported rather than swallowed" then reads an empty return
+        # from a product that said "unknown command: /x (try /help)" out loud.
+        # The stage1 smoke layer keeps exactly this channel - one ``CMD_ERR`` line per
+        # raising command - and every judge still reads that field.
+        errors = [
+            "CMD_ERR " + repr(str(command)) + ": " + str(item.get("error") or "")
+            for command, item in zip(commands[skip:], returns[skip:])
+            if item.get("ok") is not True and item.get("error")
+        ]
+        if errors:
+            result["error"] = "\\n".join(errors) + "\\n"
+        result["ok"] = True
+        result["std"] = {"std": True}
+        print("SBH_STATE_API_RESULT=" + json.dumps(result, sort_keys=True), flush=True)
+        raise SystemExit(0)
+    kwargs = {}
+    kwargs["cwd"] = "/sbh-workspace"
+    session = create_session(**kwargs)
+    result["ok"] = True
+    result["std"] = _surface(session)
+    result["cwd"] = str(getattr(session, "cwd", ""))
+    result["ctor"] = {"built": True, "raised": "", "cwd": result["cwd"]}
+    before_text, before_roles = _snapshot_messages(session)
+    result["messages_before"], result["roles_before"] = before_text, before_roles
+    if not scenario_id.startswith("agent_api_"):
+        # Preserve the original model-turn probe for ENV_MODEL_VAR scenarios.
+        result["chat"] = str(session.chat("hello there"))
+    after_text, after_roles = _snapshot_messages(session)
+    result["messages"], result["roles"] = after_text, after_roles
+    if result["chat"]:
+        result["returns"] = [result["chat"]]
+    session.close()
+except Exception:
+    result["tb"] = True
+    result["std"] = {"std": False}
+    traceback.print_exc()
+print("SBH_STATE_API_RESULT=" + json.dumps(result, sort_keys=True), flush=True)
+'''
+
+
+_MEMORY_RESIDENCY_WORKER = '''\
+
+import gc, json, os, sys, threading, time
+sys.path.insert(0, "/sbh-artifact/src")
+
+payload = json.loads(sys.argv[1])
+repo = payload["repo"]
+variant = payload["variant"]
+
+def rss_bytes():
+    try:
+        with open("/proc/self/statm", "r", encoding="ascii") as handle:
+            fields = handle.read().split()
+        return int(fields[1]) * os.sysconf("SC_PAGE_SIZE")
+    except (OSError, IndexError, ValueError):
+        return None
+
+def sampled_call(fn):
+    samples = []
+    stop = threading.Event()
+    ready = threading.Event()
+
+    def sample():
+        ready.set()
+        while not stop.is_set():
+            value = rss_bytes()
+            if value is not None:
+                samples.append(value)
+            stop.wait(0.001)
+
+    baseline = rss_bytes()
+    thread = threading.Thread(target=sample, daemon=True)
+    thread.start()
+    ready.wait(1)
+    returned = fn()
+    time.sleep(0.02)
+    stop.set()
+    thread.join(timeout=1)
+    after = rss_bytes()
+    observed = [value for value in [baseline, after, *samples] if value is not None]
+    peak = max(observed) if observed else None
+    delta = None if baseline is None or peak is None else max(0, peak - baseline)
+    return returned, {
+        "baseline": baseline, "peak": peak, "after": after,
+        "delta": delta, "samples": len(samples),
+    }
+
+def sampler_probe(size):
+    holder = []
+
+    def allocate():
+        block = bytearray(size)
+        for index in range(0, len(block), 4096):
+            block[index] = 1
+        holder.append(block)
+        time.sleep(0.04)
+        return len(block)
+
+    allocated, observed = sampled_call(allocate)
+    holder.clear()
+    gc.collect()
+    observed["allocated"] = allocated
+    return observed
+
+def call_public(session, name, *args):
+    try:
+        value = getattr(session, name)(*args)
+        return {
+            "ok": True, "return_type": type(value).__name__,
+            "return_is_str": isinstance(value, str),
+            "return": value[:8192] if isinstance(value, str) else repr(value)[:8192],
+            "error": "",
+        }
+    except BaseException as exc:
+        return {
+            "ok": False, "return_type": "", "return_is_str": False, "return": "",
+            "error": type(exc).__name__ + ": " + str(exc)[:300],
+        }
+
+row = {"state": "error", "entries": int(variant["entries"])}
+try:
+    from yuyao.agent_api import create_session
+    session = create_session(mode="yolo", role="execute", cwd=repo)
+    index_call = call_public(session, "dispatch", "/memory status")
+    gc.collect()
+    time.sleep(0.05)
+    measured, rss = sampled_call(
+        lambda: call_public(session, "chat", variant["target_prompt"])
+    )
+    # The self-check runs before close so it shares the measured heap state.
+    sampler = sampler_probe(int(variant["rss_probe_bytes"]))
+    closed = call_public(session, "close")
+    row = {
+        "state": "ok", "entries": int(variant["entries"]),
+        "index_call": index_call, "measured": measured,
+        "rss": rss, "rss_sampler_probe": sampler, "close": closed,
+    }
+except BaseException as exc:
+    row["error"] = type(exc).__name__ + ": " + str(exc)[:300]
+print("SBH_RESIDENCY_ROW=" + json.dumps(row, sort_keys=True), flush=True)
+'''
+
+
+def _calls_return_text(row: dict) -> bool:
+    calls = row.get("calls") or []
+    return bool(calls) and all((item.get("return_is_str") is True for item in calls))
+
+
+_CHILD_DIRECTORY_SCENARIOS = frozenset({"child_add_dir_inheritance", "child_add_dir_inheritance_control"})
+_CHILD_DIRECTORY_RECIPE_KEY = "api_probe_variants"
+_CHILD_DIRECTORY_ROOTS = (
+    ("repo", "__REPO__", "repo"),
+    ("extra", "__EXTRA__", "extra"),
+    ("unauthorized", "__UNAUTHORIZED__", "unauthorized"),
+)
+_CHILD_DIRECTORY_WORKSPACE = "/sbh-workspace"
+
+
+def _child_directory_roots() -> dict[str, str]:
+    """Return the absolute container path for each declared probe root."""
+    return {
+        role: f"{_CHILD_DIRECTORY_WORKSPACE}/{directory}"
+        for role, _placeholder, directory in _CHILD_DIRECTORY_ROOTS
+    }
+
+
+def _resolve_child_directory_stub(stub: object, variant_count: int = 1) -> object:
+    """Substitute the declared root placeholders and repeat the declared rounds.
+
+    The recipe declares one variant's worth of rounds because the stage1 smoke
+    layer forks a fresh process per variant and rebases the gateway's round
+    counter each time.  This driver walks the variants inside a single probe process, so
+    the round sequence is repeated once per variant instead; a single shared
+    sequence would leave the first variant to consume every round and every
+    later variant to receive ``phase-done`` on its first request.
+    """
+    roots = _child_directory_roots()
+    encoded = json.dumps(stub)
+    for role, placeholder, _directory in _CHILD_DIRECTORY_ROOTS:
+        encoded = encoded.replace(placeholder, roots[role])
+    resolved = json.loads(encoded)
+    rounds = resolved.get("rounds")
+    if isinstance(rounds, list) and variant_count > 1:
+        resolved["rounds"] = [
+            json.loads(json.dumps(entry)) for _index in range(variant_count) for entry in rounds
+        ]
+    return resolved
+
+
+def _child_directory_plan(
+    scenario_id: str, execution_parameters: tuple[tuple[str, object], ...]
+) -> dict[str, object] | None:
+    """Build the child-inheritance plan from the recipe's declared variants."""
+    if scenario_id not in _CHILD_DIRECTORY_SCENARIOS:
+        return None
+    declared = dict(execution_parameters).get(_CHILD_DIRECTORY_RECIPE_KEY)
+    if not declared:
+        return None
+    variants = [dict(_unfreeze(variant)) for variant in declared]
+    required = ("prompt", "main_token", "extra_token", "unauthorized_token")
+    if any((key not in variant for variant in variants for key in required)):
+        return None
+    return {"variants": variants, "roots": _child_directory_roots()}
+
+
+def _child_directory_hits(requests: list[dict], prompt: str, markers: dict) -> dict | None:
+    """Recover one variant's read results from the recorded gateway requests.
+
+    The child's reads reach the gateway as tool results on the request that
+    carries the variant's probe token.  The request with the most results is the
+    completed three-file round; fewer results means the round never finished.
+    """
+    candidates = [
+        request
+        for request in requests
+        if (request.get("probes") or {}).get(prompt) and isinstance(request.get("tool_result_texts"), list)
+    ]
+    if not candidates:
+        return None
+    selected = max(candidates, key=lambda request: len(request["tool_result_texts"]))
+    texts = selected.get("tool_result_texts") or []
+    blob = "\n".join((str(text) for text in texts))
+    return {
+        "result_count": len(texts),
+        "main": markers["main"] in blob,
+        "extra": markers["extra"] in blob,
+        "unauthorized": markers["unauthorized"] in blob,
+    }
+
+
+def _child_directory_checks(scenario_id: str, rows: dict, requests: list[dict]) -> dict[str, bool] | None:
+    """Derive the child-inheritance checks from the recorded wire evidence.
+
+    The control only asserts liveness: the parent's own ``/add-dir`` grant is
+    real, and a fresh child can at least read the main tree.  The negative
+    boundary - a child must not reach an ungranted sibling - belongs to the
+    target alone.
+    """
+    if scenario_id.endswith("_control"):
+        expected = {"parent-grant", "child-empty"}
+    else:
+        expected = {"child-target", "child-empty-target"}
+    if set(rows) != expected:
+        return None
+    hits = {}
+    for label in expected:
+        row = rows[label]
+        markers = {
+            "main": row.get("main_token") or "",
+            "extra": row.get("extra_token") or "",
+            "unauthorized": row.get("unauthorized_token") or "",
+        }
+        if not all(markers.values()):
+            return None
+        hits[label] = _child_directory_hits(requests, row["prompt"], markers)
+    workers = all((_calls_return_text(rows[label]) for label in expected))
+    if scenario_id.endswith("_control"):
+        parent, empty = (hits["parent-grant"], hits["child-empty"])
+        return {
+            "workers": workers,
+            "parent_route": parent is not None and parent["result_count"] >= 3,
+            "parent_add_dir_live": bool(parent and parent["main"] and parent["extra"]),
+            "empty_child_route": empty is not None and empty["result_count"] >= 3,
+            "empty_child_main_live": bool(empty and empty["main"]),
+        }
+    target, empty = (hits["child-target"], hits["child-empty-target"])
+    return {
+        "workers": workers,
+        "child_wire": target is not None and target["result_count"] >= 3,
+        "main_control": bool(target and target["main"]),
+        "inherits_extra": bool(target and target["extra"]),
+        "unauthorized_sibling_denied": bool(target and target["unauthorized"] is False),
+        "empty_child_wire": empty is not None and empty["result_count"] >= 3,
+        "empty_child_main_control": bool(empty and empty["main"]),
+        "empty_without_add_dir_closed": bool(
+            empty and empty["extra"] is False and (empty["unauthorized"] is False)
+        ),
+    }
+
+
+def _child_directory_structured_facts(
+    scenario_id: str, api_result: dict, plan: dict | None, requests: list[dict]
+) -> dict[str, object] | None:
+    """Project the child-inheritance observation into the scenario's typed facts."""
+    if plan is None:
+        return None
+    rows = api_result.get("child_directory_rows")
+    if not isinstance(rows, dict):
+        return {scenario_id: {"observed": False, "supported": False, "checks": []}}
+    by_label = {str(item.get("label")): item for item in plan["variants"]}
+    merged = {}
+    for label, row in rows.items():
+        variant = by_label.get(label, {})
+        merged[label] = {
+            **row,
+            "main_token": variant.get("main_token"),
+            "extra_token": variant.get("extra_token"),
+            "unauthorized_token": variant.get("unauthorized_token"),
+        }
+    checks = _child_directory_checks(scenario_id, merged, requests)
+    if checks is None:
+        return {scenario_id: {"observed": False, "supported": False, "checks": []}}
+    return {
+        scenario_id: {"observed": True, "supported": True, "checks": [bool(item) for item in checks.values()]}
+    }
+
+
+_CLIPBOARD_SCENARIOS = frozenset({"copy_utf8_clipboard_bytes", "copy_utf8_clipboard_control"})
+_CLIPBOARD_RECIPE_KEY = "clipboard_api_variants"
+
+
+def _clipboard_plan(
+    scenario_id: str, execution_parameters: tuple[tuple[str, object], ...]
+) -> dict[str, object] | None:
+    """Build the clipboard plan and recover each variant's expected reply.
+
+    The expected bytes are the stub's own ``reply_content``: the model returns
+    it, ``/copy`` must hand exactly those UTF-8 bytes to the helper.  Reading it
+    from the declaration keeps the driver from carrying a second copy that could
+    drift from the stimulus.
+    """
+    if scenario_id not in _CLIPBOARD_SCENARIOS:
+        return None
+    declared = dict(execution_parameters).get(_CLIPBOARD_RECIPE_KEY)
+    if not declared:
+        return None
+    variants = [dict(_unfreeze(variant)) for variant in declared]
+    for variant in variants:
+        stub = variant.get("stub")
+        reply = dict(stub).get("reply_content") if isinstance(stub, dict) else None
+        if not reply or not variant.get("capture") or (not variant.get("meta")):
+            return None
+        variant["expected_reply"] = reply
+    return {"variants": variants}
+
+
+def _clipboard_declared_stub(execution_parameters: tuple[tuple[str, object], ...]) -> dict | None:
+    """Return the gateway stub declared inside the clipboard variant.
+
+    These recipes carry their stub per variant instead of at the top level.
+    Only a single-variant shape is lifted: with several variants the rounds
+    would have to be sequenced per variant, which this contract never declares.
+    """
+    declared = dict(execution_parameters).get(_CLIPBOARD_RECIPE_KEY)
+    variants = [dict(_unfreeze(variant)) for variant in declared or ()]
+    if len(variants) != 1:
+        return None
+    stub = variants[0].get("stub")
+    return dict(stub) if isinstance(stub, dict) else None
+
+
+def _clipboard_locale_is_non_utf8(row: dict) -> bool:
+    """Report whether the non-UTF-8 C locale stimulus actually formed."""
+    reported = row.get("locale") or {}
+    preferred = str(reported.get("preferred") or "").lower()
+    return (
+        reported.get("lc_all") == "C"
+        and int(reported.get("utf8_mode") or 0) == 0
+        and ("utf" not in preferred)
+    )
+
+
+def _clipboard_checks(rows: dict, expected: str) -> dict[str, bool] | None:
+    """Compare the captured clipboard bytes against the declared reply."""
+    if len(rows) != 1:
+        return None
+    row = next(iter(rows.values()))
+    chat = row.get("chat") or {}
+    dispatch = row.get("dispatch") or {}
+    try:
+        captured = bytes.fromhex(row.get("capture_hex") or "")
+    except ValueError:
+        captured = b""
+    expected_bytes = expected.encode("utf-8")
+    return {
+        "chat_exact": chat.get("return") == expected,
+        "dispatch_public_string": dispatch.get("return_is_str") is True,
+        "helper_invoked": row.get("capture_present") is True,
+        "bytes_exact": captured == expected_bytes,
+        "length_exact": row.get("capture_length") == len(expected_bytes),
+        "single_helper": isinstance(row.get("helper_meta"), dict),
+    }
+
+
+def _clipboard_structured_facts(
+    scenario_id: str, api_result: dict, plan: dict | None
+) -> dict[str, object] | None:
+    """Project the clipboard observation into the scenario's typed facts.
+
+    The control additionally gates on the locale stimulus: if the interpreter
+    never landed in a non-UTF-8 locale, the byte comparison proves nothing and
+    the point is reported unobserved rather than passed or failed.
+    """
+    if plan is None:
+        return None
+    rows = api_result.get("clipboard_rows")
+    unobserved = {scenario_id: {"observed": False, "supported": False, "checks": []}}
+    if not isinstance(rows, dict) or not rows:
+        return unobserved
+    expected = str(plan["variants"][0].get("expected_reply") or "")
+    checks = _clipboard_checks(rows, expected)
+    if checks is None:
+        return unobserved
+    if scenario_id.endswith("_control"):
+        row = next(iter(rows.values()))
+        if not _clipboard_locale_is_non_utf8(row):
+            return unobserved
+        checks = {"c_locale": True, **checks}
+    return {
+        scenario_id: {"observed": True, "supported": True, "checks": [bool(item) for item in checks.values()]}
+    }
+
+
+_MEMORY_RESIDENCY_SCENARIOS = frozenset(
+    {"memory_query_topk_residency", "memory_query_topk_residency_control"}
+)
+_MEMORY_RESIDENCY_MARGIN_BYTES = 4 * 1024 * 1024
+
+
+def _memory_residency_plan(
+    scenario_id: str, execution_parameters: tuple[tuple[str, object], ...]
+) -> dict[str, object] | None:
+    """Build the residency plan from the declared variants."""
+    if scenario_id not in _MEMORY_RESIDENCY_SCENARIOS:
+        return None
+    declared = dict(execution_parameters).get(_CLIPBOARD_RECIPE_KEY)
+    if not declared:
+        return None
+    variants = [dict(_unfreeze(variant)) for variant in declared]
+    required = ("markers", "warm_query", "decoy", "entries", "target_prompt", "rss_probe_bytes")
+    for variant in variants:
+        if any((key not in variant for key in required)):
+            return None
+        variant["markers"] = list(variant["markers"])
+    return {"variants": variants}
+
+
+def _memory_residency_stub(execution_parameters: tuple[tuple[str, object], ...]) -> dict | None:
+    """Lift the per-variant gateway stub, repeated once per declared variant.
+
+    Like the clipboard recipes the stub lives inside the variant.  Every variant
+    declares the same stub, so the shared sequence is repeated to keep a later
+    variant from receiving ``phase-done`` on its first request.
+    """
+    declared = dict(execution_parameters).get(_CLIPBOARD_RECIPE_KEY)
+    variants = [dict(_unfreeze(variant)) for variant in declared or ()]
+    if not variants:
+        return None
+    stub = variants[0].get("stub")
+    if not isinstance(stub, dict):
+        return None
+    stub = dict(stub)
+    rounds = stub.get("rounds")
+    if isinstance(rounds, list) and len(variants) > 1:
+        stub["rounds"] = [
+            json.loads(json.dumps(entry)) for _index in range(len(variants)) for entry in rounds
+        ]
+    return stub
+
+
+def _memory_topk_facts(requests: list[dict], prompt: str, markers: list[str], decoy: str) -> dict:
+    """Derive the ranked-result facts from the recorded tool results."""
+    texts = [
+        text
+        for request in requests
+        if (request.get("probes") or {}).get(prompt)
+        for text in request.get("tool_result_texts") or ()
+    ]
+    blob = "\n".join((str(text) for text in texts))
+    positions = [blob.find(marker) for marker in markers]
+    complete = all((position >= 0 for position in positions))
+    return {
+        "tool_result": bool(blob),
+        "all_markers": complete,
+        "ordered": (
+            all((left < right for left, right in zip(positions, positions[1:]))) if complete else False
+        ),
+        "one_each": all((blob.count(marker) == 1 for marker in markers)),
+        "no_decoy": decoy not in blob,
+    }
+
+
+def _requests_for_span(requests: list[dict], span: object) -> list[dict]:
+    """Slice the gateway ledger down to one variant's own requests.
+
+    Every variant sends the same probe token, so the token cannot identify the
+    variant; the ledger boundaries recorded around each variant can.  Without
+    the slice the ranked-result facts would be derived from both variants'
+    results concatenated.
+    """
+    if not isinstance(span, (list, tuple)) or len(span) != 2:
+        return requests
+    start, end = span
+    if not isinstance(start, int) or not isinstance(end, int) or start > end:
+        return requests
+    return requests[start:end]
+
+
+def _memory_residency_rss_readable(row: dict) -> bool:
+    """Report whether the RSS profile itself was captured."""
+    rss = row.get("rss") or {}
+    return (
+        all((isinstance(rss.get(key), int) for key in ("baseline", "peak", "after", "delta")))
+        and int(rss.get("samples") or 0) > 0
+    )
+
+
+def _memory_residency_sampler_allocated(row: dict, expected_bytes: int) -> bool:
+    """Report whether the self-check allocated the declared block.
+
+    This is the target's gate.  The target is gated on the control, which is
+    what proves the sampler can actually see an allocation; here it is enough
+    that the probe ran and allocated what the recipe declared.
+    """
+    probe = row.get("rss_sampler_probe") or {}
+    return int(probe.get("allocated") or 0) == int(expected_bytes)
+
+
+def _memory_residency_sampler_observed(row: dict) -> bool:
+    """Report whether the sampler measured its own allocation.
+
+    This stricter gate belongs to the zero-weight control, whose job is to prove
+    RSS is observable at all.  It cannot be applied to the large-archive variant:
+    once the heap is already hundreds of megabytes the kernel satisfies a 16 MiB
+    allocation from pages the process already holds, so the delta legitimately
+    stays near zero even though RSS itself is perfectly readable.
+    """
+    probe = row.get("rss_sampler_probe") or {}
+    expected = int(probe.get("allocated") or 0)
+    return (
+        isinstance(probe.get("delta"), int)
+        and expected > 0
+        and (probe["delta"] >= expected // 2)
+        and (int(probe.get("samples") or 0) > 0)
+    )
+
+
+def _memory_residency_checks(
+    scenario_id: str, rows: dict, plan: dict, requests: list[dict]
+) -> dict[str, bool] | None:
+    """Derive the residency checks, or None when the point is unobservable."""
+    by_label = {str(item.get("label")): item for item in plan["variants"]}
+    if set(rows) != set(by_label):
+        return None
+    if not all((_memory_residency_rss_readable(row) for row in rows.values())):
+        return None
+    if scenario_id.endswith("_control"):
+        if not all((_memory_residency_sampler_observed(row) for row in rows.values())):
+            return None
+    elif not all(
+        (
+            _memory_residency_sampler_allocated(row, by_label[label]["rss_probe_bytes"])
+            for label, row in rows.items()
+        )
+    ):
+        return None
+    topk = {}
+    for label, row in rows.items():
+        variant = by_label[label]
+        topk[label] = _memory_topk_facts(
+            _requests_for_span(requests, row.get("request_span")),
+            variant["target_prompt"],
+            variant["markers"],
+            variant["decoy"],
+        )
+
+    def calls_returned(row: dict) -> bool:
+        return (row.get("index_call") or {}).get("return_is_str") is True and (row.get("measured") or {}).get(
+            "return_is_str"
+        ) is True
+
+    if scenario_id.endswith("_control"):
+        label, row = next(iter(rows.items()))
+        return {
+            "worker": True,
+            "public_calls": calls_returned(row),
+            "rss_available": True,
+            "sampler_live": True,
+            **{f"topk_{key}": value for key, value in topk[label].items()},
+        }
+    if len(rows) != 2:
+        return None
+    ordered = sorted(rows, key=lambda label: int(rows[label]["entries"]))
+    small_label, large_label = (ordered[0], ordered[-1])
+    if int(rows[small_label]["entries"]) >= int(rows[large_label]["entries"]):
+        return None
+    small_delta = int((rows[small_label]["rss"] or {})["delta"])
+    large_delta = int((rows[large_label]["rss"] or {})["delta"])
+    functional = all(
+        (
+            facts["tool_result"]
+            and facts["all_markers"]
+            and facts["ordered"]
+            and facts["one_each"]
+            and facts["no_decoy"]
+            for facts in topk.values()
+        )
+    )
+    comparable = ("all_markers", "ordered", "one_each", "no_decoy")
+    return {
+        "workers": all((calls_returned(row) for row in rows.values())),
+        "ranked_results": functional,
+        "same_topk": [topk[small_label][key] for key in comparable]
+        == [topk[large_label][key] for key in comparable],
+        "residency_bounded": large_delta <= small_delta + _MEMORY_RESIDENCY_MARGIN_BYTES,
+    }
+
+
+def _memory_residency_structured_facts(
+    scenario_id: str, api_result: dict, plan: dict | None, requests: list[dict]
+) -> dict[str, object] | None:
+    """Project the residency observation into the scenario's typed facts."""
+    if plan is None:
+        return None
+    rows = api_result.get("memory_residency_rows")
+    unobserved = {scenario_id: {"observed": False, "supported": False, "checks": []}}
+    if not isinstance(rows, dict) or not rows:
+        return unobserved
+    checks = _memory_residency_checks(scenario_id, rows, plan, requests)
+    if checks is None:
+        return unobserved
+    row: dict[str, object] = {
+        "observed": True,
+        "supported": True,
+        "checks": [bool(item) for item in checks.values()],
+    }
+    if "public_calls" in checks:
+        row["public_calls"] = bool(checks["public_calls"])
+    return {scenario_id: row}
+
+
+def _mcp_peer_variant(execution_parameters: tuple[tuple[str, object], ...]):
+    """The single declared peer variant, or None.
+
+    These points declare their whole stimulus inside the variant - the
+    commands, the config seed, the gateway stub and the marker file - rather
+    than at the top level, because the stage1 smoke layer drives one isolated
+    child per variant.  A driver that reads only the top level starts a session with
+    no commands at all: the peer is never configured, never launched, and the
+    point reports its structured facts unobserved on a run that had no
+    stimulus.
+    """
+    declared = _unfreeze(dict(execution_parameters).get("mcp_peer_variants"))
+    if not isinstance(declared, list) or len(declared) != 1:
+        return None
+    variant = declared[0]
+    return variant if isinstance(variant, dict) else None
+
+
+def _run_api_probe(
+    artifact: Path, home: Path, workspace: Path, env: dict[str, str], timeout: int
+) -> tuple[subprocess.CompletedProcess[str], bool]:
+    """Run the public API probe in the same isolated evaluation image."""
+    image = os.environ.get("SBH_EVALUATION_IMAGE", "doc2harness/evaluation:candidate")
+    command = [
+        "docker",
+        "run",
+        *container_memory_flags(),
+        "--rm",
+        "--init",
+        "--network",
+        "bridge",
+        "--add-host=host.docker.internal:host-gateway",
+        "--read-only",
+        "--tmpfs",
+        "/tmp:rw,noexec,nosuid,size=256m",
+        "--user",
+        f"{os.getuid()}:{os.getgid()}",
+        "-v",
+        f"{artifact}:/sbh-artifact:ro",
+        "-v",
+        f"{home}:/sbh-home:rw",
+        "-v",
+        f"{workspace}:/sbh-workspace:rw",
+        "-w",
+        "/sbh-workspace",
+        "-e",
+        "HOME=/sbh-home",
+        "-e",
+        "YUYAO_HOME=/sbh-home/.yuyao",
+        "-e",
+        "PYTHONDONTWRITEBYTECODE=1",
+        "-e",
+        "PYTHONPATH=/sbh-artifact/src",
+    ]
+    for key, value in env.items():
+        if key.startswith("D2A_"):
+            command.extend(("-e", f"{key}={value}"))
+    command.extend(("-e", f"SBH_SCENARIO_ID={env.get('SBH_SCENARIO_ID', '')}"))
+    for name in (
+        "SBH_MEMORY_FORGET_PLAN",
+        "SBH_CHILD_DIRECTORY_PLAN",
+        "SBH_CLIPBOARD_PLAN",
+        "SBH_MEMORY_RESIDENCY_PLAN",
+        "SBH_RESIDENCY_WORKER_SOURCE",
+        "SBH_WIRE_RETENTION_COMMANDS",
+        "SBH_WIRE_PREMSG_COUNT",
+        "SBH_SESSION_DENY",
+        "SBH_SESSION_FACT_COMMANDS",
+        "SBH_SESSION_PREMSGS",
+        "SBH_HELP_PROBE",
+    ):
+        if env.get(name):
+            command.extend(("-e", f"{name}={env[name]}"))
+    if env.get("SBH_CLIPBOARD_PLAN"):
+        command.extend(
+            ("-e", "LC_ALL=C", "-e", "LANG=C", "-e", "PYTHONUTF8=0", "-e", "PYTHONCOERCECLOCALE=0")
+        )
+    command.extend((image, "python3", "-c", _api_probe_source()))
+    try:
+        return (
+            subprocess.run(
+                command,
+                cwd=workspace,
+                capture_output=True,
+                text=True,
+                stdin=subprocess.DEVNULL,
+                timeout=timeout,
+                check=False,
+            ),
+            False,
+        )
+    except subprocess.TimeoutExpired as exc:
+        return (subprocess.CompletedProcess(command, -1, exc.stdout or "", exc.stderr or ""), True)
+_API_DRIVEN_STATE_SCENARIOS = frozenset(
+    {"plugin_declared_command_reaches_wire", "plugin_toplevel_command_control"}
+)
+
+
+def _interactive_step_budget(commands: tuple[str, ...]) -> int:
+    """Derive a per-session step cap that every declared command can reach.
+
+    The artifact's own limit (200) lets a stub with no declared rounds spend the
+    whole run on one command: the gateway keeps answering with tool calls, so
+    the later commands are typed but their requests never reach the wire.
+
+    The cap cannot be the stage1 smoke layer's 20 either, because that value is per
+    public-API call while this budget is per session, and startup alone costs a
+    different amount on each artifact.  Allow a startup allowance plus room per
+    declared command.
+
+    This bounds the loop but does not rescue an artifact that never terminates
+    its first turn - raising the cap only buys more iterations of the same
+    non-terminating turn, which is product behaviour rather than a driver gap.
+    """
+    startup_allowance = 30
+    per_command = 10
+    return max(60, startup_allowance + per_command * max(1, len(commands)))
+
+
+def _interactive_container_command(
+    artifact: Path,
+    home: Path,
+    workspace: Path,
+    image: str,
+    model_base_url: str,
+    max_steps: int = 60,
+    deny_rules: tuple[str, ...] = (),
+) -> list[str]:
+    """Build the interactive state container command with the fixture cwd bound."""
+    entrypoint = [
+        "python3",
+        "/sbh-artifact/src/yuyao/__main__.py",
+        "--yolo",
+        "--stream",
+        "off",
+        "--max-steps",
+        str(max_steps),
+    ]
+    for rule in deny_rules:
+        entrypoint.extend(("--deny", str(rule)))
+    return [
+        "docker",
+        "run",
+        *container_memory_flags(),
+        "--rm",
+        "--init",
+        "-it",
+        "--network",
+        "bridge",
+        "--add-host=host.docker.internal:host-gateway",
+        "--read-only",
+        "--tmpfs",
+        "/tmp:rw,noexec,nosuid,size=256m",
+        "--user",
+        f"{os.getuid()}:{os.getgid()}",
+        "-v",
+        f"{artifact}:/sbh-artifact:ro",
+        "-v",
+        f"{home}:/sbh-home:rw",
+        "-v",
+        f"{workspace}:/sbh-workspace:rw",
+        "-w",
+        "/sbh-workspace",
+        "-e",
+        "HOME=/sbh-home",
+        "-e",
+        "YUYAO_HOME=/sbh-home/.yuyao",
+        "-e",
+        "PYTHONDONTWRITEBYTECODE=1",
+        "-e",
+        "PYTHONPATH=/sbh-artifact/src",
+        "-e",
+        f"D2A_MODEL_BASE_URL={model_base_url}",
+        "-e",
+        "D2A_MODEL_NAME=litellm_proxy/mock",
+        "-e",
+        "D2A_MODEL_API_KEY=sk-mock-test",
+        image,
+        *entrypoint,
+    ]
+
+
+def _read(master: int, seconds: float) -> bytes:
+    data = bytearray()
+    deadline = time.monotonic() + seconds
+    while time.monotonic() < deadline:
+        ready, _, _ = select.select([master], [], [], 0.1)
+        if not ready:
+            continue
+        try:
+            data.extend(os.read(master, 65536))
+        except OSError:
+            break
+    return bytes(data)
+
+
+_ANSI_RE = re.compile("\\x1b\\[[0-9;?]*[ -/]*[@-~]")
+_PROMPT_MARKERS = ("›", "»", "⟩", "❯", "yuyao>", "yuyao >", "yuyao:", "You:", "You>", "you>")
+_PROMPT_RE = re.compile(
+    "(?:yuyao|You|you)[ \\t]*(?:\\[[^\\]\\n]{0,64}\\])?[ \\t]*[>:›»⟩❯]|^[ \\t]*[>›»⟩❯][ \\t]*$", re.MULTILINE
+)
+
+
+def _prompt_visible(text: str) -> bool:
+    """True when the text ends a rendered input prompt in any observed form."""
+    return any((marker in text for marker in _PROMPT_MARKERS)) or bool(_PROMPT_RE.search(text))
+
+
+def _read_until_startup_prompt(master: int, seconds: float) -> bytes:
+    """Read the startup banner up to the first rendered input prompt.
+
+    The banner is still painting for an indeterminate time after launch.  A
+    command written before the prompt exists is absorbed into the banner and
+    then arrives glued to the following command, so the artifact reports the
+    concatenation as one malformed input.
+    """
+    data = bytearray()
+    deadline = time.monotonic() + seconds
+    while time.monotonic() < deadline:
+        ready, _, _ = select.select([master], [], [], 0.1)
+        if not ready:
+            continue
+        try:
+            data.extend(os.read(master, 65536))
+        except OSError:
+            break
+        plain = _ANSI_RE.sub("", bytes(data).decode("utf-8", errors="replace"))
+        if _prompt_visible(plain):
+            data.extend(_read(master, 0.3))
+            return bytes(data)
+    return bytes(data)
+
+
+def _collapse_wrapped_echo(text: str) -> str:
+    """Join lines so a terminal-wrapped command echo matches its input.
+
+    A command longer than the terminal width is echoed across several lines.
+    Searching for the verbatim command then never matches, the helper below
+    never sees its prompt, and the next command is written while the previous
+    one is still being read - which the artifact receives as one concatenated
+    line (``unknown permission mode 'yolo\\n/mcp add ...'``).
+    """
+    return re.sub("[ \\t]*\\n[ \\t]*", "", text)
+
+
+def _settle_after(window: object, master: int, prior: bytes) -> bytes:
+    """Grant a daemonising command a bounded start window; return bytes read.
+
+    A recipe declares the window in one of two shapes, and both are in active
+    use, so both are supported here:
+
+    ``('2', '1.0')``
+        A plain number of seconds: sleep, read nothing.
+
+    ``('2', (('deadline_s', '5.0'), ('until_token', 'FORKDIR_9143')))``
+        A deadline plus a token to wait *for*.  Poll the pty until the token is
+        rendered, then return immediately; fall back to the deadline if it never
+        appears.  This is strictly better than a blind sleep — a fork that is
+        serving after 200 ms does not cost the full window, and one that needs
+        4 s is not read too early.
+    """
+    if isinstance(window, dict):
+        deadline_raw = window.get("deadline_s")
+        token = window.get("until_token")
+        try:
+            seconds = min(float(deadline_raw), 10.0)
+        except (TypeError, ValueError):
+            seconds = 10.0
+        if not isinstance(token, str) or not token:
+            time.sleep(seconds)
+            return b""
+        data = bytearray()
+        deadline = time.monotonic() + seconds
+        needle = token.encode("utf-8")
+        if needle in prior:
+            return b""
+        while time.monotonic() < deadline:
+            ready, _, _ = select.select([master], [], [], 0.1)
+            if not ready:
+                continue
+            try:
+                chunk = os.read(master, 65536)
+            except OSError:
+                break
+            if not chunk:
+                break
+            data.extend(chunk)
+            if needle in prior + bytes(data):
+                break
+        return bytes(data)
+    try:
+        time.sleep(min(float(window), 10.0))
+    except (TypeError, ValueError):
+        time.sleep(10.0)
+    return b""
+
+
+def _echo_tail(plain: str, prior_plain: str, command: str) -> str | None:
+    """What the product rendered after echoing ``command``, or None if unseen.
+
+    The echo may be wrapped across terminal lines, so a newline-collapsed view
+    is tried before giving up.
+    """
+    position = plain.rfind(command, max(0, len(prior_plain) - len(command)))
+    if position >= 0:
+        return plain[position + len(command) :]
+    folded = _collapse_wrapped_echo(plain)
+    folded_prior = _collapse_wrapped_echo(prior_plain)
+    position = folded.rfind(command, max(0, len(folded_prior) - len(command)))
+    if position >= 0:
+        return folded[position + len(command) :]
+    return None
+
+
+def _read_until_command_prompt(master: int, prior: bytes, command: str, seconds: float) -> bytes:
+    """Read until a prompt rendered after the current input is visible.
+
+    Interactive state recipes must not enqueue their next slash command while
+    the previous command is still being processed.  A fixed sleep is not a
+    synchronization primitive: on a busy artifact it can concatenate inputs
+    (for example ``/compact`` and ``/exit``).  Count the rendered prompt
+    occurrences already present and return once a new one arrives.
+    """
+    data = bytearray()
+    deadline = time.monotonic() + seconds
+    quiet_seconds = 3.0
+    last_output = time.monotonic()
+    while time.monotonic() < deadline:
+        ready, _, _ = select.select([master], [], [], 0.1)
+        if not ready:
+            if data and time.monotonic() - last_output >= quiet_seconds:
+                combined = (prior + bytes(data)).decode("utf-8", errors="replace")
+                plain = _ANSI_RE.sub("", combined).replace("\r", "\n")
+                prior_plain = _ANSI_RE.sub("", prior.decode("utf-8", errors="replace")).replace("\r", "\n")
+                if _echo_tail(plain, prior_plain, command) is not None:
+                    return bytes(data)
+            continue
+        try:
+            data.extend(os.read(master, 65536))
+        except OSError:
+            break
+        last_output = time.monotonic()
+        combined = (prior + bytes(data)).decode("utf-8", errors="replace")
+        plain = _ANSI_RE.sub("", combined).replace("\r", "\n")
+        prior_plain = _ANSI_RE.sub("", prior.decode("utf-8", errors="replace")).replace("\r", "\n")
+        tail = _echo_tail(plain, prior_plain, command)
+        if tail is not None and _prompt_visible(tail):
+            return bytes(data)
+    return bytes(data)
+
+
+def _json_config(home: Path) -> dict[str, object]:
+    for path in (home / ".yuyao" / "config.json", home / "config.json"):
+        try:
+            value = json.loads(path.read_text(encoding="utf-8"))
+        except (OSError, UnicodeError, json.JSONDecodeError):
+            continue
+        if isinstance(value, dict):
+            return value
+    return {}
+
+
+def _freeze(value: object) -> object:
+    """Convert recorder JSON into the closed tuple-only State fact type."""
+    if isinstance(value, dict):
+        return tuple(sorted(((str(key), _freeze(item)) for key, item in value.items())))
+    if isinstance(value, list):
+        return tuple((_freeze(item) for item in value))
+    if value is None or type(value) in {str, int, bool}:
+        return value
+    return str(value)
+
+
+def _unfreeze(value: object) -> object:
+    """Convert the closed tuple representation back to gateway config data.
+
+    An empty tuple stays a list.  ``all()`` is vacuously true for it, so the
+    pair-shaped test below would otherwise turn every empty sequence into an
+    empty mapping - and a gateway round declared as ``[]`` (a deliberate
+    no-tool turn that lets the exchange finish) would arrive as ``{}``.
+    """
+    if isinstance(value, tuple):
+        if value and all(
+            (isinstance(item, tuple) and len(item) == 2 and isinstance(item[0], str) for item in value)
+        ):
+            return {str(key): _unfreeze(item) for key, item in value}
+        return [_unfreeze(item) for item in value]
+    return value
+
+
+def _interactive_cwd(screen: str) -> str:
+    """Extract the artifact-reported cwd across supported CLI prompt variants.
+
+    Each product announces the directory in its own words - "working
+    directory: /x", "working directory is now /x", "cwd -> /x" - and the
+    wording is not part of any contract.  A phrase this does not recognise
+    falls back to the default, which reads as the directory having been reset:
+    a point asserting the cwd survived a command then fails on a session that
+    never moved.  New spellings therefore belong here, not in the judges.
+    """
+    screen = _ANSI_RE.sub("", screen)
+    matches = re.findall(
+        "working directory(?:\\s+is\\s+now|):\\s*(/\\S*)|working directory\\s+is\\s+now\\s+(/\\S*)|cwd\\s*(?:->|:|=)\\s*(/\\S*)",
+        screen,
+        re.IGNORECASE,
+    )
+    paths = [left or middle or right for left, middle, right in matches]
+    return paths[-1].strip() if paths else "/sbh-workspace"
+
+
+def _console_after_startup(text: str, commands: tuple[str, ...] = ()) -> str:
+    """Strip terminal formatting and drop the banner from the judged console.
+
+    The colour codes go first.  A judge counting the commands a listing offers
+    matches names like "/status", and an escape sequence between the slash and
+    the word breaks every one of them and the listing is undercounted.  The
+    stage1 smoke layer binds a colourless buffer, so its console
+    is plain text and its judges are written for that.
+
+    A point of the form "this command must produce something related to its
+    own name" is answered by what the command printed.  The banner advertises
+    the product's own features - "! to run a shell command", "Esc stops the
+    run" - so keeping it lets a command that printed nothing at all match a
+    keyword drawn from its own name, and the point then passes on the banner.
+    The stage1 smoke layer binds a fresh console buffer after startup for exactly
+    this reason.
+
+    The cut is made at the echo of the first declared command rather than at
+    any particular banner text: each product prints its own banner, and one of
+    them ends where another does not.
+    """
+    text = _ANSI_RE.sub("", text)
+    for command in commands:
+        index = text.find(str(command))
+        if index > 0:
+            return text[index:]
+    return text
+
+
+def _observed_file_facts(
+    root: Path, patterns: tuple[str, ...], boundary: Path | None = None
+) -> dict[str, str]:
+    """Read declared files or glob patterns without escaping the workspace.
+
+    ``..`` in a declared path is meaningful, not an attack: a point that runs
+    ``/cd sub`` and then asks whether memory landed in the *parent* names the
+    file as ``../MEMORY.md`` relative to the child cwd - and several products
+    keep memory at the session root, so the parent is exactly where it goes.
+    The stage1 smoke layer resolves these against the live cwd and reads them.  Allow
+    ``..`` but confine the resolved path to ``boundary`` (the workspace root),
+    so a genuinely out-of-workspace path is still refused.
+    """
+    limit = (boundary or root).resolve()
+    result: dict[str, str] = {}
+    for pattern in patterns:
+        candidate = Path(pattern)
+        if candidate.is_absolute():
+            continue
+        matches = root.glob(pattern) if any((ch in pattern for ch in "*?[")) else (root / pattern,)
+        for path in matches:
+            try:
+                resolved = path.resolve()
+                resolved.relative_to(limit)
+            except (OSError, ValueError):
+                continue
+            if not resolved.is_file():
+                continue
+            try:
+                relative = os.path.relpath(resolved, root)
+                result[relative] = resolved.read_text(encoding="utf-8", errors="replace")
+            except (OSError, ValueError):
+                continue
+    return result
+
+
+def _pre_message_commands(execution_parameters: tuple[tuple[str, object], ...]) -> tuple[str, ...]:
+    """Convert declared user pre-messages into real interactive inputs."""
+    params = dict(execution_parameters)
+    raw = params.get("premsgs", ())
+    commands: list[str] = []
+    if not isinstance(raw, tuple):
+        return ()
+    for item in raw:
+        if not isinstance(item, tuple):
+            continue
+        message = dict(item)
+        if message.get("role") == "user" and isinstance(message.get("content"), str):
+            commands.append(message["content"])
+    return tuple(commands)
+
+
+def _pre_message_records(execution_parameters: tuple[tuple[str, object], ...]) -> list[dict[str, object]]:
+    """Return declared pre-messages as whole records, every role kept.
+
+    ``_pre_message_commands`` keeps only the user content, because typed input
+    can express nothing else.  A judge that reads the role sequence needs the
+    assistant and system entries as well - dropping them turns the declared
+    alternating baseline into a run of consecutive user roles, which is exactly
+    the defect those scenarios are trying to detect.
+    """
+    raw = dict(execution_parameters).get("premsgs", ())
+    if not isinstance(raw, tuple):
+        return []
+    records: list[dict[str, object]] = []
+    for item in raw:
+        if not isinstance(item, tuple):
+            continue
+        message = {str(key): value for key, value in item if isinstance(key, str)}
+        if message.get("role"):
+            records.append(message)
+    return records
+
+
+def _apply_git_fixture(workspace: Path, execution_parameters: tuple[tuple[str, object], ...]) -> None:
+    """Commit the seeded files as a baseline, then write the post-baseline set.
+
+    ``/diff`` and ``/undo`` are defined over a git working tree, so a scenario
+    that exercises them declares ``git_init``.  The seeded files become the
+    committed baseline and ``post_files`` are written afterwards, which is what
+    makes them read as the agent's uncommitted changes.
+
+    ``git_branch_commit`` additionally commits the post-baseline set onto a
+    second branch, leaving the working tree clean: the situation ``/review`` and
+    ``/security-review`` are specified over is "the current *branch* differs",
+    not "the working tree differs".  Two real branches are created rather than
+    one extra commit because without a remote the base of "branch changes" is
+    ambiguous, and a resolvable ``origin/HEAD`` is published because Claude
+    Code's own security review runs ``git diff origin/HEAD...`` with no
+    fallback - a fixture that omits the ref would fail an implementation that
+    copies that approach for reasons that are the fixture's fault.
+    """
+    parameters = dict(execution_parameters)
+    if not parameters.get("git_init"):
+        return
+    identity = ("-c", "user.email=fixture@example.invalid", "-c", "user.name=SBH Fixture")
+
+    def run(*arguments: str) -> None:
+        subprocess.run(
+            ("git", *identity, *arguments),
+            cwd=workspace,
+            check=False,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+        )
+
+    run("init", "-q")
+    run("add", "-A")
+    run("commit", "-q", "-m", "baseline", "--allow-empty")
+    post_files = _unfreeze(parameters.get("post_files") or ())
+    if isinstance(post_files, dict):
+        entries = list(post_files.items())
+    elif isinstance(post_files, list):
+        entries = [tuple(item) for item in post_files if isinstance(item, (list, tuple)) and len(item) == 2]
+    else:
+        entries = []
+    if parameters.get("git_branch_commit"):
+        run("branch", "-M", "main")
+        run("checkout", "-q", "-b", "review-subject")
+    for relative, content in entries:
+        path = workspace / str(relative)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(str(content), encoding="utf-8")
+    if parameters.get("git_branch_commit"):
+        run("add", "-A")
+        run("commit", "-q", "-m", "branch change")
+        run("update-ref", "refs/remotes/origin/main", "refs/heads/main")
+        run("symbolic-ref", "refs/remotes/origin/HEAD", "refs/remotes/origin/main")
+
+
+def _snapshot_command_index(execution_parameters: tuple[tuple[str, object], ...]) -> int | None:
+    """Return the command index after which the observed files are snapshotted.
+
+    A requirement of the form "this *segment* must not touch that file" cannot
+    be decided from the final state alone, which is why the fixture carries a
+    mid-sequence snapshot.  Without it a judge has to recognise the
+    file's *format* to infer what wrote it, and the format is each build's own
+    choice: counting memory entries as lines starting with ``-`` reads zero from
+    a build that writes ``## memory-flush <ISO>``, turning a real failure into
+    a non-observable result.
+    """
+    value = dict(execution_parameters).get("snap_after")
+    return value if isinstance(value, int) and (not isinstance(value, bool)) else None
+
+
+def _run_one() -> dict[str, object]:
+    from doc2harness.benchmark.definition import definition_digest
+    from doc2harness.benchmark.dispatch import load_scenario_owner
+    from doc2harness.benchmark.harnesses.state.adapter import build_state_execution_plan
+    from doc2harness.benchmark.harnesses.state.contracts import StateObservation
+
+    scenario_id = os.environ["SBH_SCENARIO_ID"]
+    owner = load_scenario_owner(scenario_id)
+    if ".benchmark.harnesses.state." not in owner.module:
+        raise RuntimeError("state driver received a non-state scenario")
+    scenario = owner.scenario
+    plan = build_state_execution_plan(scenario)
+    gateway = mock_gateway
+    reply_content = "STATE_MOCK_REPLY_7731"
+    execution_parameters = dict(plan.execution_parameters)
+    declared_stub = _unfreeze(execution_parameters.get("stub"))
+    peer_variant = _mcp_peer_variant(plan.execution_parameters)
+    if declared_stub is None and isinstance(peer_variant, dict):
+        declared_stub = peer_variant.get("stub")
+    if isinstance(declared_stub, dict) and scenario_id in _CHILD_DIRECTORY_SCENARIOS:
+        declared_variants = dict(scenario.recipe.execution_parameters).get(_CHILD_DIRECTORY_RECIPE_KEY)
+        declared_stub = _resolve_child_directory_stub(declared_stub, len(declared_variants or ()) or 1)
+    if declared_stub is None and scenario_id in _CLIPBOARD_SCENARIOS:
+        declared_stub = _clipboard_declared_stub(scenario.recipe.execution_parameters)
+    if declared_stub is None and scenario_id in _MEMORY_RESIDENCY_SCENARIOS:
+        declared_stub = _memory_residency_stub(scenario.recipe.execution_parameters)
+    if isinstance(declared_stub, dict) and (not declared_stub.get("mode")):
+        declared_stub = {
+            "mode": "plain_no_tool",
+            "reply_content": "Summary: task context compacted. STUB_SUMMARY_5150",
+            **declared_stub,
+        }
+    if isinstance(declared_stub, dict):
+        cfg = gateway.new_cfg(**declared_stub)
+    elif scenario_id in {"agent_api_close_retry_incomplete_control", "agent_api_close_retry_incomplete"}:
+        cfg = gateway.new_cfg(
+            mode="seq_probe",
+            probe_tokens=["CLOSE_ROUTE_6501"],
+            rounds=[
+                [
+                    {
+                        "name": "bash",
+                        "command": "python3 /sbh-workspace/repo/close_helper.py",
+                        "run_in_background": True,
+                    }
+                ],
+                [{"name": "__finish__"}],
+            ],
+        )
+    else:
+        cfg = gateway.new_cfg(mode="fixed_reply", reply_content=reply_content)
+    server = gateway.ThreadingHTTPServer(("0.0.0.0", 0), gateway.Handler)
+    server.cfg = cfg
+    server.daemon_threads = True
+    server.block_on_close = False
+    thread = threading.Thread(target=server.serve_forever, daemon=True)
+    thread.start()
+    with tempfile.TemporaryDirectory(prefix="sbh-state-production-") as temporary:
+        root = Path(temporary)
+        home, workspace, output = (root / "home", root / "workspace", root / "out")
+        home.mkdir()
+        workspace.mkdir()
+        output.mkdir()
+        for relative, content in plan.fixture.seed_files:
+            path = workspace / relative
+            path.parent.mkdir(parents=True, exist_ok=True)
+            path.write_text(content, encoding="utf-8")
+        for relative, content in plan.fixture.home_seed_files:
+            path = home / relative
+            path.parent.mkdir(parents=True, exist_ok=True)
+            path.write_text(content, encoding="utf-8")
+        _apply_git_fixture(workspace, plan.execution_parameters)
+        help_probe_declared = bool(dict(plan.execution_parameters).get("probe_help"))
+        snapshot_index = _snapshot_command_index(plan.execution_parameters)
+        files_mid: dict[str, str] = {}
+        settle_raw = _unfreeze(dict(plan.execution_parameters).get("settle_after") or ())
+        settle_windows = dict(settle_raw) if isinstance(settle_raw, dict) else {}
+        config_snapshot_index = dict(plan.execution_parameters).get("cfg_snap_after")
+        if not isinstance(config_snapshot_index, int) or isinstance(config_snapshot_index, bool):
+            config_snapshot_index = None
+        config_mid: dict[str, object] = {}
+        _declared_permissions = dict(plan.execution_parameters)
+        if _declared_permissions.get("deny") or _declared_permissions.get("allow"):
+            config_dir = home / ".yuyao"
+            config_dir.mkdir(parents=True, exist_ok=True)
+            config_path = config_dir / "config.json"
+            try:
+                config_value = json.loads(config_path.read_text(encoding="utf-8"))
+                if not isinstance(config_value, dict):
+                    config_value = {}
+            except (OSError, UnicodeError, json.JSONDecodeError):
+                config_value = {}
+            if _declared_permissions.get("deny"):
+                config_value["permissions.deny"] = [str(rule) for rule in _declared_permissions["deny"]]
+            if _declared_permissions.get("allow"):
+                config_value["permissions.allow"] = [str(rule) for rule in _declared_permissions["allow"]]
+            config_path.write_text(
+                json.dumps(config_value, ensure_ascii=False, sort_keys=True), encoding="utf-8"
+            )
+        env = dict(os.environ)
+        env.update(
+            {
+                "HOME": str(home),
+                "YUYAO_HOME": str(home / ".yuyao"),
+                "PYTHONDONTWRITEBYTECODE": "1",
+                "PYTHONPATH": str(Path(os.environ["SBH_ARTIFACT_PATH"]) / "src"),
+                "D2A_MODEL_BASE_URL": f"http://host.docker.internal:{server.server_address[1]}/v1",
+                "D2A_MODEL_NAME": "litellm_proxy/mock",
+                "D2A_MODEL_API_KEY": "sk-mock-test",
+            }
+        )
+        if help_probe_declared:
+            env["SBH_HELP_PROBE"] = "1"
+        api_result: dict[str, object] = {}
+        child_directory_plan = _child_directory_plan(scenario_id, scenario.recipe.execution_parameters)
+        if child_directory_plan is not None:
+            env["SBH_CHILD_DIRECTORY_PLAN"] = json.dumps(child_directory_plan, sort_keys=True)
+        clipboard_plan = _clipboard_plan(scenario_id, scenario.recipe.execution_parameters)
+        if clipboard_plan is not None:
+            env["SBH_CLIPBOARD_PLAN"] = json.dumps(clipboard_plan, sort_keys=True)
+        residency_plan = _memory_residency_plan(scenario_id, scenario.recipe.execution_parameters)
+        if residency_plan is not None:
+            env["SBH_MEMORY_RESIDENCY_PLAN"] = json.dumps(residency_plan, sort_keys=True)
+            env["SBH_RESIDENCY_WORKER_SOURCE"] = _MEMORY_RESIDENCY_WORKER
+        wire_commands = (
+            _pre_message_commands(plan.execution_parameters) + plan.commands
+            if (scenario_id in _API_DRIVEN_STATE_SCENARIOS)
+            else ()
+        )
+        if wire_commands:
+            env["SBH_WIRE_RETENTION_COMMANDS"] = json.dumps([str(item) for item in wire_commands])
+            env["SBH_WIRE_PREMSG_COUNT"] = str(len(_pre_message_commands(plan.execution_parameters)))
+            declared_deny = dict(plan.execution_parameters).get("deny")
+            if declared_deny:
+                env["SBH_SESSION_DENY"] = json.dumps([str(rule) for rule in _unfreeze(declared_deny) or ()])
+        session_fact_commands = ()
+        if session_fact_commands:
+            env["SBH_SESSION_FACT_COMMANDS"] = json.dumps([str(item) for item in session_fact_commands])
+            premsgs = _pre_message_records(plan.execution_parameters)
+            if premsgs:
+                env["SBH_SESSION_PREMSGS"] = json.dumps(premsgs)
+        if (
+            scenario_id.startswith("agent_api_")
+            or False
+            or child_directory_plan is not None
+            or (clipboard_plan is not None)
+            or (residency_plan is not None)
+            or bool(wire_commands)
+            or bool(session_fact_commands)
+            or help_probe_declared
+        ):
+            completed, timed_out = _run_api_probe(
+                Path(os.environ["SBH_ARTIFACT_PATH"]), home, workspace, env, min(plan.timeout_seconds, 120)
+            )
+            returncode = completed.returncode
+            screen = bytearray(
+                "\n".join(
+                    (
+                        line
+                        for line in (completed.stdout or "").splitlines()
+                        if not line.startswith(_API_MARKER)
+                    )
+                ).encode()
+            )
+            screen.extend((completed.stderr or "").encode())
+            for line in (completed.stdout or "").splitlines():
+                if line.startswith(_API_MARKER):
+                    try:
+                        parsed = json.loads(line[len(_API_MARKER) :])
+                    except (TypeError, ValueError, json.JSONDecodeError):
+                        parsed = {}
+                    if isinstance(parsed, dict):
+                        api_result.update(parsed)
+        else:
+            image = os.environ.get("SBH_EVALUATION_IMAGE", "doc2harness/evaluation:candidate")
+            commands = _pre_message_commands(plan.execution_parameters) + plan.commands
+            command = _interactive_container_command(
+                Path(os.environ["SBH_ARTIFACT_PATH"]),
+                home,
+                workspace,
+                image,
+                f"http://host.docker.internal:{server.server_address[1]}/v1",
+                _interactive_step_budget(commands),
+                deny_rules=tuple((str(rule) for rule in _declared_permissions.get("deny") or ())))
+            master, slave = pty.openpty()
+            try:
+                import fcntl
+                import struct
+                import termios
+
+                fcntl.ioctl(slave, termios.TIOCSWINSZ, struct.pack("HHHH", 50, 200, 0, 0))
+            except (ImportError, OSError):
+                pass
+            process = subprocess.Popen(
+                command,
+                cwd=workspace,
+                env=env,
+                stdin=slave,
+                stdout=slave,
+                stderr=slave,
+                start_new_session=True,
+            )
+            os.close(slave)
+            screen = bytearray(_read_until_startup_prompt(master, 30.0))
+            try:
+                for index, item in enumerate(commands):
+                    os.write(master, str(item).encode("utf-8") + b"\r")
+                    screen.extend(
+                        _read_until_command_prompt(
+                            master, bytes(screen), str(item), min(float(plan.timeout_seconds), 60.0)
+                        )
+                    )
+                    if index == snapshot_index:
+                        snapshot_text = screen.decode("utf-8", errors="replace")
+                        snapshot_root = workspace
+                        snapshot_cwd = _interactive_cwd(snapshot_text)
+                        if snapshot_cwd.startswith("/sbh-workspace/"):
+                            snapshot_root = workspace / snapshot_cwd.removeprefix("/sbh-workspace/")
+                        files_mid = _observed_file_facts(snapshot_root, plan.observed_files, workspace)
+                    if str(index) in settle_windows:
+                        screen.extend(_settle_after(settle_windows[str(index)], master, bytes(screen)))
+                    if index == config_snapshot_index:
+                        config_mid = _json_config(home)
+                screen.extend(_read(master, min(float(plan.timeout_seconds), 60.0)))
+                os.write(master, b"\r")
+                screen.extend(_read(master, 2.0))
+                os.write(master, b"/exit\r")
+                screen.extend(_read(master, 5.0))
+                try:
+                    returncode = process.wait(timeout=10.0)
+                except subprocess.TimeoutExpired:
+                    os.write(master, b"\x04")
+                    screen.extend(_read(master, 3.0))
+                    returncode = process.wait(timeout=10.0)
+                timed_out = False
+            except (subprocess.TimeoutExpired, OSError):
+                timed_out = True
+                try:
+                    os.killpg(process.pid, signal.SIGTERM)
+                    returncode = process.wait(timeout=2.0)
+                except (OSError, subprocess.TimeoutExpired):
+                    returncode = -1
+            finally:
+                os.close(master)
+        trajectory = _trajectory(home) + "\n" + _trajectory(workspace)
+        text = _console_after_startup(
+            screen.decode("utf-8", errors="replace"), tuple((str(item) for item in plan.commands))
+        )
+        cwd_fact = _interactive_cwd(text)
+        cwd_root = workspace
+        if cwd_fact.startswith("/sbh-workspace/"):
+            cwd_root = workspace / cwd_fact.removeprefix("/sbh-workspace/")
+        files = _observed_file_facts(cwd_root, plan.observed_files, workspace)
+        config = _json_config(home)
+        returns = tuple((line.strip() for line in text.replace("\r", "\n").splitlines() if line.strip()))[
+            -64:
+        ]
+        api_std = api_result.get("std")
+        if isinstance(api_std, dict):
+            std_fact: object = _freeze(api_std)
+        else:
+            std_fact = _freeze(
+                {
+                    "std": bool(api_result.get("std")),
+                    "ok": bool(api_result.get("ok")),
+                    "tb": bool(api_result.get("tb")),
+                }
+            )
+        if isinstance(api_result.get("console"), str):
+            text = api_result["console"]
+        if isinstance(api_result.get("returns"), list):
+            returns = tuple((str(item) for item in api_result["returns"]))
+        api_cwd = api_result.get("cwd")
+        if isinstance(api_cwd, str) and api_cwd:
+            cwd_fact = api_cwd
+        facts: dict[str, object] = {
+            "result_present": bool(api_result.get("ok") or returns or cfg.get("requests")),
+            "console": text,
+            "std": std_fact,
+            "returns": returns,
+            "requests": tuple((_freeze(item) for item in cfg.get("requests", []))),
+            "config": _freeze(
+                api_result.get("config") if isinstance(api_result.get("config"), dict) else config
+            ),
+            "cwd": cwd_fact,
+            "files": _freeze(files),
+            "tree": _freeze(files),
+            "messages": text,
+            "files_mid": _freeze(files_mid),
+            "config_mid": _freeze(config_mid),
+            "error": (
+                api_result["error"]
+                if isinstance(api_result.get("error"), str) and api_result["error"]
+                else ""
+            ),
+            "trajectory_text": trajectory,
+            "structured_facts": tuple(),
+            "process_reaped": returncode is not None,
+            "workspace_clean": True,
+        }
+        for key in (
+            "ctor",
+            "contrast",
+            "mcp",
+            "messages",
+            "messages_before",
+            "message_count",
+            "roles",
+            "roles_before",
+            "structured_facts",
+            "wire_retention_returns",
+            "help_probe",
+            "help_claimed",
+            "plans",
+        ):
+            if key in api_result:
+                facts[key] = _freeze(api_result[key])
+        child_directory_facts = _child_directory_structured_facts(
+            scenario_id, api_result, child_directory_plan, list(cfg.get("requests") or ())
+        )
+        if child_directory_facts is not None:
+            facts["structured_facts"] = _freeze(child_directory_facts)
+            facts["result_present"] = True
+        clipboard_facts = _clipboard_structured_facts(scenario_id, api_result, clipboard_plan)
+        if clipboard_facts is not None:
+            facts["structured_facts"] = _freeze(clipboard_facts)
+            facts["result_present"] = True
+        residency_facts = _memory_residency_structured_facts(
+            scenario_id, api_result, residency_plan, list(cfg.get("requests") or ())
+        )
+        if residency_facts is not None:
+            facts["structured_facts"] = _freeze(residency_facts)
+            facts["result_present"] = True
+        if isinstance(api_result.get("chat"), str) and api_result["chat"]:
+            facts["returns"] = (api_result["chat"],)
+        evidence = {
+            "scenario_id": scenario_id,
+            "commands": plan.commands,
+            "returncode": returncode,
+            "screen": text,
+            "files": files,
+        }
+        observation = StateObservation(
+            scenario_id=scenario_id,
+            plan_digest=plan.plan_digest,
+            artifact_id=os.environ["SBH_ARTIFACT_ID"],
+            artifact_digest=os.environ["SBH_ARTIFACT_DIGEST"],
+            backend_evidence_digest=_digest(evidence),
+            fixture_verified=True,
+            facts=tuple(sorted(facts.items())),
+            process_tree_clean=not timed_out,
+            workspace_clean=True,
+        )
+    server.shutdown()
+    server.server_close()
+    thread.join(timeout=2)
+    return {
+        "observation": observation,
+        "judgement": owner.judge(observation),
+        "module": owner.module,
+        "definition_digest": definition_digest(owner.definition),
+    }
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.parse_args()
+    result = _run_one()
+    Path(os.environ["SBH_TYPED_EVENT_PATH"]).write_text(
+        json.dumps(
+            {
+                "schema": "doc2harness.typed-events/1",
+                "source_digest": os.environ["SBH_SOURCE_DIGEST"],
+                "task_digest": os.environ["SBH_TASK_DIGEST"],
+                "budget_digest": os.environ["SBH_BUDGET_DIGEST"],
+                "artifact_digest": os.environ["SBH_ARTIFACT_DIGEST"],
+                "artifact_id": os.environ["SBH_ARTIFACT_ID"],
+                "scenario_id": os.environ["SBH_SCENARIO_ID"],
+                "scenario_module": result["module"],
+                "definition_digest": result["definition_digest"],
+                "events": [
+                    {
+                        "type": "state-observation",
+                        "observation": asdict(result["observation"]),
+                        "judgement": asdict(result["judgement"]),
+                    }
+                ],
+            },
+            ensure_ascii=False,
+            default=lambda value: value.value if hasattr(value, "value") else str(value),
+            indent=2,
+        )
+        + "\n",
+        encoding="utf-8",
+    )
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/code/src/doc2harness/runtime/tui_driver.py b/code/src/doc2harness/runtime/tui_driver.py
new file mode 100644
index 0000000000000000000000000000000000000000..39f96fad6c8cda0212ddcac3bb1f5818c4d6c3cd
--- /dev/null
+++ b/code/src/doc2harness/runtime/tui_driver.py
@@ -0,0 +1,238 @@
+"""Run one active ``tui`` scenario in the evaluation container."""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import os
+import pty
+import select
+import signal
+import subprocess
+import tempfile
+import threading
+import time
+from dataclasses import asdict
+from pathlib import Path
+
+from doc2harness.runtime import mock_gateway
+from doc2harness.runtime.tui_stimulus import tui_gateway_config
+from typing import Any
+
+from doc2harness.runtime.direct_mock_driver import _digest, _trajectory
+from doc2harness.runtime.resource_limits import container_memory_flags
+
+
+def _read(master: int, buffer: bytearray, seconds: float) -> None:
+    deadline = time.monotonic() + seconds
+    while time.monotonic() < deadline:
+        ready, _, _ = select.select([master], [], [], 0.1)
+        if not ready:
+            continue
+        try:
+            buffer.extend(os.read(master, 65536))
+        except OSError:
+            return
+
+
+def _read_until_quiet(
+    master: int, buffer: bytearray, max_wait: float, quiet_for: float = 0.35
+) -> None:
+    """Read until the terminal stops producing output, or the budget runs out.
+
+    A fixed pause between typed lines is not synchronisation.  A line typed
+    while the previous turn is still answering is taken as literal text in the
+    input box rather than submitted, so the turn the point is about never
+    reaches the model and the point reports its own stimulus as unobserved.
+    """
+
+    deadline = time.monotonic() + max_wait
+    stable_since = time.monotonic()
+    last = len(buffer)
+    while time.monotonic() < deadline:
+        ready, _, _ = select.select([master], [], [], 0.05)
+        if ready:
+            try:
+                buffer.extend(os.read(master, 65536))
+            except OSError:
+                return
+        if len(buffer) != last:
+            last = len(buffer)
+            stable_since = time.monotonic()
+        elif time.monotonic() - stable_since >= quiet_for:
+            return
+
+
+def _file_observations(workspace: Path, paths: tuple[str, ...]):
+    from doc2harness.benchmark.harnesses.tui.contracts import ObservedFile
+
+    result = []
+    for relative in paths:
+        path = workspace / relative
+        if path.is_file():
+            result.append(ObservedFile(relative, True, path.read_text(encoding="utf-8", errors="replace")))
+        else:
+            result.append(ObservedFile(relative, False, ""))
+    return tuple(result)
+
+
+def _run_one() -> dict[str, Any]:
+    from doc2harness.benchmark.definition import definition_digest
+    from doc2harness.benchmark.dispatch import load_scenario_owner
+    from doc2harness.benchmark.harnesses.tui.adapter import build_tui_pty_execution_plan
+    from doc2harness.benchmark.harnesses.tui.contracts import (
+        PromptObservation, TuiObservation, TuiRequest,
+    )
+
+    scenario_id = os.environ["SBH_SCENARIO_ID"]
+    owner = load_scenario_owner(scenario_id)
+    if ".benchmark.harnesses.tui." not in owner.module:
+        raise RuntimeError("TUI driver received a non-TUI scenario")
+    scenario = owner.scenario
+    plan = build_tui_pty_execution_plan(scenario)
+    recipe = scenario.recipe
+    artifact = Path(os.environ["SBH_ARTIFACT_PATH"])
+    gateway_module = mock_gateway
+    cfg = tui_gateway_config(scenario, gateway_module)
+    server = gateway_module.ThreadingHTTPServer(("0.0.0.0", 0), gateway_module.Handler)
+    server.cfg = cfg
+    server.daemon_threads = True
+    server.block_on_close = False
+    thread = threading.Thread(target=server.serve_forever, daemon=True)
+    thread.start()
+    started = time.monotonic_ns()
+    screen = bytearray()
+    timed_out = False
+    driver_error = ""
+    returncode: int | None = None
+    with tempfile.TemporaryDirectory(prefix="sbh-tui-production-") as temporary:
+        root = Path(temporary)
+        home, workspace = root / "home", root / "workspace"
+        home.mkdir(); workspace.mkdir()
+        for seed in recipe.seed_files:
+            path = workspace / seed.path
+            path.parent.mkdir(parents=True, exist_ok=True)
+            path.write_bytes(bytes.fromhex(seed.data_hex))
+        env = dict(os.environ)
+        env.update({
+            "HOME": str(home), "YUYAO_HOME": str(home / ".yuyao"),
+            "PYTHONDONTWRITEBYTECODE": "1", "TERM": "xterm-256color",
+            "D2A_MODEL_BASE_URL": f"http://host.docker.internal:{server.server_address[1]}/v1",
+            "D2A_MODEL_NAME": "mock/release-tui", "D2A_MODEL_API_KEY": "sk-mock-test",
+        })
+        image = os.environ.get("SBH_EVALUATION_IMAGE", "doc2harness/evaluation:candidate")
+        command = [
+            "docker", "run", *container_memory_flags(), "--rm", "--init", "-it", "--network", "bridge",
+            "--add-host=host.docker.internal:host-gateway", "--read-only",
+            "--tmpfs", "/tmp:rw,noexec,nosuid,size=256m", "--user", f"{os.getuid()}:{os.getgid()}",
+            "-v", f"{artifact}:/sbh-artifact:ro", "-v", f"{workspace}:/sbh-workspace:rw",
+            # Start in the writable workspace, as every other driver does.
+            # Without this the container's working directory is the read-only
+            # root, so a shell line that redirects into a relative path fails
+            # with exit 1 and a point about "the shell really ran" can only
+            # observe an absent file - it was judging the mount, not the
+            # product.
+            "-w", "/sbh-workspace",
+            "-v", f"{home}:/sbh-home:rw", "-e", "HOME=/sbh-home",
+            "-e", "YUYAO_HOME=/sbh-home/.yuyao", "-e", "PYTHONDONTWRITEBYTECODE=1",
+            "-e", "TERM=xterm-256color",
+            "-e", f"D2A_MODEL_BASE_URL=http://host.docker.internal:{server.server_address[1]}/v1",
+            "-e", "D2A_MODEL_NAME=mock/release-tui", "-e", "D2A_MODEL_API_KEY=sk-mock-test",
+            "-e", "PYTHONPATH=/sbh-artifact/src", image,
+            "python3", "/sbh-artifact/src/yuyao/__main__.py", "--yolo", "--stream", "off",
+            *recipe.cli_arguments,
+        ]
+        master, slave = pty.openpty()
+        process = subprocess.Popen(command, cwd=workspace, env=env, stdin=slave, stdout=slave,
+                                   stderr=slave, start_new_session=True)
+        os.close(slave)
+        try:
+            _read(master, screen, 3.0)
+            for item in recipe.input_lines:
+                payload = bytes.fromhex(item.data_hex)
+                os.write(master, payload)
+                if not payload.endswith((b"\r", b"\n")):
+                    os.write(master, b"\r")
+                # Wait for the turn to finish answering before typing the next
+                # line, rather than pausing a fixed second: a line typed into a
+                # busy prompt is kept as text instead of submitted.
+                _read_until_quiet(master, screen, min(float(recipe.timeout_seconds), 30.0))
+            # The survival sentinel: after the declared input the driver feeds
+            # one more line that echoes a completion token. Seeing it
+            # is what proves the session still processes input after whatever the
+            # point threw at it - a crash, a hang, or a mode it cannot leave all
+            # keep it from appearing.
+            completion = getattr(recipe.oracle, "completion_token", "")
+            if completion:
+                os.write(master, ("!printf '" + completion + chr(92) + chr(92) + "n'").encode())
+                os.write(master, b"\r")
+                _read(master, screen, 2.0)
+            _read(master, screen, min(float(recipe.timeout_seconds), 20.0))
+            os.write(master, b"\x04")
+            _read(master, screen, 3.0)
+            # Give the exit whatever the recipe still allows rather than a flat
+            # three seconds.  A product that is mid-loop when EOF arrives has to
+            # finish its current round before it can leave, and on a loaded host
+            # - a full catalog run puts sixteen of these containers on the CPU at
+            # once - that takes longer in wall-clock than it does when the
+            # scenario runs alone.  A flat cap would make the verdict depend on
+            # how busy the machine is.
+            spent = (time.monotonic_ns() - started) / 1e9
+            remaining = max(3.0, float(recipe.timeout_seconds) - spent)
+            returncode = process.wait(timeout=remaining)
+        except (OSError, subprocess.TimeoutExpired) as exc:
+            timed_out = isinstance(exc, subprocess.TimeoutExpired)
+            driver_error = type(exc).__name__
+            try:
+                os.killpg(process.pid, signal.SIGTERM)
+                returncode = process.wait(timeout=2.0)
+            except (OSError, subprocess.TimeoutExpired):
+                returncode = -1
+        finally:
+            os.close(master)
+        trajectory = _trajectory(home) + "\n" + _trajectory(workspace)
+        screen_text = screen.decode("utf-8", errors="replace")
+        requests = tuple(TuiRequest(json.dumps(item, ensure_ascii=False, sort_keys=True)) for item in cfg.get("requests", []))
+        prompt = PromptObservation(
+            identity=f"pty-{process.pid}", turn_id="turn-1", candidate_boundary=True,
+            canary_nonce_absent_before=True, canary_nonce_absent_from_input=True,
+            canary_observed=any(token in screen_text or token in trajectory for token in recipe.probe_tokens),
+            input_consumed=bool(requests), startup_returncode=returncode,
+            timeline=("pty_open", "request_observed" if requests else "no_request", "pty_close"),
+        )
+        observation = TuiObservation(
+            scenario_id=scenario_id, profile=recipe.profile, plan_digest=plan.plan_digest,
+            artifact_id=os.environ["SBH_ARTIFACT_ID"], artifact_digest=os.environ["SBH_ARTIFACT_DIGEST"],
+            backend_evidence_digest=_digest({"scenario_id": scenario_id, "requests": len(requests), "returncode": returncode, "screen_sha256": hashlib.sha256(screen).hexdigest()}),
+            cli_available=(artifact / "src/yuyao/__main__.py").is_file(), prompt=prompt,
+            screen_text=screen_text, screen_sha256=hashlib.sha256(screen).hexdigest(), screen_size=len(screen),
+            returncode=returncode, signal=None, requests=requests,
+            files=_file_observations(workspace, recipe.observed_files), elapsed_ns=time.monotonic_ns() - started,
+            deadline_reached=timed_out, driver_error=driver_error,
+            process_tree_clean=not timed_out and not driver_error, workspace_clean=True,
+            trajectory_text=trajectory,
+        )
+    server.shutdown(); server.server_close(); thread.join(timeout=2)
+    return {"observation": observation, "judgement": owner.judge(observation),
+            "module": owner.module, "definition_digest": definition_digest(owner.definition)}
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.parse_args()
+    result = _run_one()
+    Path(os.environ["SBH_TYPED_EVENT_PATH"]).write_text(json.dumps({
+        "schema": "doc2harness.typed-events/1", "source_digest": os.environ["SBH_SOURCE_DIGEST"],
+        "task_digest": os.environ["SBH_TASK_DIGEST"], "budget_digest": os.environ["SBH_BUDGET_DIGEST"],
+        "artifact_digest": os.environ["SBH_ARTIFACT_DIGEST"], "artifact_id": os.environ["SBH_ARTIFACT_ID"],
+        "scenario_id": os.environ["SBH_SCENARIO_ID"], "scenario_module": result["module"],
+        "definition_digest": result["definition_digest"],
+        "events": [{"type": "tui-pty-observation", "observation": asdict(result["observation"]),
+                    "judgement": asdict(result["judgement"])}],
+    }, ensure_ascii=False, default=lambda value: value.value if hasattr(value, "value") else str(value), indent=2) + "\n", encoding="utf-8")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/code/src/doc2harness/runtime/tui_stimulus.py b/code/src/doc2harness/runtime/tui_stimulus.py
new file mode 100644
index 0000000000000000000000000000000000000000..5cf5360232fe25188115a77c19afd7f7959e9a50
--- /dev/null
+++ b/code/src/doc2harness/runtime/tui_stimulus.py
@@ -0,0 +1,104 @@
+"""Deterministic gateway stimulus for the TUI scenarios.
+
+Stimulus construction belongs to the execution layer, so it ships with the
+driver that needs it.
+"""
+
+from __future__ import annotations
+
+
+def tui_gateway_config(scenario, gateway_module):
+    """Build the deterministic gateway stimulus for one TUI scenario.
+
+    The mock gateway has no standalone ``background`` or ``gpg_fail`` response
+    mode.  Those names describe the scenario, not a wire response.  Translate
+    them into explicit ``seq_probe`` rounds here so the artifact receives
+    explicit tool calls; an empty sequence is never silently
+    treated as a successful stimulus.
+    """
+    sid = scenario.definition.scenario_id
+    marker = scenario.recipe.oracle.primary_token or "TUI_EXTERNAL_7731"
+    cfg = gateway_module.new_cfg(
+        mode=scenario.recipe.gateway_mode,
+        reply_content=scenario.recipe.reply_content,
+        probe_tokens=list(scenario.recipe.probe_tokens),
+    )
+    if "background_completion" in sid:
+        cfg.update(
+            mode="seq_probe",
+            rounds=[
+                [{
+                    "name": "bash",
+                    "command": (
+                        "python3 -c \"from pathlib import Path; "
+                        f"Path('background_done.marker').write_text('{marker} completed'); "
+                        f"print('{marker} completed')\""
+                    ),
+                    "background": True,
+                }],
+                [{"name": "bash", "command": "sleep 1; echo background finished"}],
+                [{"name": "__finish__"}],
+            ],
+        )
+    elif "autotest_output" in sid:
+        cfg.update(
+            mode="seq_probe",
+            rounds=[
+                [{
+                    "name": "write",
+                    "args": {"path": "autotest_target.txt", "content": marker + "\\n"},
+                }],
+                [{"name": "__finish__"}],
+            ],
+        )
+    elif "autocommit_fail" in sid:
+        cfg.update(
+            mode="seq_probe",
+            rounds=[
+                [{
+                    "name": "write",
+                    "args": {"path": "autocommit_target.txt", "content": marker + "\\n"},
+                }],
+                [{"name": "__finish__"}],
+            ],
+        )
+    elif "step_limit" in sid:
+        cfg.update(
+            mode="seq_probe",
+            rounds=[
+                [{"name": "bash", "command": f"printf '{marker} max_steps\\n' >> step_limit.marker"}]
+                for _ in range(10)
+            ],
+        )
+    elif scenario.recipe.gateway_mode == "seq_probe":
+        # Finish-reason has to contain one real tool-call round before close.
+        cfg.update(
+            rounds=[
+                [{"name": "bash", "command": f"printf '{marker} tool_call\\n'"}],
+                [{"name": "__finish__"}],
+            ]
+        )
+    elif scenario.recipe.gateway_mode == "recover_bad_json":
+        cfg.update(
+            mode="recover_bad_json",
+            command=f"printf '{marker} recovered\\n' | tee bad_args.marker",
+        )
+    if len(scenario.recipe.input_lines) > 1 and cfg.get("mode") == "normal":
+        # A point that types more than one line needs each turn to *end*.  The
+        # standing tool call of the plain mode is answered the same way every
+        # round, so an unattended session repeats it until its step budget is
+        # gone - and the later lines, which are what the point is about, are
+        # typed into a session with nothing left to spend.  One tool call then
+        # a plain reply bounds each turn without changing what any single-line
+        # point observes.
+        cfg.update(
+            mode="seq_probe",
+            rounds=[
+                [{"name": "bash", "command": cfg.get("command") or "true"}],
+                [{"name": "__finish__"}],
+            ] * (len(scenario.recipe.input_lines) + 2),
+        )
+    return cfg
+
+
+__all__ = ["tui_gateway_config"]
diff --git a/code/src/stage1/.dockerignore b/code/src/stage1/.dockerignore
new file mode 100644
index 0000000000000000000000000000000000000000..18898a03a5e43bcf2b8f9971ddfbd2457a497540
--- /dev/null
+++ b/code/src/stage1/.dockerignore
@@ -0,0 +1,7 @@
+# docker build context = src/stage1. The builder image needs only f0_clean/; everything
+# else is evaluation/spec material and stays out of the image.
+*
+!f0_clean
+!f0_clean/**
+**/__pycache__
+**/*.pyc
diff --git a/code/src/stage1/README.md b/code/src/stage1/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..69093e40294a1395e3925d59bcea6c60563b37b5
--- /dev/null
+++ b/code/src/stage1/README.md
@@ -0,0 +1,86 @@
+# stage1 — the product build pipeline
+
+stage1 has a model build a harness product through OpenCode, following a
+functional specification. stage2 (`doc2harness`) then scores that product. The
+two are independent: **scoring an existing product needs only stage2**; you need
+stage1 only to build a new one.
+
+Two runtime inputs are **not** distributed with this repository. Supply them
+yourself:
+
+| Input | What it is | How to supply it |
+|---|---|---|
+| Builder image | Self-contained: the OpenCode binary plus the hollowed product skeleton at `/opt/f0`. Needs no network at run time. | `docker pull ghcr.io/yuyaoge/doc2harness-builder:latest` (the default). To build it yourself: `docker build -f src/stage1/assets/Dockerfile -t ghcr.io/yuyaoge/doc2harness-builder:latest src/stage1` (that tag is the default; any other needs `--image` or `D2A_BUILDER_IMAGE`). |
+| Model gateway | A local OpenAI-compatible gateway holding **your** API key. | Copy the templates in [`gateway.example/`](gateway.example/), fill in your endpoint and key, and point `D2A_STAGE1_CFG` at your copy. See below. |
+
+Contract names are fixed and must not be renamed — `D2A_*`, `yuyao`,
+`.d2a_spec`, `run_agent.sh`, `entry.py`, `mini`. Renaming them breaks products.
+
+## Setting up the gateway
+
+The pipeline is deliberately model-agnostic: OpenCode sees exactly one model
+alias, named `builder`, so the model being evaluated never learns which upstream
+it is talking to. Any OpenAI-compatible endpoint works.
+
+```bash
+cp -r src/stage1/gateway.example /your/private/path/gateway
+$EDITOR /your/private/path/gateway/litellm.config.yaml   # your endpoint + key
+export D2A_STAGE1_CFG=/your/private/path/gateway/litellm.config.yaml
+export D2A_GATEWAY_KEY=sk-your-local-gateway-key
+bash /your/private/path/gateway/start_gateway.sh
+```
+
+Two things must line up, and `run_build` fails closed if they do not: the
+gateway port (`--gateway-port`, default 4000, or `D2A_GATEWAY_PORT`) and the
+`baseURL` in `src/stage1/opencode_profile/opencode.json`.
+
+`D2A_GATEWAY_KEY` is a local credential that the build container presents to
+your gateway. Your real upstream key stays on the host, in the gateway config,
+and never enters the container.
+
+## A. Score an existing product (stage2 only)
+
+A product is a directory containing `src/yuyao/` — typically `<run>/agent`.
+
+```bash
+# full catalog (94 scenarios; omit --ids-file to select all of them)
+PYTHONPATH=src:tools:run python3 tools/run_production_catalog.py \
+  --artifact <product dir> --artifact-id <name> \
+  --output <output dir> --concurrency 12 --timeout 300
+
+# a subset: --family permission  or  --scenario-id <id>
+```
+
+Each per-scenario JSON carries `events[*].judgement` with `outcome` and
+`applicability`. The score is applicability-first pass-over-applicable:
+`pass / (pass + fail)`.
+
+> Evaluation containers clean themselves up on a normal exit, but a run that is
+> killed or interrupted leaves orphans behind. For long parallel runs, keep a
+> janitor that periodically removes `ancestor=doc2harness/evaluation:candidate`
+> containers older than the scenario timeout, and sweep once at the end.
+
+## B. Build a new product, then score it
+
+```bash
+# 1) dry run first: prints the full orchestration plan, starts no container,
+#    calls no model, costs nothing, and needs no gateway or key
+PYTHONPATH=src python3 src/stage1/run_build.py --builder-tag <name> --dry-run
+
+# 2) the real build (needs the image and a running gateway)
+PYTHONPATH=src python3 src/stage1/run_build.py --builder-tag <name> \
+  --out-dir <results dir>
+
+# 3) score <results dir>/<run_id>/agent with flow A above
+```
+
+A build takes roughly 15 minutes, depending on the model.
+
+> The builder image already bakes the hollowed skeleton into `/opt/f0` —
+> contract sockets only — so you do not need `--f0-src`. Pass `--f0-src` only to
+> substitute a different base.
+
+## Dependencies
+
+None. stage1 is standard library only, same as the evaluation core — building a
+product needs Python 3.11+ and Docker and nothing else.
diff --git a/code/src/stage1/__init__.py b/code/src/stage1/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..0fec0f280d3c233e565628387483f652a3e0f3b7
--- /dev/null
+++ b/code/src/stage1/__init__.py
@@ -0,0 +1,9 @@
+"""stage1: build pipeline where a model + opencode produce a harness artifact.
+
+Entry point: run_build.py.
+Artifact acceptance gates live in smoke/ (docker cp'd into the container at
+build time); specs/contracts in spec/ and contract/.
+
+Standard library only, like the stage2 evaluation core: building a product needs
+Python 3.11+ and Docker and nothing else.
+"""
diff --git a/code/src/stage1/assets/Dockerfile b/code/src/stage1/assets/Dockerfile
new file mode 100644
index 0000000000000000000000000000000000000000..91e7c23f02ff6bbc1e9b1717a471e79967544c60
--- /dev/null
+++ b/code/src/stage1/assets/Dockerfile
@@ -0,0 +1,46 @@
+# stage1 builder image (build sandbox, built once and reused across all builders):
+# OpenCode + python/git + the product skeleton (f0).
+#
+# Bakes the hollowed skeleton straight into /opt/f0: contract sockets only, no kernel
+# sources, no pip-installed mini. The builder implements from scratch against the contract
+# in /opt/f0/.d2a_spec.
+#
+# Carries no evaluation scenario content (the scenarios are held out from the build); the
+# model reaches the provider only through the gateway (no upstream credentials in the
+# container).
+#
+# build:  docker build -f src/stage1/assets/Dockerfile \
+#             -t ghcr.io/yuyaoge/doc2harness-builder:latest src/stage1
+#         Tagging it anything else means passing --image or setting D2A_BUILDER_IMAGE,
+#         since that tag is run_build.py's default.
+# Note: a real build needs network access to install opencode; run_build.py --dry-run does
+# not depend on this image.
+FROM python:3.12-slim
+
+ENV DEBIAN_FRONTEND=noninteractive
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+        git curl ca-certificates bash unzip ripgrep \
+        iptables iproute2 dnsutils \
+    && rm -rf /var/lib/apt/lists/*
+# ripgrep: OpenCode's built-in glob/grep tools invoke `rg` directly; without it every
+# project-wide search fails with `ripgrep execution failed`.
+# iptables/iproute2/dnsutils: let run_build.py --egress gateway-only restrict egress inside
+# the container to the local gateway only (blocking github/pypi so a builder cannot reach
+# outside help). Requires docker run --cap-add=NET_ADMIN.
+
+# OpenCode (official install script -> /root/.opencode/bin/opencode, matching
+# run_build.py's OPENCODE_BIN).
+# VERSION must be pinned: unpinned, the script queries api.github.com for the latest
+# release, and that API is frequently rate-limited inside a build container.
+# The version below tracks the npm registry entry opencode-ai/latest.
+ARG OPENCODE_VERSION=1.17.0
+RUN curl -fsSL https://opencode.ai/install | VERSION=${OPENCODE_VERSION} bash \
+    && /root/.opencode/bin/opencode --version
+
+# The hollowed product skeleton (8 files, contract sockets that only
+# `raise NotImplementedError`) -> /opt/f0.
+COPY f0_clean/ /opt/f0/
+RUN find /opt/f0 -name __pycache__ -type d -prune -exec rm -rf {} + 2>/dev/null || true
+
+WORKDIR /opt/f0
diff --git a/code/src/stage1/assets/build_prompt-v2.md b/code/src/stage1/assets/build_prompt-v2.md
new file mode 100644
index 0000000000000000000000000000000000000000..09839340aa9026d08ad725e941b36171e12adccb
--- /dev/null
+++ b/code/src/stage1/assets/build_prompt-v2.md
@@ -0,0 +1,96 @@
+# Build task
+
+The working directory `/opt/f0` contains an empty project: package layout, entry
+point shells, and interface signatures are present, but the function bodies are
+unimplemented. Read `.d2a_spec/functional_spec.md` (the functional
+specification) and `.d2a_spec/AGENT_CONTRACT.md` (the entry-point contract),
+then build the coding agent those documents describe, in place, under `/opt/f0`.
+
+## Requirements
+
+1. **Modify the sources in `/opt/f0` in place.** Do not create a separate
+   project and do not write code elsewhere.
+2. **Implement every capability in `.d2a_spec/functional_spec.md`**: the built-in
+   tools, top-level commands, permission and role modes, global flags, in-session
+   slash commands and keyboard shortcuts, the persistent memory system, the
+   convention files, and the exit codes.
+3. You are free to restructure the architecture and to add improvements of your
+   own — context management, error handling, prompt engineering, and so on.
+
+## Deliverables
+
+See `.d2a_spec/functional_spec.md` §0.1. All of the following are required:
+
+- **`/opt/f0/install.sh`** — a single-command install, after which the `yuyao`
+  command is available. Any new third-party dependency must be declared in
+  `[project.dependencies]` in `pyproject.toml` (or in `requirements.txt`); the
+  runtime environment is offline, so an undeclared dependency fails at import.
+- **An interactive TUI** — `yuyao` starts an interactive session supporting the
+  slash commands and shortcuts in §5 of the specification.
+- **A headless form, `yuyao -p "<task>"` (`--print`)** — does not enter the
+  REPL, runs the task to termination, writes the result to stdout, exits with the
+  codes defined in §9, and accepts the global flags in §4.
+- **`/opt/f0/run_agent.sh`** — drives the headless entry point `entry.py`
+  unattended, through the interface defined by `.d2a_spec/AGENT_CONTRACT.md` and
+  §0.1.1 of the specification.
+
+  Note that `run_agent.sh` and `entry.py` must be self-contained and runnable as
+  shipped. The directory is copied verbatim into a clean container and invoked
+  directly with `bash run_agent.sh …`: **`install.sh` is not run first, no `pip
+  install` occurs, and `PYTHONPATH` is empty.** `entry.py` must therefore put its
+  own source root on `sys.path` itself — for example
+  `sys.path.insert(0, os.path.join(os.path.dirname(__file__), "src"))` before
+  importing your package — and must not assume the package is installed or that
+  `PYTHONPATH` is set externally. Verify this in a fresh shell with nothing
+  installed and `PYTHONPATH` unset.
+
+- **`yuyao.agent_api`** — see §0.1.2 of the specification.
+
+## Model access
+
+Model connectivity is supplied through the environment variables
+`D2A_MODEL_BASE_URL`, `D2A_MODEL_NAME`, and `D2A_MODEL_API_KEY` (see §0.2).
+Calls must go through that endpoint only; no other address or credential may be
+hardcoded. Cost accounting rates are injected through `D2A_MODEL_COST`.
+
+`.d2a_spec/model_call_reference.py` shows the calling convention and can be
+reused directly. Before building, running `python .d2a_spec/model_call_reference.py`
+performs a round-trip smoke test to confirm connectivity.
+
+When those variables are already present in the environment, the TUI must read
+them at startup and connect without further configuration.
+
+## Naming
+
+The product is named `yuyao agent` and its command is `yuyao`. No user-visible
+surface may mention `mini` or carry a non-English product name — this includes
+the startup banner, window titles, help output, the prompt, the version string,
+and configuration and history file paths. Internal module names may retain their
+internal package name. The kernel's own startup banner must be suppressed (for
+example by setting `MSWEA_SILENT_STARTUP=1`). For the README and architecture
+document, see §0.5.
+
+## Submission
+
+Before submitting, perform a real install and a real run in a clean environment:
+`install.sh` completes, `yuyao` enters an interactive session and completes one
+task against the live model, and `run_agent.sh` solves a small task unattended in
+a toy repository. Perform the headless run in a clean shell — for example
+`env -u PYTHONPATH bash run_agent.sh …`.
+
+> You have {{MAX_SUBMISSIONS}} submissions in total. Each `touch .build-submit`
+> consumes one. When they are exhausted, the build ends with whatever the
+> artifact is at that moment.
+
+1. Confirm that `/opt/f0/run_agent.sh` exists, is executable, and is
+   syntactically valid under `bash -n`.
+2. Run `touch /opt/f0/.build-submit`.
+3. The system validates the artifact and writes the result to
+   `/opt/f0/.build-result` as JSON: `contract_ok`, plus a `hint` describing what
+   to address when validation fails. While validation is in progress the marker
+   `/opt/f0/.build-checking` is present; **as long as it exists the check is
+   still running, so do not `touch .build-submit` again.** Poll `.build-result`
+   every 20–30 seconds, and continue improving the code while you wait.
+4. If `contract_ok=false`, address the `hint`, then `rm /opt/f0/.build-result`
+   and `touch /opt/f0/.build-submit` again.
+5. `contract_ok=true` ends the build.
diff --git a/code/src/stage1/assets/try_agent.sh b/code/src/stage1/assets/try_agent.sh
new file mode 100644
index 0000000000000000000000000000000000000000..2bd2feabe0b87adb27c7da205da1a4ffe285af73
--- /dev/null
+++ b/code/src/stage1/assets/try_agent.sh
@@ -0,0 +1,129 @@
+#!/usr/bin/env bash
+# Run a stage1-built product against a live model backend, either in the
+# interactive TUI or as a one-shot headless prompt.
+#
+#   ./try_agent.sh --list                       # list products under results/stage1
+#   ./try_agent.sh -a <run-id>                  # pick a product (run-id or directory)
+#   ./try_agent.sh -a <run-id> --port 4000      # pick the backend gateway port
+#   ./try_agent.sh -p "fix the bug in calc.py"  # one-shot headless (adds --mode yolo)
+#   ./try_agent.sh -w ~/mycode -p "add a test"  # mount your own directory as the workspace
+#   ./try_agent.sh --clean                      # remove the container
+#
+# Notes:
+#   * The product runs in the same image used to build it, installing its
+#     dependencies offline from the wheels it ships with. Products are built to
+#     the contract "copy into a clean container and run".
+#   * The backend is a LiteLLM gateway already running on the host, reached from
+#     the container via --add-host. The gateway must expose one model alias named
+#     `builder`. Set the port with --port or D2A_GATEWAY_PORT.
+set -uo pipefail
+
+# Repository root. This script lives in src/stage1/assets/, so go up three
+# levels.
+REPO="$(cd "$(dirname "${BASH_SOURCE[0]}")/../../.." && pwd)"
+RESULTS="${D2A_RESULTS_DIR:-$REPO/results/stage1}"
+IMAGE="${D2A_BUILDER_IMAGE:-ghcr.io/yuyaoge/doc2harness-builder:latest}"
+CONTAINER="yuyao-try"
+GW_KEY="${D2A_GATEWAY_KEY:-sk-d2a-local-master}"
+
+AGENT_ARG=""        # run-id or product directory; empty means the newest build
+PORT="${D2A_GATEWAY_PORT:-4000}"
+PROMPT=""           # non-empty means one-shot headless
+WORKDIR=""          # host directory to mount as the workspace
+
+usage() { sed -n '2,18p' "${BASH_SOURCE[0]}" | sed 's/^# \{0,1\}//'; }
+
+list() {
+  echo "Products in $RESULTS:"
+  local found=0
+  for d in "$RESULTS"/*/agent; do
+    [ -f "$d/run_agent.sh" ] || continue
+    found=1
+    printf "  %-24s %s\n" "$(basename "$(dirname "$d")")" "$d"
+  done
+  [ "$found" -eq 1 ] || echo "  (none; run run_build.py, or point D2A_RESULTS_DIR elsewhere)"
+  echo
+  echo "Backend gateway: --port <port> (currently :$PORT); must expose the \`builder\` alias."
+  ss -lntp 2>/dev/null | grep -q ":$PORT " \
+    && echo "  :$PORT up" || echo "  :$PORT not running"
+}
+
+while [ $# -gt 0 ]; do
+  case "$1" in
+    -a|--agent)    AGENT_ARG="$2"; shift 2 ;;
+    --port)        PORT="$2"; shift 2 ;;
+    -p|--prompt)   PROMPT="$2"; shift 2 ;;
+    -w|--workdir)  WORKDIR="$2"; shift 2 ;;
+    --list)        list; exit 0 ;;
+    --clean)       docker rm -f "$CONTAINER" >/dev/null 2>&1 && echo "removed container $CONTAINER"; exit 0 ;;
+    -h|--help)     usage; exit 0 ;;
+    *) echo "unknown argument $1 (see -h)"; exit 1 ;;
+  esac
+done
+
+# Accept a product directory, a run directory, a run-id, or nothing (newest).
+if [ -z "$AGENT_ARG" ]; then
+  AGENT_DIR="$(ls -td "$RESULTS"/*/agent 2>/dev/null | head -1)"
+elif [ -f "$AGENT_ARG/run_agent.sh" ]; then
+  AGENT_DIR="$AGENT_ARG"
+elif [ -f "$AGENT_ARG/agent/run_agent.sh" ]; then
+  AGENT_DIR="$AGENT_ARG/agent"
+elif [ "${AGENT_ARG#/}" != "$AGENT_ARG" ] || [ -d "$AGENT_ARG" ]; then
+  # An absolute path, or an existing directory, was meant literally: do not treat it as a
+  # run-id and paste it after $RESULTS, which produced paths like results/stage1//abs/path/agent.
+  AGENT_DIR="$AGENT_ARG"
+else
+  AGENT_DIR="$RESULTS/$AGENT_ARG/agent"
+fi
+
+[ -n "${AGENT_DIR:-}" ] && [ -f "$AGENT_DIR/run_agent.sh" ] || {
+  echo "no product found: '${AGENT_ARG:-<newest>}' -> '${AGENT_DIR:-}'"
+  echo "  try --list, or -a <product dir>, or run run_build.py first"
+  exit 1
+}
+AGENT_DIR="$(cd "$AGENT_DIR" && pwd)"
+
+ss -lntp 2>/dev/null | grep -q ":$PORT " || {
+  echo "no gateway on :$PORT. Start a LiteLLM gateway exposing the \`builder\` alias:"
+  echo "    D2A_GATEWAY_PORT=$PORT D2A_STAGE1_CFG=<your litellm config> \\"
+  echo "      bash src/stage1/gateway.example/start_gateway.sh"
+  echo "  (the config holding real keys is not shipped; see src/stage1/README.md)"
+  exit 1
+}
+
+echo "== product: $AGENT_DIR   backend: :$PORT =="
+
+# Reuse a running container; mount the product read-only so it cannot be edited.
+if docker ps --format '{{.Names}}' | grep -qx "$CONTAINER"; then
+  echo "-- reusing the running container (use --clean to switch products)"
+else
+  docker rm -f "$CONTAINER" >/dev/null 2>&1
+  MOUNTS=(-v "$AGENT_DIR:/opt/agent")
+  [ -n "$WORKDIR" ] && MOUNTS+=(-v "$(cd "$WORKDIR" && pwd):/work")
+  docker run --rm -d --name "$CONTAINER" \
+    --add-host=host.docker.internal:host-gateway \
+    "${MOUNTS[@]}" -w /opt/agent "$IMAGE" tail -f /dev/null >/dev/null || exit 1
+  echo "-- installing product dependencies offline from its bundled wheels"
+  # install.sh ships without the executable bit, so invoke it through bash.
+  docker exec "$CONTAINER" bash -lc "cd /opt/agent && bash install.sh" >/tmp/try_agent_install.log 2>&1 || {
+    echo "install failed, see /tmp/try_agent_install.log"; tail -12 /tmp/try_agent_install.log; exit 1; }
+  docker exec "$CONTAINER" bash -lc 'command -v yuyao >/dev/null && yuyao --version' \
+    | sed 's/^/   /' || { echo "yuyao did not install"; exit 1; }
+fi
+
+ENVS=(-e "D2A_MODEL_BASE_URL=http://host.docker.internal:$PORT"
+      -e "D2A_MODEL_NAME=litellm_proxy/builder"
+      -e "D2A_MODEL_API_KEY=$GW_KEY")
+CWD="/work"
+[ -n "$WORKDIR" ] || { docker exec "$CONTAINER" bash -lc 'mkdir -p /work' >/dev/null; }
+
+if [ -n "$PROMPT" ]; then
+  # Headless needs --mode yolo, or the agent waits for a confirmation that never
+  # comes and only offers suggestions instead of acting.
+  echo "-- headless run (--mode yolo)"
+  docker exec "${ENVS[@]}" "$CONTAINER" bash -lc \
+    "cd $CWD && yuyao -p $(printf '%q' "$PROMPT") --mode yolo"
+else
+  echo "-- interactive TUI (workspace $CWD${WORKDIR:+ <- $WORKDIR}); container persists, use --clean"
+  docker exec -it "${ENVS[@]}" "$CONTAINER" bash -lc "cd $CWD && yuyao"
+fi
diff --git a/code/src/stage1/build_scripts/cmd_scan.py b/code/src/stage1/build_scripts/cmd_scan.py
new file mode 100644
index 0000000000000000000000000000000000000000..34041cf68639badbbef70b80d4e7caae74e9454a
--- /dev/null
+++ b/code/src/stage1/build_scripts/cmd_scan.py
@@ -0,0 +1,171 @@
+
+import ast, os, re
+root = "{f0}"
+GROUPS = [
+    ["/undo"], ["/redo"], ["/rewind","/checkpoint"], ["/compact","/compress"], ["/plan"], ["/ask"],
+    ["/debug"], ["/mode"], ["/role"], ["/diff"], ["/review"], ["/security-review"], ["/run"], ["/copy"],
+    ["/focus"], ["/tui"], ["/config","/settings"], ["/background","/bg"], ["/init"], ["/memory"], ["/tools"],
+    ["/recap"], ["/context"], ["/model"], ["/new"], ["/clear","/reset"], ["/sessions","/resume"],
+    ["/title","/rename"], ["/status"], ["/export"], ["/add-dir"], ["/cd"], ["/permissions"], ["/hooks"],
+    ["/mcp"], ["/agents"], ["/help"], ["/exit","/quit"],
+    ["/goal"], ["/loop"], ["/fork"], ["/branch"], ["/btw","/side"], ["/verify"], ["/batch"],
+    ["/workflows","/workflow"], ["/skills","/skill"], ["/flow:"], ["/queue"], ["/tasks","/bashes"],
+    ["/think"], ["/show-thinking"], ["/stream"], ["/usage"],
+]
+SKIP = {".d2a_spec", "__pycache__", ".git", "node_modules", ".venv", "minisweagent", ".pytest_cache", ".mypy_cache"}
+
+# Two views of the same sources.
+#   code_blob   -- comments and docstrings removed, so a command named only in
+#                  prose does not count as implemented.  This is the load-bearing
+#                  one: scanning raw text would let a product whose entire content
+#                  is a help-text docstring listing every command score zero
+#                  missing, and `all_commands_present` is one of the checks the
+#                  basic gate requires.
+#   prose_blob  -- the removed material, reported separately.  A command that
+#                  appears only there is named but not dispatched; saying so is
+#                  more useful than a bare "missing".
+code_chunks, prose_chunks = [], []
+
+
+def split_code_and_prose(text):
+    """Return (code, prose) for one module: prose is comments plus docstrings.
+
+    Falls back to treating everything as code when the file does not parse -- a
+    syntax error is caught by source_compiles, and guessing here could only
+    manufacture a false missing.
+    """
+    try:
+        tree = ast.parse(text)
+    except SyntaxError:
+        return text, ""
+
+    prose = []
+    # Docstrings: the string expression leading a module, class or function body.
+    for node in ast.walk(tree):
+        if not isinstance(node, (ast.Module, ast.ClassDef, ast.FunctionDef, ast.AsyncFunctionDef)):
+            continue
+        body = getattr(node, "body", None) or []
+        if not body:
+            continue
+        first = body[0]
+        if (isinstance(first, ast.Expr) and isinstance(first.value, ast.Constant)
+                and isinstance(first.value.value, str)):
+            prose.append(first.value.value)
+
+    lines = text.splitlines(keepends=True)
+    # Blank out docstring spans and comments, leaving line structure intact so a
+    # later regex cannot accidentally join two unrelated lines.
+    blanked = list(lines)
+    for node in ast.walk(tree):
+        if not isinstance(node, (ast.Module, ast.ClassDef, ast.FunctionDef, ast.AsyncFunctionDef)):
+            continue
+        body = getattr(node, "body", None) or []
+        if not body:
+            continue
+        first = body[0]
+        if not (isinstance(first, ast.Expr) and isinstance(first.value, ast.Constant)
+                and isinstance(first.value.value, str)):
+            continue
+        start = getattr(first, "lineno", None)
+        end = getattr(first, "end_lineno", None)
+        if start is None or end is None:
+            continue
+        for index in range(start - 1, min(end, len(blanked))):
+            blanked[index] = "\n"
+
+    code = []
+    for line in blanked:
+        # Strip trailing comments, but only when the '#' is not inside a string.
+        # Counting unescaped quotes is enough here: the goal is to avoid cutting a
+        # literal such as "/tag#1", not to reimplement the tokenizer.
+        cut = None
+        in_single = in_double = False
+        index = 0
+        while index < len(line):
+            char = line[index]
+            if char == "\\":
+                index += 2
+                continue
+            if char == "'" and not in_double:
+                in_single = not in_single
+            elif char == '"' and not in_single:
+                in_double = not in_double
+            elif char == "#" and not in_single and not in_double:
+                cut = index
+                break
+            index += 1
+        if cut is not None:
+            prose.append(line[cut:])
+            line = line[:cut] + "\n"
+        code.append(line)
+    return "".join(code), "\n".join(prose)
+
+
+for dp, dns, fns in os.walk(root):
+    dns[:] = [d for d in dns if d not in SKIP]
+    for fn in fns:
+        if fn.endswith(".py"):
+            try:
+                with open(os.path.join(dp, fn), encoding="utf-8", errors="replace") as handle:
+                    text = handle.read()
+            except Exception:
+                continue
+            code, prose = split_code_and_prose(text)
+            code_chunks.append(code)
+            prose_chunks.append(prose)
+
+blob = "\n".join(code_chunks)
+prose_blob = "\n".join(prose_chunks)
+missing = []
+prose_only = []
+for g in GROUPS:
+    present = False
+    named_in_prose = False
+    for tok in g:
+        # A prefix command such as `/flow:` is written `/flow:<name>` in real
+        # use, so the token is followed by a word character rather than
+        # terminated.  Applying the "not followed by a word character" lookahead
+        # to it asks for the one form that never appears in working code.
+        prefix_form = tok.endswith(":")
+        literal = re.escape(tok) if prefix_form else re.escape(tok) + r"(?![\w-])"
+
+        # (a) Literal `/cmd`: enumerated implementations (help text held in a data
+        #     structure, elif cmd == "/x", handler-table keys that include the slash).
+        if re.search(literal, blob):
+            present = True
+            break
+        # (b) A `cmd_<name>` handler definition or reference: name-dispatched
+        #     implementations strip the leading '/' and build `cmd_<name>`, so the
+        #     literal `/cmd` may never appear in the source, yet `def cmd_recap`
+        #     means the command is genuinely reachable.
+        #     name = drop the leading '/', drop a trailing ':', map '-' to '_'.
+        #     Strong signal with near-zero false positives: the `cmd_` prefix is a
+        #     command-only convention.
+        #     The leading boundary must also admit `_cmd_flow`: `\b` does not match
+        #     between '_' and 'c' because '_' is a word character, so a private
+        #     handler -- an extremely common way to write these -- would go undetected.
+        name = tok[1:].rstrip(":").replace("-", "_")
+        if name and re.search(r"(?:\b|_)cmd_" + re.escape(name) + r"\b", blob):
+            present = True
+            break
+        # (c) Prefix commands are also dispatched by testing the bare prefix
+        #     against the command name, with the slash already stripped:
+        #     `if name.startswith("flow:")`.  That is a real implementation and
+        #     carries no slash, so neither (a) nor (b) can see it.
+        if prefix_form and re.search(
+                r"""["']""" + re.escape(tok[1:]) + r"""["']""", blob):
+            present = True
+            break
+        if re.search(literal, prose_blob):
+            named_in_prose = True
+    if not present:
+        missing.append(g[0])
+        if named_in_prose:
+            prose_only.append(g[0])
+print("MISSING_COUNT=%d" % len(missing))
+for m in missing:
+    print("MISSING::" + m)
+# Reported so a build's hint can say "documented but not dispatched" rather than
+# "missing", which is a different and more actionable defect.
+for m in prose_only:
+    print("PROSE_ONLY::" + m)
diff --git a/code/src/stage1/build_scripts/func_smoke.py b/code/src/stage1/build_scripts/func_smoke.py
new file mode 100644
index 0000000000000000000000000000000000000000..33d56194211a6f4ca3e98b0bf4dea0b4da5a1aea
--- /dev/null
+++ b/code/src/stage1/build_scripts/func_smoke.py
@@ -0,0 +1,3102 @@
+import glob, json, os, subprocess, tempfile, threading
+
+F0 = "/opt/f0"
+RAS = F0 + "/run_agent.sh"
+base = os.environ.get("D2A_MODEL_BASE_URL", "")
+mname = os.environ.get("D2A_MODEL_NAME", "")
+key = os.environ.get("D2A_MODEL_API_KEY", "")
+_NB = json.dumps(
+    {
+        "cells": [
+            {"cell_type": "markdown", "metadata": {}, "source": ["# MD-KEEP-TOP\n"]},
+            {
+                "cell_type": "code",
+                "metadata": {},
+                "execution_count": None,
+                "outputs": [],
+                "source": ["print('FIRST-KEEP')\n"],
+            },
+            {
+                "cell_type": "code",
+                "metadata": {},
+                "execution_count": None,
+                "outputs": [],
+                "source": ["print('OLD-MIDDLE')\n"],
+            },
+            {
+                "cell_type": "code",
+                "metadata": {},
+                "execution_count": None,
+                "outputs": [],
+                "source": ["print('THIRD-KEEP')\n"],
+            },
+            {"cell_type": "markdown", "metadata": {}, "source": ["## MD-KEEP-BOTTOM\n"]},
+        ],
+        "metadata": {},
+        "nbformat": 4,
+        "nbformat_minor": 5,
+    }
+)
+_BIG = "".join(
+    ("MARKER-L1500 please-change-me\n" if i == 1500 else "line %04d filler text\n" % i for i in range(2000))
+)
+_BIGCRLF = "".join(("crlf line %04d\r\n" % i for i in range(600)))
+_GREP_NEEDLE_FILES = {"f037.txt", "f137.txt", "f199.txt"}
+_GREP_SEED = {
+    "f%03d.txt"
+    % i: "NEEDLE-7731-XYZ\n" if "f%03d.txt" % i in _GREP_NEEDLE_FILES else "filler line %03d\n" % i
+    for i in range(200)
+}
+_HUGE = "X" * 2000000 + "ENDMARK-7731"
+TESTS = [
+    {
+        "id": "file_ops",
+        "seed": {
+            "config.txt": "name = alpha\nvalue = OLDVAL\nflag = true\n",
+            "data.txt": "FIRSTLINE-AAA\n",
+            "obsolete.txt": "junk\n",
+            "keep.txt": "KEEPME-3344\n",
+            "movable.txt": "MOVE-ME-5150\n",
+        },
+        "turns": [
+            {
+                "task": "Do ALL of the following in this repository, then stop:\n1) Create a file at path logs/app.log (create the logs directory if needed) with content exactly: STARTED-7788\n2) In config.txt, change OLDVAL to NEWVAL (keep the rest of the file).\n3) Append a new line containing SECONDLINE-BBB to data.txt (keep its existing content).\n4) Delete the file obsolete.txt. Do NOT touch keep.txt.\n5) MOVE movable.txt into a new subdirectory archive/ AND rename it, so it ends up at archive/moved.txt with its original content preserved; movable.txt must no longer exist at the top level."
+            }
+        ],
+        "checks": [
+            {"file": "logs/app.log", "contains": ["STARTED-7788"]},
+            {"file": "config.txt", "contains": ["NEWVAL"], "absent": ["OLDVAL"]},
+            {"file": "data.txt", "contains": ["FIRSTLINE-AAA", "SECONDLINE-BBB"]},
+            {"deleted": "obsolete.txt"},
+            {"file": "keep.txt", "contains": ["KEEPME-3344"]},
+            {"file": "archive/moved.txt", "contains": ["MOVE-ME-5150"]},
+            {"deleted": "movable.txt"},
+        ],
+    },
+    {
+        "id": "search_replace",
+        "seed": {
+            "a.py": "x = ALPHA\n",
+            "b.py": "y = ALPHA\n",
+            "c.txt": "z: ALPHA\n",
+            "notes.txt": "TODO fix\nok\nTODO test\nTODO ship\ndone\n",
+        },
+        "turns": [
+            {
+                "task": "Do BOTH, then stop:\n1) Replace every occurrence of ALPHA with OMEGA in all files in the repository.\n2) Count how many lines in notes.txt contain the word TODO, and write just that number (digits only) into count.txt."
+            }
+        ],
+        "checks": [
+            {"file": "a.py", "contains": ["OMEGA"], "absent": ["ALPHA"]},
+            {"file": "b.py", "contains": ["OMEGA"], "absent": ["ALPHA"]},
+            {"file": "c.txt", "contains": ["OMEGA"], "absent": ["ALPHA"]},
+        ],
+        "verify_cmd": [
+            "python",
+            "-c",
+            "c=open('count.txt',encoding='utf-8').read().strip(); assert c=='3', ('count.txt must be exactly 3', repr(c)); print('VOK')",
+        ],
+    },
+    {
+        "id": "bugfix",
+        "seed": {
+            "calc.py": "def add(a, b):\n    return a - b\n",
+            "test_calc.py": "from calc import add\n\nif __name__ == '__main__':\n    assert add(2, 3) == 5\n    print('OK')\n",
+        },
+        "turns": [
+            {
+                "task": "There is a bug in calc.py: add() returns the wrong result. Fix calc.py so that add() returns the sum of its two arguments, then run the test to confirm. Do not modify the test file."
+            }
+        ],
+        "verify_cmd": [
+            "python",
+            "-c",
+            "import sys; sys.path.insert(0, '.'); import calc; assert calc.add(2,3)==5 and calc.add(10,20)==30; print('VOK')",
+        ],
+    },
+    {
+        "id": "iter_fix_until_all_green",
+        "seed": {
+            "calc.py": "def add(a, b):\n    return a - b\n\n\ndef mul(a, b):\n    return a + b\n",
+            "test_calc.py": "from calc import add, mul\n\nif __name__ == '__main__':\n    assert add(2, 3) == 5\n    assert mul(2, 3) == 6\n    print('OK')\n",
+        },
+        "turns": [
+            {
+                "budget": {"max_steps": 18},
+                "task": "Run the test; it currently fails. Fix calc.py so that ALL assertions pass. Re-run the test after every change to confirm. Do NOT modify test_calc.py. When all tests pass, create FIXED.txt with content exactly: RAN-OK",
+            }
+        ],
+        "checks": [
+            {"file": "FIXED.txt", "contains": ["RAN-OK"]},
+            {"file": "test_calc.py", "contains": ["assert add(2, 3) == 5", "assert mul(2, 3) == 6"]},
+            {"status_not_error": True},
+        ],
+        "verify_cmd": [
+            "python",
+            "-c",
+            "import sys; sys.path.insert(0,'.'); import calc; assert calc.add(2,3)==5 and calc.add(-1,4)==3 and calc.mul(2,3)==6 and calc.mul(4,5)==20; print('VOK')",
+        ],
+    },
+    {
+        "id": "bugfix_forbidden_file_and_no_commit",
+        "seed": {
+            "AGENTS.md": "# Project rules\n- NEVER modify rates.py (it is auto-generated).\n- NEVER run `git commit`.\n",
+            "rates.py": "MULTIPLIER = 2",
+            "billing.py": "from rates import MULTIPLIER\n\n\ndef charge(x):\n    return x + MULTIPLIER\n",
+        },
+        "turns": [
+            {
+                "task": "charge() computes the wrong total. Fix it so that charge(5)==10 and charge(3)==6. Strictly obey AGENTS.md. When done, create NOTE.txt with content exactly: RAN-OK"
+            }
+        ],
+        "checks": [{"file": "NOTE.txt", "contains": ["RAN-OK"]}, {"status_not_error": True}],
+        "verify_cmd": [
+            "bash",
+            "-c",
+            'python -c "import sys;sys.path.insert(0,\'.\');import billing;assert billing.charge(5)==10 and billing.charge(3)==6" && test "$(cat rates.py)" = "MULTIPLIER = 2" && test "$(git rev-list --count HEAD)" = "1"',
+        ],
+    },
+    {
+        "id": "rename_preserve_string_literal_and_runs",
+        "seed": {
+            "pkg/__init__.py": "",
+            "pkg/core.py": 'def foo():\n    return 41\n\n\nLABEL = "foo"\n',
+            "pkg/use.py": "from pkg.core import foo\n\n\ndef run():\n    return foo() + 1\n",
+            "main.py": "import pkg.use as u\n\nprint(u.run())\n",
+        },
+        "turns": [
+            {
+                "task": 'Rename the FUNCTION foo to fetch everywhere: its definition in pkg/core.py and all code references (pkg/use.py). The string literal "foo" assigned to LABEL in core.py MUST stay exactly "foo" (do not touch it). When done, create RENAMED.txt with content exactly: RAN-OK'
+            }
+        ],
+        "checks": [{"file": "RENAMED.txt", "contains": ["RAN-OK"]}, {"status_not_error": True}],
+        "verify_cmd": [
+            "bash",
+            "-c",
+            "python -c \"import pkg.core as c;assert hasattr(c,'fetch') and not hasattr(c,'foo');assert c.LABEL=='foo'\" && python -c \"import pkg.use as u;assert u.run()==42\"",
+        ],
+    },
+    {
+        "id": "fix_new_bug_without_regressing_passing_test",
+        "seed": {
+            "strutil.py": "def slugify(s):\n    return s.strip().lower().replace(' ', '-')\n",
+            "test_empty.py": "from strutil import slugify\n\nif __name__ == '__main__':\n    assert slugify('') == ''\n    assert slugify('  a  b ') == 'a-b'\n    print('OK')\n",
+            "test_basic.py": "from strutil import slugify\n\nif __name__ == '__main__':\n    assert slugify('Hello World') == 'hello-world'\n    print('OK')\n",
+        },
+        "turns": [
+            {
+                "budget": {"max_steps": 18},
+                "task": "test_empty.py currently fails. Fix strutil.py so that ALL tests pass, including the already-passing test_basic.py. Re-run all tests after every change. Do NOT modify any test_*.py file. When all pass, create FIXED.txt with content exactly: RAN-OK",
+            }
+        ],
+        "checks": [
+            {"file": "FIXED.txt", "contains": ["RAN-OK"]},
+            {"file": "test_empty.py", "contains": ["slugify('') == ''"]},
+            {"file": "test_basic.py", "contains": ["slugify('Hello World') == 'hello-world'"]},
+            {"status_not_error": True},
+        ],
+        "verify_cmd": [
+            "python",
+            "-c",
+            "import sys;sys.path.insert(0,'.');import strutil as S;assert S.slugify('')=='' and S.slugify('  a  b ')=='a-b' and S.slugify('Hello World')=='hello-world' and S.slugify('  X  ')=='x'; print('VOK')",
+        ],
+    },
+    {
+        "id": "read_before_edit",
+        "seed": {"svc.py": "def foo():\n    return 1\n"},
+        "turns": [
+            {"task": "In svc.py, change function foo so it returns 100 instead of 1."},
+            {
+                "pre": {"file": "svc.py", "prepend": "# HUMAN_EDIT_KEEPME_5521\nimport os\n\n"},
+                "task": "Now add a NEW function named bar to svc.py that returns 200. Keep everything else in the file unchanged.",
+            },
+        ],
+        "checks": [{"file": "svc.py", "contains": ["HUMAN_EDIT_KEEPME_5521", "def bar", "200"]}],
+    },
+    {
+        "id": "status_submitted",
+        "seed": {},
+        "turns": [{"task": "Create a file done.txt with content exactly: STATUS-OK-1212"}],
+        "checks": [
+            {"file": "done.txt", "contains": ["STATUS-OK-1212"]},
+            {"status_has_cost": True},
+            {"status_not_error": True},
+        ],
+    },
+    {
+        "id": "limits_exceeded",
+        "seed": {"big.py": "# implement many functions\n"},
+        "turns": [
+            {
+                "budget": {"max_steps": 1, "max_tokens": 0, "max_wall_seconds": 120},
+                "task": "Implement a complete REST API server in big.py with at least 15 distinct endpoints, full input validation, an in-memory database layer, and unit tests for every endpoint. Keep working across many steps until everything is fully implemented and tested.",
+            }
+        ],
+        "checks": [{"status_contains": "limit"}],
+    },
+    {
+        "id": "cross_file_rename",
+        "seed": {
+            "pkg/core.py": "def foo():\n    return 1\n\n\ndef foo_helper():\n    return foo() + 1\n",
+            "pkg/sub/use.py": "from pkg.core import foo\nprint(foo())\n",
+            "main.py": "import pkg.core as c\nx = c.foo()\n",
+        },
+        "turns": [
+            {
+                "task": "Rename ONLY the function foo to compute everywhere in the repository: its definition in pkg/core.py and all references in pkg/sub/use.py and main.py. Do NOT rename foo_helper — it is a different function; keep its name, but it must still call the renamed function."
+            }
+        ],
+        "verify_cmd": [
+            "python",
+            "-c",
+            "core=open('pkg/core.py',encoding='utf-8').read(); u=open('pkg/sub/use.py',encoding='utf-8').read(); m=open('main.py',encoding='utf-8').read(); assert 'def compute(' in core and 'def foo(' not in core, ('def not renamed',core); assert 'def foo_helper(' in core, ('foo_helper clobbered',core); assert 'foo()' not in core, ('call in foo_helper not renamed',core); assert 'compute' in u and 'foo' not in u, ('ref use.py',u); assert 'c.compute()' in m and 'foo' not in m, ('ref main.py',m); print('VOK')",
+        ],
+    },
+    {
+        "id": "glob_find",
+        "seed": {
+            "m1.py": "#\n",
+            "pkg/m2.py": "#\n",
+            "pkg/sub/m3.py": "#\n",
+            "readme.txt": "x\n",
+            "pkg/data.json": "{}\n",
+        },
+        "turns": [
+            {
+                "task": "Recursively find ALL Python (.py) files anywhere in the repository, INCLUDING those in subdirectories, and write their base file names (one per line) into a file named files.txt."
+            }
+        ],
+        "checks": [
+            {
+                "file": "files.txt",
+                "contains": ["m1.py", "m2.py", "m3.py"],
+                "absent": ["readme.txt", "data.json"],
+            }
+        ],
+    },
+    {
+        "id": "apply_patch",
+        "seed": {"prog.py": "a = 1\nb = 2\nc = 3\n", "conf.py": "host = 'old'\nport = 1\n"},
+        "turns": [
+            {
+                "task": "Apply the following multi-file unified diff to the repository exactly (it changes b in prog.py AND host in conf.py):\n--- a/prog.py\n+++ b/prog.py\n@@ -1,3 +1,3 @@\n a = 1\n-b = 2\n+b = 20\n c = 3\n--- a/conf.py\n+++ b/conf.py\n@@ -1,2 +1,2 @@\n-host = 'old'\n+host = 'new'\n port = 1\n"
+            }
+        ],
+        "verify_cmd": [
+            "python",
+            "-c",
+            "p=open('prog.py',encoding='utf-8').read().splitlines(); q=open('conf.py',encoding='utf-8').read().splitlines(); assert 'b = 20' in p and 'b = 2' not in p, ('prog not patched', p); assert 'a = 1' in p and 'c = 3' in p, ('prog context clobbered', p); assert \"host = 'new'\" in q and \"host = 'old'\" not in q, ('conf not patched', q); assert 'port = 1' in q, ('conf context clobbered', q); print('VOK')",
+        ],
+    },
+    {
+        "id": "bad_patch_errors",
+        "seed": {"prog.py": "a = 1\nb = 2\nc = 3\n"},
+        "turns": [
+            {
+                "task": "Apply the following unified diff to prog.py. If it does NOT apply cleanly (the context does not match), do NOT modify prog.py at all — instead report that the patch failed.\n--- a/prog.py\n+++ b/prog.py\n@@ -1,3 +1,3 @@\n x = 999\n-y = 888\n+y = 777\n z = 0\n"
+            }
+        ],
+        "checks": [{"status_not_error": True}],
+        "verify_cmd": [
+            "python",
+            "-c",
+            "t=open('prog.py',encoding='utf-8').read(); assert t=='a = 1\\nb = 2\\nc = 3\\n', ('a bad patch must be refused and the file left byte-identical', repr(t)); print('VOK')",
+        ],
+    },
+    {
+        "id": "apply_patch_multihunk",
+        "seed": {
+            "svc.py": "name = 'svc'\nstatus = 'old'\nflag = True\ngap1 = 0\ngap2 = 0\ngap3 = 0\nflag = True\nlevel = 1\ntail = 'end'\n"
+        },
+        "turns": [
+            {
+                "task": "Apply this unified diff to svc.py exactly. It has TWO hunks for the SAME file; apply BOTH at their correct locations and change nothing else:\n--- a/svc.py\n+++ b/svc.py\n@@ -1,3 +1,3 @@\n name = 'svc'\n-status = 'old'\n+status = 'new'\n flag = True\n@@ -7,3 +7,3 @@\n flag = True\n-level = 1\n+level = 9\n tail = 'end'\n"
+            }
+        ],
+        "verify_cmd": [
+            "python",
+            "-c",
+            "ls=open('svc.py',encoding='utf-8').read().split('\\n'); assert \"status = 'new'\" in ls and \"status = 'old'\" not in ls, ('hunk1 not applied',ls); assert 'level = 9' in ls and 'level = 1' not in ls, ('hunk2 not applied',ls); assert ls.count('flag = True')==2, ('repeated-context line clobbered/duplicated',ls); assert ls[3:6]==['gap1 = 0','gap2 = 0','gap3 = 0'], ('untouched middle lines changed',ls); assert \"name = 'svc'\" in ls and \"tail = 'end'\" in ls, ('boundaries clobbered',ls); print('VOK')",
+        ],
+    },
+    {
+        "id": "bash_cd",
+        "seed": {},
+        "turns": [
+            {
+                "task": "Do ALL of the following, then stop:\n1) Create the deeply nested directory path a/b/c/d/e (create parent directories as needed) and a file at a/b/c/d/e/deep.txt with content exactly: DEEP-NEST-9.\n2) Also create a file at a/b/c/mid.txt with content exactly: MID-NEST-5.\n3) Also create a file at a/top.txt with content exactly: TOP-NEST-1.\n4) Also create a sibling directory a/b/x and a file a/b/x/sib.txt with content exactly: SIB-NEST-7."
+            }
+        ],
+        "checks": [
+            {"file": "a/b/c/d/e/deep.txt", "contains": ["DEEP-NEST-9"]},
+            {"file": "a/b/c/mid.txt", "contains": ["MID-NEST-5"]},
+            {"file": "a/top.txt", "contains": ["TOP-NEST-1"]},
+            {"file": "a/b/x/sib.txt", "contains": ["SIB-NEST-7"]},
+        ],
+    },
+    {
+        "id": "agents_convention",
+        "seed": {
+            "AGENTS.md": "# Project rules\n\nWhenever you create a new Python (.py) file, its FIRST line must be exactly:\n# MANAGED-BY-YUYAO\n"
+        },
+        "turns": [
+            {
+                "task": "Create a new Python file named greeter.py that defines a function hello() returning the string 'hi'."
+            }
+        ],
+        "checks": [{"file": "greeter.py", "contains": ["# MANAGED-BY-YUYAO", "def hello"]}],
+    },
+    {
+        "id": "edit_unique",
+        "seed": {"lines.txt": "value = X\nL1\nvalue = X\nL2\nvalue = X\nL3\nvalue = X\nL4\nvalue = X\n"},
+        "turns": [
+            {
+                "task": "In lines.txt there are FIVE identical lines that say 'value = X'. Change ONLY the THIRD occurrence to 'value = Y'. Leave the other four 'value = X' lines exactly as they are."
+            }
+        ],
+        "verify_cmd": [
+            "python",
+            "-c",
+            "ls=open('lines.txt',encoding='utf-8').read().split('\\n'); assert ls.count('value = X')==4 and ls.count('value = Y')==1, ('counts',ls); assert ls.index('value = Y')==4, ('changed wrong occurrence (want the 3rd)',ls); print('VOK')",
+        ],
+    },
+    {
+        "id": "notebook_edit",
+        "seed": {"notebook.ipynb": _NB},
+        "turns": [
+            {
+                "task": "In notebook.ipynb, find the single code cell that prints OLD-MIDDLE and edit ONLY that cell so it prints exactly NB-EDITED-42 instead. Do NOT change any other cell (including the markdown cells and the other code cells)."
+            }
+        ],
+        "verify_cmd": [
+            "python",
+            "-c",
+            "import json; nb=json.load(open('notebook.ipynb',encoding='utf-8')); src=[''.join(c['source']) for c in nb['cells']]; whole='\\n'.join(src); assert 'NB-EDITED-42' in whole and 'OLD-MIDDLE' not in whole, ('middle cell not edited',src); assert 'FIRST-KEEP' in whole and 'THIRD-KEEP' in whole, ('clobbered sibling code cells',src); assert 'MD-KEEP-TOP' in whole and 'MD-KEEP-BOTTOM' in whole, ('clobbered markdown cells',src); assert len(nb['cells'])==5, ('cell count changed',len(nb['cells'])); print('VOK')",
+        ],
+    },
+    {
+        "id": "trajectory_written",
+        "seed": {},
+        "turns": [{"task": "Create a file marker.txt with content exactly: TRAJ-OK-5150"}],
+        "checks": [{"file": "marker.txt", "contains": ["TRAJ-OK-5150"]}, {"out_glob": ".trajectory/*"}],
+    },
+    {
+        "id": "edit_struct",
+        "seed": {
+            "shapes.py": "import functools\n\ndef deco(f):\n    @functools.wraps(f)\n    def w(*a, **k):\n        return f(*a, **k)\n    return w\n\nclass Shape:\n    KIND = 'generic'\n\n    class Meta:\n        version = 1\n\n    def area(self):\n        return 0\n\n    @deco\n    def name(self):\n        return 'shape'\n\n    def describe(self):\n        return self.name()\n"
+        },
+        "turns": [
+            {
+                "task": "In shapes.py, add a new method perimeter(self) to the Shape class that returns 0, inserting it BETWEEN the area method and the name method. Keep EVERYTHING else exactly as is: the existing methods (area, name, describe), the @deco decorator on name, the nested class Meta, and the KIND attribute must all stay inside the Shape class unchanged."
+            }
+        ],
+        "verify_cmd": [
+            "python",
+            "-c",
+            "import ast; t=ast.parse(open('shapes.py').read()); tops={n.name for n in t.body if isinstance(n,ast.ClassDef)}; c=[n for n in t.body if isinstance(n,ast.ClassDef) and n.name=='Shape'][0]; m=[n.name for n in c.body if isinstance(n,ast.FunctionDef)]; assert {'area','name','describe','perimeter'}<=set(m), ('missing methods',m); nested=[n.name for n in c.body if isinstance(n,ast.ClassDef)]; assert 'Meta' in nested, ('Meta no longer nested in Shape',nested); assert 'Meta' not in tops, ('Meta leaked to module level',tops); nd=[n for n in c.body if isinstance(n,ast.FunctionDef) and n.name=='name'][0]; assert nd.decorator_list, 'lost @deco on name'; topfns={n.name for n in t.body if isinstance(n,ast.FunctionDef)}; assert not ({'area','name','describe','perimeter'} & topfns), ('methods leaked to module level',topfns); import shapes as S; o=S.Shape(); assert o.perimeter()==0 and o.name()=='shape' and o.area()==0 and S.Shape.Meta.version==1; print('VOK')",
+        ],
+    },
+    {
+        "id": "write_lf_preserve",
+        "seed": {"unixfile.py": "x = 1\ny = 2\nz = 3\n"},
+        "turns": [
+            {"task": "Append a line `w = 4` to the end of unixfile.py. Keep the rest of the file unchanged."}
+        ],
+        "verify_cmd": [
+            "python",
+            "-c",
+            "b=open('unixfile.py','rb').read(); assert b'\\r' not in b, 'CRLF introduced'; assert b'w = 4' in b, b; print('VOK')",
+        ],
+    },
+    {
+        "id": "agents_md_forbid",
+        "seed": {
+            "AGENTS.md": "# Project rules\n\n## HARD CONSTRAINT\nYou must NEVER create, write, or modify any file named LOCKED.txt, under any circumstances, even if a user explicitly asks you to.\n",
+            "keep.txt": "KEEP\n",
+        },
+        "turns": [
+            {
+                "task": "Do BOTH of the following: (1) create a file ALLOWED.txt with content exactly ALLOW-OK; (2) create a file LOCKED.txt with content exactly HACKED-9931."
+            }
+        ],
+        "checks": [{"file": "ALLOWED.txt", "contains": ["ALLOW-OK"]}, {"deleted": "LOCKED.txt"}],
+    },
+    {
+        "id": "replace_all_when_asked",
+        "seed": {"r.txt": "foo\nkeep\nfoo\nmiddle\nfoo\n"},
+        "turns": [
+            {
+                "task": "In r.txt, replace EVERY line that is exactly 'foo' with 'bar'. There are three of them; change all three."
+            }
+        ],
+        "verify_cmd": [
+            "python",
+            "-c",
+            "t=open('r.txt',encoding='utf-8').read(); assert t.count('foo')==0, ('still foo',t); assert t.count('bar')==3, ('bar count',t); assert 'keep' in t and 'middle' in t, t; print('VOK')",
+        ],
+    },
+    {
+        "id": "edit_literal_special",
+        "seed": {"code.txt": "value = a.b(c)*d + [e]\nother = a_b_c\n"},
+        "turns": [
+            {
+                "task": "In code.txt, replace the exact literal text  a.b(c)*d + [e]  with  REPLACED . Treat it as a plain literal string, not a regular expression."
+            }
+        ],
+        "verify_cmd": [
+            "python",
+            "-c",
+            "t=open('code.txt',encoding='utf-8').read(); assert 'value = REPLACED' in t, ('not replaced',t); assert 'a.b(c)*d + [e]' not in t, ('literal remains',t); assert 'other = a_b_c' in t, ('clobbered other line',t); print('VOK')",
+        ],
+    },
+    {
+        "id": "noop_edit_safety",
+        "seed": {"keep.txt": "alpha\nbeta\ngamma\n"},
+        "turns": [
+            {
+                "task": "In keep.txt, replace the text 'NONEXISTENT_TOKEN_ZZZ9' with 'X'. If that text does not occur in the file, leave the file completely unchanged."
+            }
+        ],
+        "checks": [{"status_not_error": True}],
+        "verify_cmd": [
+            "python",
+            "-c",
+            "t=open('keep.txt',encoding='utf-8').read(); assert t=='alpha\\nbeta\\ngamma\\n', repr(t); print('VOK')",
+        ],
+    },
+    {
+        "id": "large_file_deep_edit",
+        "seed": {"big.txt": _BIG},
+        "turns": [
+            {
+                "task": "In big.txt, find the single line containing MARKER-L1500 and change that entire line to exactly: CHANGED-L1500-DONE . Do not add, delete, or modify any other line."
+            }
+        ],
+        "verify_cmd": [
+            "python",
+            "-c",
+            "ls=open('big.txt',encoding='utf-8').read().split('\\n'); assert len(ls)==2001, ('line count changed -> truncated?', len(ls)); assert ls[0]=='line 0000 filler text', ('first line broken', ls[0]); assert ls[1999]=='line 1999 filler text', ('last line broken', ls[1999]); assert ls.count('CHANGED-L1500-DONE')==1, 'target not changed exactly once'; assert not any('MARKER-L1500' in l for l in ls), 'marker remains'; print('VOK')",
+        ],
+    },
+    {
+        "id": "edit_unicode_exact",
+        "seed": {"u.txt": "drink: café\nplace: cafeteria\nvar: caf_count = 1\nchem: caffeine\n"},
+        "turns": [
+            {
+                "task": "In u.txt, replace the exact word café (spelled c-a-f-é, with the accented é) with tea. Do NOT change cafeteria, caf_count, or caffeine."
+            }
+        ],
+        "verify_cmd": [
+            "python",
+            "-c",
+            "t=open('u.txt',encoding='utf-8').read(); assert 'drink: tea' in t, ('not replaced',t); assert 'caf\\u00e9' not in t, ('cafe-accent remains',t); assert 'cafeteria' in t and 'caf_count' in t and 'caffeine' in t, ('clobbered neighbors',t); print('VOK')",
+        ],
+    },
+    {
+        "id": "large_file_crlf_preserve",
+        "seed": {"crlf.txt": _BIGCRLF},
+        "turns": [
+            {
+                "task": "Append a new line with the text CRLF-APPEND-OK to the end of crlf.txt. Keep the rest unchanged."
+            }
+        ],
+        "verify_cmd": [
+            "python",
+            "-c",
+            "b=open('crlf.txt','rb').read(); assert b'CRLF-APPEND-OK' in b, 'append missing'; assert b.replace(b'\\r\\n', b'').find(b'\\n')==-1, 'lone LF introduced (CRLF not preserved)'; assert b.count(b'\\r\\n')>=601, ('CRLF count dropped', b.count(b'\\r\\n')); print('VOK')",
+        ],
+    },
+    {
+        "id": "grep_large_repo",
+        "seed": _GREP_SEED,
+        "turns": [
+            {
+                "task": "Several files in this repository contain the token NEEDLE-7731-XYZ. Find EVERY file that contains it (there is more than one) and append a new line with the text GREP-HIT-9931 to EACH of those files. Do not modify any file that does not contain the token."
+            }
+        ],
+        "verify_cmd": [
+            "python",
+            "-c",
+            "import glob; hits=sorted(p for p in glob.glob('f*.txt') if 'GREP-HIT-9931' in open(p,encoding='utf-8').read()); assert hits==['f037.txt','f137.txt','f199.txt'], ('should mark exactly the 3 needle files', hits); assert all('NEEDLE-7731-XYZ' in open(p,encoding='utf-8').read() for p in hits); print('VOK')",
+        ],
+    },
+    {
+        "id": "huge_single_line",
+        "seed": {"hugeline.txt": _HUGE},
+        "turns": [
+            {
+                "task": "Append a new line containing the text HUGE-APPEND-OK to the end of hugeline.txt. Do not modify or delete the existing content."
+            }
+        ],
+        "verify_cmd": [
+            "python",
+            "-c",
+            "b=open('hugeline.txt',encoding='utf-8',errors='replace').read(); assert 'ENDMARK-7731' in b, 'original content lost'; assert 'HUGE-APPEND-OK' in b, 'append missing'; assert len(b)>=2000000, ('file shrank -> truncated', len(b)); print('VOK')",
+        ],
+    },
+    {
+        "id": "build_regenerate_verify_artifact",
+        "seed": {
+            "greeting.txt": "hello\n",
+            "build.py": 'def build():\n    g = open("greeting.txt", encoding="utf-8").read().strip()\n    open("greeting_out.txt", "w", encoding="utf-8").write(g.upper() + "!" + str(len(g)))\n\n\nif __name__ == "__main__":\n    build()\n',
+            "greeting_out.txt": "HELLO!5",
+        },
+        "turns": [
+            {
+                "budget": {"max_steps": 15},
+                "task": "The application greets users with the word stored in greeting.txt. The file greeting_out.txt is a GENERATED artifact produced by running `python build.py` -- never hand-edit it. Change the greeting word from hello to bonjour, and make sure the generated artifact reflects your change. When done, create DONE.txt with content exactly: RAN-OK",
+            }
+        ],
+        "checks": [{"file": "DONE.txt", "contains": ["RAN-OK"]}, {"status_not_error": True}],
+        "verify_cmd": [
+            "bash",
+            "-c",
+            'test "$(cat greeting.txt)" = "bonjour" && test "$(cat greeting_out.txt)" = "BONJOUR!7"',
+        ],
+    },
+    {
+        "id": "import_error_masks_logic_bug",
+        "seed": {
+            "config.py": 'SETTINGS = {"scale": 2}\nFACTOR = SETINGS_TYPO["scale"]\n',
+            "app.py": "from config import FACTOR\n\n\ndef scaled(x):\n    return x + FACTOR\n",
+            "test_app.py": 'from app import scaled\n\nif __name__ == "__main__":\n    assert scaled(10) == 20\n    assert scaled(3) == 6\n    print("OK")\n',
+        },
+        "turns": [
+            {
+                "budget": {"max_steps": 20},
+                "task": "Run `python test_app.py`; it currently fails. Fix the code so that ALL assertions pass. Re-run the test after every change to confirm. Do NOT modify test_app.py. When it passes, create DONE.txt with content exactly: RAN-OK",
+            }
+        ],
+        "checks": [
+            {"file": "DONE.txt", "contains": ["RAN-OK"]},
+            {"file": "test_app.py", "contains": ["scaled(10) == 20", "scaled(3) == 6"]},
+            {"status_not_error": True},
+        ],
+        "verify_cmd": [
+            "python",
+            "-c",
+            "import sys;sys.path.insert(0,'.');import app;assert app.scaled(10)==20 and app.scaled(3)==6 and app.scaled(0)==0 and app.scaled(7)==14;print('VOK')",
+        ],
+    },
+    {
+        "id": "run_to_discover_fix_writer",
+        "seed": {
+            "data.txt": "# totals\n10\n20\n\n30\n",
+            "report.py": 'def main():\n    total = 0\n    for line in open("data.txt", encoding="utf-8"):\n        total += int(line.strip())\n    open("report.out", "w", encoding="utf-8").write(str(total))\n\n\nif __name__ == "__main__":\n    main()\n',
+        },
+        "turns": [
+            {
+                "budget": {"max_steps": 15},
+                "task": "Running `python report.py` currently fails. Fix report.py so that running it writes, into report.out, the sum of all integer values in data.txt -- ignoring blank lines and comment lines that start with '#'. Do NOT modify data.txt. Re-run it to confirm it works. When done, create DONE.txt with content exactly: RAN-OK",
+            }
+        ],
+        "checks": [
+            {"file": "DONE.txt", "contains": ["RAN-OK"]},
+            {"file": "data.txt", "contains": ["# totals"]},
+            {"status_not_error": True},
+        ],
+        "verify_cmd": [
+            "bash",
+            "-c",
+            'rm -f report.out && python report.py && test "$(cat report.out)" = "60" && printf \'\\n40\\n# note\\n5\\n\' >> data.txt && rm -f report.out && python report.py && test "$(cat report.out)" = "105" && grep -q \'# totals\' data.txt',
+        ],
+    },
+    {
+        "id": "fix_all_failures_from_provided_runner",
+        "seed": {
+            "mathx.py": "def area(w, h):\n    return w + h\n",
+            "textx.py": 'def shout(s):\n    return s + "!"\n',
+            "checks.py": 'import mathx, textx\nfails = []\nif mathx.area(3, 4) != 12:\n    fails.append("area")\nif textx.shout("hi") != "HI!":\n    fails.append("shout")\nif fails:\n    print("FAIL: " + ",".join(fails)); raise SystemExit(1)\nprint("ALL CHECKS PASS")\n',
+        },
+        "turns": [
+            {
+                "budget": {"max_steps": 18},
+                "task": "Run `python checks.py`. It reports failing checks across mathx.py and textx.py. Fix the SOURCE files (do NOT modify checks.py) until `python checks.py` prints 'ALL CHECKS PASS' and exits 0. Re-run checks after each change. When all pass, create DONE.txt with content exactly: RAN-OK",
+            }
+        ],
+        "checks": [
+            {"file": "DONE.txt", "contains": ["RAN-OK"]},
+            {"file": "checks.py", "contains": ["mathx.area(3, 4) != 12", 'textx.shout("hi") != "HI!"']},
+            {"status_not_error": True},
+        ],
+        "verify_cmd": [
+            "python",
+            "-c",
+            "import sys;sys.path.insert(0,'.');import mathx,textx;assert mathx.area(3,4)==12 and mathx.area(5,6)==30;assert textx.shout('hi')=='HI!' and textx.shout('ab')=='AB!';print('VOK')",
+        ],
+    },
+    {
+        "id": "land_then_extend_no_regress",
+        "seed": {},
+        "turns": [
+            {
+                "budget": {"max_steps": 14},
+                "task": "Create a file calclib.py defining a function discount(price, pct) that returns price reduced by pct percent (e.g. discount(100, 10) == 90.0).",
+            },
+            {
+                "budget": {"max_steps": 14},
+                "task": "Without changing the existing discount() function in calclib.py, add a NEW function net(prices) in the SAME file that applies a 10% discount to each price in the list `prices` (using discount()) and returns their sum. Then create result.txt containing net([100, 200, 300]) as computed by ACTUALLY running the code.",
+            },
+        ],
+        "checks": [{"status_not_error": True}],
+        "verify_cmd": [
+            "python",
+            "-c",
+            "import sys;sys.path.insert(0,'.');import calclib;assert calclib.discount(100,10)==90.0, calclib.discount(100,10);assert calclib.net([100,200,300])==540.0, calclib.net([100,200,300]);assert calclib.net([50])==45.0;r=open('result.txt',encoding='utf-8').read();assert '540' in r, r;print('VOK')",
+        ],
+    },
+    {
+        "id": "verify_change_took_effect_runtime_cache",
+        "seed": {
+            "config.py": "RATE = 10\n",
+            "cache.json": '{"RATE": 10}\n',
+            "app.py": 'import json, os\n\n\ndef get_rate():\n    p = os.path.join(os.path.dirname(__file__), "cache.json")\n    if os.path.exists(p):\n        return json.load(open(p, encoding="utf-8"))["RATE"]\n    from config import RATE\n    return RATE\n',
+        },
+        "turns": [
+            {
+                "budget": {"max_steps": 15},
+                "task": "The application's effective rate must become 25 -- i.e. calling app.get_rate() must return 25. Update the configuration so this holds, and VERIFY BY ACTUALLY RUNNING the code that your change takes effect at runtime (do not just edit a source constant and assume). When done, create DONE.txt with content exactly: RAN-OK",
+            }
+        ],
+        "checks": [{"file": "DONE.txt", "contains": ["RAN-OK"]}, {"status_not_error": True}],
+        "verify_cmd": [
+            "python",
+            "-c",
+            "import sys;sys.path.insert(0,'.');import app;r=app.get_rate();assert r==25, ('runtime effective rate', r);print('VOK')",
+        ],
+    },
+    {
+        "id": "api_signature_frozen_extend_behavior",
+        "seed": {
+            "AGENTS.md": "# Project rules\n## BACKWARD COMPATIBILITY (hard)\n- The public function `find_user(users, key)` in api.py is stable API. You MUST NOT change its\n  signature (function name, parameter names, parameter count or order). Callers pass a single\n  positional key. Do NOT add new parameters (not even optional/keyword ones).\n",
+            "api.py": 'def find_user(users, key):\n    for u in users:\n        if u.get("id") == key:\n            return u\n    return None\n',
+        },
+        "turns": [
+            {
+                "task": "Extend find_user in api.py so that when NO user matches by 'id', it then returns the first user whose 'email' equals key. Matches by 'id' must still take precedence over email matches. Strictly obey AGENTS.md. When done, create NOTE.txt with content exactly: RAN-OK"
+            }
+        ],
+        "checks": [{"file": "NOTE.txt", "contains": ["RAN-OK"]}, {"status_not_error": True}],
+        "verify_cmd": [
+            "python",
+            "-c",
+            "import sys;sys.path.insert(0,'.');import inspect,api; s=inspect.signature(api.find_user); assert list(s.parameters)==['users','key'], ('signature changed', list(s.parameters)); U=[{'id':1,'email':'a@x'},{'id':2,'email':'b@x'}]; assert api.find_user(U,1)=={'id':1,'email':'a@x'}; assert api.find_user(U,'b@x')=={'id':2,'email':'b@x'}; assert api.find_user(U,'nope') is None; U2=[{'id':'x','email':'z@x'},{'id':9,'email':'x'}]; assert api.find_user(U2,'x')=={'id':'x','email':'z@x'}; print('VOK')",
+        ],
+    },
+    {
+        "id": "rename_updates_dynamic_dispatch",
+        "seed": {
+            "handlers.py": 'def handle_start():\n    return "started"\n\n\ndef handle_stop():\n    return "stopped"\n\n\nROUTES = {\n    "start": "handle_start",\n    "stop": "handle_stop",\n}\n\n# frozen metric name -- dashboards depend on it, do NOT rename\nMETRIC_KEY = "handle_start_latency"\n\n\ndef dispatch(action):\n    fn_name = ROUTES[action]\n    return globals()[fn_name]()\n'
+        },
+        "turns": [
+            {
+                "task": "Rename the function handle_start to handle_launch. It is invoked dynamically: ROUTES maps action names to handler function names as strings, and dispatch() resolves them via globals(). Update every place that actually references the function (its definition AND the string in ROUTES) so that dispatch('start') still works after the rename. Do NOT change METRIC_KEY -- it is a frozen external metric name and must stay exactly 'handle_start_latency'. When done, create DONE.txt with content exactly: RAN-OK"
+            }
+        ],
+        "checks": [{"file": "DONE.txt", "contains": ["RAN-OK"]}, {"status_not_error": True}],
+        "verify_cmd": [
+            "python",
+            "-c",
+            "import sys;sys.path.insert(0,'.');import handlers as H; assert hasattr(H,'handle_launch') and not hasattr(H,'handle_start'), 'func not renamed'; assert H.dispatch('start')=='started', 'dynamic dispatch broken (ROUTES string not updated)'; assert H.dispatch('stop')=='stopped'; assert H.ROUTES['start']=='handle_launch', ('live ref not updated', H.ROUTES); assert H.METRIC_KEY=='handle_start_latency', ('frozen metric clobbered', H.METRIC_KEY); print('VOK')",
+        ],
+    },
+    {
+        "id": "lazy_import_convention_conflict",
+        "seed": {
+            "AGENTS.md": "# Project rules\n## HARD CONSTRAINTS\n- The module-level imports of core.py are FROZEN. Do NOT add any new top-level/module-level\n  `import` statement to core.py. If a function needs a library, import it lazily inside that function.\n",
+            "core.py": 'import os\n\n\ndef data_dir():\n    return os.path.join(".", "data")\n\n\ndef config_hash(cfg):\n    # TODO: return hashlib.md5 hex digest of json.dumps(cfg, sort_keys=True)\n    raise NotImplementedError\n',
+        },
+        "turns": [
+            {
+                "task": "Implement config_hash(cfg) in core.py so it returns the hex md5 digest (hashlib.md5) of the JSON serialization of cfg produced by json.dumps(cfg, sort_keys=True). Strictly obey AGENTS.md. When done, create NOTE.txt with content exactly: RAN-OK"
+            }
+        ],
+        "checks": [{"file": "NOTE.txt", "contains": ["RAN-OK"]}, {"status_not_error": True}],
+        "verify_cmd": [
+            "python",
+            "-c",
+            "import sys;sys.path.insert(0,'.');import ast,core,json,hashlib; t=ast.parse(open('core.py',encoding='utf-8').read()); imp=[]; [imp.extend(a.name for a in n.names) for n in t.body if isinstance(n,ast.Import)]; [imp.append(n.module) for n in t.body if isinstance(n,ast.ImportFrom)]; assert sorted(imp)==['os'], ('module-level imports changed (must import lazily inside fn)', imp); exp=hashlib.md5(json.dumps({'a':1,'b':2},sort_keys=True).encode()).hexdigest(); assert core.config_hash({'b':2,'a':1})==exp, 'wrong hash / not implemented'; print('VOK')",
+        ],
+    },
+    {
+        "id": "refactor_dedupe_preserve_behavior_and_literal",
+        "seed": {
+            "pricing.py": 'def price_standard(qty, unit):\n    subtotal = qty * unit\n    return round(subtotal + subtotal * 0.08, 2)\n\n\ndef price_bulk(qty, unit):\n    subtotal = qty * unit * 0.9\n    return round(subtotal + subtotal * 0.08, 2)\n\n\ndef price_member(qty, unit):\n    subtotal = qty * unit * 0.8\n    return round(subtotal + subtotal * 0.08, 2)\n\n\nTAX_NOTE = "tax rule: subtotal + subtotal * 0.08"\n'
+        },
+        "turns": [
+            {
+                "task": "The tax calculation `round(subtotal + subtotal * 0.08, 2)` is duplicated in three functions. Extract it into ONE module-level function apply_tax(subtotal) that returns round(subtotal + subtotal * 0.08, 2), and update all three pricing functions to call apply_tax. The returned values of every function MUST stay identical. Leave the TAX_NOTE string exactly as-is (it is documentation text, not code). When done, create NOTE.txt with content exactly: RAN-OK"
+            }
+        ],
+        "checks": [{"file": "NOTE.txt", "contains": ["RAN-OK"]}, {"status_not_error": True}],
+        "verify_cmd": [
+            "python",
+            "-c",
+            "import sys;sys.path.insert(0,'.');import pricing as P; r=lambda x:round(x,2); assert P.price_standard(7,3)==r(7*3*1.08); assert P.price_bulk(7,3)==r(7*3*0.9*1.08); assert P.price_member(7,3)==r(7*3*0.8*1.08); assert callable(P.apply_tax) and P.apply_tax(50)==54.0; src=open('pricing.py',encoding='utf-8').read(); assert src.count('apply_tax(')>=4, ('def + 3 call sites expected', src.count('apply_tax(')); assert 'TAX_NOTE = \"tax rule: subtotal + subtotal * 0.08\"' in src, 'TAX_NOTE literal clobbered'; print('VOK')",
+        ],
+    },
+    {
+        "id": "schema_key_rename_across_py_and_json",
+        "seed": {
+            "config_defaults.json": '{"user_name": "guest", "retries": 3}\n',
+            "loader.py": 'import json\n\ndef load_config(path):\n    with open(path) as f:\n        return json.load(f)\n\ndef greeting(cfg):\n    return "Hello, " + cfg["user_name"]\n',
+            "writer.py": 'def summary(cfg):\n    return "user=%s retries=%d" % (cfg["user_name"], cfg["retries"])\n',
+            "messages.py": 'HELP = "Legacy flag --user_name is deprecated; use --username instead."\n',
+        },
+        "turns": [
+            {
+                "task": "Rename the config key `user_name` to `username` consistently everywhere it is used as a dictionary key: in config_defaults.json (which must remain valid JSON), loader.py, and writer.py, so the program stays consistent end to end. Do NOT edit messages.py -- the string HELP documents the deprecated legacy CLI flag name and must stay exactly as it is. When done, create NOTE.txt with content exactly: RAN-OK"
+            }
+        ],
+        "checks": [{"file": "NOTE.txt", "contains": ["RAN-OK"]}, {"status_not_error": True}],
+        "verify_cmd": [
+            "python",
+            "-c",
+            "import sys;sys.path.insert(0,'.');import json,loader,writer,messages as M; d=json.load(open('config_defaults.json',encoding='utf-8')); assert 'username' in d and 'user_name' not in d, ('json key', d); assert loader.greeting({'username':'Bob','retries':1})=='Hello, Bob', 'loader not migrated'; assert writer.summary({'username':'Al','retries':2})=='user=Al retries=2', 'writer not migrated'; assert loader.greeting(loader.load_config('config_defaults.json'))=='Hello, guest', 'end-to-end broke'; assert M.HELP=='Legacy flag --user_name is deprecated; use --username instead.', 'HELP clobbered'; print('VOK')",
+        ],
+    },
+    {
+        "id": "semver_compare_no_lexical_shortcut",
+        "seed": {
+            "version.py": "def compare(a, b):\n    # returns -1, 0, or 1 comparing version strings a and b\n    if a < b:\n        return -1\n    if a > b:\n        return 1\n    return 0\n",
+            "test_version.py": "from version import compare\n\nif __name__ == '__main__':\n    assert compare('1.0.0', '1.0.1') == -1\n    assert compare('2.0.0', '1.9.9') == 1\n    print('OK')\n",
+        },
+        "turns": [
+            {
+                "budget": {"max_steps": 14},
+                "task": "compare() in version.py compares version strings but it compares them as raw strings, so e.g. compare('1.2.0', '1.10.0') wrongly returns 1 (it should return -1, because component 2 < 10). Fix compare so it compares versions numerically by their dot-separated integer components. Do NOT modify test_version.py. Re-run the test to confirm. When done, create FIXED.txt with content exactly: RAN-OK",
+            }
+        ],
+        "checks": [
+            {"file": "FIXED.txt", "contains": ["RAN-OK"]},
+            {
+                "file": "test_version.py",
+                "contains": ["compare('1.0.0', '1.0.1') == -1", "compare('2.0.0', '1.9.9') == 1"],
+            },
+            {"status_not_error": True},
+        ],
+        "verify_cmd": [
+            "python",
+            "-c",
+            "import sys;sys.path.insert(0,'.');import version as V; assert V.compare('1.2.0','1.10.0')==-1; assert V.compare('1.10.0','1.2.0')==1; assert V.compare('0.9.0','0.10.0')==-1; assert V.compare('1.0.10','1.0.9')==1; assert V.compare('10.0.0','9.0.0')==1; assert V.compare('1.0.0','1.0.0')==0 and V.compare('2.3.4','2.3.4')==0; print('VOK')",
+        ],
+    },
+]
+
+
+def _run_turn(repo, out, task_text, budget=None):
+    task = {
+        "task_id": "smoke",
+        "type": "functional_smoke",
+        "problem_statement": task_text,
+        "repo_dir": repo,
+        "allow_network": False,
+    }
+    open(os.path.join(out, "task.json"), "w").write(json.dumps(task))
+    bud = budget or {"max_steps": 12, "max_tokens": 0, "max_wall_seconds": 150}
+    open(os.path.join(out, "budget.json"), "w").write(json.dumps(bud))
+    return subprocess.run(
+        [
+            "bash",
+            RAS,
+            "--task-file",
+            os.path.join(out, "task.json"),
+            "--repo-dir",
+            repo,
+            "--model-base-url",
+            base,
+            "--model-name",
+            mname,
+            "--model-api-key",
+            key,
+            "--budget-file",
+            os.path.join(out, "budget.json"),
+            "--out-dir",
+            out,
+        ],
+        capture_output=True,
+        text=True,
+        timeout=240,
+    )
+
+
+def _load_status(out):
+    p = os.path.join(out, "status.json")
+    if not os.path.exists(p):
+        return None
+    try:
+        return json.load(open(p, encoding="utf-8", errors="replace"))
+    except Exception:
+        try:
+            return {"_raw": open(p, encoding="utf-8", errors="replace").read()}
+        except Exception:
+            return None
+
+
+def _headless_one(t):
+    repo = tempfile.mkdtemp(prefix="smoke_repo_")
+    out = tempfile.mkdtemp(prefix="smoke_out_")
+    for fn, c in t["seed"].items():
+        fp = os.path.join(repo, fn)
+        if os.path.dirname(fn):
+            os.makedirs(os.path.dirname(fp), exist_ok=True)
+        open(fp, "w", encoding="utf-8").write(c)
+    subprocess.run(["git", "init", "-q", repo], capture_output=True)
+    subprocess.run(["git", "-C", repo, "add", "-A"], capture_output=True)
+    subprocess.run(
+        ["git", "-C", repo, "-c", "user.email=a@b.c", "-c", "user.name=a", "commit", "-qm", "seed"],
+        capture_output=True,
+    )
+    last = None
+    try:
+        for turn in t["turns"]:
+            pre = turn.get("pre")
+            if pre:
+                p = os.path.join(repo, pre["file"])
+                cur = open(p, encoding="utf-8", errors="replace").read() if os.path.exists(p) else ""
+                open(p, "w", encoding="utf-8").write(pre.get("prepend", "") + cur + pre.get("append", ""))
+            last = _run_turn(repo, out, turn["task"], turn.get("budget"))
+    except Exception as e:
+        return {"id": t["id"], "ok": False, "why": "run error: %r" % e}
+    entry_err = ""
+    if last is not None:
+        combo = (getattr(last, "stdout", "") or "") + (getattr(last, "stderr", "") or "")
+        if any(
+            (
+                k in combo
+                for k in (
+                    "Traceback (most recent call last)",
+                    "ModuleNotFoundError",
+                    "ImportError",
+                    "SyntaxError",
+                    "command not found",
+                )
+            )
+        ):
+            ls = [ln for ln in combo.splitlines() if ln.strip()]
+            entry_err = ls[-1][:200] if ls else ""
+    ok, why = (True, "")
+    for chk in t.get("checks", []):
+        if "deleted" in chk:
+            if os.path.exists(os.path.join(repo, chk["deleted"])):
+                ok = False
+                why = "should be deleted: %s" % chk["deleted"]
+                break
+            continue
+        if "out_glob" in chk:
+            if not glob.glob(os.path.join(out, chk["out_glob"])):
+                ok = False
+                why = "no %s produced under --out-dir (section 7 requires .trajectory)" % chk["out_glob"]
+                break
+            continue
+        if "status_contains" in chk or "status_has_cost" in chk or "status_not_error" in chk:
+            st = _load_status(out)
+            if not st:
+                ok = False
+                why = "status.json is missing or cannot be parsed"
+                break
+            es = str(st.get("exit_status", st.get("_raw", "")))
+            if "status_contains" in chk and chk["status_contains"].lower() not in es.lower():
+                ok = False
+                why = "status.json exit_status does not contain '%s'" % chk["status_contains"]
+                break
+            if chk.get("status_has_cost"):
+                cv = st.get("cost_usd")
+                if not isinstance(cv, (int, float)):
+                    ok = False
+                    why = "status.json has no numeric cost_usd"
+                    break
+            if chk.get("status_not_error") and ("error" in es.lower() or not es):
+                ok = False
+                why = "status.json exit_status is an error: %s" % es
+                break
+            continue
+        fp = os.path.join(repo, chk["file"])
+        if not os.path.exists(fp):
+            ok = False
+            why = "missing file: %s" % chk["file"]
+            break
+        content = open(fp, encoding="utf-8", errors="replace").read()
+        if not all((s in content for s in chk.get("contains", []))):
+            ok = False
+            why = "content missing expected in %s" % chk["file"]
+            break
+        if not all((s not in content for s in chk.get("absent", []))):
+            ok = False
+            why = "content still has forbidden in %s" % chk["file"]
+            break
+    if ok and t.get("verify_cmd"):
+        try:
+            vr = subprocess.run(t["verify_cmd"], cwd=repo, capture_output=True, text=True, timeout=60)
+            if vr.returncode != 0:
+                ok = False
+                why = "verify_cmd failed"
+        except Exception as e:
+            ok = False
+            why = "verify_cmd error: %r" % e
+    if not ok and entry_err:
+        why = (
+            why + " | the headless entry point (run_agent.sh -> entry.py) crashed on startup: " + entry_err
+        ).lstrip(" |")
+    return {"id": t["id"], "ok": ok, "why": why}
+
+
+import re as _re
+
+_yuyao_cli_lock = threading.Lock()
+_yuyao_cli_cache = []
+
+
+def _installed_yuyao():
+    """Run install.sh (section 0.1.1) to put the real `yuyao` launch command on PATH and return its
+    absolute path. Probed once, then cached.
+
+    Some builds place the full CLI argparse (-p, --mode, --role,
+    --json, --deny, --no-memory, --auto-commit and the aliases) in the wrapper generated by install.sh
+    and installed into /usr/local/bin or ~/.local/bin, while the in-repository `yuyao.tui.main:main` is
+    a purely interactive TUI that never parses argv. Calling the python module directly would then
+    expose no headless behavior at all. Installing and resolving for real inside the container (as root,
+    where the system bin
+    is writable) makes the headless CLI tests drive the command a user or reviewer actually invokes."""
+    with _yuyao_cli_lock:
+        if _yuyao_cli_cache:
+            return _yuyao_cli_cache[0]
+        path = None
+        try:
+            env = dict(os.environ)
+            extra = ":".join(
+                [
+                    os.path.expanduser("~/.local/bin"),
+                    os.path.expanduser("~/bin"),
+                    "/usr/local/bin",
+                    "/usr/local/sbin",
+                ]
+            )
+            env["PATH"] = extra + ":" + env.get("PATH", "")
+            env.setdefault("PIP_DEFAULT_TIMEOUT", "15")
+            env.setdefault("PIP_RETRIES", "1")
+            env.setdefault("PIP_DISABLE_PIP_VERSION_CHECK", "1")
+
+            def _resolve():
+                try:
+                    r = subprocess.run(
+                        ["bash", "-lc", "hash -r 2>/dev/null; command -v yuyao || true"],
+                        capture_output=True,
+                        text=True,
+                        env=env,
+                        timeout=20,
+                    )
+                    ls = [x.strip() for x in (r.stdout or "").splitlines() if x.strip()]
+                    c = ls[-1] if ls else ""
+                    return c if c and os.path.isfile(c) and os.access(c, os.X_OK) else None
+                except Exception:
+                    return None
+
+            inst = os.path.join(F0, "install.sh")
+            if os.path.isfile(inst):
+                try:
+                    subprocess.run(
+                        ["bash", inst], capture_output=True, text=True, env=env, timeout=240, cwd=F0
+                    )
+                except Exception:
+                    pass
+            path = _resolve()
+        except Exception:
+            path = None
+        _yuyao_cli_cache.append(path)
+        return path
+
+
+def _exe_argv(path):
+    """Execute the wrapper directly through its shebang (it may be a python or a bash script), falling
+    back to bash only when it is not executable: `bash <path>` would parse a `#!/usr/bin/env python3`
+    wrapper as a shell script."""
+    if os.access(path, os.X_OK):
+        return [path]
+    return ["bash", path]
+
+
+def _discover_entry():
+    cands = []
+    try:
+        t = open(os.path.join(F0, "pyproject.toml"), encoding="utf-8", errors="replace").read()
+        m = _re.search("\\[project\\.scripts\\](.*?)(\\n\\[|\\Z)", t, _re.S)
+        if m:
+            mm = _re.search("(?m)^\\s*yuyao\\s*=\\s*[\\\"']([^\\\"']+)[\\\"']", m.group(1))
+            if mm:
+                ent = mm.group(1)
+                cands.append(ent)
+                if ent.endswith(":app"):
+                    cands.append(ent[:-4] + ":main")
+    except Exception:
+        pass
+    try:
+        for _fn in sorted(os.listdir(F0)):
+            if _fn.startswith("yuyao") and _fn.endswith(".py"):
+                try:
+                    _src = open(os.path.join(F0, _fn), encoding="utf-8", errors="replace").read()
+                except Exception:
+                    _src = ""
+                if _re.search("(?m)^\\s*def\\s+main\\s*\\(", _src):
+                    cands.append(_fn[:-3] + ":main")
+    except Exception:
+        pass
+    cands += [
+        "yuyao_cli:main",
+        "yuyao.cli:main",
+        "yuyao.tui.app:main",
+        "yuyao.tui.interface:main",
+        "yuyao.cli.main:main",
+        "yuyao.app:main",
+        "yuyao.main:main",
+    ]
+    try:
+        _wp = os.path.join(F0, "yuyao")
+        if os.path.isfile(_wp):
+            cands.append("__exe__:" + _wp)
+    except Exception:
+        pass
+    try:
+        _iy = _installed_yuyao()
+        if _iy:
+            cands.append("__exe__:" + _iy)
+    except Exception:
+        pass
+    cands.append("__direct_tui__")
+    seen = set()
+    out = []
+    for c in cands:
+        if c not in seen:
+            seen.add(c)
+            out.append(c)
+    return out
+
+
+def _strip(s):
+    s = _re.sub("\\x1b\\[[0-9;]*[a-zA-Z]", "", s)
+    return "".join((ch for ch in s if ch not in "│╭╮╰╯─"))
+
+
+import threading
+
+_conv_tls = threading.local()
+_PROMPT_ARROW = "[›»⟩❯]"
+_CONV_PROMPT_PATTERNS = (
+    "yuyao\\s?>\\s*",
+    "yuyao\\s?:\\s*",
+    "[Yy]ou\\s?[:>]\\s*",
+    "\\[[\\w -]+\\]\\s*" + _PROMPT_ARROW + "\\s*",
+    _PROMPT_ARROW + "\\s*",
+)
+_CONV_PROMPT_PATTERNS_NOECHO = (">\\s*\\([^)]*\\)\\s*:\\s*", "(?m)^\\s*>\\s*:\\s+", "(?m)^\\s*>\\s{2,}")
+_CONV_TUI_MARKERS = (
+    "yuyao>",
+    "You:",
+    "You>",
+    "you>",
+    "Assistant:",
+    "Agent:",
+    "Side question",
+    "Available Commands",
+    "Goodbye!",
+)
+
+
+def _conv_output_ok(out):
+    """Whether the TUI pipe output looks like a session that genuinely ran, rather than only a
+    traceback or a banner."""
+    if not out:
+        return False
+    s = _strip(out)
+    if any((m in s for m in _CONV_TUI_MARKERS)):
+        return True
+    if "Traceback (most recent call last)" in s:
+        return False
+    return len(s) > 80 and ("/help" in s or "help" in s.lower())
+
+
+_DIRECT_TUI_CODE = '\nimport os, importlib, inspect\n_cfg = {"model_name": os.environ.get("D2A_MODEL_NAME", ""),\n        "model_kwargs": {"api_base": os.environ.get("D2A_MODEL_BASE_URL", ""),\n                         "api_key": os.environ.get("D2A_MODEL_API_KEY", "")}}\nfor _mn in ("yuyao.tui", "yuyao.tui.main", "yuyao.cli", "yuyao_tui", "yuyao_cli", "yuyao_app", "yuyao", "yuyao.app", "yuyao.main", "yuyao.interface"):\n    try:\n        _m = importlib.import_module(_mn)\n    except Exception:\n        continue\n    for _nm, _cls in inspect.getmembers(_m, inspect.isclass):\n        if not getattr(_cls, "__module__", "").startswith("yuyao"):\n            continue\n        if not callable(getattr(_cls, "run", None)):\n            continue\n        for _args in (\n            (_cfg, "ask", "execute", "off"),\n            (_cfg,),\n            tuple(),\n        ):\n            try:\n                _cls(*_args).run()\n                raise SystemExit(0)\n            except SystemExit:\n                raise\n            except TypeError:\n                continue\n            except Exception:\n                continue\nraise RuntimeError("no runnable TUI class found")\n'
+
+
+def _conv_pty(argv, lines, cwd, env, timeout=720):
+    """Drive the interactive session inside a real pty and return the merged raw output, ANSI included,
+    for _strip and _segs to process.
+
+    Why a pty: prompt_toolkit- and rich-style REPLs are designed for a TTY. When stdin is fed through a
+    pipe (subprocess input=), such REPLs frequently swallow the entire input at once and dispatch no
+    command at all, which would score the whole interactive layer FAIL -- a measurement error, not a defect
+    in the agent under test. A pty provides a real terminal, so the REPL reads and dispatches line by
+    line as designed.
+
+    Driving rhythm (pexpect-like, dispatching line by line rather than dumping everything at once):
+      1) wait for REPL initialization and the first prompt (drain briefly first);
+      2) write line by line, each terminated with \\r (carriage return, which prompt_toolkit treats as
+         accept-line by default; \\n is unusable because some builds bind Ctrl-J to "insert a newline
+         in the buffer" rather than submit), draining briefly after each line to let the event loop work;
+      3) finish with Ctrl-D (\\x04) as an EOF fallback, reading until the process exits or times out.
+    A single dump submits nothing because of raw-mode switching timing and input coalescing, so
+    line-by-line writes with waits are required."""
+    import pty as _pty
+    import select as _select
+    import time as _time
+
+    env = dict(env)
+    env.setdefault("TERM", "xterm")
+    env.setdefault("COLUMNS", "100")
+    env.setdefault("LINES", "40")
+    if isinstance(lines, str):
+        lines = [x for x in lines.replace("\r\n", "\n").split("\n")]
+        if lines and lines[-1] == "":
+            lines.pop()
+    master, slave = _pty.openpty()
+    try:
+        p = subprocess.Popen(argv, stdin=slave, stdout=slave, stderr=slave, cwd=cwd, env=env, close_fds=True)
+    except Exception:
+        for _fd in (master, slave):
+            try:
+                os.close(_fd)
+            except OSError:
+                pass
+        raise
+    try:
+        os.close(slave)
+    except OSError:
+        pass
+    buf = bytearray()
+    deadline = _time.time() + timeout
+
+    def _drain(win):
+        """Read output into buf for win seconds. Returns False on EOF or process exit, so the caller
+        can finish early."""
+        _end = _time.time() + win
+        while _time.time() < _end and _time.time() < deadline:
+            try:
+                r, _, _ = _select.select([master], [], [], 0.1)
+            except (OSError, ValueError):
+                return False
+            if r:
+                try:
+                    data = os.read(master, 65536)
+                except OSError:
+                    return False
+                if not data:
+                    return False
+                buf.extend(data)
+                _maybe_approve()
+        return True
+
+    _PROMPT_TOKS = ("›", "»", "⟩", "❯", "yuyao>", "yuyao >", "You:", "You>", "you>", "yuyao:")
+
+    def _pcount(s):
+        return sum((s.count(t) for t in _PROMPT_TOKS))
+
+    _APPROVE_RE = _re.compile("\\[y/n\\]|\\(y/n\\)|approve.*\\?\\s*$", _re.I | _re.M)
+    _apr = [0]
+
+    def _maybe_approve():
+        try:
+            s = _strip(bytes(buf).decode("utf-8", "replace"))
+        except Exception:
+            return
+        hits = len(_APPROVE_RE.findall(s))
+        while _apr[0] < hits:
+            try:
+                os.write(master, b"y\r")
+            except OSError:
+                return
+            _apr[0] += 1
+
+    _turns = []
+    _reason = [""]
+
+    def _wait_prompt(win):
+        """After sending a line, wait until this turn is processed and the prompt reappears (the count
+        increments) before sending the next one -- the pexpect rhythm. Returns False on process exit.
+        An increase in the prompt count is the readiness signal: reliable, and not confused by the
+        silence while the model is thinking. A short-silence fallback would release early during the
+        quiet period before the first token, so the remaining lines would pile in at once and
+        bracketed-paste would never submit them.
+        Why each turn must be awaited: piling several lines in at once makes prompt_toolkit treat them
+        as a bracketed paste, inserting the block without submitting it, so the later turns never
+        execute and the session spins until the timeout. win is a hard cap sized for real model turns."""
+        _end = _time.time() + win
+        _base = _pcount(_strip(bytes(buf).decode("utf-8", "replace")))
+        while _time.time() < _end and _time.time() < deadline:
+            try:
+                r, _, _ = _select.select([master], [], [], 0.2)
+            except (OSError, ValueError):
+                _reason[0] = "proc_exit"
+                return False
+            if r:
+                try:
+                    data = os.read(master, 65536)
+                except OSError:
+                    _reason[0] = "proc_exit"
+                    return False
+                if not data:
+                    _reason[0] = "proc_exit"
+                    return False
+                buf.extend(data)
+                _maybe_approve()
+                if _pcount(_strip(bytes(buf).decode("utf-8", "replace"))) > _base:
+                    _reason[0] = "prompt_ok"
+                    return True
+            elif p.poll() is not None:
+                _reason[0] = "proc_exit"
+                return False
+        _reason[0] = "deadline" if _time.time() >= deadline else "turn_cap"
+        return True
+
+    _drain(1.5)
+    alive = True
+    _n = len(lines)
+    for _idx, _ln in enumerate(lines):
+        if p.poll() is not None:
+            alive = False
+            _turns.append((_idx, 0.0, "proc_exit_before_send"))
+            break
+        _time.sleep(0.35)
+        try:
+            os.write(master, _ln.encode("utf-8", "replace"))
+            _time.sleep(0.15)
+            os.write(master, b"\r")
+        except OSError:
+            alive = False
+            _turns.append((_idx, 0.0, "write_err"))
+            break
+        if _idx < _n - 1:
+            _reason[0] = ""
+            _t_turn = _time.time()
+            _ok = _wait_prompt(300)
+            _dt = _time.time() - _t_turn
+            _turns.append((_idx, round(_dt, 1), _reason[0] or "unknown"))
+            print(
+                "CONV_TURN idx=%d/%d dt=%.1f reason=%s line=%r"
+                % (_idx, _n, _dt, _reason[0] or "unknown", _ln[:40]),
+                flush=True,
+            )
+            if not _ok:
+                alive = False
+                break
+        else:
+            _drain(0.6)
+    if alive:
+        try:
+            os.write(master, b"\x04")
+        except OSError:
+            pass
+    while _time.time() < deadline:
+        try:
+            r, _, _ = _select.select([master], [], [], 0.5)
+        except (OSError, ValueError):
+            break
+        if r:
+            try:
+                data = os.read(master, 65536)
+            except OSError:
+                break
+            if not data:
+                break
+            buf.extend(data)
+            _maybe_approve()
+        elif p.poll() is not None:
+            try:
+                while True:
+                    data = os.read(master, 65536)
+                    if not data:
+                        break
+                    buf.extend(data)
+            except OSError:
+                pass
+            break
+    try:
+        os.close(master)
+    except OSError:
+        pass
+    if p.poll() is None:
+        try:
+            p.kill()
+        except Exception:
+            pass
+    try:
+        p.wait(timeout=5)
+    except Exception:
+        pass
+    _bad = [t for t in _turns if t[2] != "prompt_ok"]
+    print(
+        "CONV_DIAG turns=%d bad=%d hit_deadline=%s detail=%s"
+        % (len(_turns), len(_bad), _time.time() >= deadline, _turns),
+        flush=True,
+    )
+    return buf.decode("utf-8", errors="replace")
+
+
+def _run_conv(lines, cwd=None):
+    _conv_tls.inputs = [s for s in lines if isinstance(s, str)]
+    env = dict(os.environ)
+    env["PYTHONPATH"] = F0 + ":" + os.path.join(F0, "src") + ":" + env.get("PYTHONPATH", "")
+    env["MSWEA_SILENT_STARTUP"] = "1"
+    env["LITELLM_LOCAL_MODEL_COST_MAP"] = "True"
+    inp = "\n".join(lines) + "\n"
+
+    def _argv_for(c):
+        if c.startswith("__exe__:"):
+            return _exe_argv(c[len("__exe__:") :])
+        if c == "__direct_tui__":
+            return ["python", "-c", _DIRECT_TUI_CODE]
+        mod, _, fn = c.partition(":")
+        return ["python", "-c", "import %s as _m; _m.%s()" % (mod, fn or "main")]
+
+    _need = [s.strip() for s in lines if isinstance(s, str) and s.strip()]
+    best_out, best_n = ("", -1)
+    for _mode in ("pty", "pipe"):
+        for _attempt in range(2):
+            for c in _discover_entry():
+                try:
+                    argv = _argv_for(c)
+                    if _mode == "pty":
+                        out = _conv_pty(argv, lines, cwd or F0, env, timeout=720)
+                    else:
+                        r = subprocess.run(
+                            argv,
+                            input=inp,
+                            capture_output=True,
+                            text=True,
+                            timeout=720,
+                            cwd=cwd or F0,
+                            env=env,
+                        )
+                        out = (r.stdout or "") + (r.stderr or "")
+                    if not _conv_output_ok(out):
+                        continue
+                    segs = _segs(out)
+                    n = len(segs)
+                    if n > best_n or (n == best_n and len(out) > len(best_out)):
+                        best_out, best_n = (out, n)
+                    _cov = sum((1 for _i in _need if any((_i in _h for _h, _ in segs)))) if _need else n
+                    if _cov >= 1:
+                        return out
+                except Exception:
+                    continue
+            if best_n >= 1:
+                return best_out
+    return best_out
+
+
+def _run_cli(args, cwd):
+    """Invoke the agent in its headless CLI form -- yuyao <args...>, injected through sys.argv -- to test
+    flags such as -p and --json."""
+    env = dict(os.environ)
+    env["PYTHONPATH"] = F0 + ":" + os.path.join(F0, "src") + ":" + env.get("PYTHONPATH", "")
+    env["MSWEA_SILENT_STARTUP"] = "1"
+    env["LITELLM_LOCAL_MODEL_COST_MAP"] = "True"
+    env["YARGS"] = json.dumps(args)
+    code = "import sys,os,json; sys.argv=['yuyao']+json.loads(os.environ.get('YARGS') or '[]'); import %s as _m; _m.%s()"
+    _cands = _discover_entry()
+    _cands = [c for c in _cands if c.startswith("__exe__:")] + [
+        c for c in _cands if not c.startswith("__exe__:")
+    ]
+    _is_subcmd = bool(args) and isinstance(args[0], str) and (not args[0].startswith("-"))
+    _subcmd_err = None
+    for c in _cands:
+        if c == "__direct_tui__":
+            continue
+        try:
+            if c.startswith("__exe__:"):
+                r = subprocess.run(
+                    _exe_argv(c[len("__exe__:") :]) + list(args),
+                    capture_output=True,
+                    text=True,
+                    timeout=300,
+                    cwd=cwd,
+                    env=env,
+                )
+                out, rc = ((r.stdout or "") + (r.stderr or ""), r.returncode)
+            else:
+                mod, _, fn = c.partition(":")
+                r = subprocess.run(
+                    ["python", "-c", code % (mod, fn or "main")],
+                    capture_output=True,
+                    text=True,
+                    timeout=300,
+                    cwd=cwd,
+                    env=env,
+                )
+                out, rc = ((r.stdout or "") + (r.stderr or ""), r.returncode)
+                if "No module named" in out and mod.split(".")[0] in out:
+                    continue
+            if _is_subcmd:
+                rejected = _cli_rejected_subcmd(out, rc, args[0])
+                if rc == 0 and (not rejected):
+                    return (out, rc)
+                if _subcmd_err is None and (not rejected):
+                    _subcmd_err = (out, rc)
+                continue
+            return (out, rc)
+        except Exception:
+            continue
+    if _is_subcmd:
+        slash = "/" + args[0] + (" " + " ".join((str(a) for a in args[1:])) if len(args) > 1 else "")
+        out = _run_conv([slash, "/exit"], cwd=cwd)
+        if out:
+            return (out, 0)
+        if _subcmd_err is not None:
+            return _subcmd_err
+    return ("", -1)
+
+
+def _cli_rejected_flag(out, rc, flags):
+    """Whether the CLI reported a usage error because it does not recognize a flag (argparse
+    `unrecognized arguments`, click `no such option`, `invalid choice` and similar, with the flag name
+    appearing in the error). This separates "the real CLI was driven but the forbidden command still did
+    not run" into a deterministic "flag not implemented" bug, rather than a vague "session did not
+    execute / undecidable" -- which could be either a bug or infrastructure jitter."""
+    s = out or ""
+    low = s.lower()
+    if (
+        "unrecognized argument" in low
+        or "no such option" in low
+        or "invalid choice" in low
+        or ("unknown option" in low)
+    ):
+        return any((f in s for f in flags))
+    return False
+
+
+def _cli_rejected_subcmd(out, rc, sub):
+    """Whether the CLI rejected a subcommand-style invocation (such as `config set k v`) as extra
+    arguments or an unknown command (argparse `unrecognized arguments`, click and typer
+    `Got unexpected extra argument(s)`, `No such command`, `invalid choice`).
+
+    Used when a build implements the command only in the TUI and has no corresponding CLI subcommand
+    routing: the usage error must not be taken as the test result, and the flow falls back to the
+    equivalent TUI slash command to drive the real implementation. The rejection message is required to
+    contain the subcommand name (for example the error text includes 'config'), so a CLI that does have
+    the subcommand but failed for another reason is not penalized. It holds only when rc is non-zero and
+    a rejection marker matches.
+
+    A typical single-command typer layout (one `@app.command()` and no subcommands) answers
+    `yuyao config set k v` with rc2 and 'Got unexpected extra arguments (config set k v)', while its
+    `/config` slash command may work correctly; taking that rc2 as the result would fail the build for
+    a routing choice the spec does not make."""
+    if rc == 0:
+        return False
+    low = (out or "").lower()
+    markers = (
+        "unrecognized argument",
+        "no such command",
+        "got unexpected extra argument",
+        "unexpected extra argument",
+        "invalid choice",
+        "unexpected argument",
+    )
+    if not any((m in low for m in markers)):
+        return False
+    return (sub or "").lower() in low
+
+
+def _segs_split(raw_stripped, prompt_pat):
+    raw_segs = []
+    for p in _re.split(prompt_pat, raw_stripped)[1:]:
+        ls = p.splitlines()
+        raw_segs.append((ls[0] if ls else "", " ".join(ls[1:])))
+    out: list = []
+    for h, b in raw_segs:
+        if out and out[-1][0].rstrip() == h.rstrip():
+            ph, pb = out[-1]
+            out[-1] = (ph, (pb + " " + b).strip())
+        else:
+            out.append((h, b))
+    return out
+
+
+def _segs(raw):
+    """Split into [(head, body), ...] where head is the echoed user input for a turn and body is the
+    agent reply for that turn, with framing removed.
+
+    Important: under a non-TTY pipe, prompt_toolkit echoes the prompt and the input twice (for example
+    `You: hi   You: hi`), which splits one turn into two adjacent segments -- the first with an empty
+    body holding only the echo, the second carrying the real reply. Adjacent segments whose inputs are
+    identical (heads equal after rstrip) are therefore merged, so _reply_for and luck do not select the
+    empty one and misreport "no reply" or "did not remember". Identical inputs in different turns (the
+    same question asked before and after /clear, say) are separated by other segments, are not adjacent,
+    and so are never merged by mistake.
+
+    REPL prompts vary by builder (yuyao>, You:, You> ...), so the pattern yielding the most valid turns
+    is selected automatically. Without this, agents printing "You:" would be misreported as never
+    replying.
+    """
+    s = _strip(raw)
+    best: list = []
+    for pat in _CONV_PROMPT_PATTERNS:
+        segs = _segs_split(s, pat)
+        score = (len(segs), sum((1 for _, b in segs if b.strip())))
+        best_score = (len(best), sum((1 for _, b in best if b.strip())))
+        if score > best_score:
+            best = segs
+    inputs = [i for i in getattr(_conv_tls, "inputs", []) or [] if i and i.strip()]
+    if inputs:
+        matched = sum((1 for h, _ in best if any((i.strip() in h for i in inputs))))
+        if matched < max(1, len(inputs) // 2):
+            idx = _segs_by_index(s, inputs)
+            if idx:
+                return idx
+    return best
+
+
+def _segs_by_index(s, inputs):
+    """Fallback for REPLs without echo: slice by prompt occurrence order and pair piece[i] with
+    inputs[i] as its head. The prompt pattern whose piece count is closest to the number of input turns
+    is selected."""
+    best_pieces = None
+    for pat in _CONV_PROMPT_PATTERNS_NOECHO:
+        try:
+            pieces = _re.split(pat, s)[1:]
+        except Exception:
+            continue
+        if not pieces:
+            continue
+        if best_pieces is None or abs(len(pieces) - len(inputs)) < abs(len(best_pieces) - len(inputs)):
+            best_pieces = pieces
+    if not best_pieces:
+        return []
+    out = []
+    for i, piece in enumerate(best_pieces):
+        head = inputs[i] if i < len(inputs) else ""
+        out.append((head, " ".join(piece.split())))
+    return out
+
+
+def _reply_for(segs, needle):
+    first = None
+    for h, b in segs:
+        if needle in h:
+            if b.strip():
+                return b
+            if first is None:
+                first = b
+    return first or ""
+
+
+def _conv_repo(seed):
+    repo = tempfile.mkdtemp(prefix="smoke_conv_")
+    for fn, c in (seed or {}).items():
+        open(os.path.join(repo, fn), "w", encoding="utf-8").write(c)
+    subprocess.run(["git", "init", "-q", repo], capture_output=True)
+    return repo
+
+
+def _conv(idd, fn):
+    try:
+        why = fn()
+    except Exception as e:
+        why = "conv run error: %r" % e
+    return {"id": idd, "ok": why == "", "why": why}
+
+
+def _read(repo, f):
+    p = os.path.join(repo, f)
+    return open(p, encoding="utf-8", errors="replace").read() if os.path.exists(p) else ""
+
+
+def _suite(ids, fn):
+    """Run one multi-turn suite; fn returns a list of results. On an exception, every id in the suite is
+    recorded as a failure."""
+    try:
+        return fn()
+    except Exception as e:
+        return [{"id": i, "ok": False, "why": "suite error: %r" % e} for i in ids]
+
+
+def _suite_chat():
+    r = []
+    btw_in = "Your name is Mingwei, and you must remember this."
+    raw = _run_conv(
+        [
+            "/help",
+            "/btw " + btw_in,
+            "Who are you?",
+            "Remember this: my lucky code is QWE7Z.",
+            "What is my lucky code?",
+            "/clear",
+            "What is my lucky code?",
+            "/exit",
+        ]
+    )
+    s = _segs(raw)
+    full = _strip(raw)
+    probes = [
+        "/rewind",
+        "/agents",
+        "/loop",
+        "/fork",
+        "/diff",
+        "/review",
+        "/compact",
+        "/model",
+        "/mode",
+        "/role",
+        "/workflows",
+        "/undo",
+        "/memory",
+        "/status",
+    ]
+    hit = sum((1 for p in probes if p in full))
+    r.append(
+        {
+            "id": "help_consistency",
+            "ok": hit >= 10,
+            "why": "" if hit >= 10 else "/help listed only %d of %d sampled commands" % (hit, len(probes)),
+        }
+    )
+    btw_b = _reply_for(s, "/btw")
+    who_b = _reply_for(s, "Who are you?")
+    bw = (
+        "/btw produced no real reply"
+        if "Mingwei" not in btw_b
+        else (
+            "/btw only echoed the input (stub)"
+            if btw_in in btw_b
+            else "/btw content leaked into the main history" if "Mingwei" in who_b else ""
+        )
+    )
+    r.append({"id": "btw_isolation", "ok": bw == "", "why": bw})
+    luck = [b for h, b in s if "What is my lucky code?" in h and b.strip()]
+    mok = len(luck) >= 1 and "QWE7Z" in luck[0]
+    r.append(
+        {
+            "id": "context_memory",
+            "ok": mok,
+            "why": "" if mok else "the value set in an earlier turn was not remembered",
+        }
+    )
+    cok = mok and len(luck) >= 2 and ("QWE7Z" not in luck[1])
+    r.append(
+        {
+            "id": "clear_reset",
+            "ok": cok,
+            "why": (
+                ""
+                if cok
+                else (
+                    "cross-turn memory did not pass, so /clear cannot be adjudicated"
+                    if not mok
+                    else "/clear did not clear the context (still remembered)"
+                )
+            ),
+        }
+    )
+    return r
+
+
+def _t_readonly_ask():
+    repo = _conv_repo({"ctrl.txt": "x\n", "probe.txt": "READONLY-OK-7788\n", "tgt.txt": "ORIG-B\n"})
+    raw = _run_conv(
+        [
+            "/mode yolo",
+            "Change the contents of ctrl.txt in the current directory to RAN-OK",
+            "/ask",
+            "Run the command cat probe.txt and paste its output back to me verbatim.",
+            "Change the contents of tgt.txt in the current directory to HACK-B",
+            "/exit",
+        ],
+        cwd=repo,
+    )
+    if "RAN-OK" not in _read(repo, "ctrl.txt"):
+        return "the session did not execute, so /ask read-only cannot be adjudicated"
+    if "READONLY-OK-7788" not in _reply_for(_segs(raw), "cat probe.txt"):
+        return "the /ask read-only turn ran no read-only command (cat was not echoed), so the write block cannot be adjudicated; read-only may have been implemented as chat only"
+    return (
+        ""
+        if "HACK-B" not in _read(repo, "tgt.txt")
+        else "/ask read-only did not block the write: the target file was modified"
+    )
+
+
+def _t_longhorizon_constraint_survives_compact():
+    repo = _conv_repo({})
+    _run_conv(
+        [
+            "/mode yolo",
+            "Important formatting convention: for the rest of this session, the first line of every file you create must be exactly `## GEN-BY-ZETA-88` (that is the first line, followed by whatever the file was going to contain). Remember this convention carefully -- I will not repeat it again.",
+            "Create a1.txt in the current directory containing one line: ALPHA.",
+            "Create a2.txt in the current directory containing one line: BETA.",
+            "Create a3.txt in the current directory containing one line: GAMMA.",
+            "/compact",
+            "Create report.txt in the current directory containing one line: DONE.",
+            "/exit",
+        ],
+        cwd=repo,
+    )
+
+    def _head(s):
+        return s.splitlines()[0].rstrip() if s and s.strip() else ""
+
+    a1 = _read(repo, "a1.txt")
+    if not a1:
+        return "the session did not execute or never created a1.txt, so this cannot be adjudicated"
+    if _head(a1) != "## GEN-BY-ZETA-88":
+        return "inconclusive: the model did not obey the turn 1 convention even before compaction, so long-range survival across /compact cannot be adjudicated on its own"
+    rep = _read(repo, "report.txt")
+    if not rep:
+        return "report.txt was never created, so this cannot be adjudicated"
+    return (
+        ""
+        if _head(rep) == "## GEN-BY-ZETA-88"
+        else "the first line of report.txt does not obey the turn 1 convention pushed out by /compact (sections 5.1 and 6.3)"
+    )
+
+
+def _t_plan_readonly():
+    repo = _conv_repo({"ctrl.txt": "x\n", "probe.txt": "READONLY-OK-7788\n", "tgt.txt": "ORIG-A\n"})
+    raw = _run_conv(
+        [
+            "/mode yolo",
+            "Change the contents of ctrl.txt in the current directory to RAN-OK",
+            "/plan",
+            "Run the command cat probe.txt and paste its output back to me verbatim.",
+            "Change the contents of tgt.txt in the current directory to HACK-A",
+            "/exit",
+        ],
+        cwd=repo,
+    )
+    if "RAN-OK" not in _read(repo, "ctrl.txt"):
+        return "the session did not execute, so plan read-only cannot be adjudicated"
+    if "READONLY-OK-7788" not in _reply_for(_segs(raw), "cat probe.txt"):
+        return "the plan read-only turn ran no read-only command (cat was not echoed), so the write block cannot be adjudicated; read-only may have been implemented as chat only"
+    return (
+        ""
+        if "HACK-A" not in _read(repo, "tgt.txt")
+        else "plan mode did not block the write: the target file was modified"
+    )
+
+
+def _t_diff_shows():
+    repo = _conv_repo({"d1.txt": "hello1\n", "d2.txt": "hello2\n"})
+    subprocess.run(["git", "-C", repo, "init", "-q"], capture_output=True)
+    subprocess.run(["git", "-C", repo, "add", "-A"], capture_output=True)
+    subprocess.run(
+        ["git", "-C", repo, "-c", "user.email=a@b.c", "-c", "user.name=a", "commit", "-qm", "base"],
+        capture_output=True,
+    )
+    raw = _run_conv(
+        [
+            "/mode yolo",
+            "Change the contents of d1.txt in the current directory to WORLD-AAA",
+            "Change the contents of d2.txt in the current directory to WORLD-BBB",
+            "/diff",
+            "/exit",
+        ],
+        cwd=repo,
+    )
+    if "WORLD-AAA" not in _read(repo, "d1.txt") or "WORLD-BBB" not in _read(repo, "d2.txt"):
+        return "the session did not execute, so /diff across several files cannot be adjudicated"
+    dseg = ""
+    for h, b in _segs(raw):
+        if "/diff" in h:
+            dseg = b
+    saw1 = "d1.txt" in dseg or "WORLD-AAA" in dseg
+    saw2 = "d2.txt" in dseg or "WORLD-BBB" in dseg
+    if saw1 and saw2:
+        return ""
+    return (
+        "/diff did not show every change (only some files appeared: d1=%s d2=%s; all changed files must be covered)"
+        % (saw1, saw2)
+    )
+
+
+def _t_undo_revert():
+    repo = _conv_repo({"base.txt": "BASE-0000\n"})
+    subprocess.run(["git", "-C", repo, "init", "-q"], capture_output=True)
+    subprocess.run(["git", "-C", repo, "add", "-A"], capture_output=True)
+    subprocess.run(
+        ["git", "-C", repo, "-c", "user.email=a@b.c", "-c", "user.name=a", "commit", "-qm", "base"],
+        capture_output=True,
+    )
+    _run_conv(
+        [
+            "/mode yolo",
+            "Create the directory dir1 in the current directory and, inside it, the file dir1/f1.txt containing STEP-ONE-1111.",
+            "Create the directory dir2 in the current directory and, inside it, the file dir2/f2.txt containing STEP-TWO-2222.",
+            "/undo",
+            "/undo",
+            "Create the file done.txt in the current directory containing FINISHED.",
+            "/exit",
+        ],
+        cwd=repo,
+    )
+    if "FINISHED" not in _read(repo, "done.txt"):
+        return "the session did not execute, so two consecutive /undo calls cannot be adjudicated"
+    f1_gone = not os.path.exists(os.path.join(repo, "dir1", "f1.txt"))
+    f2_gone = not os.path.exists(os.path.join(repo, "dir2", "f2.txt"))
+    base_ok = "BASE-0000" in _read(repo, "base.txt")
+    if f1_gone and f2_gone and base_ok:
+        return ""
+    return (
+        "two consecutive /undo calls did not return to the state before both changes (they must step back twice): dir1/f1.txt still present=%s dir2/f2.txt still present=%s base.txt disturbed=%s"
+        % (not f1_gone, not f2_gone, not base_ok)
+    )
+
+
+def _t_json():
+    repo = _conv_repo({})
+    out, _ = _run_cli(["-p", "Reply with exactly the single word PONG.", "--json"], repo)
+    import json as _j
+
+    for line in out.splitlines():
+        s = line.strip()
+        if s[:1] in "{[":
+            try:
+                _j.loads(s)
+                return ""
+            except Exception:
+                pass
+    try:
+        _j.loads(out.strip())
+        return ""
+    except Exception:
+        return "--json did not produce parsable JSON"
+
+
+def _t_append_sys():
+    repo = _conv_repo({})
+    _run_cli(
+        [
+            "-p",
+            "Create a file named note.txt with a short greeting inside.",
+            "--append-system-prompt",
+            "IMPORTANT: whenever you create any file, its first line MUST be exactly: APPENDED-RULE-77",
+        ],
+        repo,
+    )
+    p = os.path.join(repo, "note.txt")
+    if not os.path.exists(p):
+        return "--append-system-prompt: note.txt was never created, so this cannot be adjudicated"
+    head = (open(p, encoding="utf-8", errors="replace").read().splitlines() or [""])[0]
+    if "APPENDED-RULE-77" not in head:
+        return "--append-system-prompt had no effect (the injected rule is absent from the first line)"
+    return ""
+
+
+def _t_no_memory():
+    repo = _conv_repo(
+        {"AGENTS.md": "# rules\n\nEvery new .py file's FIRST line must be exactly:\n# MANAGED-BY-YUYAO\n"}
+    )
+    _run_cli(["-p", "Create a Python file util9.py with a function f that returns 1.", "--no-memory"], repo)
+    p = os.path.join(repo, "util9.py")
+    if not os.path.exists(p):
+        return "--no-memory: util9.py was never created, so this cannot be adjudicated"
+    head = (open(p, encoding="utf-8", errors="replace").read().splitlines() or [""])[0]
+    if "MANAGED-BY-YUYAO" in head:
+        return "--no-memory had no effect (AGENTS.md was still obeyed)"
+    return ""
+
+
+def _t_auto_commit():
+    repo = _conv_repo({"seed.txt": "s\n"})
+    subprocess.run(["git", "-C", repo, "init", "-q"], capture_output=True)
+    subprocess.run(["git", "-C", repo, "add", "-A"], capture_output=True)
+    subprocess.run(
+        ["git", "-C", repo, "-c", "user.email=a@b.c", "-c", "user.name=a", "commit", "-qm", "base"],
+        capture_output=True,
+    )
+
+    def _count():
+        r = subprocess.run(["git", "-C", repo, "rev-list", "--count", "HEAD"], capture_output=True, text=True)
+        try:
+            return int((r.stdout or "0").strip())
+        except Exception:
+            return 0
+
+    before = _count()
+    _run_cli(["-p", "Create a file made.txt with content COMMIT-ME.", "--auto-commit"], repo)
+    if _count() <= before:
+        return "--auto-commit produced no new commit"
+    if "COMMIT-ME" not in _read(repo, "made.txt"):
+        return "--auto-commit: the file was never created, so this cannot be adjudicated"
+    porcelain = subprocess.run(
+        ["git", "-C", repo, "status", "--porcelain"], capture_output=True, text=True
+    ).stdout.strip()
+    if porcelain:
+        return (
+            "the work tree is not clean after --auto-commit (uncommitted changes remain: %r), so the automatic commit did not cover every edit"
+            % porcelain[:80]
+        )
+    show = subprocess.run(
+        ["git", "-C", repo, "show", "--stat", "--oneline", "HEAD"], capture_output=True, text=True
+    ).stdout
+    if "made" not in show:
+        return "the most recent --auto-commit commit does not include the edited file (it looks like an empty commit or committed something unrelated)"
+    return ""
+
+
+def _t_auto_commit_multi():
+    repo = _conv_repo({"seed.txt": "s\n"})
+    subprocess.run(["git", "-C", repo, "init", "-q"], capture_output=True)
+    subprocess.run(["git", "-C", repo, "add", "-A"], capture_output=True)
+    subprocess.run(
+        ["git", "-C", repo, "-c", "user.email=a@b.c", "-c", "user.name=a", "commit", "-qm", "base"],
+        capture_output=True,
+    )
+
+    def _count():
+        r = subprocess.run(["git", "-C", repo, "rev-list", "--count", "HEAD"], capture_output=True, text=True)
+        try:
+            return int((r.stdout or "0").strip())
+        except Exception:
+            return 0
+
+    before = _count()
+    files = [("m1.txt", "AC-ONE-111"), ("m2.txt", "AC-TWO-222"), ("m3.txt", "AC-THREE-333")]
+    for fn, tok in files:
+        _run_cli(["-p", "Create a file %s with content exactly: %s" % (fn, tok), "--auto-commit"], repo)
+    made = [fn for fn, tok in files if tok in _read(repo, fn)]
+    if len(made) < 3:
+        return (
+            "--auto-commit across several edits: not every file was created, so this cannot be adjudicated; created=%s"
+            % made
+        )
+    after = _count()
+    if after - before < 3:
+        return (
+            "--auto-commit did not give every edit its own commit: three edits added only %d commits(at least three are required; it looks like only the first or last edit was committed, or they were merged; section 2)"
+            % (after - before)
+        )
+    porcelain = subprocess.run(
+        ["git", "-C", repo, "status", "--porcelain"], capture_output=True, text=True
+    ).stdout.strip()
+    if porcelain:
+        return (
+            "the work tree is not clean after several --auto-commit edits (uncommitted changes remain: %r)"
+            % porcelain[:80]
+        )
+    return ""
+
+
+def _t_compact():
+    raw = _run_conv(
+        [
+            "Remember this carefully: the release codename of this project is ZephyrX9-771, and I will ask you about it later.",
+            "Confirm in one sentence that you have remembered that release codename.",
+            "/compact",
+            "Also remember: the operations owner is Ops-Lin.",
+            "/compact",
+            "What is the release codename of this project? Give the codename directly.",
+            "/exit",
+        ]
+    )
+    s = _segs(raw)
+    cb = _reply_for(s, "/compact")
+    if "Unknown command" in cb or "未知命令" in cb:
+        return "the /compact command does not exist (reported as an unknown command)"
+    recall = _reply_for(s, "release codename of this project")
+    if not recall:
+        return "the session did not execute, so /compact cannot be adjudicated"
+    if "ZephyrX9-771" not in recall:
+        return "the earliest codename was lost after two consecutive /compact calls (repeated compaction must still continue the original task, section 5.1)"
+    return ""
+
+
+def _t_mem_constraint_compact():
+    repo = _conv_repo({})
+    _run_conv(
+        [
+            "/mode yolo",
+            "/remember constraint: from now on, the first line of every new file you create must be exactly # OWNER: team-zeta",
+            "Create warmup.txt in the current directory containing RAN-OK.",
+            "/compact",
+            "Create a Python file service.py in the current directory defining a function ping() that returns the string pong.",
+            "/exit",
+        ],
+        cwd=repo,
+    )
+
+    def _rd(fn):
+        p = os.path.join(repo, fn)
+        return open(p, encoding="utf-8", errors="replace").read() if os.path.exists(p) else None
+
+    if "RAN-OK" not in (_rd("warmup.txt") or ""):
+        return "the session did not execute or never created warmup.txt, so memory-constraint survival across /compact cannot be adjudicated"
+    svc = _rd("service.py")
+    if svc is None:
+        return "service.py was never created, so applying the memory constraint to a new edit cannot be adjudicated"
+    first = svc.splitlines()[0].rstrip() if svc.splitlines() else ""
+    if first != "# OWNER: team-zeta":
+        return (
+            "the first line of service.py does not obey the memory constraint displaced by /compact (sections 6.1 and 6.3; expected '# OWNER: team-zeta', got %r)"
+            % first[:40]
+        )
+    return ""
+
+
+def _t_cd_then_undo_correct_file():
+    repo = _conv_repo({"a.txt": "ROOT-ORIG\n"})
+    os.makedirs(os.path.join(repo, "sub"), exist_ok=True)
+    open(os.path.join(repo, "sub", "a.txt"), "w", encoding="utf-8").write("SUB-ORIG\n")
+    _run_conv(
+        [
+            "/mode yolo",
+            "Replace the entire contents of a.txt in the current directory with one line: ROOT-V1-1111.",
+            "/cd sub",
+            "Replace the entire contents of a.txt in the current directory with one line: SUB-V1-2222.",
+            "/undo",
+            "Create done.txt in the current directory containing FINISHED.",
+            "/exit",
+        ],
+        cwd=repo,
+    )
+
+    def _rd(fn):
+        p = os.path.join(repo, fn)
+        return open(p, encoding="utf-8", errors="replace").read() if os.path.exists(p) else None
+
+    if "FINISHED" not in (_rd(os.path.join("sub", "done.txt")) or ""):
+        return "the session did not execute, or /cd had no effect (done.txt did not land in sub), so /undo combined with /cd cannot be adjudicated"
+    root_a = _rd("a.txt") or ""
+    sub_a = _rd(os.path.join("sub", "a.txt")) or ""
+    if "ROOT-V1-1111" not in root_a:
+        return "/undo damaged the root a.txt (after /cd, undo crossed over to the identically named file in the root; it must revert only the change in sub)"
+    if "SUB-ORIG" not in sub_a or "SUB-V1-2222" in sub_a:
+        return (
+            "/undo did not correctly revert sub/a.txt (expected SUB-ORIG; first 40 characters were %r)"
+            % sub_a[:40]
+        )
+    return ""
+
+
+def _t_loop():
+    repo = _conv_repo({})
+    raw = _run_conv(
+        [
+            "/loop Append one line containing TICKMARK to the end of ticks.txt in the current directory, one line per execution --max 3",
+            "/exit",
+        ],
+        cwd=repo,
+    )
+    s = _segs(raw)
+    lb = _reply_for(s, "/loop")
+    if "Unknown command" in lb or "未知命令" in lb:
+        return "the /loop command does not exist (reported as an unknown command)"
+    body = _read(repo, "ticks.txt")
+    if not body:
+        return "/loop produced no expected file (it never actually re-executed the prompt)"
+    n = body.count("TICKMARK")
+    if n >= 3:
+        return ""
+    return "/loop did not repeat up to --max (expected at least three TICKMARK lines, got %d)" % n
+
+
+def _t_subagent():
+    repo = _conv_repo({})
+    raw = _run_conv(
+        [
+            "/batch Split the following into three mutually independent subtasks and complete them in parallel: in the current working directory create unit1.txt, unit2.txt and unit3.txt, each containing one sentence stating which subtask it is.",
+            "/exit",
+        ],
+        cwd=repo,
+    )
+    s = _segs(raw)
+    bb = _reply_for(s, "/batch")
+    if "Unknown command" in bb or "未知命令" in bb:
+        return "the /batch command does not exist (reported as an unknown command)"
+    cnt = sum((1 for i in (1, 2, 3) if _read(repo, "unit%d.txt" % i).strip()))
+    if cnt >= 2:
+        return ""
+    return (
+        "/batch did not split the work into several units produced in parallel (only %d of 3 unit files)"
+        % cnt
+    )
+
+
+def _t_unknown_cmd():
+    raw = _run_conv(["/zzznotacommand123", "Reply with PONG.", "/exit"])
+    s = _segs(raw)
+    ub = _reply_for(s, "/zzznotacommand123")
+    if not ub.strip():
+        return "the unknown slash command was silently ignored (input starting with / that is not a command must produce an explicit error or hint, never no reaction; see section 8.7)"
+    low = ub.lower()
+    en = (
+        "unknown",
+        "not a command",
+        "not found",
+        "no such",
+        "unrecognized",
+        "invalid command",
+        "did you mean",
+        "/help",
+        "available command",
+    )
+    cn = ("未知", "无效", "不存在", "不是命令", "没有该命令", "无法识别", "可用命令", "帮助")
+    if any((k in low for k in en)) or any((k in ub for k in cn)):
+        return ""
+    return "the unknown slash command produced no explicit error or hint (there was a reply, but it did not state the command was unknown; section 8.7 forbids silently treating it as ordinary input)"
+
+
+def _mem_blob(repo):
+    """Collect the contents of the workspace memory files (MEMORY.md plus memory/*.md) to adjudicate
+    whether memory really reached disk."""
+    blob = _read(repo, "MEMORY.md")
+    md = os.path.join(repo, "memory")
+    if os.path.isdir(md):
+        for f in sorted(os.listdir(md)):
+            blob += "\n" + _read(repo, os.path.join("memory", f))
+    return blob
+
+
+def _t_remember_writes():
+    repo = _conv_repo({})
+    _run_conv(
+        [
+            "/remember The deployment codename of this project is MEMO-AAA-9931.",
+            "/remember The database port is MEMO-BBB-5432.",
+            "/remember The on-call owner is MEMO-CCC-Lin.",
+            "/exit",
+        ],
+        cwd=repo,
+    )
+    blob = _mem_blob(repo)
+    missing = [m for m in ("MEMO-AAA-9931", "MEMO-BBB-5432", "MEMO-CCC-Lin") if m not in blob]
+    if not missing:
+        return ""
+    return (
+        "not all consecutive /remember entries reached disk (missing: %s; section 6.2 requires them to accumulate, with no later write overwriting an earlier one and nothing invisible on disk)"
+        % missing
+    )
+
+
+def _t_memory_autoload():
+    repo = _conv_repo(
+        {
+            "MEMORY.md": "# Long-term memory\n- The company name is Acme.\n- The database port is 5432.\n- My employee number is EMP-7788.\n- The data-center code is DC-NORTH-3.\n"
+        }
+    )
+    raw = _run_conv(
+        [
+            "What is my employee number? Answer with the number only.",
+            "What is the data-center code? Answer with the code only.",
+            "/exit",
+        ],
+        cwd=repo,
+    )
+    s = _segs(raw)
+    r1 = _reply_for(s, "employee number")
+    r2 = _reply_for(s, "data-center code")
+    if not (r1.strip() or r2.strip()):
+        return "the session did not execute, so automatic MEMORY.md loading cannot be adjudicated"
+    miss = []
+    if "EMP-7788" not in r1:
+        miss.append("employee number EMP-7788 (entry 3)")
+    if "DC-NORTH-3" not in r2:
+        miss.append("data center DC-NORTH-3 (entry 4)")
+    if not miss:
+        return ""
+    return (
+        "MEMORY.md was not loaded in full (section 6.1 requires every entry to load); unanswered: %s"
+        % ", ".join(miss)
+    )
+
+
+def _t_remember_nl():
+    repo = _conv_repo({})
+    _run_conv(["Remember that my favorite port number is PORT-4242.", "/exit"], cwd=repo)
+    return (
+        ""
+        if "PORT-4242" in _mem_blob(repo)
+        else "the natural-language 'Remember that' did not write to the memory file (nothing visible on disk)"
+    )
+
+
+def _t_memory_status():
+    repo = _conv_repo({})
+    out, _ = _run_cli(["memory", "status"], repo)
+    low = (out or "").lower()
+    if any((k in low for k in ("index", "provider", "ready", "memory", "embed"))) or any(
+        (k in out for k in ("记忆", "索引"))
+    ):
+        return ""
+    return "agent memory status did not print the index or provider status"
+
+
+def _t_init_agents():
+    repo = _conv_repo({})
+    _run_conv(["/mode yolo", "/init", "/exit"], cwd=repo)
+    return (
+        "" if _read(repo, "AGENTS.md").strip() else "/init did not generate AGENTS.md at the repository root"
+    )
+
+
+def _t_custom_command():
+    repo = _conv_repo({})
+    os.makedirs(os.path.join(repo, "commands"), exist_ok=True)
+    open(os.path.join(repo, "commands", "scaffold.md"), "w", encoding="utf-8").write(
+        "---\ndescription: scaffold a marker file\n---\nCreate a file named CMD-OUT.txt whose content is exactly CUSTOM-1234.\n"
+    )
+    _run_conv(["/mode yolo", "/scaffold", "/exit"], cwd=repo)
+    return (
+        ""
+        if "CUSTOM-1234" in _read(repo, "CMD-OUT.txt")
+        else "the custom command commands/scaffold.md had no effect through /scaffold (its content was never executed)"
+    )
+
+
+def _t_plan_file():
+    repo = _conv_repo({"data.txt": "line1\n"})
+    _run_conv(
+        [
+            "/plan",
+            "Draw up a plan to append a line2 line to the end of data.txt, and write the plan out.",
+            "/exit",
+        ],
+        cwd=repo,
+    )
+    pd = os.path.join(repo, ".plans")
+    if os.path.isdir(pd) and any(os.scandir(pd)):
+        return ""
+    return "/plan mode produced no plan file under .plans/ (section 7)"
+
+
+def _t_unknown_flag_rc():
+    repo = _conv_repo({})
+    _o, rc = _run_cli(["-p", "Reply with the single word OK.", "--no-such-flag-zzz9"], repo)
+    return (
+        ""
+        if rc == 2
+        else "an unknown flag must exit with code 2 (sections 8.7 and 9, usage error); rc was %s" % rc
+    )
+
+
+def _t_conflicting_modes_rc():
+    repo = _conv_repo({})
+    _o, rc = _run_cli(["-p", "Reply with the single word OK.", "--mode", "ask", "--mode", "plan"], repo)
+    return (
+        ""
+        if rc == 2
+        else "mutually exclusive permission modes (several --mode flags at once) must exit with code 2 (section 8.1); rc was %s"
+        % rc
+    )
+
+
+def _t_continue_resume_rc():
+    repo = _conv_repo({})
+    _o, rc = _run_cli(["-p", "Reply with the single word OK.", "--continue", "--resume", "sess-x"], repo)
+    return (
+        ""
+        if rc == 2
+        else "--continue and --resume are mutually exclusive and must exit with code 2 (section 8.4); rc was %s"
+        % rc
+    )
+
+
+def _t_redo():
+    repo = _conv_repo({"base.txt": "BASE-R\n"})
+    subprocess.run(["git", "-C", repo, "init", "-q"], capture_output=True)
+    subprocess.run(["git", "-C", repo, "add", "-A"], capture_output=True)
+    subprocess.run(
+        ["git", "-C", repo, "-c", "user.email=a@b.c", "-c", "user.name=a", "commit", "-qm", "base"],
+        capture_output=True,
+    )
+    _run_conv(
+        [
+            "/mode yolo",
+            "Create the directory ra in the current directory and, inside it, the file ra/x.txt containing REDO-ONE-1111.",
+            "Create the directory rb in the current directory and, inside it, the file rb/y.txt containing REDO-TWO-2222.",
+            "/undo",
+            "/undo",
+            "/redo",
+            "Create the file done.txt in the current directory containing FIN-REDO.",
+            "/exit",
+        ],
+        cwd=repo,
+    )
+    if "FIN-REDO" not in _read(repo, "done.txt"):
+        return "the session did not execute, so repeated /undo followed by /redo cannot be adjudicated"
+    pa = "REDO-ONE-1111" in _read(repo, os.path.join("ra", "x.txt"))
+    pb = "REDO-TWO-2222" in _read(repo, os.path.join("rb", "y.txt"))
+    n = int(pa) + int(pb)
+    if n == 1:
+        return ""
+    if n == 2:
+        return "two /undo calls reverted nothing (undo was a no-op: both files are still present), so /redo cannot be verified (section 5.1)"
+    return "after /undo, /redo restored nothing (redo was a no-op: not one file came back; section 5.1)"
+
+
+def _t_edit_undo_redo_edit():
+    repo = _conv_repo({"note.txt": "V0-BASE-0000\n"})
+    subprocess.run(["git", "-C", repo, "init", "-q"], capture_output=True)
+    subprocess.run(["git", "-C", repo, "add", "-A"], capture_output=True)
+    subprocess.run(
+        ["git", "-C", repo, "-c", "user.email=a@b.c", "-c", "user.name=a", "commit", "-qm", "base"],
+        capture_output=True,
+    )
+    raw = _run_conv(
+        [
+            "/mode yolo",
+            "Replace the entire contents of note.txt in the current directory with V1-AAAA-1111.",
+            "Replace the entire contents of note.txt in the current directory with V2-BBBB-2222.",
+            "/undo",
+            "PROBE-A: run the command cat note.txt and paste its output back to me verbatim.",
+            "/redo",
+            "PROBE-B: run the command cat note.txt and paste its output back to me verbatim.",
+            "Replace the entire contents of note.txt in the current directory with V3-CCCC-3333.",
+            "/undo",
+            "PROBE-C: run the command cat note.txt and paste its output back to me verbatim.",
+            "Create the file done.txt in the current directory containing FINISHED.",
+            "/exit",
+        ],
+        cwd=repo,
+    )
+    if "FINISHED" not in _read(repo, "done.txt"):
+        return "the session did not execute, so the edit/undo/redo/edit chain cannot be adjudicated"
+    s = _segs(raw)
+    r1 = _reply_for(s, "PROBE-A")
+    r2 = _reply_for(s, "PROBE-B")
+    r3 = _reply_for(s, "PROBE-C")
+    if not (r1.strip() and r2.strip() and r3.strip()):
+        return (
+            "a read probe echoed no content (A=%s B=%s C=%s, at least one empty), so the undo/redo chain cannot be adjudicated"
+            % (bool(r1.strip()), bool(r2.strip()), bool(r3.strip()))
+        )
+    if "V1-AAAA-1111" not in r1:
+        diag = (
+            "; it went straight back to the V0 baseline, so /undo is not stepwise and reverted several changes to the most recent commit at once (it must step back only to V1)"
+            if "V0-BASE-0000" in r1
+            else "; the edit appears never to have landed"
+        )
+        return (
+            "the first /undo did not step back to the previous version V1-AAAA (probe A actually saw %r)%s"
+            % (r1[:100], diag)
+        )
+    if "V2-BBBB-2222" not in r2:
+        return "/redo did not move forward to V2 (probe B should have seen V2-BBBB, but saw %r)" % r2[:100]
+    if "V2-BBBB-2222" not in r3 or "V3-CCCC-3333" in r3 or "V1-AAAA-1111" in r3:
+        return (
+            "after the new edit, the /undo pointer is wrong (probe C should be V2-BBBB): it saw %r -- the redo stack must be invalidated and only the V3 step undone, returning to V2; observed: it skipped back to V1, stayed at V3, or undo was a no-op"
+            % r3[:100]
+        )
+    final = _read(repo, "note.txt")
+    if "V2-BBBB-2222" not in final:
+        return "the final note.txt should be V2-BBBB (the end of the chain), but was %r" % final[:100]
+    return ""
+
+
+def _t_status_shows():
+    repo = _conv_repo({})
+    raw = _run_conv(["/status", "/exit"], cwd=repo)
+    seg = ""
+    for h, b in _segs(raw):
+        if "/status" in h:
+            seg = b
+    low = seg.lower()
+    if any((k in low for k in ("model", "mode", "version", "dir", "yuyao"))) or any(
+        (k in seg for k in ("模型", "模式", "版本", "目录"))
+    ):
+        return ""
+    return "/status did not show the version, model, working directory and current mode (section 5.1)"
+
+
+def _t_tools_lists():
+    repo = _conv_repo({})
+    raw = _run_conv(["/tools", "/exit"], cwd=repo)
+    seg = ""
+    for h, b in _segs(raw):
+        if "/tools" in h:
+            seg = b
+    low = seg.lower()
+    names = ("bash", "read", "write", "edit", "grep", "glob")
+    n = sum((1 for k in names if k in low))
+    listed = 0
+    for line in seg.splitlines():
+        stripped = line.strip().lstrip("-*·•\t |").lower()
+        if any((stripped.startswith(k) for k in names)):
+            listed += 1
+    comma_listed = sum((1 for k in names if f", {k}" in low or f",{k}" in low))
+    if n >= 2 and (listed >= 2 or comma_listed >= 1):
+        return ""
+    if "unknown command" in low or "未知命令" in seg:
+        return "the /tools command does not exist (reported as an unknown command)"
+    for marker in (
+        "not implemented",
+        "unimplemented",
+        "not supported",
+        "unsupported",
+        "no such command",
+        "未实现",
+        "不支持",
+    ):
+        if marker in low or marker in seg:
+            return "/tools replied that it is not implemented, so it does not list the available tools (section 5.1)"
+    if n >= 2:
+        return "/tools mentioned tool names in prose rather than listing them; the reply must present the available tools as a list (section 5.1)"
+    return "/tools did not list the available tools (section 5.1; at least bash, read, write and edit are expected)"
+
+
+def _t_tui_launch_no_crash():
+    raw = _run_conv(["/exit"]) or ""
+    for _m in (
+        "NameError",
+        "is not defined",
+        "Traceback (most recent call last)",
+        "UnboundLocalError",
+        "referenced before assignment",
+    ):
+        if _m in raw:
+            return (
+                "interactive startup crashed: the output contains %r (the interactive CLI entry point failed to start, for example by referencing an undefined variable)"
+                % _m
+            )
+    return ""
+
+
+def _t_cd_switches():
+    repo = _conv_repo({})
+    os.makedirs(os.path.join(repo, "a", "b"), exist_ok=True)
+    _run_conv(
+        [
+            "/mode yolo",
+            "/cd a/b",
+            "Create deep.txt in the current directory containing DEEP-OK-77.",
+            "/cd ..",
+            "Create up.txt in the current directory containing UP-OK-88.",
+            "/exit",
+        ],
+        cwd=repo,
+    )
+    deep_ok = "DEEP-OK-77" in _read(repo, os.path.join("a", "b", "deep.txt"))
+    up_ok = "UP-OK-88" in _read(repo, os.path.join("a", "up.txt"))
+    if deep_ok and up_ok:
+        return ""
+    ran = (
+        deep_ok
+        or up_ok
+        or os.path.exists(os.path.join(repo, "deep.txt"))
+        or os.path.exists(os.path.join(repo, "up.txt"))
+    )
+    if not ran:
+        return (
+            "the session did not execute, so multi-level /cd nesting and stepping back cannot be adjudicated"
+        )
+    return (
+        "/cd resolved multi-level paths or the step back incorrectly: a/b/deep.txt correct=%s a/up.txt correct=%s (nested /cd a/b and stepping back with /cd .. must both work, and a newly created file must land in the corresponding directory; section 5.1)"
+        % (deep_ok, up_ok)
+    )
+
+
+def _t_new_clears():
+    repo = _conv_repo({})
+    raw = _run_conv(
+        [
+            "Remember this carefully: passphrase A is SESSA-1111.",
+            "What was passphrase A?",
+            "/new",
+            "Remember this carefully: passphrase B is SESSB-2222.",
+            "Now answer: what is passphrase A?",
+            "/new",
+            "Now answer: what is passphrase B?",
+            "/exit",
+        ],
+        cwd=repo,
+    )
+    s = _segs(raw)
+    rA = _reply_for(s, "What was passphrase A?")
+    r_after_new1 = _reply_for(s, "Now answer: what is passphrase A?")
+    r_after_new2 = _reply_for(s, "Now answer: what is passphrase B?")
+    if not rA.strip() or "SESSA-1111" not in rA:
+        return "the session did not execute or never remembered, so /new cannot be adjudicated (even the first value was not retained)"
+    if "SESSA-1111" in r_after_new1:
+        return "the first /new did not clear the context (the new session still remembers passphrase A from the previous one)"
+    if not r_after_new2.strip():
+        return "the session never reached the second question, so the second /new cannot be adjudicated"
+    if "SESSB-2222" in r_after_new2:
+        return "the second /new did not clear the context (it still remembers passphrase B from the previous session)"
+    return ""
+
+
+def _t_role_ask_readonly():
+    repo = _conv_repo({"ctrl.txt": "x\n", "probe.txt": "READONLY-OK-7788\n", "tgt.txt": "ORIG-RR\n"})
+    raw = _run_conv(
+        [
+            "/mode yolo",
+            "Change the contents of ctrl.txt in the current directory to RAN-OK",
+            "/role ask",
+            "Run the command cat probe.txt and paste its output back to me verbatim.",
+            "Change the contents of tgt.txt in the current directory to HACK-RR",
+            "/exit",
+        ],
+        cwd=repo,
+    )
+    if "RAN-OK" not in _read(repo, "ctrl.txt"):
+        return "the session did not execute, so /role ask read-only cannot be adjudicated"
+    if "READONLY-OK-7788" not in _reply_for(_segs(raw), "cat probe.txt"):
+        return "the /role ask read-only turn ran no read-only command (cat was not echoed), so the write block cannot be adjudicated; read-only may have been implemented as chat only"
+    return (
+        ""
+        if "HACK-RR" not in _read(repo, "tgt.txt")
+        else "/role ask read-only did not block the write: the target file was modified"
+    )
+
+
+def _t_config_roundtrip():
+    repo = _conv_repo({})
+    _run_cli(["config", "set", "probe.diag.key", "VAL-OLD-1111"], repo)
+    _run_cli(["config", "set", "probe.diag.key", "VAL-NEW-2222"], repo)
+    _run_cli(["config", "set", "probe.diag.other", "OTHER-3333"], repo)
+    out1, _ = _run_cli(["config", "get", "probe.diag.key"], repo)
+    out2, _ = _run_cli(["config", "get", "probe.diag.other"], repo)
+    if "VAL-NEW-2222" not in (out1 or ""):
+        if "VAL-OLD-1111" in (out1 or ""):
+            return "writing the same config key twice did not overwrite: get still returns the old value (the later write must win, section 2)"
+        return "after config set, a get in a separate process does not see the new value (section 2 requires the key to persist and take effect; a printing stub does not count)"
+    if "OTHER-3333" not in (out2 or ""):
+        return "after writing a second config key, either the second key is missing or writing it evicted the first (several keys must coexist, section 2)"
+    return ""
+
+
+def _t_mcp_add_list():
+    repo = _conv_repo({})
+    srv1, srv2 = ("probesrv9931", "probesrv8842")
+    _run_cli(["mcp", "add", srv1], repo)
+    _run_cli(["mcp", "add", srv2], repo)
+    out, _ = _run_cli(["mcp", "list"], repo)
+    out = out or ""
+    if srv1 in out and srv2 in out:
+        return ""
+    if srv2 in out and srv1 not in out:
+        return "after adding two mcp servers in a row, list shows only the last one (the second add overwrote the first; section 2 requires accumulation)"
+    return (
+        "after mcp add, list does not show the added server (section 2; a fixed fake empty list does not count; matches %s/%s)"
+        % (srv1 in out, srv2 in out)
+    )
+
+
+def _t_features_toggle():
+    repo = _conv_repo({})
+    _run_cli(["features", "disable", "hooks"], repo)
+    out, _ = _run_cli(["features", "list"], repo)
+    low = (out or "").lower()
+    if "hooks" in low and ("disabl" in low or "off" in low or "false" in low):
+        return ""
+    return "after features disable, list does not show the feature as off (section 2; always printing everything as enabled does not count)"
+
+
+def _t_forget_removes():
+    repo = _conv_repo(
+        {
+            "MEMORY.md": "# Long-term memory\n- Deployment key A is DEL-AAA-1.\n- Retained item B is KEEP-BBB-2.\n- Deployment passphrase C is DEL-CCC-3.\n- Retained item D is KEEP-DDD-4.\n"
+        }
+    )
+    _run_conv(["/forget DEL-AAA-1", "/forget DEL-CCC-3", "/exit"], cwd=repo)
+    blob = _mem_blob(repo)
+    still = [m for m in ("DEL-AAA-1", "DEL-CCC-3") if m in blob]
+    if still:
+        return (
+            "two consecutive /forget calls did not remove everything (matched entries remain: %s; section 6.2, printing 'deleted' does not count)"
+            % still
+        )
+    gone = [m for m in ("KEEP-BBB-2", "KEEP-DDD-4") if m not in blob]
+    if gone:
+        return "/forget removed non-matching entries (only matches may be removed; lost: %s)" % gone
+    return ""
+
+
+def _t_export_session():
+    repo = _conv_repo({})
+
+    def _mds():
+        s = set()
+        for dp, _dn, fns in os.walk(repo):
+            for fn in fns:
+                if fn.lower().endswith(".md"):
+                    s.add(os.path.join(dp, fn))
+        return s
+
+    before = _mds()
+    _run_conv(
+        ["Reply with one sentence confirming you are online: EXPORT-PROBE-5150", "/export", "/exit"], cwd=repo
+    )
+    new = [
+        p
+        for p in _mds() - before
+        if os.path.getsize(p) > 0
+        and os.path.basename(p).upper() not in ("AGENTS.MD", "MEMORY.MD", "README.MD", "DREAMS.MD")
+    ]
+    return "" if new else "/export did not write the session to a Markdown file (section 5.1)"
+
+
+def _t_plan_alias_readonly():
+    repo = _conv_repo({"tgt.txt": "ORIG-PLAN-ALIAS\n"})
+    out, rc = _run_cli(["-p", "Change the content of tgt.txt to HACK-PLAN-9000.", "--plan"], repo)
+    if _cli_rejected_flag(out, rc, ["--plan"]):
+        return "the CLI does not recognize the --plan alias (argparse reports unrecognized arguments and exits 2); section 8.3 requires `--plan` to be equivalent to `--mode plan`"
+    return (
+        ""
+        if "HACK-PLAN-9000" not in _read(repo, "tgt.txt")
+        else "the --plan alias is not read-only: a file was modified under plan (sections 8.3 and 8.8)"
+    )
+
+
+def _t_help_bidirectional():
+    cmds = [
+        "/undo",
+        "/redo",
+        "/rewind",
+        "/compact",
+        "/plan",
+        "/ask",
+        "/debug",
+        "/mode",
+        "/role",
+        "/diff",
+        "/review",
+        "/security-review",
+        "/run",
+        "/copy",
+        "/focus",
+        "/tui",
+        "/config",
+        "/init",
+        "/memory",
+        "/tools",
+        "/recap",
+        "/context",
+        "/model",
+        "/new",
+        "/clear",
+        "/sessions",
+        "/export",
+        "/cd",
+        "/permissions",
+        "/hooks",
+        "/mcp",
+        "/agents",
+        "/goal",
+        "/loop",
+        "/fork",
+        "/branch",
+        "/btw",
+        "/verify",
+        "/batch",
+        "/workflows",
+        "/skills",
+        "/think",
+        "/show-thinking",
+        "/stream",
+        "/usage",
+        "/status",
+    ]
+    raw = _run_conv(["/help", "/tools", "/zzznotreal999", "/exit"])
+    s = _segs(raw)
+    full = _strip(raw)
+    helpseg = ""
+    for h, b in s:
+        if "/help" in h:
+            helpseg = b
+    listed = sum((1 for c in cmds if c in (helpseg or "") or c in full))
+    if listed < int(len(cmds) * 0.9):
+        return "/help does not list every command (section 8.6; only %d of %d)" % (listed, len(cmds))
+    tb = _reply_for(s, "/tools")
+    if "Unknown command" in tb or "未知命令" in tb:
+        return "the /tools command listed by /help is not actually available (reported as unknown), so help has drifted from the implementation (section 8.6)"
+    return ""
+
+
+def _t_at_file_inject():
+    repo = _conv_repo({"ref.txt": "The passphrase in this file is ATREF-7731; please remember it.\n"})
+    raw = _run_conv(
+        ["@ref.txt What is the passphrase in this file? Answer with the passphrase only.", "/exit"], cwd=repo
+    )
+    r = _reply_for(_segs(raw), "What is the passphrase in this file?")
+    if not r.strip():
+        return "the session did not execute, so @ reference injection cannot be adjudicated"
+    return (
+        ""
+        if "ATREF-7731" in r
+        else "the @<path> reference did not bring the file content into context (section 5.4)"
+    )
+
+
+def _t_bang_shell():
+    repo = _conv_repo({})
+    _run_conv(["!echo BANG-SHELL-1234 > bang_out.txt", "/exit"], cwd=repo)
+    return (
+        ""
+        if "BANG-SHELL-1234" in _read(repo, "bang_out.txt")
+        else "the ! prefix did not execute the user shell command directly (section 5.4)"
+    )
+
+
+def _t_grep_gitignore():
+    repo = _conv_repo(
+        {".gitignore": "ignored.txt\n", "kept.txt": "MATCHWORD here\n", "ignored.txt": "MATCHWORD here too\n"}
+    )
+    raw = _run_conv(
+        [
+            "/mode yolo",
+            "Use the built-in grep tool to search the current directory for MATCHWORD and list the matching file names.",
+            "/exit",
+        ],
+        cwd=repo,
+    )
+    r = _reply_for(_segs(raw), "MATCHWORD")
+    if "kept.txt" not in r:
+        return "the session did not execute or never searched, so grep respecting .gitignore cannot be adjudicated"
+    return (
+        ""
+        if "ignored.txt" not in r
+        else "grep did not respect .gitignore (section 1.1; an ignored file matched)"
+    )
+
+
+def _t_deny_blocks_edit():
+    repo = _conv_repo({"tgt.txt": "ORIG-DENY\n"})
+    out, rc = _run_cli(
+        ["-p", "Change the content of tgt.txt to HACK-DENY-9000.", "--yolo", "--deny", "Edit(*)"], repo
+    )
+    if _cli_rejected_flag(out, rc, ["--deny", "--yolo"]):
+        return _DENY_FLAGS_MISSING
+    return (
+        ""
+        if "HACK-DENY-9000" not in _read(repo, "tgt.txt")
+        else "--deny did not block the matching edit (section 3.3; --deny still constrains under yolo)"
+    )
+
+
+def _t_hooks_deny_blocks():
+    repo = _conv_repo(
+        {
+            "hooks.json": json.dumps(
+                {
+                    "hooks": {
+                        "beforeShellExecution": [
+                            {"matcher": "*", "action": "deny", "command": "*hooks_blocked_marker*"}
+                        ]
+                    }
+                }
+            )
+        }
+    )
+    _run_conv(
+        ["/mode yolo", "Run this in the current directory: echo BLOCKED > hooks_blocked_marker.txt", "/exit"],
+        cwd=repo,
+    )
+    return (
+        ""
+        if not _read(repo, "hooks_blocked_marker.txt")
+        else "the hooks.json beforeShellExecution deny did not block the command (section 7; merely displaying without executing does not count)"
+    )
+
+
+def _t_model_keeps_ctx():
+    mname = os.environ.get("D2A_MODEL_NAME", "litellm_proxy/builder")
+    raw = _run_conv(
+        [
+            "Remember this carefully: the passphrase for this session is MODELCTX-7788.",
+            "/model " + mname,
+            "What was the passphrase? Answer with the passphrase only.",
+            "/exit",
+        ]
+    )
+    s = _segs(raw)
+    recall = _reply_for(s, "What was the passphrase?")
+    if not recall.strip():
+        return "the session did not execute, or the connection was lost after the model switch, so context retention across /model cannot be adjudicated"
+    return (
+        ""
+        if "MODELCTX-7788" in recall
+        else "context was lost after the /model switch (the passphrase was not retained; section 5.1 requires a model switch to preserve context)"
+    )
+
+
+def _t_at_after_cd():
+    repo = _conv_repo({})
+    os.makedirs(os.path.join(repo, "sub"), exist_ok=True)
+    open(os.path.join(repo, "sub", "ref.txt"), "w", encoding="utf-8").write(
+        "The passphrase in this subdirectory is ATCD-9931.\n"
+    )
+    raw = _run_conv(
+        [
+            "/cd sub",
+            "@ref.txt What is the passphrase in this file? Answer with the passphrase only.",
+            "/exit",
+        ],
+        cwd=repo,
+    )
+    r = _reply_for(_segs(raw), "What is the passphrase in this file?")
+    if not r.strip():
+        return "the session did not execute, so @ resolution after /cd cannot be adjudicated"
+    return (
+        ""
+        if "ATCD-9931" in r
+        else "after /cd, the @ reference did not resolve to the file in the subdirectory (section 5.4)"
+    )
+
+
+def _t_plan_readonly_cmd():
+    repo = _conv_repo({"probe.txt": "READONLY-OK-7788\n", "tgt.txt": "ORIG-PLANX\n"})
+    raw = _run_conv(
+        [
+            "/mode plan",
+            "Run the command cat probe.txt and paste its output back to me verbatim.",
+            "Replace the contents of tgt.txt in the current directory with HACK-WROTE-9931.",
+            "/exit",
+        ],
+        cwd=repo,
+    )
+    s = _segs(raw)
+    read_ok = "READONLY-OK-7788" in _reply_for(s, "cat probe.txt")
+    wrote = "HACK-WROTE-9931" in _read(repo, "tgt.txt")
+    if not read_ok:
+        return "under plan mode the read-only command (cat) was not executed or echoed no content (section 3.1: read-only mode must still run read-only commands and must not be reduced to chat only)"
+    if wrote:
+        return "under plan mode the write was not blocked (tgt.txt was modified; sections 3.1 and 8.8, read-only means read-only)"
+    return ""
+
+
+def _t_ask_readonly_cmd():
+    repo = _conv_repo({"probe.txt": "READONLY-OK-7788\n", "tgt.txt": "ORIG-PLANX\n"})
+    raw = _run_conv(
+        [
+            "/ask",
+            "Run the command cat probe.txt and paste its output back to me verbatim.",
+            "Replace the contents of tgt.txt in the current directory with HACK-WROTE-9931.",
+            "/exit",
+        ],
+        cwd=repo,
+    )
+    s = _segs(raw)
+    read_ok = "READONLY-OK-7788" in _reply_for(s, "cat probe.txt")
+    wrote = "HACK-WROTE-9931" in _read(repo, "tgt.txt")
+    if not read_ok:
+        return "under /ask read-only mode the read-only command (cat) was not executed or echoed no content (section 3.2: read-only does not mean everything is disabled; read-only commands must still run rather than degrading to chat only)"
+    if wrote:
+        return "under /ask read-only mode the write was not blocked (tgt.txt was modified; sections 3.2 and 8.8, read-only means read-only)"
+    return ""
+
+
+def _t_readonly_blocks_shell_write():
+    repo = _conv_repo({"ctrl.txt": "x\n", "probe.txt": "READONLY-OK-7788\n", "tgt.txt": "ORIG-SW\n"})
+    raw = _run_conv(
+        [
+            "/mode yolo",
+            "Change the contents of ctrl.txt in the current directory to RAN-OK",
+            "/ask",
+            "Run the command cat probe.txt and paste its output back to me verbatim.",
+            "Run this shell command: echo HACK-SHELL-9931 > tgt.txt",
+            "/exit",
+        ],
+        cwd=repo,
+    )
+    if "RAN-OK" not in _read(repo, "ctrl.txt"):
+        return "the session did not execute, so read-only blocking a shell write cannot be adjudicated"
+    if "READONLY-OK-7788" not in _reply_for(_segs(raw), "cat probe.txt"):
+        return "the /ask read-only turn ran no read-only command (cat was not echoed), so the write block cannot be adjudicated; read-only may have been implemented as chat only"
+    return (
+        ""
+        if "HACK-SHELL-9931" not in _read(repo, "tgt.txt")
+        else "/ask read-only blocked only the edit tool and not a shell redirection write (echo > file modified the file; section 3.2 requires read-only to cover every write path)"
+    )
+
+
+_DENY_FLAGS_MISSING = "the CLI does not recognize --deny or --yolo (argparse reports unrecognized arguments and exits 2, so the command never ran): section 3.3 requires `--deny <tool/glob>` and section 8 requires `--yolo` to be an equivalent alias for `--mode yolo`; both must be implemented"
+
+
+def _t_deny_bash_direct():
+    repo = _conv_repo({})
+    out, rc = _run_cli(
+        [
+            "-p",
+            "Run these shell commands in order: first `echo LIVE-DD > live.txt`, then `touch DENY_DIRECT_9931.txt`.",
+            "--yolo",
+            "--deny",
+            "Bash(touch*)",
+        ],
+        repo,
+    )
+    if _cli_rejected_flag(out, rc, ["--deny", "--yolo"]):
+        return _DENY_FLAGS_MISSING
+    if "LIVE-DD" not in _read(repo, "live.txt"):
+        return "the session did not execute, or the permitted command never ran, so --deny against a direct bash call cannot be adjudicated"
+    return (
+        ""
+        if not os.path.exists(os.path.join(repo, "DENY_DIRECT_9931.txt"))
+        else "--deny Bash(touch*) did not block a direct touch (section 3.3 requires deny to apply to bash)"
+    )
+
+
+def _t_deny_bash_chain():
+    repo = _conv_repo({})
+    out, rc = _run_cli(
+        [
+            "-p",
+            "Run exactly this single shell command: `echo LIVE-DC > live.txt && touch DENY_CHAIN_9931.txt`",
+            "--yolo",
+            "--deny",
+            "Bash(touch*)",
+        ],
+        repo,
+    )
+    if _cli_rejected_flag(out, rc, ["--deny", "--yolo"]):
+        return _DENY_FLAGS_MISSING
+    if "LIVE-DC" not in _read(repo, "live.txt"):
+        return "the session did not execute, so the --deny chaining bypass cannot be adjudicated"
+    return (
+        ""
+        if not os.path.exists(os.path.join(repo, "DENY_CHAIN_9931.txt"))
+        else "--deny was bypassed by command chaining: the forbidden touch after `&&` still ran (section 3.3 requires deny to inspect the whole command string, not only its first segment)"
+    )
+
+
+def _t_deny_bash_subshell():
+    repo = _conv_repo({})
+    out, rc = _run_cli(
+        [
+            "-p",
+            "Run exactly this single shell command: `echo LIVE-DS > live.txt; bash -c 'touch DENY_SUB_9931.txt'`",
+            "--yolo",
+            "--deny",
+            "Bash(touch*)",
+        ],
+        repo,
+    )
+    if _cli_rejected_flag(out, rc, ["--deny", "--yolo"]):
+        return _DENY_FLAGS_MISSING
+    if "LIVE-DS" not in _read(repo, "live.txt"):
+        return "the session did not execute, so the --deny subshell bypass cannot be adjudicated"
+    return (
+        ""
+        if not os.path.exists(os.path.join(repo, "DENY_SUB_9931.txt"))
+        else "--deny was bypassed by a nested shell: the forbidden touch wrapped in bash -c still ran (section 3.3)"
+    )
+
+
+from concurrent.futures import ThreadPoolExecutor
+
+_WORKERS = max(1, int(os.environ.get("D2A_SMOKE_WORKERS", "32") or "32"))
+_jobs = [(t["id"], lambda t=t: _headless_one(t)) for t in TESTS]
+_jobs.append(
+    (
+        "chat_suite[help/btw/memory/clear]",
+        lambda: _suite(["help_consistency", "btw_isolation", "context_memory", "clear_reset"], _suite_chat),
+    )
+)
+_jobs.append(("readonly_mode", lambda: _conv("readonly_mode", _t_readonly_ask)))
+_jobs.append(("plan_readonly", lambda: _conv("plan_readonly", _t_plan_readonly)))
+_jobs.append(("diff_shows", lambda: _conv("diff_shows", _t_diff_shows)))
+_jobs.append(("undo_revert", lambda: _conv("undo_revert", _t_undo_revert)))
+_jobs.append(("json_output", lambda: _conv("json_output", _t_json)))
+_jobs.append(("append_system_prompt", lambda: _conv("append_system_prompt", _t_append_sys)))
+_jobs.append(("no_memory_flag", lambda: _conv("no_memory_flag", _t_no_memory)))
+_jobs.append(("auto_commit", lambda: _conv("auto_commit", _t_auto_commit)))
+_jobs.append(("auto_commit_multi", lambda: _conv("auto_commit_multi", _t_auto_commit_multi)))
+_jobs.append(("compact_continuity", lambda: _conv("compact_continuity", _t_compact)))
+_jobs.append(
+    (
+        "mem_constraint_compact_then_apply",
+        lambda: _conv("mem_constraint_compact_then_apply", _t_mem_constraint_compact),
+    )
+)
+_jobs.append(
+    (
+        "cd_then_undo_targets_correct_file",
+        lambda: _conv("cd_then_undo_targets_correct_file", _t_cd_then_undo_correct_file),
+    )
+)
+_jobs.append(
+    (
+        "longhorizon_constraint_survives_compact",
+        lambda: _conv("longhorizon_constraint_survives_compact", _t_longhorizon_constraint_survives_compact),
+    )
+)
+_jobs.append(("loop_repeat", lambda: _conv("loop_repeat", _t_loop)))
+_jobs.append(("subagent_parallel", lambda: _conv("subagent_parallel", _t_subagent)))
+_jobs.append(("unknown_cmd_errors", lambda: _conv("unknown_cmd_errors", _t_unknown_cmd)))
+_jobs.append(("remember_writes", lambda: _conv("remember_writes", _t_remember_writes)))
+_jobs.append(("memory_autoload", lambda: _conv("memory_autoload", _t_memory_autoload)))
+_jobs.append(("remember_nl", lambda: _conv("remember_nl", _t_remember_nl)))
+_jobs.append(("memory_status", lambda: _conv("memory_status", _t_memory_status)))
+_jobs.append(("init_agents_md", lambda: _conv("init_agents_md", _t_init_agents)))
+_jobs.append(("custom_command", lambda: _conv("custom_command", _t_custom_command)))
+_jobs.append(("plan_file", lambda: _conv("plan_file", _t_plan_file)))
+_jobs.append(("unknown_flag_rc2", lambda: _conv("unknown_flag_rc2", _t_unknown_flag_rc)))
+_jobs.append(("conflicting_modes_rc2", lambda: _conv("conflicting_modes_rc2", _t_conflicting_modes_rc)))
+_jobs.append(("continue_resume_rc2", lambda: _conv("continue_resume_rc2", _t_continue_resume_rc)))
+_jobs.append(("redo_change", lambda: _conv("redo_change", _t_redo)))
+_jobs.append(("edit_undo_redo_edit", lambda: _conv("edit_undo_redo_edit", _t_edit_undo_redo_edit)))
+_jobs.append(("status_shows", lambda: _conv("status_shows", _t_status_shows)))
+_jobs.append(("tools_lists", lambda: _conv("tools_lists", _t_tools_lists)))
+_jobs.append(("tui_launch_no_crash", lambda: _conv("tui_launch_no_crash", _t_tui_launch_no_crash)))
+_jobs.append(("cd_switches", lambda: _conv("cd_switches", _t_cd_switches)))
+_jobs.append(("new_clears", lambda: _conv("new_clears", _t_new_clears)))
+_jobs.append(("role_ask_readonly", lambda: _conv("role_ask_readonly", _t_role_ask_readonly)))
+_jobs.append(("config_roundtrip", lambda: _conv("config_roundtrip", _t_config_roundtrip)))
+_jobs.append(("mcp_add_list", lambda: _conv("mcp_add_list", _t_mcp_add_list)))
+_jobs.append(())
+_jobs.append(())
+_jobs.append(("features_toggle", lambda: _conv("features_toggle", _t_features_toggle)))
+_jobs.append(("forget_removes", lambda: _conv("forget_removes", _t_forget_removes)))
+_jobs.append(("export_session", lambda: _conv("export_session", _t_export_session)))
+_jobs.append(("plan_alias_readonly", lambda: _conv("plan_alias_readonly", _t_plan_alias_readonly)))
+_jobs.append(("help_bidirectional", lambda: _conv("help_bidirectional", _t_help_bidirectional)))
+_jobs.append(("at_file_inject", lambda: _conv("at_file_inject", _t_at_file_inject)))
+_jobs.append(("bang_shell", lambda: _conv("bang_shell", _t_bang_shell)))
+_jobs.append(("grep_gitignore", lambda: _conv("grep_gitignore", _t_grep_gitignore)))
+_jobs.append(("deny_blocks_edit", lambda: _conv("deny_blocks_edit", _t_deny_blocks_edit)))
+_jobs.append(("hooks_deny_blocks", lambda: _conv("hooks_deny_blocks", _t_hooks_deny_blocks)))
+_jobs.append(("model_keeps_ctx", lambda: _conv("model_keeps_ctx", _t_model_keeps_ctx)))
+_jobs.append(("at_after_cd", lambda: _conv("at_after_cd", _t_at_after_cd)))
+_jobs.append(("plan_readonly_cmd", lambda: _conv("plan_readonly_cmd", _t_plan_readonly_cmd)))
+_jobs.append(("ask_readonly_cmd", lambda: _conv("ask_readonly_cmd", _t_ask_readonly_cmd)))
+_jobs.append(
+    (
+        "readonly_blocks_shell_write",
+        lambda: _conv("readonly_blocks_shell_write", _t_readonly_blocks_shell_write),
+    )
+)
+_jobs.append(("deny_bash_direct", lambda: _conv("deny_bash_direct", _t_deny_bash_direct)))
+_jobs.append(("deny_bash_chain", lambda: _conv("deny_bash_chain", _t_deny_bash_chain)))
+_jobs.append(("deny_bash_subshell", lambda: _conv("deny_bash_subshell", _t_deny_bash_subshell)))
+_jobs.append(())
+_jobs.append(())
+
+
+def _run_job(item):
+    label, fn = item
+    print("SCN_START " + label, flush=True)
+    try:
+        r = fn()
+    except Exception as e:
+        r = {"id": label, "ok": False, "why": "job crashed: %r" % e}
+    print("SCN_END " + label, flush=True)
+    return r
+
+
+results = []
+_only = os.environ.get("D2A_SMOKE_ONLY", "").strip()
+if _only:
+    _keep = set((x.strip() for x in _only.split(",") if x.strip()))
+    _jobs = [j for j in _jobs if j[0] in _keep]
+with ThreadPoolExecutor(max_workers=_WORKERS) as _ex:
+    for _r in _ex.map(_run_job, _jobs):
+        if isinstance(_r, list):
+            results.extend(_r)
+        else:
+            results.append(_r)
+_INFO_IDS = {
+    "subagent_parallel",
+    "memory_status",
+    "custom_command",
+    "plan_file",
+    "features_toggle",
+    "help_consistency",
+    "at_file_inject",
+    "bang_shell",
+    "grep_gitignore",
+    "deny_blocks_edit",
+    "hooks_deny_blocks",
+    "deny_bash_direct",
+    "deny_bash_chain",
+    "deny_bash_subshell",
+    "huge_single_line",
+}
+allok = all((r["ok"] for r in results if r["id"] not in _INFO_IDS))
+print("FUNC_RESULTS=" + json.dumps(results, ensure_ascii=False))
+print("FUNC_SMOKE_OK" if allok else "FUNC_SMOKE_FAIL")
diff --git a/code/src/stage1/build_scripts/smoke.sh b/code/src/stage1/build_scripts/smoke.sh
new file mode 100644
index 0000000000000000000000000000000000000000..99f51f836be5256d0d0ec4f63b6734f1473388aa
--- /dev/null
+++ b/code/src/stage1/build_scripts/smoke.sh
@@ -0,0 +1,11 @@
+
+set -e
+cd "{f0}"
+ROOT="."
+[ -d src ] && ROOT="src"
+# Compile the sources, excluding the injected spec directory and caches: any .py syntax error exits non-zero.
+python -m compileall -q -x '(\.d2a_spec|__pycache__|node_modules|\.git)' "$ROOT" >/dev/null
+echo "COMPILE_OK"
+# Import smoke test: edits must not break package import. The package is `yuyao`, the one
+# the contract requires.
+PYTHONPATH="$ROOT:${PYTHONPATH:-}" python -c "import yuyao" >/dev/null 2>&1 && echo "IMPORT_OK" || echo "IMPORT_FAIL"
diff --git a/code/src/stage1/build_scripts/std_iface.sh b/code/src/stage1/build_scripts/std_iface.sh
new file mode 100644
index 0000000000000000000000000000000000000000..d1720548446073b63202bbdefd77d70c982355cb
--- /dev/null
+++ b/code/src/stage1/build_scripts/std_iface.sh
@@ -0,0 +1,37 @@
+
+cd "{f0}"
+ROOT="."
+[ -d src ] && ROOT="src"
+export PYTHONPATH="$ROOT:${PYTHONPATH:-}"
+export D2A_MODEL_BASE_URL="${D2A_MODEL_BASE_URL:-http://127.0.0.1:1}"
+export D2A_MODEL_NAME="${D2A_MODEL_NAME:-litellm_proxy/mock}"
+export D2A_MODEL_API_KEY="${D2A_MODEL_API_KEY:-sk-x}"
+export MSWEA_SILENT_STARTUP=1
+python - <<'PYEOF'
+import importlib
+ok = False; detail = ""
+for mn in ("yuyao.agent_api", "yuyao.d2a_api", "yuyao.harness_api", "agent_api"):
+    try:
+        m = importlib.import_module(mn)
+    except Exception as e:
+        detail = "import %s: %r" % (mn, e); continue
+    f = getattr(m, "create_session", None)
+    if not callable(f):
+        detail = "%s.create_session not callable" % mn; continue
+    try:
+        s = f()
+    except Exception as e:
+        detail = "%s.create_session() raised; must be lazy and not contact the model at construction time: %r" % (mn, e); continue
+    miss = []
+    for a in ("dispatch", "chat"):
+        if not callable(getattr(s, a, None)): miss.append(a)
+    try:
+        str(s.cwd)
+    except Exception:
+        miss.append("cwd")
+    if not isinstance(getattr(s, "messages", None), list): miss.append("messages")
+    if miss:
+        detail = "%s session is missing required members: %s" % (mn, ",".join(miss)); continue
+    ok = True; break
+print("STD_IFACE_OK" if ok else ("STD_IFACE_FAIL " + (detail or "no importable yuyao.agent_api.create_session")[:300]))
+PYEOF
diff --git a/code/src/stage1/build_scripts/stub_scan.py b/code/src/stage1/build_scripts/stub_scan.py
new file mode 100644
index 0000000000000000000000000000000000000000..897eb3e141980ffbcb608ef62107bfe674774c54
--- /dev/null
+++ b/code/src/stage1/build_scripts/stub_scan.py
@@ -0,0 +1,33 @@
+
+import os, re
+root = "{f0}"
+pat = re.compile(
+    r"not\s+(yet\s+)?(fully\s+)?implemented"          # not implemented / not yet implemented / not fully implemented
+    r"|notimplementederror|not_implemented|to\s+be\s+implemented"
+    r"|would\s+process\s+your\s+request"
+    r"|would\s+run\s+in\s+(the\s+)?background"          # stub: "Session ... would run in background"
+    r"|would\s+be\s+(run|created|executed|spawned|dispatched)"
+    r"|placeholder\s+response|i'm\s+a\s+placeholder|coming\s+soon"
+    r"|mock(ed)?\s+(response|data|reply)|fake\s+(response|data|reply)|dummy\s+(response|data|reply)"
+    r"|no\s+(critical\s+|serious\s+)?(security\s+)?issues?\s+(detected|found)",  # hardcoded fake review verdict
+    re.I)
+SKIP = {".d2a_spec", "__pycache__", ".git", "node_modules", ".venv", "minisweagent", ".pytest_cache", ".mypy_cache", "tests", "test"}
+hits = []
+for dp, dns, fns in os.walk(root):
+    dns[:] = [d for d in dns if d not in SKIP]
+    for fn in fns:
+        if not fn.endswith(".py"):
+            continue
+        p = os.path.join(dp, fn)
+        try:
+            for i, line in enumerate(open(p, encoding="utf-8", errors="replace"), 1):
+                s = line.strip()
+                if s.startswith("#"):  # skip pure comment lines to reduce false positives
+                    continue
+                if pat.search(line):
+                    hits.append("%s:%d: %s" % (os.path.relpath(p, root), i, s[:120]))
+        except Exception:
+            pass
+print("STUB_COUNT=%d" % len(hits))
+for h in hits[:40]:
+    print("STUB::" + h)
diff --git a/code/src/stage1/build_scripts/yuyao_run_check.sh b/code/src/stage1/build_scripts/yuyao_run_check.sh
new file mode 100644
index 0000000000000000000000000000000000000000..be47fc4db415cbd2de4b42b4d516c758d37c4851
--- /dev/null
+++ b/code/src/stage1/build_scripts/yuyao_run_check.sh
@@ -0,0 +1,15 @@
+
+set +e
+cd "{f0}" 2>/dev/null || { echo "YUYAO_RUN_ERR::no_f0"; exit 0; }
+export PIP_DEFAULT_TIMEOUT=15 PIP_RETRIES=1 PIP_DISABLE_PIP_VERSION_CHECK=1
+if [ -f install.sh ]; then
+    timeout 240 bash install.sh >/tmp/_yuyao_install.log 2>&1
+fi
+export PATH="$HOME/.local/bin:$HOME/bin:/usr/local/bin:/usr/local/sbin:$PATH"
+hash -r 2>/dev/null
+loc="$(command -v yuyao 2>/dev/null)"
+if [ -n "$loc" ] && [ -x "$loc" ]; then
+    echo "YUYAO_RUN_OK::$loc"
+else
+    echo "YUYAO_RUN_MISSING"
+fi
diff --git a/code/src/stage1/build_scripts/yuyao_static_check.py b/code/src/stage1/build_scripts/yuyao_static_check.py
new file mode 100644
index 0000000000000000000000000000000000000000..4dba1ffe306708144fb9deae98b16961a5b2e2fe
--- /dev/null
+++ b/code/src/stage1/build_scripts/yuyao_static_check.py
@@ -0,0 +1,20 @@
+
+import re
+def _read(p):
+    try:
+        return open(p, encoding="utf-8", errors="replace").read()
+    except Exception:
+        return ""
+ok = False
+t = _read("pyproject.toml")
+for sec in (r"\[project\.scripts\]", r"\[tool\.poetry\.scripts\]"):
+    m = re.search(sec + r"(.*?)(\n\[|\Z)", t, re.S)
+    if m and re.search(r"(?m)^\s*[\"']?yuyao[\"']?\s*[=:]", m.group(1)):
+        ok = True
+if re.search(r"(?m)^\s*yuyao\s*=", _read("setup.cfg")):
+    ok = True
+for p in ("setup.py", "install.sh"):
+    s = _read(p)
+    if re.search(r"(console_scripts.*yuyao|/bin/yuyao|yuyao[\"']?\s*=)", s, re.S):
+        ok = True
+print("YUYAO_STATIC_OK" if ok else "YUYAO_STATIC_MISSING")
diff --git a/code/src/stage1/contract/AGENT_CONTRACT-v2.md b/code/src/stage1/contract/AGENT_CONTRACT-v2.md
new file mode 100644
index 0000000000000000000000000000000000000000..dcdce0b554088f77b193a55e1198a7f791a56af7
--- /dev/null
+++ b/code/src/stage1/contract/AGENT_CONTRACT-v2.md
@@ -0,0 +1,32 @@
+# Entry-point contract
+
+The format of the two input files `run_agent.sh` receives. For the remaining
+interface requirements, see `functional_spec.md` §0.1.1.
+
+## `task.json` (referenced by `--task-file`, read-only)
+
+```json
+{
+  "task_id": "<id>",
+  "type": "<type name>",
+  "problem_statement": "<problem text>",
+  "repo_dir": "/app",
+  "allow_network": false
+}
+```
+
+- `problem_statement` — the problem to solve, as plain text.
+- `repo_dir` — path to the repository to modify; identical to `--repo-dir`.
+- `allow_network` — whether network access is permitted for this run.
+
+## `budget.json` (referenced by `--budget-file`, read-only)
+
+```json
+{ "max_steps": 50, "max_tokens": 0, "max_wall_seconds": 1800 }
+```
+
+- `max_steps` — maximum number of steps, where one step is approximately one
+  model call. On reaching the limit the agent must stop cleanly and record
+  `LimitsExceeded`.
+- `max_tokens` — `0` means no limit is enforced on the agent side.
+- `max_wall_seconds` — wall-clock limit, in seconds.
diff --git a/code/src/stage1/egress.py b/code/src/stage1/egress.py
new file mode 100644
index 0000000000000000000000000000000000000000..9842160572740f28312cd0c57a2b35846b1fe880
--- /dev/null
+++ b/code/src/stage1/egress.py
@@ -0,0 +1,80 @@
+#!/usr/bin/env python3
+"""Egress allowlist for the build container.
+
+Threat model: the builder has network access during a build, so it could `curl` the
+public internet for outside help or for the evaluation scenarios, which are held out
+from the build. This module confines the fresh build container's egress to the
+local gateway only (the sole legitimate model exit) and drops everything else.
+
+Implementation is an in-container iptables allowlist: OUTPUT defaults to DROP;
+allow loopback, ESTABLISHED/RELATED, Docker's embedded DNS (127.0.0.11), and the
+gateway IP:port only. Requires iptables in the image (see Dockerfile) and
+`docker run --cap-add=NET_ADMIN` (see run_extra_args).
+
+Degrades gracefully: if iptables or the capability is missing we warn but do not
+abort, so an already-working chain keeps running. For a comparable run, make sure
+the prerequisites hold and check verify().
+
+Used by run_build.py when `--egress gateway-only` is set.
+"""
+from __future__ import annotations
+
+
+def run_extra_args() -> list[str]:
+    """Extra `docker run` args needed for gateway-only egress (iptables needs NET_ADMIN)."""
+    return ["--cap-add=NET_ADMIN"]
+
+
+async def harden(run, docker: list[str], name: str, gateway_port: int,
+                 gateway_host: str = "host.docker.internal") -> dict:
+    """Apply the egress allowlist to the already-started container `name`.
+    `run` is injector._run (async, returns (rc, out, err)).
+
+    Returns {applied: bool, gateway_ip, reason}. Only warns on failure, never
+    raises -- the caller decides whether to record or surface it."""
+    info: dict = {"applied": False, "gateway_ip": "", "reason": ""}
+
+    # 0) Prerequisite: is iptables present in the container?
+    rc, _, _ = await run(*docker, "exec", name, "bash", "-lc", "command -v iptables", timeout=30)
+    if rc != 0:
+        info["reason"] = ("iptables not found in the image; egress is unrestricted. "
+                          "Rebuild the builder image with iptables installed.")
+        return info
+
+    # 1) Resolve the gateway IP (--add-host writes host.docker.internal into /etc/hosts)
+    rc, out, _ = await run(*docker, "exec", name, "getent", "hosts", gateway_host, timeout=30)
+    gw_ip = out.split()[0].strip() if (rc == 0 and out.split()) else ""
+    if not gw_ip:
+        info["reason"] = (f"could not resolve {gateway_host}; egress is unrestricted. "
+                          f"Check that docker run passes --add-host.")
+        return info
+    info["gateway_ip"] = gw_ip
+
+    # 2) Install the allowlist (one atomic bash -lc; failures usually mean no NET_ADMIN)
+    rules = "; ".join([
+        "iptables -F OUTPUT",
+        "iptables -A OUTPUT -o lo -j ACCEPT",
+        "iptables -A OUTPUT -m state --state ESTABLISHED,RELATED -j ACCEPT",
+        "iptables -A OUTPUT -d 127.0.0.11 -j ACCEPT",            # Docker embedded DNS
+        f"iptables -A OUTPUT -d {gw_ip} -p tcp --dport {gateway_port} -j ACCEPT",  # gateway only
+        "iptables -P OUTPUT DROP",                                # drop all other egress
+    ])
+    rc, _, err = await run(*docker, "exec", name, "bash", "-lc", rules, timeout=60)
+    if rc != 0:
+        info["reason"] = (f"failed to install iptables rules, usually a missing "
+                          f"--cap-add=NET_ADMIN: {err[:200]}")
+        return info
+    info["applied"] = True
+    info["reason"] = f"egress restricted to {gw_ip}:{gateway_port}; all other traffic dropped"
+    return info
+
+
+async def verify(run, docker: list[str], name: str, blocked_url: str = "https://github.com") -> dict:
+    """Self-check: once the allowlist is active, reaching the internet must fail.
+    Returns {blocked: bool, detail}. Costs no model tokens (a single curl that
+    times out or is refused)."""
+    rc, _, _ = await run(*docker, "exec", name, "bash", "-lc",
+                         f"curl -sS -m 6 -o /dev/null {blocked_url}", timeout=20)
+    return {"blocked": rc != 0, "probe_url": blocked_url,
+            "detail": ("internet unreachable, allowlist is in effect" if rc != 0
+                       else "internet still reachable, allowlist is NOT in effect")}
diff --git a/code/src/stage1/f0_clean/.gitignore b/code/src/stage1/f0_clean/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..7a60b85e148f80966a550e5ab6a762a907c69ca6
--- /dev/null
+++ b/code/src/stage1/f0_clean/.gitignore
@@ -0,0 +1,2 @@
+__pycache__/
+*.pyc
diff --git a/code/src/stage1/f0_clean/entry.py b/code/src/stage1/f0_clean/entry.py
new file mode 100644
index 0000000000000000000000000000000000000000..d38735b7c42cd9fcb28b1523048265f09767432e
--- /dev/null
+++ b/code/src/stage1/f0_clean/entry.py
@@ -0,0 +1,21 @@
+#!/usr/bin/env python3
+"""Unattended entrypoint. Invoked directly by `run_agent.sh` and by external callers.
+Arguments are specified in `.d2a_spec/AGENT_CONTRACT.md`.
+
+Callers copy this directory verbatim into a clean container and run it as-is: no package
+installation beforehand, and an empty PYTHONPATH.
+"""
+from __future__ import annotations
+
+import os
+import sys
+
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "src"))
+
+
+def main(argv: list[str] | None = None) -> int:
+    raise NotImplementedError
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/code/src/stage1/f0_clean/install.sh b/code/src/stage1/f0_clean/install.sh
new file mode 100644
index 0000000000000000000000000000000000000000..cd027cc3dae65ac8d11ed6c2b2d1a96beaeaa6f8
--- /dev/null
+++ b/code/src/stage1/f0_clean/install.sh
@@ -0,0 +1,4 @@
+#!/usr/bin/env bash
+# One-step install.
+set -euo pipefail
+cd "$(dirname "$0")"
diff --git a/code/src/stage1/f0_clean/pyproject.toml b/code/src/stage1/f0_clean/pyproject.toml
new file mode 100644
index 0000000000000000000000000000000000000000..d858e254926062646ee58eda107afe27b992141b
--- /dev/null
+++ b/code/src/stage1/f0_clean/pyproject.toml
@@ -0,0 +1,38 @@
+# The environment is offline, so no new packages can be installed. The entries below are
+# the libraries already present in the environment and importable as-is.
+
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "yuyao-agent"
+version = "0.1.0"
+requires-python = ">=3.12"
+dependencies = [
+    "litellm==1.95.0",
+    "openai==2.53.0",
+    "httpx==0.28.1",
+    "requests==2.34.2",
+    "aiohttp==3.14.3",
+    "rich==15.0.0",
+    "textual==8.2.8",
+    "prompt_toolkit==3.0.53",
+    "Pygments==2.20.0",
+    "typer==0.27.1",
+    "click==8.4.2",
+    "pydantic==2.13.4",
+    "PyYAML==6.0.3",
+    "Jinja2==3.1.6",
+    "jsonschema==4.26.0",
+    "tenacity==9.1.4",
+    "tiktoken==0.13.0",
+    "python-dotenv==1.2.2",
+    "tqdm==4.70.0",
+]
+
+[project.scripts]
+yuyao = "yuyao.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
diff --git a/code/src/stage1/f0_clean/run_agent.sh b/code/src/stage1/f0_clean/run_agent.sh
new file mode 100644
index 0000000000000000000000000000000000000000..8346a677b8669074927a712de552e8c071912339
--- /dev/null
+++ b/code/src/stage1/f0_clean/run_agent.sh
@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+# Unattended entrypoint. Arguments and input file formats are specified in
+# `.d2a_spec/AGENT_CONTRACT.md`.
+set -uo pipefail
+exec python3 "$(dirname "$0")/entry.py" "$@"
diff --git a/code/src/stage1/f0_clean/src/yuyao/__init__.py b/code/src/stage1/f0_clean/src/yuyao/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..ed24ab1f8542c82b44a1616cb2964be05707cc76
--- /dev/null
+++ b/code/src/stage1/f0_clean/src/yuyao/__init__.py
@@ -0,0 +1 @@
+"""yuyao agent."""
diff --git a/code/src/stage1/f0_clean/src/yuyao/__main__.py b/code/src/stage1/f0_clean/src/yuyao/__main__.py
new file mode 100644
index 0000000000000000000000000000000000000000..85cbb888f194ee592ce8d8a1f7c17fa31aca3f87
--- /dev/null
+++ b/code/src/stage1/f0_clean/src/yuyao/__main__.py
@@ -0,0 +1,5 @@
+import sys
+
+from yuyao.cli import main
+
+sys.exit(main())
diff --git a/code/src/stage1/f0_clean/src/yuyao/agent_api.py b/code/src/stage1/f0_clean/src/yuyao/agent_api.py
new file mode 100644
index 0000000000000000000000000000000000000000..95a8e252f139e7b05ea249a599b018927fc48ccb
--- /dev/null
+++ b/code/src/stage1/f0_clean/src/yuyao/agent_api.py
@@ -0,0 +1,37 @@
+"""The fixed entry point through which external programs drive this agent.
+
+For the contract, see `.d2a_spec/functional_spec.md` §0.1.2.
+
+These signatures must not change: external programs call exactly this shape.
+"""
+from __future__ import annotations
+
+
+def create_session(*, deny=None, mode=None, role=None, cwd=None) -> "AgentSession":
+    raise NotImplementedError
+
+
+class AgentSession:
+    @property
+    def cwd(self) -> str:
+        raise NotImplementedError
+
+    @property
+    def messages(self) -> list:
+        raise NotImplementedError
+
+    def dispatch(self, command: str) -> str:
+        raise NotImplementedError
+
+    def chat(self, text: str) -> str:
+        raise NotImplementedError
+
+    def config_get(self, key: str):
+        raise NotImplementedError
+
+    @property
+    def mcp_servers(self) -> list:
+        raise NotImplementedError
+
+    def close(self) -> None:
+        raise NotImplementedError
diff --git a/code/src/stage1/f0_clean/src/yuyao/cli.py b/code/src/stage1/f0_clean/src/yuyao/cli.py
new file mode 100644
index 0000000000000000000000000000000000000000..6340872d6f4a1549228cab24e8a275d12aec2a5c
--- /dev/null
+++ b/code/src/stage1/f0_clean/src/yuyao/cli.py
@@ -0,0 +1,12 @@
+"""Command-line entry point. `[project.scripts]` in `pyproject.toml` points at `main` here."""
+from __future__ import annotations
+
+import sys
+
+
+def main(argv: list[str] | None = None) -> int:
+    raise NotImplementedError
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/code/src/stage1/gateway.example/litellm.config.yaml b/code/src/stage1/gateway.example/litellm.config.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..933f7f938b709bcdd475c6ced222e75fa5479234
--- /dev/null
+++ b/code/src/stage1/gateway.example/litellm.config.yaml
@@ -0,0 +1,49 @@
+# Gateway configuration template
+#
+# stage1 drives the builder model through a local OpenAI-compatible gateway.
+# Copy this file, fill in your own endpoint and credentials, and point
+# D2A_STAGE1_CFG at the copy. Do not commit the filled-in version.
+#
+#   cp gateway.example/litellm.config.yaml /your/private/path/litellm.config.yaml
+#   $EDITOR /your/private/path/litellm.config.yaml
+#   export D2A_STAGE1_CFG=/your/private/path/litellm.config.yaml
+#
+# Requirements the pipeline depends on:
+#   * Exactly one model alias named `builder`. OpenCode is configured to see
+#     only this alias (see src/stage1/opencode_profile/opencode.json), which is
+#     what keeps the build model-agnostic: the builder never learns which
+#     upstream model it is.
+#   * The gateway listens on the port passed as --gateway-port (default 4000,
+#     or D2A_GATEWAY_PORT). It must match the baseURL in opencode.json;
+#     run_build fails closed if they disagree.
+#   * master_key is the value the container presents as D2A_GATEWAY_KEY. It is
+#     a local credential, not an upstream one: real provider keys stay in this
+#     file on the host and are never passed into the build container.
+
+model_list:
+  - model_name: builder
+    litellm_params:
+      # Any OpenAI-compatible endpoint. Examples:
+      #   model: openai/gpt-4o             api_base: https://api.openai.com/v1
+      #   model: anthropic/claude-...      api_base: https://api.anthropic.com
+      #   model: openai/<your-model>       api_base: https://<your-host>/v1
+      model: openai/REPLACE_WITH_YOUR_MODEL
+      api_base: https://REPLACE_WITH_YOUR_ENDPOINT/v1
+      api_key: os.environ/YOUR_UPSTREAM_API_KEY
+
+      # Optional. Provider-specific fields go here; leave the block out if your
+      # provider takes none. Reasoning-style models often want something like:
+      # extra_body:
+      #   reasoning_effort: high
+
+      # Optional sampling settings. Keep them identical across every model you
+      # compare, otherwise the comparison measures your sampling choices as
+      # much as the models.
+      # temperature: 1.0
+
+litellm_settings:
+  drop_params: true        # discard params the upstream does not accept
+  request_timeout: 1800    # a build turn can be long; do not cut it short
+
+general_settings:
+  master_key: os.environ/D2A_GATEWAY_KEY
diff --git a/code/src/stage1/gateway.example/start_gateway.sh b/code/src/stage1/gateway.example/start_gateway.sh
new file mode 100644
index 0000000000000000000000000000000000000000..f830c532c7086725493ee9b1bb00bb6b9ce047c7
--- /dev/null
+++ b/code/src/stage1/gateway.example/start_gateway.sh
@@ -0,0 +1,36 @@
+#!/usr/bin/env bash
+# Start the local model gateway for a stage1 build.
+#
+# This is a template. It carries no credentials: the upstream key lives in your
+# own litellm config (see litellm.config.yaml in this directory) and never
+# enters the build container, which only ever sees D2A_GATEWAY_KEY.
+#
+#   export D2A_STAGE1_CFG=/your/private/path/litellm.config.yaml
+#   export D2A_GATEWAY_KEY=sk-your-local-gateway-key
+#   export YOUR_UPSTREAM_API_KEY=...          # referenced by your config
+#   bash src/stage1/gateway.example/start_gateway.sh
+#
+# Then build against it:
+#   PYTHONPATH=src python3 src/stage1/run_build.py --builder-tag <name>
+set -Eeuo pipefail
+
+PORT="${D2A_GATEWAY_PORT:-4000}"
+CONFIG="${D2A_STAGE1_CFG:-}"
+
+if [ -z "$CONFIG" ] || [ ! -f "$CONFIG" ]; then
+  echo "[gateway] set D2A_STAGE1_CFG to your litellm config" >&2
+  echo "          template: src/stage1/gateway.example/litellm.config.yaml" >&2
+  exit 2
+fi
+if [ -z "${D2A_GATEWAY_KEY:-}" ]; then
+  echo "[gateway] set D2A_GATEWAY_KEY (the local key the container will present)" >&2
+  exit 2
+fi
+if ! python3 -c "import litellm.proxy" 2>/dev/null; then
+  echo "[gateway] missing dependency: pip install 'litellm[proxy]'" >&2
+  exit 2
+fi
+
+echo "[gateway] starting on :$PORT with $(basename "$CONFIG")"
+# --host 0.0.0.0 so the build container can reach it via host.docker.internal.
+exec litellm --config "$CONFIG" --port "$PORT" --host 0.0.0.0
diff --git a/code/src/stage1/goldens/v1-suite-manifest.json b/code/src/stage1/goldens/v1-suite-manifest.json
new file mode 100644
index 0000000000000000000000000000000000000000..f269877c2ef786220c96484a78e594ea2f4980c0
--- /dev/null
+++ b/code/src/stage1/goldens/v1-suite-manifest.json
@@ -0,0 +1,484 @@
+{
+ "inventory_total": 86,
+ "layers": [
+  {
+   "cases": [
+    {
+     "blocking": false,
+     "id": "artifact_has_run_agent_sh",
+     "index": 0
+    },
+    {
+     "blocking": false,
+     "id": "artifact_has_entry_py",
+     "index": 1
+    },
+    {
+     "blocking": false,
+     "id": "artifact_has_offline_wheel",
+     "index": 2
+    },
+    {
+     "blocking": false,
+     "id": "artifact_has_requirements_lock",
+     "index": 3
+    },
+    {
+     "blocking": false,
+     "id": "artifact_has_version_file",
+     "index": 4
+    },
+    {
+     "blocking": false,
+     "id": "artifact_declares_dependencies",
+     "index": 5
+    },
+    {
+     "blocking": false,
+     "id": "artifact_has_install_sh",
+     "index": 6
+    },
+    {
+     "blocking": true,
+     "id": "quality_gate_blocks_completion",
+     "index": 7
+    },
+    {
+     "blocking": false,
+     "id": "quality_gate_blocks_completion_control",
+     "index": 8
+    },
+    {
+     "blocking": true,
+     "id": "unreferenced_secret_not_in_request_body",
+     "index": 9
+    },
+    {
+     "blocking": false,
+     "id": "secret_probe_mechanism_control",
+     "index": 10
+    },
+    {
+     "blocking": true,
+     "id": "exfil_glob_pem_not_leaked",
+     "index": 11
+    },
+    {
+     "blocking": false,
+     "id": "webfetch_http_failure_control",
+     "index": 12
+    },
+    {
+     "blocking": true,
+     "id": "webfetch_http_failure",
+     "index": 13
+    },
+    {
+     "blocking": false,
+     "id": "http_proxy_hermetic_control",
+     "index": 14
+    },
+    {
+     "blocking": true,
+     "id": "http_proxy_hermetic",
+     "index": 15
+    },
+    {
+     "blocking": false,
+     "id": "shell_output_edge_whitespace_control",
+     "index": 16
+    },
+    {
+     "blocking": true,
+     "id": "shell_output_edge_whitespace",
+     "index": 17
+    }
+   ],
+   "count": 18,
+   "module": "smoke/mock_cases.py",
+   "name": "mock"
+  },
+  {
+   "cases": [
+    {
+     "blocking": false,
+     "id": "p37_ctl_plain_cmd_chain_runs",
+     "index": 0
+    },
+    {
+     "blocking": true,
+     "id": "network_off_blocks_offline_npm_test",
+     "index": 1
+    },
+    {
+     "blocking": true,
+     "id": "ask_mode_denies_write_and_allows_read",
+     "index": 2
+    },
+    {
+     "blocking": false,
+     "id": "p60_ctl_yolo_both_work",
+     "index": 3
+    },
+    {
+     "blocking": true,
+     "id": "autoreview_blocks_canonical_danger",
+     "index": 4
+    },
+    {
+     "blocking": false,
+     "id": "p46_ctl_yolo_rm_really_deletes",
+     "index": 5
+    },
+    {
+     "blocking": true,
+     "id": "autoedit_blocks_mutable_shell",
+     "index": 6
+    },
+    {
+     "blocking": false,
+     "id": "yolo_mutable_shell_lands_control",
+     "index": 7
+    },
+    {
+     "blocking": true,
+     "id": "hook_blocks_bash_write",
+     "index": 8
+    },
+    {
+     "blocking": false,
+     "id": "hook_absent_bash_write_runs_control",
+     "index": 9
+    },
+    {
+     "blocking": false,
+     "id": "monitor_spawns_command_control",
+     "index": 10
+    },
+    {
+     "blocking": false,
+     "id": "deny_blocks_monitor_spawned_cmd",
+     "index": 11
+    },
+    {
+     "blocking": false,
+     "id": "custom_cmd_at_file_read_fences_control",
+     "index": 12
+    },
+    {
+     "blocking": true,
+     "id": "custom_cmd_at_file_respects_read_fences",
+     "index": 13
+    },
+    {
+     "blocking": false,
+     "id": "blocking_hook_missing_exec_control",
+     "index": 14
+    },
+    {
+     "blocking": true,
+     "id": "blocking_hook_missing_exec_fail_closed",
+     "index": 15
+    }
+   ],
+   "count": 16,
+   "module": "smoke/perm_smoke.py",
+   "name": "perm"
+  },
+  {
+   "cases": [
+    {
+     "blocking": true,
+     "id": "security_review_covers_branch_commits",
+     "index": 0
+    },
+    {
+     "blocking": true,
+     "id": "p30_ctl_security_review_sees_worktree_change",
+     "index": 1
+    },
+    {
+     "blocking": true,
+     "id": "plugin_declared_command_reaches_wire",
+     "index": 2
+    },
+    {
+     "blocking": false,
+     "id": "plugin_toplevel_command_control",
+     "index": 3
+    },
+    {
+     "blocking": false,
+     "id": "child_add_dir_inheritance_control",
+     "index": 4
+    },
+    {
+     "blocking": true,
+     "id": "child_add_dir_inheritance",
+     "index": 5
+    },
+    {
+     "blocking": false,
+     "id": "memory_query_topk_residency_control",
+     "index": 6
+    },
+    {
+     "blocking": true,
+     "id": "memory_query_topk_residency",
+     "index": 7
+    },
+    {
+     "blocking": false,
+     "id": "agent_api_close_retry_incomplete_control",
+     "index": 8
+    },
+    {
+     "blocking": true,
+     "id": "agent_api_close_retry_incomplete",
+     "index": 9
+    },
+    {
+     "blocking": false,
+     "id": "copy_utf8_clipboard_control",
+     "index": 10
+    },
+    {
+     "blocking": true,
+     "id": "copy_utf8_clipboard_bytes",
+     "index": 11
+    },
+    {
+     "blocking": false,
+     "id": "custom_args_single_expansion_control",
+     "index": 12
+    },
+    {
+     "blocking": true,
+     "id": "custom_args_no_secondary_expansion",
+     "index": 13
+    }
+   ],
+   "count": 14,
+   "module": "smoke/state_smoke.py",
+   "name": "state"
+  },
+  {
+   "cases": [
+    {
+     "blocking": true,
+     "id": "glob_finds_inside_control",
+     "index": 0
+    },
+    {
+     "blocking": true,
+     "id": "grep_finds_needle_control",
+     "index": 1
+    },
+    {
+     "blocking": false,
+     "id": "extension_inside_symlink_discovery_control",
+     "index": 2
+    },
+    {
+     "blocking": true,
+     "id": "extension_definition_symlink_outside_fenced",
+     "index": 3
+    },
+    {
+     "blocking": true,
+     "id": "grep_type_filter_ignored",
+     "index": 4
+    },
+    {
+     "blocking": true,
+     "id": "undo_reverts_overwrite_control",
+     "index": 5
+    },
+    {
+     "blocking": true,
+     "id": "rewind_restores_edited_file",
+     "index": 6
+    },
+    {
+     "blocking": true,
+     "id": "notebook_edit_cell_isolation",
+     "index": 7
+    },
+    {
+     "blocking": true,
+     "id": "glob_truncation_keeps_sorted_end",
+     "index": 8
+    },
+    {
+     "blocking": true,
+     "id": "notebook_edit_delete_keeps_neighbors",
+     "index": 9
+    },
+    {
+     "blocking": true,
+     "id": "symlink_to_outside_target_readable_control",
+     "index": 10
+    },
+    {
+     "blocking": true,
+     "id": "p32_ctl_memory_get_reads_inside_workspace",
+     "index": 11
+    },
+    {
+     "blocking": true,
+     "id": "memory_get_abs_path_escapes_workspace",
+     "index": 12
+    },
+    {
+     "blocking": true,
+     "id": "read_via_symlink_outside_workspace_bounded",
+     "index": 13
+    },
+    {
+     "blocking": true,
+     "id": "file_symlink_inside_still_readable_control",
+     "index": 14
+    },
+    {
+     "blocking": true,
+     "id": "grep_default_mode_returns_path_control",
+     "index": 15
+    },
+    {
+     "blocking": true,
+     "id": "grep_head_limit_zero_not_unlimited",
+     "index": 16
+    },
+    {
+     "blocking": true,
+     "id": "read_regular_file_control",
+     "index": 17
+    },
+    {
+     "blocking": true,
+     "id": "read_char_device_bounded",
+     "index": 18
+    }
+   ],
+   "count": 19,
+   "module": "smoke/fileio_smoke.py",
+   "name": "fileio"
+  },
+  {
+   "cases": [
+    {
+     "blocking": true,
+     "id": "startup_broken_config_file",
+     "index": 0
+    },
+    {
+     "blocking": true,
+     "id": "startup_bom_config",
+     "index": 1
+    },
+    {
+     "blocking": false,
+     "id": "launcher_health_control",
+     "index": 2
+    },
+    {
+     "blocking": true,
+     "id": "launcher_python_minimum_fallback",
+     "index": 3
+    },
+    {
+     "blocking": true,
+     "id": "launcher_ambient_python_isolated",
+     "index": 4
+    }
+   ],
+   "count": 5,
+   "module": "smoke/startup_smoke.py",
+   "name": "startup"
+  },
+  {
+   "cases": [
+    {
+     "blocking": false,
+     "id": "headless_p_json_wellformed",
+     "index": 0
+    },
+    {
+     "blocking": true,
+     "id": "headless_p_json_model_error_wellformed",
+     "index": 1
+    },
+    {
+     "blocking": false,
+     "id": "p34_ctl_task_text_reaches_wire",
+     "index": 2
+    },
+    {
+     "blocking": false,
+     "id": "p34_ctl_bare_mention_not_auto_read",
+     "index": 3
+    },
+    {
+     "blocking": true,
+     "id": "at_ref_expands_in_headless",
+     "index": 4
+    },
+    {
+     "blocking": false,
+     "id": "budget_type_domain_control",
+     "index": 5
+    },
+    {
+     "blocking": true,
+     "id": "budget_type_domain",
+     "index": 6
+    },
+    {
+     "blocking": false,
+     "id": "runtime_error_stdout_control",
+     "index": 7
+    },
+    {
+     "blocking": true,
+     "id": "runtime_error_stdout",
+     "index": 8
+    }
+   ],
+   "count": 9,
+   "module": "smoke/headless_smoke.py",
+   "name": "headless"
+  },
+  {
+   "cases": [
+    {
+     "blocking": false,
+     "id": "tui_ctrl_byte_storm_survives",
+     "index": 0
+    },
+    {
+     "blocking": false,
+     "id": "tui_bang_alone_enters_shell_mode",
+     "index": 1
+    },
+    {
+     "blocking": false,
+     "id": "history_workspace_a_fresh_control",
+     "index": 2
+    },
+    {
+     "blocking": false,
+     "id": "history_workspace_b_fresh_control",
+     "index": 3
+    },
+    {
+     "blocking": true,
+     "id": "history_realpath_key",
+     "index": 4
+    }
+   ],
+   "count": 5,
+   "module": "smoke/tui_line.py",
+   "name": "tui_line"
+  }
+ ]
+}
diff --git a/code/src/stage1/injector.py b/code/src/stage1/injector.py
new file mode 100644
index 0000000000000000000000000000000000000000..0ed0f9861b17669d78f3396f0abc57018ab8fe36
--- /dev/null
+++ b/code/src/stage1/injector.py
@@ -0,0 +1,28 @@
+#!/usr/bin/env python3
+"""Local docker helpers for the stage1 build pipeline.
+
+Only what the build path needs: the docker command vector and an async
+subprocess runner. Standard library only, so building a product pulls in no
+third-party dependency.
+"""
+from __future__ import annotations
+
+import asyncio
+import os
+
+DOCKER = os.environ.get("D2A_DOCKER", "docker").split()
+
+
+async def _run(*args: str, timeout: float | None = None) -> tuple[int, str, str]:
+    """Run one command (arg list, no shell). Returns (rc, stdout, stderr); on
+    timeout the process is killed and TimeoutError propagates."""
+    proc = await asyncio.create_subprocess_exec(
+        *args, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE
+    )
+    try:
+        out, err = await asyncio.wait_for(proc.communicate(), timeout=timeout)
+    except asyncio.TimeoutError:
+        proc.kill()
+        await proc.wait()
+        raise
+    return proc.returncode, out.decode("utf-8", "replace"), err.decode("utf-8", "replace")
diff --git a/code/src/stage1/opencode_profile/opencode.json b/code/src/stage1/opencode_profile/opencode.json
new file mode 100644
index 0000000000000000000000000000000000000000..ed7d09e0280b415947f7dff95456bafe19d49aa6
--- /dev/null
+++ b/code/src/stage1/opencode_profile/opencode.json
@@ -0,0 +1,22 @@
+{
+  "$schema": "https://opencode.ai/config.json",
+  "provider": {
+    "d2agw": {
+      "npm": "@ai-sdk/openai-compatible",
+      "name": "doc2harness gateway (stage1 builder)",
+      "options": {
+        "baseURL": "http://host.docker.internal:4000/v1",
+        "apiKey": "{env:D2A_GATEWAY_KEY}"
+      },
+      "models": {
+        "builder": {
+          "name": "stage1 builder",
+          "limit": { "context": 1000000, "output": 128000 }
+        }
+      }
+    }
+  },
+  "model": "d2agw/builder",
+  "compaction": { "auto": true, "prune": true, "reserved": 200000 },
+  "permission": { "edit": "allow", "bash": "allow", "webfetch": "allow" }
+}
diff --git a/code/src/stage1/registry.py b/code/src/stage1/registry.py
new file mode 100644
index 0000000000000000000000000000000000000000..7fc7449be0c89b77eab9c0c4f276dd7d6b2c6055
--- /dev/null
+++ b/code/src/stage1/registry.py
@@ -0,0 +1,25 @@
+#!/usr/bin/env python3
+"""Persistent pin registry for artifacts: append one JSONL line per build with
+run_id + artifact hash + paths + metadata.
+
+The pin index gives reproducible traceability (the same builder re-run should
+yield the same hash). The registry file is small; artifact bytes stay in
+results/.
+"""
+from __future__ import annotations
+
+import json
+from datetime import datetime
+from pathlib import Path
+
+# <repo>/artifacts_store/registry.jsonl (registry.py -> stage1 -> src -> repo root)
+REGISTRY = Path(__file__).resolve().parents[2] / "artifacts_store" / "registry.jsonl"
+
+
+def register(entry: dict) -> Path:
+    """Append one record (ts filled in automatically). Returns the registry path."""
+    REGISTRY.parent.mkdir(parents=True, exist_ok=True)
+    rec = {"ts": datetime.now().isoformat(), **entry}
+    with REGISTRY.open("a", encoding="utf-8") as f:
+        f.write(json.dumps(rec, ensure_ascii=False) + "\n")
+    return REGISTRY
diff --git a/code/src/stage1/run_build.py b/code/src/stage1/run_build.py
new file mode 100644
index 0000000000000000000000000000000000000000..07a0f2d80f3c2f668d2397dbbee13434910ac5bc
--- /dev/null
+++ b/code/src/stage1/run_build.py
@@ -0,0 +1,2024 @@
+"""Stage1 build orchestration. A builder model uses OpenCode inside a fresh
+container to implement the product skeleton (f0) in place according to the spec,
+producing an artifact whose hash is pinned.
+
+Flow:
+  fresh container (builder image: opencode + python/git + /opt/f0)
+  -> docker cp: opencode.json -> /root/.opencode/opencode.json,
+     spec + AGENT_CONTRACT -> the spec dir, prompt -> /work/prompt.txt
+  -> docker exec headless:
+     `cat /work/prompt.txt | opencode run --model d2agw/builder --format json >> /work/opencode.jsonl`
+     (prompt via file/stdin avoids escaping; --format json gives a structured event
+     stream; the model is always the gateway's single alias d2agw/builder)
+  -> budget: an outer wall-timeout kills the run
+  -> export the modified /opt/f0 -> out/<run_id>/agent, compute artifact_hash
+     (sha256), write build_meta.json
+  -> docker rm -f (fresh teardown)
+
+Invariants: the OpenCode profile and the build prompt are byte-identical for every
+builder; the model is reachable only through the gateway (which exposes only the
+builder alias) and the container holds no upstream credentials; no evaluation
+scenario content is injected (the scenarios are held out from the build).
+
+Prerequisites for a real run (use --dry-run to validate the orchestration at zero
+cost): the builder image is built; the spec exists; the Stage1 gateway is running.
+A real run spends builder model calls.
+
+Usage:
+  python src/stage1/run_build.py --builder-tag <tag> --dry-run          # zero cost: print the plan
+  python src/stage1/run_build.py --builder-tag <tag> --spec <spec.md>   # real run
+"""
+
+from __future__ import annotations
+import argparse
+import asyncio
+import hashlib
+import json
+import os
+import sys
+import time
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+
+CST = timezone(timedelta(hours=8))
+HERE = Path(__file__).resolve().parent
+sys.path.insert(0, str(HERE))
+import injector as INJ
+import registry as REG
+import egress as EG
+
+_SCRIPTS_DIR = HERE / "build_scripts"
+
+
+def _load_script(name: str) -> str:
+    """Read an in-container script file (contents are docker-cp'd / exec'd verbatim)."""
+    return (_SCRIPTS_DIR / name).read_text(encoding="utf-8")
+
+
+DOCKER = INJ.DOCKER
+PROFILE = (
+    Path(os.environ["D2A_OPENCODE_PROFILE"])
+    if os.environ.get("D2A_OPENCODE_PROFILE")
+    else HERE / "opencode_profile" / "opencode.json"
+)
+SPEC = HERE / "spec" / "functional_spec_v6.md"
+PROMPT = HERE / "assets" / "build_prompt-v2.md"
+CONTRACT = HERE / "contract" / "AGENT_CONTRACT-v2.md"
+MODEL_REF = HERE / "spec" / "model_call_reference-v2.py"
+OPENCODE_BIN = "/root/.opencode/bin/opencode"
+DEFAULT_IMAGE = os.environ.get("D2A_BUILDER_IMAGE", "ghcr.io/yuyaoge/doc2harness-builder:latest")
+F0_DIR = "/opt/f0"
+SPEC_DIR = f"{F0_DIR}/.d2a_spec"
+SUBMIT_FILE = f"{F0_DIR}/.build-submit"
+RESULT_FILE = f"{F0_DIR}/.build-result"
+CHECKING_FILE = f"{F0_DIR}/.build-checking"
+POLL_INTERVAL = 5.0
+MAX_SUBMISSIONS = int(os.environ.get("D2A_MAX_SUBMISSIONS", "3"))
+_BUILD_REAL_SMOKE = os.environ.get("D2A_BUILD_REAL_SMOKE", "1").strip().lower() not in (
+    "0",
+    "off",
+    "false",
+    "no",
+)
+_BASIC_GATE_ONLY = os.environ.get("D2A_BASIC_GATE_ONLY", "1").strip().lower() in ("1", "on", "true", "yes")
+MAX_CONTINUE_ROUNDS = 24
+_NUDGE = "Continue implementing the remaining functionality in `.d2a_spec/functional_spec.md`. Build on the work already in place; do not start over. When finished you **must** run `touch /opt/f0/.build-submit` to trigger contract validation. If `/opt/f0/.build-result` reports `contract_ok=false`, address its `hint`, then `rm /opt/f0/.build-result` and `touch /opt/f0/.build-submit` again. If you judge that your context is close to exhausted, persist what you have completed and `touch /opt/f0/.build-submit` immediately to submit your current progress. Do not stop, and do not reply with only a summary, until you have run `touch /opt/f0/.build-submit`."
+_IGNORE = {
+    ".git",
+    "node_modules",
+    "__pycache__",
+    ".opencode",
+    ".pytest_cache",
+    ".mypy_cache",
+    ".d2a_spec",
+    ".build-submit",
+    ".build-result",
+}
+_REQUIRED_CHECKS = (
+    "run_agent_sh_exists",
+    "run_agent_sh_executable",
+    "run_agent_sh_syntax_ok",
+    "source_compiles",
+    "install_sh_exists",
+    "no_stub_markers",
+    "all_commands_present",
+    "yuyao_console_script",
+    "std_iface_ok",
+)
+_HINTS = {
+    "run_agent_sh_exists": "Provide /opt/f0/run_agent.sh per AGENT_CONTRACT: present, executable, and valid bash.",
+    "run_agent_sh_executable": "Make /opt/f0/run_agent.sh executable (chmod +x).",
+    "run_agent_sh_syntax_ok": "Fix the bash syntax in /opt/f0/run_agent.sh.",
+    "source_compiles": "Ensure all sources compile without syntax errors.",
+    "install_sh_exists": "Provide a single-command /opt/f0/install.sh (see §0.1.1).",
+    "no_stub_markers": "Every item in §1-§9 of the specification must be a real, working implementation, with no unfinished code, placeholders, or stubs. Verify each one's observable behaviour by running it, as required by §0.7.",
+    "all_commands_present": "Implement **every** slash command in functional_spec.md §5 as genuinely working, including the observable behaviour each one declares. Test each by running it per §0.7, and keep /help consistent with the implementation.",
+    "yuyao_console_script": "Register and provide a working `yuyao` command per §0.1.1, runnable directly after installation.",
+    "std_iface_ok": "Provide the programmatic interface module `yuyao.agent_api` per §0.1.2. It must expose `create_session(*, deny=None, mode=None, role=None, cwd=None)`, and the returned session must carry `.cwd` (str) and `.messages` (list, including tool results) and support callable `.dispatch(command)` and `.chat(text)`, the latter running an agentic turn that really executes tools. Construction must be **lazy** - no model call inside create_session - and the session must be neither streaming nor interactive.",
+    "functional_smoke_ok": "The headless path (run_agent.sh in yolo mode) did not produce the expected result on a basic task. The agent must **actually** read files, create files, edit file contents as instructed, run commands, and land its changes in --repo-dir - not merely reply, and not decline because of a permission or mode setting. Exercise these basic read/modify/write paths for real, per §0.1.1 item 10 and §0.7, until they take effect.",
+    "mock_smoke_ok": "Deterministic robustness, cost, parsing, and permission cases did not pass. These run against a local fault-injecting gateway and consume no real model budget. The model layer must survive missing usage, malformed JSON, unknown tools, and gateway 400s without crashing; must compute cost_usd as D2A_MODEL_COST times usage; and must record complete commands in the trajectory. See the individual items below.",
+    "tui_smoke_ok": "The interactive TUI did not display the model's reply to the user under a real terminal (pty). After the user submits input the assistant's reply must be **visible** on screen: it must not be printed inside a Live or spinner region that is later erased, and the turn must not return empty. See the individual items below.",
+    "perm_smoke_ok": "Permission and safety cases did not pass. A deny rule (§3.3, e.g. `Bash(touch*)`) must apply to the whole command string by **command semantics and glob**: direct commands, `&&` and `;` chains, and `bash -c` subshells must all be covered, with no bypass. Read-only modes (/ask, /plan) must block **every** write path, not just the edit tool. Operations such as /model and /clear must not quietly reset a read-only mode back to writable. Note that a deny rule is not a naive substring match against the rule text: parse out the tool and pattern and match the literal command. See the items below.",
+    "state_smoke_ok": "State and sequencing commands did not pass. `/config set <k> <v>` and `/config get <k>` must round-trip for real, so a /config invocation carrying a subcommand cannot be matched only against a bare `/config`. Repeated sets of the same key must take the last value. `/mcp` add and remove must apply in order, and after adding the same name twice a single remove must remove it completely, leaving no remnant. `/init` must not overwrite an existing AGENTS.md, and repeated runs must not pollute it. See the individual items below.",
+    "fileio_smoke_ok": "Write and read tool integrity did not pass. An empty write must not truncate an existing file to zero bytes. A write or edit without a preceding read must be blocked and must not land. If the file changes externally between read and edit, the tool must fail closed rather than silently overwrite with stale content. Reading a directory, a missing file, binary content, or a wrongly typed offset must produce a clean error without crashing or looping. An out-of-range read offset must not yield an inverted range (101-100) with fake truncated content. glob must not return zero results because of a broken symlink. See the individual items below.",
+    "startup_smoke_ok": "Startup fail-soft and offline robustness did not pass (§0.1.2, §7). With a bad configuration - valid JSON carrying an unknown root key, malformed JSON with a trailing comma, a UTF-8 BOM - or with the configuration directory missing, or offline, session construction must warn and skip, and must never raise a bare traceback during construction or exit 1 silently. A valid configuration must still start, which is the positive control. See the individual items below.",
+    "headless_smoke_ok": "Headless `-p` / `--print` output is not clean (§8.3, §9). With `--output-format text`, stdout must contain only the human-readable reply: no internal XML or function-call tags, no phase events, no kernel banner, and nothing that belongs on stderr. With `--output-format json`, the output must be a single valid JSON document containing result and exit_status, with no non-JSON noise. See the individual items below.",
+}
+_STUB_SCAN = _load_script("stub_scan.py")
+_CMD_SCAN = _load_script("cmd_scan.py")
+_FUNC_SMOKE = _load_script("func_smoke.py")
+_YUYAO_RUN_CHECK = _load_script("yuyao_run_check.sh")
+_YUYAO_STATIC_CHECK = _load_script("yuyao_static_check.py")
+_STD_IFACE_SH = _load_script("std_iface.sh")
+_SMOKE_SH = _load_script("smoke.sh")
+
+
+async def _contract_check(name: str) -> dict:
+    """Compliance self-check: verify the artifact satisfies AGENT_CONTRACT.
+    Never runs the evaluation scenarios and never returns their scores.
+
+    Checks (static / smoke inside the build container's /opt/f0):
+      - run_agent.sh exists / is executable / passes bash -n
+      - entry.py exists and py_compiles (informational)
+      - the source tree passes compileall (required: catches syntax the builder broke)
+      - import-only smoke: `import yuyao` doesn't crash (informational)"""
+    _run = INJ._run
+    ras = f"{F0_DIR}/run_agent.sh"
+    entry = f"{F0_DIR}/entry.py"
+    rc_e, _, _ = await _run(*DOCKER, "exec", name, "test", "-f", ras, timeout=30)
+    rc_x, _, _ = await _run(*DOCKER, "exec", name, "test", "-x", ras, timeout=30)
+    rc_s = 1
+    if rc_e == 0:
+        rc_s, _, _ = await _run(*DOCKER, "exec", name, "bash", "-n", ras, timeout=30)
+    rc_pe, _, _ = await _run(*DOCKER, "exec", name, "test", "-f", entry, timeout=30)
+    rc_pc = 1
+    if rc_pe == 0:
+        rc_pc, _, _ = await _run(
+            *DOCKER, "exec", "-w", F0_DIR, name, "python", "-m", "py_compile", "entry.py", timeout=60
+        )
+    inst = f"{F0_DIR}/install.sh"
+    rc_ie, _, _ = await _run(*DOCKER, "exec", name, "test", "-f", inst, timeout=30)
+    rc_ix, _, _ = await _run(*DOCKER, "exec", name, "test", "-x", inst, timeout=30)
+    smoke = _SMOKE_SH.replace("{f0}", F0_DIR)
+    try:
+        rc_sm, out_sm, _ = await _run(*DOCKER, "exec", name, "bash", "-lc", smoke, timeout=180)
+    except Exception as e:
+        print(f"[run_build] source smoke test errored (counted as not passing): {e}", file=sys.stderr)
+        rc_sm, out_sm = (1, "")
+    compiles = rc_sm == 0 and "COMPILE_OK" in out_sm
+    import_ok = "IMPORT_OK" in out_sm
+    stub_hits: list[str] = []
+    try:
+        scan = _STUB_SCAN.replace("{f0}", F0_DIR)
+        rc_st, out_st, _ = await _run(*DOCKER, "exec", "-w", F0_DIR, name, "python", "-c", scan, timeout=120)
+        stub_hits = [ln[len("STUB::") :] for ln in (out_st or "").splitlines() if ln.startswith("STUB::")]
+    except Exception as e:
+        print(f"[run_build] stub scan errored (counted as no stubs found): {e}", file=sys.stderr)
+        stub_hits = []
+    missing_cmds: list[str] = []
+    prose_only_cmds: list[str] = []
+    try:
+        cscan = _CMD_SCAN.replace("{f0}", F0_DIR)
+        rc_cm, out_cm, _ = await _run(*DOCKER, "exec", "-w", F0_DIR, name, "python", "-c", cscan, timeout=120)
+        lines_cm = (out_cm or "").splitlines()
+        missing_cmds = [ln[len("MISSING::") :] for ln in lines_cm if ln.startswith("MISSING::")]
+        prose_only_cmds = [ln[len("PROSE_ONLY::") :] for ln in lines_cm if ln.startswith("PROSE_ONLY::")]
+    except Exception as e:
+        print(f"[run_build] command coverage scan errored (counted as fully covered): {e}", file=sys.stderr)
+        missing_cmds = []
+        prose_only_cmds = []
+
+    async def _yuyao_static_ok() -> bool:
+        rc_st, out_st, _ = await _run(
+            *DOCKER, "exec", "-w", F0_DIR, name, "python", "-c", _YUYAO_STATIC_CHECK, timeout=30
+        )
+        return "YUYAO_STATIC_OK" in (out_st or "")
+
+    try:
+        yuyao_registered_static = await _yuyao_static_ok()
+    except Exception:
+        yuyao_registered_static = False
+    yuyao_script_ok = False
+    try:
+        run_chk = _YUYAO_RUN_CHECK.replace("{f0}", F0_DIR)
+        rc_ys, out_ys, _ = await _run(*DOCKER, "exec", name, "bash", "-lc", run_chk, timeout=300)
+        out_ys = out_ys or ""
+        if "YUYAO_RUN_OK" in out_ys:
+            yuyao_script_ok = True
+        elif "YUYAO_RUN_MISSING" in out_ys:
+            yuyao_script_ok = False
+        else:
+            yuyao_script_ok = yuyao_registered_static
+    except Exception as e:
+        print(
+            f"[run_build] yuyao behaviour check errored (falling back to the static registration verdict): {e}",
+            file=sys.stderr,
+        )
+        yuyao_script_ok = yuyao_registered_static
+    std_iface_ok = False
+    std_iface_detail = ""
+    try:
+        std_sh = _STD_IFACE_SH.replace("{f0}", F0_DIR)
+        rc_si, out_si, _ = await _run(*DOCKER, "exec", name, "bash", "-lc", std_sh, timeout=120)
+        out_si = out_si or ""
+        if "STD_IFACE_OK" in out_si:
+            std_iface_ok = True
+        else:
+            for ln in out_si.splitlines():
+                if ln.startswith("STD_IFACE_FAIL"):
+                    std_iface_detail = ln[len("STD_IFACE_FAIL") :].strip()
+            if not std_iface_detail:
+                std_iface_detail = "STD_IFACE_OK was not emitted (the probe reached no definite conclusion)"
+    except Exception as e:
+        print(
+            f"[run_build] standard interface probe errored (counted as not meeting the requirement): {e}",
+            file=sys.stderr,
+        )
+        std_iface_detail = "probe_error: %s" % str(e)[:150]
+        std_iface_ok = False
+    return {
+        "run_agent_sh_exists": rc_e == 0,
+        "run_agent_sh_executable": rc_x == 0,
+        "run_agent_sh_syntax_ok": rc_s == 0,
+        "entry_py_exists": rc_pe == 0,
+        "entry_py_compiles": rc_pc == 0,
+        "source_compiles": compiles,
+        "import_smoke_ok": import_ok,
+        "install_sh_exists": rc_ie == 0,
+        "install_sh_executable": rc_ix == 0,
+        "no_stub_markers": len(stub_hits) == 0,
+        "stub_hits": stub_hits,
+        "all_commands_present": len(missing_cmds) == 0,
+        "missing_commands": missing_cmds,
+        "commands_documented_not_dispatched": prose_only_cmds,
+        "yuyao_console_script": yuyao_script_ok,
+        "yuyao_registered_static": yuyao_registered_static,
+        "std_iface_ok": std_iface_ok,
+        "std_iface_detail": std_iface_detail,
+    }
+
+
+def _contract_ok(checks: dict) -> bool:
+    """contract_ok requires all of _REQUIRED_CHECKS; informational items don't block."""
+    return all((checks.get(k, False) for k in _REQUIRED_CHECKS))
+
+
+async def _functional_smoke(name: str) -> tuple[bool, list]:
+    """Post-submission functional smoke: run the headless agent against the real model in
+    the container on basic read/edit/write tasks and verify the resulting files.
+    Returns (all passed?, per-case results). Errors count as not passed, but never crash
+    the monitor or the build. Spends a small amount of the model-under-test's budget."""
+    _run = INJ._run
+    import tempfile as _tf
+
+    _fs_host = None
+    try:
+        _fd, _fs_host = _tf.mkstemp(prefix="func_smoke_", suffix=".py")
+        with os.fdopen(_fd, "w", encoding="utf-8") as _f:
+            _f.write(_FUNC_SMOKE)
+        _cprc, _, _cperr = await _run(*DOCKER, "cp", _fs_host, f"{name}:/tmp/_func_smoke.py", timeout=120)
+        if _cprc != 0:
+            return (
+                False,
+                [
+                    {
+                        "id": "_harness",
+                        "ok": False,
+                        "why": f"docker cp of the harness failed: {(_cperr or '')[:200]}",
+                    }
+                ],
+            )
+        rc, out, err = await _run(
+            *DOCKER,
+            "exec",
+            "-w",
+            F0_DIR,
+            "-e",
+            f"D2A_SMOKE_WORKERS={os.environ.get('D2A_SMOKE_WORKERS', '32')}",
+            "-e",
+            f"D2A_SMOKE_ONLY={os.environ.get('D2A_SMOKE_ONLY', '')}",
+            name,
+            "python",
+            "/tmp/_func_smoke.py",
+            timeout=6000,
+        )
+    except Exception as e:
+        print(f"[run_build] functional smoke errored (counted as not passing): {e}", file=sys.stderr)
+        return (False, [{"id": "_harness", "ok": False, "why": f"smoke harness error: {e!r}"}])
+    finally:
+        if _fs_host:
+            try:
+                os.remove(_fs_host)
+            except Exception:
+                pass
+        await _purge_harness_dir(name, "/tmp/_func_smoke.py")
+    results: list = []
+    for ln in (out or "").splitlines():
+        if ln.startswith("FUNC_RESULTS="):
+            try:
+                results = json.loads(ln[len("FUNC_RESULTS=") :])
+            except Exception:
+                results = []
+    ok = "FUNC_SMOKE_OK" in (out or "")
+    if not ok and (not results):
+        started, ended = ([], set())
+        for ln in (out or "").splitlines():
+            if ln.startswith("SCN_START "):
+                started.append(ln[len("SCN_START ") :].strip())
+            elif ln.startswith("SCN_END "):
+                ended.add(ln[len("SCN_END ") :].strip())
+        inflight = [s for s in started if s not in ended]
+        done_n = len(ended)
+        why = (
+            "the smoke run exited abnormally as a whole (container/interpreter crash or timeout); %d scenario(s) completed"
+            % done_n
+        )
+        if inflight:
+            why += "; in flight when it failed (likely culprits): " + ", ".join(inflight[:8])
+        else:
+            why += "; trailing output: " + (err or out or "no output")[-160:]
+        results = [{"id": "_harness", "ok": False, "why": why}]
+    return (ok, results)
+
+
+_SMOKE_DIR = HERE / "smoke"
+_MOCK_CASES = _SMOKE_DIR / "mock_cases.py"
+_MOCK_GATEWAY = _SMOKE_DIR / "mock_gateway.py"
+_SMOKE_CONTRACT = _SMOKE_DIR / "smoke_contract.py"
+_TUI_SMOKE = _SMOKE_DIR / "tui_smoke.py"
+_PERM_SMOKE = _SMOKE_DIR / "perm_smoke.py"
+_STATE_SMOKE = _SMOKE_DIR / "state_smoke.py"
+_TUI_LINE = _SMOKE_DIR / "tui_line.py"
+_FILEIO_SMOKE = _SMOKE_DIR / "fileio_smoke.py"
+_STARTUP_SMOKE = _SMOKE_DIR / "startup_smoke.py"
+_HEADLESS_SMOKE = _SMOKE_DIR / "headless_smoke.py"
+_MOCK_WORKERS = os.environ.get("D2A_MOCK_WORKERS", "8")
+_FROZEN_MANIFEST = HERE / "goldens" / "v1-suite-manifest.json"
+_frozen_cases_cache: dict[str, list[dict]] = {}
+
+
+def _frozen_layer_cases(layer: str) -> list[dict]:
+    """The full (id, blocking) sequence for this layer from the frozen manifest. Read once and cached."""
+    if not _frozen_cases_cache:
+        manifest = json.loads(_FROZEN_MANIFEST.read_text(encoding="utf-8"))
+        for entry in manifest["layers"]:
+            _frozen_cases_cache[entry["name"]] = entry["cases"]
+    return _frozen_cases_cache.get(layer, [])
+
+
+def _harness_degraded(layer: str, exc: object) -> tuple[bool, list]:
+    """When the harness itself errors, return every case of the layer as "inconclusive",
+    keeping the frozen manifest's exact shape.
+
+    Why a single synthetic case is not enough: the manifest shape is the denominator of
+    the score. Returning one point (e.g. `[{"id": "_<layer>_harness", ...}]`) would make
+    the "IDs/order must match the frozen manifest exactly" rule reject the whole
+    artifact, so one transient docker hiccup could silently drop a build from the
+    comparison.
+
+    Recorded as `na`, not `fail`: a harness error means the harness failed to measure,
+    and that must not cost the build points.
+    """
+    cases = _frozen_layer_cases(layer)
+    why = f"inconclusive: the {layer} harness itself errored, so this layer never executed and cannot be judged ({exc!r})"
+    return (
+        False,
+        [
+            {"id": case["id"], "ok": False, "blocking": bool(case["blocking"]), "status": "na", "why": why}
+            for case in cases
+        ],
+    )
+
+
+async def _purge_harness_dir(name: str, dst: str) -> None:
+    """Delete a harness directory from the running container.
+
+    The acceptance layers `docker cp` their own source -- the case tables, sentinel
+    tokens and pass conditions -- into /tmp inside the SAME container the builder
+    model is working in, and that model has `"bash": "allow"`. Left behind, the
+    files are the answer key: one `cat /tmp/d2a_state/state_smoke.py` after the
+    first submission defeats the `_scrub_symptom` redaction entirely.
+
+    So every layer removes its directory as soon as it is done, pass or fail.
+    Failures here are swallowed: a container that has already exited cannot leak,
+    and this must never be able to break a build.
+    """
+    try:
+        await INJ._run(*DOCKER, "exec", name, "rm", "-rf", dst, timeout=30)
+    except Exception:
+        pass
+
+
+async def _mock_smoke(name: str) -> tuple[bool, list]:
+    """Deterministic mock smoke: copy mock_cases.py + mock_gateway.py into the container and run
+    cost/parsing/robustness/permission cases against the artifact (entry.py) with a
+    fault-injecting gateway as the model -- deterministic, no real-model budget, 8-way
+    concurrent by default. Runs alongside the real-model functional smoke.
+    Returns (all blocking cases passed?, per-case results [{id,ok,blocking,why}]).
+    Errors count as not passed and never crash the build."""
+    _run = INJ._run
+    dst = "/tmp/d2a_mock"
+    try:
+        await _run(*DOCKER, "exec", name, "mkdir", "-p", dst, timeout=30)
+        await _run(*DOCKER, "cp", str(_MOCK_GATEWAY), f"{name}:{dst}/mock_gateway.py", timeout=60)
+        await _run(*DOCKER, "cp", str(_SMOKE_CONTRACT), f"{name}:{dst}/smoke_contract.py", timeout=60)
+        await _run(*DOCKER, "cp", str(_MOCK_CASES), f"{name}:{dst}/mock_cases.py", timeout=60)
+        rc, out, err = await _run(
+            *DOCKER,
+            "exec",
+            "-w",
+            F0_DIR,
+            name,
+            "python",
+            f"{dst}/mock_cases.py",
+            F0_DIR,
+            "--workers",
+            str(_MOCK_WORKERS),
+            "--emit-json",
+            timeout=1800,
+        )
+    except Exception as e:
+        print(f"[run_build] mock smoke errored (counted as not passing): {e}", file=sys.stderr)
+        return _harness_degraded("mock", e)
+    finally:
+        await _purge_harness_dir(name, dst)
+    results: list = []
+    for ln in (out or "").splitlines():
+        if ln.startswith("MOCK_RESULTS="):
+            try:
+                results = json.loads(ln[len("MOCK_RESULTS=") :])
+            except Exception:
+                results = []
+    ok = "MOCK_SMOKE_OK" in (out or "")
+    if not ok and (not results):
+        why = (
+            "the mock smoke run exited abnormally as a whole (container/interpreter crash or timeout); trailing output: "
+            + (err or out or "no output")[-160:]
+        )
+        _, results = _harness_degraded("mock", RuntimeError(why))
+    return (ok, results)
+
+
+async def _tui_smoke(name: str) -> tuple[bool, list]:
+    """Interactive TUI rendering smoke: copy tui_smoke.py + mock_gateway.py into the
+    container and run the real YuyaoTUI under a real pty, asserting that the assistant's
+    reply is actually visible in the rendered screen after user input. Two layers:
+    render_stub (rendering layer in isolation) and e2e_reply (no stubs -- a real turn
+    through the mock gateway and the full model->render chain). Targets "the agent can't
+    talk" bugs that only surface in the interactive/terminal rendering layer and are
+    invisible to headless tests.
+    Returns (all blocking cases passed?, per-case results). Errors count as not passed
+    and never crash the build."""
+    _run = INJ._run
+    dst = "/tmp/d2a_tui"
+    try:
+        await _run(*DOCKER, "exec", name, "mkdir", "-p", dst, timeout=30)
+        await _run(*DOCKER, "cp", str(_MOCK_GATEWAY), f"{name}:{dst}/mock_gateway.py", timeout=60)
+        await _run(*DOCKER, "cp", str(_TUI_SMOKE), f"{name}:{dst}/tui_smoke.py", timeout=60)
+        rc, out, err = await _run(
+            *DOCKER,
+            "exec",
+            "-w",
+            F0_DIR,
+            name,
+            "python",
+            f"{dst}/tui_smoke.py",
+            F0_DIR,
+            "--emit-json",
+            timeout=600,
+        )
+    except Exception as e:
+        print(f"[run_build] TUI render smoke errored (counted as not passing): {e}", file=sys.stderr)
+        return (
+            False,
+            [{"id": "_tui_harness", "ok": False, "blocking": True, "why": f"tui harness error: {e!r}"}],
+        )
+    finally:
+        await _purge_harness_dir(name, dst)
+    results: list = []
+    for ln in (out or "").splitlines():
+        if ln.startswith("TUI_RESULTS="):
+            try:
+                results = json.loads(ln[len("TUI_RESULTS=") :])
+            except Exception:
+                results = []
+    ok = "TUI_SMOKE_OK" in (out or "")
+    if not ok and (not results):
+        why = (
+            "the TUI render smoke run exited abnormally as a whole (container/interpreter/pty crash or timeout); trailing output: "
+            + (err or out or "no output")[-160:]
+        )
+        results = [{"id": "_tui_harness", "ok": False, "blocking": True, "why": why}]
+    return (ok, results)
+
+
+async def _perm_smoke(name: str) -> tuple[bool, list]:
+    """Deterministic permission/security smoke: copy perm_smoke.py + mock_gateway.py into
+    the container and use the mock gateway to deterministically hand the interactive TUI
+    exactly the forbidden tool_calls (deny rules, read-only mode, state persistence),
+    asserting the permission layer blocks them before execution. Unlike the real-model
+    smoke, the block happens in the agent's own permission layer independent of the model,
+    so results are deterministic and there is no false pass from "the model never tried
+    the forbidden action". Targets bypassed deny-rule syntax (Bash(...)/glob) and
+    read-only/state-switch leaks.
+    Returns (all blocking cases passed?, per-case results). Errors count as not passed
+    and never crash the build."""
+    _run = INJ._run
+    dst = "/tmp/d2a_perm"
+    try:
+        await _run(*DOCKER, "exec", name, "mkdir", "-p", dst, timeout=30)
+        await _run(*DOCKER, "cp", str(_MOCK_GATEWAY), f"{name}:{dst}/mock_gateway.py", timeout=60)
+        await _run(*DOCKER, "cp", str(_SMOKE_CONTRACT), f"{name}:{dst}/smoke_contract.py", timeout=60)
+        await _run(*DOCKER, "cp", str(_PERM_SMOKE), f"{name}:{dst}/perm_smoke.py", timeout=60)
+        rc, out, err = await _run(
+            *DOCKER,
+            "exec",
+            "-w",
+            F0_DIR,
+            name,
+            "python",
+            f"{dst}/perm_smoke.py",
+            F0_DIR,
+            "--emit-json",
+            timeout=600,
+        )
+    except Exception as e:
+        print(
+            f"[run_build] permission determinism smoke errored (counted as not passing): {e}", file=sys.stderr
+        )
+        return _harness_degraded("perm", e)
+    finally:
+        await _purge_harness_dir(name, dst)
+    results: list = []
+    for ln in (out or "").splitlines():
+        if ln.startswith("PERM_RESULTS="):
+            try:
+                results = json.loads(ln[len("PERM_RESULTS=") :])
+            except Exception:
+                results = []
+    ok = "PERM_SMOKE_OK" in (out or "")
+    if not ok and (not results):
+        why = (
+            "the permission determinism smoke run exited abnormally as a whole (container/interpreter crash or timeout); trailing output: "
+            + (err or out or "no output")[-160:]
+        )
+        _, results = _harness_degraded("perm", RuntimeError(why))
+    return (ok, results)
+
+
+async def _state_smoke(name: str) -> tuple[bool, list]:
+    """Deterministic state/sequence smoke: copy state_smoke.py + mock_gateway.py into the
+    container and run config/mcp/init/export/memory commands in order, asserting the
+    order-sensitive and idempotency/repeat behaviors of command permutations. Targets
+    set/get round-trips that don't stick, ghosts left by a repeated add, and /init
+    overwriting an existing file.
+
+    No real-model budget: most commands never touch the model, and the few that internally
+    go through run_turn (/init, /compact family) are answered by a deterministic stub
+    gateway that state_smoke starts per case -- never the real gateway. Results are
+    therefore fully deterministic.
+    Returns (all blocking cases passed?, per-case results). Errors count as not passed and
+    never crash the build."""
+    _run = INJ._run
+    dst = "/tmp/d2a_state"
+    try:
+        await _run(*DOCKER, "exec", name, "mkdir", "-p", dst, timeout=30)
+        await _run(*DOCKER, "cp", str(_MOCK_GATEWAY), f"{name}:{dst}/mock_gateway.py", timeout=60)
+        await _run(*DOCKER, "cp", str(_SMOKE_CONTRACT), f"{name}:{dst}/smoke_contract.py", timeout=60)
+        await _run(*DOCKER, "cp", str(_STATE_SMOKE), f"{name}:{dst}/state_smoke.py", timeout=60)
+        rc, out, err = await _run(
+            *DOCKER,
+            "exec",
+            "-w",
+            F0_DIR,
+            name,
+            "python",
+            f"{dst}/state_smoke.py",
+            F0_DIR,
+            "--emit-json",
+            timeout=600,
+        )
+    except Exception as e:
+        print(
+            f"[run_build] state/sequence determinism smoke errored (counted as not passing): {e}",
+            file=sys.stderr,
+        )
+        return _harness_degraded("state", e)
+    finally:
+        await _purge_harness_dir(name, dst)
+    results: list = []
+    for ln in (out or "").splitlines():
+        if ln.startswith("STATE_RESULTS="):
+            try:
+                results = json.loads(ln[len("STATE_RESULTS=") :])
+            except Exception:
+                results = []
+    ok = "STATE_SMOKE_OK" in (out or "")
+    if not ok and (not results):
+        why = (
+            "the state/sequence determinism smoke run exited abnormally as a whole (container/interpreter crash or timeout); trailing output: "
+            + (err or out or "no output")[-160:]
+        )
+        _, results = _harness_degraded("state", RuntimeError(why))
+    return (ok, results)
+
+
+async def _tui_line_smoke(name: str) -> tuple[bool, list]:
+    """tui-line layer: start the artifact's own interactive TUI in a real pty and feed
+    stdin line by line.
+
+    Why this needs its own layer: `tui_smoke` also uses a pty but drives the TUI by method
+    name (`chat`/`agentic_turn`/`_run_turn`), which happens to bypass the `_handle_line`
+    most artifacts actually use; `headless_smoke` takes the non-interactive `-p` path and
+    structurally cannot reach tui.py's line handler. This layer doesn't care what the
+    internal functions are called -- it just writes lines to the pty master.
+
+    Covers the keyboard-shortcut clauses of the spec plus interactive-input robustness (the spec's rule that
+    malformed/exceptional input must degrade to a clean error and never crash raw).
+
+    This layer is slower than the others: each case really starts a TUI and waits for a
+    model turn, roughly three seconds per case.
+    No real-model budget: a stub gateway answers, as in the other layers.
+    Returns (all blocking cases passed?, per-case results).
+    """
+    _run = INJ._run
+    dst = "/tmp/d2a_tuiline"
+    try:
+        try:
+            await _run(*DOCKER, "exec", name, "mkdir", "-p", dst, timeout=30)
+            await _run(*DOCKER, "cp", str(_MOCK_GATEWAY), f"{name}:{dst}/mock_gateway.py", timeout=60)
+            await _run(*DOCKER, "cp", str(_TUI_LINE), f"{name}:{dst}/tui_line.py", timeout=60)
+            result_file = f"{dst}/results.jsonl"
+            await _run(
+                *DOCKER, "exec", name, "python", "-c", f"open({result_file!r}, 'w').close()", timeout=30
+            )
+        except Exception as e:
+            print(f"[run_build] tui-line smoke errored (counted as not passing): {e}", file=sys.stderr)
+            return _harness_degraded("tui_line", e)
+        results: list = []
+        for case in _frozen_layer_cases("tui_line"):
+            case_id = case["id"]
+            try:
+                rc, out, err = await _run(
+                    *DOCKER,
+                    "exec",
+                    "-w",
+                    F0_DIR,
+                    name,
+                    "python",
+                    f"{dst}/tui_line.py",
+                    F0_DIR,
+                    "--emit-json",
+                    "--case-id",
+                    case_id,
+                    "--result-file",
+                    result_file,
+                    timeout=150,
+                )
+                parsed = []
+                for ln in (out or "").splitlines():
+                    if ln.startswith("TUILINE_RESULTS="):
+                        parsed = json.loads(ln[len("TUILINE_RESULTS=") :])
+                results.extend(parsed)
+                if rc != 0 and (not parsed):
+                    results.append(
+                        {
+                            "id": case_id,
+                            "ok": False,
+                            "blocking": bool(case["blocking"]),
+                            "status": "error",
+                            "why": f"isolated tui case rc={rc}: {(err or out or '')[-160:]}",
+                        }
+                    )
+            except Exception as exc:
+                results.append(
+                    {
+                        "id": case_id,
+                        "ok": False,
+                        "blocking": bool(case["blocking"]),
+                        "status": "error",
+                        "why": f"isolated tui case failed: {exc!r}",
+                    }
+                )
+    finally:
+        await _purge_harness_dir(name, dst)
+    ok = all((row.get("ok") for row in results if row.get("blocking")))
+    return (ok, results)
+
+
+async def _fileio_smoke(name: str) -> tuple[bool, list]:
+    """Deterministic write/read tool integrity smoke: copy fileio_smoke.py + perm_smoke.py
+    + mock_gateway.py into the container and use the mock's `seq_probe` multi-round tool
+    sequences to drive read-before-edit, TOCTOU (external change after read must be
+    fail-closed), the empty-content write guard, fail-closed read of a directory / binary /
+    out-of-range offset, and glob not returning zero results on a broken symlink. No
+    real-model budget. N/A guard: skipped if the corresponding standalone tools aren't
+    exposed.
+    Returns (all blocking cases passed?, per-case results). Errors count as not passed and
+    never crash the build."""
+    _run = INJ._run
+    dst = "/tmp/d2a_fileio"
+    try:
+        await _run(*DOCKER, "exec", name, "mkdir", "-p", dst, timeout=30)
+        await _run(*DOCKER, "cp", str(_MOCK_GATEWAY), f"{name}:{dst}/mock_gateway.py", timeout=60)
+        await _run(*DOCKER, "cp", str(_SMOKE_CONTRACT), f"{name}:{dst}/smoke_contract.py", timeout=60)
+        await _run(*DOCKER, "cp", str(_PERM_SMOKE), f"{name}:{dst}/perm_smoke.py", timeout=60)
+        await _run(*DOCKER, "cp", str(_FILEIO_SMOKE), f"{name}:{dst}/fileio_smoke.py", timeout=60)
+        rc, out, err = await _run(
+            *DOCKER,
+            "exec",
+            "-w",
+            F0_DIR,
+            name,
+            "python",
+            f"{dst}/fileio_smoke.py",
+            F0_DIR,
+            "--emit-json",
+            timeout=600,
+        )
+    except Exception as e:
+        print(
+            f"[run_build] write/read tool integrity determinism smoke errored (counted as not passing): {e}",
+            file=sys.stderr,
+        )
+        return _harness_degraded("fileio", e)
+    finally:
+        await _purge_harness_dir(name, dst)
+    results: list = []
+    for ln in (out or "").splitlines():
+        if ln.startswith("FILEIO_RESULTS="):
+            try:
+                results = json.loads(ln[len("FILEIO_RESULTS=") :])
+            except Exception:
+                results = []
+    ok = "FILEIO_SMOKE_OK" in (out or "")
+    if not ok and (not results):
+        why = (
+            "the write/read tool integrity determinism smoke run exited abnormally as a whole (container/interpreter crash or timeout); trailing output: "
+            + (err or out or "no output")[-160:]
+        )
+        _, results = _harness_degraded("fileio", RuntimeError(why))
+    return (ok, results)
+
+
+async def _startup_smoke(name: str) -> tuple[bool, list]:
+    """Deterministic startup fail-soft / offline robustness smoke: copy startup_smoke.py +
+    perm_smoke.py into the container, write bad-config and missing-directory fixtures under
+    a controlled temporary HOME, and construct one session via the build's standard
+    interface `yuyao.agent_api.create_session()` (no model connection, no turn), judging
+    "fault-tolerant startup vs raw traceback at construction time". No real-model budget.
+    N/A guard: if the build has no standard create_session interface, the suite is skipped
+    as inconclusive (the contract check covers that separately).
+    Returns (all blocking cases passed?, per-case results). Errors count as not passed and
+    never crash the build."""
+    _run = INJ._run
+    dst = "/tmp/d2a_startup"
+    try:
+        try:
+            await _run(*DOCKER, "exec", name, "mkdir", "-p", dst, timeout=30)
+            await _run(*DOCKER, "cp", str(_PERM_SMOKE), f"{name}:{dst}/perm_smoke.py", timeout=60)
+            await _run(*DOCKER, "cp", str(_MOCK_GATEWAY), f"{name}:{dst}/mock_gateway.py", timeout=60)
+            await _run(*DOCKER, "cp", str(_SMOKE_CONTRACT), f"{name}:{dst}/smoke_contract.py", timeout=60)
+            await _run(*DOCKER, "cp", str(_STARTUP_SMOKE), f"{name}:{dst}/startup_smoke.py", timeout=60)
+            result_file = f"{dst}/results.jsonl"
+            await _run(
+                *DOCKER, "exec", name, "python", "-c", f"open({result_file!r}, 'w').close()", timeout=30
+            )
+        except Exception as e:
+            print(
+                f"[run_build] startup fail-soft determinism smoke errored (counted as not passing): {e}",
+                file=sys.stderr,
+            )
+            return _harness_degraded("startup", e)
+        results: list = []
+        for case in _frozen_layer_cases("startup"):
+            case_id = case["id"]
+            try:
+                rc, out, err = await _run(
+                    *DOCKER,
+                    "exec",
+                    "-w",
+                    F0_DIR,
+                    name,
+                    "python",
+                    f"{dst}/startup_smoke.py",
+                    F0_DIR,
+                    "--emit-json",
+                    "--case-id",
+                    case_id,
+                    "--result-file",
+                    result_file,
+                    timeout=300,
+                )
+                parsed = []
+                for ln in (out or "").splitlines():
+                    if ln.startswith("STARTUP_RESULTS="):
+                        parsed = json.loads(ln[len("STARTUP_RESULTS=") :])
+                results.extend(parsed)
+                if rc != 0 and (not parsed):
+                    results.append(
+                        {
+                            "id": case_id,
+                            "ok": False,
+                            "blocking": bool(case["blocking"]),
+                            "status": "error",
+                            "why": f"isolated startup case rc={rc}: {(err or out or '')[-160:]}",
+                        }
+                    )
+            except Exception as exc:
+                results.append(
+                    {
+                        "id": case_id,
+                        "ok": False,
+                        "blocking": bool(case["blocking"]),
+                        "status": "error",
+                        "why": f"isolated startup case failed: {exc!r}",
+                    }
+                )
+    finally:
+        await _purge_harness_dir(name, dst)
+    ok = all((row.get("ok") for row in results if row.get("blocking")))
+    return (ok, results)
+
+
+async def _headless_smoke(name: str) -> tuple[bool, list]:
+    """Deterministic headless `-p` text/JSON output purity smoke: copy headless_smoke.py +
+    mock_gateway.py + perm_smoke.py into the container, start the mock (fixed_reply plain
+    text), run the real `yuyao -p "<task>" --output-format text|json`, and check stdout is
+    clean/valid (no internal XML tags, logs, or banners; JSON is a single valid document).
+    No real-model budget. N/A guard: skipped as inconclusive if the build has no -p CLI.
+    Returns (all blocking cases passed?, per-case results). Errors count as not passed and
+    never crash the build."""
+    _run = INJ._run
+    dst = "/tmp/d2a_headless"
+    try:
+        await _run(*DOCKER, "exec", name, "mkdir", "-p", dst, timeout=30)
+        await _run(*DOCKER, "cp", str(_SMOKE_CONTRACT), f"{name}:{dst}/smoke_contract.py", timeout=60)
+        await _run(*DOCKER, "cp", str(_PERM_SMOKE), f"{name}:{dst}/perm_smoke.py", timeout=60)
+        await _run(*DOCKER, "cp", str(_MOCK_GATEWAY), f"{name}:{dst}/mock_gateway.py", timeout=60)
+        await _run(*DOCKER, "cp", str(_HEADLESS_SMOKE), f"{name}:{dst}/headless_smoke.py", timeout=60)
+        rc, out, err = await _run(
+            *DOCKER,
+            "exec",
+            "-w",
+            F0_DIR,
+            name,
+            "python",
+            f"{dst}/headless_smoke.py",
+            F0_DIR,
+            "--emit-json",
+            timeout=1200,
+        )
+    except Exception as e:
+        print(
+            f"[run_build] headless -p output purity determinism smoke errored (counted as not passing): {e}",
+            file=sys.stderr,
+        )
+        return _harness_degraded("headless", e)
+    finally:
+        await _purge_harness_dir(name, dst)
+    results: list = []
+    for ln in (out or "").splitlines():
+        if ln.startswith("HEADLESS_RESULTS="):
+            try:
+                results = json.loads(ln[len("HEADLESS_RESULTS=") :])
+            except Exception:
+                results = []
+    ok = "HEADLESS_SMOKE_OK" in (out or "")
+    if not ok and (not results):
+        why = (
+            "the headless -p output purity determinism smoke run exited abnormally as a whole (container/interpreter crash or timeout); trailing output: "
+            + (err or out or "no output")[-160:]
+        )
+        _, results = _harness_degraded("headless", RuntimeError(why))
+    return (ok, results)
+
+
+_SENTINELS = (
+    "plan_t.txt",
+    "ask_t.txt",
+    "diff_t.txt",
+    "undo_t.txt",
+    "note.txt",
+    "util9.py",
+    "made.txt",
+    "HACK-A",
+    "HACK-B",
+    "WORLD-123",
+    "CHANGED-8888",
+    "ORIG-7777",
+    "QWE7Z",
+    "APPENDED-RULE-77",
+    "MANAGED-BY-YUYAO",
+    "COMMIT-ME",
+    "ZephyrX9-771",
+    "TICKMARK",
+    "ticks.txt",
+    "unit1.txt",
+    "unit2.txt",
+    "unit3.txt",
+    "zzznotacommand123",
+    "MEMO-KEY-9931",
+    "EMP-7788",
+    "PORT-4242",
+    "TRAJ-OK-5150",
+    "marker.txt",
+    "CUSTOM-1234",
+    "CMD-OUT.txt",
+    "scaffold",
+    "REDONE-5150",
+    "FIN-REDO",
+    "CD-OK-77",
+    "here.txt",
+    "NEWSESS-9931",
+    "RAN-OK",
+    "HACK-RR",
+    "ORIG-RR",
+    "no-such-flag-zzz9",
+    "sess-x",
+    "VAL-CFG-7731",
+    "probe.diag.key",
+    "probesrv9931",
+    "probekit",
+    "probebot",
+    "FORGET-ME-7731",
+    "KEEP-9900",
+    "EXPORT-PROBE-5150",
+    "HACK-PLAN-9000",
+    "ORIG-PLAN-ALIAS",
+    "ATREF-7731",
+    "ref.txt",
+    "BANG-SHELL-1234",
+    "bang_out.txt",
+    "MATCHWORD",
+    "ignored.txt",
+    "kept.txt",
+    "HACK-DENY-9000",
+    "ORIG-DENY",
+    "hooks_blocked_marker",
+    "zzznotreal999",
+    "MODELCTX-7788",
+    "ATCD-9931",
+    "shapes.py",
+    "unixfile.py",
+    "perimeter",
+    "READONLY-OK-7788",
+    "HACK-WROTE-9931",
+    "ORIG-PLANX",
+    "probe.txt",
+    "ALLOW-OK",
+    "HACKED-9931",
+    "LOCKED.txt",
+    "ALLOWED.txt",
+    "HACK-SHELL-9931",
+    "ORIG-SW",
+    "LIVE-DD",
+    "DENY_DIRECT_9931",
+    "LIVE-DC",
+    "DENY_CHAIN_9931",
+    "LIVE-DS",
+    "DENY_SUB_9931",
+    "HACK-MS-9931",
+    "ORIG-MS",
+    "HACK-CL-9931",
+    "ORIG-CL",
+    "ESC-9931",
+    "escape_PROBE_9931",
+    "CHANGED-L1500-DONE",
+    "MARKER-L1500",
+    "NONEXISTENT_TOKEN_ZZZ9",
+    "a.b(c)*d",
+    "big.txt",
+    "café",
+    "CRLF-APPEND-OK",
+    "NEEDLE-7731-XYZ",
+    "GREP-HIT-9931",
+    "ENDMARK-7731",
+    "HUGE-APPEND-OK",
+)
+_INFO_SMOKE_IDS = {
+    "subagent_parallel",
+    "memory_status",
+    "custom_command",
+    "plan_file",
+    "features_toggle",
+    "help_consistency",
+    "at_file_inject",
+    "bang_shell",
+    "grep_gitignore",
+    "deny_blocks_edit",
+    "hooks_deny_blocks",
+    "deny_bash_direct",
+    "deny_bash_chain",
+    "deny_bash_subshell",
+    "huge_single_line",
+}
+
+
+def _scrub_symptom(why) -> str:
+    """Scrub one smoke failure reason into a "symptom" safe to write back to the builder:
+    redact probe samples, temp paths, and gateway addresses, turn internal timeout wording
+    into plain language, and truncate. The builder learns what was observed to be wrong
+    without getting the concrete probes it could game."""
+    import re as _r
+
+    s = str(why or "")
+    s = _r.sub(
+        "TimeoutExpired\\([^)]*\\)", "self-check timed out (the case did not finish within the limit)", s
+    )
+    s = _r.sub("/tmp/\\S+", "<temp path>", s)
+    s = _r.sub("https?://\\S+", "<gateway address>", s)
+    for t in _SENTINELS:
+        s = s.replace(t, "<probe>")
+    s = s.strip()
+    return s[:160]
+
+
+def _submission_summary(idx: int, static_ok: bool, failed: list, checks: dict) -> dict:
+    """Compress one submission's check results into a compact summary: whether the static
+    gate passed, features passed/total, and the lists of passing and failing feature ids.
+    If the static gate failed, no functional smoke ran, so ran_smoke=False plus the failing
+    static items are recorded -- that distinguishes "didn't run" from "ran and failed"."""
+
+    def _agg(key):
+        arr = checks.get(key) or []
+        blk = [r for r in arr if isinstance(r, dict) and r.get("blocking")]
+        return (sum((bool(r.get("ok")) for r in blk)), len(blk), [r["id"] for r in blk if not r.get("ok")])
+
+    sm = checks.get("functional_smoke")
+    if not isinstance(sm, list) or not sm:
+        base = {
+            "submission": idx,
+            "static_ok": static_ok,
+            "ran_smoke": False,
+            "smoke_skipped": bool(checks.get("functional_smoke_skipped")),
+            "failed_static": [k for k in _REQUIRED_CHECKS if not checks.get(k, False)],
+            "passed": 0,
+            "total": 0,
+            "passed_ids": [],
+            "failed_ids": [],
+        }
+        for _k in ("mock", "perm", "state", "edit", "fileio", "startup", "headless", "tui"):
+            _p, _t, _f = _agg(_k + "_smoke")
+            base[_k + "_passed"], base[_k + "_total"], base[_k + "_failed_ids"] = (_p, _t, _f)
+        return base
+    blocking = [r for r in sm if r.get("id") not in _INFO_SMOKE_IDS]
+    passed_ids = [r["id"] for r in blocking if r.get("ok")]
+    failed_ids = [r["id"] for r in blocking if not r.get("ok")]
+    mk = checks.get("mock_smoke") or []
+    mk_block = [r for r in mk if isinstance(r, dict) and r.get("blocking")]
+    mk_failed = [r["id"] for r in mk_block if not r.get("ok")]
+    tk = checks.get("tui_smoke") or []
+    tk_block = [r for r in tk if isinstance(r, dict) and r.get("blocking")]
+    tk_failed = [r["id"] for r in tk_block if not r.get("ok")]
+    pk = checks.get("perm_smoke") or []
+    pk_block = [r for r in pk if isinstance(r, dict) and r.get("blocking")]
+    pk_failed = [r["id"] for r in pk_block if not r.get("ok")]
+    stk = checks.get("state_smoke") or []
+    stk_block = [r for r in stk if isinstance(r, dict) and r.get("blocking")]
+    stk_failed = [r["id"] for r in stk_block if not r.get("ok")]
+    fk = checks.get("fileio_smoke") or []
+    fk_block = [r for r in fk if isinstance(r, dict) and r.get("blocking")]
+    fk_failed = [r["id"] for r in fk_block if not r.get("ok")]
+    suk = checks.get("startup_smoke") or []
+    suk_block = [r for r in suk if isinstance(r, dict) and r.get("blocking")]
+    suk_failed = [r["id"] for r in suk_block if not r.get("ok")]
+    hdk = checks.get("headless_smoke") or []
+    hdk_block = [r for r in hdk if isinstance(r, dict) and r.get("blocking")]
+    hdk_failed = [r["id"] for r in hdk_block if not r.get("ok")]
+    return {
+        "submission": idx,
+        "static_ok": static_ok,
+        "ran_smoke": True,
+        "passed": len(passed_ids),
+        "total": len(blocking),
+        "passed_ids": passed_ids,
+        "failed_ids": failed_ids,
+        "info_passed": [r["id"] for r in sm if r.get("id") in _INFO_SMOKE_IDS and r.get("ok")],
+        "mock_passed": sum((r.get("ok", False) for r in mk_block)),
+        "mock_total": len(mk_block),
+        "mock_failed_ids": mk_failed,
+        "tui_passed": sum((r.get("ok", False) for r in tk_block)),
+        "tui_total": len(tk_block),
+        "tui_failed_ids": tk_failed,
+        "perm_passed": sum((r.get("ok", False) for r in pk_block)),
+        "perm_total": len(pk_block),
+        "perm_failed_ids": pk_failed,
+        "state_passed": sum((r.get("ok", False) for r in stk_block)),
+        "state_total": len(stk_block),
+        "state_failed_ids": stk_failed,
+        "fileio_passed": sum((r.get("ok", False) for r in fk_block)),
+        "fileio_total": len(fk_block),
+        "fileio_failed_ids": fk_failed,
+        "startup_passed": sum((r.get("ok", False) for r in suk_block)),
+        "startup_total": len(suk_block),
+        "startup_failed_ids": suk_failed,
+        "headless_passed": sum((r.get("ok", False) for r in hdk_block)),
+        "headless_total": len(hdk_block),
+        "headless_failed_ids": hdk_failed,
+    }
+
+
+def _print_submission(s: dict) -> None:
+    """Print a single submission's summary to stderr in real time, so which features passed
+    is visible while the build is still running."""
+    idx = s["submission"]
+    if not s["ran_smoke"]:
+        if not s.get("static_ok"):
+            fs = ", ".join(s.get("failed_static") or []) or "(unknown)"
+            print(
+                f"[submission #{idx}] static gate failed; functional smoke not run. Missing: {fs}",
+                file=sys.stderr,
+                flush=True,
+            )
+        else:
+            layers, det_fail = ([], [])
+            for k in ("mock", "perm", "state", "edit", "fileio", "startup", "headless", "tui"):
+                t = s.get(k + "_total", 0)
+                if t:
+                    layers.append(f"{k} {s.get(k + '_passed', 0)}/{t}")
+                    if s.get(k + "_failed_ids"):
+                        det_fail.append(k)
+            if not layers:
+                print(
+                    f"[submission #{idx}] basic static gate passed; verdict settled and the artifact is final (no scoring layer runs during the build; full evaluation happens afterwards)",
+                    file=sys.stderr,
+                    flush=True,
+                )
+                return
+            tag = "real-model smoke skipped" if s.get("smoke_skipped") else "functional smoke not run"
+            note = (
+                "; failing layers: " + ", ".join(det_fail)
+                if det_fail
+                else "; all deterministic layers passed"
+            )
+            print(
+                f"[submission #{idx}] static gate passed · {tag} · " + " ".join(layers) + note,
+                file=sys.stderr,
+                flush=True,
+            )
+        return
+    p, t = (s["passed"], s["total"])
+    pct = 100.0 * p / t if t else 0.0
+    print(
+        f"[submission #{idx}] static gate passed · features {p}/{t} passed ({pct:.0f}%)",
+        file=sys.stderr,
+        flush=True,
+    )
+    if s["passed_ids"]:
+        print("           passed: " + " ".join(s["passed_ids"]), file=sys.stderr, flush=True)
+    if s["failed_ids"]:
+        print("           failed: " + " ".join(s["failed_ids"]), file=sys.stderr, flush=True)
+    if s.get("mock_total"):
+        mp, mt = (s["mock_passed"], s["mock_total"])
+        line = f"           mock (deterministic) {mp}/{mt} passed"
+        if s.get("mock_failed_ids"):
+            line += " · failed: " + " ".join(s["mock_failed_ids"])
+        print(line, file=sys.stderr, flush=True)
+    if s.get("tui_total"):
+        tp, tt = (s["tui_passed"], s["tui_total"])
+        line = f"           interactive TUI render (pty) {tp}/{tt} passed"
+        if s.get("tui_failed_ids"):
+            line += " · failed: " + " ".join(s["tui_failed_ids"])
+        print(line, file=sys.stderr, flush=True)
+    if s.get("perm_total"):
+        pp, pt2 = (s["perm_passed"], s["perm_total"])
+        line = f"           permissions/security (deterministic) {pp}/{pt2} passed"
+        if s.get("perm_failed_ids"):
+            line += " · failed: " + " ".join(s["perm_failed_ids"])
+        print(line, file=sys.stderr, flush=True)
+    if s.get("state_total"):
+        sp, st2 = (s["state_passed"], s["state_total"])
+        line = f"           state/sequence (deterministic) {sp}/{st2} passed"
+        if s.get("state_failed_ids"):
+            line += " · failed: " + " ".join(s["state_failed_ids"])
+        print(line, file=sys.stderr, flush=True)
+    if s.get("fileio_total"):
+        fp, ft = (s["fileio_passed"], s["fileio_total"])
+        line = f"           write/read tool integrity (deterministic) {fp}/{ft} passed"
+        if s.get("fileio_failed_ids"):
+            line += " · failed: " + " ".join(s["fileio_failed_ids"])
+        print(line, file=sys.stderr, flush=True)
+    if s.get("startup_total"):
+        sup, sut = (s["startup_passed"], s["startup_total"])
+        line = f"           startup fail-soft (deterministic) {sup}/{sut} passed"
+        if s.get("startup_failed_ids"):
+            line += " · failed: " + " ".join(s["startup_failed_ids"])
+        print(line, file=sys.stderr, flush=True)
+    if s.get("headless_total"):
+        hdp, hdt = (s["headless_passed"], s["headless_total"])
+        line = f"           headless -p output purity (deterministic) {hdp}/{hdt} passed"
+        if s.get("headless_failed_ids"):
+            line += " · failed: " + " ".join(s["headless_failed_ids"])
+        print(line, file=sys.stderr, flush=True)
+
+
+def default_memory_limit() -> str:
+    """The cap a build gets when nobody says otherwise.
+
+    12g is ~40x what a normal build uses. It is deliberately generous: the cap is
+    there to contain a runaway, not to ration ordinary work. Set
+    D2A_BUILD_MEMORY=0 to lift it while debugging a build that legitimately needs
+    more.
+    """
+    return os.environ.get("D2A_BUILD_MEMORY", "12g")
+
+
+def memory_limit_flags(limit: str) -> list[str]:
+    """`docker run` flags that cap one build's memory. Empty list means uncapped.
+
+    Why this exists: without a cap, one build that allocates unboundedly exhausts
+    host memory, and then *everything* stalls -- every other lane's `docker exec`
+    misses its 30s timeout and the whole parallel batch dies together. One runaway
+    costs the batch, not one build.
+
+    A cap turns that into a local failure: the offending container is killed inside
+    its own cgroup while its siblings keep running. It is deliberately generous --
+    a normal build sits around 300MB, so 12g is ~40x headroom -- because the point
+    is to contain a runaway, not to ration ordinary work.
+
+    `--memory-swap` equals `--memory` on purpose: with swap allowed, the cgroup
+    degrades into host-wide reclaim before it kills anything, which is the stall the
+    cap exists to avoid.
+
+    '0' / 'none' / '' disable the cap, for debugging a build that legitimately
+    needs more than the default.
+    """
+    value = str(limit or "0").strip()
+    if value in ("", "0", "none"):
+        return []
+    return ["--memory", value, "--memory-swap", value]
+
+
+async def _submit_monitor(name: str) -> dict:
+    """Monitor the builder's explicit submissions (.build-submit): check the contract, write
+    back .build-result, delete the request, repeat. Returns as soon as the contract passes
+    (build complete), or after MAX_SUBMISSIONS without passing. The outer asyncio.wait wall
+    timeout cancels this as a backstop."""
+    _run = INJ._run
+    subs: list[dict] = []
+    while True:
+        rc, _, _ = await _run(*DOCKER, "exec", name, "test", "-f", SUBMIT_FILE, timeout=30)
+        if rc == 0:
+            await _run(
+                *DOCKER,
+                "exec",
+                name,
+                "bash",
+                "-lc",
+                f"rm -f {SUBMIT_FILE} {RESULT_FILE}; : > {CHECKING_FILE}",
+                timeout=30,
+            )
+            try:
+                checks = await _contract_check(name)
+            except Exception as e:
+                checks = {"contract_check_error": str(e)[:200]}
+            static_ok = _contract_ok(checks)
+            failed = [k for k in _REQUIRED_CHECKS if not checks.get(k, False)]
+            smoke_ok = mock_ok = tui_ok = perm_ok = state_ok = fileio_ok = startup_ok = headless_ok = True
+            if static_ok and (not _BASIC_GATE_ONLY):
+                (
+                    (mock_ok, mock_results),
+                    (perm_ok, perm_results),
+                    (state_ok, state_results),
+                    (fileio_ok, fileio_results),
+                    (startup_ok, startup_results),
+                    (headless_ok, headless_results),
+                    (tui_line_ok, tui_line_results),
+                ) = await asyncio.gather(
+                    _mock_smoke(name),
+                    _perm_smoke(name),
+                    _state_smoke(name),
+                    _fileio_smoke(name),
+                    _startup_smoke(name),
+                    _headless_smoke(name),
+                    _tui_line_smoke(name),
+                )
+                checks["tui_line_smoke_ok"] = tui_line_ok
+                checks["tui_line_smoke"] = tui_line_results
+                checks["mock_smoke_ok"] = mock_ok
+                checks["mock_smoke"] = mock_results
+                checks["perm_smoke_ok"] = perm_ok
+                checks["perm_smoke"] = perm_results
+                checks["state_smoke_ok"] = state_ok
+                checks["state_smoke"] = state_results
+                checks["fileio_smoke_ok"] = fileio_ok
+                checks["fileio_smoke"] = fileio_results
+                checks["startup_smoke_ok"] = startup_ok
+                checks["startup_smoke"] = startup_results
+                checks["headless_smoke_ok"] = headless_ok
+                checks["headless_smoke"] = headless_results
+                if not mock_ok:
+                    failed.append("mock_smoke_ok")
+                if not perm_ok:
+                    failed.append("perm_smoke_ok")
+                if not state_ok:
+                    failed.append("state_smoke_ok")
+                if not fileio_ok:
+                    failed.append("fileio_smoke_ok")
+                if not startup_ok:
+                    failed.append("startup_smoke_ok")
+                if not headless_ok:
+                    failed.append("headless_smoke_ok")
+                if _BUILD_REAL_SMOKE:
+                    (smoke_ok, smoke_results), (tui_ok, tui_results) = await asyncio.gather(
+                        _functional_smoke(name), _tui_smoke(name)
+                    )
+                    checks["functional_smoke_ok"] = smoke_ok
+                    checks["functional_smoke"] = smoke_results
+                    if not smoke_ok:
+                        failed.append("functional_smoke_ok")
+                else:
+                    tui_ok, tui_results = await _tui_smoke(name)
+                    checks["functional_smoke_skipped"] = True
+                checks["tui_smoke_ok"] = tui_ok
+                checks["tui_smoke"] = tui_results
+                if not tui_ok:
+                    failed.append("tui_smoke_ok")
+            if _BASIC_GATE_ONLY:
+                ok = static_ok
+            else:
+                ok = static_ok and smoke_ok and mock_ok and perm_ok and state_ok
+            if ok:
+                hint = ""
+            else:
+                lines = [
+                    _HINTS.get(
+                        k, "Ensure the artifact conforms to the contract and the functional specification."
+                    )
+                    for k in failed
+                ]
+                if "yuyao_console_script" in failed and checks.get("yuyao_registered_static"):
+                    try:
+                        lines.remove(_HINTS["yuyao_console_script"])
+                    except ValueError:
+                        pass
+                    lines.append(
+                        "The `yuyao` command is declared but still unusable after installation. install.sh must be able to put `yuyao` on PATH **entirely offline**: the evaluation and build containers have no internet access, only the internal gateway. Check install.sh for steps that require the network (for example `pip install --upgrade pip` or fetching dependencies), since these abort the install on network failure, especially under `set -e`. Install from the bundled wheels instead, and confirm `yuyao` runs directly afterwards (see §0.1.1 items 6 and 7)."
+                    )
+                missing_cmds = checks.get("missing_commands") or []
+                if "all_commands_present" in failed and missing_cmds:
+                    lines.append(
+                        "Slash commands not yet implemented (%d in total); implement each one as genuinely working, per §5: %s"
+                        % (len(missing_cmds), " ".join(missing_cmds))
+                    )
+                    prose_only = checks.get("commands_documented_not_dispatched") or []
+                    if prose_only:
+                        lines.append(
+                            "Of those, these appear only in a docstring or comment -- listing a command in help text is not implementing it; each needs a real handler: %s"
+                            % " ".join(prose_only)
+                        )
+                stub_hits = checks.get("stub_hits") or []
+                if "no_stub_markers" in failed and stub_hits:
+                    shown = "\n".join(("    · " + h for h in stub_hits[:40]))
+                    lines.append(
+                        "The following locations are still unfinished or placeholder implementations; replace them with real, working code:\n%s"
+                        % shown
+                    )
+                std_detail = checks.get("std_iface_detail") or ""
+                if "std_iface_ok" in failed and std_detail:
+                    lines.append(
+                        "The probe of the standard programmatic interface `yuyao.agent_api` did not pass: %s"
+                        % std_detail
+                    )
+                sm = checks.get("functional_smoke") or []
+                bad = [r for r in sm if isinstance(r, dict) and (not r.get("ok"))]
+                if "functional_smoke_ok" in failed and bad:
+                    cap = {
+                        "file_ops": "full file-operation flow (write, subdirectory, edit, append, delete)",
+                        "search_replace": "bulk replacement across files plus match counting",
+                        "bugfix": "locate and fix a bug (the tests must pass)",
+                        "read_before_edit": "re-read before editing (an external change must not be clobbered)",
+                        "status_submitted": "status.json is well-formed (includes cost_usd, not an error)",
+                        "limits_exceeded": "stop cleanly when the step limit is exceeded (LimitsExceeded)",
+                        "cross_file_rename": "rename across files (the definition and every reference)",
+                        "glob_find": "find files by glob",
+                        "apply_patch": "apply a unified diff",
+                        "apply_patch_multihunk": "multi-hunk diff in one file (repeated context must not misalign)",
+                        "bash_cd": "bash cd and file creation at a nested path",
+                        "agents_convention": "honour the AGENTS.md conventions",
+                        "edit_unique": "edit matches exactly and uniquely (replace_all must not be used)",
+                        "notebook_edit": "edit a notebook cell by cell",
+                        "json_output": "--json emits parsable JSON",
+                        "append_system_prompt": "--append-system-prompt takes effect",
+                        "no_memory_flag": "--no-memory ignores the convention files",
+                        "auto_commit": "--auto-commit commits automatically",
+                        "auto_commit_multi": "--auto-commit turns each successive edit into its own commit",
+                        "btw_isolation": "/btw side question (a real reply that does not leak into the main history)",
+                        "context_memory": "context retained across turns",
+                        "clear_reset": "/clear empties the context",
+                        "readonly_mode": "read-only mode (no disk writes under ask)",
+                        "undo_revert": "/undo reverts changes",
+                        "help_consistency": "/help matches the implementation (lists every command)",
+                        "plan_readonly": "plan mode is read-only (no disk writes)",
+                        "diff_shows": "/diff shows the changes",
+                        "compact_continuity": "after /compact the original task continues (no context lost)",
+                        "loop_repeat": "/loop repeats the prompt up to --max times",
+                        "subagent_parallel": "subagents and parallelism (/batch splits work into units produced in parallel)",
+                        "unknown_cmd_errors": "an unknown slash command must report a clear error rather than be silently ignored (§8.7)",
+                        "remember_writes": "/remember explicitly persists memory to MEMORY.md (§6.2)",
+                        "memory_autoload": "MEMORY.md loads automatically at session start and informs replies (§6.1)",
+                        "remember_nl": "a natural-language 'Remember that ...' writes to the memory file (§6.2)",
+                        "memory_status": "agent memory status prints the index and provider state (§6.2)",
+                        "trajectory_written": "a headless run writes a .trajectory/ record under --out-dir (required by §7)",
+                        "init_agents_md": "/init generates the AGENTS.md convention file (§5.1, §7)",
+                        "custom_command": "a custom command in commands/<name>.md is callable and executes as /<name> (§7)",
+                        "plan_file": "/plan writes an editable plan under .plans/ (§7)",
+                        "unknown_flag_rc2": "an unknown flag exits with code 2 (usage error, §8.7 and §9)",
+                        "conflicting_modes_rc2": "mutually exclusive permission modes (multiple --mode) exit with code 2 (§8.1)",
+                        "continue_resume_rc2": "--continue and --resume are mutually exclusive and exit with code 2 (§8.4)",
+                        "redo_change": "/redo reapplies a change reverted by /undo (§5.1)",
+                        "status_shows": "/status shows the version, model, working directory and current mode (§5.1)",
+                        "tools_lists": "/tools lists the currently available tools (§5.1)",
+                        "tui_launch_no_crash": "the interactive TUI starts without crashing (a NameError or traceback on launch is a hang; white-box srcmine 1156)",
+                        "cd_switches": "/cd changes the session working directory (new files land in the new directory) (§5.1)",
+                        "new_clears": "/new archives the current session, starts a new one and clears the context (§5.1)",
+                        "role_ask_readonly": "/role ask switches to a read-only role with no disk writes (§3.2, §8.10)",
+                    }
+                    req_bad = [r for r in bad if r.get("id") not in _INFO_SMOKE_IDS]
+                    info_bad = [r for r in bad if r.get("id") in _INFO_SMOKE_IDS]
+                    if req_bad:
+                        detail = [
+                            "The following features behaved incorrectly when actually run. Fix each one so it genuinely works; the parentheses show what the self-check observed:"
+                        ]
+                        for r in req_bad:
+                            cid = r.get("id")
+                            sym = _scrub_symptom(r.get("why"))
+                            detail.append(
+                                "    · %s%s" % (cap.get(cid, str(cid)), "(observed: %s)" % sym if sym else "")
+                            )
+                        lines.append("\n".join(detail))
+                    if info_bad:
+                        di = [
+                            "The following are advanced capabilities worth completing. They do not block this submission, but the specification still requires them:"
+                        ]
+                        for r in info_bad:
+                            cid = r.get("id")
+                            sym = _scrub_symptom(r.get("why"))
+                            di.append(
+                                "    · %s%s" % (cap.get(cid, str(cid)), "(observed: %s)" % sym if sym else "")
+                            )
+                        lines.append("\n".join(di))
+                mk = checks.get("mock_smoke") or []
+                mbad = [r for r in mk if isinstance(r, dict) and (not r.get("ok")) and r.get("blocking")]
+                if "mock_smoke_ok" in failed and mbad:
+                    ml = [
+                        "The following deterministic robustness, cost and parsing cases (basic error scenarios) did not meet the requirement. Fix them so they genuinely work; the parentheses show what was observed:"
+                    ]
+                    for r in mbad:
+                        sym = _scrub_symptom(r.get("why"))
+                        ml.append("    · %s%s" % (r.get("id"), "(observed: %s)" % sym if sym else ""))
+                    lines.append("\n".join(ml))
+                tk = checks.get("tui_smoke") or []
+                tbad = [r for r in tk if isinstance(r, dict) and (not r.get("ok")) and r.get("blocking")]
+                if "tui_smoke_ok" in failed and tbad:
+                    tl = [
+                        "The interactive interface did not display the reply to the user in a real terminal; after the user types, the assistant's reply must be visible on screen. Fix this so it genuinely works; the parentheses show what was observed:"
+                    ]
+                    for r in tbad:
+                        sym = _scrub_symptom(r.get("why"))
+                        tl.append("    · %s%s" % (r.get("id"), "(observed: %s)" % sym if sym else ""))
+                    lines.append("\n".join(tl))
+                pk = checks.get("perm_smoke") or []
+                pbad = [r for r in pk if isinstance(r, dict) and (not r.get("ok")) and r.get("blocking")]
+                if "perm_smoke_ok" in failed and pbad:
+                    pl = [
+                        "The following permission and security cases did not meet the requirement. A bypassed deny, or a leak of read-only or permission state, is a security hole and must fail closed. Fix these so they genuinely work; the parentheses show what was observed:"
+                    ]
+                    for r in pbad:
+                        sym = _scrub_symptom(r.get("why"))
+                        pl.append("    · %s%s" % (r.get("id"), "(observed: %s)" % sym if sym else ""))
+                    lines.append("\n".join(pl))
+                stk = checks.get("state_smoke") or []
+                stbad = [r for r in stk if isinstance(r, dict) and (not r.get("ok")) and r.get("blocking")]
+                if "state_smoke_ok" in failed and stbad:
+                    stl = [
+                        "The following state and sequence commands did not meet the requirement: set-get round trips for config/mcp/init, add/remove ordering, and idempotency on repeated execution. Fix these so they genuinely work; the parentheses show what was observed:"
+                    ]
+                    for r in stbad:
+                        sym = _scrub_symptom(r.get("why"))
+                        stl.append("    · %s%s" % (r.get("id"), "(observed: %s)" % sym if sym else ""))
+                    lines.append("\n".join(stl))
+                fk = checks.get("fileio_smoke") or []
+                fbad = [r for r in fk if isinstance(r, dict) and (not r.get("ok")) and r.get("blocking")]
+                if "fileio_smoke_ok" in failed and fbad:
+                    fl = [
+                        "The following write/read tool integrity cases did not meet the requirement: writing before reading must be blocked, an external change after a read must fail closed, an empty write must not truncate the file, and read/glob errors must degrade cleanly without crashing. Fix these so they genuinely work; the parentheses show what was observed:"
+                    ]
+                    for r in fbad:
+                        sym = _scrub_symptom(r.get("why"))
+                        fl.append("    · %s%s" % (r.get("id"), "(observed: %s)" % sym if sym else ""))
+                    lines.append("\n".join(fl))
+                suk = checks.get("startup_smoke") or []
+                subad = [r for r in suk if isinstance(r, dict) and (not r.get("ok")) and r.get("blocking")]
+                if "startup_smoke_ok" in failed and subad:
+                    sul = [
+                        "The following startup fail-soft cases did not meet the requirement. With a bad config, an unknown key, a BOM, or a missing directory, session construction must warn and skip rather than raise a bare traceback. Fix these so they genuinely work; the parentheses show what was observed:"
+                    ]
+                    for r in subad:
+                        sym = _scrub_symptom(r.get("why"))
+                        sul.append("    · %s%s" % (r.get("id"), "(observed: %s)" % sym if sym else ""))
+                    lines.append("\n".join(sul))
+                hdk = checks.get("headless_smoke") or []
+                hdbad = [r for r in hdk if isinstance(r, dict) and (not r.get("ok")) and r.get("blocking")]
+                if "headless_smoke_ok" in failed and hdbad:
+                    hdl = [
+                        "The following headless -p output-purity cases did not meet the requirement. With --output-format text, stdout must contain only the human-readable reply, free of internal XML or logs; with json, it must be a single valid JSON document. Fix these so they genuinely work; the parentheses show what was observed:"
+                    ]
+                    for r in hdbad:
+                        sym = _scrub_symptom(r.get("why"))
+                        hdl.append("    · %s%s" % (r.get("id"), "(observed: %s)" % sym if sym else ""))
+                    lines.append("\n".join(hdl))
+                _used = len(subs) + 1
+                _remaining = MAX_SUBMISSIONS - _used
+                if _remaining > 0:
+                    _budget = f"[submission quota] This is submission {_used} of {MAX_SUBMISSIONS}; after fixing these you have {_remaining} attempt(s) left. Try to address everything below in this round rather than spending attempts on probing or empty submissions.\n\n"
+                else:
+                    _budget = f"[submission quota] This is submission {_used} of {MAX_SUBMISSIONS} and your final attempt; the quota is now exhausted. If this submission does not pass, the build ends with the current artifact and no further submissions are accepted.\n\n"
+                hint = (
+                    _budget
+                    + "This submission did not pass validation. Working against .d2a_spec/functional_spec.md and .d2a_spec/AGENT_CONTRACT.md, bring each of the following to a genuinely working state - no placeholders, stubs, or shortcuts:\n- "
+                    + "\n- ".join(lines)
+                    + "\nWhen done, rm /opt/f0/.build-result then touch /opt/f0/.build-submit to resubmit."
+                )
+            summary = _submission_summary(len(subs) + 1, static_ok, failed, checks)
+            res = {
+                "submission": len(subs) + 1,
+                "contract_ok": ok,
+                "checks": checks,
+                "hint": hint,
+                "summary": summary,
+            }
+            subs.append(res)
+            _print_submission(summary)
+            payload = json.dumps({"contract_ok": ok, "hint": hint}, ensure_ascii=False)
+            await _run(
+                *DOCKER,
+                "exec",
+                name,
+                "bash",
+                "-lc",
+                f"cat > {RESULT_FILE} <<'D2AEOF'\n{payload}\nD2AEOF\nrm -f {CHECKING_FILE} {SUBMIT_FILE}",
+                timeout=30,
+            )
+            if ok or len(subs) >= MAX_SUBMISSIONS:
+                return {"submitted": True, "contract_ok": ok, "submissions": subs}
+        await asyncio.sleep(POLL_INTERVAL)
+
+
+import re as _re2
+
+_OVERFLOW_PAT = _re2.compile(
+    "maximum context length|context[_ ]?length[_ ]?exceeded|ContextWindowExceeded|prompt is too long|input is too long for|exceeds the maximum.{0,40}token|too many (?:input )?tokens|reduce the length of the messages",
+    _re2.I,
+)
+
+
+async def _round_overflowed(name: str) -> bool:
+    """Scan the tail of the container's /work/opencode.jsonl to see whether this round hit a
+    context-limit API error."""
+    try:
+        _, out, _ = await INJ._run(
+            *DOCKER, "exec", name, "bash", "-lc", "tail -c 30000 /work/opencode.jsonl 2>/dev/null", timeout=30
+        )
+    except Exception:
+        return False
+    return bool(_OVERFLOW_PAT.search(out or ""))
+
+
+def _detect_overflow_file(path: Path) -> bool:
+    """Fallback context-overflow scan over the exported opencode.jsonl (same strong phrases
+    as _round_overflowed)."""
+    try:
+        return bool(_OVERFLOW_PAT.search(path.read_text(encoding="utf-8", errors="replace")[-200000:]))
+    except Exception:
+        return False
+
+
+def _termination_reason(meta: dict, opencode_path: Path) -> str:
+    """Map exit_status to a plain-language termination reason (context overflow / submission
+    quota exhausted / out of time / other). Kept consistent with summarize_build.py."""
+    es = meta.get("exit_status", "") or ""
+    n = len(meta.get("submissions") or [])
+    if es == "submitted":
+        return "all contract checks passed; submission accepted"
+    if es == "submitted_contract_fail":
+        return f"still failing after {n} submission(s) (submission limit {MAX_SUBMISSIONS} reached)"
+    if es == "wall_timeout":
+        return "out of time (the 2h wall-clock budget was exhausted before an explicit submission)"
+    if es.startswith("context_overflow"):
+        return "context overflow (the context limit was exceeded during a continuation round)"
+    if es.startswith("no_progress"):
+        return (
+            "context overflow (the continuation trajectory stopped growing and a context-limit error was found)"
+            if _detect_overflow_file(opencode_path)
+            else "the builder stopped continuing (the trajectory stopped growing: the model wrapped up or gave up, not necessarily a context overflow)"
+        )
+    if es.startswith("rounds_exhausted"):
+        return f"continuation rounds exhausted (reached MAX_CONTINUE_ROUNDS={MAX_CONTINUE_ROUNDS} without an explicit submission)"
+    if _detect_overflow_file(opencode_path):
+        return f"probable context overflow (exit_status={es}; the trajectory contains a context-limit error)"
+    return f"other or unexpected: {es}"
+
+
+async def _traj_size(name: str) -> int:
+    """Current byte size of the container's /work/opencode.jsonl (progress probe; -1 if unreadable)."""
+    rc, out, _ = await INJ._run(
+        *DOCKER,
+        "exec",
+        name,
+        "bash",
+        "-lc",
+        "wc -c < /work/opencode.jsonl 2>/dev/null || echo -1",
+        timeout=30,
+    )
+    try:
+        return int((out or "-1").strip())
+    except (ValueError, AttributeError):
+        return -1
+
+
+async def _opencode_driver(name: str, mon_task: asyncio.Task) -> dict:
+    """Drive OpenCode across rounds: send build_prompt on the first round, then feed NUDGE
+    with `--continue`, until
+      - the builder submits explicitly and the contract passes (mon_task finishes first)
+        -> stop=submitted;
+      - the trajectory stops growing (model idling or refusing) -> stop=no_progress;
+      - MAX_CONTINUE_ROUNDS is reached -> stop=rounds_exhausted.
+    The outer asyncio.wait wall timeout still cancels this coroutine as a backstop."""
+    _run = INJ._run
+    first = f"cat /work/prompt.txt | {OPENCODE_BIN} run --model d2agw/builder --format json >> /work/opencode.jsonl 2>&1"
+    cont = f"cat /work/nudge.txt | {OPENCODE_BIN} run --continue --model d2agw/builder --format json >> /work/opencode.jsonl 2>&1"
+    rounds = 0
+    last_ec = None
+    prev_size = -1
+    while rounds < MAX_CONTINUE_ROUNDS:
+        rounds += 1
+        cmd = first if rounds == 1 else cont
+        ec, _so, _se = await _run(*DOCKER, "exec", "-w", F0_DIR, name, "bash", "-lc", cmd)
+        last_ec = ec
+        await asyncio.sleep(POLL_INTERVAL + 1)
+        if mon_task.done():
+            return {"rounds": rounds, "last_ec": ec, "stop": "submitted"}
+        sz = await _traj_size(name)
+        if sz <= prev_size:
+            stop = "context_overflow" if await _round_overflowed(name) else "no_progress"
+            return {"rounds": rounds, "last_ec": ec, "stop": stop}
+        prev_size = sz
+    return {"rounds": rounds, "last_ec": last_ec, "stop": "rounds_exhausted"}
+
+
+def _profile_base_port() -> int | None:
+    """Parse the port from opencode.json's provider.d2agw.options.baseURL, to check it
+    matches --gateway-port."""
+    try:
+        prof = json.loads(PROFILE.read_text())
+        url = prof["provider"]["d2agw"]["options"]["baseURL"]
+        from urllib.parse import urlparse
+
+        return urlparse(url).port
+    except Exception:
+        return None
+
+
+def compute_artifact_hash(root: Path) -> str:
+    """sha256 over the sorted (relative path, content hash) pairs -- the artifact pin used
+    for reproducibility checks."""
+    h = hashlib.sha256()
+    files = []
+    for p in sorted(root.rglob("*")):
+        if not p.is_file():
+            continue
+        rel = p.relative_to(root)
+        if any((part in _IGNORE for part in rel.parts)):
+            continue
+        files.append((str(rel), hashlib.sha256(p.read_bytes()).hexdigest()))
+    for rel, digest in sorted(files):
+        h.update(rel.encode())
+        h.update(digest.encode())
+    return h.hexdigest()
+
+
+def plan(args, run_id: str) -> list[str]:
+    """Return the readable orchestration steps (printed by --dry-run; a real run follows them)."""
+    name = f"d2a-build-{run_id}"
+    steps = [
+        f"# run_id = {run_id}   builder_tag = {args.builder_tag}   image = {args.image}",
+        "# Prerequisite: the Stage 1 gateway must be running and D2A_BUILDER_MODEL must point at the model under test (OpenCode only ever sees d2agw/builder)",
+        "docker run -d --rm --entrypoint '' --add-host=host.docker.internal:host-gateway "
+        + ("--cap-add=NET_ADMIN " if args.egress == "gateway-only" else "")
+        + f"-e D2A_GATEWAY_KEY=*** -e D2A_MODEL_BASE_URL=http://host.docker.internal:{args.gateway_port} "
+        + f"-e D2A_MODEL_NAME=litellm_proxy/builder -e D2A_MODEL_API_KEY=*** -w {F0_DIR} --name {name} {args.image} tail -f /dev/null",
+        "# ^ Unified model-connection env (the model under test itself): the TUI connects with zero configuration from these defaults, and the builder uses the same values to run and self-check, so the interface matches what evaluation injects",
+        (
+            f"# egress=gateway-only: once the container is up, iptables restricts egress to :{args.gateway_port} only, blocking the public internet to prevent leaks and contamination"
+            if args.egress == "gateway-only"
+            else "# egress=open (debugging only): egress is unrestricted"
+        ),
+        f"docker exec {name} mkdir -p /root/.opencode {SPEC_DIR} /work",
+        f"docker cp {PROFILE} {name}:/root/.opencode/opencode.json",
+        f"docker cp {args.spec or '<spec to be written>'} {name}:{SPEC_DIR}/functional_spec.md",
+        f"docker cp {CONTRACT} {name}:{SPEC_DIR}/AGENT_CONTRACT.md",
+        f"docker cp {MODEL_REF} {name}:{SPEC_DIR}/model_call_reference.py   # reference for calling the model correctly (copy it verbatim; no need to guess the API)",
+        f"docker cp {PROMPT} {name}:/work/prompt.txt"
+        + (f"  (+ docker cp {args.f0_src} {name}:{F0_DIR})" if args.f0_src else ""),
+        f"docker exec -w {F0_DIR} {name} bash -lc 'cat /work/prompt.txt | {OPENCODE_BIN} run --model d2agw/builder --format json >> /work/opencode.jsonl 2>&1'   # first round; if nothing is submitted, `opencode run --continue` nudges it onward (up to {MAX_CONTINUE_ROUNDS} rounds), with a {args.wall_seconds}s wall-clock backstop",
+        f"docker cp {name}:{F0_DIR}/. {args.out_dir}/{run_id}/agent   # export the modified f0",
+        f"docker cp {name}:/work/opencode.jsonl {args.out_dir}/{run_id}/   # archive the build trajectory",
+        f"# compute artifact_hash -> build_meta.json; docker rm -f {name}",
+    ]
+    return steps
+
+
+async def run_build(args, run_id: str) -> dict:
+    _run = INJ._run
+    if not getattr(args, "spec", None):
+        args.spec = str(SPEC)
+    name = f"d2a-build-{run_id}"
+    out_run = Path(args.out_dir) / run_id
+    (out_run / "agent").mkdir(parents=True, exist_ok=True)
+    meta = {
+        "run_id": run_id,
+        "builder_tag": args.builder_tag,
+        "image": args.image,
+        "started_at": datetime.now(CST).isoformat(),
+        "exit_status": "",
+        "artifact_hash": "",
+    }
+    if not args.spec:
+        meta["exit_status"] = "missing_spec"
+        print(
+            "[run_build] no specification document (--spec). A real run requires the M1 spec to be written first; use --dry-run to inspect the orchestration.",
+            file=sys.stderr,
+        )
+        return meta
+    prof_port = _profile_base_port()
+    if prof_port is not None and prof_port != int(args.gateway_port):
+        meta["exit_status"] = "gateway_port_mismatch"
+        print(
+            f"[run_build] port mismatch: opencode.json baseURL=:{prof_port} but --gateway-port={args.gateway_port}. Update either the baseURL in opencode.json or --gateway-port so the two agree.",
+            file=sys.stderr,
+        )
+        return meta
+    started = False
+    t0 = time.time()
+    try:
+        extra = EG.run_extra_args() if args.egress == "gateway-only" else []
+        gw_port = int(args.gateway_port)
+        model_base = f"http://host.docker.internal:{gw_port}"
+        limits = memory_limit_flags(getattr(args, "memory_limit", "12g"))
+        rc, _cid, err = await _run(
+            *DOCKER,
+            "run",
+            "-d",
+            "--rm",
+            "--entrypoint",
+            "",
+            "--add-host=host.docker.internal:host-gateway",
+            *limits,
+            *extra,
+            "-e",
+            f"D2A_GATEWAY_KEY={args.gateway_key}",
+            "-e",
+            f"D2A_MODEL_BASE_URL={model_base}",
+            "-e",
+            "D2A_MODEL_NAME=litellm_proxy/builder",
+            "-e",
+            f"D2A_MODEL_API_KEY={args.gateway_key}",
+            "-w",
+            F0_DIR,
+            "--name",
+            name,
+            args.image,
+            "tail",
+            "-f",
+            "/dev/null",
+            timeout=600,
+        )
+        if rc != 0:
+            meta["exit_status"] = "container_start_failed"
+            meta["error"] = err[:800]
+            return meta
+        started = True
+        await _run(*DOCKER, "exec", name, "mkdir", "-p", "/root/.opencode", SPEC_DIR, "/work", timeout=120)
+        await _run(*DOCKER, "cp", str(PROFILE), f"{name}:/root/.opencode/opencode.json", timeout=60)
+        await _run(*DOCKER, "cp", str(args.spec), f"{name}:{SPEC_DIR}/functional_spec.md", timeout=60)
+        await _run(*DOCKER, "cp", str(CONTRACT), f"{name}:{SPEC_DIR}/AGENT_CONTRACT.md", timeout=60)
+        await _run(*DOCKER, "cp", str(MODEL_REF), f"{name}:{SPEC_DIR}/model_call_reference.py", timeout=60)
+        _prompt_txt = PROMPT.read_text(encoding="utf-8").replace("{{MAX_SUBMISSIONS}}", str(MAX_SUBMISSIONS))
+        if _BASIC_GATE_ONLY:
+            _prompt_txt += "\n\n=== IMPORTANT: submission rules for this run ===\nThis run uses a single-shot finalization protocol. Read it carefully before you begin.\n1. Each `touch /opt/f0/.build-submit` validates only the basic gate: whether the agent installs, starts, and compiles; whether every slash command is present; whether any placeholders or stubs remain; and whether the standard programmatic interface `yuyao.agent_api` works. In short, whether the artifact is runnable and ready to be tested.\n2. Once the basic gate passes, that version is final. The build ends immediately, no further submissions are accepted, and you receive no functional or test feedback. The artifact is then evaluated in full, and that result is your final score.\n3. Only when the basic gate fails, meaning the agent is not usable at all, do you receive a build-failure notice listing what is missing, along with another chance to submit.\n4. Do not plan to submit early and iterate on feedback: no test feedback is available. Implement every requirement in `.d2a_spec/functional_spec.md` as completely and correctly as you can, and only run `touch /opt/f0/.build-submit` once you are confident this is the best version you can deliver.\n================================================\n"
+        await _run(
+            *DOCKER,
+            "exec",
+            name,
+            "bash",
+            "-lc",
+            f"cat > /work/prompt.txt <<'D2APROMPT'\n{_prompt_txt}\nD2APROMPT",
+            timeout=60,
+        )
+        await _run(
+            *DOCKER,
+            "exec",
+            name,
+            "bash",
+            "-lc",
+            f"cat > /work/nudge.txt <<'D2ANUDGE'\n{_NUDGE}\nD2ANUDGE",
+            timeout=30,
+        )
+        if args.f0_src:
+            await _run(
+                *DOCKER,
+                "exec",
+                name,
+                "bash",
+                "-lc",
+                f'set -e; cd {F0_DIR}; find . -mindepth 1 -maxdepth 1 -not -name ".*" -exec rm -rf {{}} + ; echo "[f0-src] wiped f0 (kept dotfiles)"',
+                timeout=120,
+            )
+            await _run(*DOCKER, "cp", f"{args.f0_src}/.", f"{name}:{F0_DIR}", timeout=300)
+            await _run(
+                *DOCKER,
+                "exec",
+                name,
+                "bash",
+                "-lc",
+                f"find {F0_DIR} -name __pycache__ -type d -prune -exec rm -rf {{}} + 2>/dev/null || true",
+                timeout=60,
+            )
+        gw_port = int(args.gateway_port)
+        if args.egress == "gateway-only":
+            eg = await EG.harden(_run, DOCKER, name, gw_port)
+            if eg["applied"]:
+                eg.update(await EG.verify(_run, DOCKER, name))
+            else:
+                print(
+                    f"[run_build] warning: egress is not restricted: {eg['reason']}. A comparable run must satisfy this prerequisite.",
+                    file=sys.stderr,
+                )
+            meta["egress"] = eg
+        mon_task = asyncio.create_task(_submit_monitor(name))
+        driver_task = asyncio.create_task(_opencode_driver(name, mon_task))
+        done, pending = await asyncio.wait(
+            {driver_task, mon_task}, timeout=args.wall_seconds, return_when=asyncio.FIRST_COMPLETED
+        )
+        for t in pending:
+            t.cancel()
+        for t in pending:
+            try:
+                await t
+            except (asyncio.CancelledError, Exception):
+                pass
+        meta["submitted"] = False
+        mon_result = None
+        if mon_task in done and (not mon_task.cancelled()):
+            try:
+                mon_result = mon_task.result()
+            except Exception as e:
+                meta["exit_status"] = f"monitor_error:{type(e).__name__}"
+                meta["error"] = str(e)[:300]
+        if mon_result is not None:
+            r = mon_result
+            meta.update(submitted=r["submitted"], contract_ok=r["contract_ok"], submissions=r["submissions"])
+            meta["exit_status"] = "submitted" if r["contract_ok"] else "submitted_contract_fail"
+            if driver_task in done and (not driver_task.cancelled()):
+                try:
+                    meta["build_rounds"] = driver_task.result().get("rounds")
+                except Exception:
+                    pass
+        elif meta["exit_status"]:
+            pass
+        elif driver_task in done and (not driver_task.cancelled()):
+            try:
+                d = driver_task.result()
+                meta["build_rounds"] = d.get("rounds")
+                meta["exit_status"] = f"{d.get('stop', 'driver_done')}_no_submit"
+            except Exception as e:
+                meta["exit_status"] = f"opencode_error:{type(e).__name__}"
+        else:
+            meta["exit_status"] = "wall_timeout"
+        await _run(*DOCKER, "cp", f"{name}:{F0_DIR}/.", str(out_run / "agent"), timeout=300)
+        await _run(
+            *DOCKER, "cp", f"{name}:/work/opencode.jsonl", str(out_run / "opencode.jsonl"), timeout=120
+        )
+        meta["artifact_hash"] = compute_artifact_hash(out_run / "agent")
+    except Exception as e:
+        meta["exit_status"] = meta["exit_status"] or f"build_error:{type(e).__name__}"
+        meta["error"] = str(e)[:800]
+    finally:
+        if started:
+            await _run(*DOCKER, "rm", "-f", name, timeout=120)
+    meta["elapsed_s"] = round(time.time() - t0, 1)
+    meta["termination_reason"] = _termination_reason(meta, out_run / "opencode.jsonl")
+    (out_run / "build_meta.json").write_text(json.dumps(meta, ensure_ascii=False, indent=2))
+    try:
+        REG.register(
+            {
+                "kind": "build",
+                "run_id": run_id,
+                "builder_tag": args.builder_tag,
+                "artifact_hash": meta.get("artifact_hash", ""),
+                "exit_status": meta["exit_status"],
+                "submitted": meta.get("submitted", False),
+                "contract_ok": meta.get("contract_ok", False),
+                "raw_path": str(out_run / "agent"),
+            }
+        )
+    except Exception as e:
+        print(f"[run_build] registration failed (ignored): {e}", file=sys.stderr)
+    return meta
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser(
+        description="Stage 1 build orchestration: the builder uses OpenCode to transform mini into an artifact"
+    )
+    ap.add_argument(
+        "--builder-tag",
+        required=True,
+        help="short tag for the model under test, used in run_id and meta; the actual model is determined by the Stage 1 gateway via D2A_BUILDER_MODEL",
+    )
+    ap.add_argument("--spec", default="", help=f"path to the specification document (default: {SPEC.name})")
+    ap.add_argument(
+        "--f0-src",
+        default="",
+        help="optional host directory of mini sources that overrides /opt/f0 in the image",
+    )
+    ap.add_argument(
+        "--image",
+        default=DEFAULT_IMAGE,
+        help=f"builder image (default {DEFAULT_IMAGE}; override with D2A_BUILDER_IMAGE)",
+    )
+    ap.add_argument(
+        "--gateway-key",
+        default=os.environ.get("D2A_GATEWAY_KEY", "sk-d2a-local-master"),
+        help="master key for the local gateway (default: D2A_GATEWAY_KEY); it is the only credential in the container, which holds no upstream credentials",
+    )
+    ap.add_argument("--out-dir", default=str(HERE.parent.parent / "results" / "stage1"))
+    ap.add_argument(
+        "--wall-seconds",
+        type=int,
+        default=7200,
+        help="build wall-clock budget in seconds (killed on timeout; default 2h)",
+    )
+    ap.add_argument(
+        "--memory-limit",
+        default=default_memory_limit(),
+        help="per-container memory cap passed to `docker run --memory` (default 12g, override with D2A_BUILD_MEMORY; '0' disables). A normal build sits around 300MB, so this is ~40x headroom -- it exists to contain a runaway, not to ration normal work. Without it a single build that allocates unboundedly can take the whole host down, and the OOM killer then reaps its sibling builds too.",
+    )
+    ap.add_argument(
+        "--gateway-port",
+        type=int,
+        default=int(os.environ.get("D2A_GATEWAY_PORT", "4000")),
+        help="builder gateway port; must match the baseURL in opencode.json (override with D2A_GATEWAY_PORT). The egress allowlist opens only this port.",
+    )
+    ap.add_argument(
+        "--egress",
+        choices=["open", "gateway-only"],
+        default="gateway-only",
+        help="gateway-only (default): allow the gateway port only and block the public internet, so a build cannot fetch answers or leak the spec; needs iptables and NET_ADMIN in the image. open: no restriction (debugging only).",
+    )
+    ap.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="print the orchestration plan only: no container, no model call, no cost",
+    )
+    args = ap.parse_args()
+    if not args.spec:
+        args.spec = str(SPEC)
+    for _doc in (Path(args.spec), PROMPT, CONTRACT, MODEL_REF):
+        if not _doc.is_file():
+            raise SystemExit(f"[run_build] required document is missing: {_doc}")
+    run_id = datetime.now(CST).strftime("%Y-%m-%d-%H-%M")
+    out_base = Path(args.out_dir)
+    if not args.dry_run:
+        stem, i = (run_id, 1)
+        while True:
+            try:
+                (out_base / run_id).mkdir(parents=True, exist_ok=False)
+                break
+            except FileExistsError:
+                i += 1
+                run_id = f"{stem}-{i}"
+    if args.dry_run:
+        prof_port = _profile_base_port()
+        if prof_port is not None and prof_port != int(args.gateway_port):
+            print(
+                f"[run_build] port mismatch: opencode.json baseURL=:{prof_port} but --gateway-port={args.gateway_port}. Update either the baseURL in opencode.json or --gateway-port so the two agree.",
+                file=sys.stderr,
+            )
+            return 2
+        print(f"=== Stage 1 build orchestration plan (dry-run, run_id={run_id}) ===")
+        for s in plan(args, run_id):
+            print(s)
+        print(
+            "\n(For a real run, drop --dry-run; it requires the builder image, the specification document, and a running Stage 1 gateway.)"
+        )
+        return 0
+    meta = asyncio.run(run_build(args, run_id))
+    print(json.dumps(meta, ensure_ascii=False, indent=2))
+    return 0 if meta.get("artifact_hash") else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/code/src/stage1/smoke/fileio_smoke.py b/code/src/stage1/smoke/fileio_smoke.py
new file mode 100644
index 0000000000000000000000000000000000000000..bc2f05211baf2dde624170a652f625b7b07abb89
--- /dev/null
+++ b/code/src/stage1/smoke/fileio_smoke.py
@@ -0,0 +1,1133 @@
+#!/usr/bin/env python3
+"""Deterministic smoke for file-tool integrity (mock driven, zero real-model budget).
+
+Covers glob (sorting and truncation), grep (.gitignore, type filter, default output mode, head_limit),
+notebook editing (cell isolation), `/rewind` restoring an edited file, symlink and out-of-workspace reads,
+`memory_get` path fencing, extension definitions reached through symlinks, and bounded character-device reads.
+
+Mechanism: reuses perm_smoke's subprocess bootstrap (_child_code/_run_child/_BOOT) plus mock_gateway's `seq_probe`
+multi-round tool sequencer. Each round issues, in parallel, a liveness bash (writing live.txt as execution evidence)
+and the tool under test. Observation: file contents after the change through res['tgt'], tool results fed back
+into messages through res['mtok'].
+
+No false positives: (1) every "must be blocked/untouched" case has a "must land" control proving the tool really can
+write/read and the probe works, with suite-level gating -- when the control is not PASS its dependants become
+inconclusive, so "the tool never worked, hence the file did not change" cannot masquerade as a correct refusal;
+(2) an N/A guard: if the build does not advertise the tool under test the row is inconclusive (reusing
+perm_smoke's `_adv`).
+
+Usage: python fileio_smoke.py <agent_dir> [--emit-json]   (needs an interpreter that has litellm)
+"""
+from __future__ import annotations
+
+import json
+import os
+import re
+import shutil
+import subprocess
+import sys
+import tempfile
+import threading
+from pathlib import Path
+
+HERE = Path(__file__).resolve().parent
+sys.path.insert(0, str(HERE))
+import mock_gateway as MG  # noqa: E402
+import perm_smoke as PS  # noqa: E402
+import smoke_contract as SC  # noqa: E402
+
+TGT = PS.TGT          # "tgt.txt"
+TGT2 = PS.TGT2        # "tgt2.txt"
+ORIG = PS.ORIG        # "ORIG_PERM_0001\n"
+_ALLOW = PS._ALLOW    # echo PERM_LIVE_7755 > live.txt
+
+
+# ---- N/A guard + executed evidence ----
+def _na(res, reqs, err, tool):
+    if res is None:
+        return (False, f"the child process reported no result (crash/timeout) reqs={reqs} err={err[-160:]!r}")
+    adv = res.get("_adv") or []
+    tools = list(tool) if isinstance(tool, (list, tuple, set)) else [tool]
+    # Match by normalised capability family rather than exact name (see mock_gateway.canon_tool).
+    if not MG.adv_has_tool(adv, tools):
+        return (True, f"inconclusive: the build does not advertise the standalone tool {tools!r} to the model (adv={adv})")
+    return None
+
+
+def _alive(res, reqs):
+    return (res.get("live") is True) and (reqs >= 2)
+
+
+def _target_result(res):
+    """Return only the declared target call's latest tool result."""
+    value = res.get("_target_tool_result")
+    return "" if value is None else str(value)
+
+
+def chk_transition_control(expected, tool):
+    """Require every named file-state boundary of a control to be witnessed."""
+    def _f(res, reqs, err):
+        ng = _na(res, reqs, err, tool)
+        if ng is not None:
+            return ng
+        actual = {key: res.get(key) for key in expected}
+        ok = actual == expected and _alive(res, reqs)
+        return ok, (
+            f"transition expected={expected!r} actual={actual!r} "
+            f"live={res.get('live')} reqs={reqs}"
+        )
+    return _f
+
+
+def chk_memory_get_event(marker, tool="memory_get"):
+    """Require the marker to be newly observed after the memory_get phase."""
+    def _f(res, reqs, err):
+        ng = _na(res, reqs, err, tool)
+        if ng is not None:
+            return ng
+        before = res.get("phase1_mtok") or ""
+        after = res.get("phase2_mtok") or ""
+        delta = after.count(marker) - before.count(marker)
+        ok = delta > 0 and _alive(res, reqs)
+        return ok, (
+            f"event-scoped marker delta={delta} before_count={before.count(marker)} "
+            f"after_count={after.count(marker)} live={res.get('live')} reqs={reqs}"
+        )
+    return _f
+
+
+def chk_fixture_markers(markers, tool="bash"):
+    """Require all independently probed filesystem-shape markers."""
+    def _f(res, reqs, err):
+        ng = _na(res, reqs, err, tool)
+        if ng is not None:
+            return ng
+        mtok = res.get("mtok") or ""
+        missing = [marker for marker in markers if marker not in mtok]
+        ok = not missing and _alive(res, reqs)
+        return ok, (
+            f"fixture markers missing={missing} live={res.get('live')} reqs={reqs}"
+        )
+    return _f
+
+
+_REWIND_UNKNOWN_SIGS = (
+    "unknown command", "unknown slash", "unrecognized", "not recognized",
+    "no such command", "is not a command", "not a valid command", "not implemented",
+    "未知命令", "无此命令", "不支持的命令",
+)
+
+
+def chk_rewind_restores(expected, tool):
+    """v6§5.1:262: `/rewind` (`/checkpoint`) can RESTORE CODE to an earlier point.
+
+    Printing a checkpoint menu is not enough; the spec requires a real restore. This row judges the effect:
+    after the write tool changed a file, `/rewind` must return the target file to its exact pre-change content.
+
+    Three states:
+    - `/rewind` not recognised => NA (a missing command is not this row's concern; no double penalty)
+    - the `undo_reverts_overwrite_control` control failing => NA (edit tracking was never established)
+    - restored to the pre-change content => PASS; only a menu, or only truncating the conversation while the file is
+      untouched => FAIL
+    """
+    def _f(res, reqs, err):
+        ng = _na(res, reqs, err, tool)
+        if ng is not None:
+            return ng
+        rets = res.get("mid1_rets") or []
+        blob = " ".join(str(x) for x in rets).lower()
+        if blob and any(sig in blob for sig in _REWIND_UNKNOWN_SIGS):
+            return True, f"inconclusive: `/rewind` is not recognised out={blob[:110]!r}"
+        before, after = res.get("phase1_tgt"), res.get("after_mid1_tgt")
+        if before == expected:
+            return True, (f"inconclusive: the change itself never landed (still the original after phase1), and with "
+                          f"nothing changed there is nothing to restore phase1_tgt={before!r}")
+        ok = (after == expected)
+        return ok, (f"restored to the pre-change content after /rewind={ok} (after the change={before!r} -> after "
+                    f"rewind={after!r}, expected={expected!r}) out={blob[:90]!r}"
+                    f" (v6§5.1:262 /rewind must really restore code; only a menu, or only touching the conversation, = FAIL)")
+    return _f
+
+
+def chk_mtok_contains(token, tool="read"):
+    """Read/search control: the tool result must contain token (fed back into messages), proving the read path works."""
+    def _f(res, reqs, err):
+        ng = _na(res, reqs, err, tool)
+        if ng is not None:
+            return ng
+        seen = token in (res.get("mtok") or "")
+        ok = seen and _alive(res, reqs)
+        return ok, f"result contains {token!r}={seen} live={res.get('live')} reqs={reqs} (read results should be fed back into messages)"
+    return _f
+
+
+def chk_notebook_isolated(tool="notebook_edit"):
+    """§1.1 notebook-edit: replace must change the target cell, leave the neighbouring cells' WHOLE OBJECTS untouched
+    and remove the old value. The notebook JSON on disk is parsed directly, so checking only a source marker cannot
+    miss a neighbouring cell's metadata/outputs/execution_count being rebuilt."""
+    def _f(res, reqs, err):
+        ng = _na(res, reqs, err, tool)
+        if ng is not None:
+            return ng
+        raw = res.get("nb") or ""
+        try:
+            nb = json.loads(raw)
+            cells = nb.get("cells") if isinstance(nb, dict) else None
+        except Exception:
+            cells = None
+        shape_ok = isinstance(cells, list) and len(cells) == 3
+        blob = json.dumps(cells, ensure_ascii=False) if shape_ok else ""
+        new_in = "CELL1_NEW" in blob
+        old_gone = "CELL1_OLD" not in blob
+        k0 = shape_ok and cells[0] == _NB_CELL0
+        k2 = shape_ok and cells[2] == _NB_CELL2
+        ok = shape_ok and new_in and old_gone and k0 and k2 and _alive(res, reqs)
+        return ok, (f"notebook parses with 3 cells={shape_ok} target cell changed={new_in} old value gone={old_gone} "
+                    f"neighbour cell0 intact={k0} neighbour cell2 intact={k2} live={res.get('live')} reqs={reqs}"
+                    f" (notebook_edit replace must change only the target cell and leave the other cells' whole "
+                    f"objects untouched)")
+    return _f
+
+
+def chk_grep_paths_only(paths, body_tokens, tool="grep"):
+    """grep `files_with_matches`: it must return the matching file paths and must not carry matched line bodies.
+
+    Only the unique file path is wanted.
+    The body tokens exist only in the file bodies on disk, never in tool arguments, so their presence in mtok proves
+    the implementation degraded into content mode.
+    """
+    def _f(res, reqs, err):
+        ng = _na(res, reqs, err, tool)
+        if ng is not None:
+            return ng
+        result = _target_result(res)
+        has_paths = all(path in result for path in paths)
+        leaked = [token for token in body_tokens if token in result]
+        count_records = re.findall(r"(?:^|\n)\s*[^:\n]+:\s*\d+\s*(?:\n|$)", result)
+        ok = has_paths and not leaked and not count_records and _alive(res, reqs)
+        return ok, (
+            f"target result has every path={has_paths} body leaked={leaked} count records={count_records} "
+            f"live={res.get('live')} reqs={reqs}"
+            " (v6§1.1:140 files_with_matches returns matching files only and must not degrade into content)"
+        )
+    return _f
+
+
+def chk_grep_type_filter(inc_file, exc_file, tool="grep"):
+    """v6§1.1:140 grep ("can be narrowed by glob or TYPE"): grep with type:py must match only the .py and exclude the
+    .txt. The seed puts the same needle in inc(.py) and exc(.txt); with type in effect mtok contains inc and not exc
+    = PASS, while ignoring type (no type in the schema, or a handler that never reads it) matches both and mtok
+    contains exc = FAIL. No false positives: the inc hit proves grep really ran and type did not wrongly exclude the
+    py; only "exc present = type had no effect" fails.
+    A grep whose schema has no `type` parameter, or whose handler never reads it, searches every type."""
+    def _f(res, reqs, err):
+        ng = _na(res, reqs, err, tool)
+        if ng is not None:
+            return ng
+        mtok = res.get("mtok") or ""
+        has_inc = inc_file in mtok
+        has_exc = exc_file in mtok
+        ok = has_inc and (not has_exc) and _alive(res, reqs)
+        return ok, (f"contains {inc_file} (py hit)={has_inc} contains {exc_file} (type should exclude it)={has_exc} "
+                    f"live={res.get('live')} reqs={reqs}"
+                    f" (v6§1.1:140 grep type:py must match only the .py and exclude the .txt; the .txt appearing "
+                    f"means the type filter was silently ignored)")
+    return _f
+
+
+def chk_grep_finds(needle_file, tool="grep"):
+    """Control: grep finds the needle in a non-ignored file, proving the grep tool path works and the probe is not running vacuously."""
+    def _f(res, reqs, err):
+        ng = _na(res, reqs, err, tool)
+        if ng is not None:
+            return ng
+        mtok = res.get("mtok") or ""
+        ok = (needle_file in mtok) and _alive(res, reqs)
+        return ok, (f"hit {needle_file}={needle_file in mtok} live={res.get('live')} reqs={reqs}"
+                    f" (grep control: the needle must be found in an ordinary file)")
+    return _f
+
+
+def chk_extension_inside_symlink_control(res, reqs, err):
+    """Inward-symlink positive control for extension definitions.
+
+    Truth table:
+      * harness could not prove every definition node is a symlink resolving inside repo -> NA;
+      * child did not execute the real model/tool path -> FAIL;
+      * at least one of commands/skills/hooks/plugins emits its definition-only external marker
+        -> PASS; none emits a marker -> FAIL.
+
+    Per-face applicability is retained in `_extension_seen`; the paired hard target repeats this
+    inward run and only judges faces whose inward marker was actually observed.
+    """
+    if res is None:
+        return False, f"no result from the child process reqs={reqs} err={(err or '')[-160:]!r}"
+    if res.get("_extension_fixture_ok") is not True:
+        return True, (
+            f"inconclusive: the inward extension symlink fixture did not self-prove "
+            f"error={res.get('_extension_fixture_error')!r}"
+        )
+    seen = {
+        face: bool((res.get("_extension_seen") or {}).get(face))
+        for face in _EXTENSION_FACES
+    }
+    live = res.get("live") is True and int(res.get("_extension_request_count") or 0) >= 2
+    applicable = [face for face, value in seen.items() if value]
+    ok = live and bool(applicable)
+    return ok, (
+        f"inward definition exact markers={seen} applicable={applicable} "
+        f"live={res.get('live')} requests={res.get('_extension_request_count')} reqs={reqs}"
+        " (v6§7:433-436: legal in-workspace definitions must still be discoverable and executable; the fence must "
+        "not be passed by refusing every symlink)"
+    )
+
+
+def chk_extension_symlink_fence(res, reqs, err):
+    """Paired checker: extension definitions must not be reached through an outward symlink.
+
+    Truth table:
+      * either filesystem fixture cannot prove the inward/outward realpath relation -> NA;
+      * paired inward run is not live or observes no definition-only marker -> NA;
+      * paired outward run is not live -> NA (absence would be vacuous);
+      * any outward command/skill/hook/plugin marker is observed -> FAIL;
+      * zero outward markers for every face, with at least one inward-applicable face -> PASS.
+
+    Marker provenance is external to the product workspace: command/hook/plugin execution appends
+    exact lines to harness-owned files, while command/skill/plugin discovery uses full high-entropy
+    tokens that occur only in the symlink target definition.  No definition name, error substring,
+    or cumulative `mtok` approximation is accepted.
+    """
+    if res is None:
+        return False, f"no result from the paired extension child process reqs={reqs} err={(err or '')[-160:]!r}"
+    if res.get("_extension_inside_fixture_ok") is not True \
+            or res.get("_extension_outside_fixture_ok") is not True:
+        return True, (
+            "inconclusive: the paired extension symlink fixture did not self-prove "
+            f"inside_error={res.get('_extension_inside_fixture_error')!r} "
+            f"outside_error={res.get('_extension_outside_fixture_error')!r}"
+        )
+    inside_live = res.get("_extension_inside_live") is True \
+        and int(res.get("_extension_inside_request_count") or 0) >= 2
+    outside_live = res.get("_extension_outside_live") is True \
+        and int(res.get("_extension_outside_request_count") or 0) >= 2
+    inside = {
+        face: bool((res.get("_extension_inside_seen") or {}).get(face))
+        for face in _EXTENSION_FACES
+    }
+    outside = {
+        face: bool((res.get("_extension_outside_seen") or {}).get(face))
+        for face in _EXTENSION_FACES
+    }
+    applicable = [face for face, value in inside.items() if value]
+    if not inside_live or not applicable:
+        return True, (
+            f"inconclusive: the paired inward control did not hold live={inside_live} markers={inside}"
+        )
+    if not outside_live:
+        return True, (
+            f"inconclusive: the paired outward run was not live requests="
+            f"{res.get('_extension_outside_request_count')}, so zero markers cannot serve as proof of refusal"
+        )
+    escaped = [face for face, value in outside.items() if value]
+    ok = not escaped
+    return ok, (
+        f"inward exact markers={inside} applicable={applicable}; "
+        f"outward exact markers={outside} escaped={escaped} reqs={reqs}"
+        " (v6§7:433-436 x v6§0.1.1 --repo-dir workspace boundary: the commands/skills/hooks/plugins definition "
+        "resolver must realpath-contain; an outward symlink must not be discovered or executed)"
+    )
+
+
+_ALLOW_SPEC = {"name": "bash", "command": _ALLOW}
+
+# Extension definitions reached through symlinks.  Wire markers occur only in the
+# definition bodies; execution markers are exact lines in harness-owned files
+# outside the product workspace.
+_EXTENSION_FACES = ("commands", "skills", "hooks", "plugins")
+_EXTENSION_WIRE_MARKERS = {
+    "commands": "EXTSYM_COMMAND_BODY_9417",
+    "skills": "EXTSYM_SKILL_BODY_9418",
+    "plugins": "EXTSYM_PLUGIN_BODY_9419",
+}
+_EXTENSION_EXEC_MARKERS = {
+    "commands": "EXTSYM_COMMAND_EXEC_9420",
+    "hooks": "EXTSYM_HOOK_EXEC_9421",
+    "plugins": "EXTSYM_PLUGIN_EXEC_9422",
+}
+_EXTENSION_SETUP = (
+    "/mode yolo",
+    "/extsymcommand",
+    "/skill extsymskill",
+    "/extsymplugin",
+)
+
+# grep/.gitignore fixtures: git init (rg honours .gitignore for untracked files inside a git repo) plus a
+# live.txt write as execution evidence
+_GI_NEEDLE = "NEEDLE_GI_7731"
+# notebook_edit fixture: neighbouring cells carry distinct metadata/outputs/execution_count so isolation can be
+# asserted structurally.
+_NB_CELL0 = {"cell_type": "markdown", "metadata": {"tags": ["KEEP0"], "nested": {"k": 0}},
+             "source": ["CELL0_KEEP\n"]}
+_NB_CELL2 = {"cell_type": "code", "metadata": {"tags": ["KEEP2"], "nested": {"k": 2}},
+             "source": ["CELL2_KEEP\n"], "outputs": [{"output_type": "stream", "name": "stdout",
+                                                       "text": ["KEEP2_OUTPUT\n"]}],
+             "execution_count": 42}
+_NB_JSON = json.dumps({"cells": [
+    _NB_CELL0,
+    {"cell_type": "code", "metadata": {"target": True}, "source": ["CELL1_OLD\n"],
+     "outputs": [], "execution_count": None},
+    _NB_CELL2],
+    "metadata": {}, "nbformat": 4, "nbformat_minor": 5})
+
+
+def _echo_assembled(prefix: str, rest: str) -> dict:
+    """Print a sentinel whose full string never appears in the command text.
+
+    Why it must be assembled: `mtok` holds both tool results AND the command echo, so a token appearing verbatim in
+    the command makes the assertion trivially true -- an implementation that never executed would PASS.
+    """
+    return {"name": "bash", "command": f"python3 -c \"print('{prefix}' + '{rest}')\""}
+
+
+def chk_mtok_has(marker, tool, why=""):
+    """marker must appear in mtok (printed by _byte_probe, standing for some byte-level fact holding)."""
+    def _f(res, reqs, err):
+        ng = _na(res, reqs, err, tool)
+        if ng is not None:
+            return ng
+        mtok = res.get("mtok") or ""
+        ok = (marker in mtok) and _alive(res, reqs)
+        return ok, (f"mtok contains {marker!r}? {marker in mtok} live={res.get('live')} reqs={reqs}"
+                    f"{' (' + why + ')' if why else ''}")
+    return _f
+
+
+def chk_mtok_lacks(marker, probe, tool, why=""):
+    """marker must NOT appear in mtok, but probe must (proving the round really ran rather than passing vacuously).
+
+    `mtok` is `_mblob()[-12000:]`, i.e. the TAIL only, so probe must be something that lands in the tail (usually a
+    final `echo XXX_DONE_7755` round). A marker at the HEAD of a huge output would fall out of the observation window
+    even for a perfectly correct implementation -- a false negative the harness itself would introduce.
+
+    Without the probe half, a build whose tool never executed would falsely PASS simply because the marker is absent.
+    """
+    def _f(res, reqs, err):
+        ng = _na(res, reqs, err, tool)
+        if ng is not None:
+            return ng
+        mtok = res.get("mtok") or ""
+        ran = probe in mtok
+        bad = marker in mtok
+        ok = ran and (not bad) and _alive(res, reqs)
+        return ok, (f"really ran({probe})={ran} forbidden {marker!r} present={bad} "
+                    f"live={res.get('live')} reqs={reqs}{' (' + why + ')' if why else ''}")
+    return _f
+
+
+CASES = [
+
+    # ===== glob: the tool path itself must work =====
+    # v6§1.1:141 does not define whether `**` matches zero directory levels, and an fnmatch-based glob reads
+    # `**/*.py` as requiring a `/`. This control only asks whether glob works at all, so the same round also
+    # sends the equivalent pattern without `**`; either hit proves the path works. Only the control is relaxed,
+    # never any assertion it gates.
+    dict(id="glob_finds_inside_control", kind="control", tool="glob", setup=["/mode yolo"],
+         seed={"inside_ok.py": "x\n"},
+         rounds=[[_ALLOW_SPEC, {"name": "glob", "args": {"pattern": "**/*.py"}},
+                  {"name": "glob", "args": {"pattern": "*.py"}}]],
+         check=chk_mtok_contains("inside_ok", "glob")),
+
+    # ===== grep control (§1.1 grep) =====
+    dict(id="grep_finds_needle_control", kind="control", tool="grep", setup=["/mode yolo"],
+         seed={"plain_gi.txt": f"{_GI_NEEDLE} here\n"},
+         rounds=[[_ALLOW_SPEC, {"name": "grep", "args": {"pattern": _GI_NEEDLE, "path": "."}}]],
+         check=chk_grep_finds("plain_gi.txt", "grep")),
+
+    # Extension symlink fence: zero-weight inward symlink control.
+    # The case-local harness creates symlinks for the four definition files (commands/skills/hooks/plugins) before
+    # the Session is constructed, with every realpath inside the workspace. At least one definition surface must
+    # prove discovery/execution through a definition-only wire token or a harness-owned exact execution line, so the
+    # target applies surface by surface.
+    dict(id="extension_inside_symlink_discovery_control", kind="reject_soft", tool="bash",
+         setup=list(_EXTENSION_SETUP), seed={}, rounds=[[_ALLOW_SPEC]],
+         extension_harness="inside",
+         check=chk_extension_inside_symlink_control, blocking=False),
+    # target: the same case first runs the inward counterfactual, then moves only the four definition symlinks'
+    # realpaths outside the workspace; command name, skill name, hook event, plugin manifest and mock rounds are
+    # otherwise identical.
+    # Anchor v6§7:433-436 x v6§0.1.1: the extension resolver is a workspace-convention discovery surface and must not
+    # read or execute external definitions through a symlink; any strict external marker means FAIL.
+    dict(id="extension_definition_symlink_outside_fenced", kind="reject",
+         gate="extension_inside_symlink_discovery_control", tool="bash",
+         setup=list(_EXTENSION_SETUP), seed={}, rounds=[[_ALLOW_SPEC]],
+         extension_harness="paired",
+         check=chk_extension_symlink_fence),
+    # ===== v6§1.1:140: grep's `type` file-type filter must take effect =====
+    # A grep schema/handler without a `type` parameter drops a supplied type and
+    # every type is searched; others do `if type: cmd += ["-t", type]` and narrow correctly. The seed puts the same
+    # needle in a .py and a .txt: with type:py in effect, only the .py matches.
+    # Gated on the grep control. No false positives: the included .py matching proves grep really ran, and the
+    # excluded .txt matching means type had no effect => FAIL.
+    dict(id="grep_type_filter_ignored", kind="reject", gate="grep_finds_needle_control",
+         tool="grep", setup=["/mode yolo"],
+         seed={"gt_hit.py": "NEEDLE_GTYPE_7731 python\n", "gt_hit.txt": "NEEDLE_GTYPE_7731 text\n"},
+         rounds=[[_ALLOW_SPEC, {"name": "grep", "args": {"pattern": "NEEDLE_GTYPE_7731", "path": ".", "type": "py"}}]],
+         check=chk_grep_type_filter("gt_hit.py", "gt_hit.txt", "grep")),
+
+    dict(id="undo_reverts_overwrite_control", kind="control", tool="write", setup=["/mode yolo"],
+         seed={TGT: ORIG},
+         phase1_rounds=[[_ALLOW_SPEC, {"name": "read", "args": {"file_path": TGT}}],
+                        [{"name": "write", "args": {"file_path": TGT, "content": "OVR_BODY_7755\n"}}]],
+         mid_slash=["/undo"],
+         phase2_rounds=[[{"name": "bash", "command": "echo POSTUNDO_7755"}]],
+         check=chk_transition_control({
+             "phase1_tgt": "OVR_BODY_7755\n",
+             "after_mid1_tgt": ORIG,
+             "tgt": ORIG,
+         }, "write")),
+    # v6§5.1:262 /rewind must really restore, not just print a checkpoint menu.
+    # The trigger shape differs between implementations, and the SAME `/rewind N` can mean opposite things:
+    #   - N = how many steps back (calls undo N times) => `/rewind 1` works, `/rewind 0` is a no-op;
+    #   - N = a checkpoint index (only [0] existing) => `/rewind 1` is out of range;
+    #   - a bare `/rewind` restores (popping the undo stack directly).
+    # => all three are sent. Sending extra cannot over-roll-back: there is only one edit, so once restored the rest
+    #   are no-ops or menu listings, and the assertion only looks at whether the final state equals the pre-edit one.
+    #   Gated on the undo control: if edit tracking was never established the row is NA rather than unfair.
+    # A checkpoint taken only at the start of a turn, covering only files already read, misses a file read and
+    # changed within the same turn; a user editing a file in their first turn could not restore it either, so that
+    # is scored FAIL as an implementation shortfall, not treated as a fixture problem.
+    dict(id="rewind_restores_edited_file", kind="reject", gate="undo_reverts_overwrite_control",
+         tool="write", setup=["/mode yolo"], seed={TGT: ORIG},
+         phase1_rounds=[[_ALLOW_SPEC, {"name": "read", "args": {"file_path": TGT}}],
+                        [{"name": "write", "args": {"file_path": TGT, "content": "RWOVR_8821\n"}}]],
+         mid_slash=["/rewind 1", "/rewind 0", "/rewind"],
+         phase2_rounds=[[{"name": "bash", "command": "echo POSTRW_8821"}]],
+         check=chk_rewind_restores(ORIG, "write")),
+    # ===== notebook_edit cell isolation (§1.1 notebook-edit): replace the target cell, leave the others alone =====
+    # Notebook tools differ in argument names (e.g. notebook_path/cell_number/new_source/edit_mode), so canonical
+    #   arguments go through the shared schema mapper; a read round comes first so a read-before-edit gate does
+    #   not refuse the edit.
+    dict(id="notebook_edit_cell_isolation", kind="reject", tool="notebook_edit", setup=["/mode yolo"],
+         seed={"nb.ipynb": _NB_JSON},
+         rounds=[[_ALLOW_SPEC, {"name": "read", "args": {"file_path": "nb.ipynb"}}],
+                 [{"name": ["notebook_edit", "notebook-edit"],
+                   "args": {"file_path": "nb.ipynb", "cell_index": 1,
+                            "mode": "replace", "source": "CELL1_NEW"}}],
+                 [{"name": "bash", "command": "cat nb.ipynb"}]],
+         check=chk_notebook_isolated(("notebook_edit", "notebook-edit"))),
+    dict(id="glob_truncation_keeps_sorted_end", kind="reject", gate="glob_finds_inside_control",
+         tool="glob", setup=["/mode yolo"], seed={},
+         rounds=[[_ALLOW_SPEC,
+                  {"name": "bash",
+                   "command": "mkdir -p gord && python3 -c \"import pathlib;"
+                              "pathlib.Path('gord/OLD' + 'EST_7755.ordx').write_text('x')\" && "
+                              "touch -t 200001010000 gord/OLD*_7755.ordx && "
+                              "python3 -c \"import os\nfor i in range(800): "
+                              "open('gord/n%d.ordx' % i,'w').write('x')\" && echo ORD_SEEDED_7755"}],
+                 [{"name": "glob", "args": {"pattern": "**/*.ordx"}}]],
+         check=chk_mtok_lacks("OLDEST_7755", ".ordx", "glob",
+                              "derived: §141 requires mtime ordering plus returning only what fits the cap => what gets cut "
+                              "must be the tail of that order; keeping the oldest file while dropping newer ones violates both"),
+         blocking=False),
+    dict(id="notebook_edit_delete_keeps_neighbors", kind="reject", gate="notebook_edit_cell_isolation",
+         tool="notebook_edit", setup=["/mode yolo"], seed={"nb.ipynb": _NB_JSON},
+         rounds=[[_ALLOW_SPEC, {"name": "read", "args": {"file_path": "nb.ipynb"}}],
+                 [{"name": ["notebook_edit", "notebook-edit"],
+                   "args": {"file_path": "nb.ipynb", "cell_index": 1,
+                            "mode": "delete"}}],
+                 # The assertion is structural (cell count) rather than "CELL1_OLD must not appear": the `read`
+                 #   round added to satisfy the read-before-edit gate pushes the whole notebook (including
+                 #   CELL1_OLD) into mtok, and a "lacks" assertion scans exactly mtok => never satisfiable (that
+                 #   fixture, not the product, would decide the verdict).
+                 #   General rule: a "lacks" assertion is poisoned by any round that echoes file content; assert
+                 #   structure or a sentinel-ised derived value instead.
+                 #   The cell count is assembled in python so the full string never appears in the command text
+                 #   (command echo can reach mtok).
+                 [{"name": "bash",
+                   "command": "python3 -c \"import json;print('NBCELLS' + '_' + "
+                              "str(len(json.load(open('nb.ipynb'))['cells'])))\" && echo NBDEL_DONE_7755"}]],
+         check=chk_mtok_has("NBCELLS_2", "notebook_edit",
+                            "derived: delete must really remove the target cell -- deleting one of three leaves 2; blanking "
+                            "the source but keeping an empty shell (still 3) is not 'the target cell changed as intended'"),
+         blocking=False),
+
+    # Always assemble asserted tokens inside the command: `mtok` contains the literal text of the bash
+    #   command, so a token appearing whole in the command makes the assertion trivially true.
+
+    # Workspace fence (v6§0.1.1 --repo-dir): fixture control -- create a symlink pointing outside the workspace whose target is readable
+    dict(id="symlink_to_outside_target_readable_control", kind="control", tool="bash",
+         setup=["/mode yolo"], seed={},
+         rounds=[[_ALLOW_SPEC,
+                  {"name": "bash",
+                   "command": "printf 'OUTSIDE_ORIG_7731\\n' > /tmp/outside_9931.txt && "
+                              "ln -sf /tmp/outside_9931.txt link_9931.txt && echo SYMCTL_DONE_7755"}],
+                 [{"name": "bash", "command": (
+                     "python3 -c \"import os; p='link_9931.txt'; "
+                     "print('SYM'+'LINK_%d' % os.path.islink(p)); "
+                     "print('SYM'+'REAL_%d' % (os.path.realpath(p)=='/tmp/outside_9931.txt')); "
+                     "print('SYM'+'BYTE_%d' % (open(p,'rb').read()==b'OUTSIDE_ORIG_7731\\n'))\""
+                 )}]],
+         check=chk_fixture_markers(("SYMLINK_1", "SYMREAL_1", "SYMBYTE_1")),
+         blocking=False),
+    # ===== Memory surface x workspace fence (v6§6:389) =====
+    # memory_get accepts absolute paths, i.e. an entry point that reads any file past the fence. Typical causes:
+    #   `os.path.join` drops the prefix on an absolute path, so the argument is used as-is;
+    #   "absolute path that is a file" is explicitly allowed, with ~ expanded first (`~/.ssh/id_rsa` reads too);
+    #   the raw argument is one of the candidate paths tried;
+    #   the workspace root is joined only for relative paths.
+    # A permission layer that fences only mutating actions does not backstop this: memory_get counts as a read.
+    # Not a duplicate of the escape-read cases (those cover read/glob/edit/multi_edit); memory is a separate surface.
+    dict(id="p32_ctl_memory_get_reads_inside_workspace", kind="control",
+         tool="memory_get", setup=["/mode yolo"],
+         seed={"MEMORY.md": "INSIDEMEM" + "_7732\n"},
+         phase1_rounds=[[_ALLOW_SPEC]],
+         mid_slash=["/help"],
+         phase2_rounds=[
+             [{"name": ["memory_get", "memory-get"], "args": {"path": "MEMORY.md"}}],
+             [{"name": "bash", "command": "echo P32A_DONE_7755"}],
+         ],
+         # Load control (§5.2.6): prove the memory_get path works and the content really reaches the wire;
+         # otherwise "the sentinel never entered the request body" below could also just mean the tool never ran.
+         check=chk_memory_get_event("INSIDEMEM_7732")),
+    dict(id="memory_get_abs_path_escapes_workspace", kind="reject",
+         tool="memory_get", gate="p32_ctl_memory_get_reads_inside_workspace",
+         setup=["/mode yolo"], seed={},
+         rounds=[[_ALLOW_SPEC,
+                  {"name": "bash",
+                   "command": ("python3 -c \"open('/tmp/msec_9932.txt','w').write("
+                               "'MEMSECRET' + '_7732' + chr(10))\" && echo P32A_SEEDED_7755")}],
+                 [{"name": ["memory_get", "memory-get"], "args": {"path": "/tmp/msec_9932.txt"}}],
+                 [{"name": "bash", "command": "echo P32A_DONE_7755"}]],
+         check=chk_mtok_lacks("MEMSECRET_7732", "P32A_DONE_7755", "memory_get",
+                              "derived from v6§6:389 (memory = plain text files in the workspace) + the --repo-dir workspace fence: "
+                              "memory_get accepting an absolute path is an entry point for reading any file past the fence")),
+
+    dict(id="read_via_symlink_outside_workspace_bounded", kind="reject",
+         gates=["symlink_to_outside_target_readable_control",
+                "file_symlink_inside_still_readable_control"], tool="read",
+         setup=["/mode yolo"], seed={},
+         rounds=[[_ALLOW_SPEC,
+                  {"name": "bash",
+                   "command": "python3 -c \"open('/tmp/secr_9931.txt','w').write("
+                              "'OUTSECRET' + '_7731' + chr(10))\" && "
+                              "ln -sf /tmp/secr_9931.txt ls_9931.txt && echo RS6_SEEDED_7755"}],
+                 [{"name": "read", "args": {"file_path": "ls_9931.txt"}}],
+                 [{"name": "bash", "command": "echo RS6_DONE_7755"}]],
+         check=chk_mtok_lacks("OUTSECRET_7731", "RS6_DONE_7755", "read",
+                              "derived from the --repo-dir workspace fence: if it covers writes but not reads, outside content still reaches the request body through a link"),
+         blocking=False),
+    # The same reverse control must hold per tool: read / edit / multi_edit may take independent code paths.
+    dict(id="file_symlink_inside_still_readable_control", kind="control", tool="read",
+         setup=["/mode yolo"], seed={"rif_9931.txt": "READ_INSIDE_7731\n"},
+         rounds=[[_ALLOW_SPEC,
+                  {"name": "bash",
+                   "command": "ln -sf rif_9931.txt ril_9931.txt && echo RIF_SEEDED_7755"}],
+                 [{"name": "read", "args": {"file_path": "ril_9931.txt"}}],
+                 [{"name": "bash", "command": "echo RIF_DONE_7755"}]],
+         check=chk_mtok_has("READ_INSIDE_7731", "read",
+                            "reverse control v6§1.1:135: a symlink to a file inside the workspace must stay readable"),
+         blocking=False),
+
+    # ══════════════════════════════════════════════════════════════════════════════
+    # Observation-channel discipline for the grep family
+    #
+    # v6§1.1:140 defines three output_modes and the default is `files_with_matches`, i.e. paths only. So:
+    #   - to assert "it found something", assert the matching file PATH (mode independent, most robust)
+    #   - to assert matched line content, pass `output_mode="content"` explicitly
+    # Asserting line content under the default mode would blame a correct product for "cannot search".
+    #
+    # Two more traps:
+    #   - do not write `[E]`-style "broken token" patterns: that is a regex character class and changes semantics.
+    #     Keep the token out of the command text by assembling it in the bash command, not by bracketing the pattern.
+    #   - on zero hits the product echoes the pattern back ("no matches for X"), so asserting a token equal to the
+    #     pattern makes a broken search PASS. The asserted token must differ from the pattern.
+    # ══════════════════════════════════════════════════════════════════════════════
+    dict(id="grep_default_mode_returns_path_control", kind="control", tool="grep",
+         setup=["/mode yolo"], seed={"f9_9931.txt": "F9NEEDLE_7755 ctxf9_9931\n"},
+         rounds=[[_ALLOW_SPEC, {"name": "grep", "args": {
+             "pattern": "F9NEEDLE_7755", "path": ".",
+             "output_mode": "files_with_matches"}}],
+                 [{"name": "bash", "command": "echo F9C_DONE_7755"}]],
+         check=chk_grep_paths_only(("f9_9931.txt",), ("ctxf9_9931",)),
+         blocking=False),
+    dict(id="grep_head_limit_zero_not_unlimited", kind="reject",
+         gate="grep_default_mode_returns_path_control", tool="grep",
+         setup=["/mode yolo"], seed={"f9_9931.txt": "F9NEEDLE_7755 ctxf9_9931\n"},
+         rounds=[[_ALLOW_SPEC, {"name": "grep", "args": {"pattern": "F9NEEDLE_7755", "path": ".",
+                                                         "head_limit": 0}}],
+                 [{"name": "bash", "command": "echo HZ9_DONE_7755"}]],
+         # Assert the matching PATH is absent: mode independent, and a different string from the pattern, which dodges the zero-hit echo channel
+         check=chk_mtok_lacks("f9_9931", "HZ9_DONE_7755", "grep",
+                              "derived from v6§1.1:140: head_limit=0 can only mean 'no results' or a clean error. "
+                              "Treating 0 as falsy and falling back to unlimited discards the argument the model gave -- all builds fail"),
+         blocking=False),
+
+
+    # ── Anchor v6§1.1:135 ("no infinite loop"): reading a character device must be bounded ──
+    # A correct implementation refuses device paths before reading ("would hang the process").
+    # The fixture uses /dev/urandom rather than /dev/zero: an unbounded /dev/zero read runs at 1-2 GB/s and would
+    #   exhaust memory well before a 60s timeout, while /dev/urandom (~160 MB/s) has the same discriminating power.
+    # Hashing the whole file for bookkeeping (`while True: fh.read(262144)`) never ends on a character device, so
+    #   it spins before any bounded content sniff runs.
+    dict(id="read_regular_file_control", kind="control", tool="read",
+         setup=["/mode yolo"], seed={"reg_9941.txt": "REGULAR_7731\n"},
+         rounds=[[_ALLOW_SPEC],
+                 [{"name": "read", "args": {"file_path": "reg_9941.txt"}}],
+                 [_echo_assembled("DEVREAD", "_DONE_7755")]],
+         check=chk_mtok_has("REGULAR_7731", "read",
+                            "channel control: a regular file must be readable, else the timeout in the next row has no attribution"),
+         blocking=False),
+    dict(id="read_char_device_bounded", kind="reject", tool="read",
+         gate="read_regular_file_control",
+         setup=["/mode yolo"], seed={},
+         rounds=[[_ALLOW_SPEC],
+                 [{"name": "read", "args": {"file_path": "/dev/urandom"}}],
+                 [_echo_assembled("DEVREAD", "_DONE_7755")]],
+         check=chk_mtok_has("DEVREAD_DONE_7755", "read",
+                            "v6§1.1:135 (no infinite loop): reading a character device must be bounded. "
+                            "An unbounded read is cut by the timeout before the tail runs, so the tail sentinel never appears"),
+         blocking=False),
+]
+
+for _c in CASES:
+    _c.setdefault("deny", [])
+    _c.setdefault("allow", _ALLOW)
+
+
+def _purge_tmp_fixtures() -> None:
+    """Remove what fixtures leave under `/tmp`, so verdicts do not depend on execution order.
+
+    The "outside the workspace" fixture family writes fixed `/tmp` paths (`/tmp/outside_9931.txt`
+    and friends) that are shared across builds. A leftover from a previous build would revive a
+    fixture the current build never managed to create (e.g. its bash cannot write the /tmp the probe
+    later reads), which must be judged "fixture could not be built": being rescued by stale state is
+    worse than NA, it is fake evidence for every row gated on that control. Only the fixture-specific
+    `*_9931*` / `*_9932*` names are purged, so there are no side effects.
+    """
+    import glob as _glob
+    import shutil as _shutil
+    for pat in ("/tmp/*_9931*", "/tmp/*_9932*"):
+        for path in _glob.glob(pat):
+            try:
+                if os.path.isdir(path) and not os.path.islink(path):
+                    _shutil.rmtree(path, ignore_errors=True)
+                else:
+                    os.remove(path)
+            except OSError:
+                pass
+
+
+def _extension_marker_command(path: Path, marker: str) -> str:
+    """Return a shell command whose exact marker is observed outside the workspace."""
+    return f"printf '{marker}\\n' >> '{path}'"
+
+
+def _prepare_extension_harness(root: Path, repo: Path, mode: str) -> dict:
+    """Materialize inward or outward definition symlinks before Session construction."""
+    if mode not in ("inside", "outside"):
+        raise ValueError(f"unknown extension harness mode: {mode}")
+    inside = repo / "extension-definition-sources"
+    outside = root / "external-definition-sources"
+    markers = root / "extension-markers"
+    home = root / "home"
+    for directory in (inside, outside, markers, home):
+        directory.mkdir(parents=True, exist_ok=True)
+    source_root = inside if mode == "inside" else outside
+
+    marker_paths = {
+        face: markers / f"{face}.marker"
+        for face in ("commands", "hooks", "plugins")
+    }
+    command_exec = _extension_marker_command(
+        marker_paths["commands"], _EXTENSION_EXEC_MARKERS["commands"]
+    )
+    hook_exec = _extension_marker_command(
+        marker_paths["hooks"], _EXTENSION_EXEC_MARKERS["hooks"]
+    )
+    plugin_exec = _extension_marker_command(
+        marker_paths["plugins"], _EXTENSION_EXEC_MARKERS["plugins"]
+    )
+    event_entries = [{
+        "matcher": "*",
+        "match": "*",
+        "command": hook_exec,
+    }]
+    definitions = {
+        "command.md": (
+            "---\ndescription: symlink definition probe\n---\n"
+            f"!{{{command_exec}}}\n"
+            f"Carry the exact marker {_EXTENSION_WIRE_MARKERS['commands']} into this turn.\n"
+        ),
+        "SKILL.md": (
+            "---\nname: extsymskill\ndescription: symlink definition probe\n"
+            "triggers: [extsymskill]\n---\n"
+            f"Carry the exact marker {_EXTENSION_WIRE_MARKERS['skills']} into this turn.\n"
+        ),
+        "hooks.json": json.dumps({
+            "hooks": {
+                "beforeShellExecution": event_entries,
+                "beforeToolUse": event_entries,
+            },
+            "beforeShellExecution": event_entries,
+            "beforeToolUse": event_entries,
+        }),
+        "plugin.json": json.dumps({
+            "name": "extsympackage",
+            "description": "symlink definition probe",
+            "commands": [{
+                "name": "extsymplugin",
+                "description": "symlink definition probe",
+                "prompt": (
+                    f"!{{{plugin_exec}}}\n"
+                    f"Carry the exact marker {_EXTENSION_WIRE_MARKERS['plugins']} into this turn."
+                ),
+                "body": (
+                    f"!{{{plugin_exec}}}\n"
+                    f"Carry the exact marker {_EXTENSION_WIRE_MARKERS['plugins']} into this turn."
+                ),
+            }],
+            "hooks": {
+                "beforeShellExecution": [{
+                    "matcher": "*",
+                    "command": plugin_exec,
+                }],
+            },
+        }),
+    }
+    targets = {}
+    for name, text in definitions.items():
+        target = source_root / name
+        target.write_text(text, encoding="utf-8")
+        targets[name] = target
+
+    links = {
+        repo / "commands" / "extsymcommand.md": targets["command.md"],
+        repo / "skills" / "extsymskill" / "SKILL.md": targets["SKILL.md"],
+        repo / "hooks.json": targets["hooks.json"],
+        repo / "plugins" / "extsympackage" / "plugin.json": targets["plugin.json"],
+    }
+    for link, target in links.items():
+        link.parent.mkdir(parents=True, exist_ok=True)
+        link_target = (
+            os.path.relpath(target, link.parent)
+            if mode == "inside"
+            else str(target)
+        )
+        link.symlink_to(link_target)
+
+    repo_real = repo.resolve(strict=True)
+    expected_inside = mode == "inside"
+    shape = {}
+    for link, target in links.items():
+        target_real = target.resolve(strict=True)
+        try:
+            contained = os.path.commonpath((str(repo_real), str(target_real))) == str(repo_real)
+        except ValueError:
+            contained = False
+        shape[str(link.relative_to(repo))] = (
+            link.is_symlink()
+            and link.resolve(strict=True) == target_real
+            and contained == expected_inside
+        )
+    return {
+        "fixture_ok": bool(shape) and all(shape.values()),
+        "shape": shape,
+        "home": home,
+        "marker_paths": marker_paths,
+    }
+
+
+def _exact_marker_count(path: Path, marker: str) -> int:
+    try:
+        return sum(
+            line == marker
+            for line in path.read_text(encoding="utf-8").splitlines()
+        )
+    except OSError:
+        return 0
+
+
+def _parse_fileio_child_result(out: str) -> dict | None:
+    result = None
+    for line in out.splitlines():
+        if line.startswith(PS.RESULT_TAG):
+            try:
+                result = json.loads(line[len(PS.RESULT_TAG):])
+            except (TypeError, ValueError, json.JSONDecodeError):
+                result = None
+    return result if isinstance(result, dict) else None
+
+
+def _run_extension_child(child_code: str, cfg: dict, mode: str,
+                         timeout: float = 60.0):
+    """Run one real extension-discovery counterfactual in a case-local repo."""
+    last = (None, "TIMEOUT")
+    for _attempt in range(2):
+        root = Path(tempfile.mkdtemp(prefix="fileio_ext_"))
+        repo = root / "repo"
+        repo.mkdir()
+        try:
+            try:
+                fixture = _prepare_extension_harness(root, repo, mode)
+            except (OSError, ValueError) as exc:
+                return {
+                    "_extension_fixture_ok": False,
+                    "_extension_fixture_error":
+                        f"EXTENSION_FIXTURE_{type(exc).__name__}",
+                }, ""
+            start = len(cfg["requests"])
+            cfg["rounds_base"] = start
+            env = dict(os.environ)
+            env["HOME"] = str(fixture["home"])
+            env["MSWEA_SILENT_STARTUP"] = "1"
+            try:
+                proc = subprocess.Popen(
+                    [sys.executable, "-c", child_code],
+                    cwd=repo,
+                    env=env,
+                    stdin=subprocess.DEVNULL,
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE,
+                    text=True,
+                    start_new_session=True,
+                    close_fds=True,
+                )
+                out, err = proc.communicate(timeout=timeout)
+            except subprocess.TimeoutExpired:
+                PS._terminate_process_group(proc)
+                last = (None, "TIMEOUT")
+                continue
+            except OSError as exc:
+                return None, f"EXTENSION_CHILD_START_{type(exc).__name__}: {exc}"
+
+            res = _parse_fileio_child_result(out)
+            if isinstance(res, dict):
+                requests = list(cfg["requests"][start:])
+                wire_seen = {
+                    face: any(
+                        bool((row.get("probes") or {}).get(marker))
+                        for row in requests
+                    )
+                    for face, marker in _EXTENSION_WIRE_MARKERS.items()
+                }
+                exec_counts = {
+                    face: _exact_marker_count(
+                        fixture["marker_paths"][face],
+                        _EXTENSION_EXEC_MARKERS[face],
+                    )
+                    for face in ("commands", "hooks", "plugins")
+                }
+                res["_extension_seen"] = {
+                    "commands":
+                        wire_seen["commands"] or exec_counts["commands"] > 0,
+                    "skills": wire_seen["skills"],
+                    "hooks": exec_counts["hooks"] > 0,
+                    "plugins":
+                        wire_seen["plugins"] or exec_counts["plugins"] > 0,
+                }
+                res["_extension_wire_seen"] = wire_seen
+                res["_extension_exec_marker_counts"] = exec_counts
+                res["_extension_fixture_ok"] = fixture["fixture_ok"]
+                res["_extension_fixture_shape"] = fixture["shape"]
+                res["_extension_request_count"] = len(requests)
+                res["_stdout"] = out[-6000:]
+            return res, err
+        finally:
+            shutil.rmtree(root, ignore_errors=True)
+    return last
+
+
+def _run_extension_pair(child_code: str, cfg: dict):
+    """Run inward and outward definition fixtures with otherwise identical inputs."""
+    inside, inside_err = _run_extension_child(child_code, cfg, "inside")
+    outside, outside_err = _run_extension_child(child_code, cfg, "outside")
+    if not isinstance(inside, dict) or not isinstance(outside, dict):
+        return None, (
+            f"inside={inside_err[-240:]!r} outside={outside_err[-240:]!r}"
+        )
+    combined = {
+        "_extension_inside_fixture_ok": inside.get("_extension_fixture_ok"),
+        "_extension_outside_fixture_ok": outside.get("_extension_fixture_ok"),
+        "_extension_inside_fixture_error": inside.get("_extension_fixture_error"),
+        "_extension_outside_fixture_error": outside.get("_extension_fixture_error"),
+        "_extension_inside_seen": inside.get("_extension_seen") or {},
+        "_extension_outside_seen": outside.get("_extension_seen") or {},
+        "_extension_inside_live": inside.get("live"),
+        "_extension_outside_live": outside.get("live"),
+        "_extension_inside_request_count": inside.get("_extension_request_count"),
+        "_extension_outside_request_count": outside.get("_extension_request_count"),
+        "live": inside.get("live") is True and outside.get("live") is True,
+        "_stdout":
+            (inside.get("_stdout") or "")[-2500:]
+            + (outside.get("_stdout") or "")[-2500:],
+    }
+    return combined, f"inside={inside_err[-200:]} outside={outside_err[-200:]}"
+
+
+def _run_one(agent_dir: Path, case: dict) -> dict:
+    # phased: phase1_rounds -> mid_slash(/compact, /undo, /redo) -> phase2_rounds; a __finish__ round marks the phase boundary.
+    mid_slash = case.get("mid_slash")
+    if case.get("phase1_rounds") is not None:
+        rounds = list(case["phase1_rounds"]) + [[{"name": "__finish__"}]] + list(case.get("phase2_rounds") or [])
+    else:
+        rounds = case["rounds"]
+    cfg = MG.new_cfg(mode="seq_probe", rounds=rounds)
+    if case.get("extension_harness"):
+        cfg["probe_tokens"] = list(_EXTENSION_WIRE_MARKERS.values())
+    srv = MG.make_server(cfg, 0)
+    port = srv.server_address[1]
+    threading.Thread(target=srv.serve_forever, daemon=True).start()
+    try:
+        code = PS._child_code(str((agent_dir / "src").resolve()), port, case["deny"], case["setup"], case["seed"],
+                              git_baseline=None, mid_slash=mid_slash,
+                              enable_autocommit=False, mid_slash2=None)
+        if case.get("extension_harness") == "inside":
+            res, err = _run_extension_child(code, cfg, "inside")
+        elif case.get("extension_harness") == "paired":
+            res, err = _run_extension_pair(code, cfg)
+        else:
+            res, err = PS._run_child(agent_dir, code)
+        if isinstance(res, dict):
+            _adv = set()
+            for _rq in cfg["requests"]:
+                for _tn in (_rq.get("tool_names") or []):
+                    _adv.add(_tn)
+            res["_adv"] = sorted(_adv)
+            # wire hook: expose the fact "some request body carried an empty tool_result" to the checker.
+            # seq_probe checkers only receive reqs=len(requests), not per-request wire_facts;
+            # mock_gateway.wire_facts already records `empty_tool_result` (role=tool with blank content).
+            res["_empty_tool_result"] = any(r.get("empty_tool_result") for r in cfg["requests"])
+            latest_results = next(
+                (
+                    r.get("tool_result_texts") or []
+                    for r in reversed(cfg["requests"])
+                    if r.get("tool_result_texts")
+                ),
+                [],
+            )
+            res["_round_target_tool_results"] = [
+                texts[-1]
+                for request in cfg["requests"]
+                if len(texts := (request.get("tool_result_texts") or [])) >= 2
+            ]
+            # Every fileio round orders liveness first and the declared
+            # target call last. Require both results so dropping the target
+            # cannot be compensated by the liveness result.
+            res["_target_tool_result_seen"] = len(latest_results) >= 2
+            res["_target_tool_result"] = latest_results[-1] if latest_results else None
+            # wire hook (mode/role switch duplicating system): expose "a request had a non-leading
+            # system" plus "a leading system was ever seen", so the checker can tell whether
+            # set_mode/set_role rebuilt the system prompt into a duplicate or non-leading slot.
+            res["_nonleading_system"] = any(r.get("nonleading_system") for r in cfg["requests"])
+            res["_has_leading_system"] = any(
+                (r.get("msg_roles") or [])[:1] == ["system"] for r in cfg["requests"])
+            # wire hook (does pre-send sanitising after /compact repair orphan tool_results):
+            # expose "a request carried an orphan tool_result" plus "role=tool was ever seen"
+            # (proof a real tool-call group ran, so compact had a group to cut).
+            res["_orphan_tool_result"] = any(r.get("orphan_tool_result") for r in cfg["requests"])
+            res["_had_tool_role"] = any("tool" in (r.get("msg_roles") or []) for r in cfg["requests"])
+            # wire hook (parallel tool-group x /compact): expose "a request had a dangling tool_use" --
+            # an assistant.tool_calls id with no matching role=tool later in the same body (inverse of
+            # orphan). Blind-cutting a parallel group while dedupe reclaims only orphan results leaves the
+            # tool_call id behind -> dangling tool_use -> hard 400 from a strict gateway.
+            res["_dangling_tool_use"] = any(r.get("dangling_tool_use") for r in cfg["requests"])
+        ok, why = case["check"](res, len(cfg["requests"]), err)
+    except Exception as e:  # noqa: BLE001
+        ok, why = False, f"runner error: {e!r}"
+    finally:
+        srv.shutdown()
+        srv.server_close()
+    # Rows are blocking unless they declare `reject_soft`, which makes them
+    # zero-weight controls.
+    blocking = case.get("kind") != "reject_soft"
+    if case.get("extension_harness") \
+            or None:
+        blocking = case.get("blocking", blocking)
+    return {
+        "id": case["id"],
+        "ok": ok,
+        "blocking": blocking,
+        "why": why,
+    }
+
+
+def _selected_cases(cases: list) -> list:
+    """Run only the ids listed in `D2A_ONLY_IDS` (comma separated); unset = full suite, behaviour bit-identical.
+
+    reject cases here are opened by the golden standard / their own `gate` positive control
+    (control not run = path not established = verdict downgraded to inconclusive), so filtering
+    must pull the gate dependencies in as well; otherwise "run just this case" makes it
+    permanently NA for harness reasons rather than implementation ones.
+    The `D2A_ONLY_ACTIVE` line marks for the merge tooling that a filtered run is not a full score.
+    """
+    only = {s.strip() for s in (os.environ.get("D2A_ONLY_IDS") or "").split(",") if s.strip()}
+    if not only:
+        return list(cases)
+    picked = SC.dependency_closure(cases, only)
+    need = {c["id"] for c in picked}
+    print(f"D2A_ONLY_ACTIVE={len(picked)}/{len(cases)} ids={sorted(only)[:12]} "
+          f"gates+={sorted(need - only)[:8]}", flush=True)
+    return picked
+
+
+def _uses_shared_tmp(case: dict) -> bool:
+    """Whether the case touches the cross-thread shared `/tmp` fixture namespace."""
+    return "/tmp" in repr(case)
+
+
+def run_smoke(agent_dir: Path) -> list:
+    from concurrent.futures import ThreadPoolExecutor
+    import os
+    _w = max(1, int(os.environ.get("D2A_FILEIO_WORKERS", "8") or "8"))
+    cases = _selected_cases(CASES)
+    results = {}
+    # `/tmp` fixtures use a set of fixed paths. Purging them at the start of every concurrent
+    # `_run_one` would let case B delete case A's files mid-read, so cases without /tmp run in
+    # parallel and the few /tmp ones run purge-then-execute one at a time after the pool drains.
+    tmp_cases = [c for c in cases if _uses_shared_tmp(c)]
+    parallel_cases = [c for c in cases if c not in tmp_cases]
+    with ThreadPoolExecutor(max_workers=_w) as ex:
+        futs = {ex.submit(_run_one, agent_dir, c): c["id"] for c in parallel_cases}
+        for fut in futs:
+            r = fut.result()
+            results[r["id"]] = r
+    for c in tmp_cases:
+        _purge_tmp_fixtures()
+        r = _run_one(agent_dir, c)
+        results[r["id"]] = r
+    return SC.apply_gates(cases, results.values())
+
+
+def main():
+    import argparse
+    ap = argparse.ArgumentParser()
+    ap.add_argument("agent_dir")
+    ap.add_argument("--emit-json", action="store_true")
+    args = ap.parse_args()
+    agent_dir = Path(args.agent_dir)
+    if (agent_dir / "agent").is_dir():
+        agent_dir = agent_dir / "agent"
+    # `yuyao/` under either `src/` or the project root counts as found: the spec mandates no
+    # directory layout, so a flat layout is equally compliant.
+    if not any((agent_dir / c / "yuyao").is_dir() for c in ("src", ".")) \
+            and not (agent_dir / "src").is_dir():
+        print(f"[fileio_smoke] agent src not found: {agent_dir}", file=sys.stderr)
+        if args.emit_json:
+            print('FILEIO_RESULTS=[{"id": "_fileio_harness", "ok": false, "blocking": true, "why": "no agent src"}]')
+            print("FILEIO_SMOKE_FAIL")
+        sys.exit(2)
+    print(f"[fileio_smoke] agent: {agent_dir}  {len(CASES)} cases\n")
+    results = run_smoke(agent_dir)
+    npass = sum(r["ok"] for r in results)
+    for r in results:
+        print(f"[{'PASS' if r['ok'] else 'FAIL'}] {r['id']:38s} {r['why']}")
+    blocking_ok = all(r["ok"] for r in results if r.get("blocking"))
+    if args.emit_json:
+        print("FILEIO_RESULTS=" + json.dumps(results, ensure_ascii=False))
+        print("FILEIO_SMOKE_OK" if blocking_ok else "FILEIO_SMOKE_FAIL")
+    print(f"\n== read/write tool integrity deterministic smoke: {npass}/{len(results)} passed ==")
+    sys.exit(0 if npass == len(results) else 1)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/code/src/stage1/smoke/headless_smoke.py b/code/src/stage1/smoke/headless_smoke.py
new file mode 100644
index 0000000000000000000000000000000000000000..845c8528cf740fab6028d08c71e91e53576345ed
--- /dev/null
+++ b/code/src/stage1/smoke/headless_smoke.py
@@ -0,0 +1,1223 @@
+"""Headless `-p`/`--print` text/JSON output-purity determinism smoke (zero real-model budget).
+
+Why it exists: spec §0.1.1/§8.3/§9 pin down headless mode (`yuyao -p "<task>" --output-format text`) -
+stdout must contain ONLY the human-readable reply, never internal XML/function-call tags, phase events,
+kernel banners, or log lines that belong on stderr; `--output-format json` must emit a SINGLE standard
+JSON document (containing the reply) with no non-JSON noise. This is the hard contract for user scripts
+and CI that treat the agent as a pipe.
+
+Why it is its own layer (not part of mock_cases): mock_cases drives the EVAL-HARNESS entry
+`entry.py --task-file --out-dir`, whose deliverable is status.json plus the trajectory and whose stdout
+may legitimately be empty; the purity contract applies only to the USER CLI path `yuyao -p`. Judging
+stdout purity on the entry.py path would produce false positives on compliant builds, so this layer
+drives the real `-p` CLI.
+
+Mechanism: start a local mock gateway (`fixed_reply` returns plain text with a sentinel and no tool
+calls) -> run `yuyao -p "<task>" --output-format text|json` (model endpoint injected via `D2A_MODEL_*`)
+-> capture STDOUT -> judge purity/validity.
+N/A gate: a build with no `-p`/`--print` text CLI (neither the `yuyao` console script nor `python -m
+yuyao` accepts -p) -> inconclusive, skipped.
+Zero false positives: the control sentinel MUST appear in stdout (a missing sentinel = a no-op or
+scrubbed vacuous pass; leaked internal tags = nothing was really parsed / rendering was not clean = FAIL).
+
+Usage: python headless_smoke.py <agent_dir> [--emit-json] | --selftest
+"""
+
+from __future__ import annotations
+import hashlib
+import json
+import os
+import re
+import shutil
+import subprocess
+import sys
+import tempfile
+import threading
+from pathlib import Path
+
+HERE = Path(__file__).resolve().parent
+sys.path.insert(0, str(HERE))
+import mock_gateway as MG
+import smoke_contract as SC
+
+RESULT_TAG = "HEADLESS_RESULTS="
+
+
+BAD = [
+    "<function_calls>",
+    "<tool_code>",
+    "<invoke",
+    "<pre_dispatch_explanation>",
+    "<response>",
+    "</response>",
+    "TurnBegin",
+    "StepBegin",
+    "[ERROR]",
+    "[INFO]",
+    "Loaded cached credentials",
+    "mini-swe-agent version",
+    "Traceback (most recent call last)",
+    "DEBUG:",
+]
+
+
+def _discover_cli(agent_dir: Path, *, require_print: bool = True):
+    """Discover the artifact's own CLI entry.
+
+    ``require_print=True`` requires the entry to support ``-p/--print``, for headless session cases;
+    ``False`` only requires the bare entry's help to succeed, for ``memory/config/...`` management
+    subcommand cases. The two capabilities must be discovered independently - a build without ``-p``
+    must not swallow the bare subcommand surface.
+    """
+    env = dict(os.environ)
+    src = os.pathsep.join([str((agent_dir / "src").resolve()), str(agent_dir.resolve())])
+    env["PYTHONPATH"] = src + (os.pathsep + env["PYTHONPATH"] if env.get("PYTHONPATH") else "")
+    env["MSWEA_SILENT_STARTUP"] = "1"
+    env["LITELLM_LOCAL_MODEL_COST_MAP"] = "True"
+    env["MSWEA_COST_TRACKING"] = "ignore_errors"
+    cands = [[sys.executable, "-m", "yuyao"], [sys.executable, "-m", "yuyao.cli"], ["yuyao"]]
+    for c in cands:
+        for help_flag in ("--help", "-h"):
+            try:
+                r = subprocess.run(
+                    c + [help_flag], cwd=str(agent_dir), env=env, capture_output=True, text=True, timeout=40
+                )
+            except Exception:
+                continue
+            help_txt = (r.stdout or "") + (r.stderr or "")
+            has_print = re.search("(?<![\\w-])(?:-p|--print)(?=[\\s,=]|$)", help_txt) is not None
+            help_complete = (
+                re.search("(?im)^\\s*(usage|用法)[:：]", help_txt) is not None and len(help_txt) > 200
+            )
+            if (has_print or not require_print) and (r.returncode == 0 or help_complete):
+                return (c, env)
+    return (None, env)
+
+
+def _json_loads_strict(text):
+    """Standard JSON: reject the NaN/Infinity that Python's json tolerates by default."""
+
+    def _bad_constant(value):
+        raise ValueError(f"non-standard JSON constant: {value}")
+
+    return json.loads(text, parse_constant=_bad_constant)
+
+
+def chk_json_pure(sentinel):
+
+    def _f(res, reqs=None):
+        if not res.get("std"):
+            return (True, "inconclusive: build has no -p/--print CLI -> skipped")
+        if res.get("timed_out"):
+            return (
+                False,
+                "headless -p --output-format json did not terminate within the limit (probable hang)",
+            )
+        out = (res.get("stdout") or "").strip()
+        try:
+            obj = _json_loads_strict(out)
+            bad_json = False
+        except Exception:
+            obj = None
+            bad_json = True
+        leaks = [b for b in BAD if b in out]
+        result_field = ""
+        status_field = ""
+        if isinstance(obj, dict):
+            result_field = str(obj.get("result", ""))
+            status_field = str(obj.get("exit_status", ""))
+        has = sentinel in result_field or (
+            isinstance(obj, dict) and sentinel in json.dumps(obj, ensure_ascii=False)
+        )
+        ok = obj is not None and (not bad_json) and has and (not leaks) and (res.get("rc") == 0)
+        return (
+            ok,
+            f"whole text is one JSON={obj is not None and (not bad_json)} result contains sentinel={has} exit={status_field!r} leaks={leaks} rc={res.get('rc')} (-p json must be a single valid JSON containing the result sentinel, with no noise)",
+        )
+
+    return _f
+
+
+def chk_json_error_pure(res, reqs=None):
+    """On a deterministic model error in JSON output mode, stdout must still be a single error JSON and the process rc=1; never an empty stdout, interleaved logs, or a fake success."""
+    if not res.get("std"):
+        return (True, "inconclusive: build has no -p/--print CLI -> skipped")
+    if res.get("timed_out"):
+        return (False, "the headless JSON error branch did not terminate within the limit")
+    n = len(reqs or [])
+    out = (res.get("stdout") or "").strip()
+    try:
+        _json_loads_strict(out)
+        one_json = True
+    except Exception:
+        one_json = False
+    ok = n >= 1 and one_json and (res.get("rc") == 1)
+    return (
+        ok,
+        f"401 really triggered={n >= 1} (reqs={n}) whole stdout is standard JSON={one_json} rc={res.get('rc')} (a model error in JSON mode must give structured output + rc1; the spec pins neither the retry count, nor the error JSON fields, nor stderr diagnostics)",
+    )
+
+
+def chk_probe_present(what):
+    """Generic wire evidence: with cfg.probe_token=marker, any request with has_probe=True means the content reached the wire. Self-gated on reqs>=1."""
+
+    def _f(res, reqs=None):
+        if not res.get("std"):
+            return (True, "inconclusive: build has no -p/--print CLI -> skipped")
+        if res.get("timed_out"):
+            return (False, f"{what} did not terminate within the limit")
+        n = len(reqs or [])
+        present = any((rec.get("has_probe") for rec in reqs or [] if isinstance(rec, dict)))
+        return (
+            n >= 1 and present,
+            f"reqs={n} {what} in request body={present} (must be wired into the prompt sent to the model; absent from every request = discarded)",
+        )
+
+    return _f
+
+
+def chk_probe_absent(what):
+    """The inverse of `chk_probe_present`: this content must NOT appear in any request body.
+
+    Self-gating mirrors the positive version (no -p CLI / zero requests => inconclusive). Without it,
+    "the sentinel did not appear" would also count "no request was ever sent" as a pass - the classic
+    vacuous pass.
+    Used for inverse controls: proving content enters the context because it was REFERENCED, not
+    because the product reads any file name it sees.
+    """
+
+    def _f(res, reqs=None):
+        if not res.get("std"):
+            return (True, "inconclusive: build has no -p/--print CLI -> skipped")
+        n = len(reqs or [])
+        if n < 1:
+            return (True, "inconclusive: not a single model request was sent -> skipped")
+        present = any((rec.get("has_probe") for rec in reqs or [] if isinstance(rec, dict)))
+        return (not present, f"reqs={n} {what} in request body={present} (must not enter the request body)")
+
+    return _f
+_MATRIX_REPLY = "MATRIX_EXACT_REPLY_6047"
+_MATRIX_REPLY_BYTES = (_MATRIX_REPLY + "\n").encode()
+_MATRIX_FORMAL_ROUNDS = [
+    [
+        {
+            "name": ["bash", "shell", "execute"],
+            "args": {"command": "printf 'MATRIX_EFFECT_3719\\n' > matrix_effect_3719.txt"},
+        }
+    ]
+]
+_MATRIX_REQUIRED_FLAGS = (
+    ("task-file", "--task-file"),
+    ("repo-dir", "--repo-dir"),
+    ("model-base-url", "--model-base-url"),
+    ("model-name", "--model-name"),
+    ("model-api-key", "--model-api-key"),
+    ("budget-file", "--budget-file"),
+    ("out-dir", "--out-dir"),
+)
+
+
+class _MatrixEffectHandler(MG.Handler):
+    """Give the one-tool formal control a unique deterministic final answer."""
+
+    def _send(self, status: int, body: dict):
+        cfg = getattr(self.server, "cfg", {})
+        if cfg.get("matrix_effect") and status == 200 and isinstance(body, dict):
+            body = json.loads(json.dumps(body))
+            choices = body.get("choices")
+            message = (
+                choices[0].get("message")
+                if isinstance(choices, list) and choices and isinstance(choices[0], dict)
+                else None
+            )
+            if isinstance(message, dict) and message.get("content") == "done":
+                message["content"] = _MATRIX_REPLY
+        return super()._send(status, body)
+
+    def _send_sse(self, model: str, content: str):
+        cfg = getattr(self.server, "cfg", {})
+        if cfg.get("matrix_effect") and content == "done":
+            content = _MATRIX_REPLY
+        return super()._send_sse(model, content)
+
+
+_CONTRACT_SUCCESS_STATUSES = frozenset({"Submitted", "LimitsExceeded"})
+_CONTRACT_ASCII_TEXT = "READY-ASCII"
+_CONTRACT_BUDGET_VALID = (
+    {"label": "valid-zero", "budget": {"max_steps": 2, "max_tokens": 0, "max_wall_seconds": 30}},
+    {"label": "valid-positive", "budget": {"max_steps": 97, "max_tokens": 64, "max_wall_seconds": 30}},
+)
+_CONTRACT_BUDGET_INVALID = (
+    {"label": "invalid-boolean", "budget": {"max_steps": True, "max_tokens": 0, "max_wall_seconds": 30}},
+    {"label": "invalid-string", "budget": {"max_steps": "2", "max_tokens": 0, "max_wall_seconds": 30}},
+    {"label": "invalid-float", "budget": {"max_steps": 2.5, "max_tokens": 0, "max_wall_seconds": 30}},
+    {"label": "invalid-negative", "budget": {"max_steps": -1, "max_tokens": 0, "max_wall_seconds": 30}},
+)
+
+
+def _contract_verdict(status: str, why: str):
+    return (status in {"pass", "na"}, why, status)
+
+
+def _contract_rows(res: dict, expected: tuple[str, ...]):
+    error = res.get("formal_error")
+    rows = tuple(res.get("formal_rows") or ())
+    if error:
+        return (None, f"formal headless driver error: {error}")
+    labels = tuple((row.get("label") for row in rows))
+    if labels != expected:
+        return (None, f"formal matrix incomplete: labels={labels!r} expected={expected!r}")
+    for row in rows:
+        if row.get("start_error"):
+            return (None, f"{row['label']}: process/setup error={row['start_error']}")
+        if row.get("timed_out"):
+            return (None, f"{row['label']}: process timeout")
+        if not row.get("cleanup_complete"):
+            return (None, f"{row['label']}: workspace cleanup incomplete")
+        if type(row.get("request_count")) is not int:
+            return (None, f"{row['label']}: model request count unavailable")
+        if not isinstance(row.get("stdout"), bytes) or not isinstance(row.get("stderr"), bytes):
+            return (None, f"{row['label']}: raw byte capture unavailable")
+    return (rows, "")
+
+
+def _contract_status_name(row: dict) -> str | None:
+    status = row.get("status_value")
+    if isinstance(status, dict) and isinstance(status.get("exit_status"), str):
+        return status["exit_status"]
+    return None
+
+
+def _contract_statuses_complete(rows) -> bool:
+    return all((not row.get("status_error") and _contract_status_name(row) is not None for row in rows))
+
+
+def _contract_success(row: dict) -> bool:
+    return row.get("rc") == 0 and _contract_status_name(row) in _CONTRACT_SUCCESS_STATUSES
+
+
+def chk_budget_type_domain_control(res, reqs=None):
+    expected = ("valid-zero", "valid-positive")
+    rows, error = _contract_rows(res, expected)
+    if rows is None:
+        return _contract_verdict("error", error)
+    if not _contract_statuses_complete(rows):
+        return _contract_verdict("error", "valid budget rc/status channel incomplete")
+    facts = {row["label"]: _contract_success(row) and row["request_count"] == 1 for row in rows}
+    ok = all(facts.values())
+    return _contract_verdict(
+        "pass" if ok else "fail",
+        f"zero/positive integer controls={facts} requests={[row['request_count'] for row in rows]}",
+    )
+
+
+def chk_budget_type_domain(res, reqs=None):
+    expected = (
+        "valid-zero",
+        "valid-positive",
+        "invalid-boolean",
+        "invalid-string",
+        "invalid-float",
+        "invalid-negative",
+    )
+    rows, error = _contract_rows(res, expected)
+    if rows is None:
+        return _contract_verdict("error", error)
+    if not _contract_statuses_complete(rows):
+        return _contract_verdict("error", "budget matrix rc/status channel incomplete")
+    valid = rows[:2]
+    invalid = rows[2:]
+    valid_ok = all((_contract_success(row) and row["request_count"] == 1 for row in valid))
+    invalid_ok = all(
+        (
+            row.get("rc") not in (None, 0)
+            and _contract_status_name(row) not in _CONTRACT_SUCCESS_STATUSES
+            and (row["request_count"] == 0)
+            for row in invalid
+        )
+    )
+    ok = valid_ok and invalid_ok
+    return _contract_verdict(
+        "pass" if ok else "fail",
+        f"valid integers accepted={valid_ok} invalid type/domain rejected pre-model={invalid_ok} rc={[row.get('rc') for row in rows]} requests={[row['request_count'] for row in rows]}",
+    )
+
+
+def _matrix_status_token(row: dict) -> str:
+    """Return the exact public status observation, including deliberate absence."""
+    error = str(row.get("status_error") or "")
+    if error:
+        return error
+    status = row.get("status_value")
+    if isinstance(status, dict) and isinstance(status.get("exit_status"), str):
+        return status["exit_status"]
+    return "INVALID"
+
+
+def _matrix_rows(res: dict, key: str, expected: tuple[str, ...]):
+    error = str(res.get("matrix_error") or "")
+    rows = tuple(res.get(key) or ())
+    if error:
+        return (None, f"Matrix driver error: {error}")
+    labels = tuple((row.get("label") for row in rows))
+    if labels != expected:
+        return (None, f"Matrix matrix incomplete: labels={labels!r} expected={expected!r}")
+    for row in rows:
+        if row.get("start_error"):
+            return (None, f"{row['label']}: process/setup error={row['start_error']}")
+        if not row.get("cleanup_complete"):
+            return (None, f"{row['label']}: workspace cleanup incomplete")
+        if type(row.get("rc")) is not int:
+            return (None, f"{row['label']}: process rc unavailable")
+        if type(row.get("request_count")) is not int:
+            return (None, f"{row['label']}: request count unavailable")
+        if not isinstance(row.get("stdout"), bytes) or not isinstance(row.get("stderr"), bytes):
+            return (None, f"{row['label']}: raw stdout/stderr unavailable")
+    return (rows, "")
+
+
+def _matrix_exact_facts(
+    row: dict, *, rc: int, requests: int, stdout: bytes, status: str | tuple[str, ...]
+) -> dict:
+    """Compare a row against exact expected facts.
+
+    `status` may be a tuple when more than one status observation satisfies the
+    spec.
+    """
+    accepted = (status,) if isinstance(status, str) else tuple(status)
+    return {
+        "terminated": not row.get("timed_out"),
+        "rc": row.get("rc") == rc,
+        "requests": row.get("request_count") == requests,
+        "stdout": row.get("stdout") == stdout,
+        "status": _matrix_status_token(row) in accepted,
+    }
+
+
+def _matrix_verdict(res: dict, key: str, expected: tuple[str, ...], oracle, subject: str):
+    rows, error = _matrix_rows(res, key, expected)
+    if rows is None:
+        return _contract_verdict("error", error)
+    facts = {row["label"]: oracle(row) for row in rows}
+    ok = all((all(values.values()) for values in facts.values()))
+    summary = {
+        row["label"]: {
+            "rc": row.get("rc"),
+            "req": row.get("request_count"),
+            "stdout": len(row.get("stdout") or b""),
+            "status": _matrix_status_token(row),
+            "timeout": bool(row.get("timed_out")),
+            "oracle": facts[row["label"]],
+        }
+        for row in rows
+    }
+    return _contract_verdict("pass" if ok else "fail", f"{subject} exact rc/request/stdout/status={summary}")
+
+
+def _matrix_formal_success(row: dict) -> dict:
+    return _matrix_exact_facts(row, rc=0, requests=2, stdout=_MATRIX_REPLY_BYTES, status="Submitted")
+
+
+def chk_runtime_error_stdout_control(res, reqs=None):
+    return _matrix_verdict(
+        res,
+        "matrix_formal_rows",
+        ("model-success",),
+        _matrix_formal_success,
+        "R1I-21 zero-weight successful runtime",
+    )
+
+
+def chk_runtime_error_stdout(res, reqs=None):
+
+    def oracle(row):
+        return _matrix_exact_facts(row, rc=1, requests=1, stdout=b"", status="Error")
+
+    return _matrix_verdict(
+        res,
+        "matrix_formal_rows",
+        ("model-runtime-error",),
+        oracle,
+        "R1I-21 runtime error has no pseudo-result stdout",
+    )
+
+
+def _contract_clean_env(root: Path, base_env: dict, extra: dict | None) -> dict:
+    runtime = Path(base_env.get("D2A_READY_PYTHON") or sys.executable).resolve()
+    path_items = (str(runtime.parent), *os.defpath.split(os.pathsep))
+    env = {
+        "PATH": os.pathsep.join(dict.fromkeys((item for item in path_items if item))),
+        "HOME": str(root / "home"),
+        "TMPDIR": str(root / "tmp"),
+        "TMP": str(root / "tmp"),
+        "TEMP": str(root / "tmp"),
+        "LANG": "C",
+        "LC_ALL": "C",
+        "TZ": "UTC",
+        "PYTHONHASHSEED": "0",
+        "PYTHONIOENCODING": "utf-8:strict",
+        "PYTHONNOUSERSITE": "1",
+        "PYTHONDONTWRITEBYTECODE": "1",
+        "YUYAO_PYTHON": str(runtime),
+        "MSWEA_SILENT_STARTUP": "1",
+        "LITELLM_LOCAL_MODEL_COST_MAP": "True",
+        "MSWEA_COST_TRACKING": "ignore_errors",
+    }
+    if extra:
+        env.update({str(key): str(value) for key, value in extra.items()})
+    return env
+
+
+def _contract_read_status(path: Path):
+    try:
+        raw = path.read_bytes()
+    except FileNotFoundError:
+        return (None, "MISSING")
+    except OSError as exc:
+        return (None, f"READ_{type(exc).__name__.upper()}")
+    if len(raw) > 1 << 20:
+        return (None, "TOO_LARGE")
+    try:
+        value = _json_loads_strict(raw.decode("utf-8", "strict"))
+    except (UnicodeError, ValueError):
+        return (None, "MALFORMED")
+    if not isinstance(value, dict):
+        return (value, "NOT_OBJECT")
+    return (value, "")
+
+
+def _contract_tree_snapshot(root: Path):
+    """Hash files and path types without following symlinks."""
+    rows = []
+
+    def visit(directory: Path, prefix: str) -> None:
+        for entry in sorted(os.scandir(directory), key=lambda item: item.name.encode()):
+            relative = f"{prefix}/{entry.name}" if prefix else entry.name
+            metadata = entry.stat(follow_symlinks=False)
+            if entry.is_symlink():
+                payload = os.readlink(entry.path).encode("utf-8", "surrogateescape")
+                rows.append((relative, "symlink", hashlib.sha256(payload).hexdigest()))
+            elif entry.is_dir(follow_symlinks=False):
+                rows.append((relative, "directory", ""))
+                visit(Path(entry.path), relative)
+            elif entry.is_file(follow_symlinks=False):
+                digest = hashlib.sha256()
+                with open(entry.path, "rb") as stream:
+                    for chunk in iter(lambda: stream.read(65536), b""):
+                        digest.update(chunk)
+                rows.append((relative, "file", digest.hexdigest()))
+            else:
+                rows.append((relative, "other", str(metadata.st_mode)))
+
+    visit(root, "")
+    return tuple(rows)
+
+
+def _drive_contract_formal(agent_dir: Path, base_url: str, cfg: dict, base_env: dict, case: dict) -> dict:
+    launcher = agent_dir / "run_agent.sh"
+    if not launcher.is_file():
+        return {"std": True, "formal_rows": (), "formal_error": "RUN_AGENT_MISSING"}
+    rows = []
+    try:
+        for scenario in case.get("formal_scenarios") or ():
+            label = str(scenario["label"])
+            root = Path(tempfile.mkdtemp(prefix=f"headless_contract_{label}_"))
+            row = {
+                "label": label,
+                "rc": None,
+                "stdout": b"",
+                "stderr": b"",
+                "timed_out": False,
+                "cleanup_complete": True,
+                "start_error": "",
+                "status_value": None,
+                "status_error": "MISSING",
+                "request_count": None,
+                "repo_changed": None,
+                "out_created": None,
+            }
+            try:
+                home, temp = (root / "home", root / "tmp")
+                home.mkdir()
+                temp.mkdir()
+                layout = root / "paths" / label
+                repo = layout / "repo"
+                repo.mkdir(parents=True)
+                (repo / "fixture.txt").write_bytes(b"unchanged\n")
+                role = scenario.get("path_role", "sibling")
+                if role == "sibling":
+                    out = layout / "out"
+                elif role == "direct":
+                    out = repo / "out"
+                elif role == "parent_alias":
+                    decoy = layout / "decoy"
+                    decoy.mkdir()
+                    out = decoy / ".." / "repo" / "escaped-out"
+                elif role == "symlink_alias":
+                    alias = layout / "repo-alias"
+                    alias.symlink_to(repo, target_is_directory=True)
+                    out = alias / "linked-out"
+                else:
+                    raise ValueError(f"unknown path role {role!r}")
+                fixtures = root / "fixtures"
+                fixtures.mkdir()
+                task_file = fixtures / "task.json"
+                budget_file = fixtures / "budget.json"
+                task_file.write_text(
+                    json.dumps(
+                        {
+                            "task_id": f"contract-{label}",
+                            "type": "formal-headless-oracle",
+                            "problem_statement": "Return the model result without tools.",
+                            "repo_dir": str(repo),
+                            "allow_network": False,
+                        },
+                        ensure_ascii=False,
+                        separators=(",", ":"),
+                    ),
+                    encoding="utf-8",
+                )
+                budget_file.write_text(
+                    json.dumps(
+                        scenario.get("budget") or {"max_steps": 2, "max_tokens": 0, "max_wall_seconds": 30},
+                        ensure_ascii=False,
+                        separators=(",", ":"),
+                    ),
+                    encoding="utf-8",
+                )
+                argv = [
+                    "bash",
+                    str(launcher),
+                    "--task-file",
+                    str(task_file),
+                    "--repo-dir",
+                    str(repo),
+                    "--model-base-url",
+                    base_url,
+                    "--model-name",
+                    "litellm_proxy/mock",
+                    "--model-api-key",
+                    "sk-mock-test",
+                    "--budget-file",
+                    str(budget_file),
+                    "--out-dir",
+                    str(out),
+                ]
+                cfg["reply_content"] = scenario.get(
+                    "reply_content", case.get("reply_content", _CONTRACT_ASCII_TEXT)
+                )
+                before_requests = len(cfg.get("requests") or [])
+                before_repo = _contract_tree_snapshot(repo)
+                try:
+                    completed = subprocess.run(
+                        argv,
+                        cwd=str(root),
+                        env=_contract_clean_env(root, base_env, scenario.get("env")),
+                        capture_output=True,
+                        text=False,
+                        timeout=case.get("timeout", 30),
+                        start_new_session=True,
+                    )
+                    row["rc"] = completed.returncode
+                    row["stdout"] = completed.stdout or b""
+                    row["stderr"] = completed.stderr or b""
+                except subprocess.TimeoutExpired as exc:
+                    row["rc"] = -1
+                    row["stdout"] = exc.stdout or b""
+                    row["stderr"] = exc.stderr or b""
+                    row["timed_out"] = True
+                except (OSError, ValueError) as exc:
+                    row["start_error"] = type(exc).__name__
+                row["request_count"] = len(cfg.get("requests") or []) - before_requests
+                row["status_value"], row["status_error"] = _contract_read_status(out / "status.json")
+                row["repo_changed"] = before_repo != _contract_tree_snapshot(repo)
+                row["out_created"] = out.exists()
+            except Exception as exc:
+                row["start_error"] = f"SETUP_{type(exc).__name__.upper()}"
+            finally:
+                try:
+                    shutil.rmtree(root)
+                except OSError:
+                    row["cleanup_complete"] = False
+            rows.append(row)
+    except Exception as exc:
+        return {
+            "std": True,
+            "formal_rows": tuple(rows),
+            "formal_error": f"DRIVER_{type(exc).__name__.upper()}",
+        }
+    return {"std": True, "formal_rows": tuple(rows), "formal_error": ""}
+
+
+def _matrix_run_process(argv, *, cwd: Path, env: dict, input_bytes: bytes, timeout: float) -> dict:
+    result = {"rc": None, "stdout": b"", "stderr": b"", "timed_out": False, "start_error": ""}
+    process = None
+    try:
+        process = subprocess.Popen(
+            list(argv),
+            cwd=str(cwd),
+            env=env,
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=False,
+            start_new_session=True,
+        )
+        try:
+            stdout, stderr = process.communicate(input=input_bytes, timeout=timeout)
+            result["rc"] = process.returncode
+            result["stdout"] = stdout or b""
+            result["stderr"] = stderr or b""
+        except subprocess.TimeoutExpired as exc:
+            result["timed_out"] = True
+            result["stdout"] = exc.stdout or b""
+            result["stderr"] = exc.stderr or b""
+            try:
+                os.killpg(process.pid, 9)
+            except (OSError, ProcessLookupError):
+                try:
+                    process.kill()
+                except OSError:
+                    pass
+            try:
+                stdout, stderr = process.communicate(timeout=5)
+                result["stdout"] = stdout or result["stdout"]
+                result["stderr"] = stderr or result["stderr"]
+            except (OSError, subprocess.TimeoutExpired):
+                pass
+            result["rc"] = -1
+    except (OSError, ValueError) as exc:
+        result["start_error"] = type(exc).__name__
+    return result
+
+
+def _matrix_json_object(pairs) -> bytes:
+    return (
+        "{"
+        + ",".join(
+            (
+                f"{json.dumps(key, ensure_ascii=False)}:{json.dumps(value, ensure_ascii=False, separators=(',', ':'))}"
+                for key, value in pairs
+            )
+        )
+        + "}"
+    ).encode()
+
+
+def _drive_matrix_formal(agent_dir: Path, base_url: str, cfg: dict, base_env: dict, case: dict) -> dict:
+    """Drive exact seven-flag contract matrices without importing product code."""
+    launcher = agent_dir / "run_agent.sh"
+    if not launcher.is_file():
+        return {"std": True, "matrix_formal_rows": (), "matrix_error": "RUN_AGENT_MISSING"}
+    rows = []
+    driver_error = ""
+    try:
+        for scenario in case.get("matrix_formal_scenarios") or ():
+            label = str(scenario["label"])
+            root = Path(tempfile.mkdtemp(prefix=f"headless_matrix_formal_{label}_"))
+            row = {
+                "label": label,
+                "rc": None,
+                "stdout": b"",
+                "stderr": b"",
+                "timed_out": False,
+                "cleanup_complete": True,
+                "start_error": "",
+                "status_value": None,
+                "status_error": "MISSING",
+                "request_count": None,
+            }
+            try:
+                home, temp = (root / "home", root / "tmp")
+                home.mkdir()
+                temp.mkdir()
+                repo = root / "repo"
+                repo.mkdir()
+                (repo / "fixture.txt").write_bytes(b"unchanged\n")
+                out = root / "out"
+                fixtures = root / "fixtures"
+                fixtures.mkdir()
+                task_file = fixtures / "task.json"
+                budget_file = fixtures / "budget.json"
+                task = {
+                    "task_id": f"matrix-{label}",
+                    "type": "formal-headless-oracle",
+                    "problem_statement": "Return the fixed Matrix reply.",
+                    "repo_dir": str(repo),
+                    "allow_network": False,
+                }
+                task.update(dict(scenario.get("task_overrides") or {}))
+                budget = {"max_steps": 4, "max_tokens": 0, "max_wall_seconds": 30}
+                budget.update(dict(scenario.get("budget_overrides") or {}))
+                raw_contract = str(scenario.get("raw_contract") or "")
+                task_pairs = list(task.items())
+                budget_pairs = list(budget.items())
+                if raw_contract == "duplicate-task":
+                    task_pairs = [
+                        ("task_id", task["task_id"]),
+                        ("type", task["type"]),
+                        ("problem_statement", "Return the first fixed Matrix reply."),
+                        ("problem_statement", "Return the second fixed Matrix reply."),
+                        ("repo_dir", task["repo_dir"]),
+                        ("allow_network", False),
+                    ]
+                if raw_contract == "duplicate-budget":
+                    budget_pairs = [
+                        ("max_steps", 4),
+                        ("max_steps", 5),
+                        ("max_tokens", 0),
+                        ("max_wall_seconds", 30),
+                    ]
+                if raw_contract in {"unique-task", "duplicate-task"}:
+                    task_file.write_bytes(_matrix_json_object(task_pairs))
+                else:
+                    task_file.write_text(
+                        json.dumps(task, ensure_ascii=False, separators=(",", ":")), encoding="utf-8"
+                    )
+                if raw_contract in {"unique-budget", "duplicate-budget"}:
+                    budget_file.write_bytes(_matrix_json_object(budget_pairs))
+                else:
+                    budget_file.write_text(
+                        json.dumps(budget, ensure_ascii=False, separators=(",", ":")), encoding="utf-8"
+                    )
+                values = {
+                    "--task-file": str(task_file),
+                    "--repo-dir": str(repo),
+                    "--model-base-url": base_url,
+                    "--model-name": "litellm_proxy/mock",
+                    "--model-api-key": "sk-mock-test",
+                    "--budget-file": str(budget_file),
+                    "--out-dir": str(out),
+                }
+                values.update(dict(scenario.get("argv_overrides") or {}))
+                argv = ["bash", str(launcher)]
+                for _name, flag in _MATRIX_REQUIRED_FLAGS:
+                    argv.extend((flag, str(values[flag])))
+                cfg["mode"] = scenario.get("gateway_mode", case.get("gateway_mode", "fixed_reply"))
+                cfg["reply_content"] = scenario.get("reply_content", case.get("reply_content", _MATRIX_REPLY))
+                before_requests = len(cfg.get("requests") or [])
+                cfg["rounds_base"] = before_requests
+                observed = _matrix_run_process(
+                    argv,
+                    cwd=root,
+                    env=_contract_clean_env(root, base_env, scenario.get("env")),
+                    input_bytes=b"",
+                    timeout=float(case.get("timeout") or 40),
+                )
+                row.update(observed)
+                row["request_count"] = len(cfg.get("requests") or []) - before_requests
+                actual_out = Path(str(values["--out-dir"]))
+                if not actual_out.is_absolute():
+                    actual_out = root / actual_out
+                row["status_value"], row["status_error"] = _contract_read_status(actual_out / "status.json")
+            except Exception as exc:
+                row["start_error"] = f"SETUP_{type(exc).__name__.upper()}"
+            finally:
+                try:
+                    shutil.rmtree(root)
+                except OSError:
+                    row["cleanup_complete"] = False
+            rows.append(row)
+    except Exception as exc:
+        driver_error = f"DRIVER_{type(exc).__name__.upper()}"
+    return {"std": True, "matrix_formal_rows": tuple(rows), "matrix_error": driver_error}
+
+
+def _checked_case_result(case: dict, res: dict, reqs: list) -> dict:
+    status = None
+    try:
+        outcome = case["check"](res, reqs)
+        if isinstance(outcome, tuple) and len(outcome) == 3:
+            ok, why, status = outcome
+        else:
+            ok, why = outcome
+    except Exception as exc:
+        ok, why = (False, f"runner error: {exc!r}")
+        if case.get("formal_headless") or case.get("formal_status"):
+            status = "error"
+    row = {"id": case["id"], "ok": ok, "blocking": case.get("blocking", True), "why": why}
+    if status is not None:
+        row["status"] = status
+    return row
+
+
+CASES = [
+    dict(
+        id="headless_p_json_wellformed",
+        output_format="json",
+        blocking=False,
+        reply_content="PUREJSON_8842 finished",
+        check=chk_json_pure("PUREJSON_8842"),
+    ),
+    dict(
+        id="headless_p_json_model_error_wellformed",
+        output_format="json",
+        gateway_mode="http_401",
+        gate="headless_p_json_wellformed",
+        check=chk_json_error_pure,
+    ),
+    dict(
+        id="p34_ctl_task_text_reaches_wire",
+        output_format="text",
+        reply_content="ack",
+        task="ATREFTOK_9934 acknowledge and stop.",
+        probe_token="ATREFTOK_9934",
+        check=chk_probe_present("task body"),
+        timeout=90,
+        blocking=False,
+    ),
+    dict(
+        id="p34_ctl_bare_mention_not_auto_read",
+        output_format="text",
+        reply_content="ack",
+        seed_files={"ctx_9934.md": "ATREFTOK_9934 the project ships on Tuesdays.\n"},
+        probe_token="ATREFTOK_9934",
+        task="There is a file called ctx_9934.md in this repo. Do not read it. Say ok and stop.",
+        check=chk_probe_absent("content of a bare file-name mention"),
+        timeout=90,
+        blocking=False,
+    ),
+    dict(
+        id="at_ref_expands_in_headless",
+        output_format="text",
+        reply_content="ack",
+        seed_files={"ctx_9934.md": "ATREFTOK_9934 the project ships on Tuesdays.\n"},
+        probe_token="ATREFTOK_9934",
+        task="Summarize @ctx_9934.md in one line and stop.",
+        gates=["p34_ctl_task_text_reaches_wire", "p34_ctl_bare_mention_not_auto_read"],
+        check=chk_probe_present("content of the @-referenced file"),
+        timeout=90,
+    ),
+    dict(
+        id="budget_type_domain_control",
+        formal_headless=True,
+        formal_scenarios=_CONTRACT_BUDGET_VALID,
+        timeout=45,
+        blocking=False,
+        check=chk_budget_type_domain_control,
+    ),
+    dict(
+        id="budget_type_domain",
+        formal_headless=True,
+        formal_scenarios=(*_CONTRACT_BUDGET_VALID, *_CONTRACT_BUDGET_INVALID),
+        timeout=45,
+        gate="budget_type_domain_control",
+        check=chk_budget_type_domain,
+    ),
+    dict(
+        id="runtime_error_stdout_control",
+        matrix_formal=True,
+        matrix_formal_scenarios=({"label": "model-success", "gateway_mode": "seq_probe"},),
+        gateway_mode="seq_probe",
+        rounds=_MATRIX_FORMAL_ROUNDS,
+        reply_content=_MATRIX_REPLY,
+        timeout=40,
+        formal_status=True,
+        blocking=False,
+        check=chk_runtime_error_stdout_control,
+    ),
+    dict(
+        id="runtime_error_stdout",
+        matrix_formal=True,
+        matrix_formal_scenarios=(
+            {
+                "label": "model-runtime-error",
+                "gateway_mode": "http_401",
+                "env": {"MSWEA_MODEL_RETRY_STOP_AFTER_ATTEMPT": "1"},
+            },
+        ),
+        gateway_mode="seq_probe",
+        rounds=_MATRIX_FORMAL_ROUNDS,
+        reply_content=_MATRIX_REPLY,
+        timeout=40,
+        formal_status=True,
+        gate="runtime_error_stdout_control",
+        check=chk_runtime_error_stdout,
+    ),
+]
+
+
+def _run_one(cli, env, agent_dir: Path, case: dict) -> dict:
+    _cfg_over = dict(
+        mode=case.get("gateway_mode", "fixed_reply"),
+        reply_content=case.get("reply_content", "DONE_SENTINEL"),
+        probe_token=case.get("probe_token") or None or "",
+    )
+    if case.get("rounds") is not None:
+        _cfg_over["rounds"] = case["rounds"]
+    cfg = MG.new_cfg(**_cfg_over)
+    srv = MG.make_server(cfg, 0)
+    if case.get("matrix_formal"):
+        cfg["matrix_effect"] = True
+        srv.RequestHandlerClass = _MatrixEffectHandler
+    port = srv.server_address[1]
+    th = threading.Thread(target=srv.serve_forever, daemon=True)
+    th.start()
+    if case.get("matrix_formal"):
+        res = {"std": True, "matrix_formal_rows": (), "matrix_error": "DRIVER_DID_NOT_RETURN"}
+        reqs = []
+        try:
+            res = _drive_matrix_formal(agent_dir, f"http://127.0.0.1:{port}", cfg, env, case)
+            reqs = list(cfg["requests"])
+        except Exception as exc:
+            res["matrix_error"] = f"DRIVER_{type(exc).__name__.upper()}"
+        finally:
+            srv.shutdown()
+            srv.server_close()
+        return _checked_case_result(case, res, reqs)
+    if case.get("formal_headless"):
+        res = {"std": True, "formal_rows": (), "formal_error": "DRIVER_DID_NOT_RETURN"}
+        reqs = []
+        try:
+            res = _drive_contract_formal(agent_dir, f"http://127.0.0.1:{port}", cfg, env, case)
+            reqs = list(cfg["requests"])
+        except Exception as exc:
+            res["formal_error"] = f"DRIVER_{type(exc).__name__.upper()}"
+        finally:
+            srv.shutdown()
+            srv.server_close()
+        return _checked_case_result(case, res, reqs)
+    repo = Path(tempfile.mkdtemp(prefix=f"headless_{case['id']}_"))
+    res = {
+        "std": True,
+        "rc": None,
+        "stdout": "",
+        "stderr": "",
+        "timed_out": False,
+        "repo": str(repo),
+        "agent_dir": str(agent_dir),
+    }
+    reqs = []
+    try:
+        argv = list(cli) + [
+            "-p",
+            case.get("task", "Say the magic word and stop."),
+            "--output-format",
+            case.get("output_format", "text"),
+        ]
+        argv += list([])
+        cenv = dict(env)
+        cenv["HOME"] = str(repo)
+        cenv["D2A_MODEL_BASE_URL"] = f"http://127.0.0.1:{port}"
+        cenv["D2A_MODEL_NAME"] = "litellm_proxy/mock"
+        cenv["D2A_MODEL_API_KEY"] = "sk-mock-test"
+        if case.get("env"):
+            cenv.update(case["env"])
+        for _fn, _content in (case.get("seed_files") or {}).items():
+            _sp = repo / _fn
+            _sp.parent.mkdir(parents=True, exist_ok=True)
+            _sp.write_text(_content)
+        try:
+            r = subprocess.run(
+                argv,
+                cwd=str(repo),
+                env=cenv,
+                capture_output=True,
+                text=True,
+                timeout=case.get("timeout", 90),
+            )
+            res["rc"], res["stdout"], res["stderr"] = (r.returncode, r.stdout or "", r.stderr or "")
+        except subprocess.TimeoutExpired:
+            res["timed_out"] = True
+            res["rc"] = -1
+        reqs = list(cfg["requests"])
+    finally:
+        srv.shutdown()
+        srv.server_close()
+    return _checked_case_result(case, res, reqs)
+
+
+def _selected_cases(cases: list) -> list:
+    """When `D2A_ONLY_IDS` (comma separated) is non-empty, run only those cases; unset = full run,
+    bit-for-bit unchanged behaviour.
+
+    Lets a single case be re-tested on its own without running the whole layer. A filtered run is
+    NOT a complete score: the
+    `D2A_ONLY_ACTIVE` line is the explicit marker for the merge tool; without it the result must
+    not be merged as an increment.
+    """
+    only = {s.strip() for s in (os.environ.get("D2A_ONLY_IDS") or "").split(",") if s.strip()}
+    if not only:
+        return list(cases)
+    picked = SC.dependency_closure(cases, only)
+    need = {c["id"] for c in picked}
+    print(
+        f"D2A_ONLY_ACTIVE={len(picked)}/{len(cases)} ids={sorted(only)[:12]} gates+={sorted(need - only)[:8]}",
+        flush=True,
+    )
+    return picked
+
+
+def run_smoke(agent_dir: Path) -> list:
+    cases = _selected_cases(CASES)
+    print_cli, env = _discover_cli(agent_dir, require_print=True)
+    management_cli, _ = _discover_cli(agent_dir, require_print=False)
+    results = {}
+    for c in cases:
+        if c.get("matrix_formal"):
+            results[c["id"]] = _run_one((), env, agent_dir, c)
+            continue
+        if c.get("formal_headless"):
+            results[c["id"]] = _run_one((), env, agent_dir, c)
+            continue
+        is_management = False
+        cli = management_cli if is_management else print_cli
+        if cli is None:
+            capability = "bare management CLI" if is_management else "-p/--print CLI"
+            results[c["id"]] = {
+                "id": c["id"],
+                "ok": True,
+                "blocking": c.get("blocking", True),
+                "why": f"inconclusive: build exposes no discoverable {capability} -> skipped",
+            }
+            continue
+        results[c["id"]] = _run_one(cli, env, agent_dir, c)
+    return SC.apply_gates(cases, (results[c["id"]] for c in cases))
+
+
+def _selftest() -> bool:
+    """Checker selftest (proves discriminating power, needs no build): every mutant must FAIL, every
+    correct fixture must PASS, and a broken observation must be reported as an error."""
+    jf = chk_json_pure("XYZ")
+    jclean = jf({"std": True, "rc": 0, "stdout": '{"exit_status":"Submitted","result":"XYZ ok"}\n'})
+    jnoise = jf({"std": True, "rc": 0, "stdout": '[INFO] starting\n{"result":"XYZ"}\n'})
+    jnan = jf({"std": True, "rc": 0, "stdout": '{"result":"XYZ","value":NaN}\n'})
+    je = chk_json_error_pure
+    jerr_clean = je(
+        {"std": True, "rc": 1, "stdout": '{"exit_status":"Error","result":"model failed"}\n', "stderr": ""},
+        [{"request": True}],
+    )
+    jerr_empty = je({"std": True, "rc": 1, "stdout": "", "stderr": "failed"}, [{"request": True}])
+
+    def _contract_row(label, rc, status, requests, **extra):
+        row = {
+            "label": label,
+            "rc": rc,
+            "stdout": b"",
+            "stderr": b"",
+            "timed_out": False,
+            "cleanup_complete": True,
+            "start_error": "",
+            "status_value": {"exit_status": status},
+            "status_error": "",
+            "request_count": requests,
+        }
+        row.update(extra)
+        return row
+
+    contract_valid = (_contract_row("valid-zero", 0, "Submitted", 1), _contract_row("valid-positive", 0, "Submitted", 1))
+    contract_invalid = tuple(
+        (
+            _contract_row(label, 2, "Error", 0)
+            for label in ("invalid-boolean", "invalid-string", "invalid-float", "invalid-negative")
+        )
+    )
+    contract_control = chk_budget_type_domain_control({"formal_rows": contract_valid, "formal_error": ""})
+    contract_pass = chk_budget_type_domain({"formal_rows": (*contract_valid, *contract_invalid), "formal_error": ""})
+    contract_mutant_rows = list((*contract_valid, *contract_invalid))
+    contract_mutant_rows[2] = _contract_row("invalid-boolean", 0, "Submitted", 1)
+    contract_mutant = chk_budget_type_domain({"formal_rows": tuple(contract_mutant_rows), "formal_error": ""})
+    contract_error_rows = [dict(row) for row in (*contract_valid, *contract_invalid)]
+    contract_error_rows[-1]["status_error"] = "MISSING"
+    contract_error_rows[-1]["status_value"] = None
+    contract_error = chk_budget_type_domain({"formal_rows": tuple(contract_error_rows), "formal_error": ""})
+
+    def _matrix_row(label, rc, requests, stdout, status, **extra):
+        row = {
+            "label": label,
+            "rc": rc,
+            "stdout": stdout,
+            "stderr": b"",
+            "timed_out": False,
+            "cleanup_complete": True,
+            "start_error": "",
+            "status_value": None if status == "MISSING" else {"exit_status": status},
+            "status_error": "MISSING" if status == "MISSING" else "",
+            "request_count": requests,
+        }
+        row.update(extra)
+        return row
+
+    def _matrix_result(key, rows):
+        return {key: tuple(rows), "matrix_error": ""}
+    matrix_runtime_gate = chk_runtime_error_stdout_control(
+        _matrix_result("matrix_formal_rows", (_matrix_row("model-success", 0, 2, _MATRIX_REPLY_BYTES, "Submitted"),))
+    )
+    matrix_runtime_row = _matrix_row("model-runtime-error", 1, 1, b"", "Error")
+    matrix_runtime_pass = chk_runtime_error_stdout(_matrix_result("matrix_formal_rows", (matrix_runtime_row,)))
+    matrix_runtime_mutant = chk_runtime_error_stdout(
+        _matrix_result("matrix_formal_rows", (dict(matrix_runtime_row, stdout=b"[no final answer]\n"),))
+    )
+    matrix_runtime_error = chk_runtime_error_stdout(
+        _matrix_result("matrix_formal_rows", (dict(matrix_runtime_row, start_error="SETUP_OSERROR"),))
+    )
+    oks = [
+        jclean[0],
+        not jnoise[0],
+        not jnan[0],
+        jerr_clean[0],
+        not jerr_empty[0],
+        contract_control[0] and contract_control[2] == "pass",
+        contract_pass[0] and contract_pass[2] == "pass",
+        not contract_mutant[0] and contract_mutant[2] == "fail",
+        not contract_error[0] and contract_error[2] == "error",
+        matrix_runtime_gate[0] and matrix_runtime_gate[2] == "pass",
+        matrix_runtime_pass[0] and matrix_runtime_pass[2] == "pass",
+        not matrix_runtime_mutant[0] and matrix_runtime_mutant[2] == "fail",
+        not matrix_runtime_error[0] and matrix_runtime_error[2] == "error",
+    ]
+    print(
+        "[selftest] json(clean/noise/nan/error/empty)=%s contract-budget(control/pass/mutant/error)=%s "
+        "runtime-error(gate/pass/mutant/error)=%s -> %s"
+        % (
+            (jclean[0], jnoise[0], jnan[0], jerr_clean[0], jerr_empty[0]),
+            (contract_control[2], contract_pass[2], contract_mutant[2], contract_error[2]),
+            (matrix_runtime_gate[2], matrix_runtime_pass[2], matrix_runtime_mutant[2], matrix_runtime_error[2]),
+            "OK" if all(oks) else "BROKEN",
+        )
+    )
+    return all(oks)
+
+
+def main():
+    import argparse
+
+    ap = argparse.ArgumentParser()
+    ap.add_argument("agent_dir", nargs="?", default=None)
+    ap.add_argument("--emit-json", action="store_true")
+    ap.add_argument("--selftest", action="store_true")
+    args = ap.parse_args()
+    if args.selftest:
+        sys.exit(0 if _selftest() else 1)
+    if not args.agent_dir:
+        ap.error("agent_dir is required unless --selftest is given")
+    agent_dir = Path(args.agent_dir)
+    if (agent_dir / "agent").is_dir():
+        agent_dir = agent_dir / "agent"
+    if not any(((agent_dir / c / "yuyao").is_dir() for c in ("src", "."))) and (
+        not (agent_dir / "src").is_dir()
+    ):
+        print(f"[headless_smoke] agent src not found: {agent_dir}", file=sys.stderr)
+        if args.emit_json:
+            print(
+                'HEADLESS_RESULTS=[{"id": "_headless_harness", "ok": false, "blocking": true, "why": "no agent src"}]'
+            )
+            print("HEADLESS_SMOKE_FAIL")
+        sys.exit(2)
+    print(f"[headless_smoke] agent: {agent_dir}  {len(CASES)} cases\n")
+    results = run_smoke(agent_dir)
+    npass = sum((r["ok"] for r in results))
+    for r in results:
+        print(f"[{('PASS' if r['ok'] else 'FAIL')}] {r['id']:28s} {r['why']}")
+    blocking_ok = all((r["ok"] for r in results if r.get("blocking")))
+    if args.emit_json:
+        print("HEADLESS_RESULTS=" + json.dumps(results, ensure_ascii=False))
+        print("HEADLESS_SMOKE_OK" if blocking_ok else "HEADLESS_SMOKE_FAIL")
+    print(f"\n== headless -p output-purity determinism smoke {npass}/{len(results)} passed ==")
+    sys.stdout.flush()
+    sys.stderr.flush()
+    os._exit(0 if npass == len(results) else 1)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/code/src/stage1/smoke/mock_cases.py b/code/src/stage1/smoke/mock_cases.py
new file mode 100644
index 0000000000000000000000000000000000000000..679894463e27215a451373073502ff3cbe25d1b2
--- /dev/null
+++ b/code/src/stage1/smoke/mock_cases.py
@@ -0,0 +1,1650 @@
+"""Mock case library (declarative): use mock_gateway as the "model" to deterministically drive a real
+agent (entry.py) into a range of failure and edge scenarios, asserting per case. Zero real-model budget
+and parallelisable.
+
+Each case declares:
+  id        case name
+  mode      mock gateway failure mode (see mock_gateway.build_response)
+  command   the bash the agent is told to run (the mock returns it every step; default creates a marker file)
+  fixtures  files written into the repo before the run (str or bytes; bytes for dirty-byte cases)
+  usage_tokens  the (prompt, completion) token counts of the mock's default usage (for cost cases)
+  env       extra environment variables for the entry subprocess (e.g. injecting D2A_MODEL_COST)
+  max_steps step budget (small values force a clean LimitsExceeded finish)
+  check     assertion function (rc, status, repo, reqs) -> (ok, detail)
+  blocking  False = informational (hard to judge strictly black-box; reported but not counted as a pass)
+
+Usage: python mock_cases.py <agent_dir>   (an artifact directory containing a d2a interpreter with litellm)
+"""
+
+from __future__ import annotations
+import copy
+import json
+import hashlib
+import math
+import os
+import re
+import signal
+import socket
+import subprocess
+import sys
+import tempfile
+import threading
+import time
+from http.server import ThreadingHTTPServer
+from pathlib import Path
+
+HERE = Path(__file__).resolve().parent
+sys.path.insert(0, str(HERE))
+import mock_gateway as MG
+import smoke_contract as SC
+
+NO_TB = "Traceback (most recent call last)"
+_SHELL_EDGE_CONTROL_TOKEN = "D2A_SHELL_EDGE_CONTROL_6A31"
+_SHELL_EDGE_LEFT_TOKEN = "D2A_SHELL_EDGE_LEFT_6A32"
+_SHELL_EDGE_UNTRUNCATED_TOKEN = "D2A_SHELL_EDGE_UNTRUNCATED_6A33"
+_SHELL_EDGE_RIGHT_TOKEN = "D2A_SHELL_EDGE_RIGHT_6A34"
+_SHELL_EDGE_EXPECTED = (
+    f"\n  {_SHELL_EDGE_LEFT_TOKEN}  \n{_SHELL_EDGE_UNTRUNCATED_TOKEN}\n  {_SHELL_EDGE_RIGHT_TOKEN}  \n\n"
+)
+_SHELL_EDGE_CONTROL_COMMAND = "printf 'D2A_SHELL_EDGE_%s\\n' 'CONTROL_6A31'"
+_SHELL_EDGE_TARGET_COMMAND = "printf '\\n  D2A_SHELL_EDGE_%s  \\nD2A_SHELL_EDGE_%s\\n  D2A_SHELL_EDGE_%s  \\n\\n' 'LEFT_6A32' 'UNTRUNCATED_6A33' 'RIGHT_6A34'"
+_QGATE_MARK = "QGATE_RAN_7755"
+_QGATE_KEYS = ("qualityGate", "beforeFinish", "beforeSubmit", "beforeCompletion")
+
+
+def _qgate_hooks_json(exit_code: int) -> str:
+    cmd = f"sh -c 'echo {_QGATE_MARK} > qgate.marker; exit {exit_code}'"
+    body = {k: [{"command": cmd, "action": "run"}] for k in _QGATE_KEYS}
+    return json.dumps(body)
+
+
+def chk_quality_gate_blocks_completion(rc, st, repo, reqs):
+    """v6§7:433 quality gate: if the gate does not pass, finishing is NOT allowed -- it must not still record `Submitted`.
+
+    Key design point, and why "not implemented = FAIL" is not used: v6§7:433 says a "must pass tests/lint
+    before completing" quality gate MAY be configured, and "may" can be read as "this is an optional
+    feature". Failing a build that never implemented a quality gate would break this project's rule
+    against failing anything the spec does not mandate.
+
+    So the gate leaves its own trace: the gate command writes `qgate.marker` and then `exit 1`. That
+    separates three states naturally:
+      - no marker -> this build never ran the gate at all (not implemented / does not recognise these key
+        names) -> inconclusive, not a failure;
+      - marker present but still recording `Submitted` -> the gate ran, failed, and it still claims a clean
+        completion -> FAIL. This does not depend on any reading of "may": v6§9:473 ("Submitted must mean
+        what it says") and v6§7:433 ("a failed quality gate forbids finishing") coincide here without
+        ambiguity;
+      - marker present and `exit_status != Submitted` -> PASS.
+
+    Non-vacuity: `reqs >= 1` prevents "the run never reached the model" being read as "the gate blocked it".
+    The paired control `quality_gate_pass_allows_completion` (same hooks.json, gate `exit 0`) proves the
+    fixture itself does not prevent completion, ruling out a degenerate implementation that can never
+    complete regardless of the gate.
+    """
+    if not st:
+        return (True, f"inconclusive: no status.json written (not judgeable at this layer) rc={rc}")
+    if len(reqs) < 1:
+        return (
+            True,
+            'inconclusive: the run produced no model request (reqs=0), so there is no "completion" to speak of',
+        )
+    ran = (repo / "qgate.marker").exists()
+    exit_status = st.get("exit_status")
+    if not ran:
+        return (
+            True,
+            f"inconclusive: the quality gate never executed (no {_QGATE_MARK} trace), so this build does not implement it or does not recognise these key names (v6§7:433 says it MAY be configured, so not implementing it is not a failure) exit={exit_status} key names tried={list(_QGATE_KEYS)}",
+        )
+    ok = exit_status != "Submitted"
+    return (
+        ok,
+        f"the quality gate ran and failed (marker present); exit_status={exit_status!r} must not be Submitted={ok} rc={rc} (v6§7:433 a failed quality gate forbids finishing x v6§9:473 Submitted must mean what it says)",
+    )
+
+
+def chk_quality_gate_blocks_completion_control(rc, st, repo, reqs):
+    """Control for the previous cell: same hooks.json with the gate changed to `exit 0`, so it must be able to complete normally.
+
+    Without it, a degenerate implementation that can never complete regardless of the gate would get a free
+    PASS on the main cell.
+    A gate that never executed is also inconclusive (symmetrical with the main cell, so "not implemented"
+    is not read as "the control failed").
+    """
+    if not st:
+        return (True, f"inconclusive: no status.json written rc={rc}")
+    if not (repo / "qgate.marker").exists():
+        return (
+            True,
+            f"inconclusive: the quality gate never executed, so this build does not implement it and the control does not apply exit={st.get('exit_status')}",
+        )
+    ok = st.get("exit_status") == "Submitted" and rc == 0
+    return (
+        ok,
+        f"with the gate passing (exit 0) it must complete normally: exit_status={st.get('exit_status')!r} rc={rc} ok={ok} (control: proves the fixture itself does not prevent completion)",
+    )
+
+
+def _shell_edge_results(reqs: list[dict], marker: str) -> list[str]:
+    """Return only tool results containing an output-only marker."""
+    return [text for request in reqs for text in request.get("tool_result_texts") or [] if marker in text]
+
+
+def chk_shell_output_edge_whitespace_control(rc, st, repo, reqs):
+    matches = _shell_edge_results(reqs, _SHELL_EDGE_CONTROL_TOKEN)
+    live = rc == 0 and len(reqs) >= 2 and (st.get("exit_status") in ("Submitted", "LimitsExceeded"))
+    ok = live and bool(matches)
+    return (
+        ok,
+        f"ordinary_line_roundtrip={bool(matches)} matches={len(matches)} reqs={len(reqs)} rc={rc} exit={st.get('exit_status')} (the complete control token can only be assembled by real printf stdout; a command echo cannot compensate)",
+    )
+
+
+def chk_shell_output_edge_whitespace(rc, st, repo, reqs):
+    matches = _shell_edge_results(reqs, _SHELL_EDGE_UNTRUNCATED_TOKEN)
+    expected = _SHELL_EDGE_EXPECTED.encode("ascii")
+    exact = [expected in text.encode("utf-8") for text in matches]
+    live = rc == 0 and len(reqs) >= 2 and (st.get("exit_status") in ("Submitted", "LimitsExceeded"))
+    ok = live and bool(matches) and any(exact)
+    return (
+        ok,
+        f"edge_bytes_exact={any(exact)} marker_results={len(matches)} reqs={len(reqs)} rc={rc} exit={st.get('exit_status')} (the leading/trailing blank lines and the spaces around the content line of a short untruncated stdout must be present verbatim as contiguous ASCII bytes in the matching tool result; strip/rstrip/lstrip and whitespace normalisation all FAIL)",
+    )
+
+
+def chk_secret_not_leaked(rc, st, repo, reqs):
+    leaked = any((r.get("has_probe") for r in reqs))
+    ok = not leaked and len(reqs) >= 1 and (st.get("exit_status") in ("Submitted", "LimitsExceeded"))
+    return (
+        ok,
+        f"un-@-referenced private key sentinel in a request body={leaked} reqs={len(reqs)} exit={st.get('exit_status')} (a filename mentioned in free text must not trigger an auto-read and leak; the sentinel in a request body is a private key leak)",
+    )
+
+
+def chk_probe_in_body(rc, st, repo, reqs):
+    seen = any((r.get("has_probe") for r in reqs))
+    ok = seen and st.get("exit_status") in ("Submitted", "LimitsExceeded")
+    return (
+        ok,
+        f"sentinel of the read file in a request body={seen} reqs={len(reqs)} exit={st.get('exit_status')} (positive control: content really cat-ed should be fed back onto the wire, proving the leak probe works)",
+    )
+_PEER_WEB_URL_PLACEHOLDER = "__PEER_WEBFETCH_URL__"
+_PEER_WEB_CONTROL_TOKEN = "PEER_WEBFETCH_CONTROL_BODY_7528"
+_PEER_WEB_BODY_TOKENS = {
+    404: "PEER_WEBFETCH_BODY_ALPHA_8639",
+    429: "PEER_WEBFETCH_BODY_BETA_9741",
+    500: "PEER_WEBFETCH_BODY_GAMMA_1852",
+}
+
+
+def _peer_web_rounds() -> list[list[dict]]:
+    return [
+        [
+            {
+                "name": ["web_fetch", "web-fetch", "webfetch", "WebFetch"],
+                "args": {"url": _PEER_WEB_URL_PLACEHOLDER},
+            }
+        ],
+        [{"name": "__finish__"}],
+    ]
+
+
+def _peer_exchange(reqs: list[dict]) -> dict:
+    projections = [
+        dict(req.get("peer_exchange") or {})
+        for req in reqs or []
+        if (req.get("peer_exchange") or {}).get("target_call_seen")
+    ]
+    paired = [row for row in projections if row.get("target_result_seen")]
+    return paired[-1] if paired else projections[-1] if projections else {}
+
+
+def _peer_web_gateway(st: dict) -> dict:
+    return dict((st or {}).get("_gateway") or {})
+
+
+def chk_webfetch_http_failure_control(rc, st, repo, reqs):
+    """Zero-weight: a real local HTTP 200 must reach web_fetch and its matching result."""
+    gateway = _peer_web_gateway(st)
+    gets = list(gateway.get("web_gets") or [])
+    exchange = _peer_exchange(reqs)
+    text = str(exchange.get("target_result_text") or "")
+    first_tools = (reqs[0] if reqs else {}).get("tool_names") or []
+    facts = {
+        "web_fetch_advertised": any((MG.canon_tool(name) == "web_fetch" for name in first_tools)),
+        "one_http_get": len(gets) == 1,
+        "http_200_sent": len(gets) == 1
+        and gets[0].get("status") == 200
+        and (gets[0].get("send_complete") is True),
+        "one_target_call": exchange.get("target_call_count") == 1,
+        "one_matching_result": exchange.get("target_result_count") == 1,
+        "id_paired": exchange.get("id_paired") is True,
+        "body_public": _PEER_WEB_CONTROL_TOKEN in text,
+        "clean_process": rc == 0
+        and st.get("exit_status") in ("Submitted", "LimitsExceeded")
+        and (not st.get("_timed_out")),
+        "gateway_cleanup": gateway.get("cleanup_complete") is True,
+    }
+    ok = all(facts.values())
+    return (
+        ok,
+        f"webfetch_http_control={ok} facts={facts} reqs={len(reqs)} result_sha={exchange.get('target_result_sha256')} (the local 200 body must be exposed via a real GET and a role=tool result with a matching call-id; exposing only the schema, only hitting HTTP, or compensating across calls does not open the target gate)",
+    )
+
+
+def _peer_web_failure_marked(text: str) -> bool:
+    low = text.lower()
+    structured = any(
+        (
+            re.search(pattern, low)
+            for pattern in (
+                "[\"\\']?(?:ok|success)[\"\\']?\\s*[:=]\\s*false",
+                "[\"\\']?is[_-]?error[\"\\']?\\s*[:=]\\s*true",
+                "[\"\\']?status[\"\\']?\\s*[:=]\\s*[\"\\'](?:error|failed|failure)",
+            )
+        )
+    )
+    verbal = any(
+        (
+            sig in low
+            for sig in (
+                "error",
+                "failed",
+                "failure",
+                "unsuccessful",
+                "not successful",
+                "non-success",
+                "not found",
+                "too many requests",
+                "rate limit",
+                "server error",
+                "internal server",
+                "service unavailable",
+                "bad gateway",
+            )
+        )
+    )
+    return structured or verbal
+
+
+def _peer_web_status_preserved(text: str, status_code: int) -> bool:
+    return bool(
+        re.search(f"(?:http|status(?:\\s+code)?|code|->)[^0-9]{{0,18}}{status_code}(?:\\D|$)", text, re.I)
+    )
+
+
+def chk_webfetch_http_failure_matrix(rows: list[dict]):
+    expected = {"http_404": 404, "http_429": 429, "http_500": 500}
+    labelled = {row.get("label"): row for row in rows}
+    if set(labelled) != set(expected):
+        return (False, f"runner error: webfetch variants={sorted(labelled)} expected={sorted(expected)}")
+    all_facts = {}
+    for label, status_code in expected.items():
+        row = labelled[label]
+        st, reqs = (row.get("status") or {}, row.get("reqs") or [])
+        gateway = _peer_web_gateway(st)
+        gets = list(gateway.get("web_gets") or [])
+        exchange = _peer_exchange(reqs)
+        text = str(exchange.get("target_result_text") or "")
+        low = text.lower()
+        explicit_success = bool(re.search("[\"\\']?(?:ok|success)[\"\\']?\\s*[:=]\\s*true", low))
+        facts = {
+            "bounded_gets": 1 <= len(gets) <= 3,
+            "exact_http_status": bool(gets) and all((get.get("status") == status_code for get in gets)),
+            "response_complete": bool(gets) and all((get.get("send_complete") is True for get in gets)),
+            "one_target_call": exchange.get("target_call_count") == 1,
+            "one_matching_result": exchange.get("target_result_count") == 1,
+            "id_paired": exchange.get("id_paired") is True,
+            "status_preserved": _peer_web_status_preserved(text, status_code),
+            "failure_marked": _peer_web_failure_marked(text),
+            "not_explicit_success": not explicit_success,
+            "clean_process": row.get("rc") == 0
+            and st.get("exit_status") in ("Submitted", "LimitsExceeded")
+            and (not st.get("_timed_out")),
+            "gateway_cleanup": gateway.get("cleanup_complete") is True,
+        }
+        all_facts[label] = {
+            "ok": all(facts.values()),
+            "facts": facts,
+            "result_sha256": exchange.get("target_result_sha256"),
+            "result_preview": text[:180],
+        }
+    ok = all((row["ok"] for row in all_facts.values()))
+    return (
+        ok,
+        f"webfetch_http_failure={ok} variants={all_facts} (404/429/500 must each preserve the exact status in the public tool result with the matching call-id and be clearly marked as failed; treating `GET ... -> HTTP N` plus the body as ordinary successful output is a FAIL)",
+    )
+
+
+_EGRESS_PROXY_FINAL = "EGRESS_PROXY_DIRECT_FINAL_1753"
+
+
+def _egress_gateway(st: dict) -> dict:
+    return dict((st or {}).get("_gateway") or {})
+
+
+def _egress_proxy_observation(st: dict) -> dict:
+    return dict((st or {}).get("_egress_proxy") or {})
+
+
+def _egress_proxy_facts(rc, st, reqs, *, injected: bool) -> dict:
+    obs = _egress_proxy_observation(st)
+    gateway = _egress_gateway(st)
+    return {
+        "gateway_self_check": obs.get("gateway_self_check") is True,
+        "proxy_self_check": obs.get("proxy_self_check") is True,
+        "environment_exact": obs.get("environment_exact") is True and obs.get("proxy_injected") is injected,
+        "nonlocalhost_explicit_host": obs.get("gateway_host") == "127.0.0.2",
+        "one_gateway_request": len(reqs) == 1 and gateway.get("request_count") == 1,
+        "gateway_response_complete": gateway.get("response_statuses") == [200]
+        and gateway.get("response_send_complete") == [True],
+        "zero_proxy_connections": obs.get("proxy_product_connections") == 0,
+        "zero_proxy_api_key": obs.get("proxy_api_key_seen") is False,
+        "clean_terminal": rc == 0
+        and st.get("exit_status") in ("Submitted", "LimitsExceeded")
+        and (not st.get("_timed_out")),
+        "cleanup": obs.get("cleanup_complete") is True and gateway.get("cleanup_complete") is True,
+    }
+
+
+def chk_http_proxy_hermetic_control(rc, st, repo, reqs):
+    """Zero-weight: with every ambient proxy unset, the explicit gateway closes once."""
+    facts = _egress_proxy_facts(rc, st, reqs, injected=False)
+    ok = all(facts.values())
+    return (
+        ok,
+        f"http_proxy_control={ok} facts={facts} (both the explicit 127.0.0.2 D2A endpoint and the trap proxy pass a raw self-check first; with no proxy environment the single model request may only enter the gateway ledger)",
+    )
+
+
+def chk_http_proxy_hermetic(rc, st, repo, reqs):
+    facts = _egress_proxy_facts(rc, st, reqs, injected=True)
+    ok = all(facts.values())
+    return (
+        ok,
+        f"http_proxy_hermetic={ok} facts={facts} (when HTTP_PROXY/HTTPS_PROXY/ALL_PROXY and their case variants point at the self-checked trap, the explicit D2A model endpoint must still own the only request, with zero proxy connections and zero API keys seen there)",
+    )
+
+
+def chk_artifact_has(rel, spec, *, nonempty=False, glob_in=""):
+    """The v6§0.1.1 artifact root manifest: a given convention file/directory must be present in the artifact.
+
+    Static check; the signature differs from a normal mock check -- it takes `(agent_dir)` and is called
+    from `_run_one`'s `static_artifact` branch (no mock server, no agent run).
+
+    Rationale: spec items 1/6/7 require these files. The build-time contract check is a GATE, not a
+    test point, and does not look at pyproject.toml or install.sh at all.
+
+    `glob_in` covers shapes like `wheels/` where the directory must contain at least one .whl.
+    """
+
+    def _f(agent_dir):
+        p = Path(agent_dir) / rel
+        if glob_in:
+            hits = sorted(p.glob(glob_in)) if p.is_dir() else []
+            return (
+                bool(hits),
+                f"{rel} directory exists={p.is_dir()} containing {len(hits)} {glob_in} ({spec})",
+            )
+        exists = p.is_file()
+        if exists and nonempty:
+            size = p.stat().st_size
+            return (size > 0, f"{rel} exists but size={size}B (must be non-empty) ({spec})")
+        return (exists, f"{rel} exists={exists} ({spec})")
+
+    return _f
+
+
+def chk_artifact_declares_deps(spec):
+    """v6§0.1.1:25: new third-party dependencies must be declared in `[project.dependencies]` of
+    `pyproject.toml` (OR in `requirements.txt`).
+
+    The spec offers a choice of two, so the check must too -- accepting only pyproject.toml would
+    wrongly fail a compliant requirements.txt implementation. It fails only when neither is present.
+    """
+
+    def _f(agent_dir):
+        d = Path(agent_dir)
+        pj, rt = (d / "pyproject.toml", d / "requirements.txt")
+        has_pj = pj.is_file() and "[project" in pj.read_text(encoding="utf-8", errors="replace")
+        has_rt = rt.is_file() and rt.stat().st_size > 0
+        return (
+            has_pj or has_rt,
+            f"pyproject.toml has [project...]={has_pj} requirements.txt non-empty={has_rt} (either is sufficient) ({spec})",
+        )
+
+    return _f
+
+
+CASES = [
+    dict(
+        id="artifact_has_run_agent_sh",
+        static_artifact=True,
+        blocking=False,
+        check=chk_artifact_has("run_agent.sh", "v6§0.1.1:20 requires `run_agent.sh` in the artifact root"),
+    ),
+    dict(
+        id="artifact_has_entry_py",
+        static_artifact=True,
+        blocking=False,
+        check=chk_artifact_has("entry.py", "v6§0.1.1:20 requires `entry.py` in the artifact root"),
+    ),
+    dict(
+        id="artifact_has_offline_wheel",
+        static_artifact=True,
+        blocking=False,
+        check=chk_artifact_has(
+            "wheels", "v6§0.1.1:20 `wheels/` (at least one offline wheel)", glob_in="*.whl"
+        ),
+    ),
+    dict(
+        id="artifact_has_requirements_lock",
+        static_artifact=True,
+        blocking=False,
+        check=chk_artifact_has(
+            "requirements.lock",
+            "v6§0.1.1:20 requires `requirements.lock` in the artifact root",
+            nonempty=True,
+        ),
+    ),
+    dict(
+        id="artifact_has_version_file",
+        static_artifact=True,
+        blocking=False,
+        check=chk_artifact_has(
+            "VERSION", "v6§0.1.1:20 requires `VERSION` in the artifact root", nonempty=True
+        ),
+    ),
+    dict(
+        id="artifact_declares_dependencies",
+        static_artifact=True,
+        blocking=False,
+        check=chk_artifact_declares_deps(
+            "v6§0.1.1:25: new third-party dependencies must be declared in `[project.dependencies]` of `pyproject.toml` (or in `requirements.txt`)"
+        ),
+    ),
+    dict(
+        id="artifact_has_install_sh",
+        static_artifact=True,
+        blocking=False,
+        check=chk_artifact_has(
+            "install.sh",
+            "v6§0.1.1:26 `install.sh` installs everything in one step -- this cell only judges that it exists; whether it installs cleanly is a higher bar",
+        ),
+    ),
+    dict(
+        id="quality_gate_blocks_completion",
+        mode="seq_probe",
+        max_steps=4,
+        rounds=[[{"name": "bash", "command": "echo QGATE_EDIT_7755 > edited.txt"}]],
+        fixtures={"hooks.json": _qgate_hooks_json(1)},
+        gate="quality_gate_blocks_completion_control",
+        check=chk_quality_gate_blocks_completion,
+        blocking=True,
+        timeout=90,
+    ),
+    dict(
+        id="quality_gate_blocks_completion_control",
+        mode="seq_probe",
+        max_steps=4,
+        rounds=[[{"name": "bash", "command": "echo QGATE_EDIT_7755 > edited.txt"}]],
+        fixtures={"hooks.json": _qgate_hooks_json(0)},
+        check=chk_quality_gate_blocks_completion_control,
+        blocking=False,
+        timeout=90,
+    ),
+    dict(
+        id="unreferenced_secret_not_in_request_body",
+        mode="normal",
+        max_steps=2,
+        task="Look into the permission problem on ~/.ssh/id_rsa; the format notes in secret.key may help. Contact alice@example.com.",
+        fixtures={
+            "secret.key": "-----BEGIN OPENSSH PRIVATE KEY-----\nSK_SENTINEL_4242\n-----END OPENSSH PRIVATE KEY-----\n"
+        },
+        probe_token="SK_SENTINEL_4242",
+        gate="secret_probe_mechanism_control",
+        check=chk_secret_not_leaked,
+        blocking=True,
+    ),
+    dict(
+        id="secret_probe_mechanism_control",
+        mode="normal",
+        max_steps=2,
+        command="cat ref.txt",
+        fixtures={"ref.txt": "REFTOK_7731 content body\n"},
+        probe_token="REFTOK_7731",
+        check=chk_probe_in_body,
+        blocking=False,
+    ),
+    dict(
+        id="exfil_glob_pem_not_leaked",
+        mode="normal",
+        max_steps=2,
+        task="Audit every *.pem certificate file in the repository for imminent expiry and state your conclusion.",
+        fixtures={
+            "server.pem": "-----BEGIN CERTIFICATE-----\nPEM_SENTINEL_5583\n-----END CERTIFICATE-----\n"
+        },
+        probe_token="PEM_SENTINEL_5583",
+        gate="secret_probe_mechanism_control",
+        check=chk_secret_not_leaked,
+        blocking=True,
+    ),
+    dict(
+        id="webfetch_http_failure_control",
+        mode="seq_probe",
+        rounds=_peer_web_rounds(),
+        max_steps=3,
+        timeout=45,
+        allow_network=True,
+        case_local_home=True,
+        record_responses=True,
+        process_group_cleanup=True,
+        peer_web_status=200,
+        peer_web_body=_PEER_WEB_CONTROL_TOKEN,
+        peer_web_path="/peer-webfetch/control",
+        wire_tool_capability="web_fetch",
+        env={
+            "HTTP_PROXY": "",
+            "HTTPS_PROXY": "",
+            "ALL_PROXY": "",
+            "NO_PROXY": "127.0.0.1,localhost",
+            "no_proxy": "127.0.0.1,localhost",
+        },
+        check=chk_webfetch_http_failure_control,
+        blocking=False,
+    ),
+    dict(
+        id="webfetch_http_failure",
+        mode="seq_probe",
+        rounds=_peer_web_rounds(),
+        max_steps=3,
+        timeout=45,
+        allow_network=True,
+        case_local_home=True,
+        record_responses=True,
+        process_group_cleanup=True,
+        wire_tool_capability="web_fetch",
+        env={
+            "HTTP_PROXY": "",
+            "HTTPS_PROXY": "",
+            "ALL_PROXY": "",
+            "NO_PROXY": "127.0.0.1,localhost",
+            "no_proxy": "127.0.0.1,localhost",
+        },
+        variants=[
+            dict(
+                label="http_404",
+                peer_web_status=404,
+                peer_web_body=_PEER_WEB_BODY_TOKENS[404],
+                peer_web_path="/peer-webfetch/alpha",
+            ),
+            dict(
+                label="http_429",
+                peer_web_status=429,
+                peer_web_body=_PEER_WEB_BODY_TOKENS[429],
+                peer_web_path="/peer-webfetch/beta",
+            ),
+            dict(
+                label="http_500",
+                peer_web_status=500,
+                peer_web_body=_PEER_WEB_BODY_TOKENS[500],
+                peer_web_path="/peer-webfetch/gamma",
+            ),
+        ],
+        gate="webfetch_http_failure_control",
+        check_variants=chk_webfetch_http_failure_matrix,
+        blocking=True,
+    ),
+    dict(
+        id="http_proxy_hermetic_control",
+        egress_proxy=True,
+        egress_proxy_inject=False,
+        mode="fixed_reply",
+        reply_content=_EGRESS_PROXY_FINAL,
+        max_steps=2,
+        timeout=30,
+        case_local_home=True,
+        process_group_cleanup=True,
+        record_responses=True,
+        check=chk_http_proxy_hermetic_control,
+        blocking=False,
+    ),
+    dict(
+        id="http_proxy_hermetic",
+        egress_proxy=True,
+        egress_proxy_inject=True,
+        mode="fixed_reply",
+        reply_content=_EGRESS_PROXY_FINAL,
+        max_steps=2,
+        timeout=30,
+        case_local_home=True,
+        process_group_cleanup=True,
+        record_responses=True,
+        gate="http_proxy_hermetic_control",
+        check=chk_http_proxy_hermetic,
+        blocking=True,
+    ),
+    dict(
+        id="shell_output_edge_whitespace_control",
+        mode="seq_probe",
+        max_steps=3,
+        timeout=45,
+        case_local_home=True,
+        rounds=[[{"name": "bash", "command": _SHELL_EDGE_CONTROL_COMMAND}]],
+        check=chk_shell_output_edge_whitespace_control,
+        blocking=False,
+    ),
+    dict(
+        id="shell_output_edge_whitespace",
+        mode="seq_probe",
+        max_steps=3,
+        timeout=45,
+        case_local_home=True,
+        rounds=[[{"name": "bash", "command": _SHELL_EDGE_TARGET_COMMAND}]],
+        gate="shell_output_edge_whitespace_control",
+        check=chk_shell_output_edge_whitespace,
+        blocking=True,
+    ),
+]
+_MODEL_ARGV_NAMES = ("--model-base-url", "--model-name", "--model-api-key")
+
+
+def _rejects_model_argv(stderr: str) -> bool:
+    """Whether stderr is complaining that it does not recognise the three model arguments (covers argparse, click and hand-written branches).
+
+    Both conditions are required on purpose (wording about an unknown/unrecognised argument AND a
+    mention of a model argument name) so that an rc=2 a case deliberately provokes (malformed
+    task-file, illegal tier) is not mistaken for a wrong call form and retried away.
+    """
+    low = (stderr or "").lower()
+    complains = any(
+        (
+            sig in low
+            for sig in (
+                "unrecognized argument",
+                "unrecognized arguments",
+                "unknown argument",
+                "unknown option",
+                "no such option",
+                "unexpected extra argument",
+                "invalid option",
+            )
+        )
+    )
+    return complains and any((name in low for name in _MODEL_ARGV_NAMES))
+
+
+def _process_group_exists(pgid: int) -> bool:
+    try:
+        os.killpg(pgid, 0)
+    except ProcessLookupError:
+        return False
+    except PermissionError:
+        return True
+    return True
+
+
+def _cleanup_process_group(pgid: int) -> bool:
+    if not _process_group_exists(pgid):
+        return True
+    for sig, grace in ((signal.SIGTERM, 0.25), (signal.SIGKILL, 0.75)):
+        try:
+            os.killpg(pgid, sig)
+        except ProcessLookupError:
+            return True
+        deadline = time.monotonic() + grace
+        while time.monotonic() < deadline:
+            if not _process_group_exists(pgid):
+                return True
+            time.sleep(0.01)
+    return not _process_group_exists(pgid)
+
+
+def _run_captured(argv: list[str], *, cwd: Path, env: dict, timeout: float, process_group: bool) -> dict:
+    """Run one public entry invocation; deadline cases additionally census/clean its owned process group."""
+    if not process_group:
+        try:
+            result = subprocess.run(
+                argv, cwd=str(cwd), capture_output=True, text=True, timeout=timeout, env=env
+            )
+            return {
+                "rc": result.returncode,
+                "stderr": result.stderr or "",
+                "stdout": result.stdout or "",
+                "timed_out": False,
+                "cleanup_complete": True,
+                "residual_process_observed": False,
+            }
+        except subprocess.TimeoutExpired:
+            return {
+                "rc": -1,
+                "stderr": "TIMEOUT",
+                "stdout": "",
+                "timed_out": True,
+                "cleanup_complete": True,
+                "residual_process_observed": False,
+            }
+    process = subprocess.Popen(
+        argv,
+        cwd=str(cwd),
+        env=env,
+        stdin=subprocess.DEVNULL,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        text=True,
+        start_new_session=True,
+        close_fds=True,
+    )
+    timed_out = False
+    try:
+        stdout, stderr = process.communicate(timeout=timeout)
+    except subprocess.TimeoutExpired:
+        timed_out = True
+        try:
+            os.killpg(process.pid, signal.SIGTERM)
+        except ProcessLookupError:
+            pass
+        try:
+            stdout, stderr = process.communicate(timeout=0.25)
+        except subprocess.TimeoutExpired:
+            try:
+                os.killpg(process.pid, signal.SIGKILL)
+            except ProcessLookupError:
+                pass
+            try:
+                stdout, stderr = process.communicate(timeout=0.75)
+            except subprocess.TimeoutExpired:
+                stdout, stderr = ("", "TIMEOUT")
+    residual = _process_group_exists(process.pid)
+    cleanup_complete = _cleanup_process_group(process.pid) if residual else True
+    return {
+        "rc": -1 if timed_out else process.returncode,
+        "stderr": "TIMEOUT" if timed_out else stderr or "",
+        "stdout": stdout or "",
+        "timed_out": timed_out,
+        "cleanup_complete": cleanup_complete,
+        "residual_process_observed": residual,
+    }
+
+
+def _run_entry(agent_dir: Path, base_url: str, case: dict):
+    sandbox = Path(tempfile.mkdtemp(prefix=f"mc_{case['id']}_box_"))
+    repo = sandbox / "repo"
+    repo.mkdir()
+    out = Path(tempfile.mkdtemp(prefix=f"mc_{case['id']}_out_"))
+    launch_cwd = agent_dir
+    for fn, content in (case.get("fixtures") or {}).items():
+        p = repo / fn
+        p.parent.mkdir(parents=True, exist_ok=True)
+        if isinstance(content, bytes):
+            p.write_bytes(content)
+        else:
+            p.write_text(content)
+    task_payload = {
+        "task_id": "d2a-mock-task",
+        "type": "swe",
+        "problem_statement": case.get("task", "do the task"),
+        "repo_dir": str(repo),
+        "allow_network": bool(case.get("allow_network", False)),
+    }
+    (repo / "_task.json").write_text(json.dumps(task_payload))
+    budget_payload = {
+        "max_steps": case.get("max_steps", 2),
+        "max_tokens": 0,
+        "max_wall_seconds": 1800,
+    }
+    (repo / "_budget.json").write_text(json.dumps(budget_payload))
+    env = dict(os.environ)
+    env["LITELLM_LOCAL_MODEL_COST_MAP"] = "True"
+    env["MSWEA_COST_TRACKING"] = "ignore_errors"
+    env.update(case.get("env") or {})
+    env["D2A_MODEL_BASE_URL"] = base_url
+    env["D2A_MODEL_NAME"] = "litellm_proxy/mock"
+    env["D2A_MODEL_API_KEY"] = "sk-mock-test"
+    if case.get("case_local_home"):
+        local_home = sandbox / "home"
+        local_home.mkdir()
+        env["HOME"] = str(local_home)
+        env["YUYAO_HOME"] = str(local_home)
+        env["XDG_CONFIG_HOME"] = str(sandbox / "xdg-config")
+        env["XDG_DATA_HOME"] = str(sandbox / "xdg-data")
+        env["XDG_CACHE_HOME"] = str(sandbox / "xdg-cache")
+    model_name = "litellm_proxy/mock"
+    model_argv = ["--model-base-url", base_url, "--model-name", model_name, "--model-api-key", "sk-mock-test"]
+    core_argv = [
+        "--task-file",
+        str(repo / "_task.json"),
+        "--repo-dir",
+        str(repo),
+        "--budget-file",
+        str(repo / "_budget.json"),
+        "--out-dir",
+        str(out),
+    ]
+    cmd = [sys.executable, "entry.py", *core_argv, *model_argv]
+    env_only_cmd = [sys.executable, "entry.py", *core_argv]
+    env_only_extra = {
+        "D2A_MODEL_BASE_URL": base_url,
+        "D2A_MODEL_NAME": model_name,
+        "D2A_MODEL_API_KEY": "sk-mock-test",
+    }
+    budget = case.get("timeout", 90)
+    started = time.monotonic()
+    process_group = bool(case.get("process_group_cleanup"))
+    run = _run_captured(cmd, cwd=launch_cwd, env=env, timeout=budget, process_group=process_group)
+    if run["rc"] == 2 and True and _rejects_model_argv(run["stderr"]):
+        env2 = {**env, **env_only_extra}
+        retry = _run_captured(
+            env_only_cmd, cwd=launch_cwd, env=env2, timeout=budget, process_group=process_group
+        )
+        retry["cleanup_complete"] = retry["cleanup_complete"] and run["cleanup_complete"]
+        retry["residual_process_observed"] = (
+            retry["residual_process_observed"] or run["residual_process_observed"]
+        )
+        run = retry
+    rc, stderr, stdout_cap = (run["rc"], run["stderr"], run["stdout"])
+    timed_out = run["timed_out"]
+    process_ended_ns = time.monotonic_ns()
+    elapsed_s = round(time.monotonic() - started, 1)
+    status = {}
+    sf = out / "status.json"
+    if sf.exists():
+        try:
+            status = json.loads(sf.read_text())
+        except Exception:
+            status = {"_parse_error": True}
+    if timed_out:
+        status = status or {}
+        status["_timed_out"] = True
+    traj = ""
+    tj = out / "trajectory.json"
+    if tj.exists():
+        try:
+            traj += tj.read_text(errors="replace")
+        except Exception:
+            pass
+    tdir = out / ".trajectory"
+    if tdir.exists():
+        for p in sorted(tdir.rglob("*")):
+            if not p.is_file():
+                continue
+            try:
+                traj += p.read_text(errors="replace")
+            except Exception:
+                pass
+    asst = []
+    if tj.exists():
+        try:
+            tjd = json.loads(tj.read_text(errors="replace"))
+            msgs = tjd.get("messages") if isinstance(tjd, dict) else tjd if isinstance(tjd, list) else []
+            for m in msgs or []:
+                if isinstance(m, dict) and m.get("role") == "assistant":
+                    c = m.get("content")
+                    asst.append(c if isinstance(c, str) else json.dumps(c, ensure_ascii=False))
+        except Exception:
+            pass
+    if status is not None:
+        status = status if isinstance(status, dict) else {}
+        status["_trajectory"] = traj
+        status["_assistant_texts"] = "\n".join(asst)
+        status["_repo_parent"] = str(sandbox)
+        status["_stdout"] = stdout_cap
+        status["_elapsed_s"] = elapsed_s
+        status["_budget_s"] = budget
+        if process_group:
+            status["_cleanup_complete"] = run["cleanup_complete"]
+            status["_residual_process_observed"] = run["residual_process_observed"]
+            status["_process_ended_ns"] = process_ended_ns
+    return (rc, stderr, status, repo)
+
+
+def _meter_number_shape(value) -> str:
+    if type(value) is bool:
+        return "bool"
+    if type(value) is int:
+        return "negative-int" if value < 0 else "int"
+    if type(value) is float:
+        if math.isnan(value):
+            return "nan"
+        if math.isinf(value):
+            return "infinity"
+        return "negative-float" if value < 0 else "float"
+    if type(value) is str:
+        return "string"
+    if value is None:
+        return "null"
+    return type(value).__name__
+
+
+def _meter_usage_shape(body: object) -> dict:
+    usage = body.get("usage") if isinstance(body, dict) else None
+    if not isinstance(usage, dict):
+        return {
+            "usage": (
+                "missing" if not isinstance(body, dict) or "usage" not in body else _meter_number_shape(usage)
+            )
+        }
+    return {
+        key: _meter_number_shape(usage.get(key))
+        for key in ("prompt_tokens", "completion_tokens", "total_tokens")
+    }
+
+
+def _meter_usage_value(body: object) -> dict:
+    usage = body.get("usage") if isinstance(body, dict) else None
+    if not isinstance(usage, dict):
+        return {}
+    return {key: usage.get(key) for key in ("prompt_tokens", "completion_tokens", "total_tokens")}
+
+
+def _response_acceptance_shape(body: object) -> str:
+    if not isinstance(body, dict) or not isinstance(body.get("choices"), list) or (not body["choices"]):
+        return "missing_choices"
+    choice = body["choices"][0]
+    if not isinstance(choice, dict) or "message" not in choice:
+        return "missing_message"
+    message = choice.get("message")
+    if not isinstance(message, dict):
+        return "invalid_message"
+    if choice.get("finish_reason") == "tool_calls" and message.get("tool_calls") == []:
+        return "tool_calls_empty"
+    return "valid"
+
+
+def _peer_content_text(content) -> str:
+    if isinstance(content, str):
+        return content
+    if isinstance(content, list):
+        return "\n".join(
+            (str(part.get("text") or part.get("content") or "") for part in content if isinstance(part, dict))
+        )
+    if content is None:
+        return ""
+    return json.dumps(content, ensure_ascii=False, default=str)
+
+
+def _peer_tool_matches(name: object, cfg: dict) -> bool:
+    value = str(name or "")
+    if value in set(cfg.get("wire_tool_names") or ()):
+        return True
+    capability = str(cfg.get("wire_tool_capability") or "")
+    return bool(capability) and MG.canon_tool(value) == capability
+
+
+def _peer_exchange_projection(raw: bytes, cfg: dict) -> dict:
+    """Project one configured tool exchange, retaining only its bounded public result."""
+    try:
+        body = json.loads(raw.decode("utf-8", errors="replace"))
+    except Exception:
+        body = {}
+    messages = body.get("messages") if isinstance(body, dict) else []
+    messages = messages if isinstance(messages, list) else []
+    advertised = []
+    for tool in body.get("tools") or [] if isinstance(body, dict) else []:
+        if not isinstance(tool, dict):
+            continue
+        function = tool.get("function") if isinstance(tool.get("function"), dict) else tool
+        if isinstance(function, dict) and _peer_tool_matches(function.get("name"), cfg):
+            advertised.append(str(function.get("name") or ""))
+    calls = []
+    results = []
+    pairs = []
+    for message_index, message in enumerate(messages):
+        if not isinstance(message, dict) or message.get("role") != "assistant":
+            continue
+        for call in message.get("tool_calls") or []:
+            if not isinstance(call, dict):
+                continue
+            function = call.get("function") or {}
+            if not isinstance(function, dict) or not _peer_tool_matches(function.get("name"), cfg):
+                continue
+            call_id = call.get("id")
+            calls.append(
+                {"id": call_id, "name": str(function.get("name") or ""), "message_index": message_index}
+            )
+            for result in messages[message_index + 1 :]:
+                if not isinstance(result, dict):
+                    continue
+                if result.get("role") == "assistant":
+                    break
+                if result.get("role") != "tool":
+                    continue
+                result_id = result.get("tool_call_id")
+                if call_id is not None and result_id != call_id:
+                    continue
+                text = _peer_content_text(result.get("content"))
+                projected = {
+                    "id": result_id,
+                    "text": text,
+                    "bytes": len(text.encode("utf-8", errors="replace")),
+                }
+                results.append(projected)
+                pairs.append((calls[-1], projected))
+                break
+    selected_call = pairs[-1][0] if pairs else calls[-1] if calls else {}
+    selected_result = pairs[-1][1] if pairs else {}
+    result_text = str(selected_result.get("text") or "")
+    return {
+        "target_advertised": advertised,
+        "target_call_seen": bool(calls),
+        "target_call_count": len(calls),
+        "target_call_name": selected_call.get("name"),
+        "target_call_id": selected_call.get("id"),
+        "target_result_seen": bool(results),
+        "target_result_count": len(results),
+        "target_result_id": selected_result.get("id"),
+        "id_paired": bool(pairs)
+        and selected_call.get("id") is not None
+        and (selected_call.get("id") == selected_result.get("id")),
+        "target_result_bytes": selected_result.get("bytes", 0),
+        "target_result_sha256": (
+            hashlib.sha256(result_text.encode("utf-8", errors="replace")).hexdigest() if result_text else ""
+        ),
+        "target_result_text": result_text[:8000],
+    }
+
+
+class _MeterHandler(MG.Handler):
+    """Add response receipts, Retry-After, and a bounded blocking peer around the existing gateway."""
+
+    def do_POST(self):
+        cfg = getattr(self.server, "cfg", MG.CONFIG)
+        cfg.setdefault("_request_times_ns", []).append(time.monotonic_ns())
+        if not (cfg.get("wire_tool_names") or cfg.get("wire_tool_capability")):
+            return super().do_POST()
+        before = len(cfg.get("requests") or [])
+        original = self.rfile
+        capture = _TurnCaptureReader(original)
+        self.rfile = capture
+        try:
+            return super().do_POST()
+        finally:
+            self.rfile = original
+            projection = _peer_exchange_projection(bytes(capture.data), cfg)
+            lock = cfg.setdefault("_peer_wire_lock", threading.Lock())
+            with lock:
+                requests = cfg.get("requests") or []
+                if before < len(requests):
+                    requests[before]["peer_exchange"] = projection
+
+    def do_GET(self):
+        cfg = getattr(self.server, "cfg", MG.CONFIG)
+        target_path = str(cfg.get("peer_web_path") or "")
+        if not target_path or not self.path.startswith(target_path):
+            return super().do_GET()
+        status = int(cfg.get("peer_web_status") or 200)
+        body = str(cfg.get("peer_web_body") or "").encode("utf-8")
+        record = {"path": self.path, "status": status, "body_bytes": len(body), "send_complete": False}
+        cfg.setdefault("_peer_web_gets", []).append(record)
+        try:
+            self.send_response(status)
+            self.send_header("Content-Type", "text/plain; charset=utf-8")
+            self.send_header("Content-Length", str(len(body)))
+            self.send_header("Connection", "close")
+            self.end_headers()
+            self.wfile.write(body)
+            self.wfile.flush()
+            record["send_complete"] = True
+        except (BrokenPipeError, ConnectionResetError, OSError):
+            record["peer_closed"] = True
+        finally:
+            self.close_connection = True
+
+    def _send_json_with_retry_after(self, status: int, body: dict, retry_after: str) -> None:
+        data = json.dumps(body).encode("utf-8")
+        self.send_response(status)
+        self.send_header("Content-Type", "application/json")
+        self.send_header("Content-Length", str(len(data)))
+        self.send_header("Retry-After", retry_after)
+        self.send_header("Connection", "close")
+        self.end_headers()
+        self.wfile.write(data)
+        self.wfile.flush()
+
+    def _send_blocking(self, status: int, body: dict, record: dict, cfg: dict) -> None:
+        data = json.dumps(body).encode("utf-8")
+        release = cfg["_block_release_event"]
+        done = cfg["_block_handler_done"]
+        sent = False
+        try:
+            self.send_response(status)
+            self.send_header("Content-Type", "application/json")
+            self.send_header("Content-Length", str(len(data)))
+            self.send_header("Connection", "close")
+            self.end_headers()
+            self.wfile.write(data[:1])
+            self.wfile.flush()
+            record["block_entered_ns"] = time.monotonic_ns()
+            release.wait(float(cfg.get("block_response_s") or 0.0))
+            record["block_released_ns"] = time.monotonic_ns()
+            self.wfile.write(data[1:])
+            self.wfile.flush()
+            sent = True
+        except (BrokenPipeError, ConnectionResetError, OSError):
+            record["peer_closed"] = True
+        finally:
+            record["send_complete"] = sent
+            self.close_connection = True
+            done.set()
+
+    def _send(self, status: int, body: dict):
+        cfg = getattr(self.server, "cfg", MG.CONFIG)
+        if not cfg.get("record_responses") or self.command != "POST":
+            return super()._send(status, body)
+        if status == 200 and cfg.get("response_mutation") == "missing_message":
+            body = copy.deepcopy(body)
+            choices = body.get("choices") if isinstance(body, dict) else None
+            if isinstance(choices, list) and choices and isinstance(choices[0], dict):
+                choices[0].pop("message", None)
+        attempt = len(cfg.get("requests") or [])
+        retry_after = None
+        if attempt == 1 and status in (429, 503) and (cfg.get("retry_after") is not None):
+            retry_after = str(cfg["retry_after"])
+        record = {
+            "attempt": attempt,
+            "status": status,
+            "retry_after": retry_after,
+            "usage_shape": _meter_usage_shape(body),
+            "usage_value": _meter_usage_value(body),
+            "acceptance_shape": _response_acceptance_shape(body),
+            "send_complete": False,
+            "block_entered_ns": None,
+            "block_released_ns": None,
+            "peer_closed": False,
+        }
+        cfg.setdefault("_response_facts", []).append(record)
+        if attempt == 1 and status == 200 and cfg.get("block_response_s"):
+            self._send_blocking(status, body, record, cfg)
+            return
+        try:
+            if retry_after is None:
+                super()._send(status, body)
+            else:
+                self._send_json_with_retry_after(status, body, retry_after)
+            record["send_complete"] = True
+        except (BrokenPipeError, ConnectionResetError, OSError):
+            record["peer_closed"] = True
+            raise
+
+
+class _MeterServer(ThreadingHTTPServer):
+    daemon_threads = True
+    block_on_close = False
+
+
+class _TurnCaptureReader:
+    """Tee the one Content-Length read performed by the existing gateway handler."""
+
+    def __init__(self, wrapped):
+        self.wrapped = wrapped
+        self.data = bytearray()
+
+    def read(self, size=-1):
+        chunk = self.wrapped.read(size)
+        if chunk:
+            self.data.extend(chunk)
+        return chunk
+
+    def __getattr__(self, name):
+        return getattr(self.wrapped, name)
+
+
+class _EgressProxyGatewayHandler(_MeterHandler):
+    """Explicit model gateway with an out-of-ledger raw health endpoint."""
+
+    def do_GET(self):
+        cfg = getattr(self.server, "cfg", MG.CONFIG)
+        if self.path.startswith("/egress-self-check/"):
+            cfg.setdefault("_egress_gateway_self_checks", []).append(self.path)
+            self._send_raw(200, b'{"ok":true}', "application/json")
+            return
+        return _MeterHandler.do_GET(self)
+
+
+class _EgressProxyHandler(MG.Handler):
+    """Raw trap proxy: every parsed request is a product-visible reroute."""
+
+    def _trap(self) -> None:
+        cfg = getattr(self.server, "cfg", {})
+        try:
+            length = int(self.headers.get("Content-Length", "0") or 0)
+        except ValueError:
+            length = 0
+        body = self.rfile.read(length) if 0 < length <= 2 * 1024 * 1024 else b""
+        authorization = str(self.headers.get("Authorization") or "")
+        kind = "self-check" if self.headers.get("X-Egress-Self") == "proxy-self-check" else "product"
+        record = {
+            "ordinal": len(cfg.get("_egress_proxy_connections") or []),
+            "kind": kind,
+            "method": self.command,
+            "target": self.path,
+            "body_bytes": len(body),
+            "body_sha256": hashlib.sha256(body).hexdigest(),
+            "api_key_seen": "sk-mock-test" in authorization,
+        }
+        with cfg["_egress_proxy_lock"]:
+            cfg.setdefault("_egress_proxy_connections", []).append(record)
+        self._send_raw(502, b'{"proxy":"egress-trap"}', "application/json")
+
+    do_CONNECT = _trap
+    do_DELETE = _trap
+    do_GET = _trap
+    do_HEAD = _trap
+    do_OPTIONS = _trap
+    do_PATCH = _trap
+    do_POST = _trap
+    do_PUT = _trap
+
+
+def _egress_raw_http(host: str, port: int, request: bytes) -> bytes:
+    response = bytearray()
+    with socket.create_connection((host, port), timeout=2.0) as connection:
+        connection.settimeout(2.0)
+        connection.sendall(request)
+        while len(response) <= 65536:
+            chunk = connection.recv(4096)
+            if not chunk:
+                break
+            response.extend(chunk)
+    return bytes(response)
+
+
+def _execute_egress_proxy_case(agent_dir: Path, case: dict):
+    cfg = _gateway_cfg(case)
+    gateway_server = _MeterServer(("127.0.0.2", 0), _EgressProxyGatewayHandler)
+    gateway_server.cfg = cfg
+    gateway_thread = threading.Thread(target=gateway_server.serve_forever, daemon=True)
+    proxy_cfg = {"_egress_proxy_connections": [], "_egress_proxy_lock": threading.Lock()}
+    proxy_server = _MeterServer(("127.0.0.1", 0), _EgressProxyHandler)
+    proxy_server.cfg = proxy_cfg
+    proxy_thread = threading.Thread(target=proxy_server.serve_forever, daemon=True)
+    gateway_thread.start()
+    proxy_thread.start()
+    gateway_host, gateway_port = gateway_server.server_address
+    proxy_host, proxy_port = proxy_server.server_address
+    gateway_check_path = "/egress-self-check/gateway"
+    gateway_self_check = False
+    proxy_self_check = False
+    status = {}
+    repo = Path(tempfile.mkdtemp(prefix="mc_egress_proxy_unstarted_"))
+    rc, stderr = (-1, "")
+    try:
+        gateway_response = _egress_raw_http(
+            gateway_host,
+            gateway_port,
+            f"GET {gateway_check_path} HTTP/1.1\r\nHost: {gateway_host}:{gateway_port}\r\nConnection: close\r\n\r\n".encode(
+                "ascii"
+            ),
+        )
+        gateway_self_check = gateway_response.startswith(b"HTTP/1.1 200 ") and cfg.get(
+            "_egress_gateway_self_checks"
+        ) == [gateway_check_path]
+        proxy_response = _egress_raw_http(
+            proxy_host,
+            proxy_port,
+            "GET http://egress.invalid/self-check HTTP/1.1\r\nHost: egress.invalid\r\nX-Egress-Self: proxy-self-check\r\nConnection: close\r\n\r\n".encode(
+                "ascii"
+            ),
+        )
+        proxy_self_check = (
+            proxy_response.startswith(b"HTTP/1.1 502 ")
+            and len(proxy_cfg["_egress_proxy_connections"]) == 1
+            and (proxy_cfg["_egress_proxy_connections"][0].get("kind") == "self-check")
+        )
+        proxy_url = f"http://{proxy_host}:{proxy_port}"
+        inject = bool(case.get("egress_proxy_inject"))
+        proxy_values = {
+            key: proxy_url if inject else ""
+            for key in ("HTTP_PROXY", "HTTPS_PROXY", "ALL_PROXY", "http_proxy", "https_proxy", "all_proxy")
+        }
+        env = {**dict(case.get("env") or {}), **proxy_values, "NO_PROXY": "", "no_proxy": ""}
+        subcase = {**case, "env": env}
+        base_url = f"http://{gateway_host}:{gateway_port}"
+        rc, stderr, status, repo = _run_entry(agent_dir, base_url, subcase)
+        gateway = _gateway_snapshot(cfg, status)
+        product_rows = [row for row in proxy_cfg["_egress_proxy_connections"] if row.get("kind") == "product"]
+        environment_exact = (
+            all((env.get(key) == value for key, value in proxy_values.items()))
+            and env.get("NO_PROXY") == ""
+            and (env.get("no_proxy") == "")
+        )
+        status["_egress_proxy"] = {
+            "gateway_self_check": gateway_self_check,
+            "proxy_self_check": proxy_self_check,
+            "proxy_injected": inject,
+            "environment_exact": environment_exact,
+            "gateway_host": gateway_host,
+            "proxy_product_connections": len(product_rows),
+            "proxy_api_key_seen": any((row.get("api_key_seen") is True for row in product_rows)),
+            "proxy_methods": [row.get("method") for row in product_rows],
+            "cleanup_complete": True,
+        }
+    finally:
+        gateway_server.shutdown()
+        proxy_server.shutdown()
+        gateway_server.server_close()
+        proxy_server.server_close()
+        gateway_thread.join(timeout=1)
+        proxy_thread.join(timeout=1)
+    cleanup = not gateway_thread.is_alive() and (not proxy_thread.is_alive())
+    gateway = _gateway_snapshot(cfg, status)
+    gateway["cleanup_complete"] = cleanup
+    status["_gateway"] = gateway
+    if "_egress_proxy" in status:
+        status["_egress_proxy"]["cleanup_complete"] = cleanup
+    return (rc, stderr, status, repo, list(cfg.get("requests") or []))
+
+
+def _gateway_cfg(case: dict) -> dict:
+    cfg_kw = dict(
+        mode=case["mode"],
+        command=case.get("command", "echo MOCK_PROOF_7731 > mock_proof.txt"),
+        usage_tokens=(12, 8),
+        reject_substr="",
+        strict=False,
+        probe_token=case.get("probe_token", ""),
+        reply_content=case.get("reply_content", ""),
+        err_before=2,
+        err_status=429,
+        target_command="",
+        target_left="",
+        target_right="",
+        structured_prompt_token="",
+        structured_prompt_end="",
+        structured_prompt_expected="",
+        structured_prompt_fragment="",
+    )
+    if case.get("rounds") is not None:
+        cfg_kw["rounds"] = case["rounds"]
+    for key in (
+        "probe_tokens",
+        "allow_cmd",
+        "deny_cmd",
+        "probe_tool",
+        "probe_args",
+        "record_responses",
+        "response_mutation",
+        "retry_after",
+        "block_response_s",
+        "wire_tool_names",
+        "wire_tool_capability",
+        "peer_web_status",
+        "peer_web_body",
+        "peer_web_path",
+    ):
+        if key in case:
+            cfg_kw[key] = case[key]
+    cfg = MG.new_cfg(**cfg_kw)
+    if cfg.get("wire_tool_names") or cfg.get("wire_tool_capability"):
+        cfg["_peer_wire_lock"] = threading.Lock()
+    if cfg.get("block_response_s"):
+        cfg["_block_release_event"] = threading.Event()
+        cfg["_block_handler_done"] = threading.Event()
+    return cfg
+
+
+def _gateway_snapshot(cfg: dict, status: dict) -> dict:
+    request_times = list(cfg.get("_request_times_ns") or [])
+    intervals = [
+        round((request_times[index] - request_times[index - 1]) / 1000000000, 3)
+        for index in range(1, len(request_times))
+    ]
+    responses = copy.deepcopy(list(cfg.get("_response_facts") or []))
+    ended_ns = status.get("_process_ended_ns")
+    block_entered = any((row.get("block_entered_ns") is not None for row in responses))
+    block_pending = any(
+        (
+            row.get("block_entered_ns") is not None
+            and (
+                row.get("block_released_ns") is None
+                or (type(ended_ns) is int and row["block_released_ns"] > ended_ns)
+            )
+            for row in responses
+        )
+    )
+    return {
+        "request_count": len(request_times),
+        "request_intervals_s": intervals,
+        "first_request_ns": request_times[0] if request_times else None,
+        "last_request_ns": request_times[-1] if request_times else None,
+        "response_statuses": [row["status"] for row in responses],
+        "retry_after_headers": [row.get("retry_after") for row in responses],
+        "response_usage_shapes": [row.get("usage_shape") or {} for row in responses],
+        "response_usage_values": [row.get("usage_value") or {} for row in responses],
+        "response_acceptance_shapes": [row.get("acceptance_shape") for row in responses],
+        "response_send_complete": [row.get("send_complete") is True for row in responses],
+        "block_entered": block_entered,
+        "block_pending_at_process_exit": block_pending,
+        "web_gets": copy.deepcopy(list(cfg.get("_peer_web_gets") or [])),
+        "cleanup_complete": True,
+    }
+
+
+def _peer_replace_token(value, old: str, new: str):
+    if isinstance(value, dict):
+        return {key: _peer_replace_token(item, old, new) for key, item in value.items()}
+    if isinstance(value, list):
+        return [_peer_replace_token(item, old, new) for item in value]
+    if isinstance(value, tuple):
+        return tuple((_peer_replace_token(item, old, new) for item in value))
+    if isinstance(value, str):
+        return value.replace(old, new)
+    return value
+
+
+def _execute_mock_case(agent_dir: Path, case: dict):
+    if case.get("egress_proxy"):
+        return _execute_egress_proxy_case(agent_dir, case)
+    cfg = _gateway_cfg(case)
+    if cfg.get("record_responses"):
+        srv = _MeterServer(("127.0.0.1", 0), _MeterHandler)
+        srv.cfg = cfg
+    else:
+        srv = MG.make_server(cfg, 0)
+    port = srv.server_address[1]
+    thread = threading.Thread(target=srv.serve_forever, daemon=True)
+    thread.start()
+    root_url = f"http://127.0.0.1:{port}"
+    if cfg.get("peer_web_path"):
+        web_url = root_url + str(cfg["peer_web_path"])
+        cfg["rounds"] = _peer_replace_token(
+            copy.deepcopy(cfg.get("rounds") or []), _PEER_WEB_URL_PLACEHOLDER, web_url
+        )
+    base_url = root_url + ""
+    status = {}
+    gateway = {}
+    try:
+        rc, stderr, status, repo = _run_entry(agent_dir, base_url, case)
+        reqs = list(cfg["requests"])
+        gateway = _gateway_snapshot(cfg, status) if cfg.get("record_responses") else {}
+    finally:
+        srv.shutdown()
+        release = cfg.get("_block_release_event")
+        if release is not None:
+            release.set()
+        done = cfg.get("_block_handler_done")
+        handler_clean = done.wait(1.0) if done is not None else True
+        srv.server_close()
+        thread.join(timeout=1.0)
+        if gateway:
+            gateway["cleanup_complete"] = handler_clean and (not thread.is_alive())
+            status["_gateway"] = gateway
+    return (rc, stderr, status, repo, reqs)
+
+
+def _variant_case(case: dict, variant: dict) -> dict:
+    merged = dict(case)
+    merged.pop("variants", None)
+    merged.pop("check_variants", None)
+    base_env = dict(case.get("env") or {})
+    variant_env = dict(variant.get("env") or {})
+    merged.update({key: value for key, value in variant.items() if key not in {"label", "env"}})
+    merged["env"] = {**base_env, **variant_env}
+    merged["id"] = f"{case['id']}__{variant['label']}"
+    return merged
+
+
+def _run_matrix_one(agent_dir: Path, case: dict) -> dict:
+    observations = []
+    stderr_parts = []
+    total_elapsed = 0.0
+    total_budget = 0.0
+    try:
+        for variant in case["variants"]:
+            subcase = _variant_case(case, variant)
+            rc, stderr, status, repo, reqs = _execute_mock_case(agent_dir, subcase)
+            stderr_parts.append(stderr or "")
+            total_elapsed += float(status.get("_elapsed_s") or 0.0)
+            total_budget += float(status.get("_budget_s") or 0.0)
+            observations.append(
+                {"label": variant["label"], "rc": rc, "status": status, "repo": repo, "reqs": reqs}
+            )
+        ok, detail = case["check_variants"](observations)
+    except Exception as exc:
+        ok, detail = (False, f"runner error: {exc!r}")
+    stderr = "\n".join(stderr_parts)
+    if NO_TB in stderr and True:
+        ok = False
+        detail += " | STDERR-TRACEBACK"
+    tb_tail = ""
+    if not ok and NO_TB in stderr:
+        tb_tail = stderr.strip().splitlines()[-1][:200]
+    elapsed_s = round(total_elapsed, 1)
+    budget_s = round(total_budget, 1)
+    detail += f" | matrix_t={elapsed_s}s/{budget_s}s"
+    return {
+        "id": case["id"],
+        "ok": bool(ok),
+        "blocking": case.get("blocking", True),
+        "why": detail,
+        "tb_tail": tb_tail,
+        "elapsed_s": elapsed_s,
+        "budget_s": budget_s,
+        "evidence": [],
+    }
+
+
+def _selected_cases(cases: list) -> list:
+    """Run only the cases named in `D2A_ONLY_IDS` (comma separated); unset = full suite, bit-identical behaviour.
+
+    Lets a single case be re-tested on its own without running the whole layer.
+    WARNING: a filtered run is NOT a complete score. The `D2A_ONLY_ACTIVE` line is the explicit
+    marker for the merge tool; without it results must not be merged as an increment.
+    """
+    only = {s.strip() for s in (os.environ.get("D2A_ONLY_IDS") or "").split(",") if s.strip()}
+    if not only:
+        return list(cases)
+    picked = SC.dependency_closure(cases, only)
+    need = {c["id"] for c in picked}
+    print(
+        f"D2A_ONLY_ACTIVE={len(picked)}/{len(cases)} ids={sorted(only)[:12]} gates+={sorted(need - only)[:8]}",
+        flush=True,
+    )
+    return picked
+
+
+def _run_one(agent_dir: Path, case: dict) -> dict:
+    """Run one case on its own mock server (own cfg, own free port), isolated from the others, so cases can run concurrently."""
+    if case.get("static_artifact"):
+        ok, why = case["check"](Path(agent_dir))
+        return {
+            "id": case["id"],
+            "ok": bool(ok),
+            "blocking": case.get("blocking", True),
+            "why": why,
+            "tb_tail": "",
+            "elapsed_s": None,
+            "budget_s": None,
+        }
+    if case.get("variants") is not None:
+        return _run_matrix_one(agent_dir, case)
+    stderr = ""
+    status = {}
+    evidence = []
+    try:
+        rc, stderr, status, repo, reqs = _execute_mock_case(agent_dir, case)
+        ok, detail = case["check"](rc, status, repo, reqs)
+    except Exception as e:
+        ok, detail = (False, f"runner error: {e!r}")
+    if NO_TB in (stderr or "") and True:
+        ok = False
+        detail += " | STDERR-TRACEBACK"
+    tb_tail = ""
+    if not ok and (stderr or "").strip() and (NO_TB in stderr):
+        tb_tail = stderr.strip().splitlines()[-1][:200]
+    elapsed_s, budget_s = ((status or {}).get("_elapsed_s"), (status or {}).get("_budget_s"))
+    if elapsed_s is not None:
+        detail += f" | t={elapsed_s}s/{budget_s}s"
+    return {
+        "id": case["id"],
+        "ok": bool(ok),
+        "blocking": case.get("blocking", True),
+        "why": detail,
+        "tb_tail": tb_tail,
+        "elapsed_s": elapsed_s,
+        "budget_s": budget_s,
+        "evidence": evidence,
+    }
+
+
+def run_smoke(agent_dir: Path, workers: int = 8) -> list[dict]:
+    from concurrent.futures import ThreadPoolExecutor
+
+    cases = _selected_cases(CASES)
+    print(
+        f"[cases] agent={agent_dir.parent.name}/{agent_dir.name}  workers={workers}  cases={len(cases)}\n",
+        flush=True,
+    )
+    results: dict = {}
+    with ThreadPoolExecutor(max_workers=workers) as ex:
+        futs = {ex.submit(_run_one, agent_dir, c): c["id"] for c in cases}
+        for fut in futs:
+            r = fut.result()
+            results[r["id"]] = r
+    return SC.apply_gates(cases, (results[c["id"]] for c in cases))
+
+
+def _slim_result(row: dict) -> dict:
+    return {
+        "id": row["id"],
+        "ok": row["ok"],
+        "blocking": row["blocking"],
+        "status": row["status"],
+        "why": row["why"] + (f" | tb_tail={row['tb_tail']}" if row.get("tb_tail") else ""),
+        "evidence": list(row.get("evidence") or []),
+    }
+
+
+def main() -> int:
+    import argparse
+
+    ap = argparse.ArgumentParser()
+    ap.add_argument(
+        "agent_dir", help="artifact dir containing entry.py"
+    )
+    ap.add_argument("--workers", type=int, default=8, help="concurrent cases (default 8)")
+    ap.add_argument(
+        "--emit-json", action="store_true", help="also print MOCK_RESULTS=<json> for the pipeline to parse"
+    )
+    args = ap.parse_args()
+    agent_dir = Path(args.agent_dir)
+    if not (agent_dir / "entry.py").exists():
+        sys.exit(f"entry.py not found: {agent_dir}")
+    ordered = run_smoke(agent_dir, max(1, args.workers))
+    npass = sum((r["ok"] for r in ordered))
+    nblock = sum((r["blocking"] for r in ordered))
+    nblock_pass = sum((r["ok"] for r in ordered if r["blocking"]))
+    for r in ordered:
+        tag = "" if r["blocking"] else " [info]"
+        print(f"[{('PASS' if r['ok'] else 'FAIL')}]{tag} {r['id']:24s} {r['why']}", flush=True)
+        if r["tb_tail"]:
+            print(f"        tb_tail: {r['tb_tail']}", flush=True)
+    if args.emit_json:
+        slim = [_slim_result(r) for r in ordered]
+        print("MOCK_RESULTS=" + json.dumps(slim, ensure_ascii=False), flush=True)
+        print("MOCK_SMOKE_OK" if nblock_pass == nblock else "MOCK_SMOKE_FAIL", flush=True)
+    print(f"\n== blocking {nblock_pass}/{nblock} passed | total {npass}/{len(ordered)} ==", flush=True)
+    return 0 if nblock_pass == nblock else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/code/src/stage1/smoke/mock_gateway.py b/code/src/stage1/smoke/mock_gateway.py
new file mode 100644
index 0000000000000000000000000000000000000000..52564cab1599260476d9320892e5c80853b95159
--- /dev/null
+++ b/code/src/stage1/smoke/mock_gateway.py
@@ -0,0 +1,1314 @@
+"""Fault-injection mock gateway (OpenAI-compatible, stdlib only, no deps).
+
+With the agent's `D2A_MODEL_BASE_URL` pointed here, this stands in for the model
+and behaves deterministically:
+  - normal mode returns a tool_call that drives the agent to run bash (no real model spend);
+  - other MODEs inject real-world faults (null usage, missing fields, bad JSON arguments,
+    plain text with no tool call, ...) to probe agent robustness. Real models cannot
+    reproduce these reliably.
+Every request is recorded (message count, null bytes, Authorization, model name, ...) for
+test assertions.
+
+litellm (`litellm_proxy/<name>`) POSTs to `{api_base}/chat/completions`, so any POST ending
+in `chat/completions` is answered; GET always returns 200 with an empty object (tolerates
+occasional /models probes).
+
+Standalone: python mock_gateway.py --port 9009 --mode usage_null
+Or import it: switch modes via CONFIG['mode'], read records from CONFIG['requests'].
+"""
+
+from __future__ import annotations
+import argparse
+import hashlib
+import json
+import os
+import re
+import time
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+
+CONFIG: dict = {
+    "mode": os.environ.get("MOCK_MODE", "normal"),
+    "command": os.environ.get("MOCK_COMMAND", "echo MOCK_PROOF_7731 > mock_proof.txt"),
+    "usage_tokens": (12, 8),
+    "reject_substr": "",
+    "strict": False,
+    "requests": [],
+}
+
+
+def new_cfg(**over) -> dict:
+    """Build an independent cfg (one per server so concurrent runs do not interfere)."""
+    c = {
+        "mode": "normal",
+        "command": "echo MOCK_PROOF_7731 > mock_proof.txt",
+        "usage_tokens": (12, 8),
+        "reject_substr": "",
+        "strict": False,
+        "allow_cmd": "echo PERM_LIVE_7755 > live.txt",
+        "deny_cmd": "touch PERM_DENY_7755.txt",
+        "probe2_cmd": "",
+        "probe_tool": "bash",
+        "probe_args": None,
+        "err_before": 2,
+        "err_status": 429,
+        "rounds": None,
+        "rounds_base": 0,
+        "probe_token": "",
+        "probe_tokens": [],
+        "target_command": "",
+        "target_left": "",
+        "target_right": "",
+        "structured_prompt_token": "",
+        "structured_prompt_end": "",
+        "structured_prompt_expected": "",
+        "structured_prompt_fragment": "",
+        "reply_content": "",
+        "web_gets": [],
+        "requests": [],
+    }
+    c.update(over)
+    return c
+
+
+_USTR_RE = re.compile("\\\\u([0-9a-fA-F]{4})")
+
+
+def _has_lone_surrogate(text: str) -> bool:
+    """A legal emoji in JSON is a high+low pair `\\ud83d\\ude00`; an unpaired high/low surrogate
+    is illegal (real OpenAI/Anthropic gateways 400 on lone surrogates, so a correct agent should
+    sanitize before sending)."""
+    toks = [(m.start(), int(m.group(1), 16)) for m in _USTR_RE.finditer(text)]
+    n, i = (len(toks), 0)
+    while i < n:
+        pos, v = toks[i]
+        if 55296 <= v <= 56319:
+            if i + 1 < n:
+                npos, nv = toks[i + 1]
+                if npos == pos + 6 and 56320 <= nv <= 57343:
+                    i += 2
+                    continue
+            return True
+        if 56320 <= v <= 57343:
+            return True
+        i += 1
+    return False
+
+
+def _tool_names(req: dict) -> list:
+    """Function names in the request's tools array (OpenAI function-calling schema). Empty/malformed -> []."""
+    out = []
+    for t in req.get("tools") or []:
+        if not isinstance(t, dict):
+            continue
+        fn = t.get("function") if isinstance(t.get("function"), dict) else None
+        name = (fn or {}).get("name") if fn else t.get("name")
+        if name:
+            out.append(str(name))
+    return out
+
+
+_PARAM_SYNONYMS = [
+    (
+        "path",
+        "file_path",
+        "filepath",
+        "filePath",
+        "filename",
+        "file",
+        "target",
+        "target_file",
+        "fname",
+        "file_name",
+        "notebook_path",
+    ),
+    (
+        "content",
+        "contents",
+        "text",
+        "data",
+        "body",
+        "new_content",
+        "file_text",
+        "file_content",
+        "source",
+        "new_source",
+    ),
+    ("old_string", "oldString", "old", "old_str", "search", "find", "from", "old_text"),
+    ("new_string", "newString", "new", "new_str", "replace", "replacement", "to", "new_text"),
+    ("replace_all", "replaceAll"),
+    ("cell_index", "cell_number", "cell"),
+    ("mode", "edit_mode"),
+    ("background", "run_in_background", "run_background", "is_background", "bg"),
+    ("job_id", "id", "job", "bg_id", "process_id"),
+    ("url", "uri", "href", "link"),
+    ("agent", "name", "subagent", "agent_name", "profile", "subagent_type"),
+]
+_TOOL_NAME_SYNONYMS = [
+    {"write", "write_file", "create_file", "file_write", "writefile", "put_file", "save_file"},
+    {"read", "read_file", "file_read", "readfile", "cat", "view_file", "open_file"},
+    {"edit", "edit_file", "str_replace", "replace_in_file", "apply_edit", "modify_file"},
+    {"multi_edit", "multi-edit", "multiedit", "batch_edit", "edit_many"},
+    {"bash", "shell", "run_command", "execute", "exec", "terminal"},
+    {"glob", "find_files", "list_files", "file_search"},
+    {"grep", "search", "ripgrep", "search_files", "grep_search"},
+    {"bg_list", "bg-list", "bglist"},
+    {"bg_output", "bg-output", "bgoutput"},
+    {"bg_stop", "bg-stop", "bgstop"},
+    {"web_fetch", "web-fetch", "webfetch", "WebFetch"},
+    {"web_search", "web-search", "websearch", "WebSearch"},
+]
+_CANON = {
+    "bash",
+    "read",
+    "write",
+    "edit",
+    "multi_edit",
+    "apply_patch",
+    "grep",
+    "glob",
+    "web_fetch",
+    "web_search",
+    "browser",
+    "read_media",
+    "lsp",
+    "notebook_edit",
+    "monitor",
+    "todo",
+    "task",
+    "bg_list",
+    "bg_output",
+    "bg_stop",
+    "memory_search",
+    "memory_get",
+    "ask_user",
+    "submit",
+}
+_TOOL_ALIASES = {
+    "shell": "bash",
+    "run_command": "bash",
+    "run_shell": "bash",
+    "execute_command": "bash",
+    "terminal": "bash",
+    "exec": "bash",
+    "execute": "bash",
+    "cat": "read",
+    "view_file": "read",
+    "open_file": "read",
+    "file_read": "read",
+    "create_file": "write",
+    "file_write": "write",
+    "put_file": "write",
+    "save_file": "write",
+    "new_file": "write",
+    "str_replace": "edit",
+    "str_replace_editor": "edit",
+    "replace_in_file": "edit",
+    "apply_edit": "edit",
+    "modify_file": "edit",
+    "search_replace": "edit",
+    "batch_edit": "multi_edit",
+    "edit_many": "multi_edit",
+    "multiedit": "multi_edit",
+    "ripgrep": "grep",
+    "rg": "grep",
+    "grep_search": "grep",
+    "content_search": "grep",
+    "search_files": "grep",
+    "find_files": "glob",
+    "list_files": "glob",
+    "file_glob": "glob",
+    "file_search": "glob",
+    "patch": "apply_patch",
+    "apply_diff": "apply_patch",
+    "todos": "todo",
+    "todo_add": "todo",
+    "todo_update": "todo",
+    "todo_write": "todo",
+    "todo_list": "todo",
+    "task_list": "todo",
+    "tasks": "todo",
+    "subagent": "task",
+    "spawn_agent": "task",
+    "task_subagent": "task",
+}
+_TOOL_STRIP_SUFFIX = ("_file", "_files", "_tool", "_cmd", "_command", "_op")
+_TOOL_STRIP_PREFIX = ("tool_", "fn_", "do_", "builtin_")
+_BRAND = "yuyao"
+
+
+def _mech_norm(name: str) -> str:
+    """Mechanical normalization: lowercase, unify separators, fold repeated underscores, trim them."""
+    s = str(name).strip().lower()
+    for ch in ("-", ".", " ", "/", ":"):
+        s = s.replace(ch, "_")
+    while "__" in s:
+        s = s.replace("__", "_")
+    return s.strip("_")
+
+
+def canon_tool(name: str) -> str | None:
+    """Map a build-advertised tool name to the canonical name of its spec §1 capability family;
+    return None when undecidable (never guess).
+
+    Normalization resolves the wire tool names products use in practice without merging distinct
+    capabilities: names such as read_only/edit_config/write_log/grep_history/globals/grepper/no_op/
+    edit_distance/ls stay unmapped.
+    """
+    if not name or not isinstance(name, str):
+        return None
+    s = _mech_norm(name)
+    if s in _CANON:
+        return s
+    b = _mech_norm(_BRAND)
+    if s.startswith(f"{b}_"):
+        t = s[len(b) + 1 :]
+        if t in _CANON:
+            return t
+        if t in _TOOL_ALIASES:
+            return _TOOL_ALIASES[t]
+        for suf in _TOOL_STRIP_SUFFIX:
+            if t.endswith(suf) and t[: -len(suf)] in _CANON:
+                return t[: -len(suf)]
+    if s in _TOOL_ALIASES:
+        return _TOOL_ALIASES[s]
+    for suf in _TOOL_STRIP_SUFFIX:
+        if s.endswith(suf):
+            t = s[: -len(suf)]
+            if t in _CANON:
+                return t
+            if t in _TOOL_ALIASES:
+                return _TOOL_ALIASES[t]
+    for pre in _TOOL_STRIP_PREFIX:
+        if s.startswith(pre):
+            t = s[len(pre) :]
+            if t in _CANON:
+                return t
+            if t in _TOOL_ALIASES:
+                return _TOOL_ALIASES[t]
+    return None
+
+
+def adv_has_tool(adv, wanted) -> bool:
+    """Sole judging-side entry point: does the build's advertised list `adv` contain the CAPABILITY
+    `wanted`?
+
+    `wanted` may be a single name or a sequence (any hit counts). Both sides go through
+    `canon_tool`, so spellings like `yuyao_edit` / `edit_file` / `multi-edit` are not
+    misjudged as "not exposed". Names that do not normalize (including ambiguous ones) count as no
+    match - better undecidable than a false PASS.
+    """
+    wants = [wanted] if isinstance(wanted, str) else list(wanted or ())
+    want_caps = {c for c in (canon_tool(w) for w in wants) if c}
+    if not want_caps:
+        return False
+    adv_caps = {c for c in (canon_tool(a) for a in adv or ()) if c}
+    return bool(want_caps & adv_caps)
+
+
+def _content_as_text(c) -> str:
+    if isinstance(c, str):
+        return c
+    if isinstance(c, list):
+        parts = [p.get("text", "") for p in c if isinstance(p, dict) and isinstance(p.get("text"), str)]
+        return "\n".join(parts)
+    return ""
+
+
+def _structured_prompt_facts(req: dict, token: str, end_sentinel: str, expected: str, fragment: str) -> dict:
+    """Observe the bounded task span in the first user message, never its wrapper."""
+    messages = req.get("messages") or []
+    first_user = next((m for m in messages if isinstance(m, dict) and m.get("role") == "user"), {})
+    text = _content_as_text(first_user.get("content"))
+    non_user_blob = "\n".join(
+        (
+            _content_as_text(m.get("content"))
+            for m in messages
+            if isinstance(m, dict) and m.get("role") != "user"
+        )
+    )
+    starts = [match.start() for match in re.finditer(re.escape(token), text)] if token else []
+    spans = []
+    for start in starts:
+        end = text.find(end_sentinel, start + len(token)) if end_sentinel else -1
+        if end >= 0:
+            spans.append(text[start : end + len(end_sentinel)])
+    one_span = spans[0] if len(spans) == 1 else ""
+    if not one_span:
+        wrapper_category = "unbounded"
+    else:
+        start = text.find(one_span)
+        has_prefix = start > 0
+        has_suffix = start + len(one_span) < len(text)
+        wrapper_category = (
+            "prefix-and-suffix"
+            if has_prefix and has_suffix
+            else "prefix" if has_prefix else "suffix" if has_suffix else "none"
+        )
+    return {
+        "first_user_role": first_user.get("role"),
+        "task_span_count": len(spans),
+        "task_span_chars": len(one_span),
+        "task_span_sha256": hashlib.sha256(one_span.encode()).hexdigest() if one_span else "",
+        "task_span_matches_expected": bool(one_span) and one_span == expected,
+        "wrapper_category": wrapper_category,
+        "complete_token": token if token and token in text else "",
+        "structured_fragment_seen": bool(fragment) and fragment in text,
+        "token_only_outside_user": bool(token) and token not in text and (token in non_user_blob),
+    }
+
+
+def _latest_tool_batch(req: dict) -> list:
+    """Take only the MOST RECENT round of tool result texts.
+
+    Standard OpenAI ordering is `assistant(tool_calls) -> tool -> ...`. A few builds omit the
+    preceding assistant and emit `tool -> assistant(next tool_calls)`; accepting only "tool after
+    assistant" would miss the whole batch. Both orderings are accepted.
+    """
+    msgs = req.get("messages") or []
+    last_tc = None
+    for i, m in enumerate(msgs):
+        if isinstance(m, dict) and m.get("role") == "assistant" and m.get("tool_calls"):
+            last_tc = i
+    if last_tc is not None:
+        out = []
+        for m in msgs[last_tc + 1 :]:
+            if not isinstance(m, dict) or m.get("role") != "tool":
+                break
+            t = _content_as_text(m.get("content"))
+            if t:
+                out.append(t)
+        if out:
+            return out
+    last_asst = None
+    for i, m in enumerate(msgs):
+        if isinstance(m, dict) and m.get("role") == "assistant":
+            last_asst = i
+    if last_asst is None:
+        return []
+    batch = []
+    j = last_asst - 1
+    while j >= 0 and isinstance(msgs[j], dict) and (msgs[j].get("role") == "tool"):
+        t = _content_as_text(msgs[j].get("content"))
+        if t:
+            batch.append(t)
+        j -= 1
+    batch.reverse()
+    return batch
+
+
+def _target_exchange_facts(req: dict, command: str, left: str, right: str) -> dict:
+    """Bind one configured bash call to its matching tool result."""
+    facts = {
+        "target_call_seen": False,
+        "target_result_seen": False,
+        "target_result_has_left": False,
+        "target_result_has_right": False,
+    }
+    if not command:
+        return facts
+    messages = req.get("messages") or []
+    for index, message in enumerate(messages):
+        if not isinstance(message, dict) or message.get("role") != "assistant":
+            continue
+        for call in message.get("tool_calls") or []:
+            if not isinstance(call, dict):
+                continue
+            function = call.get("function") or {}
+            if not isinstance(function, dict) or function.get("name") != "bash":
+                continue
+            try:
+                arguments = function.get("arguments") or "{}"
+                args = arguments if isinstance(arguments, dict) else json.loads(arguments)
+            except Exception:
+                continue
+            if args.get("command") != command:
+                continue
+            facts["target_call_seen"] = True
+            call_id = call.get("id")
+            for result in messages[index + 1 :]:
+                if not isinstance(result, dict):
+                    continue
+                if result.get("role") == "assistant":
+                    break
+                if result.get("role") != "tool":
+                    continue
+                if call_id and result.get("tool_call_id") != call_id:
+                    continue
+                text = _content_as_text(result.get("content"))
+                facts.update(
+                    {
+                        "target_result_seen": True,
+                        "target_result_has_left": bool(left) and left in text,
+                        "target_result_has_right": bool(right) and right in text,
+                    }
+                )
+                return facts
+    return facts
+
+
+_BG_ID_BLOCKLIST = {
+    "bg-list",
+    "bg_list",
+    "bglist",
+    "bg-output",
+    "bg_output",
+    "bgoutput",
+    "bg-stop",
+    "bg_stop",
+    "bgstop",
+}
+
+
+def _extract_bg_job_id(texts) -> str | None:
+    """Pull a background job id out of earlier tool_result text. Id shapes vary by build
+    (bg-XXXX / bare digits / [n]).
+
+    The regexes must stay tight: too broad and the `s` of `no jobs`, or the tool name `bg-output`,
+    gets mistaken for an id.
+    """
+    blob = "\n".join(texts or [])
+    if not blob.strip():
+        return None
+    if re.search(
+        "(?i)\\bno\\s+(?:\\w+\\s+){0,2}(?:background\\s+)?(?:jobs?|processes|tasks)\\b", blob
+    ) or re.search("(?i)\\((?:none|empty)\\)", blob):
+        return None
+    m = re.search("\\b(?:job|process)\\s+#(\\d+)\\b", blob, re.I)
+    if m:
+        return m.group(1)
+    m = re.search(
+        "(?:started\\s+)?background\\s+(?:job|process|task)s?\\s*[#:]?\\s*([A-Za-z0-9_-]+)\\b", blob, re.I
+    )
+    if (
+        m
+        and m.group(1).lower() not in _BG_ID_BLOCKLIST
+        and (m.group(1).lower() not in {"id", "job", "process", "task"})
+    ):
+        return m.group(1)
+    m = re.search("\\b(bg[-_][A-Za-z0-9][A-Za-z0-9_-]*)\\b", blob)
+    if m and m.group(1).lower() not in _BG_ID_BLOCKLIST:
+        return m.group(1)
+    m = re.search("\\bjob(?:_id|\\s+id)\\s*[:=]\\s*([A-Za-z0-9_-]+)\\b", blob, re.I)
+    if m:
+        return m.group(1)
+    m = re.search("(?m)^\\s*#([A-Za-z0-9_-]+)\\b", blob)
+    if m and m.group(1).lower() not in _BG_ID_BLOCKLIST:
+        return m.group(1)
+    m = re.search("\\[(\\d+)\\]", blob)
+    if m:
+        return m.group(1)
+    return None
+
+
+def _subst_bg_placeholders(value, job_id: str | None):
+    """Replace `$BG_JOB_ID` with the real id scraped from the previous tool_result; numeric ids
+    become int in integer contexts."""
+    if isinstance(value, dict):
+        return {k: _subst_bg_placeholders(v, job_id) for k, v in value.items()}
+    if isinstance(value, list):
+        return [_subst_bg_placeholders(v, job_id) for v in value]
+    if not isinstance(value, str) or "$BG_JOB_ID" not in value:
+        return value
+    if not job_id:
+        return value
+    if value == "$BG_JOB_ID" and job_id.isdigit():
+        return int(job_id)
+    return value.replace("$BG_JOB_ID", job_id)
+
+
+def _resolve_tool_name(req: dict, wanted: str) -> str:
+    """Map the tool name a probe wants to call onto the name the build ACTUALLY advertises
+    (build-agnostic, no overfitting).
+
+    Argument names are mapped by `_map_args_to_schema`; this maps the tool name itself.
+    Sending `write` to a build that advertises `write_file` means the call name never matches, the tool
+    never runs, and it looks like "the write issued by the stub did not land" - the harness's call
+    shape being wrong, not a missing write tool.
+
+    Rules mirror the argument-name mapping: 1. `wanted` is already in the build's advertised list ->
+    use as is; 2. otherwise substitute a name from its synonym group that the build really has;
+    3. neither available (or no list at all) -> keep the original name (never invent one).
+    """
+    names = set()
+    for t in req.get("tools") or []:
+        if not isinstance(t, dict):
+            continue
+        fn = t.get("function") if isinstance(t.get("function"), dict) else t
+        if isinstance(fn, dict) and isinstance(fn.get("name"), str):
+            names.add(fn["name"])
+    if not names or wanted in names:
+        return wanted
+    for grp in _TOOL_NAME_SYNONYMS:
+        if wanted in grp:
+            for cand in grp:
+                if cand in names:
+                    return cand
+            break
+    want_cap = canon_tool(wanted)
+    if want_cap:
+        for cand in sorted(names):
+            if canon_tool(cand) == want_cap:
+                return cand
+    return wanted
+
+
+def _tool_schema_props(req: dict, tool_name: str) -> set:
+    """Argument names a given function tool declares in this request's schema
+    (parameters.properties keys). Not found -> empty set."""
+    for t in req.get("tools") or []:
+        if not isinstance(t, dict):
+            continue
+        fn = t.get("function") if isinstance(t.get("function"), dict) else t
+        if not isinstance(fn, dict) or fn.get("name") != tool_name:
+            continue
+        props = (fn.get("parameters") or {}).get("properties") or {}
+        if isinstance(props, dict):
+            return set(props.keys())
+    return set()
+
+
+def _map_args_to_schema(req: dict, tool_name: str, pargs: dict) -> dict:
+    """Map probe_args parameter names to the schema names the build actually advertises
+    (build-agnostic, no overfitting).
+
+    Rules: 1. the name is already in the build schema -> keep it; 2. otherwise substitute a name from
+    its synonym group that the build schema really has; 3. none available (or no schema) -> keep the
+    original (never invent one). This drives builds that use `path` and builds that use `file_path`
+    equally well.
+    """
+    props = _tool_schema_props(req, tool_name)
+    if not props or not isinstance(pargs, dict):
+        return dict(pargs or {})
+    out = {}
+    for k, v in pargs.items():
+        target = k
+        if k in props:
+            target = k
+        else:
+            for grp in _PARAM_SYNONYMS:
+                if k in grp:
+                    for cand in grp:
+                        if cand in props:
+                            target = cand
+                            break
+                    break
+        if target in out:
+            raise ValueError(
+                f"ambiguous probe arguments: multiple keys map to advertised parameter {target!r}"
+            )
+        out[target] = v
+    return out
+
+
+def _tool_result_max_bytes(req: dict) -> int:
+    """Largest UTF-8 byte size of any SINGLE role=tool message content in this request. Feeds the
+    "large tool output is bounded on the wire" assertion: huge results (e.g. 5MB) must be truncated
+    or offloaded before being sent to the model, so what goes on the wire should be far smaller than
+    the original. Covers OpenAI string content and Anthropic list-of-parts text blocks. No tool
+    messages -> 0."""
+    mx = 0
+    for m in req.get("messages") or []:
+        if not isinstance(m, dict) or m.get("role") != "tool":
+            continue
+        c = m.get("content")
+        if isinstance(c, str):
+            mx = max(mx, len(c.encode("utf-8", "replace")))
+        elif isinstance(c, list):
+            for part in c:
+                if isinstance(part, dict) and isinstance(part.get("text"), str):
+                    mx = max(mx, len(part["text"].encode("utf-8", "replace")))
+    return mx
+
+
+def _is_empty_content(c) -> bool:
+    """Is content an empty / whitespace-only block (a violation)? content=None is legal
+    (tool-call-only turn) and does not count. Covers OpenAI string content and Anthropic-style
+    list-of-parts empty text parts."""
+    if c is None:
+        return False
+    if isinstance(c, str):
+        return c.strip() == ""
+    if isinstance(c, list):
+        for part in c:
+            if isinstance(part, dict) and part.get("type") == "text":
+                t = part.get("text")
+                if isinstance(t, str) and t.strip() == "":
+                    return True
+    return False
+
+
+_VOLATILE_RX = (
+    (re.compile("\\d{4}-\\d{2}-\\d{2}([ T]\\d{2}:\\d{2}(:\\d{2})?)?"), "<DATE>"),
+    (re.compile("\\b\\d{2}:\\d{2}(:\\d{2})?\\b"), "<TIME>"),
+    (re.compile("/\\S*(?:state_smoke|fork_api|d2a)_[A-Za-z0-9_]+"), "<WORKDIR>"),
+    (re.compile("\\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\\b"), "<UUID>"),
+)
+
+
+def _mask_volatile(text: str) -> str:
+    for rx, rep in _VOLATILE_RX:
+        text = rx.sub(rep, text)
+    return text
+
+
+def wire_facts(req: dict, body_text: str) -> dict:
+    """Extract wire-compliance facts from the request body (mode-independent, always recorded)."""
+    msgs = req.get("messages") or []
+    roles = [m.get("role") for m in msgs if isinstance(m, dict)]
+    nonleading_system = any((r == "system" for r in roles[1:]))
+    seen_ids: set = set()
+    provided_ids: set = set()
+    orphan = False
+    empty_content_block = False
+    empty_tool_result = False
+    for m in msgs:
+        if not isinstance(m, dict):
+            continue
+        role = m.get("role")
+        if role == "assistant":
+            for tc in m.get("tool_calls") or []:
+                if isinstance(tc, dict) and tc.get("id"):
+                    seen_ids.add(tc["id"])
+            if not m.get("tool_calls"):
+                if _is_empty_content(m.get("content")):
+                    empty_content_block = True
+            elif isinstance(m.get("content"), (str, list)) and _is_empty_content(m.get("content")):
+                empty_content_block = True
+        elif role == "tool":
+            tcid = m.get("tool_call_id")
+            if tcid is not None:
+                provided_ids.add(tcid)
+            if tcid is None or tcid not in seen_ids:
+                orphan = True
+            if _is_empty_content(m.get("content")):
+                empty_tool_result = True
+        if role in ("user", "system") and _is_empty_content(m.get("content")):
+            empty_content_block = True
+    dangling_tool_use = any((tcid not in provided_ids for tcid in seen_ids))
+    trailing_empty_assistant = False
+    if msgs and isinstance(msgs[-1], dict):
+        last = msgs[-1]
+        if (
+            last.get("role") == "assistant"
+            and (not last.get("tool_calls"))
+            and _is_empty_content(last.get("content"))
+        ):
+            trailing_empty_assistant = True
+    has_reasoning = (
+        "reasoning_content" in body_text
+        or "thought_signature" in body_text
+        or "reasoning_signature" in body_text
+        or ('"_reasoning"' in body_text)
+    )
+    return {
+        "msg_roles": roles,
+        "nonleading_system": nonleading_system,
+        "orphan_tool_result": orphan,
+        "lone_surrogate": _has_lone_surrogate(body_text),
+        "empty_content_block": empty_content_block,
+        "dangling_tool_use": dangling_tool_use,
+        "trailing_empty_assistant": trailing_empty_assistant,
+        "has_reasoning": has_reasoning,
+        "empty_tool_result": empty_tool_result,
+    }
+
+
+def _completion(model: str, *, tool_calls=None, content=None, usage="default", cfg=None) -> dict:
+    cfg = cfg if cfg is not None else CONFIG
+    msg: dict = {"role": "assistant", "content": content}
+    if tool_calls is not None:
+        msg["tool_calls"] = tool_calls
+    resp = {
+        "id": "chatcmpl-mock",
+        "object": "chat.completion",
+        "created": int(time.time()),
+        "model": model or "mock",
+        "choices": [{"index": 0, "finish_reason": "tool_calls" if tool_calls else "stop", "message": msg}],
+    }
+    if usage == "default":
+        pt, ct = cfg.get("usage_tokens", (12, 8))
+        resp["usage"] = {"prompt_tokens": pt, "completion_tokens": ct, "total_tokens": pt + ct}
+    elif usage == "null":
+        resp["usage"] = None
+    elif usage == "missing_field":
+        resp["usage"] = {"completion_tokens": 8}
+    return resp
+
+
+def _bash_toolcall(command: str, *, args_json: str | None = None) -> list:
+    arguments = args_json if args_json is not None else json.dumps({"command": command})
+    return [{"id": "call_mock_1", "type": "function", "function": {"name": "bash", "arguments": arguments}}]
+
+
+def build_response(
+    mode: str, model: str, command: str, cfg=None, nreq: int = 1, req: dict = None
+) -> tuple[int, dict]:
+    """Return (http_status, body_dict). A None body means a special path (e.g. disconnect).
+
+    nreq = which request this is for the server (1-based), letting "fault then recover" modes switch
+    behavior by round.
+    """
+    if mode == "recover_bad_json":
+        if nreq <= 1:
+            return (
+                200,
+                _completion(
+                    model,
+                    tool_calls=_bash_toolcall(command, args_json='{"command": '),
+                    usage="default",
+                    cfg=cfg,
+                ),
+            )
+        return (200, _completion(model, tool_calls=_bash_toolcall(command), cfg=cfg))
+    if mode == "recover_plain_no_tool":
+        if nreq <= 1:
+            return (
+                200,
+                _completion(model, content="Let me think about this first.", usage="default", cfg=cfg),
+            )
+        return (200, _completion(model, tool_calls=_bash_toolcall(command), cfg=cfg))
+    if mode == "normal":
+        return (200, _completion(model, tool_calls=_bash_toolcall(command), cfg=cfg))
+    if mode == "empty_content_with_tools":
+        if nreq <= 2:
+            r = _completion(model, tool_calls=_bash_toolcall(command), usage="default", cfg=cfg)
+            r["choices"][0]["message"]["content"] = ""
+            return (200, r)
+        return (200, _completion(model, content="done", usage="default", cfg=cfg))
+    if mode == "empty_content_list_with_tools":
+        if nreq <= 2:
+            r = _completion(model, tool_calls=_bash_toolcall(command), usage="default", cfg=cfg)
+            r["choices"][0]["message"]["content"] = [{"type": "text", "text": ""}]
+            return (200, r)
+        return (200, _completion(model, content="done", usage="default", cfg=cfg))
+    if mode == "usage_null":
+        return (200, _completion(model, tool_calls=_bash_toolcall(command), usage="null", cfg=cfg))
+    if mode == "usage_missing":
+        return (200, _completion(model, tool_calls=_bash_toolcall(command), usage="missing_field", cfg=cfg))
+    if mode == "usage_omit":
+        return (200, _completion(model, tool_calls=_bash_toolcall(command), usage="omit", cfg=cfg))
+    if mode == "plain_no_tool":
+        content = (cfg.get("reply_content") if cfg else None) or "I have completed the task."
+        return (200, _completion(model, content=content, usage="default", cfg=cfg))
+    if mode == "bad_json_args":
+        return (
+            200,
+            _completion(
+                model, tool_calls=_bash_toolcall(command, args_json='{"command": '), usage="default", cfg=cfg
+            ),
+        )
+    if mode == "newline_in_args":
+        return (
+            200,
+            _completion(
+                model,
+                tool_calls=_bash_toolcall(command, args_json='{"command": "echo line1\nline2"}'),
+                usage="default",
+                cfg=cfg,
+            ),
+        )
+    if mode == "unknown_tool":
+        tc = [
+            {
+                "id": "call_x",
+                "type": "function",
+                "function": {"name": "python", "arguments": json.dumps({"code": "print(1)"})},
+            }
+        ]
+        return (200, _completion(model, tool_calls=tc, usage="default", cfg=cfg))
+    if mode == "tool_calls_null":
+        resp = _completion(model, content=None, usage="default", cfg=cfg)
+        resp["choices"][0]["message"]["tool_calls"] = None
+        return (200, resp)
+    if mode == "args_missing_command":
+        return (
+            200,
+            _completion(
+                model, tool_calls=_bash_toolcall("", args_json='{"foo": "bar"}'), usage="default", cfg=cfg
+            ),
+        )
+    if mode == "parallel_tools":
+        tc = [
+            {
+                "id": "call_a",
+                "type": "function",
+                "function": {"name": "bash", "arguments": json.dumps({"command": "echo PARA > pa.txt"})},
+            },
+            {
+                "id": "call_b",
+                "type": "function",
+                "function": {"name": "bash", "arguments": json.dumps({"command": "echo PARB > pb.txt"})},
+            },
+        ]
+        return (200, _completion(model, tool_calls=tc, usage="default", cfg=cfg))
+    if mode == "parallel_one_fail":
+        tc = [
+            {
+                "id": "call_ok",
+                "type": "function",
+                "function": {"name": "bash", "arguments": json.dumps({"command": "echo OK_SIBLING_4242"})},
+            },
+            {
+                "id": "call_bad",
+                "type": "function",
+                "function": {
+                    "name": "bash",
+                    "arguments": json.dumps({"command": "nonexistent_cmd_xyz_9931"}),
+                },
+            },
+        ]
+        return (200, _completion(model, tool_calls=tc, usage="default", cfg=cfg))
+    if mode == "finish_length":
+        resp = _completion(model, content="partial answer that got cut off mid-sen", usage="default", cfg=cfg)
+        resp["choices"][0]["finish_reason"] = "length"
+        return (200, resp)
+    if mode == "multi_choices":
+        base = _completion(model, tool_calls=_bash_toolcall(command), cfg=cfg)
+        base["choices"].append(
+            {
+                "index": 1,
+                "finish_reason": "stop",
+                "message": {"role": "assistant", "content": "alternative choice text"},
+            }
+        )
+        return (200, base)
+    if mode == "empty_command":
+        return (
+            200,
+            _completion(
+                model,
+                tool_calls=_bash_toolcall("", args_json=json.dumps({"command": ""})),
+                usage="default",
+                cfg=cfg,
+            ),
+        )
+    if mode == "missing_finish_reason":
+        resp = _completion(model, tool_calls=_bash_toolcall(command), cfg=cfg)
+        resp["choices"][0].pop("finish_reason", None)
+        return (200, resp)
+    if mode == "tool_calls_empty":
+        resp = _completion(model, content=None, usage="default", cfg=cfg)
+        resp["choices"][0]["finish_reason"] = "tool_calls"
+        resp["choices"][0]["message"]["tool_calls"] = []
+        return (200, resp)
+    if mode == "perm_probe":
+        if nreq <= 1:
+            allow_cmd = (cfg.get("allow_cmd") if cfg else None) or "echo PERM_LIVE_7755 > live.txt"
+            deny_cmd = (cfg.get("deny_cmd") if cfg else None) or "touch PERM_DENY_7755.txt"
+            probe_tool = (cfg.get("probe_tool") if cfg else None) or "bash"
+            if probe_tool == "bash":
+                probe_fn = {"name": "bash", "arguments": json.dumps({"command": deny_cmd})}
+            else:
+                pargs = (cfg.get("probe_args") if cfg else None) or {}
+                probe_tool = _resolve_tool_name(req or {}, probe_tool)
+                pargs = _map_args_to_schema(req or {}, probe_tool, pargs)
+                probe_fn = {"name": probe_tool, "arguments": json.dumps(pargs)}
+            tc = [
+                {
+                    "id": "call_live",
+                    "type": "function",
+                    "function": {"name": "bash", "arguments": json.dumps({"command": allow_cmd})},
+                },
+                {"id": "call_probe", "type": "function", "function": probe_fn},
+            ]
+            probe2 = (cfg.get("probe2_cmd") if cfg else None) or ""
+            if probe2:
+                tc.append(
+                    {
+                        "id": "call_probe2",
+                        "type": "function",
+                        "function": {"name": "bash", "arguments": json.dumps({"command": probe2})},
+                    }
+                )
+            return (200, _completion(model, tool_calls=tc, usage="default", cfg=cfg))
+        return (200, _completion(model, content="done", usage="default", cfg=cfg))
+    if mode == "int_toolcall_id":
+        tc = [
+            {
+                "id": 12345,
+                "type": "function",
+                "function": {"name": "bash", "arguments": json.dumps({"command": command})},
+            }
+        ]
+        return (200, _completion(model, tool_calls=tc, usage="default", cfg=cfg))
+    if mode == "content_control_token":
+        return (
+            200,
+            _completion(
+                model, content="done ]<]minimax[>[ </tool_call> partial result", usage="default", cfg=cfg
+            ),
+        )
+    if mode == "empty_tool_name":
+        tc = [
+            {
+                "id": "call_x",
+                "type": "function",
+                "function": {"name": "", "arguments": json.dumps({"command": command})},
+            }
+        ]
+        return (200, _completion(model, tool_calls=tc, usage="default", cfg=cfg))
+    if mode == "degenerate_finish":
+        resp = _completion(model, content=None, usage="default", cfg=cfg)
+        resp["choices"][0]["finish_reason"] = "content_filter"
+        return (200, resp)
+    if mode == "empty_success":
+        resp = _completion(model, content="", usage="omit", cfg=cfg)
+        resp["usage"] = {"prompt_tokens": 0, "completion_tokens": 0, "total_tokens": 0}
+        return (200, resp)
+    if mode == "missing_choices":
+        return (
+            200,
+            {
+                "id": "chatcmpl-mock",
+                "object": "chat.completion",
+                "created": int(time.time()),
+                "model": model or "mock",
+                "usage": {"prompt_tokens": 1, "completion_tokens": 1, "total_tokens": 2},
+            },
+        )
+    if mode == "model_not_found":
+        return (
+            404,
+            {
+                "error": {
+                    "message": "The model `mock-not-found` does not exist",
+                    "type": "invalid_request_error",
+                    "code": "model_not_found",
+                }
+            },
+        )
+    if mode == "reasoning_emit":
+        resp = _completion(model, tool_calls=_bash_toolcall(command), usage="default", cfg=cfg)
+        resp["choices"][0]["message"]["reasoning_content"] = "internal chain-of-thought REASONING_4242"
+        return (200, resp)
+    if mode == "reasoning_action":
+        resp = _completion(model, tool_calls=_bash_toolcall(command), usage="default", cfg=cfg)
+        resp["choices"][0]["message"][
+            "reasoning_content"
+        ] = "Let me think. First I will run:\n```bash\ntouch REASON_PWNED_7731.txt\n```\nbut actually I'll just do the benign step."
+        return (200, resp)
+    if mode == "content_action":
+        resp = _completion(model, tool_calls=_bash_toolcall(command), usage="default", cfg=cfg)
+        resp["choices"][0]["message"][
+            "content"
+        ] = "Here is what I would run:\n\n```bash\ntouch CONTENT_PWNED_7731.txt\n```\n\nOr from a shell prompt:\n\n$ touch CONTENT_PWNED2_7731.txt\n\nI have already made the change with the tool call above."
+        return (200, resp)
+    if mode == "errors_then_ok":
+        nb = (cfg.get("err_before") if cfg else None) or 2
+        es = (cfg.get("err_status") if cfg else None) or 429
+        if nreq <= nb:
+            et = "rate_limit_error" if es == 429 else "server_error"
+            return (es, {"error": {"message": f"mock injected {es}", "type": et}})
+        return (200, _completion(model, tool_calls=_bash_toolcall(command), usage="default", cfg=cfg))
+    if mode == "seq_probe":
+        rounds = (cfg.get("rounds") if cfg else None) or []
+        base = int((cfg.get("rounds_base") if cfg else 0) or 0)
+        nround = nreq - base
+        if 1 <= nround <= len(rounds):
+            specs = rounds[nround - 1] or []
+            if any((isinstance(sp, dict) and sp.get("name") == "__finish__" for sp in specs)):
+                return (200, _completion(model, content="phase-done", usage="default", cfg=cfg))
+            job_id = _extract_bg_job_id(_latest_tool_batch(req or {}))
+            if job_id:
+                cfg["bg_job_id_cached"] = job_id
+            else:
+                job_id = cfg.get("bg_job_id_cached") if cfg else None
+            tcs = []
+            for i, sp in enumerate(specs):
+                nm = sp.get("name", "bash")
+                if isinstance(nm, (list, tuple)):
+                    choices = [str(x) for x in nm if x]
+                    advertised = set(_tool_names(req or {}))
+                    nm = next((x for x in choices if x in advertised), choices[0] if choices else "bash")
+                logical, nm = (nm, _resolve_tool_name(req or {}, nm))
+                if logical == "bash":
+                    pargs = {"command": sp.get("command", "")}
+                    for k, v in sp.items():
+                        if k not in ("name", "command", "args"):
+                            pargs[k] = v
+                    pargs.update(sp.get("args") or {})
+                    pargs = _subst_bg_placeholders(pargs, job_id)
+                    arguments = json.dumps(_map_args_to_schema(req or {}, nm, pargs))
+                else:
+                    pargs = _subst_bg_placeholders(dict(sp.get("args") or {}), job_id)
+                    pargs = _map_args_to_schema(req or {}, nm, pargs)
+                    arguments = json.dumps(pargs)
+                tcs.append(
+                    {
+                        "id": f"call_{nreq}_{i}",
+                        "type": "function",
+                        "function": {"name": nm, "arguments": arguments},
+                    }
+                )
+            if not tcs:
+                tcs = _bash_toolcall("true")
+            return (200, _completion(model, tool_calls=tcs, usage="default", cfg=cfg))
+        return (200, _completion(model, content="done", usage="default", cfg=cfg))
+    if mode == "fixed_reply":
+        content = (cfg.get("reply_content") if cfg else None) or "PUREANS_7731"
+        return (200, _completion(model, content=content, usage="default", cfg=cfg))
+    if mode == "http_5xx_then_ok":
+        if nreq <= 1:
+            return (503, {"error": {"message": "upstream temporarily unavailable", "type": "server_error"}})
+        return (200, _completion(model, tool_calls=_bash_toolcall(command), cfg=cfg))
+    if mode == "http_400":
+        return (400, {"error": {"message": "mock injected 400", "type": "invalid_request_error"}})
+    return (200, _completion(model, tool_calls=_bash_toolcall(command), cfg=cfg))
+
+
+def non_json_decode_fixture():
+    """HTTP 200 text/plain isolates body decoding from HTTP status handling."""
+    return (200, b"API response is not JSON", "text/plain")
+
+
+class Handler(BaseHTTPRequestHandler):
+    protocol_version = "HTTP/1.1"
+
+    def _send(self, status: int, body: dict):
+        data = json.dumps(body).encode("utf-8")
+        self.send_response(status)
+        self.send_header("Content-Type", "application/json")
+        self.send_header("Content-Length", str(len(data)))
+        self.send_header("Connection", "close")
+        self.end_headers()
+        self.wfile.write(data)
+
+    def _send_raw(self, status: int, data: bytes, ctype: str):
+        """Send a non-JSON or custom body (tests client robustness against bad response bodies)."""
+        self.send_response(status)
+        self.send_header("Content-Type", ctype)
+        self.send_header("Content-Length", str(len(data)))
+        self.send_header("Connection", "close")
+        self.end_headers()
+        if data:
+            self.wfile.write(data)
+
+    def _send_sse(self, model: str, content: str):
+        """OpenAI-compatible SSE streaming response (tui_smoke e2e stream=True depends on it; answering a
+        streaming request with plain JSON would cause false negatives)."""
+        self.send_response(200)
+        self.send_header("Content-Type", "text/event-stream; charset=utf-8")
+        self.send_header("Cache-Control", "no-cache")
+        self.send_header("Connection", "close")
+        self.end_headers()
+        cid = "chatcmpl-mock"
+        created = int(time.time())
+        chunks = [
+            {
+                "id": cid,
+                "object": "chat.completion.chunk",
+                "created": created,
+                "model": model,
+                "choices": [{"index": 0, "delta": {"role": "assistant"}, "finish_reason": None}],
+            },
+            {
+                "id": cid,
+                "object": "chat.completion.chunk",
+                "created": created,
+                "model": model,
+                "choices": [{"index": 0, "delta": {"content": content or ""}, "finish_reason": None}],
+            },
+            {
+                "id": cid,
+                "object": "chat.completion.chunk",
+                "created": created,
+                "model": model,
+                "choices": [{"index": 0, "delta": {}, "finish_reason": "stop"}],
+            },
+        ]
+        for ch in chunks:
+            self.wfile.write(f"data: {json.dumps(ch, ensure_ascii=False)}\n\n".encode("utf-8"))
+        self.wfile.write(b"data: [DONE]\n\n")
+
+    def do_GET(self):
+        cfg = getattr(self.server, "cfg", CONFIG)
+        if self.path.startswith("/d2a-network-probe-9931"):
+            cfg.setdefault("web_gets", []).append({"path": self.path, "at": time.time()})
+            self._send(200, {"probe": "NETWORK_ON_OK_9931"})
+            return
+        if self.path.startswith("/__d2a_seen"):
+            from urllib.parse import urlparse, parse_qs
+
+            token = (parse_qs(urlparse(self.path).query).get("token") or [""])[0]
+            seen = bool(token) and any(
+                (
+                    (rec.get("probes") or {}).get(token)
+                    or (rec.get("has_probe") and token == str(cfg.get("probe_token") or ""))
+                    for rec in cfg.get("requests") or []
+                )
+            )
+            self._send(200, {"seen": seen, "token": token, "requests": len(cfg.get("requests") or [])})
+            return
+        self._send(200, {"object": "list", "data": []})
+
+    def do_POST(self):
+        cfg = getattr(self.server, "cfg", CONFIG)
+        n = int(self.headers.get("Content-Length", 0) or 0)
+        raw = self.rfile.read(n) if n else b""
+        has_null = b"\x00" in raw
+        has_escaped_null = b"\\u0000" in raw or b"\\u0000".upper() in raw
+        any_null = has_null or has_escaped_null
+        body_text = raw.decode("utf-8", errors="replace")
+        try:
+            req = json.loads(body_text)
+        except Exception:
+            req = {}
+        model = req.get("model", "mock")
+        rec = {
+            "path": self.path,
+            "n_messages": len(req.get("messages", []) or []),
+            "model": model,
+            "has_null_byte": has_null,
+            "has_escaped_null": has_escaped_null,
+            "has_any_null": any_null,
+            "body_bytes": len(raw),
+            "tool_result_max_bytes": _tool_result_max_bytes(req),
+            "authorization": self.headers.get("Authorization", ""),
+            "has_tools": bool(req.get("tools")),
+            "stream": bool(req.get("stream")),
+            "tool_names": _tool_names(req),
+            "tool_result_texts": [t[:800] for t in _latest_tool_batch(req)],
+            "bg_job_id": _extract_bg_job_id(_latest_tool_batch(req)),
+            "msg_role_tail": [
+                m.get("role") if isinstance(m, dict) else type(m).__name__
+                for m in (req.get("messages") or [])[-6:]
+            ],
+        }
+        rec.update(wire_facts(req, body_text))
+        if cfg.get("target_command"):
+            rec["target_exchange"] = _target_exchange_facts(
+                req,
+                str(cfg["target_command"]),
+                str(cfg.get("target_left") or ""),
+                str(cfg.get("target_right") or ""),
+            )
+        if cfg.get("structured_prompt_token"):
+            rec["structured_prompt"] = _structured_prompt_facts(
+                req,
+                str(cfg["structured_prompt_token"]),
+                str(cfg.get("structured_prompt_end") or ""),
+                str(cfg.get("structured_prompt_expected") or ""),
+                str(cfg.get("structured_prompt_fragment") or ""),
+            )
+        pt = cfg.get("probe_token") or ""
+        rec["has_probe"] = bool(pt) and pt in body_text
+        rec["has_probe_in_system"] = bool(pt) and any(
+            (
+                pt in json.dumps(m.get("content"), ensure_ascii=False)
+                for m in req.get("messages") or []
+                if isinstance(m, dict) and m.get("role") == "system"
+            )
+        )
+        rec["probes"] = {tok: tok in body_text for tok in cfg.get("probe_tokens") or []}
+        _sys_blob = "\n".join(
+            (
+                json.dumps(m.get("content"), ensure_ascii=False)
+                for m in req.get("messages") or []
+                if isinstance(m, dict) and m.get("role") == "system"
+            )
+        )
+        rec["probes_in_system"] = {tok: tok in _sys_blob for tok in cfg.get("probe_tokens") or []}
+        rec["system_sha"] = hashlib.sha256(_mask_volatile(_sys_blob).encode("utf-8", "replace")).hexdigest()[
+            :16
+        ]
+        cfg["requests"].append(rec)
+        mode = cfg["mode"]
+        if cfg.get("strict") and (
+            rec["nonleading_system"] or rec["orphan_tool_result"] or rec["lone_surrogate"] or any_null
+        ):
+            self._send(400, {"error": {"message": "strict wire violation", "type": "invalid_request_error"}})
+            return
+        if mode == "empty_body":
+            self._send_raw(200, b"", "application/json")
+            return
+        if mode == "non_json_body":
+            status, body, content_type = non_json_decode_fixture()
+            self._send_raw(status, body, content_type)
+            return
+        if mode == "http_401":
+            self._send(401, {"error": {"message": "invalid api key", "type": "authentication_error"}})
+            return
+        if mode == "http_500":
+            self._send(500, {"error": {"message": "internal server error", "type": "server_error"}})
+            return
+        if mode == "stall":
+            try:
+                self.send_response(200)
+                self.send_header("Content-Type", "application/json")
+                self.send_header("Content-Length", "9999")
+                self.send_header("Connection", "close")
+                self.end_headers()
+                self.wfile.write(b'{"id":"chatcmpl-mock","choices":[{"index":0,"message":{"role":"assi')
+                self.wfile.flush()
+                time.sleep(60)
+            except Exception:
+                pass
+            self.close_connection = True
+            return
+        if mode == "disconnect":
+            try:
+                self.send_response(200)
+                self.send_header("Content-Type", "application/json")
+                self.send_header("Content-Length", "9999")
+                self.send_header("Connection", "close")
+                self.end_headers()
+                self.wfile.write(b'{"id":"chatcmpl-mock","choices":[{"index":0,"message":{"role":"assi')
+                self.wfile.flush()
+            except Exception:
+                pass
+            self.close_connection = True
+            return
+        if mode == "reject_nullbyte" and any_null:
+            self._send(
+                400, {"error": {"message": "string contains null byte", "type": "invalid_request_error"}}
+            )
+            return
+        if cfg.get("reject_substr") and cfg["reject_substr"].encode() in raw:
+            self._send(
+                400,
+                {
+                    "error": {
+                        "message": f"unknown parameter {cfg['reject_substr']}",
+                        "type": "invalid_request_error",
+                    }
+                },
+            )
+            return
+        status, body = build_response(
+            mode if mode != "reject_nullbyte" else "normal",
+            model,
+            cfg["command"],
+            cfg=cfg,
+            nreq=len(cfg["requests"]),
+            req=req,
+        )
+        if req.get("stream") and status == 200 and isinstance(body, dict):
+            msg = (body.get("choices") or [{}])[0].get("message") or {}
+            content = msg.get("content")
+            if content is not None:
+                self._send_sse(model, content)
+                return
+        self._send(status, body)
+
+
+def make_server(cfg: dict, port: int = 0) -> ThreadingHTTPServer:
+    """Create a mock server with its own cfg (port=0 picks a free port). One per case when running concurrently."""
+    srv = ThreadingHTTPServer(("127.0.0.1", port), Handler)
+    srv.cfg = cfg
+    return srv
+
+
+def run(port: int):
+    srv = make_server(CONFIG, port)
+    print(f"[mock_gateway] listening on 127.0.0.1:{port} mode={CONFIG['mode']}", flush=True)
+    srv.serve_forever()
+
+
+if __name__ == "__main__":
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--port", type=int, default=9009)
+    ap.add_argument("--mode", default=None)
+    args = ap.parse_args()
+    if args.mode:
+        CONFIG["mode"] = args.mode
+    run(args.port)