harness-everything 0.5.2 → 0.6.0

package/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
       "name": "harness-everything",
       "source": "./",
       "description": "Harness OS: an orchestrated agent operating system — tier routing, circuit breaker guardrails, verification gates, WAL session memory, and self-evolving workspace rules.",
-      "version": "0.5.2",
+      "version": "0.6.0",
       "author": {
         "name": "Miya Daniel"
       },

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "harness-everything",
   "description": "Harness OS: an orchestrated agent operating system — tier routing, circuit breaker guardrails, verification gates, WAL session memory, and self-evolving workspace rules.",
-  "version": "0.5.2",
+  "version": "0.6.0",
   "author": {
     "name": "Miya Daniel"
   },

package/AGENTS.md

@@ -13,7 +13,7 @@ You are modifying **Harness**: an orchestrated agent operating system (skills +
 | `<skill-name>/SKILL.md` | One canonical skill per top-level directory. Frontmatter: `name`, `description`, `metadata.author`, `metadata.version`. |
 | `hooks/` | Claude Code lifecycle hook scripts and shared mechanisms such as circuit breaker, scope guard, and stop gate. Do not infer that every host packages every hook. |
 | `harness-everything/scripts/` | Runtime: kernel/tier routing, verification, bootstrap, self-heal. |
-| `opencode-plugin/` | OpenCode native plugin implementation. Mechanism-tested; live plugin loading remains unverified until real host evidence exists. |
+| `opencode-plugin/` | OpenCode native plugin implementation. Mechanism-tested, with partial live-host evidence for project-scope `.js` loading and edit/verification state on OpenCode 1.18.31 (macOS); see the evidence boundary below. |
 | `.agents/plugins/` + `plugins/harness-everything/` | Local OpenAI/Codex marketplace + `.codex-plugin` package with canonical skill copies and packaged session/prompt hooks. |
 | `submission/openai/` | Public OpenAI Skills-only listing/test inputs. The public artifact does not include local `.codex-plugin` lifecycle hooks. |
 | `evals/<skill>/` | Trigger/routing eval per skill (waza format). Required for every canonical routed skill. |
@@ -25,6 +25,10 @@ You are modifying **Harness**: an orchestrated agent operating system (skills +
 | `.nvmrc` | Primary development/CI Node runtime. `package.json#engines.node` remains the minimum supported runtime. |
 | `docs/`, `references/` | Philosophy, architecture, workflow documentation, shared checklists. |
 
+## OpenCode evidence boundary
+
+The retained [OpenCode evidence](benchmarks/results/live-host/opencode-2026-09-16/README.md) supports only the scoped loading and state effects above. The final snapshot is post-reset (`hardLock: false`, `count: 1`). Hard lock is only an interactive observation with no retained blocked-tool trace; reflection was operator-seeded, then agent-rewritten. Agent-controlled state deletion resets the breaker, so do not claim durable hard enforcement or behavioral effectiveness. `.mjs` auto-discovery is broken on this host version. Global scope, npm-package installation, and other host versions remain unverified.
+
 ## Non-Negotiable Change Rules
 
 1. **Every canonical SKILL.md keeps ≤ 500 tokens** (hard CI gate) and must contain `## USE FOR:` and `## DO NOT USE FOR:` sections. Deep detail goes in the skill's `references/` or `guides/`.

package/BENCHMARK_SOP.md

@@ -4,7 +4,7 @@ This guide helps you objectively test the performance difference between an AI A
 
 **What this SOP does NOT test:** it compares emergent behavior (did the agent avoid the loop, did it stay in scope), not whether an underlying hook/plugin mechanism actually loaded, fired, or blocked anything. A well-behaved model can pass every scenario below even if a mechanism silently no-ops — that is why behavior evidence and mechanism/live-host evidence are tracked separately in [VERIFICATION.md](VERIFICATION.md).
 
-Do not classify mechanism support by product name alone. A host can expose more than one Harness surface. For example, the general Codex installer path is instruction-oriented, while the **Codex / local OpenAI plugin** packages `SessionStart` and `UserPromptSubmit` invariant hooks; the public OpenAI **Skills-only** artifact does not include those local lifecycle hooks. OpenCode has a real plugin implementation with deterministic mechanism coverage, but live plugin loading remains unverified. Use [docs/platform-capabilities.md](docs/platform-capabilities.md) as the current source of truth.
+Do not classify mechanism support by product name alone. A host can expose more than one Harness surface. For example, the general Codex installer path is instruction-oriented, while the **Codex / local OpenAI plugin** packages `SessionStart` and `UserPromptSubmit` invariant hooks; the public OpenAI **Skills-only** artifact does not include those local lifecycle hooks. OpenCode has deterministic mechanism coverage and partial live-host evidence for project-scope `.js` loading and edit/verification state on OpenCode 1.18.31 (macOS). The [retained evidence](benchmarks/results/live-host/opencode-2026-09-16/README.md) is a post-reset snapshot, not a full enforcement history. Hard lock is only an interactive observation with no retained blocked-tool trace; reflection was operator-seeded, then agent-rewritten. Agent-controlled state deletion resets the breaker; neither durable hard enforcement nor behavioral effectiveness is proven. Global scope, npm-package installation, and other host versions remain unverified. Use [docs/platform-capabilities.md](docs/platform-capabilities.md) as the current source of truth.
 
 This SOP is therefore a **behavior** benchmark. Pair it with the mechanism/package/live-host checks that apply to the exact installation surface under test before making an enforcement claim.
 

package/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 All notable changes to this project are documented in this file.
 
+## [0.6.0](https://github.com/dyphn1/Harness-everything/compare/v0.5.3...v0.6.0) (2026-09-17)
+
+### Features
+
+* **behavioral:** add paired benchmark contract ([42d52b3](https://github.com/dyphn1/Harness-everything/commit/42d52b3a6db89fa27cd2239726a22fe119299932))
+
+## [0.5.3](https://github.com/dyphn1/Harness-everything/compare/v0.5.2...v0.5.3) (2026-09-17)
+
+### Bug Fixes
+
+* **opencode:** Install discoverable plugin and guard loadability ([5645c08](https://github.com/dyphn1/Harness-everything/commit/5645c080c794b82afd50a0206cf35d2dd3fcd54c))
+
 ## [0.5.2](https://github.com/dyphn1/Harness-everything/compare/v0.5.1...v0.5.2) (2026-09-16)
 
 ### Bug Fixes

package/README.md

@@ -31,7 +31,7 @@ Harness deliberately follows a **minimal rails, maximum freedom** design: the ru
 | **System Audit** | Blindly assumes shell syntax | Requires manual shell check | Uses environment detection and explicit verification paths instead of assuming one shell/runtime |
 | **Memory** | Resets on every new chat session | Static text rules | Stateful hook/plugin integrations can persist bounded runtime state; instruction-only integrations cannot |
 
-The exact "Harness" behavior depends on the installation surface. Claude Code has the broadest currently verified lifecycle-hook coverage. OpenCode has a real plugin implementation with deterministic mechanism tests, but **live loading remains unverified**. Codex has both an advisory `--codex` installer path and a **local OpenAI plugin** path with mechanism-tested session, prompt, supported-tool, subagent, and stop hooks. The public OpenAI **Skills-only** submission is narrower and does not include those local lifecycle hooks. See [Supported AI IDEs & Tools](#supported-ai-ides--tools) and [docs/platform-capabilities.md](docs/platform-capabilities.md).
+The exact "Harness" behavior depends on the installation surface. Claude Code has the broadest currently verified lifecycle-hook coverage. OpenCode has deterministic mechanism tests and **partial live-host evidence** for project-scope `.js` loading and edit/verification state on OpenCode 1.18.31 (macOS), not durable hard enforcement; global scope and npm install remain unverified. Codex has both an advisory `--codex` installer path and a **local OpenAI plugin** path with mechanism-tested session, prompt, supported-tool, subagent, and stop hooks. The public OpenAI **Skills-only** submission is narrower and does not include those local lifecycle hooks. See [Supported AI IDEs & Tools](#supported-ai-ides--tools) and [docs/platform-capabilities.md](docs/platform-capabilities.md).
 
 ### When should I use Harness?
 * You regularly use agentic coding tools (like Claude Code, Cursor, or Copilot) on medium-to-large codebases.
@@ -158,12 +158,12 @@ Harness operates through six core cognitive concepts:
 
 The authoritative current matrix is [docs/platform-capabilities.md](docs/platform-capabilities.md). The important distinction is that **one host can have multiple Harness installation surfaces**.
 
-[`opencode-plugin/`](opencode-plugin/) (`index.mjs`) implements a verification gate and a Rule of 3 breaker against OpenCode's real, source-verified plugin API (`tool.execute.before`/`.after`, the `session.idle` event). `ci/mechanism-2n-opencode-plugin.test.js` drives the exported hooks directly against a mock context matching that API. What's *not* yet done: a live OpenCode session actually loading and firing the plugin, so the current claim remains **hard-capable / mechanism-tested, unverified live**.
+[`opencode-plugin/`](opencode-plugin/) (`index.mjs`) implements a verification gate and a Rule of 3 breaker against OpenCode's real, source-verified plugin API (`tool.execute.before`/`.after`, the `session.idle` event). `ci/mechanism-2n-opencode-plugin.test.js` drives the exported hooks directly against a mock context matching that API. Retained evidence supports project-scope `.js` plugin loading and edit/verification state on OpenCode 1.18.31 (macOS): [live-host evidence](benchmarks/results/live-host/opencode-2026-09-16/README.md). The final snapshot is post-reset (`hardLock: false`, `count: 1`); hard lock is only an interactive observation with no retained blocked-tool trace. Reflection was operator-seeded, then agent-rewritten, not unaided. Agent-controlled state deletion resets the breaker, so this does not prove durable hard enforcement or behavioral effectiveness. Install with a **`.js`** destination name: this host silently ignores `.mjs` (issue #127, guarded by `test:opencode:loadability`). Global scope, npm-package installation, and other host versions remain unverified.
 
 | AI Agent Tool / Surface | Integration Method | Local Target Location | Enforcement claim |
 |---|---|---|---|
 | **Claude Code** | Native lifecycle hooks (`PreToolUse`, `PostToolUse`, `SessionStart`, `UserPromptSubmit`, `Stop`) | `.claude/settings.json`, `.claude/skills/`, `.claude/agents/` | **Hard** for the supported verified hook gates |
-| **OpenCode** | Native plugin module ([`opencode-plugin/index.mjs`](opencode-plugin/index.mjs)) | `.opencode/plugins/` | **Hard-capable, unverified live** — mechanism/source coverage exists; live host loading is not yet evidence-backed |
+| **OpenCode** | Native plugin module ([`opencode-plugin/index.mjs`](opencode-plugin/index.mjs), install as `harness-enforcement.js`) | `.opencode/plugins/` | **Partial live-host evidence** — project-scope `.js` loading and edit/verification state on OpenCode 1.18.31 (macOS); hard lock reported only, no retained blocked-tool trace; not durable hard enforcement |
 | **Codex — general installer path** | Skills + `AGENTS.md` guidance | `AGENTS.md` + repo-scoped `.agents/skills/` | **Advisory/instruction-oriented** where the host only consumes instructions |
 | **Codex / local OpenAI plugin** | `.codex-plugin` package with session, prompt, supported-tool, subagent, and stop hooks plus 26 canonical skills | `.agents/plugins/marketplace.json` → `plugins/harness-everything/` | **Mechanism-tested local enforcement** for the packaged mappings; live host loading remains unverified |
 | **Public OpenAI Skills-only plugin** | Public Skills-only bundle | Generated submission ZIP from `plugins/harness-everything/skills/` | **Skill/workflow behavior only**; no local `.codex-plugin` lifecycle hooks in the public artifact |

package/VERIFICATION.md

@@ -22,7 +22,7 @@ First identify **which Harness surface you are testing**. One host can have more
 | Surface | Artifact / location | What artifact presence proves |
 |---|---|---|
 | Claude Code | `.claude/settings.json`, `.claude/skills/`, `.claude/agents/` | The Claude installer/plugin wrote its lifecycle-hook configuration and content |
-| OpenCode | `.opencode/plugins/` / `opencode-plugin/index.mjs` | The native plugin module exists; this alone does not prove live loading |
+| OpenCode | `.opencode/plugins/harness-enforcement.js` (copied from `opencode-plugin/index.mjs`) | The loadable plugin module exists under a `.js` name; this alone does not prove live loading |
 | Codex — general installer | `AGENTS.md`, repo-scoped `.agents/skills/` | Advisory/instruction integration and project Agent Skills are installed |
 | **Codex / local OpenAI plugin** | `.agents/plugins/marketplace.json`, `plugins/harness-everything/.codex-plugin/plugin.json`, packaged hooks/skills | The local OpenAI plugin package is structurally present |
 | **Public OpenAI Skills-only** | generated `dist/openai-submission/harness-everything-skills.zip` | The public-review bundle was generated; local `.codex-plugin` lifecycle hooks are intentionally not part of this artifact |
@@ -127,9 +127,9 @@ The repository implements the real OpenCode plugin API and has deterministic mec
 npm run test:mechanism
 ```
 
-and inspect the OpenCode-specific mechanism suite (`ci/mechanism-2n-opencode-plugin.test.js`).
+and inspect the OpenCode-specific mechanism suites (`ci/mechanism-2n-opencode-plugin.test.js` for hook behavior, `ci/mechanism-30-opencode-plugin-loadability.test.js` for install-filename loadability).
 
-**Current evidence boundary:** implementation/mechanism-tested, **live plugin loading remains unverified** until a real OpenCode session artifact demonstrates that the host loaded and fired the plugin.
+**Current evidence boundary:** deterministic mechanism coverage plus partial live-host evidence for project-scope `.js` loading and edit/verification state on OpenCode 1.18.31 (macOS). See [retained evidence](benchmarks/results/live-host/opencode-2026-09-16/README.md). The final snapshot is post-reset (`hardLock: false`, `count: 1`), not a history of the enforcement sequence. Hard lock is only an interactive observation with no retained blocked-tool trace. Reflection was operator-seeded, then agent-rewritten; follow-up delivery is reported/state-consistent, without a retained transcript. Agent-controlled state deletion resets the breaker, so neither durable hard enforcement nor behavioral effectiveness is proven. `.mjs` auto-discovery is broken on this host version (issue #127). Global scope, npm-package installation, and other host versions remain unverified.
 
 ---
 
@@ -142,7 +142,7 @@ npm run test:docs:capabilities
 npm run test:consistency
 ```
 
-The capability test checks the current-state documentation surfaces for stale platform paths and pre-plugin claims, requires the Codex local-plugin vs public Skills-only distinction, preserves the OpenCode live-unverified qualifier, and records the Hermes native user skill target plus the Continue installer candidate boundary.
+The capability test checks the current-state documentation surfaces for stale platform paths and pre-plugin claims, requires the Codex local-plugin vs public Skills-only distinction, requires the OpenCode retained artifact path, host/version/OS and project `.js` scope, and explicit partial-evidence limitations, and records the Hermes native user skill target plus the Continue installer candidate boundary.
 
 When changing platform integration behavior, update [docs/platform-capabilities.md](docs/platform-capabilities.md) and all affected current-state docs in the same PR.
 
@@ -237,7 +237,7 @@ Fill in one row **per installation surface**, not merely per brand name.
 |---|---|---|---|---|---|---|
 | Package/artifact present | | | | | | |
 | Deterministic mechanism tests | | | N/A/explicit CLI only | | N/A (skill bundle) | N/A |
-| Live host loaded mechanism | | **unverified until evidenced** | N/A | | N/A | N/A |
+| Live host loaded mechanism | | **loading verified; lifecycle evidence partial** (project scope, OpenCode 1.18.31, macOS, `.js`) — [evidence](benchmarks/results/live-host/opencode-2026-09-16/README.md) | N/A | | N/A | N/A |
 | Routing/invariant behavior | | | | | | |
 | Objective verification discipline | | | | | | |
 | Failure recovery discipline | | | | | | |

package/behavioral-evals/PAIRED-BENCHMARK.md

@@ -0,0 +1,186 @@
+# Paired Behavioral Benchmark Protocol
+
+This protocol is the measurement surface for issue #71. It is intentionally
+separate from mechanism tests: mechanism tests prove deterministic hook and
+state-machine behavior, while this benchmark measures agent behavior under a
+real model session.
+
+## Separate causal questions
+
+Never combine these interventions into one headline number.
+
+### `skill-text`
+
+Measures the incremental effect of Harness skill guidance only.
+
+- baseline: no Harness skill text, no Harness hooks/plugin enforcement;
+- treatment: the case's named Harness skill text only;
+- same engine, explicit model, prompt, fixture, rubric, CLI policy, and tool
+  availability in both arms.
+
+The treatment does **not** install `hooks/hooks.json` or the OpenCode
+`harness-enforcement.js` plugin. This removes the old confound where a
+"skill" treatment also changed enforcement behavior.
+
+### `plugin-enforcement`
+
+Measures the incremental effect of OpenCode enforcement while holding skill
+text constant.
+
+- baseline: named Harness skill text, no OpenCode enforcement plugin;
+- treatment: the same named Harness skill text plus the canonical OpenCode
+  enforcement module installed as `.opencode/plugins/harness-enforcement.js`.
+
+This experiment currently supports OpenCode only. It requires a retained
+hard-lock preflight produced by `opencode-hardlock-live.js`. The preflight must
+still pass verification and its plugin SHA-256 must equal the current canonical
+`opencode-plugin/index.mjs`; changing the plugin invalidates the old preflight.
+
+Each treatment case must also leave retained plugin state proving that the
+plugin fired during that case. Missing attribution is classified as
+infrastructure/inconclusive and is excluded from behavioral pass rates.
+
+### Cost and execution overhead
+
+Cost is reported separately from correctness:
+
+- provider cost, where exposed by the host;
+- total tokens, where exposed;
+- attempted tool calls;
+- elapsed duration.
+
+The report gives treatment-minus-baseline deltas and does not fold them into a
+correctness score.
+
+## Predeclare the decision threshold
+
+There is deliberately **no default minimum effect**. Before model calls start,
+the caller must supply `--min-effect-pp <N>` to state the smallest paired pass
+rate improvement that would be practically meaningful for that study. The
+experiment manifest is written before either arm runs, so the threshold cannot
+be selected after seeing the result.
+
+Example only (not a project-wide default):
+
+```bash
+--min-effect-pp 10
+```
+
+A study reports `meets-predeclared-threshold` only when the lower bound of the
+paired bootstrap 95% confidence interval is at or above that predeclared
+minimum. It reports `below-predeclared-threshold` when the interval lies wholly
+below it, otherwise `uncertain-at-predeclared-threshold`. Fewer than two
+included pairs is `insufficient-data`.
+
+The report also includes an exact McNemar p-value for the discordant pairs. The
+p-value is evidence about symmetry of fail->pass vs pass->fail transitions; it
+is not a substitute for the predeclared practical-effect threshold.
+
+## Evidence and exclusions
+
+A pair enters the behavioral denominator only when both arms are definitive
+`pass` or `fail` and the pair contract validates.
+
+Excluded reasons include:
+
+- CLI/session error;
+- grader error;
+- incomplete or inconclusive transcript evidence;
+- mismatched actual model when both hosts report it;
+- pair-contract hash mismatch;
+- intervention shape mismatch;
+- missing OpenCode plugin attribution/preflight/hash evidence.
+
+`command_exit_0` remains a post-hoc workspace correctness check. It is tagged
+as such in the result and is never presented as proof that the agent itself
+executed the same command. Agent execution claims require structured tool
+transcript evidence.
+
+## Retained artifacts
+
+Each experiment receives a unique directory under
+`behavioral-evals/results/paired/` containing:
+
+- `manifest.json` — pre-run engine/model/effect/threshold/repository/host
+  contract;
+- `pairs/*.json` — one immutable record per case/repeat;
+- `<pair-id>/<arm>.transcript.jsonl` and stderr;
+- `<pair-id>/<arm>.workspace/` — final synthetic fixture snapshot excluding
+  Harness install artifacts and `.git`;
+- `<pair-id>/<arm>.state/` — isolated Harness state, when any;
+- `summary.json` — included/excluded counts, transitions, paired effect and CI,
+  repeat variance, McNemar statistic, and overhead deltas.
+
+Pair IDs include a UUID, so repeated runs of the same case never overwrite one
+another.
+
+## Run skill-text pairs
+
+Use an explicit model. The same model argument is sent to both arms.
+
+```bash
+npm run eval:paired -- \
+  --effect skill-text \
+  --engine opencode \
+  --model <provider/model> \
+  --min-effect-pp <N> \
+  --repeats 3
+```
+
+A single case can be targeted with `--case <case-id>`.
+
+Claude is also supported for the `skill-text` experiment:
+
+```bash
+npm run eval:paired -- \
+  --effect skill-text \
+  --engine claude \
+  --model <model> \
+  --min-effect-pp <N> \
+  --case baseline-debugging \
+  --repeats 3
+```
+
+Both Claude arms use the same permission/configuration invocation. The old
+runner's baseline-only `--safe-mode` difference is not used in this protocol.
+
+## Run OpenCode plugin-enforcement pairs
+
+First produce the #37 attribution evidence from the exact plugin revision being
+measured:
+
+```bash
+npm run eval:opencode:hardlock-live
+```
+
+Then pass that evidence directory into the paired study:
+
+```bash
+npm run eval:paired -- \
+  --effect plugin-enforcement \
+  --engine opencode \
+  --model <provider/model> \
+  --min-effect-pp <N> \
+  --opencode-preflight benchmarks/results/live-host/opencode-hardlock-<timestamp> \
+  --repeats 3
+```
+
+If the preflight fails, is missing, or belongs to a different plugin SHA, the
+study refuses to start rather than silently counting an unattributed plugin
+arm.
+
+## Statistical output
+
+For included pairs the summary reports:
+
+- baseline and treatment pass/fail counts;
+- `fail->pass`, `pass->fail`, `pass->pass`, and `fail->fail` transitions;
+- paired effect in percentage points: `(treatment passes - baseline passes) / n`;
+- deterministic paired-bootstrap 95% confidence interval;
+- exact McNemar p-value on discordant pairs;
+- per-case repeat count, mean paired difference, and sample variance;
+- excluded pairs with explicit reasons;
+- cost/token/tool-call/duration deltas in a separate section.
+
+Historical `opencode-with-plugin` result files pre-dating the live attribution
+protocol are descriptive only and must not be mixed into this paired dataset.

package/behavioral-evals/README.md

@@ -104,3 +104,49 @@ machine-specific workspace or transcript paths. Each archive includes the case
 fixture, replay command, fixture/prompt/rubric/code hashes, and engine/model
 provenance. Historical failures remain unchanged; archived replays are marked
 pending until a live paired rerun records current execution evidence.
+
+## OpenCode hard-lock live evidence
+
+Issue #37 needs a stronger proof than the hermetic state-machine test: a real
+OpenCode host must show an attributed edit attempt being blocked after the same
+verification failure returns post-reflection. Run the dedicated probe on a
+machine with an authenticated `opencode` CLI:
+
+```bash
+npm run eval:opencode:hardlock-live
+
+# Optional explicit output/model
+node behavioral-evals/opencode-hardlock-live.js run \
+  --out benchmarks/results/live-host/opencode-hardlock-local \
+  --model opencode/union-alpha
+
+# Re-check a retained evidence directory without making a model call
+node behavioral-evals/opencode-hardlock-live.js verify \
+  benchmarks/results/live-host/opencode-hardlock-local
+```
+
+The runner uses an isolated temporary `HARNESS_STATE_HOME`, installs the
+canonical `opencode-plugin/index.mjs` as the auto-discoverable
+`.opencode/plugins/harness-enforcement.js`, and keeps the verification failure
+constant. It does **not** seed breaker/reflection state. The live agent must
+produce the reflection artifact through the host/plugin flow.
+
+A PASS requires all of the following evidence to agree:
+
+- a structured pre-lock edit attempt containing `PRELOCK_OK`, and that marker
+  must reach `probe.txt` (negative control showing edits were possible);
+- a preserved reflection artifact with the current token and `RESUME:` decision;
+- a post-reflection retry containing `POST_REFLECTION_RETRY`, which must reach
+  the file and drive the same failure signature to at least count 4;
+- a pre-reset `circuit-breaker.json` snapshot with `hardLock: true`;
+- a structured final edit attempt containing `SHOULD_NOT_LAND` plus the live
+  Harness hard-lock error in host output;
+- `SHOULD_NOT_LAND` must **not** appear in the final file, proving the attempted
+  edit was blocked before filesystem mutation.
+
+The runner archives raw transcript/stderr, sanitized host/model/plugin metadata,
+the final fixture files, the selected pre-reset state, the reflection artifact,
+and the complete isolated raw-state tree before deleting its temporary working
+directory. A failed/incomplete live run is retained as failed evidence rather
+than being counted as behavioral failure. This probe is intended to become the
+OpenCode plugin-arm preflight for the paired benchmark tracked by #71.