harness-everything 0.15.0 → 0.16.1

package/hooks/scripts/lib/workflow-runtime.js

@@ -4,11 +4,10 @@ const fs = require('fs');
 const path = require('path');
 const { getWorkspaceRoot, getSessionDir, getSessionId, getStateRoot } = require('./harness-state');
 const { atomicWriteJson, readJson } = require('./fable-contracts');
-const { workspaceFingerprint } = require('./workflow-isolation');
 
 const OPEN_STATES = new Set(['pending', 'active', 'running', 'failed', 'blocked', 'escaped']);
 const SAFE_ID = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
-const WORKFLOW_CONTROLLER_COMMANDS = new Set(['start', 'revision', 'reset-budget', 'escape', 'block']);
+const WORKFLOW_CONTROLLER_COMMANDS = new Set(['start', 'revision', 'escape', 'block']);
 
 function activeWorkflowPlan(workflow) {
   if (!workflow) return null;
@@ -44,412 +43,35 @@ function loadWorkflow(payload) {
 
 function saveWorkflow(context) { atomicWriteJson(context.file, context.workflow); }
 
-const MUTATION_PROBE_KEY = /^[a-f0-9]{64}$/;
-const MUTATION_PROBE_WAIT = new Int32Array(new SharedArrayBuffer(4));
-const MUTATION_PROBE_DEFAULT_TIMEOUT_MS = 120000;
-const MUTATION_PROBE_RECLAIM_GRACE_MS = 5000;
-const MUTATION_PROBE_MAX_TIMEOUT_MS = 30 * 60 * 1000;
-
-function mutationProbeLeaseMs(timeoutMs) {
-  const parsed = Number(timeoutMs);
-  const executionMs = Number.isFinite(parsed) && parsed > 0
-    ? Math.min(parsed, MUTATION_PROBE_MAX_TIMEOUT_MS)
-    : MUTATION_PROBE_DEFAULT_TIMEOUT_MS;
-  return executionMs + MUTATION_PROBE_RECLAIM_GRACE_MS;
-}
-
-function mutationProbeExpired(probe, now = Date.now()) {
-  const reclaimAfterAt = Number(probe?.reclaimAfterAt);
-  if (Number.isFinite(reclaimAfterAt)) return now >= reclaimAfterAt;
-  const observedAt = Number(probe?.observedAt);
-  return Number.isFinite(observedAt) &&
-    now - observedAt >= mutationProbeLeaseMs(null);
-}
-
-function mutationProbeDir(context) {
-  return path.join(context.sessionDir, 'mutation-probes');
-}
-
-function mutationProbeFile(context, key) {
-  if (!MUTATION_PROBE_KEY.test(String(key || ''))) throw new Error('invalid mutation probe identity');
-  return path.join(mutationProbeDir(context), key + '.json');
-}
-
-function withMutationProbeLock(context, callback) {
-  fs.mkdirSync(context.sessionDir, { recursive: true });
-  const lockDir = path.join(context.sessionDir, '.mutation-probes.lock');
-  let acquired = false;
-  for (let attempt = 0; attempt < 200; attempt++) {
-    try {
-      fs.mkdirSync(lockDir);
-      acquired = true;
-      break;
-    } catch (error) {
-      if (error.code !== 'EEXIST') throw error;
-      try {
-        const stat = fs.statSync(lockDir);
-        if (Date.now() - stat.mtimeMs > 30000) {
-          fs.rmSync(lockDir, { recursive: true, force: true });
-          continue;
-        }
-      } catch (_) { /* retry below */ }
-      Atomics.wait(MUTATION_PROBE_WAIT, 0, 0, 10);
-    }
-  }
-  if (!acquired) throw new Error('cannot acquire mutation probe lock');
-  try { return callback(); }
-  finally { fs.rmSync(lockDir, { recursive: true, force: true }); }
-}
-
-function probeCountsIteration(probe) {
-  return Boolean(probe && (probe.countIteration === true ||
-    (probe.countIteration === undefined && probe.reserveIteration === true)));
-}
-
-function mutationProbeReservations(context) {
-  const dir = mutationProbeDir(context);
-  let files = [];
-  try { files = fs.readdirSync(dir).filter(file => /^[a-f0-9]{64}\.json$/.test(file)); }
-  catch (_) { return 0; }
-  const now = Date.now();
-  let count = 0;
-  for (const file of files) {
-    const probe = readJson(path.join(dir, file));
-    if (probe?.schemaVersion !== 1 || probe.reserveIteration !== true) continue;
-    // A reservation remains active for the host/tool execution timeout plus
-    // a grace period. This prevents a genuinely in-flight command from being
-    // reclaimed merely because it ran longer than an arbitrary short delay.
-    if (!mutationProbeExpired(probe, now)) count++;
-  }
-  return count;
-}
-
-function refreshWorkflowForProbe(context) {
-  const latest = readJson(context.file);
-  if (!latest || latest.sessionId !== context.sessionId) throw new Error('cannot refresh workflow for mutation probe');
-  context.workflow = latest;
-  return latest;
-}
-
-function assertIterationCapacity(context, evidence) {
-  const { workflow } = context;
-  if (!workflow) throw budgetError('no workflow available for iteration capacity');
-  const budget = ensureWorkflowBudget(workflow);
-  if (budget.state !== 'active') throw budgetError(`workflow budget is ${budget.state}: ${budget.reasonCode || 'unavailable'}`);
-  const limit = budget.limits.maxIterations;
-  if (limit === null) return { applicable: false, value: budget.counters.iterations, reserved: 0 };
-  const reserved = mutationProbeReservations(context);
-  if (budget.counters.iterations + reserved >= limit) {
-    return exhaustBudget(context, 'iteration-budget-exhausted', evidence || 'untrusted-shell-capacity');
-  }
-  return { applicable: true, value: budget.counters.iterations, reserved, limit };
-}
-
-function reclaimStaleMutationProbes(context, keepKey) {
-  const dir = mutationProbeDir(context);
-  let files = [];
-  try { files = fs.readdirSync(dir).filter(file => /^[a-f0-9]{64}\.json$/.test(file)); }
-  catch (_) { return; }
-  const now = Date.now();
-  for (const name of files) {
-    const staleKey = name.slice(0, -'.json'.length);
-    if (staleKey === keepKey) continue;
-    const file = path.join(dir, name);
-    const probe = readJson(file);
-    if (!probe || probe.schemaVersion !== 1) continue;
-    if (!mutationProbeExpired(probe, now)) continue;
-    const countsIteration = probeCountsIteration(probe);
-    if (!probe.observationCwd) {
-      // Legacy probes predate stored observation roots and cannot be safely
-      // re-observed. Once outside the in-flight grace window they must not
-      // reserve capacity forever.
-      fs.unlinkSync(file);
-      continue;
-    }
-    let currentFingerprint;
-    try {
-      currentFingerprint = workspaceFingerprint(probe.observationCwd);
-    } catch (_) {
-      fs.unlinkSync(file);
-      context.workflow.lastMutationAt = now;
-      if (countsIteration && context.workflow.strategy === 'iterative-single') {
-        recordBudgetEvent(context, 'iteration', { evidence: 'shell:reclaimed-unobservable-workspace' });
-      } else {
-        saveWorkflow(context);
-      }
-      continue;
-    }
-    if (currentFingerprint !== probe.fingerprint) {
-      fs.unlinkSync(file);
-      context.workflow.lastMutationAt = now;
-      if (countsIteration && context.workflow.strategy === 'iterative-single') {
-        recordBudgetEvent(context, 'iteration', { evidence: 'shell:reclaimed-stale-workspace-mutation' });
-      } else {
-        saveWorkflow(context);
-      }
-      continue;
-    }
-    // No visible workspace effect after the grace window: this probe was
-    // orphaned by a denial/block/missing Post event. Discard it so it cannot
-    // reserve capacity or later attribute an unrelated mutation (#161).
-    fs.unlinkSync(file);
-  }
-}
-
-function registerMutationProbe(context, key, fingerprint, reserveIteration, observationCwd, options = {}) {
-  if (!MUTATION_PROBE_KEY.test(String(key || '')) || !MUTATION_PROBE_KEY.test(String(fingerprint || ''))) {
-    throw new Error('invalid mutation probe identity');
-  }
-  return withMutationProbeLock(context, () => {
-    refreshWorkflowForProbe(context);
-    reclaimStaleMutationProbes(context, key);
-    let activeReservation = Boolean(reserveIteration);
-    let atLimitAllowance = false;
-    if (activeReservation) {
-      const budget = ensureWorkflowBudget(context.workflow);
-      const limit = budget.limits.maxIterations;
-      const reserved = mutationProbeReservations(context);
-      if (options.allowAtLimit === true && budget.state === 'active' && limit !== null &&
-          budget.counters.iterations === limit && reserved === 0) {
-        // Verification-shaped commands get observation-only admission at the
-        // exact mutation limit. If they mutate, settlement still records the
-        // mutation and exhausts the budget after execution (#164).
-        activeReservation = false;
-        atLimitAllowance = true;
-      } else {
-        assertIterationCapacity(context, 'shell:untrusted');
-      }
-    }
-    const dir = mutationProbeDir(context);
-    fs.mkdirSync(dir, { recursive: true });
-    const file = mutationProbeFile(context, key);
-    if (fs.existsSync(file)) throw new Error('mutation probe is already pending for this tool call');
-    const observedAt = Date.now();
-    const probe = {
-      schemaVersion: 1,
-      fingerprint,
-      reserveIteration: activeReservation,
-      countIteration: options.countIteration === undefined ? Boolean(reserveIteration) : Boolean(options.countIteration),
-      atLimitAllowance,
-      observationCwd: observationCwd ? path.resolve(observationCwd) : null,
-      observedAt,
-      reclaimAfterAt: observedAt + mutationProbeLeaseMs(options.timeoutMs),
-    };
-    atomicWriteJson(file, probe);
-    return probe;
-  });
-}
-
-function peekMutationProbe(context, key) {
-  return readJson(mutationProbeFile(context, key));
-}
-
-function settleMutationProbe(context, key, afterFingerprint, tool) {
-  if (!MUTATION_PROBE_KEY.test(String(afterFingerprint || ''))) throw new Error('invalid mutation probe fingerprint');
-  return withMutationProbeLock(context, () => {
-    const file = mutationProbeFile(context, key);
-    const probe = readJson(file);
-    if (!probe || probe.schemaVersion !== 1) return null;
-    refreshWorkflowForProbe(context);
-    fs.unlinkSync(file);
-    const changed = afterFingerprint !== probe.fingerprint;
-    if (changed) {
-      context.workflow.lastMutationAt = Date.now();
-      if (probeCountsIteration(probe) && context.workflow.strategy === 'iterative-single') {
-        recordBudgetEvent(context, 'iteration', { evidence: String(tool || 'shell') + ':observed-workspace-mutation' });
-      } else {
-        saveWorkflow(context);
-      }
-    }
-    return { changed, probe };
-  });
-}
-
-function settleMutationProbeConservative(context, key, tool, evidence = 'unobservable-workspace') {
-  return withMutationProbeLock(context, () => {
-    const file = mutationProbeFile(context, key);
-    const probe = readJson(file);
-    if (!probe || probe.schemaVersion !== 1) return null;
-    refreshWorkflowForProbe(context);
-    fs.unlinkSync(file);
-    context.workflow.lastMutationAt = Date.now();
-    if (probeCountsIteration(probe) && context.workflow.strategy === 'iterative-single') {
-      recordBudgetEvent(context, 'iteration', { evidence: String(tool || 'shell') + ':' + evidence });
-    } else {
-      saveWorkflow(context);
-    }
-    return { changed: true, probe, conservative: true };
-  });
-}
-
-function discardMutationProbe(context, key) {
-  return withMutationProbeLock(context, () => {
-    const file = mutationProbeFile(context, key);
-    if (!fs.existsSync(file)) return false;
-    fs.unlinkSync(file);
-    return true;
-  });
-}
-
-function clearMutationProbes(context) {
-  return withMutationProbeLock(context, () => {
-    fs.rmSync(mutationProbeDir(context), { recursive: true, force: true });
-  });
-}
-
+// Numeric workflow limits are planning hints only. Exact runtime budget/probe
+// enforcement was retired in #190 because it introduced locks, shared-state
+// races, parser exceptions, and recovery states disproportionate to its value.
 function budgetLimits(workflow) {
   const limits = workflow?.workflowPlan?.limits || {};
   return {
-    maxIterations: Number.isInteger(limits.maxIterations) && limits.maxIterations > 0 ? limits.maxIterations : null,
-    maxRevisionRounds: Number.isInteger(limits.maxRevisionRounds) && limits.maxRevisionRounds >= 0 ? limits.maxRevisionRounds : 0,
-    maxReplans: Number.isInteger(limits.maxReplans) && limits.maxReplans >= 0 ? limits.maxReplans : 0,
-    maxWorkers: Number.isInteger(limits.maxWorkers) && limits.maxWorkers > 0 ? limits.maxWorkers : 1,
+    maxIterations: Number.isInteger(limits.maxIterations) ? limits.maxIterations : null,
+    maxRevisionRounds: Number.isInteger(limits.maxRevisionRounds) ? limits.maxRevisionRounds : null,
+    maxReplans: Number.isInteger(limits.maxReplans) ? limits.maxReplans : null,
+    maxWorkers: Number.isInteger(limits.maxWorkers) ? limits.maxWorkers : null,
   };
 }
-
-function ensureWorkflowBudget(workflow) {
-  if (workflow.budget && workflow.budget.schemaVersion === 1) return workflow.budget;
-  const now = new Date().toISOString();
-  workflow.budget = {
-    schemaVersion: 1,
-    epoch: 0,
-    state: 'active',
-    limits: budgetLimits(workflow),
-    counters: { iterations: 0, revisionRounds: 0, replans: 0 },
-    activeWorkers: {},
-    reasonCode: null,
-    exhaustedAt: null,
-    resets: [],
-    events: [],
-    createdAt: now,
-    updatedAt: now,
-  };
-  return workflow.budget;
-}
-
-function syncBudgetToRun(context) {
-  const match = matchingRun(context);
-  if (!match || !context.workflow?.budget) return;
-  const updated = {
-    ...match.run,
-    budget: JSON.parse(JSON.stringify(context.workflow.budget)),
-  };
-  atomicWriteJson(path.join(match.runRoot, 'run.json'), updated);
-}
-
-function persistBudget(context) {
-  saveWorkflow(context);
-  syncBudgetToRun(context);
-}
-
-function budgetError(message) {
-  const error = new Error(message);
-  error.code = 'HARNESS_WORKFLOW_BUDGET';
-  return error;
-}
-
-function appendBudgetEvent(budget, event) {
-  budget.events = [...(budget.events || []), event].slice(-64);
-  budget.updatedAt = event.observedAt;
-}
-
-function exhaustBudget(context, reasonCode, evidence) {
-  const budget = ensureWorkflowBudget(context.workflow);
-  const now = new Date().toISOString();
-  budget.state = 'budget-exhausted';
-  budget.reasonCode = reasonCode;
-  budget.exhaustedAt = now;
-  appendBudgetEvent(budget, { type: 'budget-exhausted', reasonCode, evidence: evidence || null, observedAt: now });
-  context.workflow.state = 'blocked';
-  context.workflow.blockReason = reasonCode;
-  persistBudget(context);
-  throw budgetError(`budget-exhausted: ${reasonCode}`);
-}
-
+function ensureWorkflowBudget(workflow) { return { schemaVersion: 2, state: 'advisory', limits: budgetLimits(workflow) }; }
+// Compatibility stubs: no files, reservations, counters, locks, or blocks.
+function mutationProbeReservations() { return 0; }
+function assertIterationCapacity() { return { applicable: false, advisory: true, reserved: 0 }; }
+function registerMutationProbe() { return null; }
+function peekMutationProbe() { return null; }
+function settleMutationProbe() { return null; }
+function settleMutationProbeConservative() { return null; }
+function discardMutationProbe() { return false; }
+function clearMutationProbes() { return false; }
 function recordBudgetEvent(context, type, options = {}) {
-  const { workflow } = context;
-  if (!workflow) throw budgetError('no workflow available for budget accounting');
-  const budget = ensureWorkflowBudget(workflow);
-  if (budget.state !== 'active') throw budgetError(`workflow budget is ${budget.state}: ${budget.reasonCode || 'unavailable'}`);
-  const now = new Date().toISOString();
-  const evidence = options.evidence || null;
-
-  const consume = (counter, limitName, reasonCode) => {
-    const limit = budget.limits[limitName];
-    if (limit === null) return { applicable: false, value: budget.counters[counter] };
-    const reserved = type === 'iteration' ? mutationProbeReservations(context) : 0;
-    if (budget.counters[counter] + reserved >= limit) return exhaustBudget(context, reasonCode, evidence);
-    budget.counters[counter]++;
-    appendBudgetEvent(budget, { type, counter, value: budget.counters[counter], limit, evidence, observedAt: now });
-    persistBudget(context);
-    return { applicable: true, value: budget.counters[counter], limit };
-  };
-
-  if (type === 'iteration') return consume('iterations', 'maxIterations', 'iteration-budget-exhausted');
-  if (type === 'revision') return consume('revisionRounds', 'maxRevisionRounds', 'revision-budget-exhausted');
-  if (type === 'replan') return consume('replans', 'maxReplans', 'replan-budget-exhausted');
-
-  if (type === 'worker-acquire') {
-    const workerId = String(options.workerId || '').trim();
-    if (!SAFE_ID.test(workerId)) throw budgetError('worker-acquire requires a stable safe worker id');
-    if (budget.activeWorkers[workerId]) return { active: Object.keys(budget.activeWorkers).length, idempotent: true };
-    const active = Object.keys(budget.activeWorkers).length;
-    if (active >= budget.limits.maxWorkers) return exhaustBudget(context, 'worker-budget-exhausted', evidence || workerId);
-    budget.activeWorkers[workerId] = { acquiredAt: now, evidence };
-    appendBudgetEvent(budget, { type, workerId, active: active + 1, limit: budget.limits.maxWorkers, evidence, observedAt: now });
-    persistBudget(context);
-    return { active: active + 1, limit: budget.limits.maxWorkers };
-  }
-
-  if (type === 'worker-release') {
-    const workerId = String(options.workerId || '').trim();
-    if (!SAFE_ID.test(workerId)) throw budgetError('worker-release requires a stable safe worker id');
-    const existed = Boolean(budget.activeWorkers[workerId]);
-    delete budget.activeWorkers[workerId];
-    appendBudgetEvent(budget, { type, workerId, existed, active: Object.keys(budget.activeWorkers).length, evidence, observedAt: now });
-    persistBudget(context);
-    return { active: Object.keys(budget.activeWorkers).length, existed };
-  }
-
-  throw budgetError(`unknown workflow budget event: ${type}`);
+  return { advisory: true, type, limits: budgetLimits(context && context.workflow), evidence: options.evidence || null };
 }
-
 function resetWorkflowBudget(context, evidence) {
-  const { workflow } = context;
-  if (!workflow) throw budgetError('no workflow available for budget reset');
-  const previous = ensureWorkflowBudget(workflow);
-  if (previous.state !== 'budget-exhausted' || workflow.state !== 'blocked') {
-    throw budgetError('budget reset is allowed only after explicit budget exhaustion');
-  }
-  if (!String(evidence || '').trim()) throw budgetError('budget reset requires audit evidence');
-  const now = new Date().toISOString();
-  const resets = [...(previous.resets || []), {
-    epoch: previous.epoch,
-    reasonCode: previous.reasonCode,
-    counters: previous.counters,
-    evidence: String(evidence).trim(),
-    resetAt: now,
-  }].slice(-16);
-  clearMutationProbes(context);
-  workflow.budget = {
-    schemaVersion: 1,
-    epoch: previous.epoch + 1,
-    state: 'active',
-    limits: budgetLimits(workflow),
-    counters: { iterations: 0, revisionRounds: 0, replans: 0 },
-    activeWorkers: {},
-    reasonCode: null,
-    exhaustedAt: null,
-    resets,
-    events: [{ type: 'budget-reset', evidence: String(evidence).trim(), observedAt: now }],
-    createdAt: previous.createdAt || now,
-    updatedAt: now,
-  };
-  workflow.state = 'pending';
-  delete workflow.blockReason;
-  persistBudget(context);
-  return workflow.budget;
+  return { retired: true, state: 'advisory', limits: budgetLimits(context && context.workflow), evidence: evidence || null };
 }
+function syncBudgetToRun() { return false; }
 
 function matchingRun(context) {
   const { workflow, root, sessionId } = context;
@@ -463,7 +85,7 @@ function matchingRun(context) {
   return { runRoot, run };
 }
 
-function unresolvedStages(match, workflow) {
+function unresolvedStages(match, workflow, lastEditAt = 0) {
   const unresolved = [];
   const stages = [];
   for (const stageId of match.run.stageIds) {
@@ -491,7 +113,7 @@ function unresolvedStages(match, workflow) {
     const workers = stages.filter(stage => stage.agent !== 'fable-verifier').map(stage => stage.workerId).filter(Boolean);
     const latestCheck = Math.max(0, ...stages.filter(stage => stage.agent !== 'fable-verifier').map(stage => Date.parse(stage.verifiedAt) || 0));
     if (!verifiers.some(stage => stage.workerId && !workers.includes(stage.workerId) && stage.status === 'pass' &&
-        Date.parse(stage.verifiedAt) >= Math.max(workflow.lastMutationAt || 0, latestCheck) &&
+        Date.parse(stage.verifiedAt) >= Math.max(workflow.lastMutationAt || 0, lastEditAt || 0, latestCheck) &&
         match.run.stageIds.filter(id => id !== stage.stageId).every(id => stage.dependsOn?.includes(id)))) {
       unresolved.push('independent-verifier-missing');
     }
@@ -507,7 +129,7 @@ function readHookInput(decide) {
     finished = true;
     clearTimeout(timeout);
     try { decide(input.trim() ? JSON.parse(input) : null); }
-    catch (error) { console.error(`[Workflow Gate] ${error.message}`); process.exitCode = 2; }
+    catch (error) { console.error(`[Workflow Reminder] Ignoring malformed workflow hook input: ${error.message}`); }
   };
   const timeout = setTimeout(finish, 500);
   process.stdin.setEncoding('utf8');

package/hooks/scripts/rule-of-3-tracker.js

@@ -24,6 +24,11 @@ process.stdin.on('end', () => {
     const failureText = typeof payload.error === 'string' ? payload.error : '';
     const rawExitCode = toolResponse.exitCode ?? toolResponse.exit_code ?? payload.exitCode ?? payload.exit_code;
     const exitCode = typeof rawExitCode === 'number' ? rawExitCode : undefined;
+    const toolName = payload.tool_name || payload.tool || 'command';
+    const toolInput = payload.tool_input || {};
+    const filePath = toolInput.file_path || toolInput.filePath || '';
+    const command = toolInput.command || '';
+    const operationHash = crypto.createHash('md5').update(`${toolName}:${filePath}:${command}`).digest('hex');
 
     const explicitFailure = exitCode !== undefined && exitCode !== 0;
     const stderrSignal = typeof stderr === 'string' && stderr.trim().length > 0;
@@ -37,7 +42,7 @@ process.stdin.on('end', () => {
     const root = getWorkspaceRoot(payload);
     const stateFile = path.join(getSessionDir(root, payload.session_id || payload.sessionId), 'rule-of-3-state.json');
 
-    let state = { count: 0, lastHash: null, zoomOutResolved: false, zoomOutCycles: 0, lastFailureAt: 0 };
+    let state = { count: 0, lastHash: null, lastOperationHash: null, zoomOutResolved: false, zoomOutCycles: 0, lastFailureAt: 0 };
     if (fs.existsSync(stateFile)) {
       state = JSON.parse(fs.readFileSync(stateFile, 'utf8'));
     }
@@ -45,9 +50,6 @@ process.stdin.on('end', () => {
     if (isFailure && errorText) {
       // Enhanced failure signature detection with context-aware categorization
       // Hash includes: error message, file path, command attempted, and failure category
-      const filePath = payload.tool_input?.file_path || payload.tool_input?.filePath || '';
-      const command = payload.tool_input?.command || '';
-
       // Categorize failure type for context-aware thresholds.
       // NOTE (#167): match anchored diagnostic phrases, not bare substrings.
       // A bare `denied`/`timeout` substring matches file names such as
@@ -79,22 +81,7 @@ process.stdin.on('end', () => {
       const contextString = `${category}:${filePath}:${command}:${normalized.slice(-200)}`;
       const hash = crypto.createHash('md5').update(contextString).digest('hex');
 
-      // Context-aware thresholds: different failure types have different breaking points
-      let threshold = 3; // Default: 3 strikes
-      if (category === 'syntax') {
-        threshold = 3; // Same syntax error 3 times = stop
-      } else if (category === 'environment') {
-        threshold = 4; // Environment issues may need more exploration
-      } else if (category === 'test') {
-        threshold = 3; // Same test failure 3 times = stop
-      } else if (category === 'timeout') {
-        threshold = 2; // Timeouts are expensive, fail faster
-      } else if (category === 'permission') {
-        threshold = 2; // Permission issues rarely resolve by retrying
-      } else if (category === 'dependency') {
-        threshold = 4; // Dependency issues may need different approaches
-      }
-
+      // One deliberately simple policy: three repeats of the same signature trigger zoom-out.
       if (state.lastHash === hash) {
         state.count += 1;
         state.category = category; // Track failure category for smarter decisions
@@ -105,9 +92,7 @@ process.stdin.on('end', () => {
         // New signature = new problem: the zoom-out cycle budget starts over.
         state.zoomOutCycles = 0;
       }
-
-      // Store threshold for this failure type
-      state.threshold = threshold;
+      state.lastOperationHash = operationHash;
 
       // Any fresh failure re-arms the breaker. Without this, a signature that
       // failed again after a success (or after a zoom-out release) would keep
@@ -119,12 +104,12 @@ process.stdin.on('end', () => {
 
       fs.writeFileSync(stateFile, JSON.stringify(state, null, 2), 'utf8');
     } else if (!isFailure) {
-      // NOTE (#166, follows #153): Claude Code PostToolUse success payloads
-      // carry no numeric exit code. The lifecycle event is authoritative:
-      // PostToolUse is success unless a numeric non-zero status contradicts it;
-      // hosts without lifecycle event names keep the conservative stderr fallback.
-      // A successful action after an accepted zoom-out is an objective recovery
-      // boundary. Emit only IDs/hashes/category; never copy command/output text.
+      let stateChanged = false;
+
+      // The first confirmed success after an accepted zoom-out is useful
+      // learning evidence even when it is not the same command that failed.
+      // Consume only the recovery-cycle marker here; do not erase the
+      // repeated-failure signature or count for an unrelated operation.
       if ((state.zoomOutCycles || 0) > 0 && state.lastHash) {
         const toolEventId = payload.tool_use_id || payload.toolUseId || `success-${Date.now()}`;
         try {
@@ -144,12 +129,24 @@ process.stdin.on('end', () => {
         } catch (_) {
           // Learning capture is additive and must never break recovery tracking.
         }
+        state.zoomOutCycles = 0;
+        stateChanged = true;
       }
-      // Only reset on a *confirmed* zero exit code, not merely "not a failure".
-      if (state.count > 0 || state.zoomOutCycles > 0) {
+
+      // Only a success for the same operation resolves its tracked signature.
+      if (state.lastOperationHash && state.lastOperationHash === operationHash &&
+          (state.count > 0 || state.lastHash)) {
         state.count = 0;
+        state.lastHash = null;
+        state.lastOperationHash = null;
         state.zoomOutResolved = true;
         state.zoomOutCycles = 0;
+        state.lastFailureAt = 0;
+        delete state.category;
+        stateChanged = true;
+      }
+
+      if (stateChanged) {
         fs.writeFileSync(stateFile, JSON.stringify(state, null, 2), 'utf8');
       }
     }

package/hooks/scripts/rule-of-3.js

@@ -6,9 +6,8 @@
 // breaker locks mutating tools and demands a zoom-out fact-check first
 // (read-only tools stay available). A valid reflection report - written to
 // the session's zoom-out-report.md (path given in the block message below) -
-// releases the breaker again. Only a SECOND trip on the same failure
-// signature - proof that reflection alone couldn't crack it - hard-locks the
-// session until the Human Partner decides.
+// releases the breaker again. A later set of three matching failures triggers
+// another zoom-out; there is no persistent second-stage hard lock.
 //
 // State is scoped per Claude Code session_id (see lib/harness-state.js) so
 // two sessions open on the same repo never share a trip count. The common
@@ -33,11 +32,7 @@ function readState(stateFile) {
 }
 
 function isTripped(state) {
-  if (!state || state.zoomOutResolved) return false;
-
-  // Use context-aware thresholds if available, otherwise default to 3
-  const threshold = state.threshold || 3;
-  return state.count >= threshold;
+  return Boolean(state && !state.zoomOutResolved && state.count >= 3);
 }
 
 function anySessionTripped(root) {
@@ -102,21 +97,6 @@ function blockForReflection(state, reportFile) {
   process.exit(2);
 }
 
-function blockForHumanDecision(state) {
-  console.error(`[CRITICAL] RULE OF 3 CIRCUIT BREAKER TRIGGERED! (repeat trip - hard lock)`);
-  console.error(`Error Signature: ${state.lastHash}`);
-  console.error(`\nYou already completed a zoom-out reflection for this same failure signature`);
-  console.error(`and the fresh diagnosis failed too. This is now past reflect-and-retry:`);
-  console.error(`STOP and hand the decision to your Human Partner.`);
-  console.error(`\nPresent a DECISION REQUEST, not a plea: the goal, the verified facts, every`);
-  console.error(`path already falsified (including the post-reflection diagnosis), 2-3`);
-  console.error(`concrete options with trade-offs, and your recommendation.`);
-  console.error(`\nThis lock persists until the Human Partner clears it by running`);
-  console.error(`"npm run harness:reset" in their own terminal, or by starting a new`);
-  console.error(`session / running /clear (which resets it automatically on SessionStart).`);
-  process.exit(2);
-}
-
 function main(payload) {
   try {
     const root = getWorkspaceRoot(payload);
@@ -142,15 +122,11 @@ function main(payload) {
         `[Rule of 3] Zoom-out report accepted - breaker released. Follow your ` +
         `report's Decision: RESUME means one fresh run at the NEW diagnosis; ` +
         `ESCALATE means present the decision request and WAIT for the Human ` +
-        `Partner before mutating anything. If this same signature trips the ` +
-        `breaker again, it hard-locks for a human decision.`
+        `Partner before mutating anything. A later set of three matching failures will trigger another zoom-out.`
       );
       process.exit(0);
     }
 
-    if ((state.zoomOutCycles || 0) >= 1) {
-      blockForHumanDecision(state);
-    }
     blockForReflection(state, reportFile);
   } catch (err) {
     // Fail open if state tracking breaks