harness-everything 0.15.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-2al-codex-hooks-compat.test.js

@@ -0,0 +1,286 @@
+#!/usr/bin/env node
+'use strict';
+
+const assert = require('assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const compat = require('../scripts/codex-hooks-compat');
+
+let failed = 0;
+function check(condition, message, detail = '') {
+  if (condition) console.log('  PASS ' + message);
+  else {
+    failed++;
+    console.error('  FAIL ' + message + (detail ? ' — ' + detail : ''));
+  }
+}
+
+function read(file) {
+  return JSON.parse(fs.readFileSync(file, 'utf8'));
+}
+
+function findHarnessEntries(config, runtimeDir) {
+  const out = [];
+  for (const [event, entries] of Object.entries(config.hooks || {})) {
+    for (const entry of entries || []) {
+      if (JSON.stringify(entry).toLowerCase().includes(path.resolve(runtimeDir).replace(/\\/g, '\\\\').toLowerCase()) ||
+          JSON.stringify(entry).replace(/\\\\/g, '/').toLowerCase().includes(path.resolve(runtimeDir).replace(/\\/g, '/').toLowerCase())) {
+        out.push({ event, entry });
+      }
+    }
+  }
+  return out;
+}
+
+console.log('\n[2al] Codex user-hook compatibility fallback (#122)...');
+
+const root = fs.mkdtempSync(path.join(os.tmpdir(), 'harness-codex-hooks-compat-'));
+const codexHome = path.join(root, '.codex');
+fs.mkdirSync(codexHome, { recursive: true });
+const hooksFile = path.join(codexHome, 'hooks.json');
+const configFile = path.join(codexHome, 'config.toml');
+const userHook = {
+  matcher: 'Bash',
+  hooks: [{
+    type: 'command',
+    command: 'node "/user/policy.js"',
+    timeout: 7,
+    statusMessage: 'User policy',
+  }],
+};
+const original = {
+  description: 'user-owned metadata',
+  hooks: {
+    PreToolUse: [userHook],
+    Stop: [{
+      hooks: [{ type: 'command', command: 'node "/user/stop.js"', timeout: 5 }],
+    }],
+  },
+};
+fs.writeFileSync(hooksFile, JSON.stringify(original, null, 4) + '\n', 'utf8');
+fs.writeFileSync(configFile, 'model = "test"\n# user trust/config state\n', 'utf8');
+const configBefore = fs.readFileSync(configFile, 'utf8');
+
+try {
+  const installed = compat.install({ codexHome });
+  check(installed.status === 'installed' && installed.entries > 0,
+    'explicit install materializes compatibility entries');
+  check(installed.trustChanged === false && fs.readFileSync(configFile, 'utf8') === configBefore,
+    'install never changes Codex trust/config.toml state');
+
+  const state = compat.status({ codexHome });
+  check(state.installed && state.healthy && state.exactEntriesPresent === state.expectedEntries,
+    'status verifies exact installed entry hashes and runtime tree');
+
+  const config = read(hooksFile);
+  check(config.description === original.description &&
+    JSON.stringify(config.hooks.PreToolUse[0]) === JSON.stringify(userHook) &&
+    config.hooks.Stop.some(entry => entry.hooks?.[0]?.command === 'node "/user/stop.js"'),
+    'existing unrelated user hooks and top-level metadata are preserved semantically');
+
+  const manifest = read(path.join(codexHome, 'harness-everything', 'compat-hooks', 'manifest.json'));
+  const harnessEntries = findHarnessEntries(config, manifest.runtimeDir);
+  check(harnessEntries.length === manifest.entries.length,
+    'every compatibility hook command resolves to the Harness-owned runtime copy');
+  check(!JSON.stringify(harnessEntries).includes('${PLUGIN_ROOT}') &&
+    !JSON.stringify(harnessEntries).includes('${CLAUDE_PLUGIN_ROOT}') &&
+    !JSON.stringify(harnessEntries).includes('%PLUGIN_ROOT%'),
+    'compatibility entries use literal absolute runtime paths without shell-specific plugin expansion');
+  check(fs.existsSync(path.join(manifest.runtimeDir, 'hooks', 'scripts', 'codex-action-gate-pre.js')) &&
+    fs.existsSync(path.join(manifest.runtimeDir, 'skills', 'harness-everything', 'scripts', 'kernel-router.js')),
+    'compatibility runtime is self-contained for hook and router dependencies');
+
+  const countsBefore = Object.fromEntries(Object.entries(config.hooks).map(([event, entries]) => [event, entries.length]));
+  const updated = compat.install({ codexHome });
+  const configAfterUpdate = read(hooksFile);
+  const countsAfter = Object.fromEntries(Object.entries(configAfterUpdate.hooks).map(([event, entries]) => [event, entries.length]));
+  check(updated.status === 'updated' && JSON.stringify(countsAfter) === JSON.stringify(countsBefore),
+    'reinstall/update is idempotent and does not duplicate hook entries');
+
+  configAfterUpdate.hooks.PostToolUse = configAfterUpdate.hooks.PostToolUse || [];
+  const addedUserHook = { hooks: [{ type: 'command', command: 'node "/user/later.js"', timeout: 3 }] };
+  configAfterUpdate.hooks.PostToolUse.unshift(addedUserHook);
+  fs.writeFileSync(hooksFile, JSON.stringify(configAfterUpdate, null, 2) + '\n', 'utf8');
+  compat.install({ codexHome });
+  check(read(hooksFile).hooks.PostToolUse.some(entry => entry.hooks?.[0]?.command === 'node "/user/later.js"'),
+    'update preserves user hooks added after the initial compatibility install');
+
+  const beforeTamper = fs.readFileSync(hooksFile, 'utf8');
+  const tampered = read(hooksFile);
+  const currentManifest = read(path.join(codexHome, 'harness-everything', 'compat-hooks', 'manifest.json'));
+  let changed = false;
+  for (const [event, entries] of Object.entries(tampered.hooks)) {
+    for (const entry of entries) {
+      if (!changed && JSON.stringify(entry).replace(/\\\\/g, '/').toLowerCase()
+          .includes(path.resolve(currentManifest.runtimeDir).replace(/\\/g, '/').toLowerCase())) {
+        entry.hooks[0].statusMessage = 'user modified this installed Harness hook';
+        changed = true;
+      }
+    }
+  }
+  fs.writeFileSync(hooksFile, JSON.stringify(tampered, null, 2) + '\n', 'utf8');
+  const tamperedBytes = fs.readFileSync(hooksFile, 'utf8');
+  let updateRefused = false;
+  try { compat.install({ codexHome }); } catch (error) { updateRefused = /modified/.test(error.message); }
+  check(updateRefused && fs.readFileSync(hooksFile, 'utf8') === tamperedBytes,
+    'modified Harness compatibility entry makes update fail closed without rewriting user config');
+
+  let uninstallRefused = false;
+  try { compat.uninstall({ codexHome }); } catch (error) { uninstallRefused = /modified/.test(error.message); }
+  check(uninstallRefused && fs.readFileSync(hooksFile, 'utf8') === tamperedBytes,
+    'modified Harness compatibility entry makes uninstall fail closed rather than deleting user edits');
+
+  // Restore the exact generated config by starting from the pre-tamper bytes.
+  fs.writeFileSync(hooksFile, beforeTamper, 'utf8');
+  compat.install({ codexHome });
+  const removed = compat.uninstall({ codexHome });
+  const finalConfig = read(hooksFile);
+  check(removed.status === 'uninstalled' && removed.removed > 0 && removed.trustChanged === false,
+    'explicit uninstall removes exact Harness-owned entries without changing trust state');
+  check(finalConfig.description === original.description &&
+    finalConfig.hooks.PreToolUse.some(entry => entry.hooks?.[0]?.command === 'node "/user/policy.js"') &&
+    finalConfig.hooks.Stop.some(entry => entry.hooks?.[0]?.command === 'node "/user/stop.js"') &&
+    finalConfig.hooks.PostToolUse.some(entry => entry.hooks?.[0]?.command === 'node "/user/later.js"'),
+    'uninstall preserves unrelated pre-existing and later-added user hooks');
+  check(fs.readFileSync(configFile, 'utf8') === configBefore,
+    'uninstall leaves config.toml/trust state byte-identical');
+  check(!fs.existsSync(path.join(codexHome, 'harness-everything', 'compat-hooks', 'manifest.json')),
+    'uninstall removes Harness compatibility ownership manifest');
+
+  const emptyHome = path.join(root, 'empty-codex');
+  fs.mkdirSync(emptyHome, { recursive: true });
+  compat.install({ codexHome: emptyHome });
+  check(fs.existsSync(path.join(emptyHome, 'hooks.json')),
+    'compatibility install can create a new hooks.json when none exists');
+  compat.uninstall({ codexHome: emptyHome });
+  check(!fs.existsSync(path.join(emptyHome, 'hooks.json')),
+    'uninstall removes hooks.json only when Harness created it and no user entries remain');
+
+  const duplicateHome = path.join(root, 'duplicate-codex');
+  fs.mkdirSync(duplicateHome, { recursive: true });
+  compat.install({ codexHome: duplicateHome });
+  const duplicateConfig = read(path.join(duplicateHome, 'hooks.json'));
+  duplicateConfig.hooks.PreToolUse.push(JSON.parse(JSON.stringify(duplicateConfig.hooks.PreToolUse[0])));
+  fs.writeFileSync(path.join(duplicateHome, 'hooks.json'), JSON.stringify(duplicateConfig, null, 2) + '\n', 'utf8');
+  const duplicateBytes = fs.readFileSync(path.join(duplicateHome, 'hooks.json'), 'utf8');
+  let duplicateRefused = false;
+  try { compat.uninstall({ codexHome: duplicateHome }); } catch (error) { duplicateRefused = /modified/.test(error.message); }
+  check(duplicateRefused && fs.readFileSync(path.join(duplicateHome, 'hooks.json'), 'utf8') === duplicateBytes,
+    'extra identical Harness hook is treated as user config drift, not silently deleted');
+
+  const removedConfigHome = path.join(root, 'removed-config-codex');
+  fs.mkdirSync(removedConfigHome, { recursive: true });
+  fs.writeFileSync(path.join(removedConfigHome, 'hooks.json'), JSON.stringify(original, null, 2) + '\n', 'utf8');
+  compat.install({ codexHome: removedConfigHome });
+  fs.rmSync(path.join(removedConfigHome, 'hooks.json'), { force: true });
+  const removedConfigResult = compat.uninstall({ codexHome: removedConfigHome });
+  check(removedConfigResult.status === 'uninstalled' && !fs.existsSync(path.join(removedConfigHome, 'hooks.json')),
+    'uninstall never recreates a user hooks.json that was removed after compatibility install');
+
+  const preexistingHome = path.join(root, 'preexisting-identical-codex');
+  fs.mkdirSync(preexistingHome, { recursive: true });
+  const sourceHash = compat.treeHash(compat.SOURCE_PLUGIN_ROOT);
+  const preexistingPaths = compat.pathsFor(preexistingHome, sourceHash);
+  const preexistingEntries = compat.sourceHookEntries(preexistingPaths.runtimeDir);
+  const preexistingHooks = {};
+  for (const record of preexistingEntries) {
+    preexistingHooks[record.event] = preexistingHooks[record.event] || [];
+    preexistingHooks[record.event].push(JSON.parse(JSON.stringify(record.entry)));
+  }
+  fs.writeFileSync(path.join(preexistingHome, 'hooks.json'),
+    JSON.stringify({ hooks: preexistingHooks }, null, 2) + '\n', 'utf8');
+  const preexistingBefore = fs.readFileSync(path.join(preexistingHome, 'hooks.json'), 'utf8');
+  const preexistingInstall = compat.install({ codexHome: preexistingHome });
+  const preexistingManifest = read(path.join(preexistingHome, 'harness-everything', 'compat-hooks', 'manifest.json'));
+  check(preexistingInstall.status === 'installed' && preexistingManifest.entries.length === 0,
+    'byte-identical pre-existing user hooks are reused but never recorded as Harness-owned');
+  const preexistingRemoved = compat.uninstall({ codexHome: preexistingHome });
+  check(preexistingRemoved.removed === 0 &&
+    fs.readFileSync(path.join(preexistingHome, 'hooks.json'), 'utf8') === preexistingBefore,
+    'uninstall preserves byte-identical hooks that predated compatibility install');
+
+  const forgedManifestHome = path.join(root, 'forged-manifest-codex');
+  fs.mkdirSync(forgedManifestHome, { recursive: true });
+  fs.writeFileSync(path.join(forgedManifestHome, 'hooks.json'),
+    JSON.stringify({ hooks: { PreToolUse: [userHook] } }, null, 2) + '\n', 'utf8');
+  compat.install({ codexHome: forgedManifestHome });
+  const forgedManifestPath = path.join(
+    forgedManifestHome, 'harness-everything', 'compat-hooks', 'manifest.json');
+  const forgedManifest = read(forgedManifestPath);
+  forgedManifest.entries.push({
+    event: 'PreToolUse',
+    hash: compat.entryHash(userHook),
+    entry: userHook,
+  });
+  fs.writeFileSync(forgedManifestPath, JSON.stringify(forgedManifest, null, 2) + '\n', 'utf8');
+  const forgedHooksBefore = fs.readFileSync(path.join(forgedManifestHome, 'hooks.json'), 'utf8');
+  let forgedManifestRefused = false;
+  try { compat.uninstall({ codexHome: forgedManifestHome }); }
+  catch (error) { forgedManifestRefused = /corrupt/.test(error.message); }
+  check(forgedManifestRefused &&
+    fs.readFileSync(path.join(forgedManifestHome, 'hooks.json'), 'utf8') === forgedHooksBefore,
+    'forged manifest ownership fails closed without deleting a user hook');
+
+  const failedInstallHome = path.join(root, 'failed-install-codex');
+  fs.mkdirSync(failedInstallHome, { recursive: true });
+  const failedInstallHooks = path.join(failedInstallHome, 'hooks.json');
+  fs.writeFileSync(failedInstallHooks,
+    JSON.stringify({ description: 'must survive', hooks: { PreToolUse: [userHook] } }, null, 4) + '\n',
+    'utf8');
+  const failedInstallBefore = fs.readFileSync(failedInstallHooks, 'utf8');
+  const failedManifestPath = path.join(
+    failedInstallHome, 'harness-everything', 'compat-hooks', 'manifest.json');
+  const realRenameSync = fs.renameSync;
+  let failedInstallRefused = false;
+  fs.renameSync = function injectedManifestFailure(source, destination) {
+    if (path.resolve(destination) === path.resolve(failedManifestPath)) {
+      throw new Error('injected manifest commit failure');
+    }
+    return realRenameSync(source, destination);
+  };
+  try { compat.install({ codexHome: failedInstallHome }); }
+  catch (error) { failedInstallRefused = /injected manifest commit failure/.test(error.message); }
+  finally { fs.renameSync = realRenameSync; }
+  check(failedInstallRefused &&
+    fs.readFileSync(failedInstallHooks, 'utf8') === failedInstallBefore &&
+    !fs.existsSync(failedManifestPath),
+    'failed manifest commit rolls hooks.json back byte-identically');
+
+  const linkedOwnerHome = path.join(root, 'linked-owner-codex');
+  const linkedOwnerOutside = path.join(root, 'linked-owner-outside');
+  fs.mkdirSync(path.join(linkedOwnerHome, 'harness-everything'), { recursive: true });
+  fs.mkdirSync(linkedOwnerOutside, { recursive: true });
+  fs.symlinkSync(
+    linkedOwnerOutside,
+    path.join(linkedOwnerHome, 'harness-everything', 'compat-hooks'),
+    process.platform === 'win32' ? 'junction' : 'dir'
+  );
+  let linkedOwnerRefused = false;
+  try { compat.install({ codexHome: linkedOwnerHome }); }
+  catch (error) { linkedOwnerRefused = /linked|outside/.test(error.message); }
+  check(linkedOwnerRefused && fs.readdirSync(linkedOwnerOutside).length === 0,
+    'linked compatibility owner path cannot redirect writes outside Codex home');
+
+  const malformedHome = path.join(root, 'malformed-codex');
+  fs.mkdirSync(malformedHome, { recursive: true });
+  const malformed = path.join(malformedHome, 'hooks.json');
+  fs.writeFileSync(malformed, '{ this is not json', 'utf8');
+  const malformedBefore = fs.readFileSync(malformed, 'utf8');
+  let malformedRefused = false;
+  try { compat.install({ codexHome: malformedHome }); } catch (_) { malformedRefused = true; }
+  check(malformedRefused && fs.readFileSync(malformed, 'utf8') === malformedBefore,
+    'malformed user hooks.json fails closed without replacement');
+
+  const source = read(path.join(compat.SOURCE_PLUGIN_ROOT, 'hooks', 'hooks.json'));
+  const sourceCount = Object.values(source.hooks).reduce((sum, entries) => sum + entries.length, 0);
+  check(sourceCount === installed.entries,
+    'fallback derives from the current packaged hook manifest instead of maintaining a second manual hook inventory');
+} finally {
+  fs.rmSync(root, { recursive: true, force: true });
+}
+
+console.log('\n' + (failed === 0 ? 'PASS' : 'FAIL') +
+  ': #122 Codex compatibility fallback (' + failed + ' failure' + (failed === 1 ? '' : 's') + ')');
+process.exit(failed === 0 ? 0 : 1);

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,