Add full evaluation code (GitHub 5411f53) and run instructions

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 |

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
+}

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

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/

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

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

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.

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.

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)"

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.

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

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

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

code/requirements/run.txt

@@ -0,0 +1 @@
+PyYAML>=6.0,<7

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.

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}

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: {}

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 \
+  "$@"

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())

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}" \
+  "$@"

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())

code/src/doc2harness/__init__.py

@@ -0,0 +1 @@
+__all__ = []

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",
+]

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",
+]

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" },
+]

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",
+]

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",
+]

code/src/doc2harness/benchmark/harnesses/__init__.py

@@ -0,0 +1,3 @@
+"""Primary Harness layer packages."""
+
+__all__: list[str] = []

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",
+]

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" },
+]

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",
+]

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] = []

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"]

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"]

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"]

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"]

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"]

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"]

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"]

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",
+]

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",
+]

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" },
+]

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",
+]

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",
+]

code/src/doc2harness/benchmark/harnesses/direct/scenarios/__init__.py

@@ -0,0 +1,3 @@
+"""Independent definition owners for direct mock-process scenarios."""
+
+__all__: list[str] = []

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"]

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"]