@stanco323/oh-my-claude-code 4.10.3 → 4.11.0

package/scripts/post-tool-verifier.mjs

@@ -6,14 +6,23 @@
  * Cross-platform: Windows, macOS, Linux
  */
 
+import { execSync } from 'child_process';
+import { createHash } from 'crypto';
 import { existsSync, readFileSync, writeFileSync, mkdirSync, appendFileSync, renameSync, unlinkSync } from 'fs';
-import { join, dirname } from 'path';
-import { homedir } from 'os';
+import { closeSync, openSync, readSync, statSync } from 'fs';
+import { basename, join, dirname, resolve } from 'path';
+import { homedir, tmpdir } from 'os';
 import { fileURLToPath, pathToFileURL } from 'url';
+import { getClaudeConfigDir } from './lib/config-dir.mjs';
 import { readStdin } from './lib/stdin.mjs';
 
 const AGENT_OUTPUT_ANALYSIS_LIMIT = parseInt(process.env.OMC_AGENT_OUTPUT_ANALYSIS_LIMIT || '12000', 10);
 const AGENT_OUTPUT_SUMMARY_LIMIT = parseInt(process.env.OMC_AGENT_OUTPUT_SUMMARY_LIMIT || '360', 10);
+const PREEMPTIVE_WARNING_THRESHOLD_PERCENT = parseInt(process.env.OMC_PREEMPTIVE_COMPACTION_WARNING_PERCENT || '70', 10);
+const PREEMPTIVE_CRITICAL_THRESHOLD_PERCENT = parseInt(process.env.OMC_PREEMPTIVE_COMPACTION_CRITICAL_PERCENT || '90', 10);
+const PREEMPTIVE_COOLDOWN_MS = parseInt(process.env.OMC_PREEMPTIVE_COMPACTION_COOLDOWN_MS || '60000', 10);
+const PREEMPTIVE_TRANSCRIPT_TAIL_BYTES = 4096;
+const PREEMPTIVE_LARGE_OUTPUT_TOOLS = new Set(['read', 'grep', 'glob', 'bash', 'webfetch', 'task', 'taskcreate', 'taskupdate', 'taskoutput']);
 const QUIET_LEVEL = getQuietLevel();
 const SESSION_ID_ALLOWLIST = /^[a-zA-Z0-9][a-zA-Z0-9_-]{0,255}$/;
 
@@ -23,6 +32,19 @@ function getQuietLevel() {
   return Math.max(0, parsed);
 }
 
+function clampPercent(percent, fallback) {
+  if (!Number.isFinite(percent)) return fallback;
+  return Math.min(100, Math.max(1, percent));
+}
+
+function getPreemptiveWarningThreshold() {
+  return clampPercent(PREEMPTIVE_WARNING_THRESHOLD_PERCENT, 70);
+}
+
+function getPreemptiveCriticalThreshold() {
+  return clampPercent(PREEMPTIVE_CRITICAL_THRESHOLD_PERCENT, 90);
+}
+
 // Get the directory of this script to resolve the dist module
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -45,7 +67,7 @@ const debugLog = (...args) => {
 };
 
 // State file for session tracking
-const cfgDir = process.env.CLAUDE_CONFIG_DIR || join(homedir(), '.claude');
+const cfgDir = getClaudeConfigDir();
 const STATE_FILE = join(cfgDir, '.session-stats.json');
 
 // Ensure state directory exists
@@ -217,6 +239,170 @@ function detectBackgroundOperation(output) {
   return bgPatterns.some(pattern => pattern.test(output));
 }
 
