harness-everything 0.16.1 → 0.16.2

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.16.1",
+      "version": "0.16.2",
       "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.16.1",
+  "version": "0.16.2",
   "author": {
     "name": "Miya Daniel"
   },

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 All notable changes to this project are documented in this file.
 
+## [0.16.2](https://github.com/dyphn1/Harness-everything/compare/v0.16.1...v0.16.2) (2026-09-20)
+
+### Bug Fixes
+
+* **runtime:** align post-190 advisory contracts ([562f067](https://github.com/dyphn1/Harness-everything/commit/562f067e97319aa7fc2e7145a55a24652c4499c0))
+
 ## [0.16.1](https://github.com/dyphn1/Harness-everything/compare/v0.16.0...v0.16.1) (2026-09-20)
 
 ### Bug Fixes

package/behavioral-evals/PAIRED-BENCHMARK.md

@@ -32,7 +32,7 @@ text constant.
   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
+Rule-of-3 reflection-gate preflight produced by `opencode-reflection-gate-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.
 
@@ -150,7 +150,7 @@ First produce the #37 attribution evidence from the exact plugin revision being
 measured:
 
 ```bash
-npm run eval:opencode:hardlock-live
+npm run eval:opencode:reflection-gate-live
 ```
 
 Then pass that evidence directory into the paired study:
@@ -161,7 +161,7 @@ npm run eval:paired -- \
   --engine opencode \
   --model <provider/model> \
   --min-effect-pp <N> \
-  --opencode-preflight benchmarks/results/live-host/opencode-hardlock-<timestamp> \
+  --opencode-preflight benchmarks/results/live-host/opencode-reflection-gate-<timestamp> \
   --repeats 3
 ```
 

package/behavioral-evals/README.md

@@ -97,7 +97,7 @@ node behavioral-evals/paired-benchmark.js run \
   --effect skill-text --engine claude --model <model> \
   --min-effect-pp <predeclared-threshold>
 
-# OpenCode plugin-enforcement effect (requires retained hard-lock preflight)
+# OpenCode plugin-enforcement effect (requires retained reflection-gate preflight)
 node behavioral-evals/paired-benchmark.js run \
   --effect plugin-enforcement --engine opencode --model <model> \
   --min-effect-pp <predeclared-threshold> \
@@ -142,48 +142,54 @@ 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
+## OpenCode Rule-of-3 reflection-gate 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:
+The paired OpenCode plugin benchmark needs a real-host preflight from the exact
+plugin revision being measured. The current boundary is the Rule-of-3
+reflection gate: the third same-signature verification failure pauses code
+edits until a valid tokenized reflection report is written. A completed report
+resets that signature's count; three more matching failures request another
+reflection rather than creating a permanent second-stage lock.
+
+Run the dedicated probe on a machine with an authenticated `opencode` CLI:
 
 ```bash
-npm run eval:opencode:hardlock-live
+npm run eval:opencode:reflection-gate-live
 
 # Optional explicit output/model
-node behavioral-evals/opencode-hardlock-live.js run \
-  --out benchmarks/results/live-host/opencode-hardlock-local \
+node behavioral-evals/opencode-reflection-gate-live.js run \
+  --out benchmarks/results/live-host/opencode-reflection-gate-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
+# Re-check retained evidence without making a model call
+node behavioral-evals/opencode-reflection-gate-live.js verify \
+  benchmarks/results/live-host/opencode-reflection-gate-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.
+constant. It does **not** seed breaker/reflection state.
+
+A PASS requires the evidence to agree that:
+
+- three matching failures reach the first reflection boundary;
+- while `reflectionPending` is true, a structured code-edit attempt is rejected
+  and its marker never reaches the filesystem;
+- a valid tokenized `RESUME:` reflection is preserved and releases the gate;
+- after the reflection resets the failure count, three more matching failures
+  reach a second `reflectionPending` state for the same signature;
+- the selected breaker snapshot contains no retired `hardLock` field, and
+  compliance records at least two forced reflections;
+- the installed plugin bytes and retained plugin SHA-256 match the canonical
+  source used by the paired benchmark.
 
 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.
+the final fixture files, selected breaker/compliance state, the first reflection
+artifact, and the isolated raw-state tree before deleting its temporary working
+directory. Failed/incomplete live runs remain failed evidence rather than being
+counted as behavioral failures.
+
+Historical hard-lock evidence captured before #190 remains retained as
+historical evidence (see `docs/platform-capabilities.md`); it is not accepted as
+the current OpenCode paired-benchmark preflight.

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

@@ -1,301 +1,17 @@
 #!/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;
-}
+// Compatibility shim for callers that used the pre-#190 probe name.
+// The current live contract is the Rule-of-3 reflection gate plus re-trip.
+const probe = require('./opencode-reflection-gate-live');
 
 if (require.main === module) {
-  try { process.exitCode = main(); }
+  console.warn('Deprecated: use behavioral-evals/opencode-reflection-gate-live.js.');
+  try { process.exitCode = probe.main(process.argv.slice(2)); }
   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,
-};
+module.exports = probe;