harness-everything 0.11.6 → 0.12.0

package/ci/mechanism-2a-rule-of-3.test.js

@@ -68,6 +68,77 @@ helper.check(
   `Got exit=${successResult.code}, state=${JSON.stringify(resetState)}`
 );
 
+helper.runHook('rule-of-3-tracker.js', claudeFailurePayload);
+const claudeNoExitSuccess = helper.runHook('rule-of-3-tracker.js', {
+  hook_event_name: 'PostToolUse',
+  tool_name: 'Bash',
+  tool_input: { command: 'echo recovered' },
+  tool_response: {
+    stdout: 'recovered',
+    stderr: 'warning: successful command emitted an error-like diagnostic',
+  },
+  session_id: helper.SESSION_ID,
+});
+const noExitResetState = helper.readState('rule-of-3-state.json');
+helper.check(
+  '2a-claude-success-no-exit. PostToolUse without exitCode resets even with stderr diagnostics',
+  claudeNoExitSuccess.code === 0 &&
+    noExitResetState.count === 0 &&
+    noExitResetState.zoomOutResolved === true,
+  `Got exit=${claudeNoExitSuccess.code}, state=${JSON.stringify(noExitResetState)}`
+);
+
+helper.writeState('rule-of-3-state.json', {
+  count: 0, lastHash: null, zoomOutResolved: false, zoomOutCycles: 0, lastFailureAt: 0,
+});
+helper.runHook('rule-of-3-tracker.js', {
+  hook_event_name: 'PostToolUseFailure',
+  tool_name: 'Bash',
+  tool_input: { command: 'diff -rq hooks cache-hooks' },
+  error: 'Exit code 1\nworkflow-mutation-denied.js\nFiles hooks/a.js and cache-hooks/a.js differ',
+  session_id: helper.SESSION_ID,
+});
+const deniedFilenameState = helper.readState('rule-of-3-state.json');
+helper.check(
+  '2a-category-negative. File name containing denied stays unknown/threshold 3',
+  deniedFilenameState.category === 'unknown' && deniedFilenameState.threshold === 3,
+  `State=${JSON.stringify(deniedFilenameState)}`
+);
+
+helper.writeState('rule-of-3-state.json', {
+  count: 0, lastHash: null, zoomOutResolved: false, zoomOutCycles: 0, lastFailureAt: 0,
+});
+helper.runHook('rule-of-3-tracker.js', {
+  hook_event_name: 'PostToolUseFailure',
+  tool_name: 'Bash',
+  tool_input: { command: 'cat protected.txt' },
+  error: 'EACCES: permission denied, open protected.txt',
+  session_id: helper.SESSION_ID,
+});
+const permissionState = helper.readState('rule-of-3-state.json');
+helper.check(
+  '2a-category-permission. Real EACCES is permission/threshold 2',
+  permissionState.category === 'permission' && permissionState.threshold === 2,
+  `State=${JSON.stringify(permissionState)}`
+);
+
+helper.writeState('rule-of-3-state.json', {
+  count: 0, lastHash: null, zoomOutResolved: false, zoomOutCycles: 0, lastFailureAt: 0,
+});
+helper.runHook('rule-of-3-tracker.js', {
+  hook_event_name: 'PostToolUseFailure',
+  tool_name: 'Bash',
+  tool_input: { command: 'node slow.js' },
+  error: 'TimeoutError: operation timed out',
+  session_id: helper.SESSION_ID,
+});
+const timeoutState = helper.readState('rule-of-3-state.json');
+helper.check(
+  '2a-category-timeout. Real timeout is timeout/threshold 2',
+  timeoutState.category === 'timeout' && timeoutState.threshold === 2,
+  `State=${JSON.stringify(timeoutState)}`
+);
+
 helper.writeState('rule-of-3-state.json', { count: 3, lastHash: 'mech-test', zoomOutResolved: false });
 const tripResult = helper.runHook('rule-of-3.js', { session_id: helper.SESSION_ID });
 helper.check(

package/ci/mechanism-2ah-workflow-lifecycle.test.js

@@ -17,6 +17,7 @@ const env = { ...process.env, HARNESS_STATE_HOME: path.join(temp, 'state'), HARN
 process.env.HARNESS_STATE_HOME = env.HARNESS_STATE_HOME;
 const state = require(path.join(runtimeRoot, 'hooks/scripts/lib/harness-state'));
 const workflowRuntime = require(path.join(runtimeRoot, 'hooks/scripts/lib/workflow-runtime'));
+const workflowIsolation = require(path.join(runtimeRoot, 'hooks/scripts/lib/workflow-isolation'));
 const sessionId = 'workflow-lifecycle';
 const payload = { session_id: sessionId, cwd: repo };
 const sessionDir = state.getSessionDir(repo, sessionId);
@@ -35,6 +36,14 @@ function git(args) {
 }
 const route = prompt => node('harness-everything/scripts/kernel-router.js', { ...payload, prompt });
 const gate = (tool, input, cwd = linked) => node('hooks/scripts/workflow-gate.js', { ...payload, cwd, tool_name: tool, tool_input: input });
+const persistDirect = (tool, input, cwd = repo, response = {}) => node('hooks/scripts/state-persist.js', {
+  ...payload,
+  cwd,
+  hook_event_name: 'PostToolUse',
+  tool_name: tool,
+  tool_input: input,
+  tool_response: response,
+});
 let toolUseSeq = 0;
 function beginShell(command, cwd = repo) {
   const toolUseId = 'toolu_fixture_' + (++toolUseSeq);
@@ -77,6 +86,28 @@ const probeFiles = () => {
 };
 const stop = extra => node('hooks/scripts/workflow-stop-gate.js', { ...payload, ...extra });
 const control = (...args) => node('hooks/scripts/workflow-disposition.js', null, [args[0], '--session-id', sessionId, ...args.slice(1)]);
+function fixtureSession(fixtureSessionId) {
+  const fixturePayload = { session_id: fixtureSessionId, cwd: repo };
+  const fixtureSessionDir = state.getSessionDir(repo, fixtureSessionId);
+  const fixtureFile = path.join(fixtureSessionDir, 'workflow-run.json');
+  return {
+    payload: fixturePayload,
+    file: fixtureFile,
+    sessionDir: fixtureSessionDir,
+    route: prompt => node('harness-everything/scripts/kernel-router.js', { ...fixturePayload, prompt }),
+    gate: (tool, input, extra = {}) => node('hooks/scripts/workflow-gate.js', { ...fixturePayload, ...extra, tool_name: tool, tool_input: input }),
+    persist: (tool, input, response = {}, extra = {}) => node('hooks/scripts/state-persist.js', {
+      ...fixturePayload,
+      ...extra,
+      hook_event_name: 'PostToolUse',
+      tool_name: tool,
+      tool_input: input,
+      tool_response: response,
+    }),
+    stop: extra => node('hooks/scripts/workflow-stop-gate.js', { ...fixturePayload, ...extra }),
+    control: (...args) => node('hooks/scripts/workflow-disposition.js', null, [args[0], '--session-id', fixtureSessionId, ...args.slice(1)]),
+  };
+}
 const stages = [
   { stageId: 'build', goal: 'fix', agent: 'fable-worker', task: 'fix bounded module', dependsOn: [], writeSet: ['src'], checkCommand: 'node test-build.js', passCondition: 'exit 0' },
   { stageId: 'optional', goal: 'external scope', agent: 'fable-worker', task: 'external task', dependsOn: [], writeSet: [], checkCommand: 'node external.js', passCondition: 'exit 0' },
@@ -84,9 +115,95 @@ const stages = [
 ];
 
 try {
+  // #162: Tier-2 shell accounting must degrade conservatively when a workspace
+  // is not a Git repository. Lack of a Git fingerprint is not an isolation
+  // violation for a non-major workflow.
+  const nonGit = fixtureSession('workflow-non-git');
+  check(nonGit.route('Fix this checkout bug with a regression test').status === 0 &&
+    read(nonGit.file).strategy === 'iterative-single',
+    '#162 non-git fixture routes to Tier 2 iterative workflow');
+  check(nonGit.control('start').status === 0 && read(nonGit.file).state === 'running',
+    '#162 non-git Tier 2 workflow starts normally');
+  let nonGitIterations = read(nonGit.file).budget?.counters?.iterations || 0;
+  for (const [index, command] of ['npm --version', 'node -e "process.exit(0)"', 'cd .', 'git init -q'].entries()) {
+    const toolUseId = 'toolu_non_git_pre_' + index;
+    const admitted = nonGit.gate('Bash', { command }, { tool_use_id: toolUseId });
+    check(admitted.status === 0, '#162 non-git Tier 2 admits untrusted shell: ' + command);
+    const afterGate = read(nonGit.file);
+    check(afterGate.budget.counters.iterations === ++nonGitIterations &&
+      afterGate.lastMutationAt > 0 &&
+      afterGate.budget.events.at(-1)?.evidence === 'shell:unobservable-workspace',
+      '#162 unobservable non-git shell is conservatively counted once: ' + command);
+    check(nonGit.persist('Bash', { command }, { stdout: 'fixture success' }, { tool_use_id: toolUseId }).status === 0,
+      '#162 non-git shell PostToolUse stays fail-open without a probe: ' + command);
+  }
+
+  // A probe may have been created while Git was observable and become
+  // unobservable before PostToolUse (for example .git disappears). Tier 2
+  // must settle it conservatively instead of blocking the workflow.
+  const lostObservationId = 'toolu_non_git_post_fallback';
+  const lostObservationPayload = {
+    ...nonGit.payload,
+    tool_name: 'Bash',
+    tool_use_id: lostObservationId,
+    tool_input: { command: 'node lost-observation.js' },
+  };
+  const lostObservationContext = workflowRuntime.loadWorkflow(lostObservationPayload);
+  const lostObservationKey = workflowIsolation.shellProbeKey(lostObservationPayload, repo);
+  workflowRuntime.registerMutationProbe(lostObservationContext, lostObservationKey, 'f'.repeat(64), true);
+  const beforeLostObservation = read(nonGit.file);
+  check(nonGit.persist('Bash', { command: 'node lost-observation.js' }, { stdout: 'fixture success' },
+    { tool_use_id: lostObservationId }).status === 0,
+    '#162 Tier 2 PostToolUse degrades when workspace observation becomes unavailable');
+  const afterLostObservation = read(nonGit.file);
+  check(afterLostObservation.state === 'running' &&
+    afterLostObservation.budget.counters.iterations === beforeLostObservation.budget.counters.iterations + 1 &&
+    afterLostObservation.lastMutationAt >= (beforeLostObservation.lastMutationAt || 0),
+    '#162 lost post-observation is settled as one conservative mutation without blocking');
+
+  const nonGitTarget = path.join(repo, 'non-git-edit.txt');
+  check(nonGit.gate('Write', { file_path: nonGitTarget }).status === 0,
+    '#162 direct edit remains available in non-git Tier 2');
+  fs.writeFileSync(nonGitTarget, 'changed\n');
+  check(nonGit.persist('Write', { file_path: nonGitTarget }).status === 0,
+    '#162 direct non-git edit persists mutation milestone');
+  const verifyId = 'toolu_non_git_verify';
+  check(nonGit.gate('Bash', { command: 'node run-test.js' }, { tool_use_id: verifyId }).status === 0,
+    '#162 verification shell is admitted in non-git Tier 2');
+  check(nonGit.persist('Bash', { command: 'node run-test.js' }, { stdout: 'tests passed' },
+    { tool_use_id: verifyId }).status === 0,
+    '#162 non-git verification result is persisted');
+  check(nonGit.stop().status === 0 && read(nonGit.file).state === 'satisfied',
+    '#162 edit then verification can satisfy Stop in non-git Tier 2');
+
+  const nonGitMajor = fixtureSession('workflow-non-git-major');
+  check(nonGitMajor.route('Refactor the entire authentication architecture across all services without fable').status === 0 &&
+    read(nonGitMajor.file).tier === 'tier3',
+    '#162 non-git major fixture routes to Tier 3');
+  check(nonGitMajor.control('start').status === 0 && read(nonGitMajor.file).state === 'running',
+    '#162 non-Fable Tier 3 controller can enter running state before mutation');
+  const majorBlocked = nonGitMajor.gate('Bash', { command: 'node mutate.js' }, { tool_use_id: 'toolu_non_git_major' });
+  check(majorBlocked.status === 2 && /Git worktree isolation/i.test(majorBlocked.stderr),
+    '#162 non-git Tier 3 remains fail-closed with an isolation-specific error');
+
+  fs.unlinkSync(nonGitTarget);
   git(['init']); fs.writeFileSync(path.join(repo, 'README.md'), 'fixture\n'); git(['add', '.']);
   git(['-c', 'user.name=Harness Test', '-c', 'user.email=harness@example.invalid', 'commit', '-m', 'fixture']);
   git(['worktree', 'add', linked, '-b', 'isolated']);
+  const taskNotification = '<task-notification><summary>Background command "Run full test suite" failed with exit code 1</summary></task-notification>';
+  const unboundNotification = node('harness-everything/scripts/kernel-router.js', { cwd: repo, prompt: taskNotification });
+  check(unboundNotification.status === 0 &&
+    unboundNotification.stdout.includes('ignored for routing') &&
+    !unboundNotification.stdout.includes('WORKFLOW EXECUTION CONTRACT'),
+    'host notification without session binding is a routing no-op');
+  const noWorkflowNotification = route(taskNotification);
+  check(noWorkflowNotification.status === 0 && !fs.existsSync(file),
+    'host notification with no active workflow creates no contract');
+  check(noWorkflowNotification.stdout.includes('ignored for routing') &&
+    !noWorkflowNotification.stdout.includes('iterative-single') &&
+    !noWorkflowNotification.stdout.includes('WORKFLOW EXECUTION CONTRACT'),
+    'host notification with no active workflow emits no notification-derived routing contract');
+
   const routed = route('Refactor the entire repository architecture in dependent stages.');
   check(routed.status === 0, 'prompt hook creates workflow');
   const initial = read(file);
@@ -149,6 +266,15 @@ try {
   check(stop().status === 2, 'verification predating a new mutation is stale');
   write(file, mutationState);
   check(stop().status === 0 && read(file).state === 'satisfied', 'all covered stages and verifier resolve workflow to satisfied');
+  const satisfiedWorkflow = read(file);
+  const satisfiedNotification = route(taskNotification);
+  check(satisfiedNotification.status === 0 &&
+    read(file).workflowId === satisfiedWorkflow.workflowId &&
+    read(file).state === 'satisfied',
+    'satisfied workflow followed by host notification keeps the same satisfied contract');
+  check(!satisfiedNotification.stdout.includes('Run full test suite') &&
+    satisfiedNotification.stdout.includes('routing unchanged'),
+    'satisfied host notification text is not routed as new work');
   check(route('Refactor the entire repository architecture in dependent stages.').status === 0 && read(file).workflowId !== initial.workflowId, 'next completed-task boundary creates a fresh workflow');
   check(stop({ stop_hook_active: true }).status === 0 && read(file).state === 'blocked', 'Stop retry reports blocked instead of faking completion');
   check(gate('Write', { file_path: path.join(linked, 'src.js') }).status === 2, 'blocked state still prohibits mutation');
@@ -194,11 +320,161 @@ try {
     promotedTier3.mutationIsolation?.required === true && !promotedTier3.pendingPlan, 'pending Tier 3 isolation becomes active atomically on start');
   check(workflowRuntime.isMajorWorkflow(promotedTier3), 'major-workflow classification flips only after explicit activation');
   check(gate('Write', { file_path: path.join(repo, 'premature-primary.js') }, repo).status === 2, 'activated Tier 3 plan still blocks primary-tree mutation');
+
+  // #163: a queued Tier-3 plan can intentionally remain single-agent when
+  // Fable is prohibited. Explicit start must still promote the whole plan,
+  // including isolation and budget metadata, before any mutation is admitted.
+  fs.unlinkSync(file);
+  check(route('Fix this checkout bug with a regression test').status === 0 && read(file).strategy === 'iterative-single',
+    '#163 fixture starts from a Tier 2 iterative workflow');
+  check(control('start').status === 0 && read(file).state === 'running',
+    '#163 fixture activates Tier 2 before a stronger route arrives');
+  check(route('Refactor the entire authentication architecture across all services and migrate the database schema without fable').status === 0,
+    '#163 stronger Tier 3 route without Fable is retained for explicit replan');
+  const queuedNonFableTier3 = read(file);
+  check(queuedNonFableTier3.state === 'blocked' &&
+    queuedNonFableTier3.pendingPlan?.tier === 'tier3' &&
+    queuedNonFableTier3.pendingPlan?.strategy === 'iterative-single' &&
+    queuedNonFableTier3.pendingPlan?.mutationIsolation?.required === true,
+    '#163 queued Tier 3 plan remains non-Fable but still requires isolation');
+  write(file, {
+    ...queuedNonFableTier3,
+    budget: {
+      ...queuedNonFableTier3.budget,
+      limits: { ...queuedNonFableTier3.budget.limits, maxIterations: 1 },
+    },
+  });
+  check(control('start').status === 0, '#163 explicit start activates queued non-Fable Tier 3 plan');
+  const promotedNonFableTier3 = read(file);
+  check(promotedNonFableTier3.workflowPlan?.tier === 'tier3' &&
+    promotedNonFableTier3.tier === 'tier3' &&
+    promotedNonFableTier3.strategy === 'iterative-single' &&
+    promotedNonFableTier3.mutationIsolation?.required === true &&
+    !promotedNonFableTier3.pendingPlan,
+    '#163 non-Fable Tier 3 plan replaces all authoritative active-plan fields');
+  check(promotedNonFableTier3.budget?.limits?.maxIterations === promotedNonFableTier3.workflowPlan?.limits?.maxIterations &&
+    promotedNonFableTier3.budget?.limits?.maxIterations !== 1,
+    '#163 plan activation re-derives budget limits from the promoted plan');
+  check(workflowRuntime.isMajorWorkflow(promotedNonFableTier3),
+    '#163 non-Fable Tier 3 promotion enables major-workflow isolation');
+  check(gate('Write', { file_path: path.join(repo, 'non-fable-primary.js') }, repo).status === 2,
+    '#163 promoted non-Fable Tier 3 blocks primary-tree mutation');
+  check(gate('Write', { file_path: path.join(linked, 'non-fable-linked.js') }, linked).status === 0,
+    '#163 promoted non-Fable Tier 3 admits linked-worktree mutation');
+
   fs.unlinkSync(file);
   check(route('Fix this checkout bug with a regression test').status === 0 && read(file).strategy === 'iterative-single', 'fresh bounded fix returns to Tier 2 iterative lifecycle');
+  let tier2 = read(file);
+  const tier2WorkflowId = tier2.workflowId;
+  write(file, { ...tier2, state: 'deferred' });
+  const deferredNotification = route(taskNotification);
+  check(deferredNotification.status === 0 &&
+    read(file).workflowId === tier2WorkflowId &&
+    read(file).state === 'deferred',
+    'deferred workflow followed by host notification keeps the same deferred contract');
+  check(!deferredNotification.stdout.includes('Run full test suite') &&
+    deferredNotification.stdout.includes('routing unchanged'),
+    'deferred host notification text is not routed as new work');
+  write(file, tier2);
+
   const iterationLimit = read(file).workflowPlan.limits.maxIterations;
   check(Number.isInteger(iterationLimit) && iterationLimit > 0, 'iterative route exposes a numeric iteration budget');
 
+  // #165: direct Edit/Write/apply_patch accounting follows workspace effects.
+  // Bookkeeping outside the repository must not consume Tier-2 iterations or
+  // advance workflow/Stop-gate mutation milestones.
+  const handoffFile = path.join(sessionDir, 'handoff-state.json');
+  const outsideTarget = path.join(temp, 'scratch-note.txt');
+  const beforeOutside = read(file);
+  const beforeOutsideIterations = beforeOutside.budget?.counters?.iterations || 0;
+  const beforeOutsideMutationAt = beforeOutside.lastMutationAt || 0;
+  const beforeOutsideEditAt = fs.existsSync(handoffFile) ? (read(handoffFile).lastEditAt || 0) : 0;
+  for (let i = 0; i < 3; i++) {
+    check(gate('Write', { file_path: outsideTarget }, repo).status === 0,
+      'out-of-workspace Write is admitted without Tier-2 mutation accounting');
+    fs.writeFileSync(outsideTarget, 'scratch ' + i + '\n');
+    const outsideResponse = i === 0
+      ? { stderr: 'warning: successful bookkeeping write emitted diagnostic text' }
+      : {};
+    check(persistDirect('Write', { file_path: outsideTarget }, repo, outsideResponse).status === 0,
+      'out-of-workspace Write post-tool state persists without mutation milestone');
+  }
+  const afterOutside = read(file);
+  const afterOutsideHandoff = read(handoffFile);
+  check((afterOutside.budget?.counters?.iterations || 0) === beforeOutsideIterations &&
+    (afterOutside.lastMutationAt || 0) === beforeOutsideMutationAt &&
+    (afterOutsideHandoff.lastEditAt || 0) === beforeOutsideEditAt &&
+    afterOutsideHandoff.status !== 'failed',
+    'out-of-workspace Writes leave iterations/milestones unchanged and PostToolUse stderr is not a failure');
+  check(stop().status === 0, 'out-of-workspace-only bookkeeping does not force verification before Stop');
+
+  check(route('Fix this checkout bug with a regression test').status === 0 && read(file).strategy === 'iterative-single',
+    'real follow-up user prompt after notification/accounting checks routes normally');
+  let observedDirectIterations = read(file).budget?.counters?.iterations || 0;
+  const internalTarget = path.join(repo, 'direct-inside.txt');
+  const beforeInternalMutationAt = read(file).lastMutationAt || 0;
+  check(gate('Write', { file_path: internalTarget }, repo).status === 0, 'in-workspace Write is admitted');
+  fs.writeFileSync(internalTarget, 'inside\n');
+  check(persistDirect('Write', { file_path: internalTarget }, repo).status === 0, 'in-workspace Write post-tool state persists');
+  check(read(file).budget.counters.iterations === ++observedDirectIterations &&
+    read(file).lastMutationAt >= beforeInternalMutationAt &&
+    read(handoffFile).lastEditAt > beforeOutsideEditAt,
+    'in-workspace Write consumes exactly one iteration and advances mutation milestones');
+
+  const mixedPatch = [
+    '*** Begin Patch',
+    `*** Update File: ${outsideTarget}`,
+    '@@',
+    '-scratch',
+    '+scratch updated',
+    `*** Update File: ${path.join(repo, 'README.md')}`,
+    '@@',
+    '-fixture',
+    '+fixture updated',
+    '*** End Patch',
+  ].join('\n');
+  check(gate('apply_patch', { patch: mixedPatch }, repo).status === 0, 'mixed apply_patch is admitted');
+  check(persistDirect('apply_patch', { patch: mixedPatch }, repo).status === 0, 'mixed apply_patch post-tool state persists');
+  check(read(file).budget.counters.iterations === ++observedDirectIterations,
+    'mixed apply_patch counts exactly once when any target is inside the workspace');
+
+  const pureOutsidePatch = [
+    '*** Begin Patch',
+    `*** Update File: ${outsideTarget}`,
+    '@@',
+    '-scratch updated',
+    '+scratch external only',
+    '*** End Patch',
+  ].join('\n');
+  const beforePureOutside = read(file);
+  const beforePureOutsideEditAt = read(handoffFile).lastEditAt || 0;
+  check(gate('apply_patch', { patch: pureOutsidePatch }, repo).status === 0, 'pure external apply_patch is admitted');
+  check(persistDirect('apply_patch', { patch: pureOutsidePatch }, repo).status === 0, 'pure external apply_patch post-tool state persists');
+  check(read(file).budget.counters.iterations === observedDirectIterations &&
+    read(file).lastMutationAt === beforePureOutside.lastMutationAt &&
+    (read(handoffFile).lastEditAt || 0) === beforePureOutsideEditAt,
+    'pure external apply_patch consumes no iteration and advances no mutation milestone');
+
+  const linkedTarget = path.join(linked, 'direct-linked.txt');
+  check(gate('Write', { file_path: linkedTarget }, linked).status === 0,
+    'Write inside a linked worktree is treated as workspace mutation');
+  fs.writeFileSync(linkedTarget, 'linked\n');
+  check(persistDirect('Write', { file_path: linkedTarget }, linked).status === 0,
+    'linked-worktree Write post-tool state persists');
+  check(read(file).budget.counters.iterations === ++observedDirectIterations,
+    'linked-worktree Write consumes exactly one iteration');
+
+  // Keep the #165 regression fixture from consuming the budget used by the
+  // pre-existing lifecycle/exhaustion assertions below.
+  fs.unlinkSync(internalTarget);
+  fs.unlinkSync(linkedTarget);
+  fs.unlinkSync(file);
+  if (fs.existsSync(handoffFile)) fs.unlinkSync(handoffFile);
+  check(route('Fix this checkout bug with a regression test').status === 0 &&
+    read(file).strategy === 'iterative-single' &&
+    (read(file).budget?.counters?.iterations || 0) === 0,
+    '#165 regression fixture resets into a fresh Tier-2 lifecycle baseline');
+
   // #155/#157 regression lock: read-only shell composition, including quoted
   // and escaped separator characters inside arguments, must never look like an
   // iterative mutation or advance the mutation clock.

package/ci/mechanism-2c-state-persist.test.js

@@ -16,14 +16,57 @@ helper.check(
 
 helper.runHook('state-persist.js', {
   session_id: helper.SESSION_ID,
+  hook_event_name: 'PostToolUse',
   tool_name: 'Bash',
-  tool_response: { stdout: 'ok', exitCode: 0 },
+  tool_response: {
+    stdout: 'ok',
+    stderr: 'warning: successful command emitted diagnostic text',
+  },
 });
 const resolvedHandoff = helper.readState('handoff-state.json');
 helper.check(
-  '2c. A subsequent successful command clears status back to idle',
+  '2c. Claude-shaped PostToolUse without exitCode clears failed state even with stderr diagnostics',
   resolvedHandoff.status === 'idle' && !!resolvedHandoff.lastResolved,
   `Got ${JSON.stringify(resolvedHandoff)}`
 );
 
+helper.runHook('state-persist.js', {
+  session_id: helper.SESSION_ID,
+  hook_event_name: 'PostToolUse',
+  tool_name: 'Bash',
+  tool_response: { stdout: '', stderr: 'numeric failure', exitCode: 2 },
+});
+const numericFailure = helper.readState('handoff-state.json');
+helper.check(
+  '2c. Numeric non-zero exit still records failure on hosts that report exit codes',
+  numericFailure.status === 'failed' && numericFailure.exitCode === 2,
+  `Got ${JSON.stringify(numericFailure)}`
+);
+
+helper.runHook('state-persist.js', {
+  session_id: helper.SESSION_ID,
+  hook_event_name: 'PostToolUse',
+  tool_name: 'Bash',
+  tool_response: { stdout: 'ok', exitCode: 0 },
+});
+const numericResolved = helper.readState('handoff-state.json');
+helper.check(
+  '2c. Numeric zero exit still clears failure state',
+  numericResolved.status === 'idle' && !!numericResolved.lastResolved,
+  `Got ${JSON.stringify(numericResolved)}`
+);
+
+helper.runHook('state-persist.js', {
+  session_id: helper.SESSION_ID,
+  hook_event_name: 'PostToolUseFailure',
+  tool_name: 'Bash',
+  error: 'host-declared failure without numeric exit code',
+});
+const eventFailure = helper.readState('handoff-state.json');
+helper.check(
+  '2c. PostToolUseFailure remains authoritative without numeric exitCode',
+  eventFailure.status === 'failed',
+  `Got ${JSON.stringify(eventFailure)}`
+);
+
 helper.finish();

package/ci/mechanism-2t-issue-20.test.js

@@ -64,12 +64,4 @@ helper.check(
   `exit ${negativeControls.status}\n${negativeControls.stdout}\n${negativeControls.stderr}`
 );
 
-const rollup = fs.readFileSync(path.join(helper.root, 'docs', 'issue-20-rollup.md'), 'utf8');
-const deferredWork = ['baseline-debugging', 'baseline-performance', 'baseline-security-review', 'baseline-simple-bugfix', 'verify-before-done', 'verification-loop', 'zoom-out', 'security-review'];
-helper.check(
-  '2t. issue rollup records unresolved acceptance work accurately',
-  /Issue #20 remains open/.test(rollup) && deferredWork.every(term => rollup.includes(term)),
-  'rollup must name the open issue and each deferred baseline/skill item'
-);
-
 helper.finish();

package/ci/mechanism-30-opencode-plugin-loadability.test.js

@@ -40,13 +40,29 @@ function verifyInstall(text) {
   }
 }
 
+function isWorktreeRoot(dir) {
+  try {
+    return fs.existsSync(path.join(dir, '.git'));
+  } catch (_) {
+    return false;
+  }
+}
+
 function walk(directory) {
   return fs.readdirSync(directory, { withFileTypes: true }).flatMap(entry => {
-    if (['node_modules', '.git'].includes(entry.name) || entry.isSymbolicLink()) return [];
+    if (['node_modules', '.git', '.worktrees'].includes(entry.name) || entry.isSymbolicLink()) return [];
     const file = path.join(directory, entry.name);
     const relative = path.relative(root, file).split(path.sep).join('/');
     if (relative === 'benchmarks/results' || relative === 'CHANGELOG.md') return [];
-    return entry.isDirectory() ? walk(file) : [file];
+    if (relative === '.worktrees' || relative.startsWith('.worktrees/')) return [];
+    if (entry.isDirectory()) {
+      // Skip linked worktrees / nested checkouts: a `.git` file marks a
+      // linked worktree root, a `.git` dir marks a nested repo. Either way
+      // the content belongs to another checkout, not this one (#170).
+      if (isWorktreeRoot(file)) return [];
+      return walk(file);
+    }
+    return [file];
   });
 }
 
@@ -68,12 +84,28 @@ try {
   }
   assert.deepStrictEqual(invalidTargets('opencode-plugin/index.mjs .opencode/plugins/example.js'), []);
 
-  const violations = [];
-  for (const file of walk(root).filter(file => /\.(?:md|js|mjs|json|jsonc|yml|yaml|txt)$/.test(file))) {
+  const scanViolations = (readText = file => fs.readFileSync(file, 'utf8')) => {
+    const violations = [];
+    for (const file of walk(root).filter(file => /\.(?:md|js|mjs|json|jsonc|yml|yaml|txt)$/.test(file))) {
+      const text = readText(file);
+      for (const target of invalidTargets(text)) violations.push(`${path.relative(root, file)}: ${target}`);
+    }
+    return violations;
+  };
+  assert.deepStrictEqual(scanViolations(), [], 'Unsupported OpenCode install destinations; only .js/.ts are auto-discovered');
+
+  const scannedFiles = walk(root);
+  assert.ok(scannedFiles.includes(readmeFile), 'Tracked OpenCode README must remain in the repository scan');
+  const plantedTarget = '.opencode/plugins/' + 'negative-control.mjs';
+  const planted = scanViolations(file => {
     const text = fs.readFileSync(file, 'utf8');
-    for (const target of invalidTargets(text)) violations.push(`${path.relative(root, file)}: ${target}`);
-  }
-  assert.deepStrictEqual(violations, [], 'Unsupported OpenCode install destinations; only .js/.ts are auto-discovered');
+    return file === readmeFile ? text + '\n' + plantedTarget + '\n' : text;
+  });
+  assert.ok(
+    planted.some(item => item === `${path.relative(root, readmeFile)}: ${plantedTarget}`),
+    'Scanner negative control must fail when a tracked file contains an unsupported .mjs install target'
+  );
+
   const readme = fs.readFileSync(readmeFile, 'utf8');
   for (const destination of ['.opencode/plugins/harness-enforcement.js', '~/.config/opencode/plugins/harness-enforcement.js']) {
     assert.ok(readme.includes(`cp opencode-plugin/index.mjs ${destination}`));