+function resolveTranscriptPath(transcriptPath, cwd) {
+  if (!transcriptPath) return undefined;
+
+  try {
+    if (existsSync(transcriptPath)) return transcriptPath;
+  } catch {}
+
+  const worktreePattern = /--claude-worktrees-[^/\\]+/;
+  if (worktreePattern.test(transcriptPath)) {
+    const resolvedPath = transcriptPath.replace(worktreePattern, '');
+    try {
+      if (existsSync(resolvedPath)) return resolvedPath;
+    } catch {}
+  }
+
+  const effectiveCwd = cwd || process.cwd();
+  try {
+    const gitCommonDir = execSync('git rev-parse --git-common-dir', {
+      cwd: effectiveCwd,
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim();
+
+    const mainRepoRoot = dirname(resolve(effectiveCwd, gitCommonDir));
+    const worktreeTop = execSync('git rev-parse --show-toplevel', {
+      cwd: effectiveCwd,
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim();
+
+    if (mainRepoRoot !== worktreeTop) {
+      const sessionFile = basename(transcriptPath);
+      if (sessionFile) {
+        const projectsDir = join(getClaudeConfigDir(), 'projects');
+        if (existsSync(projectsDir)) {
+          const encodedMain = mainRepoRoot.replace(/[/\\]/g, '-');
+          const resolvedPath = join(projectsDir, encodedMain, sessionFile);
+          if (existsSync(resolvedPath)) return resolvedPath;
+        }
+      }
+    }
+  } catch {}
+
+  return transcriptPath;
+}
+
+function readTranscriptUsage(transcriptPath) {
+  if (!transcriptPath) return null;
+
+  let fd = -1;
+  try {
+    const stat = statSync(transcriptPath);
+    if (stat.size === 0) return null;
+
+    fd = openSync(transcriptPath, 'r');
+    const readSize = Math.min(PREEMPTIVE_TRANSCRIPT_TAIL_BYTES, stat.size);
+    const buffer = Buffer.alloc(readSize);
+    readSync(fd, buffer, 0, readSize, stat.size - readSize);
+    closeSync(fd);
+    fd = -1;
+
+    const tail = buffer.toString('utf-8');
+    const windowMatches = tail.match(/"context_window"\s{0,5}:\s{0,5}(\d+)/g);
+    const inputMatches = tail.match(/"input_tokens"\s{0,5}:\s{0,5}(\d+)/g);
+    if (!windowMatches || !inputMatches) return null;
+
+    const lastWindow = Number.parseInt(
+      windowMatches[windowMatches.length - 1].match(/(\d+)/)?.[1] || '0',
+      10,
+    );
+    const lastInput = Number.parseInt(
+      inputMatches[inputMatches.length - 1].match(/(\d+)/)?.[1] || '0',
+      10,
+    );
+    if (!Number.isFinite(lastWindow) || lastWindow <= 0) return null;
+    if (!Number.isFinite(lastInput) || lastInput < 0) return null;
+
+    return Math.round((lastInput / lastWindow) * 100);
+  } catch {
+    return null;
+  } finally {
+    if (fd !== -1) {
+      try { closeSync(fd); } catch {}
+    }
+  }
+}
+
+function getPreemptiveCooldownFilePath(directory, sessionId) {
+  const cooldownScope =
+    sessionId && sessionId !== 'unknown'
+      ? `${directory || process.cwd()}::${sessionId}`
+      : directory || process.cwd();
+  const hash = createHash('sha1').update(cooldownScope).digest('hex');
+  const cooldownDir = join(tmpdir(), 'omc-preemptive-compaction');
+  mkdirSync(cooldownDir, { recursive: true });
+  return join(cooldownDir, `${hash}.json`);
+}
+
+function readPreemptiveCooldownState(directory, sessionId) {
+  try {
+    const filePath = getPreemptiveCooldownFilePath(directory, sessionId);
+    if (!existsSync(filePath)) return null;
+    const data = JSON.parse(readFileSync(filePath, 'utf-8'));
+    if (!data || typeof data !== 'object') return null;
+    return {
+      lastWarningTime:
+        typeof data.lastWarningTime === 'number' ? data.lastWarningTime : 0,
+      severity: data.severity === 'critical' ? 'critical' : 'warning',
+    };
+  } catch {
+    return null;
+  }
+}
+
+function writePreemptiveCooldownState(directory, sessionId, severity, now) {
+  writeFileSync(
+    getPreemptiveCooldownFilePath(directory, sessionId),
+    JSON.stringify({ lastWarningTime: now, severity }),
+    { mode: 0o600 },
+  );
+}
+
+function shouldSuppressPreemptiveWarning(directory, sessionId, severity, now) {
+  const cooldownState = readPreemptiveCooldownState(directory, sessionId);
+  if (!cooldownState) return false;
+  if (now - cooldownState.lastWarningTime >= PREEMPTIVE_COOLDOWN_MS) return false;
+  return !(cooldownState.severity === 'warning' && severity === 'critical');
+}
+
+function buildPreemptiveContextMessage(percentUsed, severity) {
+  if (severity === 'critical') {
+    return `[OMC CRITICAL] Context at ${percentUsed}% (critical threshold: ${getPreemptiveCriticalThreshold()}%). Run /compact now before continuing with more tools or agent fan-out.`;
+  }
+
+  return `[OMC WARNING] Context at ${percentUsed}% (warning threshold: ${getPreemptiveWarningThreshold()}%). Plan a /compact soon to preserve room for the next large tool output.`;
+}
+
+function maybeBuildPreemptiveCompactionMessage(toolName, data, directory) {
+  if (!PREEMPTIVE_LARGE_OUTPUT_TOOLS.has(String(toolName || '').toLowerCase())) {
+    return '';
+  }
+
+  const percentUsed = readTranscriptUsage(
+    resolveTranscriptPath(data.transcript_path || data.transcriptPath, directory),
+  );
+  const warningThreshold = getPreemptiveWarningThreshold();
+  const criticalThreshold = getPreemptiveCriticalThreshold();
+
+  if (percentUsed === null || percentUsed < warningThreshold) {
+    return '';
+  }
+
+  const severity = percentUsed >= criticalThreshold ? 'critical' : 'warning';
+  const now = Date.now();
+  const sessionId = data.session_id || data.sessionId || 'unknown';
+
+  if (shouldSuppressPreemptiveWarning(directory, sessionId, severity, now)) {
+    return '';
+  }
+
+  writePreemptiveCooldownState(directory, sessionId, severity, now);
+  return buildPreemptiveContextMessage(percentUsed, severity);
+}
+
 function getInvokedSkillName(toolInput) {
   if (!toolInput || typeof toolInput !== 'object') return null;
   const rawSkill =
@@ -477,6 +663,10 @@ function generateMessage(toolName, toolOutput, sessionId, toolCount, directory,
   return message;
 }
 
+function combineMessages(...messages) {
+  return messages.filter(Boolean).join(' | ');
+}
+
 async function main() {
   // Skip guard: check OMC_SKIP_HOOKS env var (see issue #838)
   const _skipHooks = (process.env.OMC_SKIP_HOOKS || '').split(',').map(s => s.trim());
@@ -528,10 +718,13 @@ async function main() {
     }
 
     // Generate contextual message
-    const message = generateMessage(toolName, clippedToolOutput, sessionId, toolCount, directory, {
-      wasTruncated,
-      rawLength: toolOutput.length,
-    });
+    const message = combineMessages(
+      generateMessage(toolName, clippedToolOutput, sessionId, toolCount, directory, {
+        wasTruncated,
+        rawLength: toolOutput.length,
+      }),
+      maybeBuildPreemptiveCompactionMessage(toolName, data, directory),
+    );
 
     // Build response - use hookSpecificOutput.additionalContext for PostToolUse
     const response = { continue: true };

package/scripts/pre-tool-enforcer.mjs

@@ -6,11 +6,12 @@
  * Cross-platform: Windows, macOS, Linux
  */
 
-import { closeSync, existsSync, mkdirSync, openSync, readFileSync, readSync, renameSync, statSync, writeFileSync } from 'fs';
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'fs';
 import { dirname, join, resolve } from 'path';
 import { execSync } from 'child_process';
-import { homedir } from 'os';
 import { fileURLToPath, pathToFileURL } from 'url';
+import { getClaudeConfigDir } from './lib/config-dir.mjs';
+import { evaluateAgentHeavyPreflight } from './lib/pre-tool-enforcer-preflight.mjs';
 import { readStdin } from './lib/stdin.mjs';
 
 // Inlined from src/config/models.ts — avoids a dist/ import so the hook works
@@ -90,8 +91,6 @@ const MODE_STATE_FILES = [
   'team-state.json',
   'omc-teams-state.json',
 ];
-const AGENT_HEAVY_TOOLS = new Set(['Task', 'TaskCreate', 'TaskUpdate']);
-const PREFLIGHT_CONTEXT_THRESHOLD = parseInt(process.env.OMC_AGENT_PREFLIGHT_CONTEXT_THRESHOLD || '72', 10);
 const QUIET_LEVEL = getQuietLevel();
 
 function getQuietLevel() {
@@ -139,7 +138,7 @@ function resolveTranscriptPath(transcriptPath, cwd) {
       const lastSep = transcriptPath.lastIndexOf('/');
       const sessionFile = lastSep !== -1 ? transcriptPath.substring(lastSep + 1) : '';
       if (sessionFile) {
-        const configDir = process.env.CLAUDE_CONFIG_DIR || join(homedir(), '.claude');
+        const configDir = getClaudeConfigDir();
         const projectsDir = join(configDir, 'projects');
         if (existsSync(projectsDir)) {
           const encodedMain = mainRepoRoot.replace(/[/\\]/g, '-');
@@ -155,46 +154,6 @@ function resolveTranscriptPath(transcriptPath, cwd) {
   return transcriptPath;
 }
 
-function estimateContextPercent(transcriptPath) {
-  if (!transcriptPath) return 0;
-
-  let fd = -1;
-  try {
-    const stat = statSync(transcriptPath);
-    if (stat.size === 0) return 0;
-
-    fd = openSync(transcriptPath, 'r');
-    const readSize = Math.min(4096, stat.size);
-    const buf = Buffer.alloc(readSize);
-    readSync(fd, buf, 0, readSize, stat.size - readSize);
-    closeSync(fd);
-    fd = -1;
-
-    const tail = buf.toString('utf-8');
-    const windowMatch = tail.match(/"context_window"\s{0,5}:\s{0,5}(\d+)/g);
-    const inputMatch = tail.match(/"input_tokens"\s{0,5}:\s{0,5}(\d+)/g);
-
-    if (!windowMatch || !inputMatch) return 0;
-
-    const lastWindow = parseInt(windowMatch[windowMatch.length - 1].match(/(\d+)/)[1], 10);
-    const lastInput = parseInt(inputMatch[inputMatch.length - 1].match(/(\d+)/)[1], 10);
-
-    if (lastWindow === 0) return 0;
-    return Math.round((lastInput / lastWindow) * 100);
-  } catch {
-    return 0;
-  } finally {
-    if (fd !== -1) try { closeSync(fd); } catch { /* ignore */ }
-  }
-}
-
-function buildPreflightRecoveryAdvice(contextPercent) {
-  return `[OMC] Preflight context guard: ${contextPercent}% used ` +
-    `(threshold: ${PREFLIGHT_CONTEXT_THRESHOLD}%). Avoid spawning additional agent-heavy tasks ` +
-    `until context is reduced. Safe recovery: (1) pause new Task fan-out, (2) run /compact now, ` +
-    `(3) if compact fails, open a fresh session and continue from .omc/state + .omc/notepad.md.`;
-}
-
 // Simple JSON field extraction
 function extractJsonField(input, field, defaultValue = '') {
   try {
@@ -247,7 +206,8 @@ function getTodoStatus(directory) {
     }
   }
 
-  // NOTE: We intentionally do NOT scan the global ~/.claude/todos/ directory.
+  // NOTE: We intentionally do NOT scan the global
+  // [$CLAUDE_CONFIG_DIR|~/.claude]/todos/ directory.
   // That directory accumulates todo files from ALL past sessions across all
   // projects, causing phantom task counts in fresh sessions (see issue #354).
 
@@ -362,7 +322,7 @@ function generateAgentSpawnMessage(toolInput, directory, todoStatus, sessionId)
       `Task(team_name="${teamName}", name="worker-N", subagent_type="${agentType}"). ` +
       `Do NOT use Task without team_name during an active team session. ` +
       `If TeamCreate is not available in your tools, tell the user to verify ` +
-      `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1 is set in ~/.claude/settings.json and restart Claude Code.`;
+      'CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1 is set in [$CLAUDE_CONFIG_DIR|~/.claude]/settings.json. Restart Claude Code.';
   }
 
   if (QUIET_LEVEL >= 2) return '';
@@ -455,7 +415,7 @@ function getSkillProtectionLevel(skillName, rawSkillName) {
 // Load OMC config to check forceInherit setting (issues #1135, #1201)
 function loadOmcConfig() {
   const configPaths = [
-    join(homedir(), '.claude', '.omc-config.json'),
+    join(getClaudeConfigDir(), '.omc-config.json'),
     join(process.cwd(), '.omc', 'config.json'),
   ];
   for (const configPath of configPaths) {
@@ -784,16 +744,15 @@ async function main() {
 
     const todoStatus = getTodoStatus(directory);
 
-    if (AGENT_HEAVY_TOOLS.has(toolName)) {
+    if (toolName === 'Task' || toolName === 'TaskCreate' || toolName === 'TaskUpdate') {
       const rawTranscriptPath = data.transcript_path || data.transcriptPath || '';
       const transcriptPath = resolveTranscriptPath(rawTranscriptPath, directory);
-      const contextPercent = estimateContextPercent(transcriptPath);
-
-      if (contextPercent >= PREFLIGHT_CONTEXT_THRESHOLD) {
-        console.log(JSON.stringify({
-          decision: 'block',
-          reason: buildPreflightRecoveryAdvice(contextPercent),
-        }));
+      const preflightBlock = evaluateAgentHeavyPreflight({
+        toolName,
+        transcriptPath,
+      });
+      if (preflightBlock) {
+        console.log(JSON.stringify(preflightBlock));
         return;
       }
     }