harness-everything 0.16.0 → 0.16.2

package/ci/mechanism-2ai-workspace-fingerprint-batch.test.js

@@ -202,10 +202,9 @@ try {
   const workflowFile = path.join(state.getSessionDir(repo, sessionId), 'workflow-run.json');
   const workflow = JSON.parse(fs.readFileSync(workflowFile, 'utf8'));
   check(workflow.state === 'running' &&
-    workflow.budget?.counters?.iterations === 1 &&
-    workflow.lastMutationAt > 0 &&
-    workflow.budget?.events?.at(-1)?.evidence === 'shell:fingerprint-limit',
-    '#169 fingerprint-limit fallback records one auditable conservative mutation');
+    !workflow.budget?.counters &&
+    !fs.existsSync(path.join(state.getSessionDir(repo, sessionId), 'mutation-probes')),
+    '#190 shell admission no longer creates conservative budget/probe state');
 
   console.log('PASS: batched workspace fingerprint (' + passed + ' assertions, 1000-file ' + elapsedMs.toFixed(1) + 'ms)');
 } finally {

package/ci/mechanism-2b-boundary-guard.test.js

@@ -1,16 +1,6 @@
-const fs = require('fs');
-const helper = require('./test-helper');
-
-console.log('\n[2b] Boundary guard...');
-
-const bigFile = helper.tempFile('.mechanism-test-big.tmp');
-fs.writeFileSync(bigFile, 'x'.repeat(600 * 1024));
-const boundaryResult = helper.runHook('boundary-guard.js', { tool_name: 'Read', tool_input: { file_path: bigFile } });
-helper.check(
-  '2b. Blocks a 600KB Read without limit/offset (exit=2, BLOCKED)',
-  boundaryResult.code === 2 && boundaryResult.stderr.includes('[Boundary Guard] BLOCKED'),
-  `Got exit=${boundaryResult.code}, stderr="${boundaryResult.stderr.slice(0, 200)}"`
-);
-fs.unlinkSync(bigFile);
-
-helper.finish();
+const fs=require('fs'),path=require('path'),{spawnSync}=require('child_process'),helper=require('./test-helper');
+console.log('\n[2b] Boundary reminder...');
+const bigFile=helper.tempFile('.mechanism-test-big.tmp');fs.writeFileSync(bigFile,'x'.repeat(600*1024));
+const result=spawnSync(process.execPath,[path.join(helper.hooksDir,'boundary-guard.js')],{input:JSON.stringify({tool_name:'Read',tool_input:{file_path:bigFile}}),encoding:'utf8'});
+helper.check('2b. Large read emits a reminder but remains available',result.status===0&&/Boundary Reminder/i.test(result.stderr),`exit=${result.status}, stderr=${result.stderr.slice(0,200)}`);
+fs.unlinkSync(bigFile);helper.finish();

package/ci/mechanism-2e-scope-guard.test.js

@@ -1,24 +1,8 @@
-const fs = require('fs');
-const path = require('path');
-const helper = require('./test-helper');
-
-console.log('\n[2e] Subagent scope guard...');
-
-helper.runHook('subagent-scope-guard.js', {
-  session_id: helper.SESSION_ID, tool_name: 'Task', hook_event_name: 'PreToolUse', tool_input: {},
-});
-const scopeFile = helper.tempFile('.mechanism-test-scope.tmp');
-fs.writeFileSync(scopeFile, 'unexpected change');
-const scopeResult = helper.runHook('subagent-scope-guard.js', {
-  session_id: helper.SESSION_ID, tool_name: 'Task', hook_event_name: 'PostToolUse', tool_input: {},
-});
-helper.check(
-  '2e. Flags the newly-created file after a Task burst (exit=2, lists filename)',
-  scopeResult.code === 2 &&
-    scopeResult.stderr.includes('Subagent Scope Guard') &&
-    scopeResult.stderr.includes(path.basename(scopeFile)),
-  `Got exit=${scopeResult.code}, stderr="${scopeResult.stderr.slice(0, 300)}"`
-);
-fs.unlinkSync(scopeFile);
-
-helper.finish();
+const fs=require('fs'),path=require('path'),{spawnSync}=require('child_process'),helper=require('./test-helper');
+console.log('\n[2e] Subagent scope reminder...');
+function run(payload){return spawnSync(process.execPath,[path.join(helper.hooksDir,'subagent-scope-guard.js')],{input:JSON.stringify(payload),encoding:'utf8'});}
+run({session_id:helper.SESSION_ID,tool_name:'Task',hook_event_name:'PreToolUse',tool_input:{}});
+const scopeFile=helper.tempFile('.mechanism-test-scope.tmp');fs.writeFileSync(scopeFile,'unexpected change');
+const result=run({session_id:helper.SESSION_ID,tool_name:'Task',hook_event_name:'PostToolUse',tool_input:{}});
+helper.check('2e. Scope drift is reported without blocking',result.status===0&&result.stderr.includes(path.basename(scopeFile)),`exit=${result.status}, stderr=${result.stderr.slice(0,300)}`);
+fs.unlinkSync(scopeFile);helper.finish();

package/ci/mechanism-2f-stop-gate.test.js

@@ -1,76 +1,22 @@
-const fs = require('fs');
-const helper = require('./test-helper');
-
-console.log('\n[2f] Stop gate...');
-
-helper.writeState('handoff-state.json', { status: 'idle', lastEditAt: Date.now(), lastVerifyAt: 0 });
-const dirtyFile = helper.tempFile('.mechanism-test-dirty.tmp');
-fs.writeFileSync(dirtyFile, 'dirty');
-const firstStop = helper.runHook('stop-gate.js', { session_id: helper.SESSION_ID });
-helper.check(
-  '2f. First stop after an unverified edit bounces (exit=2)',
-  firstStop.code === 2 && firstStop.stderr.includes('[Stop Gate]'),
-  `Got exit=${firstStop.code}, stderr="${firstStop.stderr.slice(0, 200)}"`
-);
-const secondStop = helper.runHook('stop-gate.js', { session_id: helper.SESSION_ID });
-helper.check(
-  '2f. Same edit batch does not bounce twice (exit=0)',
-  secondStop.code === 0,
-  `Got exit=${secondStop.code}`
-);
-fs.unlinkSync(dirtyFile);
-
-console.log('\n[2f] workflow-stop-gate (iterative-single) verification signal...');
-
-const now = Date.now();
-
-// Bug reproduction (issue #153): a verify-classified command that genuinely
-// succeeded but whose host never reported a numeric exit code (observed on
-// at least one live host - state-persist.js writes lastVerifyExitCode: null
-// for any non-failing command when the PostToolUse payload has no numeric
-// exitCode) must not be treated as unverified.
-helper.writeState('workflow-run.json', {
-  schemaVersion: 1, sessionId: helper.SESSION_ID, strategy: 'iterative-single',
-  state: 'running', lastMutationAt: now - 5000,
-});
-helper.writeState('handoff-state.json', {
-  status: 'idle', lastEditAt: now - 5000, lastVerifyAt: now, lastVerifyExitCode: null,
-});
-const hostExitCodeUnavailable = helper.runHook('workflow-stop-gate.js', { session_id: helper.SESSION_ID });
-helper.check(
-  '2f. workflow-stop-gate resolves when verify ran after edit even without a numeric exit code',
-  hostExitCodeUnavailable.code === 0 && helper.readState('workflow-run.json').state === 'satisfied',
-  `Got exit=${hostExitCodeUnavailable.code}, stderr="${hostExitCodeUnavailable.stderr.slice(0, 300)}"`
-);
-
-// Regression guard: explicit exit 0 (host does report it) must still resolve.
-helper.writeState('workflow-run.json', {
-  schemaVersion: 1, sessionId: helper.SESSION_ID, strategy: 'iterative-single',
-  state: 'running', lastMutationAt: now - 5000,
-});
-helper.writeState('handoff-state.json', {
-  status: 'idle', lastEditAt: now - 5000, lastVerifyAt: now, lastVerifyExitCode: 0,
-});
-const hostExitCodeReported = helper.runHook('workflow-stop-gate.js', { session_id: helper.SESSION_ID });
-helper.check(
-  '2f. workflow-stop-gate still resolves when the host does report exit code 0',
-  hostExitCodeReported.code === 0 && helper.readState('workflow-run.json').state === 'satisfied',
-  `Got exit=${hostExitCodeReported.code}`
-);
-
-// Negative control: no verification ran after the edit at all -> stays blocked.
-helper.writeState('workflow-run.json', {
-  schemaVersion: 1, sessionId: helper.SESSION_ID, strategy: 'iterative-single',
-  state: 'running', lastMutationAt: now,
-});
-helper.writeState('handoff-state.json', {
-  status: 'idle', lastEditAt: now, lastVerifyAt: now - 5000, lastVerifyExitCode: null,
-});
-const staleVerify = helper.runHook('workflow-stop-gate.js', { session_id: helper.SESSION_ID });
-helper.check(
-  '2f. workflow-stop-gate still blocks when no verification ran after the edit',
-  staleVerify.code === 2 && staleVerify.stderr.includes('verification-after-edit-missing'),
-  `Got exit=${staleVerify.code}, stderr="${staleVerify.stderr.slice(0, 300)}"`
-);
-
+const fs=require('fs'),path=require('path'),{spawnSync}=require('child_process'),helper=require('./test-helper');
+console.log('\n[2f] Verification reminders...');
+function run(script,payload){return spawnSync(process.execPath,[path.join(helper.hooksDir,script)],{input:JSON.stringify(payload),encoding:'utf8'});}
+helper.writeState('handoff-state.json',{status:'idle',lastEditAt:Date.now(),lastVerifyAt:0});
+const dirty=helper.tempFile('.mechanism-test-dirty.tmp');fs.writeFileSync(dirty,'dirty');
+const reminder=run('stop-gate.js',{session_id:helper.SESSION_ID});
+helper.check('2f. Unverified dirty Stop emits reminder and exits 0',reminder.status===0&&/Verification Reminder/i.test(reminder.stderr),`exit=${reminder.status}, stderr=${reminder.stderr.slice(0,200)}`);
+helper.check('2f. Stop reminder creates no lock/throttle state',!helper.stateExists('stop-gate-state.json'),'unexpected stop-gate-state.json');
+fs.unlinkSync(dirty);
+
+const now=Date.now();
+helper.writeState('workflow-run.json',{schemaVersion:1,sessionId:helper.SESSION_ID,strategy:'iterative-single',state:'running',lastMutationAt:now-5000});
+helper.writeState('handoff-state.json',{status:'idle',lastEditAt:now-5000,lastVerifyAt:now,lastVerifyExitCode:null});
+const verified=run('workflow-stop-gate.js',{session_id:helper.SESSION_ID});
+helper.check('2f. Observed verification can mark workflow satisfied',verified.status===0&&helper.readState('workflow-run.json').state==='satisfied',verified.stderr);
+
+helper.writeState('workflow-run.json',{schemaVersion:1,sessionId:helper.SESSION_ID,strategy:'iterative-single',state:'running',lastMutationAt:now});
+helper.writeState('handoff-state.json',{status:'idle',lastEditAt:now,lastVerifyAt:now-5000,lastVerifyExitCode:null});
+const stale=run('workflow-stop-gate.js',{session_id:helper.SESSION_ID});
+helper.check('2f. Missing verification is reminder-only',stale.status===0&&/verification-after-edit-missing/i.test(stale.stderr),`exit=${stale.status}, stderr=${stale.stderr.slice(0,300)}`);
+helper.check('2f. Missing verification does not create blocked state',helper.readState('workflow-run.json').state==='running',JSON.stringify(helper.readState('workflow-run.json')));
 helper.finish();

package/ci/mechanism-2n-opencode-plugin.test.js

@@ -158,7 +158,7 @@ helper.check(
   const sig = Object.keys(breaker.failures)[0];
   helper.check(
     '2n. two failures on the same signature: still allowed, not yet tripped',
-    breaker.failures[sig].count === 2 && breaker.hardLock === false,
+    breaker.failures[sig].count === 2 && breaker.hardLock === undefined,
     JSON.stringify(breaker)
   );
   helper.check('2n. each failed verification sends exactly one follow-up prompt', promptCalls.length === 2, `${promptCalls.length} prompt(s) sent`);
@@ -235,8 +235,8 @@ helper.check(
   );
   breaker = JSON.parse(fs.readFileSync(breakerFile, 'utf8'));
   helper.check(
-    '2n. apply_patch reflection completes the lifecycle and persists lastReflection',
-    Number.isFinite(breaker.lastReflection) && breaker.lastReflection > 0 && breaker.reflectionPending === false,
+    '2n. apply_patch reflection completes the lifecycle, resets the signature count, and persists lastReflection',
+    Number.isFinite(breaker.lastReflection) && breaker.lastReflection > 0 && breaker.reflectionPending === false && breaker.failures[sig].count === 0,
     JSON.stringify(breaker)
   );
 
@@ -330,42 +330,27 @@ helper.check(
   }
   helper.check('2n. mixed apply_patch cannot bypass a pending reflection', mixedPatchBlocked, 'unrelated files were accepted with the reflection artifact');
 
-  // A new code edit after a completed reflection is the post-reflection retry.
+  // A fresh failure after reflection starts a new three-failure cycle.
   await hooks['tool.execute.after']({ tool: 'edit', sessionID: 's1', callID: 'c5' }, { title: '', output: '', metadata: {} });
   await hooks.event({ event: { type: 'session.idle', properties: { sessionID: 's1' } } });
   breaker = JSON.parse(fs.readFileSync(breakerFile, 'utf8'));
-  helper.check('2n. the same failure returning after a reflection hard-locks the breaker', breaker.hardLock === true, JSON.stringify(breaker));
-  helper.check(
-    '2n. the hard-lock prompt says locked',
-    /lock/i.test(promptCalls[promptCalls.length - 1].body.parts[0].text),
-    promptCalls[promptCalls.length - 1].body.parts[0].text
-  );
-
-  // --- circuit breaker enforcement (tool.execute.before) ---
-  let blocked = false;
+  helper.check('2n. first post-reflection failure starts again at count=1', breaker.failures[sig].count === 1 && breaker.reflectionPending === false, JSON.stringify(breaker));
+  let postReflectionEditAllowed = true;
   try {
     await hooks['tool.execute.before']({ tool: 'edit', sessionID: 's1', callID: 'c6' }, { args: {} });
   } catch {
-    blocked = true;
-  }
-  helper.check('2n. hard-locked breaker throws on the next edit attempt', blocked, 'tool.execute.before did not throw');
-
-  let readBlocked = false;
-  try {
-    await hooks['tool.execute.before']({ tool: 'read', sessionID: 's1', callID: 'c7' }, { args: {} });
-  } catch {
-    readBlocked = true;
+    postReflectionEditAllowed = false;
   }
-  helper.check('2n. a hard lock only blocks edit-shaped tools, not read', !readBlocked, 'tool.execute.before blocked a read');
+  helper.check('2n. no permanent post-reflection hard lock remains', postReflectionEditAllowed, 'tool.execute.before unexpectedly blocked after one fresh failure');
 
   // The same workspace can host independent sessions. Session s2 starts with
-  // a fresh breaker and cannot inherit s1's hard lock.
+  // a fresh breaker and cannot inherit s1 state.
   await hooks['tool.execute.after']({ tool: 'edit', sessionID: 's2', callID: 's2-c1', args: {} }, { title: '', output: '', metadata: {} });
   await hooks.event({ event: { type: 'session.idle', properties: { sessionID: 's2' } } });
   const secondBreaker = JSON.parse(fs.readFileSync(path.join(secondSessionDir, 'circuit-breaker.json'), 'utf8'));
   helper.check(
     '2n. a second session has an independent breaker stream',
-    secondBreaker.hardLock === false && Object.values(secondBreaker.failures).some((entry) => entry.count === 1),
+    secondBreaker.hardLock === undefined && Object.values(secondBreaker.failures).some((entry) => entry.count === 1),
     JSON.stringify(secondBreaker)
   );
 
@@ -382,9 +367,9 @@ helper.check(
     corruptStateMessage = String(error && error.message ? error.message : error);
   }
   helper.check(
-    '2n. corrupt breaker state fails closed before an edit',
-    corruptStateBlocked && /corrupt/i.test(corruptStateMessage),
-    corruptStateMessage || 'tool.execute.before allowed an edit with corrupt breaker state'
+    '2n. corrupt breaker state fails open instead of becoming a cognitive lock',
+    !corruptStateBlocked,
+    corruptStateMessage || 'corrupt state was ignored as expected'
   );
 
   // A prompt transport failure is retryable without re-running verification

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

@@ -3,14 +3,16 @@ const path = require('path');
 const helper = require('./test-helper');
 const {
   BLOCKED_MARKER,
-  HARDLOCK_MESSAGE,
+  FIRST_CYCLE_MARKERS,
   INSTALLED_PLUGIN_NAME,
-  POST_REFLECTION_MARKER,
-  PRELOCK_MARKER,
+  PRE_REFLECTION_MARKER,
+  PROBE_CONTRACT,
+  REFLECTION_REQUIRED_MESSAGE,
+  RETRIP_MARKERS,
   verifyEvidence,
-} = require('../behavioral-evals/opencode-hardlock-live');
+} = require('../behavioral-evals/opencode-reflection-gate-live');
 
-console.log('\n[31] opencode live hard-lock evidence contract...');
+console.log('\n[31] opencode live Rule-of-3 reflection evidence contract...');
 
 function writeJson(file, value) {
   fs.mkdirSync(path.dirname(file), { recursive: true });
@@ -18,121 +20,63 @@ function writeJson(file, value) {
 }
 
 function makeEvidence() {
-  const dir = helper.tempDir('.mechanism-test-opencode-live-evidence');
+  const dir = helper.tempDir('.mechanism-test-opencode-live-reflection-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 } },
+    schemaVersion: 2, probeContract: PROBE_CONTRACT, 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: PRE_REFLECTION_MARKER }),
+    ...FIRST_CYCLE_MARKERS.map((marker) => toolEvent({ filePath: 'probe.txt', text: marker })),
     toolEvent({ filePath: 'probe.txt', text: BLOCKED_MARKER }),
-    JSON.stringify({ type: 'text', part: { text: `${HARDLOCK_MESSAGE} after a repeat failure post-reflection.` } }),
-    '',
+    ...RETRIP_MARKERS.map((marker) => toolEvent({ filePath: 'probe.txt', text: marker })),
+    JSON.stringify({ type: 'text', part: { text: REFLECTION_REQUIRED_MESSAGE } }), '',
   ].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');
+  fs.writeFileSync(path.join(dir, 'workspace', 'probe.txt'), ['baseline', PRE_REFLECTION_MARKER, ...FIRST_CYCLE_MARKERS, ...RETRIP_MARKERS, ''].join('\n'), 'utf8');
+  const signature = 'npm test: HARNESS_LIVE_PROBE_RED';
   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,
+    failures: { [signature]: { count: 3, firstSeen: 5, lastSeen: 8 } },
+    lastReflection: 4, lastReflectionSignature: signature, reflectionPending: true,
+    reflectionRequestedAt: 8, reflectionToken: 'second456', reflectionSignature: signature,
+  });
+  writeJson(path.join(dir, 'state', 'compliance.json'), {
+    sessionStart: 1, totalEdits: 6, verifiedEdits: 0, circuitBreakerTrips: 2, reflectionsForced: 2,
   });
   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',
