harness-everything 0.3.6 → 0.4.0

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

@@ -7,32 +7,21 @@ const fs = require('fs');
 module.exports = {
   name: 'copilot',
   label: 'GitHub Copilot',
-  getHarnessDir(workspaceRoot) {
-    return path.join(workspaceRoot, '.github', 'harness-everything');
-  },
-  getStateDir(workspaceRoot) {
-    return path.join(this.getHarnessDir(workspaceRoot), 'state');
-  },
-  getSkillsDir(workspaceRoot) {
-    return path.join(workspaceRoot, '.github', 'skills');
-  },
+  getHarnessDir(workspaceRoot) { return path.join(workspaceRoot, '.github', 'harness-everything'); },
+  getStateDir(workspaceRoot) { return path.join(this.getHarnessDir(workspaceRoot), 'state'); },
+  getSkillsDir(workspaceRoot) { return path.join(workspaceRoot, '.github', 'skills'); },
   getIgnorePatterns(workspaceRoot) {
     const patterns = ['.github/harness-everything/'];
     const skillsDir = path.join(workspaceRoot, '.github', 'skills');
     if (fs.existsSync(skillsDir)) {
       try {
-        const entries = fs.readdirSync(skillsDir, { withFileTypes: true });
-        for (const entry of entries) {
-          if (entry.isDirectory()) {
-            const skillMdPath = path.join(skillsDir, entry.name, 'SKILL.md');
-            if (fs.existsSync(skillMdPath)) {
-              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(`.github/skills/${entry.name}/`);
-              }
-            }
-          }
+        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(`.github/skills/${entry.name}/`);
         }
       } catch (e) {
         // Fallback or ignore to prevent breaking execution
@@ -41,19 +30,14 @@ module.exports = {
     return patterns;
   },
   isMatch(pattern, trimmedLine) {
-    if (trimmedLine === '.github/' || trimmedLine === '.github') {
-      return true;
-    }
+    if (trimmedLine === '.github/' || trimmedLine === '.github') return true;
     if (pattern === '.github/harness-everything/') {
-      return trimmedLine === '.github/harness-everything' ||
-             trimmedLine === '.github/harness-everything/';
+      return trimmedLine === '.github/harness-everything' || trimmedLine === '.github/harness-everything/';
     }
     return trimmedLine === pattern || trimmedLine === pattern.slice(0, -1);
   },
   isInstalled(workspaceRoot, userHome, isGlobal) {
-    if (isGlobal) {
-      return false; // Handled via global userPromptsDir check
-    }
+    if (isGlobal) return false;
     return fs.existsSync(path.join(workspaceRoot, '.github', 'copilot-instructions.md'));
   },
   getSkillsTarget({ workspaceRoot, userHome, isGlobal, manifest }) {
@@ -64,46 +48,38 @@ module.exports = {
         label: '~/.agents/skills/',
         manifestPath: manifest.getManifestPath(globalAgentsDir),
       };
-    } else {
-      const githubDir = path.join(workspaceRoot, '.github');
-      return {
-        path: path.join(githubDir, 'skills'),
-        label: '.github/skills/',
-        manifestPath: manifest.getManifestPath(githubDir),
-      };
     }
+    const githubDir = path.join(workspaceRoot, '.github');
+    return {
+      path: path.join(githubDir, 'skills'),
+      label: '.github/skills/',
+      manifestPath: manifest.getManifestPath(githubDir),
+    };
   },
   install({ isGlobal, targetWorkspaceRoot, getUserPromptsDir, advisory }) {
     if (!isGlobal) {
       const targetFile = path.join(targetWorkspaceRoot, '.github', 'copilot-instructions.md');
       advisory.injectAdvisoryText(targetFile, '# Copilot Instructions', '.github/copilot-instructions.md');
-    } else {
-      try {
-        const promptsDir = getUserPromptsDir();
-        if (!fs.existsSync(promptsDir)) {
-          fs.mkdirSync(promptsDir, { recursive: true });
-        }
-        const vscodeInstFile = path.join(promptsDir, 'harness.instructions.md');
-        fs.writeFileSync(vscodeInstFile, advisory.buildCopilotGlobalContent(), 'utf8');
-        console.log(`  ✅ Installed global Copilot instructions to VS Code: ${vscodeInstFile}`);
-      } catch (err) {
-        console.warn(`  ⚠️ Failed to write VS Code user prompts folder: ${err.message}`);
-      }
+      return;
     }
+    const promptsDir = getUserPromptsDir();
+    if (!fs.existsSync(promptsDir)) fs.mkdirSync(promptsDir, { recursive: true });
+    const vscodeInstFile = path.join(promptsDir, 'harness.instructions.md');
+    advisory.assertHarnessOwnedOrAbsent(vscodeInstFile, 'global Copilot instructions');
+    fs.writeFileSync(vscodeInstFile, advisory.buildCopilotGlobalContent(), 'utf8');
+    console.log(`  ✅ Installed global Copilot instructions to VS Code: ${vscodeInstFile}`);
   },
   uninstall({ removeLocal, removeGlobal, workspaceRoot, userHome, getUserPromptsDir, cleanEmptyDirs }) {
     const advisory = require('../../../../scripts/lib/advisory-text');
-    if (removeLocal) {
-      advisory.removeAdvisoryText(path.join(workspaceRoot, '.github', 'copilot-instructions.md'));
-    }
+    if (removeLocal) advisory.removeAdvisoryText(path.join(workspaceRoot, '.github', 'copilot-instructions.md'));
     if (removeGlobal) {
       const promptsDir = getUserPromptsDir();
       const vscodeInstFile = path.join(promptsDir, 'harness.instructions.md');
-      if (fs.existsSync(vscodeInstFile)) {
+      if (fs.existsSync(vscodeInstFile) && advisory.hasHarnessMarker(fs.readFileSync(vscodeInstFile, 'utf8'))) {
         fs.unlinkSync(vscodeInstFile);
         console.log(`  ✅ Removed global Copilot instructions: ${vscodeInstFile}`);
       }
       cleanEmptyDirs(promptsDir, [userHome]);
     }
   }
-};
+};

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

@@ -1,57 +1,108 @@
 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-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/') {
-      return trimmedLine === '.hermes/' || 
-             trimmedLine === '.hermes' || 
-             trimmedLine === '.hermes/harness-state' ||
-             trimmedLine === '.hermes/harness-state/';
+    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 false;
+      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 globalAgentsDir = path.join(userHome, '.agents');
+      const hermesDir = path.join(userHome, '.hermes');
       return {
-        path: path.join(globalAgentsDir, 'skills'),
-        label: '~/.agents/skills/',
-        manifestPath: manifest.getManifestPath(globalAgentsDir),
+        path: path.join(hermesDir, 'skills'),
+        label: '~/.hermes/skills/',
+        manifestPath: manifest.getManifestPath(hermesDir),
       };
     }
