harness-everything 0.16.0 → 0.16.1

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/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');
@@ -267,7 +267,7 @@ const kernelIterative = spawnSync(process.execPath, [kernelRouter, 'Fix this che
   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,

package/ci/workflow-execution-contract.test.js

@@ -1,133 +1,55 @@
 #!/usr/bin/env node
 'use strict';
-
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-const { spawnSync } = require('child_process');
-
+const fs = require('fs'), os = require('os'), path = require('path'), { spawnSync } = require('child_process');
 const ROOT = path.resolve(__dirname, '..');
-const { recordBudgetEvent, resetWorkflowBudget } = require(path.join(ROOT, 'hooks/scripts/lib/workflow-runtime.js'));
-let failed = 0;
-
-function check(condition, message) {
-  if (condition) console.log(`  PASS ${message}`);
-  else { console.error(`  FAIL ${message}`); failed++; }
-}
-
-function runNode(args, options = {}) {
-  return spawnSync(process.execPath, args, { cwd: ROOT, encoding: 'utf8', ...options });
-}
-
-console.log('=== Workflow Execution Enforcement ===');
-
-for (const rel of [
-  'harness-everything/scripts/kernel-router.js',
-  'harness-everything/scripts/kernel-router-core.js',
-  'hooks/scripts/workflow-gate.js',
-  'hooks/scripts/workflow-stop-gate.js',
-  'hooks/scripts/workflow-disposition.js',
-]) {
-  const result = runNode(['--check', path.join(ROOT, rel)]);
-  check(result.status === 0, `${rel} parses as valid JavaScript`);
-}
-
-const routed = runNode([
-  path.join(ROOT, 'harness-everything/scripts/kernel-router.js'),
-  'audit the entire repository architecture and coordinate multiple modules',
-]);
-check(routed.status === 0, 'enforced kernel route exits successfully');
-check(routed.stdout.includes('"strategy":"fable-staged"'), 'macro prompt selects fable-staged');
-check(routed.stdout.includes('WORKFLOW EXECUTION CONTRACT (MANDATORY WHEN SELECTED)'), 'wrapper emits mandatory execution contract');
-check(routed.stdout.includes('Execute the selected workflow to resolution'), 'wrapper requires workflow resolution');
-check(routed.stdout.includes('workflow-uncovered-scope'), 'wrapper exposes only explicit evidence-backed escape path');
-check(!routed.stdout.includes('execution remains advisory after evaluation'), 'wrapper removes advisory-execution runtime wording');
-
-const disposition = fs.readFileSync(path.join(ROOT, 'hooks/scripts/workflow-disposition.js'), 'utf8');
-check(disposition.includes("'workflow-uncovered-scope'"), 'escape supports workflow-uncovered-scope');
-check(disposition.includes("'host-capability-unavailable'"), 'escape supports host-capability-unavailable');
-check(disposition.includes('generic simple/routine/already-clear reasons are intentionally rejected'), 'generic confidence-based escape reasons are rejected');
-check(disposition.includes('--scope is required') && disposition.includes('--evidence is required') && disposition.includes('--stage-id must name'), 'escape requires a declared stage, scope and evidence');
-
-const hooks = JSON.parse(fs.readFileSync(path.join(ROOT, 'hooks/hooks.json'), 'utf8'));
-check((hooks.hooks.PreToolUse || []).some(entry => entry.id === 'harness:pre:workflow-gate'), 'Claude hook wiring includes pre-mutation workflow gate');
-check((hooks.hooks.Stop || []).some(entry => entry.id === 'harness:stop:workflow-completion-gate'), 'Claude hook wiring includes workflow completion gate');
-
-
-const budgetRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'harness-budget-'));
-function budgetContext(name, strategy = 'iterative-single', limits = {}) {
-  const file = path.join(budgetRoot, name, 'workflow-run.json');
-  return {
-    root: path.join(budgetRoot, name),
-    sessionId: name,
-    sessionDir: path.join(budgetRoot, name),
-    file,
-    workflow: {
-      schemaVersion: 2,
-      sessionId: name,
-      workflowId: `wf-${name}`,
-      state: 'running',
-      strategy,
-      revision: 0,
-      workflowPlan: {
-        strategy,
-        limits: { maxIterations: 8, maxRevisionRounds: 2, maxReplans: 2, maxWorkers: 4, ...limits },
-      },
-    },
-  };
-}
-function expectBudgetBlock(fn, reason, message) {
-  try {
-    fn();
-    check(false, message);
-  } catch (error) {
-    check(error.code === 'HARNESS_WORKFLOW_BUDGET' && error.message.includes(reason), `${message} (${error.message})`);
+const runtime = require(path.join(ROOT, 'hooks/scripts/lib/workflow-runtime.js'));
+let failed=0;
+function check(c,m){if(c)console.log('  PASS '+m);else{console.error('  FAIL '+m);failed++;}}
+function runNode(args){return spawnSync(process.execPath,args,{cwd:ROOT,encoding:'utf8'});}
+console.log('=== Workflow Guidance Contract ===');
+for(const rel of ['harness-everything/scripts/kernel-router.js','hooks/scripts/workflow-gate.js','hooks/scripts/workflow-stop-gate.js','hooks/scripts/workflow-disposition.js','hooks/scripts/state-persist.js','hooks/scripts/rule-of-3.js','hooks/scripts/rule-of-3-tracker.js'])check(runNode(['--check',path.join(ROOT,rel)]).status===0,rel+' parses as valid JavaScript');
+const ctx={workflow:{workflowPlan:{limits:{maxIterations:8,maxRevisionRounds:2,maxReplans:2,maxWorkers:4}}}};
+for(const type of ['iteration','revision','replan','worker-acquire'])check(runtime.recordBudgetEvent(ctx,type,{evidence:'fixture'}).advisory===true,type+' is advisory rather than blocking');
+check(runtime.mutationProbeReservations(ctx)===0,'mutation probes reserve no capacity');
+check(runtime.registerMutationProbe(ctx,'x','y')===null,'mutation probe registration is a no-op');
+check(runtime.resetWorkflowBudget(ctx,'legacy').retired===true,'reset-budget API is retired compatibility only');
+check(!runtime.WORKFLOW_CONTROLLER_COMMANDS.has('reset-budget'),'reset-budget is no longer a controller command');
+const rs=fs.readFileSync(path.join(ROOT,'hooks/scripts/lib/workflow-runtime.js'),'utf8');
+check(!rs.includes('.mutation-probes.lock'),'runtime contains no mutation-probe lock');
+check(!rs.includes('budget-exhausted'),'runtime contains no budget-exhausted transition');
+const gs=fs.readFileSync(path.join(ROOT,'hooks/scripts/workflow-gate.js'),'utf8');
+check(!gs.includes('registerMutationProbe')&&!gs.includes('recordBudgetEvent'),'workflow gate has no probe/budget enforcement');
+check(gs.includes('[Workflow Reminder]'),'workflow gate emits reminders');
+const r3=fs.readFileSync(path.join(ROOT,'hooks/scripts/rule-of-3.js'),'utf8');
+check(r3.includes('state.count >= 3'),'Rule of 3 uses fixed third-failure boundary');
+check(!r3.includes('blockForHumanDecision'),'Rule of 3 has no second-stage permanent hard lock');
+const tr=fs.readFileSync(path.join(ROOT,'hooks/scripts/rule-of-3-tracker.js'),'utf8');
+check(!tr.includes('threshold = 2')&&!tr.includes('threshold = 4'),'Rule of 3 has no category-specific thresholds');
+const oc=fs.readFileSync(path.join(ROOT,'opencode-plugin/index.mjs'),'utf8');
+check(!oc.includes('action: "hard_lock"'),'OpenCode has no permanent hard-lock action');
+const hk=JSON.parse(fs.readFileSync(path.join(ROOT,'hooks/hooks.json'),'utf8'));
+check(!hk.hooks.PermissionDenied,'obsolete mutation-probe PermissionDenied hook is removed');
+
+const freshnessRoot=fs.mkdtempSync(path.join(os.tmpdir(),'harness-fable-freshness-'));
+try{
+  const contracts=path.join(freshnessRoot,'contracts'),evidence=path.join(freshnessRoot,'evidence');fs.mkdirSync(contracts);fs.mkdirSync(evidence);
+  const run={runId:'freshness-run',planId:'freshness-plan',sessionId:'freshness-session',stageIds:['worker','verifier']};
+  const workerAt=Date.now()-10000,verifierAt=Date.now()-5000;
+  const stages=[
+    {stageId:'worker',agent:'fable-worker',workerId:'worker-1',writeSet:['src/x.js'],dependsOn:[],checkCommand:'worker-check',verifiedAt:new Date(workerAt).toISOString()},
+    {stageId:'verifier',agent:'fable-verifier',workerId:'verifier-1',writeSet:[],dependsOn:['worker'],checkCommand:'verify-check',verifiedAt:new Date(verifierAt).toISOString()},
+  ];
+  for(const stage of stages){
+    const contract={...stage,runId:run.runId,planId:run.planId,sessionId:run.sessionId,status:'pass'};
+    fs.writeFileSync(path.join(contracts,stage.stageId+'.json'),JSON.stringify(contract));
+    fs.writeFileSync(path.join(evidence,stage.stageId+'.json'),JSON.stringify({status:'pass',exitCode:0,planId:run.planId,runId:run.runId,stageId:stage.stageId,sessionId:run.sessionId,checkCommand:stage.checkCommand,observedAt:stage.verifiedAt,workerId:stage.workerId}));
   }
-}
-
-const iterationCtx = budgetContext('iteration');
-for (let i = 0; i < 8; i++) recordBudgetEvent(iterationCtx, 'iteration', { evidence: `mutation-${i + 1}` });
-check(iterationCtx.workflow.budget.counters.iterations === 8, 'iteration budget allows exactly maxIterations events');
-expectBudgetBlock(() => recordBudgetEvent(iterationCtx, 'iteration', { evidence: 'mutation-9' }), 'iteration-budget-exhausted', 'ninth iterative event is blocked');
-check(iterationCtx.workflow.state === 'blocked' && iterationCtx.workflow.budget.state === 'budget-exhausted', 'iteration exhaustion is persisted as blocked evidence');
-const persistedIteration = JSON.parse(fs.readFileSync(iterationCtx.file, 'utf8'));
-check(persistedIteration.blockReason === 'iteration-budget-exhausted', 'budget exhaustion survives on-disk workflow state');
-
-const isolatedCtx = budgetContext('isolated');
-recordBudgetEvent(isolatedCtx, 'iteration', { evidence: 'independent-run' });
-check(isolatedCtx.workflow.budget.counters.iterations === 1, 'another run/session has independent accounting');
-check(iterationCtx.workflow.budget.counters.iterations === 8, 'independent accounting does not reset exhausted run');
-
-resetWorkflowBudget(iterationCtx, 'new explicitly authorized attempt');
-check(iterationCtx.workflow.state === 'pending' && iterationCtx.workflow.budget.epoch === 1, 'budget reset is explicit, auditable, and starts a new epoch');
-check(iterationCtx.workflow.budget.counters.iterations === 0 && iterationCtx.workflow.budget.resets.length === 1, 'reset clears only the target run counters and retains history');
-
-const revisionCtx = budgetContext('revision', 'fable-staged');
-recordBudgetEvent(revisionCtx, 'revision', { evidence: 'verifier-fail-1' });
-recordBudgetEvent(revisionCtx, 'revision', { evidence: 'verifier-fail-2' });
-expectBudgetBlock(() => recordBudgetEvent(revisionCtx, 'revision', { evidence: 'verifier-fail-3' }), 'revision-budget-exhausted', 'third revision round is blocked');
-
-const replanCtx = budgetContext('replan', 'fable-staged');
-recordBudgetEvent(replanCtx, 'replan', { evidence: 'replan-1' });
-recordBudgetEvent(replanCtx, 'replan', { evidence: 'replan-2' });
-expectBudgetBlock(() => recordBudgetEvent(replanCtx, 'replan', { evidence: 'replan-3' }), 'replan-budget-exhausted', 'third full replan is blocked');
-
-const workerCtx = budgetContext('workers', 'fable-parallel');
-for (const id of ['w1', 'w2', 'w3', 'w4']) recordBudgetEvent(workerCtx, 'worker-acquire', { workerId: id });
-check(Object.keys(workerCtx.workflow.budget.activeWorkers).length === 4, 'worker accounting reaches but does not exceed maxWorkers');
-recordBudgetEvent(workerCtx, 'worker-release', { workerId: 'w1' });
-recordBudgetEvent(workerCtx, 'worker-acquire', { workerId: 'w5' });
-check(Object.keys(workerCtx.workflow.budget.activeWorkers).length === 4 && workerCtx.workflow.budget.activeWorkers.w5, 'released worker capacity is reusable');
-
-const overflowCtx = budgetContext('worker-overflow', 'fable-parallel');
-for (const id of ['w1', 'w2', 'w3', 'w4']) recordBudgetEvent(overflowCtx, 'worker-acquire', { workerId: id });
-expectBudgetBlock(() => recordBudgetEvent(overflowCtx, 'worker-acquire', { workerId: 'w5' }), 'worker-budget-exhausted', 'fifth concurrent worker is blocked');
-
-try { fs.rmSync(budgetRoot, { recursive: true, force: true }); } catch (_) {}
-
-const pluginHooks = JSON.parse(fs.readFileSync(path.join(ROOT, 'plugins/harness-everything/hooks/hooks.json'), 'utf8'));
-check((pluginHooks.hooks.PreToolUse || []).some(entry => (entry.hooks || []).some(hook => /workflow-gate\.js/.test(hook.command || ''))), 'OpenAI plugin hook package carries workflow gate adapter');
-check((pluginHooks.hooks.Stop || []).some(entry => (entry.hooks || []).some(hook => /workflow-stop-gate\.js/.test(hook.command || ''))), 'OpenAI plugin hook package carries workflow completion adapter');
-
-console.log(`\n${failed === 0 ? 'PASS' : 'FAIL'}: workflow execution enforcement (${failed} failure${failed === 1 ? '' : 's'})`);
-process.exit(failed === 0 ? 0 : 1);
+  const workflow={lastMutationAt:0,verification:{independent:true}};
+  const fresh=runtime.unresolvedStages({runRoot:freshnessRoot,run},workflow,workerAt);
+  check(!fresh.includes('independent-verifier-missing'),'Fable independent verifier accepts edits older than verifier evidence');
+  const stale=runtime.unresolvedStages({runRoot:freshnessRoot,run},workflow,verifierAt+1000);
+  check(stale.includes('independent-verifier-missing'),'Fable independent verifier is invalidated by newer handoff shell-edit evidence');
+}finally{fs.rmSync(freshnessRoot,{recursive:true,force:true});}
+
+console.log('\n'+(failed===0?'PASS':'FAIL')+': workflow guidance contract ('+failed+' failures)');
+process.exit(failed===0?0:1);

package/ci/workflow-plan-consumers-edge.test.js

@@ -63,7 +63,7 @@ const result = spawnSync(process.execPath, [hook], {
   encoding: 'utf8',
   env: { ...process.env, HARNESS_STATE_HOME: stateHome },
 });
-check(result.status === 2, 'a check from another session cannot resolve this run contract');
+check(result.status === 0 && /session|correlat|resolve/i.test(result.stderr), 'a cross-session check is reported without resolving the run contract');
 const manifest = JSON.parse(fs.readFileSync(path.join(isolated.runRoot, 'contracts', 'verify.json'), 'utf8'));
 check(manifest.status === 'planned', 'cross-session check leaves the target contract unmodified');
 

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

@@ -92,7 +92,7 @@ const runA = prepareRun({
   sessionId: 'phase3-session',
 });
 check(JSON.stringify(runA.execution.batches) === JSON.stringify([['architecture', 'security'], ['synthesis']]), 'parallel plan emits dependency-safe ready batches');
-check(runA.execution.limits.maxWorkers === 4, 'run manifest retains the numeric worker cap');
+check(runA.execution.limits.maxWorkers === 4, 'run manifest retains maxWorkers as an advisory planning hint');
 check(fs.existsSync(path.join(runA.runRoot, 'contracts', 'security.json')), 'run-scoped stage contract is written');
 check(fs.existsSync(path.join(runA.runRoot, 'contracts', 'synthesis.json')), 'downstream stage has its own contract');
 
@@ -119,9 +119,9 @@ const wideRun = prepareRun({
   runId: 'phase3-wide-parallel',
   sessionId: 'wide-session',
 });
-check(wideRun.execution.batches.length === 2, 'ready set larger than worker cap is deterministically chunked');
-check(wideRun.execution.batches.every(batch => batch.length <= 4), 'no dispatchable batch exceeds maxWorkers=4');
-check(wideRun.execution.batches.flat().length === 6, 'worker-cap chunking preserves every ready stage');
+check(wideRun.execution.batches.length === 1, 'ready set is not hard-chunked by the advisory maxWorkers hint');
+check(wideRun.execution.batches[0].length === 6, 'all dependency-ready stages remain dispatchable');
+check(wideRun.execution.batches.flat().length === 6, 'advisory worker guidance preserves every ready stage');
 
 const stagedRun = prepareRun({
   routerContract: stagedContract,
@@ -235,7 +235,7 @@ const ambiguousResult = spawnSync(process.execPath, [contractHook], {
   encoding: 'utf8',
   env: { ...process.env, HARNESS_STATE_HOME: stateHome },
 });
-check(ambiguousResult.status === 2, 'ambiguous same-command correlation blocks acceptance');
+check(ambiguousResult.status === 0 && /ambiguous|multiple/i.test(ambiguousResult.stderr), 'ambiguous same-command correlation is reported without blocking');
 for (const runId of ['ambiguous-a', 'ambiguous-b']) {
   const manifest = JSON.parse(fs.readFileSync(path.join(getWorkspaceStateRoot(workspace), 'fable-runs', runId, 'contracts', 'same-check.json'), 'utf8'));
   check(manifest.status === 'planned', `${runId} remains unmodified after ambiguous check`);
@@ -280,7 +280,7 @@ check(inScope.status === 0 && /in-scope/.test(inScope.stdout), 'declared in-scop
 check(runScope('PreToolUse').status === 0, 'next burst starts from rolled-forward baseline');
 fs.writeFileSync(path.join(gitWorkspace, 'docs', 'oops.txt'), 'unexpected\n');
 const outOfScope = runScope('PostToolUse');
-check(outOfScope.status === 2 && /OUT-OF-SCOPE/.test(outOfScope.stderr), 'undeclared worker edit is rejected by scope guard');
+check(outOfScope.status === 0 && /OUT-OF-SCOPE/.test(outOfScope.stderr), 'undeclared worker edit is reported without blocking');
 
 const contractDoc = fs.readFileSync(path.join(ROOT, 'fable-mode', 'CONTRACT-FORMAT.md'), 'utf8');
 const orchestratorDoc = fs.readFileSync(path.join(ROOT, 'fable-mode', 'agents', 'fable-orchestrator.md'), 'utf8');