harness-everything 0.40.0 → 0.41.1

package/ci/mechanism-2p-opencode-v2-entrypoint.test.js

@@ -0,0 +1,179 @@
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const { pathToFileURL } = require('url');
+const helper = require('./test-helper');
+
+console.log('\n[2p] opencode 2.x default-export entrypoint: registration and firing behavior...');
+
+// OpenCode 2.x requires a default export { id, setup } that registers hooks
+// through ctx.tool.hook / ctx.event.subscribe. The named V1 factory still
+// exists for OpenCode 1 hosts and the mechanism tests; this test covers the
+// V2 adapter that the real host actually loads.
+
+helper.check(
+  '2p. the plugin ships as a single self-contained module',
+  fs.existsSync(path.join(helper.root, 'opencode-plugin', 'index.mjs')),
+  'index.mjs missing'
+);
+
+(async () => {
+  // Isolate state exactly like mechanism-2n: HOME -> temp, no HARNESS_STATE_HOME.
+  delete process.env.HARNESS_STATE_HOME;
+  const fakeHome = helper.tempDir('.mechanism-test-opencode-v2-home');
+  const workspace = helper.tempDir('.mechanism-test-opencode-v2-workspace');
+  fs.mkdirSync(fakeHome, { recursive: true });
+  fs.mkdirSync(workspace, { recursive: true });
+  process.env.HOME = fakeHome;
+  process.env.USERPROFILE = fakeHome;
+
+  // Mirrors the plugin getWorkspaceKey(): cwd-realpath + slug + 12-char sha1.
+  const realWorkspace = fs.realpathSync(path.resolve(workspace));
+  const slug = realWorkspace.split(path.sep).pop().toLowerCase().replace(/[^a-z0-9._-]+/g, '-').replace(/^-+|-+$/g, '') || 'workspace';
+  const hashInput = process.platform === 'win32' ? realWorkspace.toLowerCase() : realWorkspace;
+  const hash = crypto.createHash('sha1').update(hashInput).digest('hex').slice(0, 12);
+  const stateRoot = path.join(fakeHome, '.agents', 'harness-everything', 'workspaces', `${slug}-${hash}`, 'state', 'sessions');
+
+  fs.writeFileSync(
+    path.join(workspace, 'package.json'),
+    JSON.stringify({ name: 'fixture', version: '0.0.0', scripts: { test: 'node -e "process.exit(1)"' } }, null, 2)
+  );
+
+  const prompts = [];
+  const registered = [];
+  let subscribeCount = 0;
+  const eventQueue = [];
+  const fakeCtx = {
+    location: { directory: workspace },
+    tool: {
+      hook: async (name, callback) => {
+        registered.push({ name, callback });
+        return { dispose: async () => {} };
+      },
+    },
+    session: {
+      prompt: async (input) => {
+        prompts.push(input);
+        return {};
+      },
+    },
+    event: {
+      subscribe: (options) => {
+        subscribeCount++;
+        return {
+          [Symbol.asyncIterator]: () => ({
+            next: async () => {
+              while (eventQueue.length === 0) {
+                if (options.signal.aborted) return { done: true, value: undefined };
+                await new Promise((resolve) => setTimeout(resolve, 5));
+              }
+              return { done: false, value: eventQueue.shift() };
+            },
+          }),
+        };
+      },
+    },
+  };
+
+  const push = (event) => eventQueue.push(event);
+  const settle = () => new Promise((resolve) => setTimeout(resolve, 50));
+
+  const mod = await import(pathToFileURL(path.join(helper.root, 'opencode-plugin', 'index.mjs')).href);
+  const definition = mod.default;
+
+  helper.check(
+    '2p. the module default-exports an OpenCode 2 definition with a string id and setup function',
+    definition && typeof definition.setup === 'function' && typeof definition.id === 'string' && definition.id.length > 0,
+    `default export keys: ${JSON.stringify(definition && Object.keys(definition))}`
+  );
+
+  helper.check(
+    '2p. the module still exports the V1 HarnessEnforcement factory for OpenCode 1 hosts and tests',
+    typeof mod.HarnessEnforcement === 'function',
+    `exports: ${Object.keys(mod).join(', ')}`
+  );
+
+  await definition.setup(fakeCtx);
+
+  helper.check(
+    '2p. setup registers the V2 tool hooks under their OpenCode 2 names',
+    registered.some((r) => r.name === 'execute.before') && registered.some((r) => r.name === 'execute.after'),
+    JSON.stringify(registered.map((r) => r.name))
+  );
+
+  helper.check('2p. setup subscribes to the event stream exactly once', subscribeCount === 1, `subscribes: ${subscribeCount}`);
+
+  const before = registered.find((r) => r.name === 'execute.before').callback;
+  const after = registered.find((r) => r.name === 'execute.after').callback;
+
+  // Flow 1: a failure loop drives verification through real V2 event shapes:
+  // execute.before/after carry {tool, sessionID, id, input}; the event stream
+  // carries flat {type, sessionID}.
+  const sessionDir = path.join(stateRoot, 's1');
+  for (let i = 1; i <= 3; i++) {
+    await after({ tool: 'edit', sessionID: 's1', id: `c${i}`, input: {} });
+    push({ type: 'session.idle', sessionID: 's1' });
+    await settle();
+  }
+
+  helper.check(
+    '2p. three v2-shaped edit/idle cycles force reflection',
+    prompts.length === 3,
+    `prompts: ${prompts.length}`
+  );
+
+  helper.check(
+    '2p. the V2 ctx.session.prompt receives {sessionID, text}, not the V1 {path, body} shape',
+    prompts.every((p) => typeof p.sessionID === 'string' && typeof p.text === 'string'),
+    JSON.stringify(prompts)
+  );
+
+  const breaker = JSON.parse(fs.readFileSync(path.join(sessionDir, 'circuit-breaker.json'), 'utf8'));
+  const signature = Object.keys(breaker.failures)[0];
+  helper.check(
+    '2p. three same-signature failures via the v2 hooks force reflectionPending',
+    breaker.failures[signature].count === 3 && breaker.reflectionPending === true,
+    JSON.stringify(breaker)
+  );
+
+  let blocked = false;
+  try {
+    await before({ tool: 'edit', sessionID: 's1', id: 'blocked-edit', input: {} });
+  } catch {
+    blocked = true;
+  }
+  helper.check('2p. a pending reflection blocks a v2-shaped edit call', blocked, 'edit call was allowed during pending reflection');
+
+  // Flow 2: the reflection artifact is accepted through the V2 after hook,
+  // proving input-args mapping across the adapter.
+  const token = (prompts.map((p) => (p.text.match(/reflection token: ([A-Za-z0-9_-]+)/i) || [])[1]).filter(Boolean).pop());
+  const reflectionFile = path.join(sessionDir, 'zoom-out-report.md');
+  fs.writeFileSync(
+    reflectionFile,
+    `## Goal\nfix the fixture\n## Failed Attempts\nthree retries\n## Verified Facts\ntest stays red\n## Diagnosis\nthe fixture intentionally fails\n## Decision\nRESUME: change the fixture\nReflection token: ${token}\n`
+  );
+  await after({ tool: 'write', sessionID: 's1', id: 'reflect-write', input: { filePath: reflectionFile } });
+
+  const breakerAfter = JSON.parse(fs.readFileSync(path.join(sessionDir, 'circuit-breaker.json'), 'utf8'));
+  helper.check(
+    '2p. a v2-shaped reflection artifact completes the reflection',
+    breakerAfter.reflectionPending === false && Number.isFinite(breakerAfter.lastReflection) && breakerAfter.failures[signature].count === 0,
+    JSON.stringify(breakerAfter)
+  );
+
+  // Flow 3: session reset through the flat V2 event shape.
+  await after({ tool: 'edit', sessionID: 'reset', id: 'reset-edit', input: {} });
+  helper.check('2p. an edit created state for its session before the reset probe', fs.existsSync(path.join(stateRoot, 'reset', 'edit-state.json')), 'state/reset');
+  push({ type: 'session.created', sessionID: 'reset' });
+  await settle();
+  helper.check(
+    '2p. a flat v2 session.created event resets that session state',
+    !fs.existsSync(path.join(stateRoot, 'reset', 'edit-state.json')),
+    'edit-state.json survived the reset'
+  );
+
+  helper.finish();
+})().catch((err) => {
+  console.error('2p. opencode v2 entrypoint test crashed:', err);
+  process.exit(1);
+});