-    '',
+    '## Goal','exercise the Rule-of-3 reflection gate','## 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 three-failure cycle after reflection','Reflection token: first123','',
   ].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 valid=makeEvidence(); let result=verifyEvidence(valid);
+  helper.check('31. complete attributed reflection/re-trip 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 wrongPlugin=makeEvidence(); const mf=path.join(wrongPlugin,'metadata.json'); const md=JSON.parse(fs.readFileSync(mf,'utf8'));
+  md.installedPluginSha256='b'.repeat(64); writeJson(mf,md); result=verifyEvidence(wrongPlugin);
+  helper.check('31. evidence fails when the installed plugin hash differs from the canonical source hash',!result.passed&&result.checks.some((e)=>e.name==='installed plugin is byte-identical to the recorded canonical source'&&!e.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 landed=makeEvidence(); fs.appendFileSync(path.join(landed,'workspace','probe.txt'),`${BLOCKED_MARKER}\n`); result=verifyEvidence(landed);
+  helper.check('31. reflection gate fails if the blocked marker reached the filesystem',!result.passed&&result.checks.some((e)=>e.name==='reflection-pending blocked marker did not reach the filesystem'&&!e.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 retired=makeEvidence(); const bf=path.join(retired,'state','circuit-breaker.json'); const bs=JSON.parse(fs.readFileSync(bf,'utf8')); bs.hardLock=true; writeJson(bf,bs); result=verifyEvidence(retired);
+  helper.check('31. current evidence rejects the retired hardLock field',!result.passed&&result.checks.some((e)=>e.name==='snapshot has no retired hardLock field'&&!e.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 noRetrip=makeEvidence(); const rf=path.join(noRetrip,'state','circuit-breaker.json'); const rs=JSON.parse(fs.readFileSync(rf,'utf8')); rs.reflectionPending=false; rs.reflectionToken=null; rs.reflectionSignature=null; writeJson(rf,rs); result=verifyEvidence(noRetrip);
+  helper.check('31. evidence fails without a second Rule-of-3 reflection request',!result.passed&&result.checks.some((e)=>e.name==='three more matching failures request a second reflection instead of a permanent lock'&&!e.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),
-  );
+  const noAttempt=makeEvidence(); const tf=path.join(noAttempt,'transcript.jsonl'); fs.writeFileSync(tf,fs.readFileSync(tf,'utf8').split(/\r?\n/).filter((line)=>!line.includes(BLOCKED_MARKER)).join('\n')); result=verifyEvidence(noAttempt);
+  helper.check('31. evidence fails when no structured edit was attempted during reflectionPending',!result.passed&&result.checks.some((e)=>e.name==='structured tool trace contains the edit attempt blocked by reflectionPending'&&!e.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 first reflection artifact',!result.passed&&result.checks.some((e)=>e.name==='first reflection artifact is valid and preserved'&&!e.pass),JSON.stringify(result.checks));
 
   helper.finish();
-} catch (error) {
-  helper.check('31. OpenCode hard-lock live evidence contract', false, error.stack);
-  helper.finish();
-}
+} catch(error) { helper.check('31. OpenCode Rule-of-3 reflection live evidence contract',false,error.stack); helper.finish(); }

package/ci/openai-plugin-package.test.js

@@ -162,8 +162,8 @@ assert.ok(hooks.hooks.Stop?.length, 'Stop hook missing');
 const hookText = JSON.stringify(hooks);
 assert.match(hookText, /PLUGIN_ROOT/, 'plugin hooks must resolve from PLUGIN_ROOT');
 assert.match(hookText, /commandWindows/, 'plugin hooks need a Windows command override');
-assert.match(hookText, /workflow-gate\.js/, 'plugin hooks must package workflow bypass enforcement');
-assert.match(hookText, /workflow-stop-gate\.js/, 'plugin hooks must package workflow completion enforcement');
+assert.match(hookText, /workflow-gate\.js/, 'plugin hooks must package workflow guidance');
+assert.match(hookText, /workflow-stop-gate\.js/, 'plugin hooks must package workflow completion reminders');
 
 const session = spawnSync(process.execPath, [path.join(PLUGIN, 'hooks', 'session-start.js')], { encoding: 'utf8' });
 assert.strictEqual(session.status, 0, session.stderr);
@@ -190,15 +190,15 @@ assert.strictEqual(second.status, 0, second.stderr);
 assert.strictEqual(first.stdout, second.stdout, 'identical routing input must produce identical output');
 assert.match(first.stdout, /RECOMMENDED TIER:\s*Tier 2/i);
 assert.match(first.stdout, /REQUIRED HARNESS INVARIANTS/);
-assert.match(first.stdout, /WORKFLOW SKILLS \(EVALUATE APPLICABILITY .*SELECTED WORKFLOW IS MANDATORY\)/);
+assert.match(first.stdout, /WORKFLOW SKILLS \(EVALUATE APPLICABILITY .*SELECTED WORKFLOW IS GUIDANCE\)/);
 assert.match(first.stdout, /evaluate-suggestions-before-skip/);
 assert.match(first.stdout, /read its complete SKILL\.md entry/);
 assert.doesNotMatch(first.stdout, /BASE EXECUTION LOOP/);
-assert.match(first.stdout, /ORCHESTRATION POLICY: Mandatory applicable workflow/);
-assert.match(first.stdout, /WORKFLOW EXECUTION CONTRACT \(MANDATORY WHEN SELECTED\)/);
+assert.match(first.stdout, /ORCHESTRATION POLICY: Selected topology is planning guidance/);
+assert.match(first.stdout, /WORKFLOW GUIDANCE \(ADVISORY WHEN SELECTED\)/);
 assert.match(first.stdout, /Selected workflow: iterative-single/);
-assert.match(first.stdout, /Completion requires the workflow obligations and objective verification/);
-assert.doesNotMatch(first.stdout, /execution remains advisory after evaluation/);
+assert.match(first.stdout, /Before claiming completion, review unresolved workflow evidence and objective verification/);
+assert.doesNotMatch(first.stdout, /budget-exhausted|reset-budget/);
 
 const trivial = route('Update one README typo');
 assert.strictEqual(trivial.status, 0, trivial.stderr);
@@ -213,4 +213,4 @@ assert.match(unmatched.stdout, /RECOMMENDED TIER:\s*Unclassified/i);
 assert.match(unmatched.stdout, /"tier":"unclassified"/i);
 assert.doesNotMatch(unmatched.stdout, /RECOMMENDED TIER:\s*Tier 1/i);
 
-console.log(`OpenAI plugin package verified: ${skillNames.length} skills, publication metadata, hooks, marketplace, deterministic mandatory-workflow routing.`);
+console.log(`OpenAI plugin package verified: ${skillNames.length} skills, publication metadata, hooks, marketplace, deterministic guidance-first routing.`);

package/ci/openai-plugin-runtime.test.js

@@ -169,7 +169,7 @@ const subagentStop = runHook('hooks/scripts/subagent-stop.js', {
   cwd: fixture,
   agent_type: 'worker'
 }, stateHome);
-assert.strictEqual(subagentStop.status, 2, subagentStop.stderr);
-assert.match(subagentStop.stderr, /Subagent Scope Guard/);
+assert.strictEqual(subagentStop.status, 0, subagentStop.stderr);
+assert.match(subagentStop.stderr, /Subagent Scope Reminder/);
 
 console.log('OpenAI plugin runtime compatibility verified.');

package/ci/router-workflow-plan.test.js

@@ -75,12 +75,12 @@ if (validContract(iterative, 'iterative-single')) {
   const plan = iterative.contract.workflowPlan;
   check(plan.tier === 'tier2', 'ordinary test-first bug fix is tier2');
   check(plan.strategy === 'iterative-single', 'ordinary bug fix selects iterative-single');
-  check(plan.limits.maxIterations === ITERATIVE_MAX_ITERATIONS, 'iterative-single has an explicit loop budget');
-  check(plan.limits.maxRevisionRounds === WORKFLOW_MAX_REVISION_ROUNDS, 'workflow exposes one numeric revision budget');
-  check(plan.limits.maxReplans === FABLE_MAX_REPLANS, 'workflow exposes one numeric replan budget');
-  check(plan.limits.maxWorkers === FABLE_MAX_WORKERS, 'workflow exposes one numeric worker cap');
+  check(plan.limits.maxIterations === ITERATIVE_MAX_ITERATIONS, 'iterative-single retains an advisory iteration guidance value');
+  check(plan.limits.maxRevisionRounds === WORKFLOW_MAX_REVISION_ROUNDS, 'workflow exposes an advisory revision guidance value');
+  check(plan.limits.maxReplans === FABLE_MAX_REPLANS, 'workflow exposes an advisory replan guidance value');
+  check(plan.limits.maxWorkers === FABLE_MAX_WORKERS, 'workflow exposes an advisory worker guidance value');
   check(plan.requiredInvariants.includes('objective-verification'), 'iterative-single carries objective verification invariant');
-  check(plan.requiredInvariants.includes('loop-budget'), 'iterative-single carries loop-budget invariant');
+  check(plan.requiredInvariants.includes('loop-awareness'), 'iterative-single carries loop-awareness guidance');
   check(plan.suggestedSkills.includes('tdd'), 'TDD stays advisory rather than an invariant');
   check(plan.memory.write === 'none', 'ordinary iterative work cannot write durable memory');
   check(!plan.requiredInvariants.includes('tdd'), 'suggested skills are separated from mandatory invariants');
@@ -262,12 +262,31 @@ check(kernelUnknown.stdout.includes('ROUTER WORKFLOW PLAN (JSON)'), 'kernel emit
 check(kernelUnknown.stdout.includes('"strategySelection":"deferred"'), 'kernel exposes deferred unclassified selection');
 check(!/RECOMMENDED TIER:\s*Tier 1/i.test(kernelUnknown.stdout), 'kernel does not expose a silent Tier 1 fallback for unmatched prompts');
 
+const notificationStateHome = fs.mkdtempSync(path.join(os.tmpdir(), 'harness-router-notification-fail-open-'));
+const notificationStateFile = path.join(notificationStateHome, 'not-a-directory');
+fs.writeFileSync(notificationStateFile, 'x', 'utf8');
+const kernelNotificationPersistFailure = spawnSync(process.execPath, [kernelRouter], {
+  cwd: ROOT,
+  encoding: 'utf8',
+  input: JSON.stringify({
+    session_id: 'router-host-notification-fail-open',
+    cwd: ROOT,
+    hook_event_name: 'UserPromptSubmit',
+    prompt: '<task-notification><task-id>background-1</task-id><status>completed</status></task-notification>',
+  }),
+  env: { ...process.env, HARNESS_STATE_HOME: notificationStateFile, HARNESS_WORKSPACE_ROOT: ROOT },
+});
+check(kernelNotificationPersistFailure.status === 0, 'host notification persistence failure stays fail-open');
+check(kernelNotificationPersistFailure.stdout.includes('Host notification — no active execution contract; ignored for routing.'), 'host notification remains a routing no-op when state persistence fails');
+check(kernelNotificationPersistFailure.stderr.includes('routing state was not persisted'), 'host notification persistence failure remains visible as a reminder');
+fs.rmSync(notificationStateHome, { recursive: true, force: true });
+
 const kernelIterative = spawnSync(process.execPath, [kernelRouter, 'Fix this checkout bug and add a regression test.'], {
   cwd: ROOT,
   encoding: 'utf8',
 });
 check(kernelIterative.stdout.includes('"strategy":"iterative-single"'), 'kernel consumes strategy from structured plan');
-check(kernelIterative.stdout.includes('loop-budget:'), 'kernel prints dynamic plan invariants');
+check(kernelIterative.stdout.includes('loop-awareness:'), 'kernel prints dynamic plan guidance');
 check(kernelIterative.stdout.includes('   - tdd'), 'kernel prints advisory skills separately');
 
 for (const schemaPath of [

package/ci/self-evolve-loop.test.js

@@ -168,7 +168,10 @@ try {
     tool_use_id: 'verify-fail-1',
     tool_response: { exitCode: 1, stderr: 'fixture assertion failed' },
   });
-  check(firstFail.status === 2, 'first verifier failure remains authoritative and blocks stage acceptance');
+  check(firstFail.status === 0, 'first verifier failure remains authoritative without blocking the hook');
+
+  const failedContract = JSON.parse(fs.readFileSync(path.join(prepared.runRoot, 'contracts', 'verify-recovery.json'), 'utf8'));
+  check(failedContract.status === 'fail', 'failed verifier evidence remains authoritative in the stage contract');
 
   const laterPass = run(contractHook, {
     ...basePayload,