claudecode-omc 4.3.4

package/scripts/cleanup-orphans.mjs

@@ -0,0 +1,189 @@
+#!/usr/bin/env node
+
+/**
+ * OMC Orphan Agent Cleanup
+ *
+ * Detects and terminates orphan agent processes — agents whose team
+ * config has been deleted (via TeamDelete) but whose OS processes
+ * are still running. This happens when TeamDelete fires before all
+ * teammates confirm shutdown.
+ *
+ * Usage:
+ *   node cleanup-orphans.mjs [--team-name <name>] [--dry-run]
+ *
+ * When --team-name is provided, only checks for orphans from that team.
+ * When omitted, scans for ALL orphan claude agent processes.
+ *
+ * --dry-run: Report orphans without killing them.
+ *
+ * Exit codes:
+ *   0 - Success (orphans cleaned or none found)
+ *   1 - Error during cleanup
+ */
+
+import { existsSync } from 'node:fs';
+import { execSync } from 'node:child_process';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+
+const args = process.argv.slice(2);
+const teamNameIdx = args.indexOf('--team-name');
+const rawTeamName = teamNameIdx !== -1 ? args[teamNameIdx + 1] : null;
+const dryRun = args.includes('--dry-run');
+
+// Validate team name to prevent path traversal and injection
+const TEAM_NAME_RE = /^[\w][\w-]{0,63}$/;
+const teamName = rawTeamName && TEAM_NAME_RE.test(rawTeamName) ? rawTeamName : null;
+if (rawTeamName && !teamName) {
+  console.error(`[cleanup-orphans] Invalid team name: ${rawTeamName}`);
+  process.exit(1);
+}
+
+/**
+ * Find claude agent processes that match team patterns.
+ * Cross-platform: uses ps on Unix, tasklist on Windows.
+ */
+function findOrphanProcesses(filterTeam) {
+  const orphans = [];
+
+  try {
+    if (process.platform === 'win32') {
+      // Windows: use WMIC to find node/claude processes
+      const output = execSync(
+        'wmic process where "name like \'%node%\' or name like \'%claude%\'" get processid,commandline /format:csv',
+        { encoding: 'utf-8', timeout: 10000 }
+      ).trim();
+
+      for (const line of output.split('\n')) {
+        if (line.includes('--team-name') || line.includes('team_name')) {
+          // Restrict team name match to valid slug characters (alphanumeric + hyphens)
+          const match = line.match(/--team-name[=\s]+([\w][\w-]{0,63})/i) || line.match(/team_name[=:]\s*"?([\w][\w-]{0,63})"?/i);
+          if (match) {
+            const procTeam = match[1];
+            if (filterTeam && procTeam !== filterTeam) continue;
+
+            const pidMatch = line.match(/,(\d+)\s*$/);
+            if (pidMatch) {
+              orphans.push({ pid: parseInt(pidMatch[1], 10), team: procTeam, cmd: line.trim() });
+            }
+          }
+        }
+      }
+    } else {
+      // Unix (macOS / Linux): use ps
+      const output = execSync('ps aux', { encoding: 'utf-8', timeout: 10000 });
+
+      for (const line of output.split('\n')) {
+        // Match claude agent processes with team context
+        if ((line.includes('claude') || line.includes('node')) &&
+            (line.includes('--team-name') || line.includes('team_name'))) {
+
+          // Restrict team name match to valid slug characters
+          const match = line.match(/--team-name[=\s]+([\w][\w-]{0,63})/i) || line.match(/team_name[=:]\s*"?([\w][\w-]{0,63})"?/i);
+          if (match) {
+            const procTeam = match[1];
+            if (filterTeam && procTeam !== filterTeam) continue;
+
+            const parts = line.trim().split(/\s+/);
+            const pid = parseInt(parts[1], 10);
+            if (pid && pid !== process.pid && pid !== process.ppid) {
+              orphans.push({ pid, team: procTeam, cmd: line.trim().substring(0, 200) });
+            }
+          }
+        }
+      }
+    }
+  } catch {
+    // ps/wmic failed — can't detect orphans
+  }
+
+  return orphans;
+}
+
+/**
+ * Check if a team's config still exists (i.e., team is still active).
+ */
+function teamConfigExists(name) {
+  const configDir = process.env.CLAUDE_CONFIG_DIR || join(homedir(), '.claude');
+  const configPath = join(configDir, 'teams', name, 'config.json');
+  return existsSync(configPath);
+}
+
+/**
+ * Kill a process: SIGTERM first, SIGKILL after 5s if still alive.
+ */
+function killProcess(pid) {
+  // Validate PID is a positive integer (prevent command injection)
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+
+  try {
+    if (process.platform === 'win32') {
+      execSync(`taskkill /PID ${pid} /F`, { timeout: 10000 });
+    } else {
+      // Send SIGTERM
+      process.kill(pid, 'SIGTERM');
+
+      // Wait 5s, then SIGKILL if still alive
+      setTimeout(() => {
+        try {
+          process.kill(pid, 0); // Check if still running
+          process.kill(pid, 'SIGKILL');
+        } catch {
+          // Process already exited
+        }
+      }, 5000);
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function main() {
+  const processes = findOrphanProcesses(teamName);
+
+  if (processes.length === 0) {
+    console.log(JSON.stringify({
+      orphans: 0,
+      message: teamName
+        ? `No orphan processes found for team "${teamName}".`
+        : 'No orphan agent processes found.',
+    }));
+    process.exit(0);
+  }
+
+  // Filter to actual orphans: processes whose team config no longer exists
+  const orphans = processes.filter(p => !teamConfigExists(p.team));
+
+  if (orphans.length === 0) {
+    console.log(JSON.stringify({
+      orphans: 0,
+      message: `Found ${processes.length} team process(es) but all have active team configs.`,
+    }));
+    process.exit(0);
+  }
+
+  const results = [];
+
+  for (const orphan of orphans) {
+    if (dryRun) {
+      results.push({ pid: orphan.pid, team: orphan.team, action: 'would_kill' });
+      console.error(`[dry-run] Would kill PID ${orphan.pid} (team: ${orphan.team})`);
+    } else {
+      const killed = killProcess(orphan.pid);
+      results.push({ pid: orphan.pid, team: orphan.team, action: killed ? 'killed' : 'failed' });
+      console.error(`[cleanup] ${killed ? 'Killed' : 'Failed to kill'} PID ${orphan.pid} (team: ${orphan.team})`);
+    }
+  }
+
+  console.log(JSON.stringify({
+    orphans: orphans.length,
+    dryRun,
+    results,
+    message: dryRun
+      ? `Found ${orphans.length} orphan(s). Re-run without --dry-run to clean up.`
+      : `Cleaned up ${results.filter(r => r.action === 'killed').length}/${orphans.length} orphan(s).`,
+  }));
+}
+
+main();

package/scripts/code-simplifier.mjs

@@ -0,0 +1,193 @@
+#!/usr/bin/env node
+
+/**
+ * OMC Code Simplifier Stop Hook (Node.js)
+ *
+ * Intercepts Stop events to automatically delegate recently modified source files
+ * to the code-simplifier agent for cleanup and simplification.
+ *
+ * Opt-in via ~/.omc/config.json: { "codeSimplifier": { "enabled": true } }
+ * Default: disabled (must explicitly opt in)
+ */
+
+import {
+  existsSync,
+  readFileSync,
+  writeFileSync,
+  mkdirSync,
+  unlinkSync,
+} from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { execSync } from 'child_process';
+import { readStdin } from './lib/stdin.mjs';
+
+const DEFAULT_EXTENSIONS = ['.ts', '.tsx', '.js', '.jsx', '.py', '.go', '.rs'];
+const DEFAULT_MAX_FILES = 10;
+const MARKER_FILENAME = 'code-simplifier-triggered.marker';
+
+function readJsonFile(filePath) {
+  try {
+    if (!existsSync(filePath)) return null;
+    return JSON.parse(readFileSync(filePath, 'utf-8'));
+  } catch {
+    return null;
+  }
+}
+
+function readOmcConfig() {
+  return readJsonFile(join(homedir(), '.omc', 'config.json'));
+}
+
+function isEnabled(config) {
+  return config?.codeSimplifier?.enabled === true;
+}
+
+function getModifiedFiles(cwd, extensions, maxFiles) {
+  try {
+    const output = execSync('git diff HEAD --name-only', {
+      cwd,
+      encoding: 'utf-8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+      timeout: 5000,
+    });
+
+    return output
+      .trim()
+      .split('\n')
+      .filter((f) => f.trim().length > 0)
+      .filter((f) => extensions.some((ext) => f.endsWith(ext)))
+      .slice(0, maxFiles);
+  } catch {
+    return [];
+  }
+}
+
+function buildMessage(files) {
+  const fileList = files.map((f) => `  - ${f}`).join('\n');
+  const fileArgs = files.join('\\n');
+  return (
+    `[CODE SIMPLIFIER] Recently modified files detected. Delegate to the ` +
+    `code-simplifier agent to simplify the following files for clarity, ` +
+    `consistency, and maintainability (without changing behavior):\n\n` +
+    `${fileList}\n\n` +
+    `Use: Task(subagent_type="oh-my-claudecode:code-simplifier", ` +
+    `prompt="Simplify the recently modified files:\\n${fileArgs}")`
+  );
+}
+
+async function main() {
+  try {
+    const input = await readStdin();
+    let data = {};
+    try {
+      data = JSON.parse(input);
+    } catch {
+      process.stdout.write(JSON.stringify({ continue: true }) + '\n');
+      return;
+    }
+
+    const cwd = data.cwd || data.directory || process.cwd();
+    const stateDir = join(cwd, '.omc', 'state');
+    const config = readOmcConfig();
+
+    if (!isEnabled(config)) {
+      process.stdout.write(JSON.stringify({ continue: true }) + '\n');
+      return;
+    }
+
+    const markerPath = join(stateDir, MARKER_FILENAME);
+
+    // If already triggered this turn, clear marker and allow stop
+    if (existsSync(markerPath)) {
+      try {
+        unlinkSync(markerPath);
+      } catch {
+        // ignore
+      }
+      process.stdout.write(JSON.stringify({ continue: true }) + '\n');
+      return;
+    }
+
+    const extensions = config?.codeSimplifier?.extensions ?? DEFAULT_EXTENSIONS;
+    const maxFiles = config?.codeSimplifier?.maxFiles ?? DEFAULT_MAX_FILES;
+    const files = getModifiedFiles(cwd, extensions, maxFiles);
+
+    if (files.length === 0) {
+      process.stdout.write(JSON.stringify({ continue: true }) + '\n');
+      return;
+    }
+
+    // Write trigger marker to prevent re-triggering within this turn cycle
+    try {
+      if (!existsSync(stateDir)) {
+        mkdirSync(stateDir, { recursive: true });
+      }
+      writeFileSync(markerPath, new Date().toISOString(), 'utf-8');
+    } catch {
+      // best-effort — proceed even if marker write fails
+    }
+
+    process.stdout.write(
+      JSON.stringify({ decision: 'block', reason: buildMessage(files) }) + '\n',
+    );
+  } catch (error) {
+    try {
+      process.stderr.write(`[code-simplifier] Error: ${error?.message || error}\n`);
+    } catch {
+      // ignore
+    }
+    try {
+      process.stdout.write(JSON.stringify({ continue: true }) + '\n');
+    } catch {
+      process.exit(0);
+    }
+  }
+}
+
+process.on('uncaughtException', (error) => {
+  try {
+    process.stderr.write(`[code-simplifier] Uncaught: ${error?.message || error}\n`);
+  } catch {
+    // ignore
+  }
+  try {
+    process.stdout.write(JSON.stringify({ continue: true }) + '\n');
+  } catch {
+    // ignore
+  }
+  process.exit(0);
+});
+
+process.on('unhandledRejection', (error) => {
+  try {
+    process.stderr.write(`[code-simplifier] Unhandled: ${error?.message || error}\n`);
+  } catch {
+    // ignore
+  }
+  try {
+    process.stdout.write(JSON.stringify({ continue: true }) + '\n');
+  } catch {
+    // ignore
+  }
+  process.exit(0);
+});
+
+// Safety timeout: force exit after 10 seconds to prevent hook from hanging
+const safetyTimeout = setTimeout(() => {
+  try {
+    process.stderr.write('[code-simplifier] Safety timeout reached, forcing exit\n');
+  } catch {
+    // ignore
+  }
+  try {
+    process.stdout.write(JSON.stringify({ continue: true }) + '\n');
+  } catch {
+    // ignore
+  }
+  process.exit(0);
+}, 10000);
+
+main().finally(() => {
+  clearTimeout(safetyTimeout);
+});

package/scripts/compose-docs.mjs

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+
+/**
+ * Documentation Composition Script
+ *
+ * Processes template files with {{INCLUDE:path}} syntax to compose
+ * final documentation from shared partials.
+ *
+ * Usage: node scripts/compose-docs.mjs
+ *
+ * Template syntax: {{INCLUDE:partials/agent-tiers.md}}
+ * Templates: docs/templates/*.template.md
+ * Output: docs/*.md (same name without .template)
+ * Partials also copied to docs/shared/ for direct reference.
+ */
+
+import { readFileSync, writeFileSync, readdirSync, mkdirSync, existsSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const docsDir = join(__dirname, '..', 'docs');
+const partialsDir = join(docsDir, 'partials');
+const sharedDir = join(docsDir, 'shared');
+
+// Ensure directories exist
+[partialsDir, sharedDir].forEach(dir => {
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+});
+
+// Copy partials to shared/ for direct reference by skills
+if (existsSync(partialsDir)) {
+  const partials = readdirSync(partialsDir).filter(f => f.endsWith('.md'));
+
+  for (const partial of partials) {
+    const content = readFileSync(join(partialsDir, partial), 'utf-8');
+    writeFileSync(join(sharedDir, partial), content);
+  }
+  console.log(`Synced ${readdirSync(partialsDir).filter(f => f.endsWith('.md')).length} partials to shared/`);
+}
+
+console.log('Documentation composition complete.');

package/scripts/context-guard-stop.mjs

@@ -0,0 +1,181 @@
+#!/usr/bin/env node
+
+/**
+ * OMC Context Guard Hook (Stop)
+ *
+ * Suggests session refresh when context usage exceeds a warning threshold.
+ * This complements persistent-mode.cjs — it fires BEFORE modes like Ralph
+ * or Ultrawork process the stop, providing an early warning.
+ *
+ * Configurable via OMC_CONTEXT_GUARD_THRESHOLD env var (default: 75%).
+ *
+ * Safety rules:
+ *   - Never block context_limit stops (would cause compaction deadlock)
+ *   - Never block user-requested stops (respect Ctrl+C / cancel)
+ *   - Max 2 blocks per transcript (retry guard prevents infinite loops)
+ *
+ * Hook output:
+ *   - { decision: "block", reason: "..." } when context too high
+ *   - { continue: true, suppressOutput: true } otherwise
+ */
+
+import { existsSync, readFileSync, writeFileSync, mkdirSync, statSync, openSync, readSync, closeSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { tmpdir } from 'node:os';
+import { readStdin } from './lib/stdin.mjs';
+
+const THRESHOLD = parseInt(process.env.OMC_CONTEXT_GUARD_THRESHOLD || '75', 10);
+const MAX_BLOCKS = 2;
+
+/**
+ * Detect if stop was triggered by context-limit related reasons.
+ * Mirrors the logic in persistent-mode.cjs to stay consistent.
+ */
+function isContextLimitStop(data) {
+  const reason = (data.stop_reason || data.stopReason || '').toLowerCase();
+  const contextPatterns = [
+    'context_limit', 'context_window', 'context_exceeded',
+    'context_full', 'max_context', 'token_limit',
+    'max_tokens', 'conversation_too_long', 'input_too_long',
+  ];
+
+  if (contextPatterns.some(p => reason.includes(p))) return true;
+
+  const endTurnReason = (data.end_turn_reason || data.endTurnReason || '').toLowerCase();
+  if (endTurnReason && contextPatterns.some(p => endTurnReason.includes(p))) return true;
+
+  return false;
+}
+
+/**
+ * Detect if stop was triggered by user abort.
+ */
+function isUserAbort(data) {
+  if (data.user_requested || data.userRequested) return true;
+
+  const reason = (data.stop_reason || data.stopReason || '').toLowerCase();
+  const exactPatterns = ['aborted', 'abort', 'cancel', 'interrupt'];
+  const substringPatterns = ['user_cancel', 'user_interrupt', 'ctrl_c', 'manual_stop'];
+
+  return (
+    exactPatterns.some(p => reason === p) ||
+    substringPatterns.some(p => reason.includes(p))
+  );
+}
+
+/**
+ * Estimate context usage percentage from the transcript file.
+ */
+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');
+
+    // Bounded quantifiers to avoid ReDoS on malformed input
+    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 */ }
+  }
+}
+
+/**
+ * Retry guard: track how many times we've blocked this transcript.
+ * Prevents infinite block loops by capping at MAX_BLOCKS.
+ */
+function getBlockCount(sessionId) {
+  if (!sessionId) return 0;
+  const guardFile = join(tmpdir(), `omc-context-guard-${sessionId}.json`);
+  try {
+    if (existsSync(guardFile)) {
+      const data = JSON.parse(readFileSync(guardFile, 'utf-8'));
+      return data.blockCount || 0;
+    }
+  } catch { /* ignore */ }
+  return 0;
+}
+
+function incrementBlockCount(sessionId) {
+  if (!sessionId) return;
+  const guardFile = join(tmpdir(), `omc-context-guard-${sessionId}.json`);
+  try {
+    let count = 0;
+    if (existsSync(guardFile)) {
+      const data = JSON.parse(readFileSync(guardFile, 'utf-8'));
+      count = data.blockCount || 0;
+    }
+    writeFileSync(guardFile, JSON.stringify({ blockCount: count + 1 }));
+  } catch { /* ignore */ }
+}
+
+async function main() {
+  try {
+    const input = await readStdin();
+    const data = JSON.parse(input);
+
+    // CRITICAL: Never block context-limit stops (compaction deadlock)
+    if (isContextLimitStop(data)) {
+      console.log(JSON.stringify({ continue: true, suppressOutput: true }));
+      return;
+    }
+
+    // Respect user abort
+    if (isUserAbort(data)) {
+      console.log(JSON.stringify({ continue: true, suppressOutput: true }));
+      return;
+    }
+
+    const sessionId = data.session_id || data.sessionId || '';
+    const transcriptPath = data.transcript_path || data.transcriptPath || '';
+    const pct = estimateContextPercent(transcriptPath);
+
+    if (pct >= THRESHOLD) {
+      // Check retry guard
+      const blockCount = getBlockCount(sessionId);
+      if (blockCount >= MAX_BLOCKS) {
+        // Already blocked enough times — let it through
+        console.log(JSON.stringify({ continue: true, suppressOutput: true }));
+        return;
+      }
+
+      incrementBlockCount(sessionId);
+
+      console.log(JSON.stringify({
+        decision: 'block',
+        reason: `[OMC] Context at ${pct}% (threshold: ${THRESHOLD}%). ` +
+          `Quality degrades at high context. Run /compact or start a fresh session. ` +
+          `(Block ${blockCount + 1}/${MAX_BLOCKS})`
+      }));
+      return;
+    }
+
+    console.log(JSON.stringify({ continue: true, suppressOutput: true }));
+  } catch {
+    // On any error, allow stop (never block on hook failure)
+    console.log(JSON.stringify({ continue: true, suppressOutput: true }));
+  }
+}
+
+main();

package/scripts/context-safety.mjs

@@ -0,0 +1,96 @@
+#!/usr/bin/env node
+
+/**
+ * OMC Context Safety Hook (PreToolUse)
+ *
+ * Blocks expensive operations (TeamCreate, ExitPlanMode) when context usage
+ * exceeds a safe threshold. Spawning teams or exiting plan mode at high
+ * context leads to unrecoverable extended-thinking loops because the model
+ * cannot converge on a next action.
+ *
+ * Configurable via OMC_CONTEXT_SAFETY_THRESHOLD env var (default: 55%).
+ *
+ * Hook output:
+ *   - Block (exit 2 + stderr message) when context too high for the tool
+ *   - Allow ({ continue: true, suppressOutput: true }) otherwise
+ */
+
+import { statSync, openSync, readSync, closeSync } from 'node:fs';
+import { readStdin } from './lib/stdin.mjs';
+
+const THRESHOLD = parseInt(process.env.OMC_CONTEXT_SAFETY_THRESHOLD || '55', 10);
+const BLOCKED_TOOLS = new Set(['TeamCreate', 'ExitPlanMode']);
+
+/**
+ * Estimate context usage percentage from the transcript file.
+ * Reads the last 4KB of the transcript to find the most recent usage entry.
+ */
+function estimateContextPercent(transcriptPath) {
+  if (!transcriptPath) return 0;
+
+  let fd = -1;
+  try {
+    const stat = statSync(transcriptPath);
+    if (stat.size === 0) return 0;
+
+    // Read the last 4KB — covers ~50-100 JSONL entries for recent usage data
+    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');
+
+    // Look for context_window / input_tokens patterns in JSON lines
+    // Bounded quantifiers to avoid ReDoS on malformed input
+    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;
+
+    // Take the last occurrence of each
+    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 */ }
+  }
+}
+
+async function main() {
+  try {
+    const input = await readStdin();
+    const data = JSON.parse(input);
+
+    const toolName = data.tool_name || data.toolName || '';
+
+    if (!BLOCKED_TOOLS.has(toolName)) {
+      console.log(JSON.stringify({ continue: true, suppressOutput: true }));
+      return;
+    }
+
+    const transcriptPath = data.transcript_path || data.transcriptPath || '';
+    const pct = estimateContextPercent(transcriptPath);
+
+    if (pct >= THRESHOLD) {
+      process.stderr.write(
+        `[OMC] Context at ${pct}% (threshold: ${THRESHOLD}%). ` +
+        `Too high for ${toolName}. Run /compact or start a fresh session to free context.\n`
+      );
+      process.exit(2);
+    }
+
+    console.log(JSON.stringify({ continue: true, suppressOutput: true }));
+  } catch {
+    // On any error, allow the tool to proceed (never block on hook failure)
+    console.log(JSON.stringify({ continue: true, suppressOutput: true }));
+  }
+}
+
+main();