package/ci/mechanism-325-3b-preparation.test.js

@@ -1,10 +1,11 @@
 #!/usr/bin/env node
 'use strict';
 
-// #325 Phase 3b preparation (H1+H2): fixture inventory, the qualified expected-RED runner, legacy controls,
-// switch sanitation, source/package parity and negative registry checks. This suite asserts no runtime
-// behaviour change and no pilot credit. Desired-contract gaps are qualified by the registry, never
-// asserted as passing behaviour. Full replay runs use the runner; negative checks use one case each.
+// #325 Phase 3b preparation (H1+H2): fixture inventory, legacy controls, switch sanitation, source/package parity and
+// the runner's infrastructure bounds. This suite asserts no runtime behaviour change and no pilot credit. The qualified
+// RED runner, its frozen registry and the runtime-fingerprint and recapture checks are archived by F4-T2 under
+// ci/archive/325-prep (historical evidence, see its README.md). The archived runner is still invoked here, only for its
+// infrastructure path (exit 2, child deadline, output bound), which is live.
 
 const assert = require('assert');
 const crypto = require('crypto');
@@ -13,11 +14,11 @@ const os = require('os');
 const path = require('path');
 const { spawnSync } = require('child_process');
 const fx = require('./lib/doc-reconciliation-prep-fixtures');