-    return null;
+    const hermesDir = path.join(workspaceRoot, '.hermes');
+    return {
+      path: path.join(workspaceRoot, '.agents', 'skills'),
+      label: '.agents/skills/',
+      manifestPath: manifest.getManifestPath(hermesDir),
+    };
   },
-  install({ isGlobal, targetWorkspaceRoot, advisory }) {
+  install({ isGlobal, targetWorkspaceRoot, advisory, userHome }) {
     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.`);
+      // 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 }) {
+  uninstall({ removeLocal, removeGlobal, workspaceRoot, userHome, cleanEmptyDirs }) {
     const advisory = require('../../../../scripts/lib/advisory-text');
-    if (removeLocal) {
-      advisory.removeAdvisoryText(path.join(workspaceRoot, '.hermes.md'));
+    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/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/rule-of-3-tracker.js

@@ -27,7 +27,8 @@ process.stdin.on('end', () => {
     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');
+    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)) {
@@ -39,7 +40,7 @@ process.stdin.on('end', () => {
       // 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)) {
@@ -55,7 +56,7 @@ process.stdin.on('end', () => {
       } 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()
@@ -63,7 +64,7 @@ process.stdin.on('end', () => {
         .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');
@@ -94,10 +95,10 @@ 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;
-      
+
       // 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.
@@ -116,9 +117,9 @@ process.stdin.on('end', () => {
         fs.writeFileSync(stateFile, JSON.stringify(state, null, 2), 'utf8');
       }
     }
-    
+
   } catch (err) {
     // silently fail
   }
   process.exit(0);
-});
+});

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

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-// Rule of 3 circuit breaker (PreToolUse: Bash|PowerShell|Edit|Write).
+// Rule of 3 circuit breaker (PreToolUse: Bash|PowerShell|Edit|Write|apply_patch).
 //
 // Tripping the breaker forces REFLECTION, not surrender. The most common
 // agent failure mode is drilling deeper on one unverified assumption, so the
@@ -34,7 +34,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;
@@ -47,7 +47,7 @@ function anySessionTripped(root) {
 // The one mutation allowed while tripped: writing the reflection report.
 const ALLOWED_WRITE_TOOLS = new Set([
   'Write', 'Edit', 'create_file', 'replace_string_in_file',
-  'insert_edit_into_file', 'write_file', 'edit_file'
+  'insert_edit_into_file', 'write_file', 'edit_file', 'apply_patch'
 ]);
 
 function isReportWrite(payload, reportFile) {
@@ -56,8 +56,15 @@ function isReportWrite(payload, reportFile) {
   if (!ALLOWED_WRITE_TOOLS.has(toolName)) return false;
   const input = payload.tool_input || payload.toolInput || payload.input || {};
   const target = input.file_path || input.filePath || input.path || input.file;
-  if (!target) return false;
-  return path.resolve(target).toLowerCase() === path.resolve(reportFile).toLowerCase();
+  if (target && path.resolve(target).toLowerCase() === path.resolve(reportFile).toLowerCase()) return true;
+  if (toolName !== 'apply_patch') return false;
+
+  const patch = input.patch || input.command || input.content || '';
+  const base = payload.cwd || process.cwd();
+  const files = [...String(patch).matchAll(/^\*\*\* (?:Update|Add|Delete) File:\s*(.+?)\s*$/gm)]
+    .map(match => match[1]);
+  const reportPath = path.resolve(reportFile).toLowerCase();
+  return files.length > 0 && files.every(file => path.resolve(base, file).toLowerCase() === reportPath);
 }
 
 // A report only counts if it was written AFTER the failure that tripped the
@@ -75,7 +82,7 @@ function blockForReflection(state, reportFile) {
   console.error(`[CRITICAL] RULE OF 3 CIRCUIT BREAKER TRIGGERED!`);
   console.error(`The same failure signature has now occurred 3 times.`);
   console.error(`Error Signature: ${state.lastHash}`);
-  console.error(`\nMutating tools (Bash/PowerShell/Edit/Write) are locked - not because you`);
+  console.error(`\nMutating tools (Bash/PowerShell/Edit/Write/apply_patch) are locked - not because you`);
   console.error(`must wait for a human, but because you must stop drilling and rebuild the`);
   console.error(`full picture first. Do NOT ask the Human Partner yet.`);
   console.error(`\nACTION REQUIRED (reflect first):`);
@@ -112,8 +119,8 @@ function blockForHumanDecision(state) {
 
 function main(payload) {
   try {
-    const root = getWorkspaceRoot();
-    const sessionDir = getSessionDir(root, payload && payload.session_id);
+    const root = getWorkspaceRoot(payload);
+    const sessionDir = getSessionDir(root, payload && (payload.session_id || payload.sessionId));
     const stateFile = path.join(sessionDir, 'rule-of-3-state.json');
     const reportFile = path.join(sessionDir, 'zoom-out-report.md');
 
@@ -151,22 +158,23 @@ function main(payload) {
   }
 }
 
-// Fast path: skip stdin entirely unless some session's breaker is actually
-// tripped (also keeps manual terminal runs instant).
-let tripped = false;
-try {
-  tripped = anySessionTripped(getWorkspaceRoot());
-} catch (err) {
-  tripped = false; // fail open
-}
-
-if (!tripped) {
-  process.exit(0);
+// Read the payload before the fast path. The session registry may point at a
+// different workspace than process.cwd() after an agent changes directory;
+// checking the cwd first would skip an active breaker in the bound session.
+function runForPayload(payload) {
+  let tripped = false;
+  try {
+    tripped = anySessionTripped(getWorkspaceRoot(payload));
+  } catch (err) {
+    tripped = false; // fail open
+  }
+  if (!tripped) process.exit(0);
+  main(payload);
 }
 
 if (process.stdin.isTTY) {
   // Manual run in a terminal - no payload is coming.
-  main(null);
+  runForPayload(null);
 } else {
   let raw = '';
   let finished = false;
@@ -175,7 +183,7 @@ if (process.stdin.isTTY) {
     finished = true;
     let payload = null;
     try { payload = JSON.parse(raw); } catch (err) { /* no payload */ }
-    main(payload);
+    runForPayload(payload);
   };
   // Claude Code closes stdin right after writing the payload; the timer is a
   // safety net so an odd caller that never closes stdin can't hang the hook.

package/hooks/scripts/state-persist.js

@@ -29,8 +29,9 @@ process.stdin.on('end', () => {
 
 function processState(payload) {
   try {
-    const sessionId = payload && payload.session_id;
-    const stateFile = path.join(getSessionDir(getWorkspaceRoot(), sessionId), 'handoff-state.json');
+    const sessionId = payload && (payload.session_id || payload.sessionId);
+    const root = getWorkspaceRoot(payload);
+    const stateFile = path.join(getSessionDir(root, sessionId), 'handoff-state.json');
 
     // Merge into the existing state rather than replacing it, so the
     // failure/idle status and the Stop-gate milestones can coexist.
@@ -40,7 +41,7 @@ function processState(payload) {
     }
 
     if (payload) {
-      // Claude Code nests tool output under tool_response, not at the top
+      // Hook hosts nest tool output under tool_response, not at the top
       // level, and uses tool_name rather than tool. A numeric exit code
       // also isn't guaranteed to be present at all - only trust it when
       // it's actually a number; fall back to a stderr signal otherwise.
@@ -76,7 +77,7 @@ function processState(payload) {
 
       // Milestones for the Stop gate: when did the last mutation happen, and
       // has any verification-ish command succeeded since.
-      if (toolName === 'Edit' || toolName === 'Write') {
+      if (toolName === 'Edit' || toolName === 'Write' || toolName === 'apply_patch') {
         state.lastEditAt = Date.now();
       } else if ((toolName === 'Bash' || toolName === 'PowerShell') && !isFailed) {
         const command = (payload.tool_input && payload.tool_input.command) || '';

package/hooks/scripts/stop-gate.js

@@ -21,8 +21,8 @@ function decide(payload) {
       process.exit(0);
     }
 
-    const root = getWorkspaceRoot();
-    const sessionDir = getSessionDir(root, payload && payload.session_id);
+    const root = getWorkspaceRoot(payload);
+    const sessionDir = getSessionDir(root, payload && (payload.session_id || payload.sessionId));
     const handoffFile = path.join(sessionDir, 'handoff-state.json');
     const gateFile = path.join(sessionDir, 'stop-gate-state.json');