harness-everything 0.5.2 → 0.6.0

package/ci/mechanism-31-opencode-hardlock-evidence.test.js

@@ -0,0 +1,138 @@
+const fs = require('fs');
+const path = require('path');
+const helper = require('./test-helper');
+const {
+  BLOCKED_MARKER,
+  HARDLOCK_MESSAGE,
+  INSTALLED_PLUGIN_NAME,
+  POST_REFLECTION_MARKER,
+  PRELOCK_MARKER,
+  verifyEvidence,
+} = require('../behavioral-evals/opencode-hardlock-live');
+
+console.log('\n[31] opencode live hard-lock evidence contract...');
+
+function writeJson(file, value) {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, JSON.stringify(value, null, 2));
+}
+
+function makeEvidence() {
+  const dir = helper.tempDir('.mechanism-test-opencode-live-evidence');
+  fs.mkdirSync(path.join(dir, 'workspace'), { recursive: true });
+  fs.mkdirSync(path.join(dir, 'state'), { recursive: true });
+  const pluginHash = 'a'.repeat(64);
+  writeJson(path.join(dir, 'metadata.json'), {
+    schemaVersion: 1,
+    stateIsolated: true,
+    installedPluginName: INSTALLED_PLUGIN_NAME,
+    pluginSha256: pluginHash,
+    installedPluginSha256: pluginHash,
+  });
+  const toolEvent = (input) => JSON.stringify({
+    type: 'tool',
+    part: { tool: 'edit', state: { input } },
+  });
+  fs.writeFileSync(path.join(dir, 'transcript.jsonl'), [
+    toolEvent({ filePath: 'probe.txt', text: PRELOCK_MARKER }),
+    toolEvent({ filePath: 'probe.txt', text: POST_REFLECTION_MARKER }),
+    toolEvent({ filePath: 'probe.txt', text: BLOCKED_MARKER }),
+    JSON.stringify({ type: 'text', part: { text: `${HARDLOCK_MESSAGE} after a repeat failure post-reflection.` } }),
+    '',
+  ].join('\n'));
+  fs.writeFileSync(path.join(dir, 'stderr.txt'), '', 'utf8');
+  fs.writeFileSync(path.join(dir, 'workspace', 'probe.txt'), `baseline\n${PRELOCK_MARKER}\n${POST_REFLECTION_MARKER}\n`, 'utf8');
+  writeJson(path.join(dir, 'state', 'circuit-breaker.json'), {
+    failures: {
+      'npm test: HARNESS_LIVE_PROBE_RED': { count: 4, firstSeen: 1, lastSeen: 5 },
+    },
+    hardLock: true,
+    lastReflection: 4,
+    lastReflectionSignature: 'npm test: HARNESS_LIVE_PROBE_RED',
+    reflectionPending: false,
+    reflectionRequestedAt: null,
+    reflectionToken: null,
+    reflectionSignature: null,
+  });
+  fs.writeFileSync(path.join(dir, 'state', 'zoom-out-report.md'), [
+    '## Goal',
+    'exercise the breaker',
+    '## Failed Attempts',
+    'three controlled failures',
+    '## Verified Facts',
+    'the verification fixture intentionally stays red',
+    '## Diagnosis',
+    'this is a live enforcement probe',
+    '## Decision',
+    'RESUME: reproduce the same failure once after reflection',
+    'Reflection token: abc123',
+    '',
+  ].join('\n'));
+  return dir;
+}
+
+try {
+  const valid = makeEvidence();
+  let result = verifyEvidence(valid);
+  helper.check('31. complete attributed hard-lock evidence passes', result.passed, JSON.stringify(result.checks.filter((entry) => !entry.pass)));
+
+  const wrongPlugin = makeEvidence();
+  const metadataFile = path.join(wrongPlugin, 'metadata.json');
+  const metadata = JSON.parse(fs.readFileSync(metadataFile, 'utf8'));
+  metadata.installedPluginSha256 = 'b'.repeat(64);
+  writeJson(metadataFile, metadata);
+  result = verifyEvidence(wrongPlugin);
+  helper.check(
+    '31. evidence fails when the installed plugin hash differs from the canonical source hash',
+    !result.passed && result.checks.some((entry) => entry.name === 'installed plugin is byte-identical to the recorded canonical source' && !entry.pass),
+    JSON.stringify(result.checks),
+  );
+
+  const landed = makeEvidence();
+  fs.appendFileSync(path.join(landed, 'workspace', 'probe.txt'), `${BLOCKED_MARKER}\n`);
+  result = verifyEvidence(landed);
+  helper.check(
+    '31. negative control fails if the blocked marker reached the filesystem',
+    !result.passed && result.checks.some((entry) => entry.name === 'blocked marker did not reach the filesystem' && !entry.pass),
+    JSON.stringify(result.checks),
+  );
+
+  const unlocked = makeEvidence();
+  const breakerFile = path.join(unlocked, 'state', 'circuit-breaker.json');
+  const breaker = JSON.parse(fs.readFileSync(breakerFile, 'utf8'));
+  breaker.hardLock = false;
+  writeJson(breakerFile, breaker);
+  result = verifyEvidence(unlocked);
+  helper.check(
+    '31. evidence fails without a pre-reset hard-lock snapshot',
+    !result.passed && result.checks.some((entry) => entry.name === 'pre-reset breaker snapshot is hard-locked' && !entry.pass),
+    JSON.stringify(result.checks),
+  );
+
+  const noAttempt = makeEvidence();
+  const transcript = fs.readFileSync(path.join(noAttempt, 'transcript.jsonl'), 'utf8')
+    .split(/\r?\n/)
+    .filter((line) => !line.includes(BLOCKED_MARKER))
+    .join('\n');
+  fs.writeFileSync(path.join(noAttempt, 'transcript.jsonl'), transcript);
+  result = verifyEvidence(noAttempt);
+  helper.check(
+    '31. evidence fails when the final blocked edit was never observed as a structured tool attempt',
+    !result.passed && result.checks.some((entry) => entry.name === 'structured tool trace contains the final blocked edit attempt' && !entry.pass),
+    JSON.stringify(result.checks),
+  );
+
+  const noReflection = makeEvidence();
+  fs.rmSync(path.join(noReflection, 'state', 'zoom-out-report.md'));
+  result = verifyEvidence(noReflection);
+  helper.check(
+    '31. evidence fails without the preserved reflection artifact',
+    !result.passed && result.checks.some((entry) => entry.name === 'reflection artifact is valid and preserved' && !entry.pass),
+    JSON.stringify(result.checks),
+  );
+
+  helper.finish();
+} catch (error) {
+  helper.check('31. OpenCode hard-lock live evidence contract', false, error.stack);
+  helper.finish();
+}