-const runner = require('./prep/doc-reconciliation-red.js');
+const runner = require('./archive/325-prep/doc-reconciliation-red.js');
 
 const ROOT = path.resolve(__dirname, '..');
 const PREP_DIR = path.join(__dirname, 'fixtures', 'doc-obligations', 'reconciliation-prep');
-const RUNNER = path.join(__dirname, 'prep', 'doc-reconciliation-red.js');
+const RUNNER = path.join(__dirname, 'archive', '325-prep', 'doc-reconciliation-red.js');
 const corpus = fx.readCaseCorpus(path.join(PREP_DIR, 'cases.json'));
 const registry = JSON.parse(fs.readFileSync(path.join(PREP_DIR, 'pending-red.json'), 'utf8'));
 const workDir = fs.mkdtempSync(path.join(os.tmpdir(), 'doc-recon-prep-suite-'));
@@ -43,16 +44,10 @@ function checkCase(name, runCase) {
 function runRunner(args) {
   return spawnSync(process.execPath, [RUNNER, ...args], { cwd: ROOT, encoding: 'utf8' });
 }
-function writeRegistry(name, mutate) {
-  const copy = JSON.parse(JSON.stringify(registry));
-  mutate(copy);
-  const file = path.join(workDir, name);
-  fs.writeFileSync(file, `${JSON.stringify(copy, null, 2)}\n`, 'utf8');
-  return file;
-}
 
-console.log('=== #325 3b preparation: corpus, qualified RED runner and controls (H1+H2) ===');
+console.log('=== #325 3b preparation: corpus, legacy controls and infrastructure bounds (H1+H2) ===');
 
+// locks: unresolved — fixture-shape control (corpus field shape); no A/B/C/R3 clause
 checkCase('inventory: the H2 corpus covers P01-P07 with the L1 field shape', () => {
   const ids = corpus.cases.map(item => item.id);
   assert.deepStrictEqual(ids, ['P01', 'P04', 'P06', 'P02a', 'P02b', 'P02c', 'P02g', 'P02d', 'P02e', 'P02f', 'P03', 'P05', 'P07-fable-staged', 'P07-fable-parallel', 'P07-fable-multi-agent-workspace', 'P07u']);
@@ -74,65 +69,6 @@ checkCase('inventory: the H2 corpus covers P01-P07 with the L1 field shape', ()
   }
 });
 
-// The full replay runs once, through the runner's JSON report. Every case must be a control or a qualified gap,
-// with matching parity between the two legs and no pilot credit.
-let report = null;
-checkCase('expected-RED mode: every case is CONTROL_PASS or EXPECTED_RED and exits 0', () => {
-  const run = runRunner(['--expect-red', '--json']);
-  assert.strictEqual(run.status, 0, `exit ${run.status}: ${(run.stderr || run.stdout).slice(0, 400)}`);
-  report = JSON.parse(run.stdout);
-});
-
-checkCase('expected-RED report: legs agree, controls are green, no pilot credit, runtime fingerprint matches', () => {
-  assert.ok(report, 'the report was produced');
-  assert.strictEqual(report.pilotCredit, false, 'preparation reports never grant pilot credit');
-  assert.strictEqual(report.runtimeFingerprintMatches, true, 'registry describes the current shared runtime bytes');
-  for (const item of report.cases) {
-    assert.ok(['CONTROL_PASS', 'EXPECTED_RED'].includes(item.status), `${item.caseId} is ${item.status}`);
-    assert.strictEqual(item.parity, 'match', `${item.caseId} source and packaged legs agree`);
-  }
-  const controls = report.cases.filter(item => item.status === 'CONTROL_PASS').map(item => item.caseId).sort();
-  assert.deepStrictEqual(controls, ['P01', 'P02a', 'P02b', 'P02c', 'P02d', 'P02f', 'P02g', 'P04', 'P06', 'P07-fable-multi-agent-workspace', 'P07-fable-parallel', 'P07-fable-staged', 'P07u']);
-});
-
-checkCase('gap registry: every entry is qualified and the expected-RED mode accounts for all of them', () => {
-  assert.ok(report, 'the report was produced');
-  const qualified = report.cases.flatMap(item => item.assertions.filter(entry => entry.status === 'gap-qualified'));
-  assert.strictEqual(qualified.length, registry.entries.length, 'each registry entry is observed exactly once');
-  assert.ok(!report.cases.some(item => item.assertions.some(entry => entry.status === 'gap-unqualified' || entry.status === 'unexpected-pass')));
-});
-
-checkCase('strict mode fails on the recorded gaps and preserves the RED log', () => {
-  const log = path.join(workDir, 'p02e-red.json');
-  const run = runRunner(['--strict', '--case', 'P02e', '--log', log]);
-  assert.strictEqual(run.status, 1, `strict mode exits 1 on gaps: ${run.stdout}`);
-  const saved = JSON.parse(fs.readFileSync(log, 'utf8'));
-  assert.ok(saved.cases[0].assertions.some(entry => entry.status === 'gap-qualified'), 'the log keeps the qualified gaps');
-});
-
-checkCase('malformed registry is an infrastructure error, not a RED pass', () => {
-  const file = writeRegistry('missing-reason.json', copy => { delete copy.entries[0].reasonCode; });
-  const run = runRunner(['--expect-red', '--case', 'P01', '--registry', file]);
-  assert.strictEqual(run.status, 2, `registry errors exit 2: ${run.stdout} ${run.stderr}`);
-});
-
-checkCase('a registry that omits a gap fails expected-RED mode', () => {
-  const file = writeRegistry('omit-gap.json', copy => { copy.entries = copy.entries.filter(entry => entry.assertionId !== 'P02e.on.review-pass-exit' || entry.distribution !== 'source'); });
-  const run = runRunner(['--expect-red', '--case', 'P02e', '--registry', file]);
-  assert.strictEqual(run.status, 1, `an unqualified gap fails: ${run.stdout}`);
-});
-
-checkCase('an unexpected PASS on a control fails expected-RED mode', () => {
-  const file = writeRegistry('unexpected-pass.json', copy => {
-    copy.entries.push({
-      caseId: 'P06', assertionId: 'P06.on.stop-satisfied', distribution: 'source', baselineSha: copy.baselineSha,
-      actual: 'satisfied', desired: 'running', blocker: '#341 E0', reasonCode: 'pretend-gap'
-    });
-  });
-  const run = runRunner(['--expect-red', '--case', 'P06', '--registry', file]);
-  assert.strictEqual(run.status, 1, `a passing assertion with a registry entry fails: ${run.stdout}`);
-});
-
 // Infrastructure rule: an abnormal action result is never a qualified gap. The controls start from one healthy replay
 // set of P01 and change only the ON route result, so every other fault and assertion is the unmodified replay's.
 const p01 = corpus.cases.find(item => item.id === 'P01');
@@ -144,6 +80,7 @@ const injectIntoRoute = (patch, legs = ['source', 'packaged']) => {
   return injected;
 };
 
+// locks: C — "unavailable observations ... cannot become a false PASS"; control: P01
 checkCase('negative control: an abnormal route in P01 is infrastructure, and --expect-red exits nonzero though later assertions still match', () => {
   const injected = injectIntoRoute({ exitCode: 1 });
   const later = p01.expectations.on.filter(assertion => assertion.id.startsWith('verify-obligation') || assertion.id.startsWith('stop-'));
@@ -165,6 +102,7 @@ checkCase('negative control: an abnormal route in P01 is infrastructure, and --e
   assert.strictEqual(runner.exitCodeFor({ cases: [result] }, 'expect-red'), 2, 'expected-RED mode exits nonzero');
 });
 
+// locks: C — "unavailable observations ... cannot become a false PASS"; control: P01
 checkCase('negative control: a route killed by a signal or without an exit status is infrastructure', () => {
   const result = runner.classifyCase(p01, injectIntoRoute({ exitCode: null, signal: 'SIGTERM' }), p01Entries);
   assert.strictEqual(result.status, 'INFRASTRUCTURE');
@@ -172,18 +110,21 @@ checkCase('negative control: a route killed by a signal or without an exit statu
   assert.ok(result.infrastructure.includes('source.on.route: no exit status'), result.infrastructure.join('; '));
 });
 
+// locks: C — "unavailable observations ... cannot become a false PASS"; control: P01
 checkCase('negative control: a spawn error on the route is infrastructure', () => {
   const result = runner.classifyCase(p01, injectIntoRoute({ exitCode: null, error: 'spawnSync node ENOENT' }), p01Entries);
   assert.strictEqual(result.status, 'INFRASTRUCTURE');
   assert.ok(result.infrastructure.includes('source.on.route: spawn error spawnSync node ENOENT'), result.infrastructure.join('; '));
 });
 
+// locks: C — "unavailable observations ... cannot become a false PASS"; control: P01
 checkCase('negative control: an accepted route exit without the routing checkpoint is malformed required output', () => {
   const result = runner.classifyCase(p01, injectIntoRoute({ stdout: 'routing unavailable' }), p01Entries);
   assert.strictEqual(result.status, 'INFRASTRUCTURE');
   assert.ok(result.infrastructure.includes('source.on.route: malformed required output'), result.infrastructure.join('; '));
 });
 
+// locks: C — "unavailable observations ... cannot become a false PASS"; control: P01
 checkCase('--expect-red exits nonzero from the CLI when a real route exit falls outside its policy', () => {
   const corpusCopy = JSON.parse(JSON.stringify(corpus));
   corpusCopy.cases.find(item => item.id === 'P01').actions.find(action => action.id === 'route').expectExit = { off: 1, on: 1 };
@@ -212,6 +153,7 @@ function runWithChildLimits(caseId, childLimits) {
   return { run, elapsed: Date.now() - started };
 }
 
+// locks: C — "unavailable observations ... cannot become a false PASS"; control: P01
 checkCase('a hung route entrypoint cannot stall --expect-red: the CLI exits 2 promptly and removes the replay directories', () => {
   const before = replayDirsFor('P01');
   const { run, elapsed } = runWithChildLimits('P01', { timeoutMs: 500, substitutes: { route: 'hang-entrypoint.js' } });
@@ -222,6 +164,7 @@ checkCase('a hung route entrypoint cannot stall --expect-red: the CLI exits 2 pr
   assert.strictEqual(replayDirsFor('P01'), before, 'replay directories are removed after the timeout');
 });
 
+// locks: C — "unavailable observations ... cannot become a false PASS"; control: P01
 checkCase('a route that floods stdout is stopped by the output bound and exits 2 through the CLI', () => {
   const before = replayDirsFor('P01');
   const { run, elapsed } = runWithChildLimits('P01', { timeoutMs: 5000, substitutes: { route: 'flood-entrypoint.js' } });
@@ -232,6 +175,7 @@ checkCase('a route that floods stdout is stopped by the output bound and exits 2
   assert.strictEqual(replayDirsFor('P01'), before, 'replay directories are removed after the output bound');
 });
 
+// locks: C — "unavailable observations ... cannot become a false PASS"; control: P01
 checkCase('a faulted replay runs no action after its first infrastructure fault and still removes its directories', () => {
   const before = replayDirsFor('P01');
   const item = { ...p01, childLimits: { timeoutMs: 500, substitutes: { route: 'hang-entrypoint.js' } } };
@@ -246,6 +190,7 @@ checkCase('a faulted replay runs no action after its first infrastructure fault
 // spend one deadline per replay (64 route timeouts). The fail-fast spends one, names the rest NOT_RUN, and exits 2.
 const SHARED_HANG_DEADLINE_MS = 500;
 const SHARED_HANG_BOUND_MS = 5000;
+// locks: C — "unavailable observations ... cannot become a false PASS"; control: P01
 checkCase('corpus-level: a route hung in every case costs one deadline, exits 2, and names the other cases NOT_RUN', () => {
   const everyCaseHangs = JSON.parse(JSON.stringify(corpus));
   for (const item of everyCaseHangs.cases) {
@@ -274,15 +219,18 @@ checkCase('corpus-level: a route hung in every case costs one deadline, exits 2,
   assert.strictEqual(replayDirsFor(''), before, 'replay directories are removed');
 });
 
+// locks: unresolved — test-only override guard (tool control); no A/B/C/R3 clause
 checkCase('the committed corpus carries no child-limit override, so production replays use the default deadline', () => {
   assert.ok(corpus.cases.every(item => item.childLimits === undefined), 'a childLimits key is test-only');
 });
 
+// locks: unresolved — deadline-shortening guard (tool control); no A/B/C/R3 clause
 checkCase('a child deadline override can only shorten the default deadline', () => {
   const item = { ...corpus.cases.find(candidate => candidate.id === 'P06'), childLimits: { timeoutMs: 60000 } };
   assert.throws(() => fx.replayCase(item, 'source'), /may only shorten/);
 });
 
+// locks: C — "unavailable observations ... cannot become a false PASS"; control: P06
 checkCase('a malformed expectExit policy is an infrastructure error, not a RED pass', () => {
   const corpusCopy = JSON.parse(JSON.stringify(corpus));
   corpusCopy.cases.find(item => item.id === 'P06').actions.find(action => action.id === 'route').expectExit = { off: 'two' };
@@ -292,33 +240,7 @@ checkCase('a malformed expectExit policy is an infrastructure error, not a RED p
   assert.strictEqual(run.status, 2, `a malformed policy exits 2: ${run.stdout} ${run.stderr}`);
 });
 
-checkCase('a runtime fingerprint change invalidates qualification and prints the exact deliberate re-capture command', () => {
-  const file = writeRegistry('stale-fingerprint.json', copy => { copy.runtimeFingerprint = '0'.repeat(64); });
-  const run = runRunner(['--expect-red', '--case', 'P01', '--registry', file]);
-  assert.strictEqual(run.status, 1, `a fingerprint mismatch fails: ${run.stdout}`);
-  const output = run.stdout + run.stderr;
-  assert.ok(output.includes('--recapture-candidate ci/fixtures/doc-obligations/reconciliation-prep/pending-red.candidate.json'), 'the re-capture command names the candidate');
-  assert.ok(/--baseline-sha [0-9a-f]{40}/.test(output), 'the re-capture command names the commit');
-  assert.ok(output.includes('nothing is auto-accepted'), 'the message says nothing is auto-accepted');
-});
-
-checkCase('recapture writes a reviewable candidate and never the committed registry', () => {
-  const candidate = path.join(workDir, 'candidate.json');
-  const before = fs.readFileSync(path.join(PREP_DIR, 'pending-red.json'), 'utf8');
-  const run = spawnSync(process.execPath, [RUNNER, '--recapture-candidate', candidate, '--baseline-sha', registry.baselineSha, '--case', 'P06'], { cwd: ROOT, encoding: 'utf8' });
-  assert.strictEqual(run.status, 0, run.stderr);
-  assert.strictEqual(fs.readFileSync(path.join(PREP_DIR, 'pending-red.json'), 'utf8'), before, 'the committed registry is untouched');
-  const saved = JSON.parse(fs.readFileSync(candidate, 'utf8'));
-  assert.strictEqual(saved.entries.length, 0, 'a control case has no gaps to record');
-  assert.strictEqual(saved.runtimeFingerprint, registry.runtimeFingerprint, 'the candidate describes the current runtime');
-});
-
-checkCase('a candidate with unreviewed reasons is rejected by the registry validator', () => {
-  const file = writeRegistry('unreviewed.json', copy => { copy.entries[0].reasonCode = 'needs-reason'; });
-  const run = runRunner(['--expect-red', '--case', 'P01', '--registry', file]);
-  assert.strictEqual(run.status, 2, 'an unreviewed reason is a registry error');
-});
-
+// locks: unresolved — package parity control (shared runtime bytes); not a false-PASS claim
 checkCase('P08 parity: shared runtime files are byte-identical between the source and packaged legs', () => {
   for (const [source, packaged] of SHARED_FILES) {
     const left = crypto.createHash('sha256').update(fs.readFileSync(path.join(ROOT, source))).digest('hex');
@@ -328,6 +250,7 @@ checkCase('P08 parity: shared runtime files are byte-identical between the sourc
 });
 
 // Switch sanitation: an inherited ON request does not reach an OFF replay (one replay).
+// locks: unresolved — OFF isolation from an inherited ON request; the I2 invariant is not in the A/B/C/R3 table
 checkCase('switch sanitation: an inherited ON request does not reach an OFF replay', () => {
   const previous = process.env[fx.PILOT_SWITCH];
   process.env[fx.PILOT_SWITCH] = '1';
@@ -342,6 +265,7 @@ checkCase('switch sanitation: an inherited ON request does not reach an OFF repl
   }
 });
 
+// locks: unresolved — temporary-directory hygiene control; no A/B/C/R3 clause
 checkCase('cleanup: replays remove their temporary workspace and state directories', () => {
   const prefix = 'doc-recon-P06-source-';
   const before = fs.readdirSync(os.tmpdir()).filter(name => name.startsWith(prefix)).length;
@@ -351,6 +275,7 @@ checkCase('cleanup: replays remove their temporary workspace and state directori
 });
 
 // F-a: separator-agnostic scrubbing. Windows-shaped strings from each leg must normalize to the same markers.
+// locks: unresolved — replay path-normalisation control; no A/B/C/R3 clause
 checkCase('F-a: Windows-shaped source and packaged paths normalize identically', () => {
   const roots = { repo: 'D:\\a\\repo', tmp: ['C:\\Users\\runneradmin\\AppData\\Local\\Temp'] };
   const sourceSkill = fx.scrubText('D:\\a\\repo\\tdd\\SKILL.md', roots);
@@ -366,6 +291,7 @@ checkCase('F-a: Windows-shaped source and packaged paths normalize identically',
 });
 
 // F-b: a per-action switch override must not reach an OFF replay.
+// locks: unresolved — OFF replay carries no per-action switch; the I2 invariant is not in the A/B/C/R3 table
 checkCase('F-b: an OFF replay of P05 carries no per-action switch; the ON replay keeps its overrides', () => {
   const item = corpus.cases.find(candidate => candidate.id === 'P05');
   const off = fx.replayCase(item, 'source');
@@ -378,5 +304,5 @@ checkCase('F-b: an OFF replay of P05 carries no per-action switch; the ON replay
 });
 
 fs.rmSync(workDir, { recursive: true, force: true });
-console.log(failed ? `\n${failed} preparation check(s) failed` : '\nAll preparation checks passed (desired-contract gaps are qualified, not asserted as behaviour)');
+console.log(failed ? `\n${failed} preparation check(s) failed` : '\nAll preparation checks passed');
 process.exitCode = failed ? 1 : 0;