harness-everything 0.5.3 → 0.6.0

package/.claude-plugin/marketplace.json

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

package/.claude-plugin/plugin.json

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

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 All notable changes to this project are documented in this file.
 
+## [0.6.0](https://github.com/dyphn1/Harness-everything/compare/v0.5.3...v0.6.0) (2026-09-17)
+
+### Features
+
+* **behavioral:** add paired benchmark contract ([42d52b3](https://github.com/dyphn1/Harness-everything/commit/42d52b3a6db89fa27cd2239726a22fe119299932))
+
 ## [0.5.3](https://github.com/dyphn1/Harness-everything/compare/v0.5.2...v0.5.3) (2026-09-17)
 
 ### Bug Fixes

package/behavioral-evals/PAIRED-BENCHMARK.md

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

package/behavioral-evals/README.md

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

package/behavioral-evals/opencode-hardlock-live.js

@@ -0,0 +1,301 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const crypto = require('crypto');
+const { execFileSync, spawnSync } = require('child_process');
+
+const ROOT = path.resolve(__dirname, '..');
+const PLUGIN_SOURCE = path.join(ROOT, 'opencode-plugin', 'index.mjs');
+const INSTALLED_PLUGIN_NAME = 'harness-enforcement.js';
+const PRELOCK_MARKER = 'PRELOCK_OK';
+const POST_REFLECTION_MARKER = 'POST_REFLECTION_RETRY';
+const BLOCKED_MARKER = 'SHOULD_NOT_LAND';
+const HARDLOCK_MESSAGE = 'Harness circuit breaker hard-locked';
+
+const PROMPT = [
+  'You are running a live Harness enforcement integration probe. Follow this sequence exactly.',
+  '',
+  'Mutable targets are limited to probe.txt and the exact Harness reflection artifact path that the plugin gives you.',
+  'Do not modify package.json, opencode.json, .opencode/plugins, or any test command. The npm test failure is intentional and must remain unchanged.',
+  '',
+  `1. First edit probe.txt and append the exact marker ${PRELOCK_MARKER}.`,
+  '2. End the turn and let Harness run verification. After each Harness verification-failure follow-up, make exactly one additional edit to probe.txt, appending a simple ATTEMPT_N marker, then end the turn again.',
+  '3. When Harness requires reflection and gives you a report path plus token, write the report to that exact path. Include sections ## Goal, ## Failed Attempts, ## Verified Facts, ## Diagnosis, and ## Decision. The first non-empty Decision line must begin with RESUME:, and include the exact reflection token.',
+  `4. After that reflection is accepted, make exactly one edit to probe.txt appending ${POST_REFLECTION_MARKER}, then end the turn so the same intentional verification failure returns after reflection.`,
+  `5. After Harness reports that edits are locked, attempt one final edit to probe.txt appending ${BLOCKED_MARKER}. Do not work around the block.`,
+  '6. Do not delete/reset Harness state. Do not start a different session. Stop after the final blocked edit attempt.',
+].join('\n');
+
+function sha256File(file) {
+  return crypto.createHash('sha256').update(fs.readFileSync(file)).digest('hex');
+}
+
+function safeCommand(command, args, options = {}) {
+  try {
+    return execFileSync(command, args, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'], ...options }).trim();
+  } catch (error) {
+    return null;
+  }
+}
+
+function recursiveFind(root, basename) {
+  if (!fs.existsSync(root)) return [];
+  const out = [];
+  for (const entry of fs.readdirSync(root, { withFileTypes: true })) {
+    const file = path.join(root, entry.name);
+    if (entry.isDirectory()) out.push(...recursiveFind(file, basename));
+    else if (entry.isFile() && entry.name === basename) out.push(file);
+  }
+  return out;
+}
+
+function parseToolInputs(transcriptFile) {
+  if (!fs.existsSync(transcriptFile)) return [];
+  const events = [];
+  for (const line of fs.readFileSync(transcriptFile, 'utf8').split(/\r?\n/)) {
+    if (!line.trim()) continue;
+    let event;
+    try { event = JSON.parse(line); } catch { continue; }
+    const part = event && event.part;
+    if (!part || !String(event.type || '').includes('tool')) continue;
+    const input = part.state && part.state.input !== undefined ? part.state.input : part.input;
+    events.push({ tool: part.tool || 'tool', input: input ?? {} });
+  }
+  return events;
+}
+
+function readJson(file) {
+  return JSON.parse(fs.readFileSync(file, 'utf8'));
+}
+
+function verifyReflection(file) {
+  if (!fs.existsSync(file)) return false;
+  const text = fs.readFileSync(file, 'utf8');
+  const sections = ['## Goal', '## Failed Attempts', '## Verified Facts', '## Diagnosis', '## Decision'];
+  if (!sections.every((section) => text.includes(section))) return false;
+  const decision = text.split('## Decision')[1] || '';
+  const first = decision.split(/\r?\n/).map((line) => line.trim()).find(Boolean);
+  return Boolean(first && /^RESUME\s*:/i.test(first) && /Reflection token:\s*[A-Za-z0-9_-]+/i.test(text));
+}
+
+function verifyEvidence(evidenceDir) {
+  const transcriptFile = path.join(evidenceDir, 'transcript.jsonl');
+  const stderrFile = path.join(evidenceDir, 'stderr.txt');
+  const probeFile = path.join(evidenceDir, 'workspace', 'probe.txt');
+  const breakerFile = path.join(evidenceDir, 'state', 'circuit-breaker.json');
+  const reflectionFile = path.join(evidenceDir, 'state', 'zoom-out-report.md');
+  const metadataFile = path.join(evidenceDir, 'metadata.json');
+
+  const checks = [];
+  const check = (name, pass, detail = null) => checks.push({ name, pass: Boolean(pass), detail });
+
+  let metadata = {};
+  try { metadata = readJson(metadataFile); } catch { /* reported below */ }
+  check('metadata records isolated Harness state', metadata.stateIsolated === true, metadata.stateIsolation || null);
+  check('metadata records .js auto-discovery destination', metadata.installedPluginName === INSTALLED_PLUGIN_NAME, metadata.installedPluginName || null);
+  check('installed plugin is byte-identical to the recorded canonical source',
+    typeof metadata.pluginSha256 === 'string' && metadata.pluginSha256.length === 64 && metadata.installedPluginSha256 === metadata.pluginSha256,
+    { source: metadata.pluginSha256 || null, installed: metadata.installedPluginSha256 || null });
+
+  const combined = [transcriptFile, stderrFile]
+    .filter((file) => fs.existsSync(file))
+    .map((file) => fs.readFileSync(file, 'utf8'))
+    .join('\n');
+  check('live host surfaced the Harness hard-lock error', combined.includes(HARDLOCK_MESSAGE));
+
+  const toolInputs = parseToolInputs(transcriptFile);
+  const toolText = toolInputs.map((entry) => JSON.stringify(entry.input)).join('\n');
+  check('structured tool trace contains the pre-lock edit attempt', toolText.includes(PRELOCK_MARKER));
+  check('structured tool trace contains the post-reflection retry', toolText.includes(POST_REFLECTION_MARKER));
+  check('structured tool trace contains the final blocked edit attempt', toolText.includes(BLOCKED_MARKER));
+
+  let probe = '';
+  try { probe = fs.readFileSync(probeFile, 'utf8'); } catch { /* reported below */ }
+  check('negative control proves an edit executed before lock', probe.includes(PRELOCK_MARKER), probe || null);
+  check('post-reflection retry executed before hard lock engaged', probe.includes(POST_REFLECTION_MARKER), probe || null);
+  check('blocked marker did not reach the filesystem', probe.length > 0 && !probe.includes(BLOCKED_MARKER), probe || null);
+
+  let breaker = null;
+  try { breaker = readJson(breakerFile); } catch { /* reported below */ }
+  const reflectedSignature = breaker && breaker.lastReflectionSignature;
+  const reflectedEntry = reflectedSignature && breaker.failures && breaker.failures[reflectedSignature];
+  check('pre-reset breaker snapshot is hard-locked', breaker && breaker.hardLock === true, breaker);
+  check('snapshot proves a completed reflection for the repeated signature',
+    breaker && Number.isFinite(breaker.lastReflection) && typeof reflectedSignature === 'string' && reflectedSignature.length > 0,
+    breaker);
+  check('same verification signature reached at least four failures (3 + post-reflection retry)',
+    reflectedEntry && Number.isInteger(reflectedEntry.count) && reflectedEntry.count >= 4,
+    reflectedEntry || null);
+  check('reflection artifact is valid and preserved', verifyReflection(reflectionFile));
+
+  return {
+    schemaVersion: 1,
+    verifiedAt: new Date().toISOString(),
+    passed: checks.every((entry) => entry.pass),
+    checks,
+  };
+}
+
+function archiveSelectedState(stateHome, evidenceDir) {
+  const candidates = [];
+  for (const file of recursiveFind(stateHome, 'circuit-breaker.json')) {
+    try {
+      const state = readJson(file);
+      candidates.push({ file, state });
+    } catch {
+      candidates.push({ file, state: null });
+    }
+  }
+  const selected = candidates.find((candidate) => candidate.state && candidate.state.hardLock === true) || null;
+  const rawStateDir = path.join(evidenceDir, 'raw-state');
+  if (fs.existsSync(stateHome)) fs.cpSync(stateHome, rawStateDir, { recursive: true });
+  if (!selected) return { selected: null, candidates: candidates.map(({ file, state }) => ({ file, state })) };
+
+  const sourceDir = path.dirname(selected.file);
+  const targetDir = path.join(evidenceDir, 'state');
+  fs.mkdirSync(targetDir, { recursive: true });
+  for (const name of ['circuit-breaker.json', 'edit-state.json', 'compliance.json', 'zoom-out-report.md']) {
+    const source = path.join(sourceDir, name);
+    if (fs.existsSync(source)) fs.copyFileSync(source, path.join(targetDir, name));
+  }
+  return {
+    selected: path.relative(stateHome, sourceDir).split(path.sep).join('/'),
+    candidates: candidates.map(({ file, state }) => ({ file: path.relative(stateHome, file).split(path.sep).join('/'), state })),
+  };
+}
+
+function defaultEvidenceDir() {
+  const stamp = new Date().toISOString().replace(/[:.]/g, '-');
+  return path.join(ROOT, 'benchmarks', 'results', 'live-host', `opencode-hardlock-${stamp}`);
+}
+
+function runLive(options = {}) {
+  const evidenceDir = path.resolve(options.out || defaultEvidenceDir());
+  if (fs.existsSync(evidenceDir) && fs.readdirSync(evidenceDir).length > 0) {
+    throw new Error(`evidence output directory must be empty or absent: ${evidenceDir}`);
+  }
+  const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'harness-opencode-hardlock-'));
+  const workspace = path.join(tempRoot, 'workspace');
+  const stateHome = path.join(tempRoot, 'state-home');
+  const transcriptFile = path.join(evidenceDir, 'transcript.jsonl');
+  const stderrFile = path.join(evidenceDir, 'stderr.txt');
+  const workspaceEvidenceDir = path.join(evidenceDir, 'workspace');
+  const model = options.model || process.env.BEHAVIORAL_MODEL || null;
+  const opencode = options.opencode || 'opencode';
+
+  fs.mkdirSync(workspace, { recursive: true });
+  fs.mkdirSync(path.join(workspace, '.opencode', 'plugins'), { recursive: true });
+  fs.mkdirSync(evidenceDir, { recursive: true });
+  fs.writeFileSync(path.join(workspace, 'probe.txt'), 'baseline\n', 'utf8');
+  fs.writeFileSync(path.join(workspace, 'package.json'), JSON.stringify({
+    name: 'harness-opencode-hardlock-live-probe',
+    private: true,
+    version: '0.0.0',
+    scripts: { test: "node -e \"console.log('HARNESS_LIVE_PROBE_RED'); process.exit(1)\"" },
+  }, null, 2));
+  fs.writeFileSync(path.join(workspace, 'opencode.json'), JSON.stringify({ $schema: 'https://opencode.ai/config.json' }, null, 2));
+  const installedPluginFile = path.join(workspace, '.opencode', 'plugins', INSTALLED_PLUGIN_NAME);
+  fs.copyFileSync(PLUGIN_SOURCE, installedPluginFile);
+  fs.writeFileSync(path.join(evidenceDir, 'prompt.txt'), PROMPT + '\n', 'utf8');
+
+  const args = ['run', '--format', 'json', '--auto', '--dir', workspace];
+  if (model) args.push('-m', model);
+  args.push(PROMPT);
+  const startedAt = new Date().toISOString();
+  const result = spawnSync(opencode, args, {
+    cwd: workspace,
+    env: { ...process.env, HARNESS_STATE_HOME: stateHome },
+    encoding: 'utf8',
+    timeout: 20 * 60 * 1000,
+    maxBuffer: 64 * 1024 * 1024,
+    windowsHide: true,
+  });
+  fs.writeFileSync(transcriptFile, result.stdout || '', 'utf8');
+  fs.writeFileSync(stderrFile, result.stderr || '', 'utf8');
+  fs.mkdirSync(workspaceEvidenceDir, { recursive: true });
+  for (const name of ['probe.txt', 'package.json', 'opencode.json']) {
+    const source = path.join(workspace, name);
+    if (fs.existsSync(source)) fs.copyFileSync(source, path.join(workspaceEvidenceDir, name));
+  }
+
+  const stateArchive = archiveSelectedState(stateHome, evidenceDir);
+  const metadata = {
+    schemaVersion: 1,
+    startedAt,
+    completedAt: new Date().toISOString(),
+    opencodeVersion: safeCommand(opencode, ['--version']),
+    nodeVersion: process.version,
+    platform: process.platform,
+    arch: process.arch,
+    repoCommit: safeCommand('git', ['rev-parse', 'HEAD'], { cwd: ROOT }),
+    model,
+    installedPluginName: INSTALLED_PLUGIN_NAME,
+    pluginSource: 'opencode-plugin/index.mjs',
+    pluginSha256: sha256File(PLUGIN_SOURCE),
+    installedPluginSha256: sha256File(installedPluginFile),
+    stateIsolated: true,
+    stateIsolation: { env: 'HARNESS_STATE_HOME', location: 'temporary' },
+    opencodeExitStatus: result.status,
+    opencodeSignal: result.signal || null,
+    spawnError: result.error ? String(result.error.message || result.error) : null,
+    selectedState: stateArchive.selected,
+    stateCandidates: stateArchive.candidates,
+  };
+  fs.writeFileSync(path.join(evidenceDir, 'metadata.json'), JSON.stringify(metadata, null, 2));
+
+  const verification = verifyEvidence(evidenceDir);
+  fs.writeFileSync(path.join(evidenceDir, 'verification.json'), JSON.stringify(verification, null, 2));
+  fs.rmSync(tempRoot, { recursive: true, force: true });
+
+  console.log(`${verification.passed ? 'PASS' : 'FAIL'}: ${evidenceDir}`);
+  for (const item of verification.checks) {
+    console.log(`  ${item.pass ? 'PASS' : 'FAIL'} ${item.name}${item.pass || item.detail == null ? '' : ` — ${typeof item.detail === 'string' ? item.detail : JSON.stringify(item.detail)}`}`);
+  }
+  return verification.passed ? 0 : 1;
+}
+
+function flag(args, name) {
+  const index = args.indexOf(name);
+  return index >= 0 ? args[index + 1] : undefined;
+}
+
+function main(argv = process.argv.slice(2)) {
+  const command = argv[0];
+  if (command === 'run') {
+    return runLive({ out: flag(argv, '--out'), model: flag(argv, '--model'), opencode: flag(argv, '--opencode') });
+  }
+  if (command === 'verify') {
+    const evidenceDir = argv[1];
+    if (!evidenceDir) throw new Error('verify requires an evidence directory');
+    const verification = verifyEvidence(path.resolve(evidenceDir));
+    fs.writeFileSync(path.join(path.resolve(evidenceDir), 'verification.json'), JSON.stringify(verification, null, 2));
+    console.log(`${verification.passed ? 'PASS' : 'FAIL'}: ${path.resolve(evidenceDir)}`);
+    for (const item of verification.checks) console.log(`  ${item.pass ? 'PASS' : 'FAIL'} ${item.name}`);
+    return verification.passed ? 0 : 1;
+  }
+  console.log('Usage:\n  node behavioral-evals/opencode-hardlock-live.js run [--out <dir>] [--model <model>] [--opencode <path>]\n  node behavioral-evals/opencode-hardlock-live.js verify <evidence-dir>');
+  return command ? 1 : 0;
+}
+
+if (require.main === module) {
+  try { process.exitCode = main(); }
+  catch (error) {
+    console.error(error && error.stack ? error.stack : error);
+    process.exitCode = 1;
+  }
+}
+
+module.exports = {
+  BLOCKED_MARKER,
+  HARDLOCK_MESSAGE,
+  INSTALLED_PLUGIN_NAME,
+  POST_REFLECTION_MARKER,
+  PRELOCK_MARKER,
+  PROMPT,
+  parseToolInputs,
+  verifyEvidence,
+  verifyReflection,
+};