package/ci/mechanism-32-paired-benchmark.test.js

@@ -0,0 +1,254 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const helper = require('./test-helper');
+const {
+  mcnemarExactP,
+  prepareArmWorkspace,
+  summarizePairs,
+  validatePairRecord,
+  validateRunConfig,
+} = require('../behavioral-evals/paired-benchmark');
+
+console.log('\n[32] paired behavioral benchmark contract...');
+
+function stable(value) {
+  if (Array.isArray(value)) return value.map(stable);
+  if (!value || typeof value !== 'object') return value;
+  return Object.fromEntries(Object.keys(value).sort().map((key) => [key, stable(value[key])]));
+}
+
+function hash(value) {
+  return crypto.createHash('sha256').update(JSON.stringify(stable(value))).digest('hex');
+}
+
+function skillContract(caseId = 'case-a') {
+  return {
+    schema_version: 1,
+    effect_type: 'skill-text',
+    engine: 'opencode',
+    requested_model: 'test/model',
+    case_id: caseId,
+    max_turns: 8,
+    loaded_skills: ['tdd'],
+    fixture_sha256: 'fixture-hash',
+    prompt_sha256: 'prompt-hash',
+    rubric_sha256: 'rubric-hash',
+    execution_policy: 'opencode-auto',
+  };
+}
+
+function arm(outcome, treatment, overrides = {}) {
+  return {
+    outcome,
+    model_name: 'test/model',
+    intervention: {
+      skill_text: treatment,
+      plugin_enforcement: false,
+    },
+    loaded_skills: treatment ? ['tdd'] : [],
+    plugin_sha256: null,
+    plugin_attribution: null,
+    cost: treatment ? 2 : 1,
+    total_tokens: treatment ? 120 : 100,
+    tool_call_count: treatment ? 4 : 3,
+    duration_ms: treatment ? 1200 : 1000,
+    ...overrides,
+  };
+}
+
+function skillPair(id, baselineOutcome, treatmentOutcome, overrides = {}) {
+  const contract = skillContract(overrides.caseId || id);
+  return {
+    schema_version: 1,
+    id: overrides.caseId || id,
+    pair_id: id,
+    effect_type: 'skill-text',
+    contract,
+    contract_sha256: hash(contract),
+    arms: {
+      baseline: arm(baselineOutcome, false, overrides.baseline || {}),
+      treatment: arm(treatmentOutcome, true, overrides.treatment || {}),
+    },
+  };
+}
+
+try {
+  const missingThreshold = validateRunConfig({
+    effect_type: 'skill-text', engine: 'opencode', model: 'test/model',
+    min_effect_pp: NaN, repeats: 1,
+  });
+  helper.check(
+    '32. a paired study cannot start without a predeclared minimum effect',
+    missingThreshold.some((problem) => problem.includes('min-effect-pp')),
+    missingThreshold.join('; '),
+  );
+
+  const noModel = validateRunConfig({
+    effect_type: 'skill-text', engine: 'opencode', model: '',
+    min_effect_pp: 10, repeats: 1,
+  });
+  helper.check(
+    '32. an explicit model is required so both arms share the same model contract',
+    noModel.some((problem) => problem.includes('explicit --model')),
+    noModel.join('; '),
+  );
+
+  const badPluginEngine = validateRunConfig({
+    effect_type: 'plugin-enforcement', engine: 'claude', model: 'test/model',
+    min_effect_pp: 10, repeats: 1,
+  });
+  helper.check(
+    '32. plugin-enforcement is not generalized beyond the currently attributed OpenCode surface',
+    badPluginEngine.some((problem) => problem.includes('opencode only')),
+    badPluginEngine.join('; '),
+  );
+
+  const fixtureCase = {
+    id: 'workspace-shape',
+    discipline: 'tdd',
+    fixture: { files: [{ path: 'probe.txt', content: 'baseline\n' }] },
+  };
+  const skillBaseline = prepareArmWorkspace(fixtureCase, 'skill-text', 'baseline', 'opencode');
+  const skillTreatment = prepareArmWorkspace(fixtureCase, 'skill-text', 'treatment', 'opencode');
+  helper.check(
+    '32. skill-text control contains no Harness skill or plugin',
+    !fs.existsSync(path.join(skillBaseline.ws, '.claude', 'skills', 'tdd', 'SKILL.md')) &&
+      !fs.existsSync(path.join(skillBaseline.ws, '.opencode', 'plugins', 'harness-enforcement.js')),
+    skillBaseline.ws,
+  );
+  helper.check(
+    '32. skill-text treatment installs the named skill without installing hooks/plugin enforcement',
+    fs.existsSync(path.join(skillTreatment.ws, '.claude', 'skills', 'tdd', 'SKILL.md')) &&
+      !fs.existsSync(path.join(skillTreatment.ws, '.claude', 'settings.json')) &&
+      !fs.existsSync(path.join(skillTreatment.ws, '.opencode', 'plugins', 'harness-enforcement.js')),
+    skillTreatment.ws,
+  );
+  fs.rmSync(skillBaseline.ws, { recursive: true, force: true });
+  fs.rmSync(skillTreatment.ws, { recursive: true, force: true });
+
+  const pluginBaseline = prepareArmWorkspace(fixtureCase, 'plugin-enforcement', 'baseline', 'opencode');
+  const pluginTreatment = prepareArmWorkspace(fixtureCase, 'plugin-enforcement', 'treatment', 'opencode');
+  helper.check(
+    '32. plugin experiment holds skill text constant and changes only enforcement installation',
+    fs.existsSync(path.join(pluginBaseline.ws, '.claude', 'skills', 'tdd', 'SKILL.md')) &&
+      fs.existsSync(path.join(pluginTreatment.ws, '.claude', 'skills', 'tdd', 'SKILL.md')) &&
+      !fs.existsSync(path.join(pluginBaseline.ws, '.opencode', 'plugins', 'harness-enforcement.js')) &&
+      fs.existsSync(path.join(pluginTreatment.ws, '.opencode', 'plugins', 'harness-enforcement.js')),
+    JSON.stringify({ baseline: pluginBaseline.ws, treatment: pluginTreatment.ws }),
+  );
+  fs.rmSync(pluginBaseline.ws, { recursive: true, force: true });
+  fs.rmSync(pluginTreatment.ws, { recursive: true, force: true });
+
+  const validSkillPair = skillPair('p1', 'fail', 'pass');
+  helper.check('32. a correctly isolated skill-text pair is includable', validatePairRecord(validSkillPair).included, JSON.stringify(validatePairRecord(validSkillPair)));
+
+  const modelMismatch = skillPair('model-mismatch', 'fail', 'pass', {
+    treatment: { model_name: 'other/model' },
+  });
+  helper.check(
+    '32. actual model mismatch excludes the pair instead of counting it as behavior',
+    !validatePairRecord(modelMismatch).included && validatePairRecord(modelMismatch).reason === 'actual-model-mismatch',
+    JSON.stringify(validatePairRecord(modelMismatch)),
+  );
+
+  const pluginContract = {
+    schema_version: 1,
+    effect_type: 'plugin-enforcement',
+    engine: 'opencode',
+    requested_model: 'test/model',
+    case_id: 'plugin-case',
+    max_turns: 8,
+    loaded_skills: ['tdd'],
+    fixture_sha256: 'fixture-hash',
+    prompt_sha256: 'prompt-hash',
+    rubric_sha256: 'rubric-hash',
+    execution_policy: 'opencode-auto',
+  };
+  const pluginPair = {
+    id: 'plugin-case',
+    pair_id: 'plugin-pair',
+    effect_type: 'plugin-enforcement',
+    contract: pluginContract,
+    contract_sha256: hash(pluginContract),
+    preflight: { passed: true, plugin_sha256: 'plugin-hash' },
+    arms: {
+      baseline: {
+        ...arm('fail', true),
+        intervention: { skill_text: true, plugin_enforcement: false },
+        loaded_skills: ['tdd'],
+      },
+      treatment: {
+        ...arm('pass', true),
+        intervention: { skill_text: true, plugin_enforcement: true },
+        loaded_skills: ['tdd'],
+        plugin_sha256: 'plugin-hash',
+        plugin_attribution: { fired: true, state_files: ['workspaces/x/state/sessions/y/edit-state.json'] },
+      },
+    },
+  };
+  helper.check(
+    '32. plugin pair is includable only when preflight, hash, constant skill text, and per-arm attribution agree',
+    validatePairRecord(pluginPair).included,
+    JSON.stringify(validatePairRecord(pluginPair)),
+  );
+  const unattributedPlugin = JSON.parse(JSON.stringify(pluginPair));
+  unattributedPlugin.pair_id = 'plugin-unattributed';
+  unattributedPlugin.arms.treatment.plugin_attribution.fired = false;
+  helper.check(
+    '32. missing live plugin attribution is infrastructure/inconclusive, not a behavioral result',
+    !validatePairRecord(unattributedPlugin).included && validatePairRecord(unattributedPlugin).reason === 'plugin-attribution-missing',
+    JSON.stringify(validatePairRecord(unattributedPlugin)),
+  );
+
+  const records = [
+    skillPair('a-r1', 'fail', 'pass', { caseId: 'a' }),
+    skillPair('a-r2', 'fail', 'pass', { caseId: 'a' }),
+    skillPair('b-r1', 'pass', 'fail', { caseId: 'b' }),
+    skillPair('c-r1', 'pass', 'pass', { caseId: 'c' }),
+    skillPair('infra-r1', 'pass', 'session-error', { caseId: 'infra' }),
+  ];
+  const summary = summarizePairs(records, 10);
+  helper.check(
+    '32. summary excludes infrastructure outcomes and reports paired transitions',
+    summary.requested_pairs === 5 && summary.included_pairs === 4 && summary.excluded_pairs === 1 &&
+      summary.transitions['fail->pass'] === 2 && summary.transitions['pass->fail'] === 1 &&
+      summary.transitions['pass->pass'] === 1 && summary.transitions['fail->fail'] === 0,
+    JSON.stringify(summary),
+  );
+  helper.check(
+    '32. paired effect is derived from within-pair transitions and carries a deterministic uncertainty interval',
+    summary.paired_effect_pp === 25 && Array.isArray(summary.paired_effect_ci95_pp) && summary.paired_effect_ci95_pp.length === 2,
+    JSON.stringify(summary),
+  );
+  helper.check(
+    '32. repeated runs remain separate samples and expose per-case variance instead of overwriting',
+    summary.repeat_variance.a.repeats === 2 && summary.repeat_variance.a.paired_difference_variance === 0,
+    JSON.stringify(summary.repeat_variance),
+  );
+  helper.check(
+    '32. cost and execution overhead are reported separately from correctness',
+    summary.cost_and_execution_overhead.cost_delta.mean === 1 &&
+      summary.cost_and_execution_overhead.token_delta.mean === 20 &&
+      summary.cost_and_execution_overhead.tool_call_delta.mean === 1 &&
+      summary.cost_and_execution_overhead.duration_ms_delta.mean === 200,
+    JSON.stringify(summary.cost_and_execution_overhead),
+  );
+  helper.check(
+    '32. exact discordant-pair statistic is available without turning it into an unpaired pass-rate verdict',
+    mcnemarExactP(2, 1) === 1 && summary.mcnemar_exact_p === 1,
+    JSON.stringify({ direct: mcnemarExactP(2, 1), summary: summary.mcnemar_exact_p }),
+  );
+  helper.check(
+    '32. the predeclared practical threshold is retained in the summary decision contract',
+    summary.decision.min_effect_pp === 10 && /predeclared/i.test(summary.decision.rule),
+    JSON.stringify(summary.decision),
+  );
+
+  helper.finish();
+} catch (error) {
+  helper.check('32. paired behavioral benchmark 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.6.0",
   "runtime": "index.mjs",
   "hooks": {
     "verify": "hooks/verify.js"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "harness-everything",
-  "version": "0.5.2",
+  "version": "0.6.0",
   "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",
@@ -39,6 +40,9 @@
     "eval:behavioral": "node behavioral-evals/run.js run",
     "eval:behavioral:validate": "node behavioral-evals/run.js validate",
     "eval:behavioral:plugin": "node behavioral-evals/run-with-plugin.js run",
+    "eval:opencode:hardlock-live": "node behavioral-evals/opencode-hardlock-live.js run",
+    "eval:paired": "node behavioral-evals/paired-benchmark.js run",
+    "eval:paired:summarize": "node behavioral-evals/paired-benchmark.js summarize",
     "test:ab": "node ci/ab-test-harness.js validate",
     "test:ab:run": "node ci/ab-test-harness.js run",
     "harness:reset": "node hooks/scripts/reset-circuit-breaker.js",

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

@@ -1,6 +1,6 @@
 {
   "name": "harness-everything",
-  "version": "0.5.2",
+  "version": "0.6.0",
   "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.6.0",
   "description": "Invariant-first engineering harness for routing, verification, and failure recovery while preserving agent autonomy.",
   "author": {
     "name": "Miya Daniel",