harness-everything 0.2.2 → 0.4.0

package/hooks/scripts/lib/platforms/hermes.js

@@ -1,57 +1,108 @@
-const path = require('path');
-const fs = require('fs');
-
-module.exports = {
-  name: 'hermes',
-  label: 'Hermes Agent',
-  getStateDir(workspaceRoot) {
-    return path.join(workspaceRoot, '.hermes', 'harness-state');
-  },
-  getIgnorePatterns(workspaceRoot) {
-    const patterns = [];
-    if (fs.existsSync(path.join(workspaceRoot, '.hermes', 'harness-state'))) {
-      patterns.push('.hermes/harness-state/');
-    }
-    return patterns;
-  },
-  isMatch(pattern, trimmedLine) {
-    if (pattern === '.hermes/harness-state/') {
-      return trimmedLine === '.hermes/' || 
-             trimmedLine === '.hermes' || 
-             trimmedLine === '.hermes/harness-state' ||
-             trimmedLine === '.hermes/harness-state/';
-    }
-    return trimmedLine === pattern || trimmedLine === pattern.slice(0, -1);
-  },
-  isInstalled(workspaceRoot, userHome, isGlobal) {
-    if (isGlobal) {
-      return false;
-    }
-    return fs.existsSync(path.join(workspaceRoot, '.hermes.md'));
-  },
-  getSkillsTarget({ workspaceRoot, userHome, isGlobal, manifest }) {
-    if (isGlobal) {
-      const globalAgentsDir = path.join(userHome, '.agents');
-      return {
-        path: path.join(globalAgentsDir, 'skills'),
-        label: '~/.agents/skills/',
-        manifestPath: manifest.getManifestPath(globalAgentsDir),
-      };
-    }
-    return null;
-  },
-  install({ isGlobal, targetWorkspaceRoot, advisory }) {
-    if (!isGlobal) {
-      const targetFile = path.join(targetWorkspaceRoot, '.hermes.md');
-      advisory.injectAdvisoryText(targetFile, '# .hermes.md', '.hermes.md');
-    } else {
-      console.log(`  ℹ️  Hermes Agent has no documented global instructions file (it reads .hermes.md from the current project directory only) - skipping global install for --hermes.`);
-    }
-  },
-  uninstall({ removeLocal, removeGlobal, workspaceRoot, userHome }) {
-    const advisory = require('../../../../scripts/lib/advisory-text');
-    if (removeLocal) {
-      advisory.removeAdvisoryText(path.join(workspaceRoot, '.hermes.md'));
-    }
-  }
-};
+const path = require('path');
+const fs = require('fs');
+
+const GLOBAL_MARKER = 'hermes-global.json';
+
+function appendHarnessSkillPatterns(patterns, skillsDir, prefix) {
+  if (!fs.existsSync(skillsDir)) return;
+  try {
+    for (const entry of fs.readdirSync(skillsDir, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue;
+      const skillMdPath = path.join(skillsDir, entry.name, 'SKILL.md');
+      if (!fs.existsSync(skillMdPath)) continue;
+      const content = fs.readFileSync(skillMdPath, 'utf8');
+      const authorLine = content.split('\n').find(line => line.trim().startsWith('author:'));
+      if (authorLine && authorLine.includes('Miya Daniel')) patterns.push(`${prefix}/${entry.name}/`);
+    }
+  } catch (e) {
+    // Best effort only; ignore-pattern generation must not break installation.
+  }
+}
+
+module.exports = {
+  name: 'hermes',
+  label: 'Hermes Agent',
+  getHarnessDir(workspaceRoot) {
+    return path.join(workspaceRoot, '.hermes', 'harness-everything');
+  },
+  getStateDir(workspaceRoot) {
+    return path.join(workspaceRoot, '.hermes', 'harness-state');
+  },
+  getSkillsDir(workspaceRoot) {
+    // Hermes discovers trusted project skills from `.agents/skills/` as well
+    // as `.hermes/skills/`. Use the shared Agent Skills location locally so
+    // explicit `--copy` and canonical auto mode are both discoverable.
+    return path.join(workspaceRoot, '.agents', 'skills');
+  },
+  getIgnorePatterns(workspaceRoot) {
+    const patterns = [];
+    if (fs.existsSync(path.join(workspaceRoot, '.hermes', 'harness-state'))) patterns.push('.hermes/harness-state/');
+    if (fs.existsSync(path.join(workspaceRoot, '.hermes', 'harness-everything'))) patterns.push('.hermes/harness-everything/');
+    appendHarnessSkillPatterns(patterns, path.join(workspaceRoot, '.agents', 'skills'), '.agents/skills');
+    return patterns;
+  },
+  isMatch(pattern, trimmedLine) {
+    if (pattern === '.hermes/harness-state/' || pattern === '.hermes/harness-everything/') {
+      return trimmedLine === '.hermes/' ||
+             trimmedLine === '.hermes' ||
+             trimmedLine === pattern.slice(0, -1) ||
+             trimmedLine === pattern;
+    }
+    if ((trimmedLine === '.agents/' || trimmedLine === '.agents') && pattern.startsWith('.agents/skills/')) return true;
+    return trimmedLine === pattern || trimmedLine === pattern.slice(0, -1);
+  },
+  isInstalled(workspaceRoot, userHome, isGlobal) {
+    if (isGlobal) {
+      return fs.existsSync(path.join(userHome, '.hermes', 'skills')) ||
+        fs.existsSync(path.join(userHome, '.agents', 'harness-everything', GLOBAL_MARKER));
+    }
+    return fs.existsSync(path.join(workspaceRoot, '.hermes.md'));
+  },
+  getSkillsTarget({ workspaceRoot, userHome, isGlobal, manifest }) {
+    if (isGlobal) {
+      const hermesDir = path.join(userHome, '.hermes');
+      return {
+        path: path.join(hermesDir, 'skills'),
+        label: '~/.hermes/skills/',
+        manifestPath: manifest.getManifestPath(hermesDir),
+      };
+    }
+    const hermesDir = path.join(workspaceRoot, '.hermes');
+    return {
+      path: path.join(workspaceRoot, '.agents', 'skills'),
+      label: '.agents/skills/',
+      manifestPath: manifest.getManifestPath(hermesDir),
+    };
+  },
+  install({ isGlobal, targetWorkspaceRoot, advisory, userHome }) {
+    if (!isGlobal) {
+      const targetFile = path.join(targetWorkspaceRoot, '.hermes.md');
+      advisory.injectAdvisoryText(targetFile, '# .hermes.md', '.hermes.md');
+    } else {
+      // Hermes has no global advisory-context file. Keep a tiny Harness-owned
+      // marker in the existing global bookkeeping home so non-interactive
+      // uninstall can distinguish an intentional Hermes global install from
+      // an unrelated ~/.hermes directory without changing Hermes config.
+      const markerDir = path.join(userHome, '.agents', 'harness-everything');
+      fs.mkdirSync(markerDir, { recursive: true });
+      fs.writeFileSync(
+        path.join(markerDir, GLOBAL_MARKER),
+        JSON.stringify({ package: 'harness-everything', platform: 'hermes' }, null, 2),
+        'utf8'
+      );
+      console.log('  ℹ️  Hermes global skills install to ~/.hermes/skills/. Project advisory context remains project-scoped via .hermes.md.');
+    }
+  },
+  uninstall({ removeLocal, removeGlobal, workspaceRoot, userHome, cleanEmptyDirs }) {
+    const advisory = require('../../../../scripts/lib/advisory-text');
+    if (removeLocal) advisory.removeAdvisoryText(path.join(workspaceRoot, '.hermes.md'));
+    if (removeGlobal) {
+      const marker = path.join(userHome, '.agents', 'harness-everything', GLOBAL_MARKER);
+      if (fs.existsSync(marker)) fs.unlinkSync(marker);
+      if (typeof cleanEmptyDirs === 'function') {
+        cleanEmptyDirs(path.join(userHome, '.hermes', 'skills'), [userHome]);
+        cleanEmptyDirs(path.dirname(marker), [userHome]);
+      }
+    }
+  }
+};

package/hooks/scripts/lib/platforms/index.js

@@ -1,17 +1,17 @@
-const claude = require('./claude');
-const cursor = require('./cursor');
-const copilot = require('./copilot');
-const codex = require('./codex');
-const _continue = require('./continue');
-const hermes = require('./hermes');
-const worktrees = require('./worktrees');
-
-module.exports = [
-  claude,
-  cursor,
-  copilot,
-  codex,
-  _continue,
-  hermes,
-  worktrees
-];
+const claude = require('./claude');
+const cursor = require('./cursor');
+const copilot = require('./copilot');
+const codex = require('./codex');
+const _continue = require('./continue');
+const hermes = require('./hermes');
+const worktrees = require('./worktrees');
+
+module.exports = [
+  claude,
+  cursor,
+  copilot,
+  codex,
+  _continue,
+  hermes,
+  worktrees
+];

package/hooks/scripts/lib/platforms/worktrees.js

@@ -1,20 +1,20 @@
-const path = require('path');
-const fs = require('fs');
-
-module.exports = {
-  name: 'worktrees',
-  label: 'Git Worktrees',
-  getIgnorePatterns(workspaceRoot) {
-    const patterns = [];
-    if (fs.existsSync(path.join(workspaceRoot, '.worktrees'))) {
-      patterns.push('.worktrees/');
-    }
-    if (fs.existsSync(path.join(workspaceRoot, 'worktrees'))) {
-      patterns.push('worktrees/');
-    }
-    return patterns;
-  },
-  isInstalled() {
-    return false; // Not a standalone platform hook/settings installer
-  }
-};
+const path = require('path');
+const fs = require('fs');
+
+module.exports = {
+  name: 'worktrees',
+  label: 'Git Worktrees',
+  getIgnorePatterns(workspaceRoot) {
+    const patterns = [];
+    if (fs.existsSync(path.join(workspaceRoot, '.worktrees'))) {
+      patterns.push('.worktrees/');
+    }
+    if (fs.existsSync(path.join(workspaceRoot, 'worktrees'))) {
+      patterns.push('worktrees/');
+    }
+    return patterns;
+  },
+  isInstalled() {
+    return false; // Not a standalone platform hook/settings installer
+  }
+};

package/hooks/scripts/openai-session-start.js

@@ -0,0 +1,81 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const {
+  getWorkspaceRoot,
+  getSessionId,
+  getSessionDir,
+  writeCurrentSession,
+  pruneStaleSessions
+} = require('./lib/harness-state');
+
+const POLICY = [
+  'Harness Cognitive OS policy is active.',
+  'Use Discover -> Think -> Try -> Summarize -> Record as a lightweight reasoning loop.',
+  'Cross-cutting invariants:',
+  '- Route before execution: establish task scope before mutating work.',
+  '- Verify before claim: require objective evidence appropriate to the change.',
+  '- Re-plan on repetition: after 3 same-signature failures, zoom out instead of repeating the same attempt.',
+  'Domain skills are advisory. Do not enforce a universal workflow order; choose the smallest useful skill/tool set.'
+].join('\n');
+
+function readPayload() {
+  if (process.stdin.isTTY) return null;
+  try {
+    const raw = fs.readFileSync(0, 'utf8').trim();
+    return raw ? JSON.parse(raw) : null;
+  } catch (err) {
+    return null;
+  }
+}
+
+function removeIfPresent(file) {
+  try {
+    if (fs.existsSync(file)) fs.unlinkSync(file);
+  } catch (err) {
+    // Session reset is best effort; a stale breaker must never block startup.
+  }
+}
+
+function handoffContext(sessionDir) {
+  try {
+    const handoff = JSON.parse(fs.readFileSync(path.join(sessionDir, 'handoff-state.json'), 'utf8'));
+    if (handoff.status !== 'failed') return '';
+    const detail = String(handoff.errorSummary || 'No error snippet available').trim().slice(-300);
+    return `\nPrevious session checkpoint: ${handoff.tool || 'unknown'} failed${handoff.exitCode ? ` (exit ${handoff.exitCode})` : ''}.\nReview the failure evidence before continuing.\n${detail}`;
+  } catch (err) {
+    return '';
+  }
+}
+
+function main() {
+  const payload = readPayload();
+  const root = getWorkspaceRoot(payload);
+  const sessionId = getSessionId(payload);
+  let additionalContext = POLICY;
+
+  if (root) {
+    try {
+      pruneStaleSessions(root);
+      writeCurrentSession(root, sessionId);
+      const sessionDir = getSessionDir(root, sessionId);
+      removeIfPresent(path.join(sessionDir, 'rule-of-3-state.json'));
+      removeIfPresent(path.join(sessionDir, 'zoom-out-report.md'));
+      removeIfPresent(path.join(sessionDir, 'subagent-scope-state.json'));
+      additionalContext += handoffContext(sessionDir);
+    } catch (err) {
+      // Policy injection remains useful even if runtime state is unavailable.
+    }
+  }
+
+  console.log(JSON.stringify({
+    hookSpecificOutput: {
+      hookEventName: 'SessionStart',
+      additionalContext
+    }
+  }));
+}
+
+main();

package/hooks/scripts/reset-circuit-breaker.js

@@ -1,30 +1,30 @@
-#!/usr/bin/env node
-// Manual escape hatch for the Rule of 3 circuit breaker. Run this directly
-// in your own terminal (not through the agent — Bash is blocked while the
-// breaker is tripped) to clear it without waiting for a new session.
-const fs = require('fs');
-const path = require('path');
-const { getWorkspaceRoot, getSessionDir, readCurrentSession } = require('./lib/harness-state');
-
-// This is run directly by the human, not through the agent, so there's no
-// hook payload to read a session_id from - resolve "the session that's
-// currently blocked" via the pointer bootstrap.js wrote at its last
-// SessionStart.
-const root = getWorkspaceRoot();
-const harnessDir = getSessionDir(root, readCurrentSession(root));
-const stateFile = path.join(harnessDir, 'rule-of-3-state.json');
-const reportFile = path.join(harnessDir, 'zoom-out-report.md');
-
-if (fs.existsSync(stateFile)) {
-  fs.unlinkSync(stateFile);
-  console.log('Rule of 3 circuit breaker cleared.');
-} else {
-  console.log('Rule of 3 circuit breaker is not currently tripped.');
-}
-
-// A human reset is a full clear: the stale reflection report belongs to the
-// loop that was just abandoned.
-if (fs.existsSync(reportFile)) {
-  fs.unlinkSync(reportFile);
-  console.log('Stale zoom-out report removed.');
-}
+#!/usr/bin/env node
+// Manual escape hatch for the Rule of 3 circuit breaker. Run this directly
+// in your own terminal (not through the agent — Bash is blocked while the
+// breaker is tripped) to clear it without waiting for a new session.
+const fs = require('fs');
+const path = require('path');
+const { getWorkspaceRoot, getSessionDir, readCurrentSession } = require('./lib/harness-state');
+
+// This is run directly by the human, not through the agent, so there's no
+// hook payload to read a session_id from - resolve "the session that's
+// currently blocked" via the pointer bootstrap.js wrote at its last
+// SessionStart.
+const root = getWorkspaceRoot();
+const harnessDir = getSessionDir(root, readCurrentSession(root));
+const stateFile = path.join(harnessDir, 'rule-of-3-state.json');
+const reportFile = path.join(harnessDir, 'zoom-out-report.md');
+
+if (fs.existsSync(stateFile)) {
+  fs.unlinkSync(stateFile);
+  console.log('Rule of 3 circuit breaker cleared.');
+} else {
+  console.log('Rule of 3 circuit breaker is not currently tripped.');
+}
+
+// A human reset is a full clear: the stale reflection report belongs to the
+// loop that was just abandoned.
+if (fs.existsSync(reportFile)) {
+  fs.unlinkSync(reportFile);
+  console.log('Stale zoom-out report removed.');
+}

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

@@ -1,91 +1,125 @@
-#!/usr/bin/env node
-const fs = require('fs');
-const path = require('path');
-const crypto = require('crypto');
-const { getWorkspaceRoot, getSessionDir } = require('./lib/harness-state');
-
-// PostToolUse hooks in Claude Code typically receive the tool output via stdin
-let inputData = '';
-
-process.stdin.on('data', chunk => {
-  inputData += chunk;
-});
-
-process.stdin.on('end', () => {
-  try {
-    const payload = JSON.parse(inputData);
-    // Claude Code's documented PostToolUse payload nests tool output under
-    // tool_response rather than at the top level, and does not guarantee a
-    // numeric exit code field. Treating a missing/unknown exit code as a
-    // failure (the old `exitCode !== 0` check) flags every successful call
-    // as an error. Only count a call as a failure when we have positive
-    // evidence of one.
-    const toolResponse = payload.tool_response || {};
-    const stdout = toolResponse.stdout ?? payload.stdout ?? '';
-    const stderr = toolResponse.stderr ?? payload.stderr ?? '';
-    const rawExitCode = toolResponse.exitCode ?? toolResponse.exit_code ?? payload.exitCode;
-    const exitCode = typeof rawExitCode === 'number' ? rawExitCode : undefined;
-
-    const explicitFailure = exitCode !== undefined && exitCode !== 0;
-    const explicitSuccess = exitCode === 0;
-    const stderrSignal = typeof stderr === 'string' && stderr.trim().length > 0;
-    // Without an exit code, bare stderr is not enough evidence: plenty of
-    // tools chat on stderr while succeeding (git, npm warnings, progress
-    // bars), and three identical warnings must not trip the breaker. Require
-    // the text to actually look like a failure.
-    const looksLikeError = /\b(error|fail|failed|failure|exception|fatal|panic|traceback|denied|refused|cannot|unable)\b/i.test(stderr);
-    const isFailure = explicitFailure || (exitCode === undefined && stderrSignal && looksLikeError);
-    const errorText = (stderrSignal ? stderr : stdout) || '';
-
-    const stateFile = path.join(getSessionDir(getWorkspaceRoot(), payload.session_id), 'rule-of-3-state.json');
-
-    let state = { count: 0, lastHash: null, zoomOutResolved: false, zoomOutCycles: 0, lastFailureAt: 0 };
-    if (fs.existsSync(stateFile)) {
-      state = JSON.parse(fs.readFileSync(stateFile, 'utf8'));
-    }
-
-    if (isFailure && errorText) {
-      // Hash the tail of the error to identify identical loops. Normalize
-      // first: timestamps, line numbers, addresses and counters vary between
-      // otherwise-identical failures, and an ever-changing hash would hide a
-      // genuine loop from the breaker.
-      const normalized = errorText.slice(-400)
-        .toLowerCase()
-        .replace(/0x[0-9a-f]+/g, '#')
-        .replace(/\d+/g, '#')
-        .replace(/\s+/g, ' ')
-        .trim();
-      const hash = crypto.createHash('md5').update(normalized.slice(-200)).digest('hex');
-
-      if (state.lastHash === hash) {
-        state.count += 1;
-      } else {
-        state.count = 1;
-        state.lastHash = hash;
-        // New signature = new problem: the zoom-out cycle budget starts over.
-        state.zoomOutCycles = 0;
-      }
-      // 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
-      // zoomOutResolved=true and the breaker could never trip on it again.
-      state.zoomOutResolved = false;
-      // rule-of-3.js only honors a zoom-out report written AFTER this moment,
-      // so a stale report can't unlock a later trip.
-      state.lastFailureAt = Date.now();
-
-      fs.writeFileSync(stateFile, JSON.stringify(state, null, 2), 'utf8');
-    } else if (explicitSuccess) {
-      // Only reset on a *confirmed* zero exit code, not merely "not a failure".
-      if (state.count > 0 || state.zoomOutCycles > 0) {
-        state.count = 0;
-        state.zoomOutResolved = true;
-        state.zoomOutCycles = 0;
-        fs.writeFileSync(stateFile, JSON.stringify(state, null, 2), 'utf8');
-      }
-    }
-    
-  } catch (err) {
-    // silently fail
-  }
-  process.exit(0);
-});
+#!/usr/bin/env node
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const { getWorkspaceRoot, getSessionDir } = require('./lib/harness-state');
+
+// PostToolUse hooks in Claude Code typically receive the tool output via stdin
+let inputData = '';
+
+process.stdin.on('data', chunk => {
+  inputData += chunk;
+});
+
+process.stdin.on('end', () => {
+  try {
+    const payload = JSON.parse(inputData);
+    const toolResponse = payload.tool_response || {};
+    const stdout = toolResponse.stdout ?? payload.stdout ?? '';
+    const stderr = toolResponse.stderr ?? payload.stderr ?? '';
+    const rawExitCode = toolResponse.exitCode ?? toolResponse.exit_code ?? payload.exitCode;
+    const exitCode = typeof rawExitCode === 'number' ? rawExitCode : undefined;
+
+    const explicitFailure = exitCode !== undefined && exitCode !== 0;
+    const explicitSuccess = exitCode === 0;
+    const stderrSignal = typeof stderr === 'string' && stderr.trim().length > 0;
+    const looksLikeError = /\b(error|fail|failed|failure|exception|fatal|panic|traceback|denied|refused|cannot|unable)\b/i.test(stderr);
+    const isFailure = explicitFailure || (exitCode === undefined && stderrSignal && looksLikeError);
+    const errorText = (stderrSignal ? stderr : stdout) || '';
+
+    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 };
+    if (fs.existsSync(stateFile)) {
+      state = JSON.parse(fs.readFileSync(stateFile, 'utf8'));
+    }
+
+    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
+      let category = 'unknown';
+      if (/SyntaxError|Unexpected token|Syntax Error/i.test(errorText)) {
+        category = 'syntax';
+      } else if (/ENOENT|not found|No such file|找不到|不存在/i.test(errorText)) {
+        category = 'environment';
+      } else if (/timeout|timed out|超時|逾時/i.test(errorText)) {
+        category = 'timeout';
+      } else if (/test.*fail|assertion|AssertionError|測試.*失敗|斷言.*錯誤/i.test(errorText)) {
+        category = 'test';
+      } else if (/permission|denied|EACCES|權限/i.test(errorText)) {
+        category = 'permission';
+      } else if (/dependency|module not found|Cannot find module|模組.*找不到/i.test(errorText)) {
+        category = 'dependency';
+      }
+
+      // Normalize error text with context for better loop detection
+      const normalized = errorText.slice(-400)
+        .toLowerCase()
+        .replace(/0x[0-9a-f]+/g, '#')
+        .replace(/\d+/g, '#')
+        .replace(/\s+/g, ' ')
+        .trim();
+
+      // Include file path and command in hash for better context
+      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
+      }
+
+      if (state.lastHash === hash) {
+        state.count += 1;
+        state.category = category; // Track failure category for smarter decisions
+      } else {
+        state.count = 1;
+        state.lastHash = hash;
+        state.category = category;
+        // New signature = new problem: the zoom-out cycle budget starts over.
+        state.zoomOutCycles = 0;
+      }
+
+      // Store threshold for this failure type
+      state.threshold = threshold;
+
+      // 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
+      // zoomOutResolved=true and the breaker could never trip on it again.
+      state.zoomOutResolved = false;
+      // rule-of-3.js only honors a zoom-out report written AFTER this moment,
+      // so a stale report can't unlock a later trip.
+      state.lastFailureAt = Date.now();
+
+      fs.writeFileSync(stateFile, JSON.stringify(state, null, 2), 'utf8');
+    } else if (explicitSuccess) {
+      // Only reset on a *confirmed* zero exit code, not merely "not a failure".
+      if (state.count > 0 || state.zoomOutCycles > 0) {
+        state.count = 0;
+        state.zoomOutResolved = true;
+        state.zoomOutCycles = 0;
+        fs.writeFileSync(stateFile, JSON.stringify(state, null, 2), 'utf8');
+      }
+    }
+
+  } catch (err) {
+    // silently fail
+  }
+  process.exit(0);
+});