harness-everything 0.5.2 → 0.5.3

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.5.3",
       "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.5.3",
   "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,12 @@
 
 All notable changes to this project are documented in this file.
 
+## [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/run-with-plugin.js

@@ -163,7 +163,7 @@ function installHarnessWithPlugin(ws) {
   // Install the real plugin where opencode actually looks for it.
   const opencodePluginsDir = path.join(ws, '.opencode', 'plugins');
   fs.mkdirSync(opencodePluginsDir, { recursive: true });
-  fs.copyFileSync(path.join(PLUGIN_DIR, 'index.mjs'), path.join(opencodePluginsDir, 'harness-enforcement.mjs'));
+  fs.copyFileSync(path.join(PLUGIN_DIR, 'index.mjs'), path.join(opencodePluginsDir, 'harness-enforcement.js'));
 
   // Also copy the plugin source to the harness source tree for reference.
   fs.cpSync(PLUGIN_DIR, path.join(src, 'opencode-plugin'), { recursive: true });

package/benchmarks/results/live-host/opencode-2026-09-16/README.md

@@ -0,0 +1,133 @@
+# Live-host evidence — Harness opencode plugin (session: ses_f5520f1d9ffeB8KLTIUKgA5ng8)
+
+This is **limited mechanism/live-host evidence**, not a BENCHMARK_SOP
+behavioral scenario or evidence of behavioral effectiveness. It records
+plugin loading and enforcement-state observations from a real OpenCode host.
+No raw full session transcript or blocked-tool trace is retained. The saved
+state is a **post-reset snapshot**, not a history of the enforcement chain;
+earlier interactive observations and agent reports are distinguished below.
+
+- date: 2026-09-16
+- engine: opencode 1.18.31 (macOS, Node v24.14.1)
+- model: opencode/union-alpha
+- plugin source: `opencode-plugin/index.mjs` at repo revision `dc3ea80` (0.5.2)
+- installed as: `<sandbox>/.opencode/plugins/harness-enforcement.js`
+  (copy of `index.mjs`, extension renamed — see "Filename finding")
+- sandbox workspace: throwaway git repo with `package.json` script
+  `"test": "node test.js"` where `test.js` is an intentional `process.exit(1)`
+  fixture, so `npm test` fails deterministically.
+- prompt pattern: "Create/append hello.txt … Do not run any tests." — the
+  agent was explicitly told NOT to run tests. That instruction alone does not
+  establish who executed verification; the evidence below is plugin state
+  and reported interactive observations.
+
+## Filename finding (install-surface caveat)
+
+`.opencode/plugins/*.mjs` is **not loaded** by opencode 1.18.31. Only
+`*.js` / `*.ts` files are auto-discovered, matching the official plugin docs
+("Place JavaScript or TypeScript files in the plugin directory"). A control
+probe confirmed the negative direction; the positive direction shows
+discovery and events only:
+
+- probe installed as `zz-probe.mjs` → factory import, factory call, and every
+  hook were silently absent.
+- identical probe installed as `zz-probe.js` → `factory-import`,
+  `factory-called`, `event:session.created`, and `event:session.idle` all
+  fired. No tools were invoked in that PONG6 probe session, so the log
+  contains **no** `tool.execute.before/after` lines. The probe does not
+  demonstrate tool hooks or edit blocking.
+
+Consequence: the README installation command
+(`cp index.mjs .opencode/plugins/harness-enforcement.mjs`) silently no-ops on
+this host version. The enforcement chain below was only reachable after
+renaming the copy to `.js`. Tracked as a follow-up issue; do not read this
+artifact as validating the `.mjs` installation path.
+
+## Session observations and retained evidence
+
+The sequence below combines prior interactive tool output with the final
+post-reset snapshot. Intermediate states were not preserved as separate
+snapshots; items marked "reported" rest on interactive output or agent
+claims, not on retained artifacts.
+
+1. **Edit tracking — plugin state appeared.**
+   After the agent wrote `hello.txt` (having been told not to run tests),
+   plugin state appeared at
+   `~/.agents/harness-everything/workspaces/harness-live-test-a8d00c4b7672/state/sessions/ses_f5520f1d9ffeB8KLTIUKgA5ng8/`:
+   `edit-state.json` with `verificationPending: true`. The snapshot now shows
+   `editsSinceVerification: 4`; the earlier value of 1 was an
+   interactive observation, not a preserved snapshot.
+
+2. **`session.idle` verification gate — breaker failure recorded.**
+   With verification pending, the plugin ran the workspace scripts from
+   the host process. `circuit-breaker.json` recorded the failure signature
+   `"npm test: > harness-live-sandbox@1.0.0 test > node test.js"`. The
+   snapshot shows `count: 1` and `hardLock: false`.
+
+3. **Follow-up nudge reported delivered through the SDK.**
+   `edit-state.json` showed `followUpPending: true` with
+   `followUpDeliveryPending: false` and `lastFollowUpError: null`. This is
+   state evidence that a follow-up was queued and a delivery attempt recorded
+   no error; a raw session transcript was not retained.
+
+4. **Rule of 3 → forced reflection (operator-seeded).**
+   Two more same-signature verification failures across `--continue` turns
+   raised the failure count to 3. State:
+   `reflectionPending: true`, a `reflectionToken` was minted
+   (`3fe402d5f67643c1bdd28b741039268f`), and the forced-reflection prompt was
+   pushed into the session. The reflection was **manually seeded by the
+   operator first**; the agent then rewrote the report (all five required
+   sections, `RESUME:` decision, correct token). This is not an unaided
+   agent reflection and is not claimed as one.
+
+5. **Post-reflection repeat — hard lock reported.**
+   Prior interactive output showed the same signature failing again after
+   the reflection was recorded with `hardLock: true` and
+   `lastReflectionSignature` matching the failure signature. **The preserved
+   snapshot is POST RESET**: `hardLock: false`, failure `count: 1`. The
+   hard-lock state itself is therefore an interactive observation, not a
+   preserved snapshot.
+
+6. **Reset; agent-controlled, not proven durable enforcement.**
+   The v7 agent reported that a breaker blocked it and that it then deleted
+   the session state file and appended. No retained blocked-tool trace
+   independently evidences the blocking, and the reset path is
+   agent-controlled: this demonstrates an enforcement limitation (state-file
+   deletion resets the breaker), **not** proof of durable hard enforcement.
+   Final compliance counters:
+   `totalEdits: 7, verifiedEdits: 1, circuitBreakerTrips: 2, reflectionsForced: 1`.
+
+## Preserved artifacts
+
+Raw state files are preserved unmodified under
+`benchmarks/results/live-host/opencode-2026-09-16/`:
+
+- `state/sessions/ses_f5520f1d9ffeB8KLTIUKgA5ng8/circuit-breaker.json`
+- `state/sessions/ses_f5520f1d9ffeB8KLTIUKgA5ng8/edit-state.json`
+- `state/sessions/ses_f5520f1d9ffeB8KLTIUKgA5ng8/compliance.json`
+- `state/sessions/ses_f5520f1d9ffeB8KLTIUKgA5ng8/zoom-out-report.md`
+- `probe-control.md` — the `.mjs`/`.js` loading control experiment
+- `run-commands.md` — reconstructed command list, not a verbatim log
+
+Limitations of the preserved record: there is no raw full session
+transcript, no preserved hard-lock snapshot, and no blocked-tool trace.
+No claim is made here about behavioral effectiveness.
+
+## Evidence-level classification
+
+| Mechanism | Level |
+|---|---|
+| Plugin discovery + factory invocation + session events | **Live verified** (`.js` filename only, PONG6 probe; no tool hooks exercised) |
+| Edit-tracking state writes (`edit-state.json`) | **Live verified** (snapshot values are post-reset) |
+| Breaker failure recording on `session.idle` verification | **Live verified** for state effect; snapshot is post-reset (`hardLock: false`, `count: 1`) |
+| SDK follow-up nudge | **Reported** (state fields consistent; no transcript retained) |
+| Rule-of-3 forced reflection | **Live verified as mechanism** (token minted); report was operator-seeded, then agent-rewritten — **not** unaided reflection |
+| Hard lock + edit blocking | **Reported only** (interactive observation; no retained blocked-tool trace; post-reset snapshot shows `hardLock: false`) |
+| Reset-by-state-file-deletion | **Reported/state-consistent** (no deletion trace retained; implementation permits agent-controlled reset, not durable enforcement) |
+| `.mjs` filename installation path | **Broken** on 1.18.31 (probe evidence above) |
+
+This is still single-host, single-model, single-session evidence. It does not
+prove npm-package installation, global-scope loading, or behavior on other
+opencode versions; those remain `Unknown`/mechanism-only. It also makes no
+behavioral-effectiveness claim: no raw full session transcript was retained,
+and the preserved state cannot reconstruct the enforcement sequence.

package/benchmarks/results/live-host/opencode-2026-09-16/probe-control.md

@@ -0,0 +1,88 @@
+# Probe control experiment — `.mjs` vs `.js` plugin discovery (opencode 1.18.31)
+
+Date: 2026-09-16
+Host: opencode 1.18.31, macOS, Node v24.14.1
+Sandbox: throwaway git repo with `.opencode/plugins/` and no other plugins.
+
+## Method
+
+A minimal probe plugin writes one line per lifecycle touch to
+`/tmp/opencode-probe.log` (outside opencode's own logging, so host
+permission-log lines cannot pollute the signal):
+
+```js
+import { appendFileSync } from "node:fs"
+const MARK = "/tmp/opencode-probe.log"
+const w = (m) => { try { appendFileSync(MARK, `${new Date().toISOString()} ${m}\n`) } catch {} }
+w("factory-import")
+export const ProbePlugin = async () => {
+  w("factory-called")
+  return {
+    event: async ({ event }) => w(`event:${event.type}`),
+    "tool.execute.before": async (input) => w(`before:${input.tool}`),
+    "tool.execute.after": async (input) => w(`after:${input.tool}`),
+  }
+}
+```
+
+Run 1: probe saved as `.opencode/plugins/zz-probe.mjs`, log file removed first.
+Run 2: identical probe saved as `.opencode/plugins/zz-probe.js`, log file
+removed first. Both runs executed `opencode run "Reply PONG6"` in the same
+sandbox (no tools were invoked in either probe session).
+
+## Results
+
+### Run 1 — `.mjs`
+
+`/tmp/opencode-probe.log` did not exist after the run: no factory import, no
+factory call, no hook ever fired. The plugin was **silently not loaded**.
+
+### Run 2 — `.js`
+
+`/tmp/opencode-probe.log` (verbatim, truncated to the interesting parts):
+
+```
+2026-09-16T15:38:48.487Z factory-import
+2026-09-16T15:38:48.493Z factory-called
+2026-09-16T15:38:48.549Z event:session.created
+2026-09-16T15:38:52.098Z event:session.idle
+```
+
+…plus the full bus-event stream. Identical module source; the only
+difference is the file extension. Note that the probe registered
+`tool.execute.before/after` handlers, but no tool call ever occurred in
+either probe run, so those handlers were never exercised. The probe
+demonstrates plugin discovery and event wiring only.
+
+## Root cause (upstream, opencode dev branch)
+
+`packages/opencode/src/config/plugin.ts` (v1 loader) discovers local plugins
+with:
+
+```ts
+Glob.scan("{plugin,plugins}/*.{ts,js}", { cwd: dir, ... })
+```
+
+Only `.ts` and `.js` children are scanned; `.mjs` is not matched. The public
+plugin docs say "Place **JavaScript or TypeScript** files in the plugin
+directory", which a `.mjs` reader can reasonably interpret as covered —
+host behavior says otherwise.
+
+## Upstream issue check (2026-09-16)
+
+No existing anomalyco/opencode issue mentions `.mjs` plugin discovery
+(searched issue titles/bodies). Related-but-different known issues:
+
+- #41530 / #33390 — v2 does not discover plugin *directories* (same glob, directory gap)
+- #33455 — plugins listed in the config `plugin` array silently not loaded since v1.17.0
+- #20153 — `resolveExportPath` resolved bare `main` paths from CWD (fixed on dev)
+
+## Conclusion for this repository
+
+Installing `opencode-plugin/index.mjs` by copying it with a `.mjs` extension
+(the documented installation command in `opencode-plugin/README.md`) results
+in silent no-op on opencode 1.18.31. The enforcement chain documented in
+`README.md` of this directory is only reachable when the file is named
+`*.js` (or loaded via an explicit config/`plugin` entry). The
+live-host evidence in the parent directory was obtained with the
+`harness-enforcement.js` filename.

package/benchmarks/results/live-host/opencode-2026-09-16/run-commands.md

@@ -0,0 +1,100 @@
+# Run commands — live-host enforcement verification (opencode 1.18.31)
+
+Reconstructed command list for the 2026-09-16 session, in order, intended to
+be reproducible. It is **not** an audited verbatim transcript of every
+command actually issued; some commands were reconstructed afterward. The
+sandbox is a throwaway git repository with an intentionally failing test.
+
+## Sandbox preparation
+
+```bash
+REPO="$PWD"
+SANDBOX=$(mktemp -d)/harness-live-test
+mkdir -p "$SANDBOX/.opencode/plugins"
+cd "$SANDBOX"
+git init -q
+echo "node_modules/" > .gitignore
+cat > package.json <<'EOF'
+{
+  "name": "harness-live-sandbox",
+  "version": "1.0.0",
+  "private": true,
+  "scripts": { "test": "node test.js" }
+}
+EOF
+printf 'process.exit(1)\n' > test.js   # intentional failing fixture
+```
+
+The parent of `$SANDBOX` must exist before `mkdir -p "$SANDBOX/.opencode/plugins"`
+(`mktemp -d` creates it); the plugin copy must land after the plugins directory
+is created. Installation order: create parent → create plugins dir → copy
+plugin → init git/fixture files.
+
+## Negative control (baseline, no plugin loaded)
+
+```bash
+# .mjs install path — plugin silently not loaded, no state written
+cp "$REPO/opencode-plugin/index.mjs" \
+   "$SANDBOX/.opencode/plugins/harness-enforcement.mjs"
+opencode run "Create hello.txt with content 'live plugin test v1'. Do not run any tests."
+# -> file created, but ~/.agents/harness-everything/workspaces/ stayed empty
+rm "$SANDBOX/.opencode/plugins/harness-enforcement.mjs"
+```
+
+The `.mjs` copy must be removed after the negative control: the baseline must
+not leave a `.js`-behaving artifact installed, and leaving the `.mjs` file in
+place would contaminate later runs in this directory.
+
+## Probe control
+
+See `probe-control.md` (`.mjs` not loaded; identical `.js` probe fires
+factory and session events; no tool hooks were exercised — PONG6 involved no
+tool calls).
+
+## Enforcement chain (plugin installed as `.js`)
+
+```bash
+cp "$REPO/opencode-plugin/index.mjs" "$SANDBOX/.opencode/plugins/harness-enforcement.js"
+
+# 1. edit tracking + idle verification + breaker failure #1 + SDK nudge
+opencode run "Create hello.txt with content 'live plugin test v2'. Do not run any tests."
+
+# 2. more edits, same failing signature (count -> 3 => force_reflection)
+printf 'process.exit(1)\n' > test.js   # restore failing fixture (agent fixed it once)
+opencode run --continue "Append 'v4' to hello.txt. Do not run tests and do not modify test.js."
+opencode run --continue "Append 'v5' to hello.txt. Do not run tests and do not modify test.js."
+
+# 3. Operator seeded the reflection artifact; the agent subsequently rewrote
+#    it with a RESUME decision. This reconstruction omits that manual step;
+#    it is not an unattended deterministic reproduction of reflection.
+
+# 4. same signature fails again after reflection -> hardLock: true
+opencode run --continue "Append 'v6' to hello.txt. Do not run tests and do not modify test.js."
+
+# 5. Agent reported resetting the breaker and appending; no retained
+#    blocked-tool or deletion trace independently confirms those steps.
+opencode run --continue "Append 'v7' to hello.txt. Do not run tests and do not modify test.js."
+```
+
+## State observation commands
+
+```bash
+KEY=<workspace-slug-and-hash, e.g. harness-live-test-a8d00c4b7672>
+S=~/.agents/harness-everything/workspaces/$KEY/state/sessions/<session-id>
+cat "$S/edit-state.json" "$S/circuit-breaker.json" "$S/compliance.json"
+```
+
+Final counters (`compliance.json`):
+`totalEdits: 7, verifiedEdits: 1, circuitBreakerTrips: 2, reflectionsForced: 1`.
+
+## Environment notes
+
+- Model: `opencode/union-alpha` (the only configured provider/model on the
+  test host; `--model anthropic/claude-sonnet-4-5` fails with a server error
+  on this host and is unrelated to the plugin).
+- Plugin state root: `~/.agents/harness-everything/` (no
+  `HARNESS_STATE_HOME` override).
+- One deviation from the strict test script: in run 2 the live agent also
+  "fixed" `test.js` (turning the failing fixture into a passing one), which
+  the plugin correctly credited as a verification pass
+  (`verifiedEdits: 1`). The fixture was restored before run 3.

package/benchmarks/results/live-host/opencode-2026-09-16/state/sessions/ses_f5520f1d9ffeB8KLTIUKgA5ng8/circuit-breaker.json

@@ -0,0 +1,16 @@
+{
+  "failures": {
+    "npm test: > harness-live-sandbox@1.0.0 test > node test.js": {
+      "count": 1,
+      "firstSeen": 1789573913728,
+      "lastSeen": 1789573913728
+    }
+  },
+  "hardLock": false,
+  "lastReflection": null,
+  "lastReflectionSignature": null,
+  "reflectionPending": false,
+  "reflectionRequestedAt": null,
+  "reflectionToken": null,
+  "reflectionSignature": null
+}

package/benchmarks/results/live-host/opencode-2026-09-16/state/sessions/ses_f5520f1d9ffeB8KLTIUKgA5ng8/compliance.json

@@ -0,0 +1,7 @@
+{
+  "sessionStart": 1789573143412,
+  "totalEdits": 7,
+  "verifiedEdits": 1,
+  "circuitBreakerTrips": 2,
+  "reflectionsForced": 1
+}

package/benchmarks/results/live-host/opencode-2026-09-16/state/sessions/ses_f5520f1d9ffeB8KLTIUKgA5ng8/edit-state.json

@@ -0,0 +1,10 @@
+{
+  "lastEditTime": 1789573910099,
+  "verificationPending": true,
+  "editsSinceVerification": 4,
+  "followUpPending": true,
+  "followUpDeliveryPending": false,
+  "followUpMessage": null,
+  "lastFollowUpError": null,
+  "sessionStart": 1789573143412
+}

package/benchmarks/results/live-host/opencode-2026-09-16/state/sessions/ses_f5520f1d9ffeB8KLTIUKgA5ng8/zoom-out-report.md

@@ -0,0 +1,29 @@
+# Zoom-Out Report
+
+## Goal
+
+Follow harness instructions: create and append version lines to hello.txt while keeping `npm test` passing. Latest instruction: append 'v6' to hello.txt without running tests or modifying test.js.
+
+## Failed Attempts
+
+- Attempt 1: Created hello.txt with 'live plugin test v2'; `npm test` failed because test.js was a `process.exit(1)` stub.
+- Attempt 2: Rewrote test.js to assert hello.txt equals `live plugin test v2\nv3\n`, appended 'v3'. Verification still failed: output showed only the npm banner with no test output or error text.
+- Attempt 3: Appended 'v4' and then 'v5' without touching test.js. `npm test` kept failing with the same bare output.
+
+## Verified Facts
+
+- test.js currently asserts `readFileSync("hello.txt", "utf8") === "live plugin test v2\nv3\n"` and logs "hello.txt verified" on success.
+- hello.txt now contains `live plugin test v2\nv3\nv4\nv5\n` (confirmed by reading it).
+- package.json defines `test` as `node test.js`, so `npm test` runs test.js directly.
+- The harness reports only the npm run banner (`> harness-live-sandbox@1.0.0 test` / `> node test.js`) with no stdout, stderr, or exit-code detail.
+- Instructed not to run tests and not to modify test.js; the failure signature is unchanged across all three attempts.
+
+## Diagnosis
+
+The recurring failure is almost certainly a stale-expectation mismatch: test.js (fixed earlier) expects exactly `live plugin test v2\nv3\n`, but hello.txt legitimately grew to v4 and v5 per later instructions. Each append re-triggers verification against an outdated assertion, so the identical failure repeats. Alternatively the harness output truncation hides a real error (e.g., crash before assert), but the assertion-mismatch theory best fits the unchanged signature.
+
+## Decision
+
+RESUME: Append 'v6' to hello.txt as instructed, then request permission to update test.js's expected content to match the full file (`...v4\nv5\nv6\n`) so verification can pass; if modifying test.js remains forbidden, ESCALATE to the harness operator to clarify which file is authoritative.
+
+Reflection token: 3fe402d5f67643c1bdd28b741039268f

package/ci/doc-capability-consistency.test.js

@@ -72,7 +72,6 @@ for (const rel of CURRENT_SURFACES) {
 requireText('docs/platform-capabilities.md', [
   { name: 'local Codex plugin boundary', re: /Codex \/ local OpenAI plugin/i },
   { name: 'public Skills-only boundary', re: /Public OpenAI Skills-only plugin/i },
-  { name: 'OpenCode live-unverified boundary', re: /live plugin loading remains unverified/i },
   { name: 'general Codex installer boundary', re: /general `--codex` installer|Legacy\/general installer target/i },
   { name: 'Codex project skill target', re: /Codex[^\n]*`\.agents\/skills\/`/i },
   { name: 'Continue global skill target', re: /Continue\.dev[^\n]*`~\/\.continue\/skills\/`/i },
@@ -92,7 +91,6 @@ requireText('docs/platform-compatibility.json', [
 requireText('README.md', [
   { name: 'local Codex plugin surface', re: /Codex \/ local OpenAI plugin|local OpenAI plugin/i },
   { name: 'public Skills-only distinction', re: /Public OpenAI[^\n]*Skills-only|public OpenAI \*\*Skills-only\*\*/i },
-  { name: 'OpenCode live-unverified qualifier', re: /OpenCode[^\n]*(?:live plugin loading|live loading) remains unverified/i },
   { name: 'canonical matrix link', re: /docs\/platform-capabilities\.md/ },
   { name: 'Codex repo Agent Skills path', re: /Codex[^\n]*`?\.agents\/skills\/?`?/i },
   { name: 'Continue native global skills path', re: /`~\/\.continue\/skills\/`/i },
@@ -109,12 +107,10 @@ requireText('AGENTS.md', [
 requireText('BENCHMARK_SOP.md', [
   { name: 'behavior vs mechanism separation', re: /behavior[^\n]{0,120}mechanism|mechanism\/live-host evidence/i },
   { name: 'Codex multi-surface distinction', re: /Codex \/ local OpenAI plugin|general Codex installer path/i },
-  { name: 'OpenCode live-unverified qualifier', re: /OpenCode[^\n]*(?:live plugin loading|live loading) remains unverified/i },
 ]);
 
 requireText('docs/architecture.md', [
   { name: 'Codex local plugin host adapter', re: /Codex[^\n]*local OpenAI plugin/i },
-  { name: 'OpenCode live loading remains unverified', re: /live (plugin )?loading remains unverified/i },
 ]);
 
 requireText('VERIFICATION.md', [
@@ -158,9 +154,64 @@ requireText('submission/openai/README.md', [
   { name: 'submission excludes local hooks', re: /does not contain the local `\.codex-plugin` lifecycle hooks/i },
 ]);
 
+const OPENCODE_EVIDENCE = 'benchmarks/results/live-host/opencode-2026-09-16/README.md';
+const OPENCODE_SURFACES = [
+  'README.md',
+  'AGENTS.md',
+  'BENCHMARK_SOP.md',
+  'VERIFICATION.md',
+  'docs/architecture.md',
+  'docs/platform-capabilities.md',
+  'docs/platform-compatibility.json',
+  'opencode-plugin/README.md',
+];
+
+read(OPENCODE_EVIDENCE);
+for (const rel of OPENCODE_SURFACES) {
+  requireText(rel, [
+    { name: 'OpenCode retained artifact path', re: /benchmarks\/results\/live-host\/opencode-2026-09-16\/README\.md/ },
+    { name: 'OpenCode host/version/OS scope', re: /OpenCode 1\.18\.31[^\n]{0,40}macOS/i },
+    { name: 'OpenCode project .js scope', re: /project[- ]scope[^\n]{0,100}\.js/i },
+    { name: 'OpenCode loading and state evidence', re: /loading[^\n]{0,120}edit\/verification state/i },
+    { name: 'OpenCode post-reset snapshot boundary', re: /post-reset/i },
+    { name: 'OpenCode operator-seeded reflection boundary', re: /operator-seeded/i },
+    { name: 'OpenCode hard-lock observation boundary', re: /hard[- ]lock[^\n]{0,100}interactive observation/i },
+    { name: 'OpenCode missing blocked-tool trace', re: /no (?:retained )?blocked-tool trace/i },
+    { name: 'OpenCode unverified remainder', re: /Global scope, npm-package installation, and other (?:OpenCode|host) versions remain unverified/i },
+  ]);
+  const text = read(rel);
+  for (const re of [/fired the full (?:enforcement )?chain/i, /Hard, live-verified/i, /live (?:plugin )?loading remains unverified until/i]) {
+    if (re.test(text)) fail(`${rel}: contains unsupported OpenCode claim ${re}`);
+  }
+}
+
+const matrix = JSON.parse(read('docs/platform-compatibility.json'));
+const opencode = matrix.platforms.find(platform => platform.id === 'opencode');
+for (const dimension of ['hooksLifecycle', 'liveHostVerification']) {
+  if (opencode?.capabilities[dimension]?.status !== 'Partial') {
+    fail(`OpenCode ${dimension}: must remain Partial`);
+  }
+}
+if (opencode?.capabilities.liveHostVerification.evidence !== OPENCODE_EVIDENCE) {
+  fail('OpenCode liveHostVerification: missing exact retained artifact path');
+}
+for (const platform of matrix.platforms.filter(platform => platform.id !== 'opencode')) {
+  if (platform.capabilities.liveHostVerification.status !== 'Unknown') {
+    fail(`${platform.id}: liveHostVerification must remain Unknown without its own evidence`);
+  }
+}
+
+const capabilitySummaryCount = read('docs/platform-capabilities.md').match(/^## Current capability summary$/gm)?.length;
+if (capabilitySummaryCount !== 1) fail('docs/platform-capabilities.md: expected one current capability summary');
+
 requireText('opencode-plugin/README.md', [
-  { name: 'live OpenCode evidence limitation', re: /Live opencode plugin loading remains unverified/i },
+  { name: 'project install directory creation', re: /mkdir -p \.opencode\/plugins\s+cp opencode-plugin\/index\.mjs \.opencode\/plugins\/harness-enforcement\.js/ },
+  { name: 'global install directory creation', re: /mkdir -p ~\/\.config\/opencode\/plugins\s+cp opencode-plugin\/index\.mjs ~\/\.config\/opencode\/plugins\/harness-enforcement\.js/ },
+  { name: 'restart after installation', re: /restart OpenCode/i },
 ]);
+if (/package names, not local file paths/i.test(read('opencode-plugin/README.md'))) {
+  fail('opencode-plugin/README.md: incorrect local plugin path exclusion');
+}
 
 requireText('docs/audit.md', [
   { name: 'historical snapshot boundary', re: /Historical snapshot boundary/i },

package/ci/mechanism-2w-platform-compatibility.test.js

@@ -70,11 +70,24 @@ for (const platform of matrix.platforms) {
     const capability = platform.capabilities[dimension];
     assert.ok(capability && STATUSES.has(capability.status), `${platform.id}/${dimension}: invalid status`);
   }
-  assert.strictEqual(
-    platform.capabilities.liveHostVerification.status,
-    'Unknown',
-    `${platform.id}: a live status requires a preserved host artifact before publication`
-  );
+  if (platform.id === 'opencode') {
+    const capability = platform.capabilities.liveHostVerification;
+    assert.strictEqual(capability.status, 'Partial');
+    assert.strictEqual(capability.evidence, 'benchmarks/results/live-host/opencode-2026-09-16/README.md');
+    const artifactRoot = path.dirname(path.join(ROOT, capability.evidence));
+    for (const file of ['README.md', 'probe-control.md', 'run-commands.md']) {
+      assert.ok(fs.statSync(path.join(artifactRoot, file)).size > 0, `Missing OpenCode evidence: ${file}`);
+    }
+    const session = path.join(artifactRoot, 'state', 'sessions', 'ses_f5520f1d9ffeB8KLTIUKgA5ng8');
+    const breaker = JSON.parse(fs.readFileSync(path.join(session, 'circuit-breaker.json'), 'utf8'));
+    const compliance = JSON.parse(fs.readFileSync(path.join(session, 'compliance.json'), 'utf8'));
+    assert.strictEqual(breaker.hardLock, false, 'Retained snapshot is post-reset, not hard-lock proof');
+    assert.ok(compliance.totalEdits > 0);
+    assert.ok(fs.statSync(path.join(session, 'edit-state.json')).size > 0);
+    assert.ok(fs.statSync(path.join(session, 'zoom-out-report.md')).size > 0);
+  } else {
+    assert.strictEqual(platform.capabilities.liveHostVerification.status, 'Unknown', `${platform.id}: no preserved live evidence`);
+  }
 }
 
 const installerTargetSpecs = {
@@ -142,7 +155,7 @@ try {
 const capabilityDocs = fs.readFileSync(path.join(ROOT, 'docs', 'platform-capabilities.md'), 'utf8');
 assert.match(capabilityDocs, /platform-compatibility\.json/);
 assert.match(capabilityDocs, /Continue\.dev[\s\S]*`Unknown` for standalone `SKILL\.md` discovery/);
-assert.match(capabilityDocs, /live plugin loading remains unverified/i);
-assert.match(capabilityDocs, /no fresh host-session artifacts/i);
+assert.match(capabilityDocs, /live-host evidence|Partial` live-host loading/i);
+assert.match(capabilityDocs, /No fresh artifacts exist yet|no fresh host-session artifacts/i);
 
 console.log('Platform compatibility verified: official-source matrix, installer targets, package manifests, and public bundle boundaries.');

package/ci/mechanism-30-opencode-plugin-loadability.test.js

@@ -0,0 +1,86 @@
+const assert = require('assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const vm = require('vm');
+const helper = require('./test-helper');
+
+const root = helper.root;
+const sourceFile = path.join(root, 'opencode-plugin', 'index.mjs');
+const runnerFile = path.join(root, 'behavioral-evals', 'run-with-plugin.js');
+const readmeFile = path.join(root, 'opencode-plugin', 'README.md');
+
+function pluginInstallTargets(text) {
+  return [...text.matchAll(/(?:\.opencode|(?:~[\\/])?\.config[\\/]opencode)[\\/]plugins?[\\/][\w.@/-]+/g)]
+    .map(match => match[0].replace(/[\\/]+$/, ''));
+}
+
+function invalidTargets(text) {
+  return pluginInstallTargets(text).filter(target => !/\.(?:js|ts)$/.test(target));
+}
+
+function installStatement(text) {
+  const statements = text.match(/fs\.copyFileSync\(path\.join\(PLUGIN_DIR,[^;]+;/g) || [];
+  assert.strictEqual(statements.length, 1, 'Expected one canonical plugin installation');
+  return statements[0];
+}
+
+function verifyInstall(text) {
+  const directory = fs.mkdtempSync(path.join(os.tmpdir(), 'harness-loadability-'));
+  try {
+    vm.runInNewContext(installStatement(text), {
+      fs, path,
+      PLUGIN_DIR: path.dirname(sourceFile),
+      opencodePluginsDir: directory,
+    }, { timeout: 1000 });
+    assert.deepStrictEqual(fs.readdirSync(directory), ['harness-enforcement.js']);
+    assert.ok(fs.readFileSync(sourceFile).equals(fs.readFileSync(path.join(directory, 'harness-enforcement.js'))));
+  } finally {
+    fs.rmSync(directory, { recursive: true, force: true });
+  }
+}
+
+function walk(directory) {
+  return fs.readdirSync(directory, { withFileTypes: true }).flatMap(entry => {
+    if (['node_modules', '.git'].includes(entry.name) || entry.isSymbolicLink()) return [];
+    const file = path.join(directory, entry.name);
+    const relative = path.relative(root, file).split(path.sep).join('/');
+    if (relative === 'benchmarks/results' || relative === 'CHANGELOG.md') return [];
+    return entry.isDirectory() ? walk(file) : [file];
+  });
+}
+
+try {
+  const runner = fs.readFileSync(runnerFile, 'utf8');
+  verifyInstall(runner);
+  assert.throws(() => verifyInstall(runner.replace('harness-enforcement.js', 'harness-enforcement.mjs')));
+  assert.throws(() => verifyInstall(runner.replace("'index.mjs'", "'plugin.json'")));
+
+  for (const extension of ['mjs', 'cjs', 'mts', 'cts', 'jsx', 'tsx', 'json']) {
+    for (const base of ['.opencode/plugins/', '~/.config/opencode/plugins/']) {
+      assert.strictEqual(invalidTargets(`${base}example.${extension}`).length, 1);
+    }
+  }
+  for (const base of ['.opencode/plugins/', '~/.config/opencode/plugins/']) {
+    assert.strictEqual(invalidTargets(`${base}example`).length, 1);
+    assert.deepStrictEqual(invalidTargets(`${base}example.js`), []);
+    assert.deepStrictEqual(invalidTargets(`${base}example.ts`), []);
+  }
+  assert.deepStrictEqual(invalidTargets('opencode-plugin/index.mjs .opencode/plugins/example.js'), []);
+
+  const violations = [];
+  for (const file of walk(root).filter(file => /\.(?:md|js|mjs|json|jsonc|yml|yaml|txt)$/.test(file))) {
+    const text = fs.readFileSync(file, 'utf8');
+    for (const target of invalidTargets(text)) violations.push(`${path.relative(root, file)}: ${target}`);
+  }
+  assert.deepStrictEqual(violations, [], 'Unsupported OpenCode install destinations; only .js/.ts are auto-discovered');
+  const readme = fs.readFileSync(readmeFile, 'utf8');
+  for (const destination of ['.opencode/plugins/harness-enforcement.js', '~/.config/opencode/plugins/harness-enforcement.js']) {
+    assert.ok(readme.includes(`cp opencode-plugin/index.mjs ${destination}`));
+  }
+  helper.check('30. real install statement produces a byte-identical .js/.ts-discoverable file; non-allowlisted filenames and content mutations fail', true);
+  helper.finish();
+} catch (error) {
+  helper.check('30. OpenCode installation contract', false, error.stack);
+  helper.finish();
+}

package/docs/architecture.md

@@ -100,9 +100,9 @@ The installer configures native lifecycle hooks and project skills.
 
 The prompt hook is intentionally lightweight: it does **not** prescribe TODO/TDD/Fable order. It gives the model the rails and lets the model orchestrate itself.
 
-### 2. OpenCode — plugin enforcement, live loading still unverified
+### 2. OpenCode — plugin enforcement, scoped live verification
 
-`opencode-plugin/` maps supported enforcement behavior to OpenCode's real plugin API. Source-level/mechanism tests exist, but live plugin loading remains unverified; do not promote source/mechanism evidence into a live-host enforcement claim until a real OpenCode session artifact exists.
+`opencode-plugin/` maps supported enforcement behavior to OpenCode's real plugin API with deterministic mechanism coverage. Partial live-host evidence supports project-scope `.js` loading and edit/verification state on OpenCode 1.18.31 (macOS): [retained evidence](../benchmarks/results/live-host/opencode-2026-09-16/README.md). The final snapshot is post-reset (`hardLock: false`, `count: 1`), 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; state-file deletion is an agent-controlled reset, not durable hard enforcement. This does not establish behavioral effectiveness. `.mjs` auto-discovery is broken on this host version (issue #127). Global scope, npm-package installation, and other host versions remain unverified.
 
 ### 3. Cursor — skills plus advisory rules
 

package/docs/platform-capabilities.md

@@ -15,7 +15,7 @@ Statuses are intentionally explicit:
 - `Unsupported`: official host documentation explicitly rules out the capability.
 - `Unknown`: the capability or its current host behavior was not established.
 
-All current `liveHostVerification` rows are `Unknown`. This checkout contains deterministic package and installer evidence, but no fresh host-session artifacts, managed-workspace import report, or public OpenAI approval record.
+All `liveHostVerification` rows except OpenCode are `Unknown`. OpenCode's row is `Partial`: retained evidence supports project-scope `.js` loading and edit/verification state on OpenCode 1.18.31 (macOS), not durable hard enforcement. No fresh artifacts exist yet for the other surfaces, managed-workspace import, or public OpenAI approval.
 
 ## Current capability summary
 
@@ -24,7 +24,7 @@ All current `liveHostVerification` rows are `Unknown`. This checkout contains de
 | Codex | `Supported` | `Mechanism verified` | `Mechanism verified` for the local OpenAI package, including session, prompt, supported-tool, subagent, and stop hooks | `.agents/skills/`, `AGENTS.md` | `~/.agents/skills/` | Local package hooks are mechanically checked; live loading and marketplace refresh remain `Unknown`. |
 | ChatGPT / OpenAI Plugin | `Unknown` for a repository-local standalone path | `Mechanism verified` | `Partial`: local Work/Codex hooks are separate from ordinary Chat | Managed workspace marketplace | Not established | The public Skills-only bundle is mechanically reproducible; import, approval, and live behavior remain `Unknown`. |
 | Claude Code | `Supported` | `Supported` | `Mechanism verified` for Harness configuration | `.claude/skills/` | `~/.claude/skills/` | Native Claude surfaces are documented and package/installer checks pass; fresh-host execution is not preserved here. |
-| OpenCode | `Supported` | `Mechanism verified` | `Mechanism verified` against `tool.execute.*` and `session.idle` | `.opencode/skills/`, `.agents/skills/`, `.opencode/plugins/` | `~/.config/opencode/skills/`, `~/.agents/skills/`, `~/.config/opencode/plugins/` | The real adapter API is tested, but live plugin loading remains unverified. |
+| OpenCode | `Supported` | `Partial` live-host loading for the project-scope, `.js`-filename install path on OpenCode 1.18.31 (macOS); other install paths remain `Mechanism verified` | `Partial` live-host evidence for project-scope `.js` loading and edit/verification state; hard lock reported only, with no retained blocked-tool trace and a post-reset final snapshot | `.opencode/skills/`, `.agents/skills/`, `.opencode/plugins/` | `~/.config/opencode/skills/`, `~/.agents/skills/`, `~/.config/opencode/plugins/` | [Retained evidence](../benchmarks/results/live-host/opencode-2026-09-16/README.md): loading and state effects verified in one host session; final snapshot post-reset; hard lock only an interactive observation; reflection operator-seeded, then agent-rewritten; no raw transcript or behavioral-effectiveness claim. `.mjs` auto-discovery broken (issue #127); global scope, npm-package installation, and other host versions remain unverified. |
 | GitHub Copilot agent surfaces | `Supported` | `Unknown` for a Harness-specific plugin install | `Unknown` | `.github/skills/`, `.agents/skills/`, repository instructions | `~/.copilot/skills/`, `~/.agents/skills/` | GitHub Agent Skills paths and installer behavior are checked; no live Copilot session or plugin install is preserved. |
 | Cursor | `Supported` | `Mechanism verified` for the portable package shape | `Unknown` for Harness | `.cursor/skills/`, `.agents/skills/` | `~/.cursor/skills/`, `~/.agents/skills/` | Official paths and package shape are checked; Cursor plugin loading and hooks remain unverified. |
 | Continue.dev | `Unknown` for standalone `SKILL.md` discovery | `Unknown` | `Unknown` | `.continue/rules/` is documented; `.continue/skills/` is only an installer candidate | `~/.continue/skills/` is only an installer candidate | The reviewed official docs establish rules, not an Agent Skills host contract. |
@@ -64,7 +64,7 @@ The general installer merges shared files only through Harness-owned markers and
 
 ## OpenCode boundary
 
-The OpenCode adapter uses the documented plugin API and has deterministic mechanism coverage. That proves the implementation contract only. **Live plugin loading remains unverified** until a real OpenCode session artifact demonstrates that the host loaded and fired the module.
+The OpenCode adapter uses the documented plugin API and has deterministic mechanism coverage. Retained evidence supports project-scope `.js` 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`), 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. Agent-controlled state deletion resets the breaker, so do not promote this into a durable hard-enforcement or behavioral-effectiveness claim. `.mjs` auto-discovery is broken on this host version (issue #127). Global scope, npm-package installation, and other host versions remain unverified.
 
 ## Official sources
 

package/docs/platform-compatibility.json

@@ -172,15 +172,15 @@
       ],
       "capabilities": {
         "standaloneSkills": {"status": "Supported", "paths": {"project": [".opencode/skills", ".agents/skills", ".claude/skills"], "global": ["~/.config/opencode/skills", "~/.agents/skills", "~/.claude/skills"]}},
-        "pluginSupport": {"status": "Mechanism verified", "paths": {"project": [".opencode/plugins"], "global": ["~/.config/opencode/plugins"]}},
+        "pluginSupport": {"status": "Partial", "paths": {"project": [".opencode/plugins"], "global": ["~/.config/opencode/plugins"]}, "notes": "Live verified scoped: project-scope install of the plugin copied under a .js filename loads on OpenCode 1.18.31 (macOS) and edit/verification state effects are retained (benchmarks/results/live-host/opencode-2026-09-16/README.md). The host discovery silently ignores .mjs install names (issue #127). Global scope and npm-package installation remain mechanism-only."},
         "bundledSkills": {"status": "Partial", "notes": "Harness provides a standalone enforcement module; it is not an OpenCode bundled-skill package."},
-        "hooksLifecycle": {"status": "Mechanism verified", "notes": "tool.execute.before, tool.execute.after, and session.idle are covered against the documented plugin API."},
-        "projectScope": {"status": "Mechanism verified", "paths": {"skills": [".opencode/skills", ".agents/skills"], "plugins": [".opencode/plugins"]}},
+        "hooksLifecycle": {"status": "Partial", "notes": "Live-host evidence covers project-scope .js loading and edit/verification state (edit tracking, forced verification, breaker failure recording) on OpenCode 1.18.31 (macOS); hard lock is only an interactive observation with no retained blocked-tool trace and the final snapshot is post-reset (benchmarks/results/live-host/opencode-2026-09-16/README.md). Global scope, npm-package installation, and other host versions remain mechanism-tested."},
+        "projectScope": {"status": "Partial", "paths": {"skills": [".opencode/skills", ".agents/skills"], "plugins": [".opencode/plugins"]}, "notes": "Plugin loading at project scope and edit/verification state are live-verified via the retained host session artifact; standalone skill discovery remains path-contract verified."},
         "globalScope": {"status": "Mechanism verified", "paths": {"skills": ["~/.config/opencode/skills", "~/.agents/skills"], "plugins": ["~/.config/opencode/plugins"]}},
         "installUninstallSymmetry": {"status": "Unknown", "notes": "The adapter is manually copied; Harness does not own an OpenCode install/uninstall flow."},
         "assetsReferences": {"status": "Mechanism verified", "notes": "The adapter is self-contained and skill references are separately checked."},
         "updateSync": {"status": "Unknown", "notes": "No live OpenCode refresh or npm plugin update is preserved."},
-        "liveHostVerification": {"status": "Unknown", "notes": "The real OpenCode host has not loaded the module in a preserved session artifact."}
+        "liveHostVerification": {"status": "Partial", "evidence": "benchmarks/results/live-host/opencode-2026-09-16/README.md", "notes": "Retained evidence supports project-scope .js plugin loading and edit/verification state on OpenCode 1.18.31 (macOS), not durable hard enforcement: final snapshot is post-reset (hardLock: false), hard lock only an interactive observation with no retained blocked-tool trace, reflection operator-seeded, agent-controlled state deletion resets the breaker. Global scope, npm-package installation, and other host versions remain unverified."}
       }
     },
     {

package/opencode-plugin/README.md

@@ -3,7 +3,7 @@
 Adds hard enforcement gates for Harness skills in opencode, addressing the
 limitation that skills are otherwise advisory-only on that platform.
 
-> **Evidence boundary:** the plugin is implemented against opencode's real plugin API and covered by deterministic mechanism tests. **Live opencode plugin loading remains unverified** until a real host session artifact proves the host loaded and fired these hooks. See [`../docs/platform-capabilities.md`](../docs/platform-capabilities.md).
+> **Evidence boundary:** the plugin is implemented against opencode's real plugin API and covered by deterministic mechanism tests. Live plugin loading remains unverified beyond one scoped surface: retained evidence supports project-scope `.js` 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`), 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; agent-controlled state deletion resets the breaker, so no durable hard enforcement or behavioral effectiveness is claimed. Global scope, npm-package installation, and other host versions remain unverified. See [`../docs/platform-capabilities.md`](../docs/platform-capabilities.md).
 
 ## Problem
 
@@ -20,15 +20,18 @@ actually loads: a JS/TS file exporting a function that returns a hooks
 object (see https://opencode.ai/docs/plugins/). There is no manifest-to-script
 mechanism; an earlier version of this plugin assumed one (a `plugin.json`
 mapping event names to standalone scripts) and opencode never invoked it -
-see issue #37 for how that was found and fixed.
+see issue #37 for how that was found and fixed. **Naming caveat (issue
+#127):** opencode's discovery glob only matches `*.js`/`*.ts`, so the file
+must be copied to a `.js` name when installed - see Installation below.
 
 It implements three enforcement mechanisms across opencode's real hooks:
 
 The module follows opencode's V1 plugin contract directly: the named
 `HarnessEnforcement` export is an async factory receiving the opencode context
 (`client`, `directory`, `project`, `worktree`, and `$`) and returning the hook
-map. Copying this one `.mjs` file into `.opencode/plugins/` is enough for
-opencode to discover and invoke it; `plugin.json` is only a repository
+map. Copying this one file into `.opencode/plugins/` under a `.js` name is
+enough for opencode to discover and invoke it; `plugin.json` is only a
+repository
 inventory and is not an opencode runtime manifest. The hook callbacks use the
 V1 `(input, output)` shape, including
 `output.args` when the host supplies tool arguments only in the result object.
@@ -73,18 +76,30 @@ new breaker failure. A reflection artifact itself does not count as a code edit.
 
 ## Installation
 
-Copy `index.mjs` into opencode's plugin directory - it is self-contained, no
-sibling files required:
+Copy `index.mjs` into opencode's plugin directory **under a `.js` filename** -
+it is self-contained, no sibling files required:
 
 ```bash
-cp opencode-plugin/index.mjs .opencode/plugins/harness-enforcement.mjs   # project-level
+mkdir -p .opencode/plugins
+cp opencode-plugin/index.mjs .opencode/plugins/harness-enforcement.js   # project-level
 # or
-cp opencode-plugin/index.mjs ~/.config/opencode/plugins/harness-enforcement.mjs  # global
+mkdir -p ~/.config/opencode/plugins
+cp opencode-plugin/index.mjs ~/.config/opencode/plugins/harness-enforcement.js  # global
 ```
 
-opencode auto-loads any file dropped in those directories at startup - no
-`opencode.json` entry needed. (`opencode.json`'s `plugin` array is for npm
-package names, not local file paths.)
+Restart OpenCode after copying so the plugin is discovered at startup.
+
+The destination extension matters: opencode's plugin auto-discovery scans
+only `*.js` / `*.ts` files in those directories (`{plugin,plugins}/*.{ts,js}`
+in its v1 loader), so a `.mjs` copy is **silently never loaded** - no error,
+no hooks, no state. Verified live on opencode 1.18.31 with an extension A/B
+probe (see
+[`benchmarks/results/live-host/opencode-2026-09-16/probe-control.md`](../benchmarks/results/live-host/opencode-2026-09-16/probe-control.md)).
+
+opencode auto-loads `.js`/`.ts` files dropped in those directories at startup -
+no `opencode.json` entry needed. This procedure tests directory discovery;
+explicit local-file configuration and npm-package installation are separate
+installation surfaces and were not verified in this run.
 
 ## Manual verification CLI
 
@@ -135,3 +150,9 @@ fail-closed behavior, and patch-based reflection writes.
 It does not launch a real opencode process; the test remains a deterministic
 hook-sequence check against the documented and source-verified hook signatures.
 A passing test is therefore mechanism evidence, not live-host loading evidence.
+Live-host evidence and the install-filename loadability guard live elsewhere:
+the host session artifact is
+[`benchmarks/results/live-host/opencode-2026-09-16/`](../benchmarks/results/live-host/opencode-2026-09-16/),
+and `ci/mechanism-30-opencode-plugin-loadability.test.js` (npm script
+`test:opencode:loadability`) fails any change that reintroduces a
+silently-ignored install filename such as `harness-enforcement.mjs`.

package/opencode-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "harness-enforcement",
   "description": "Repository inventory for the opencode enforcement plugin and its standalone helper",
-  "version": "0.5.2",
+  "version": "0.5.3",
   "runtime": "index.mjs",
   "hooks": {
     "verify": "hooks/verify.js"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "harness-everything",
-  "version": "0.5.2",
+  "version": "0.5.3",
   "description": "Harness OS: An Orchestrated Agent Operating System for AI-driven Development",
   "main": "harness-everything/scripts/bootstrap.js",
   "bin": {
@@ -10,6 +10,7 @@
     "test": "node self-evolve/scripts/self-regression.js",
     "self-regression": "node self-evolve/scripts/self-regression.js",
     "test:mechanism": "node ci/mechanism-test.js",
+    "test:opencode:loadability": "node ci/mechanism-30-opencode-plugin-loadability.test.js",
     "test:mutations": "node ci/mutation-check.js",
     "test:tdd-quality": "node ci/mechanism-2s-tdd-quality.test.js",
     "tdd:quality": "node tdd/scripts/quality-gate.js",

package/plugins/harness-everything/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "harness-everything",
-  "version": "0.5.2",
+  "version": "0.5.3",
   "description": "Invariant-first engineering harness for routing, verification, and failure recovery while preserving agent autonomy.",
   "author": {
     "name": "Miya Daniel",

package/plugins/harness-everything/plugin.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
   "name": "harness-everything",
-  "version": "0.5.2",
+  "version": "0.5.3",
   "description": "Invariant-first engineering harness for routing, verification, and failure recovery while preserving agent autonomy.",
   "author": {
     "name": "Miya Daniel",