claudecode-omc 4.8.4 → 4.9.4

package/scripts/context-guard-stop.mjs

@@ -28,6 +28,7 @@ import { readStdin } from './lib/stdin.mjs';
 const THRESHOLD = parseInt(process.env.OMC_CONTEXT_GUARD_THRESHOLD || '75', 10);
 const CRITICAL_THRESHOLD = 95;
 const MAX_BLOCKS = 2;
+const SESSION_ID_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9_-]{0,255}$/;
 
 /**
  * Detect if stop was triggered by context-limit related reasons.
@@ -171,9 +172,16 @@ function estimateContextPercent(transcriptPath) {
  * Retry guard: track how many times we've blocked this transcript.
  * Prevents infinite block loops by capping at MAX_BLOCKS.
  */
+function getGuardFilePath(sessionId) {
+  const configDir = process.env.CLAUDE_CONFIG_DIR || join(homedir(), '.claude');
+  const guardDir = join(configDir, 'projects', '.omc-guards');
+  mkdirSync(guardDir, { recursive: true, mode: 0o700 });
+  return join(guardDir, `context-guard-${sessionId}.json`);
+}
+
 function getBlockCount(sessionId) {
-  if (!sessionId) return 0;
-  const guardFile = join(tmpdir(), `omc-context-guard-${sessionId}.json`);
+  if (!sessionId || !SESSION_ID_PATTERN.test(sessionId)) return 0;
+  const guardFile = getGuardFilePath(sessionId);
   try {
     if (existsSync(guardFile)) {
       const data = JSON.parse(readFileSync(guardFile, 'utf-8'));
@@ -184,15 +192,15 @@ function getBlockCount(sessionId) {
 }
 
 function incrementBlockCount(sessionId) {
-  if (!sessionId) return;
-  const guardFile = join(tmpdir(), `omc-context-guard-${sessionId}.json`);
+  if (!sessionId || !SESSION_ID_PATTERN.test(sessionId)) return;
+  const guardFile = getGuardFilePath(sessionId);
   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 }));
+    writeFileSync(guardFile, JSON.stringify({ blockCount: count + 1 }), { mode: 0o600 });
   } catch { /* ignore */ }
 }
 

package/scripts/context-safety.mjs

@@ -1,165 +1,28 @@
 #!/usr/bin/env node
 
 /**
- * OMC Context Safety Hook (PreToolUse)
+ * OMC Context Safety Hook (PreToolUse) - compatibility no-op
  *
- * 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.
+ * TeamCreate was removed from this guard in #1006 because blocking lightweight
+ * orchestration setup caused silent fallback behavior. ExitPlanMode was removed
+ * in #1597 because blocking a lightweight plan-mode exit traps long-running
+ * planning skills such as /deep-interview in irreversible approval loops once
+ * context crosses the warning threshold.
  *
- * 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
+ * The script remains as a permissive compatibility shim so older patched hook
+ * installations that still point at scripts/context-safety.mjs do not fail.
  */
 
-import { existsSync, statSync, openSync, readSync, closeSync } from 'node:fs';
-import { join, dirname, resolve } from 'node:path';
-import { homedir } from 'node:os';
-import { execSync } from 'node:child_process';
 import { readStdin } from './lib/stdin.mjs';
 
-/**
- * Resolve a transcript path that may be mismatched in worktree sessions (issue #1094).
- * When Claude Code runs inside .claude/worktrees/X, the encoded project directory
- * contains `--claude-worktrees-X` which doesn't exist. Strip it to find the real path.
- */
-function resolveTranscriptPath(transcriptPath, cwd) {
-  if (!transcriptPath) return transcriptPath;
-  try {
-    if (existsSync(transcriptPath)) return transcriptPath;
-  } catch { /* fallthrough */ }
-
-  // Strategy 1: Strip Claude worktree segment from encoded project directory
-  const worktreePattern = /--claude-worktrees-[^/\\]+/;
-  if (worktreePattern.test(transcriptPath)) {
-    const resolved = transcriptPath.replace(worktreePattern, '');
-    try {
-      if (existsSync(resolved)) return resolved;
-    } catch { /* fallthrough */ }
-  }
-
-  // Strategy 2: Detect native git worktree via git-common-dir.
-  // When CWD is a linked worktree (created by `git worktree add`), the
-  // transcript path encodes the worktree CWD, but the file lives under
-  // the main repo's encoded path.
-  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 absoluteCommonDir = resolve(effectiveCwd, gitCommonDir);
-    const mainRepoRoot = dirname(absoluteCommonDir);
-
-    const worktreeTop = execSync('git rev-parse --show-toplevel', {
-      cwd: effectiveCwd,
-      encoding: 'utf-8',
-      stdio: ['pipe', 'pipe', 'pipe'],
-    }).trim();
-
-    if (mainRepoRoot !== worktreeTop) {
-      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 projectsDir = join(configDir, 'projects');
-        if (existsSync(projectsDir)) {
-          const encodedMain = mainRepoRoot.replace(/[/\\]/g, '-');
-          const resolvedPath = join(projectsDir, encodedMain, sessionFile);
-          try {
-            if (existsSync(resolvedPath)) return resolvedPath;
-          } catch { /* fallthrough */ }
-        }
-      }
-    }
-  } catch { /* not in a git repo or git not available — skip */ }
-
-  return transcriptPath;
-}
-
-const THRESHOLD = parseInt(process.env.OMC_CONTEXT_SAFETY_THRESHOLD || '55', 10);
-// TeamCreate was removed from BLOCKED_TOOLS in issue #1006.
-// Blocking TeamCreate at high context caused silent fallback to regular subagents,
-// defeating the team orchestration pipeline. TeamCreate is lightweight infrastructure
-// setup, not expensive model inference, so context pressure is not a concern.
-const BLOCKED_TOOLS = new Set(['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 rawTranscriptPath = data.transcript_path || data.transcriptPath || '';
-    const transcriptPath = resolveTranscriptPath(rawTranscriptPath, data.cwd);
-    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 }));
+    await readStdin();
   } catch {
-    // On any error, allow the tool to proceed (never block on hook failure)
-    console.log(JSON.stringify({ continue: true, suppressOutput: true }));
+    // Ignore malformed input - this hook is intentionally permissive.
   }
+
+  console.log(JSON.stringify({ continue: true, suppressOutput: true }));
 }
 
 main();

package/scripts/eval-autoresearch-json.mjs

@@ -0,0 +1,49 @@
+import { execSync } from 'node:child_process';
+
+function run(cmd) {
+  return execSync(cmd, {
+    stdio: 'pipe',
+    encoding: 'utf8',
+  });
+}
+
+function passedTestFiles(output) {
+  const match = output.match(/Test Files\s+(\d+) passed/i);
+  return match ? Number(match[1]) : 0;
+}
+
+function passedTests(output) {
+  const match = output.match(/Tests\s+(\d+) passed/i);
+  return match ? Number(match[1]) : 0;
+}
+
+try {
+  const runtimeOutput = run('npm run test:run -- src/autoresearch/__tests__/runtime.test.ts src/autoresearch/__tests__/runtime-parity-extra.test.ts');
+  const cliOutput = run('npm test -- --run src/cli/__tests__/autoresearch.test.ts src/cli/__tests__/autoresearch-guided.test.ts');
+  run('npm run build');
+
+  const runtimeFiles = passedTestFiles(runtimeOutput);
+  const runtimeTests = passedTests(runtimeOutput);
+  const cliFiles = passedTestFiles(cliOutput);
+  const cliTests = passedTests(cliOutput);
+  const score = runtimeTests + cliTests + (runtimeFiles * 5) + (cliFiles * 5) + 10;
+
+  process.stdout.write(JSON.stringify({
+    pass: true,
+    score,
+    details: {
+      runtime_test_files: runtimeFiles,
+      runtime_tests: runtimeTests,
+      cli_test_files: cliFiles,
+      cli_tests: cliTests,
+      build: 'pass',
+    },
+  }));
+} catch (error) {
+  const stdout = error && typeof error === 'object' && 'stdout' in error ? String(error.stdout || '') : '';
+  const stderr = error && typeof error === 'object' && 'stderr' in error ? String(error.stderr || '') : '';
+  process.stdout.write(JSON.stringify({
+    pass: false,
+    details: { stdout, stderr },
+  }));
+}

package/scripts/eval-autoresearch-timed-json.mjs

@@ -0,0 +1,62 @@
+import { execSync } from 'node:child_process';
+
+function run(cmd) {
+  const start = Date.now();
+  const output = execSync(cmd, {
+    stdio: 'pipe',
+    encoding: 'utf8',
+  });
+  const durationMs = Date.now() - start;
+  return { output, durationMs };
+}
+
+function passedTestFiles(output) {
+  const match = output.match(/Test Files\s+(\d+) passed/i);
+  return match ? Number(match[1]) : 0;
+}
+
+function passedTests(output) {
+  const match = output.match(/Tests\s+(\d+) passed/i);
+  return match ? Number(match[1]) : 0;
+}
+
+try {
+  const runtime = run('npm run test:run -- src/autoresearch/__tests__/runtime.test.ts src/autoresearch/__tests__/runtime-parity-extra.test.ts');
+  const cli = run('npm test -- --run src/cli/__tests__/autoresearch.test.ts src/cli/__tests__/autoresearch-guided.test.ts');
+  const build = run('npm run build');
+
+  const runtimeFiles = passedTestFiles(runtime.output);
+  const runtimeTests = passedTests(runtime.output);
+  const cliFiles = passedTestFiles(cli.output);
+  const cliTests = passedTests(cli.output);
+
+  const totalMs = runtime.durationMs + cli.durationMs + build.durationMs;
+  const correctnessScore = runtimeTests + cliTests + (runtimeFiles * 5) + (cliFiles * 5) + 10;
+  const speedBonus = Math.max(0, Math.round((120000 - totalMs) / 1000));
+  const score = correctnessScore + speedBonus;
+
+  process.stdout.write(JSON.stringify({
+    pass: true,
+    score,
+    details: {
+      runtime_test_files: runtimeFiles,
+      runtime_tests: runtimeTests,
+      runtime_ms: runtime.durationMs,
+      cli_test_files: cliFiles,
+      cli_tests: cliTests,
+      cli_ms: cli.durationMs,
+      build_ms: build.durationMs,
+      total_ms: totalMs,
+      correctness_score: correctnessScore,
+      speed_bonus: speedBonus,
+      build: 'pass'
+    }
+  }));
+} catch (error) {
+  const stdout = error && typeof error === 'object' && 'stdout' in error ? String(error.stdout || '') : '';
+  const stderr = error && typeof error === 'object' && 'stderr' in error ? String(error.stderr || '') : '';
+  process.stdout.write(JSON.stringify({
+    pass: false,
+    details: { stdout, stderr }
+  }));
+}

package/scripts/generate-featured-contributors.ts

@@ -0,0 +1,43 @@
+#!/usr/bin/env node
+
+import { pathToFileURL } from 'url';
+import {
+  collectFeaturedContributors,
+  extractRepoSlug,
+  FEATURED_CONTRIBUTORS_END_MARKER,
+  FEATURED_CONTRIBUTORS_MIN_STARS,
+  FEATURED_CONTRIBUTORS_START_MARKER,
+  FEATURED_CONTRIBUTORS_TITLE,
+  formatStarCount,
+  loadRepoSlugFromPackageJson,
+  pickTopPersonalRepo,
+  renderFeaturedContributorsSection,
+  runFeaturedContributorsCli,
+  sortFeaturedContributors,
+  syncFeaturedContributorsReadme,
+  upsertFeaturedContributorsSection,
+} from '../src/lib/featured-contributors.js';
+
+if (import.meta.url === pathToFileURL(process.argv[1]).href) {
+  runFeaturedContributorsCli().catch((error) => {
+    console.error(error instanceof Error ? error.message : error);
+    process.exit(1);
+  });
+}
+
+export {
+  collectFeaturedContributors,
+  extractRepoSlug,
+  FEATURED_CONTRIBUTORS_END_MARKER,
+  FEATURED_CONTRIBUTORS_MIN_STARS,
+  FEATURED_CONTRIBUTORS_START_MARKER,
+  FEATURED_CONTRIBUTORS_TITLE,
+  formatStarCount,
+  loadRepoSlugFromPackageJson,
+  pickTopPersonalRepo,
+  renderFeaturedContributorsSection,
+  runFeaturedContributorsCli,
+  sortFeaturedContributors,
+  syncFeaturedContributorsReadme,
+  upsertFeaturedContributorsSection,
+};

package/scripts/keyword-detector.mjs

@@ -125,17 +125,81 @@ function sanitizeForKeywordDetection(text) {
     .replace(/`[^`]+`/g, '');
 }
 
+const INFORMATIONAL_INTENT_PATTERNS = [
+  /\b(?:what(?:'s|\s+is)|what\s+are|how\s+(?:to|do\s+i)\s+use|explain|explanation|tell\s+me\s+about|describe)\b/i,
+  /(?:뭐야|뭔데|무엇(?:이야|인가요)?|어떻게|설명|사용법|알려\s?줘|알려줄래|소개해?\s?줘|소개\s*부탁|설명해\s?줘|뭐가\s*달라|어떤\s*기능|기능\s*(?:알려|설명|뭐)|방법\s*(?:알려|설명|뭐))/u,
+  /(?:とは|って何|使い方|説明)/u,
+  /(?:什么是|什麼是|怎(?:么|樣)用|如何使用|解释|說明|说明)/u,
+];
+const INFORMATIONAL_CONTEXT_WINDOW = 80;
+
+function isInformationalKeywordContext(text, position, keywordLength) {
+  const start = Math.max(0, position - INFORMATIONAL_CONTEXT_WINDOW);
+  const end = Math.min(text.length, position + keywordLength + INFORMATIONAL_CONTEXT_WINDOW);
+  const context = text.slice(start, end);
+  return INFORMATIONAL_INTENT_PATTERNS.some((pattern) => pattern.test(context));
+}
+
+function hasActionableKeyword(text, pattern) {
+  const flags = pattern.flags.includes('g') ? pattern.flags : `${pattern.flags}g`;
+  const globalPattern = new RegExp(pattern.source, flags);
+
+  for (const match of text.matchAll(globalPattern)) {
+    if (match.index === undefined) {
+      continue;
+    }
+
+    if (isInformationalKeywordContext(text, match.index, match[0].length)) {
+      continue;
+    }
+
+    return true;
+  }
+
+  return false;
+}
+
 // Create state file for a mode
 function activateState(directory, prompt, stateName, sessionId) {
-  const state = {
-    active: true,
-    started_at: new Date().toISOString(),
-    original_prompt: prompt,
-    session_id: sessionId || undefined,
-    project_path: directory,
-    reinforcement_count: 0,
-    last_checked_at: new Date().toISOString()
-  };
+  let state;
+
+  if (stateName === 'ralph') {
+    // Ralph needs specific fields for proper loop tracking
+    state = {
+      active: true,
+      iteration: 1,
+      max_iterations: 100,
+      started_at: new Date().toISOString(),
+      prompt: prompt,
+      session_id: sessionId || undefined,
+      project_path: directory,
+      linked_ultrawork: true,
+      awaiting_confirmation: true,
+      last_checked_at: new Date().toISOString()
+    };
+  } else if (stateName === 'ralplan') {
+    // Ralplan needs active + session_id for stop-hook enforcement
+    state = {
+      active: true,
+      started_at: new Date().toISOString(),
+      session_id: sessionId || undefined,
+      project_path: directory,
+      awaiting_confirmation: true,
+      last_checked_at: new Date().toISOString()
+    };
+  } else {
+    // Generic state for ultrawork, autopilot, etc.
+    state = {
+      active: true,
+      started_at: new Date().toISOString(),
+      original_prompt: prompt,
+      session_id: sessionId || undefined,
+      project_path: directory,
+      reinforcement_count: 0,
+      awaiting_confirmation: true,
+      last_checked_at: new Date().toISOString()
+    };
+  }
 
   // Write to session-scoped path if sessionId available
   if (sessionId && /^[a-zA-Z0-9][a-zA-Z0-9_-]{0,255}$/.test(sessionId)) {
@@ -144,10 +208,10 @@ function activateState(directory, prompt, stateName, sessionId) {
       try { mkdirSync(sessionDir, { recursive: true }); } catch {}
     }
     try { writeFileSync(join(sessionDir, `${stateName}-state.json`), JSON.stringify(state, null, 2), { mode: 0o600 }); } catch {}
-    return; // Session-only write, skip legacy
+    return;
   }
 
-  // Fallback: write to legacy local .omc/state directory (no valid sessionId)
+  // Fallback: write to legacy local .omc/state directory
   const localDir = join(directory, '.omc', 'state');
   if (!existsSync(localDir)) {
     try { mkdirSync(localDir, { recursive: true }); } catch {}
@@ -367,30 +431,30 @@ async function main() {
     const matches = [];
 
     // Cancel keywords
-    if (/\b(cancelomc|stopomc)\b/i.test(cleanPrompt)) {
+    if (hasActionableKeyword(cleanPrompt, /\b(cancelomc|stopomc)\b/i)) {
       matches.push({ name: 'cancel', args: '' });
     }
 
     // Ralph keywords
-    if (/\b(ralph|don't stop|must complete|until done)\b/i.test(cleanPrompt)) {
+    if (hasActionableKeyword(cleanPrompt, /\b(ralph|don't stop|must complete|until done)\b|(랄프)/i)) {
       matches.push({ name: 'ralph', args: '' });
     }
 
     // Autopilot keywords
-    if (/\b(autopilot|auto pilot|auto-pilot|autonomous|full auto|fullsend)\b/i.test(cleanPrompt) ||
-        /\b(build|create|make)\s+me\s+(an?\s+)?(app|feature|project|tool|plugin|website|api|server|cli|script|system|service|dashboard|bot|extension)\b/i.test(cleanPrompt) ||
-        /\bi\s+want\s+a\s+/i.test(cleanPrompt) ||
-        /\bi\s+want\s+an\s+/i.test(cleanPrompt) ||
-        /\bhandle\s+it\s+all\b/i.test(cleanPrompt) ||
-        /\bend\s+to\s+end\b/i.test(cleanPrompt) ||
-        /\be2e\s+this\b/i.test(cleanPrompt)) {
+    if (hasActionableKeyword(cleanPrompt, /\b(autopilot|auto pilot|auto-pilot|autonomous|full auto|fullsend)\b|(오토파일럿)/i) ||
+        hasActionableKeyword(cleanPrompt, /\b(build|create|make)\s+me\s+(an?\s+)?(app|feature|project|tool|plugin|website|api|server|cli|script|system|service|dashboard|bot|extension)\b/i) ||
+        hasActionableKeyword(cleanPrompt, /\bi\s+want\s+a\s+/i) ||
+        hasActionableKeyword(cleanPrompt, /\bi\s+want\s+an\s+/i) ||
+        hasActionableKeyword(cleanPrompt, /\bhandle\s+it\s+all\b/i) ||
+        hasActionableKeyword(cleanPrompt, /\bend\s+to\s+end\b/i) ||
+        hasActionableKeyword(cleanPrompt, /\be2e\s+this\b/i)) {
       matches.push({ name: 'autopilot', args: '' });
     }
 
     // Ultrapilot keywords removed — routed to team which is now explicit-only (/team).
 
     // Ultrawork keywords
-    if (/\b(ultrawork|ulw|uw)\b/i.test(cleanPrompt)) {
+    if (hasActionableKeyword(cleanPrompt, /\b(ultrawork|ulw|uw)\b|(울트라워크)/i)) {
       matches.push({ name: 'ultrawork', args: '' });
     }
 
@@ -400,17 +464,17 @@ async function main() {
 
 
     // CCG keywords (Claude-Codex-Gemini tri-model orchestration)
-    if (/\b(ccg|claude-codex-gemini)\b/i.test(cleanPrompt)) {
+    if (hasActionableKeyword(cleanPrompt, /\b(ccg|claude-codex-gemini)\b|(씨씨지)/i)) {
       matches.push({ name: 'ccg', args: '' });
     }
 
     // Ralplan keyword
-    if (/\b(ralplan)\b/i.test(cleanPrompt)) {
+    if (hasActionableKeyword(cleanPrompt, /\b(ralplan)\b|(랄플랜)/i)) {
       matches.push({ name: 'ralplan', args: '' });
     }
 
     // Deep interview keywords
-    if (/\b(deep[\s-]interview|ouroboros)\b/i.test(cleanPrompt)) {
+    if (hasActionableKeyword(cleanPrompt, /\b(deep[\s-]interview|ouroboros)\b|(딥인터뷰)/i)) {
       matches.push({ name: 'deep-interview', args: '' });
     }
 
@@ -420,36 +484,36 @@ async function main() {
     }
 
     // TDD keywords
-    if (/\b(tdd)\b/i.test(cleanPrompt) ||
-        /\btest\s+first\b/i.test(cleanPrompt) ||
-        /\bred\s+green\b/i.test(cleanPrompt)) {
+    if (hasActionableKeyword(cleanPrompt, /\b(tdd)\b|(테스트\s?퍼스트)/i) ||
+        hasActionableKeyword(cleanPrompt, /\btest\s+first\b/i) ||
+        hasActionableKeyword(cleanPrompt, /\bred\s+green\b/i)) {
       matches.push({ name: 'tdd', args: '' });
     }
 
     // Code review keywords
-    if (/\b(code\s+review|review\s+code)\b/i.test(cleanPrompt)) {
+    if (hasActionableKeyword(cleanPrompt, /\b(code\s+review|review\s+code)\b|(코드\s?리뷰)(?!어)/i)) {
       matches.push({ name: 'code-review', args: '' });
     }
 
     // Security review keywords
-    if (/\b(security\s+review|review\s+security)\b/i.test(cleanPrompt)) {
+    if (hasActionableKeyword(cleanPrompt, /\b(security\s+review|review\s+security)\b|(보안\s?리뷰)(?!어)/i)) {
       matches.push({ name: 'security-review', args: '' });
     }
 
     // Ultrathink keywords
-    if (/\b(ultrathink|think hard|think deeply)\b/i.test(cleanPrompt)) {
+    if (hasActionableKeyword(cleanPrompt, /\b(ultrathink|think hard|think deeply)\b|(울트라씽크)/i)) {
       matches.push({ name: 'ultrathink', args: '' });
     }
 
     // Deepsearch keywords
-    if (/\b(deepsearch)\b/i.test(cleanPrompt) ||
-        /\bsearch\s+(the\s+)?(codebase|code|files?|project)\b/i.test(cleanPrompt) ||
-        /\bfind\s+(in\s+)?(codebase|code|all\s+files?)\b/i.test(cleanPrompt)) {
+    if (hasActionableKeyword(cleanPrompt, /\b(deepsearch)\b|(딥\s?서치)/i) ||
+        hasActionableKeyword(cleanPrompt, /\bsearch\s+(the\s+)?(codebase|code|files?|project)\b/i) ||
+        hasActionableKeyword(cleanPrompt, /\bfind\s+(in\s+)?(codebase|code|all\s+files?)\b/i)) {
       matches.push({ name: 'deepsearch', args: '' });
     }
 
     // Analyze keywords
-    if (/\b(deep[\s-]?analyze|deepanalyze)\b/i.test(cleanPrompt)) {
+    if (hasActionableKeyword(cleanPrompt, /\b(deep[\s-]?analyze|deepanalyze)\b|(딥\s?분석)/i)) {
       matches.push({ name: 'analyze', args: '' });
     }
 
@@ -476,6 +540,42 @@ async function main() {
     let tracer = null;
     try { tracer = await import('../dist/hooks/subagent-tracker/flow-tracer.js'); } catch { /* silent */ }
 
+    // Import follow-up planner modules (best-effort — requires npm run build)
+    let followupPlanner = null;
+    let planningArtifacts = null;
+    try {
+      followupPlanner = await import('../dist/team/followup-planner.js');
+      planningArtifacts = await import('../dist/planning/artifacts.js');
+    } catch { /* silent — dist/ may not exist yet */ }
+
+    // Check for approved follow-up shortcut: bypass ralplan gate when a prior ralplan
+    // cycle completed and left an approved plan with a launch hint.
+    if (followupPlanner && planningArtifacts) {
+      // Detect if ralplan state exists (was recently active) — serves as "prior skill = ralplan" signal
+      const ralplanStatePath = sessionId && /^[a-zA-Z0-9][a-zA-Z0-9_-]{0,255}$/.test(sessionId)
+        ? join(directory, '.omc', 'state', 'sessions', sessionId, 'ralplan-state.json')
+        : join(directory, '.omc', 'state', 'ralplan-state.json');
+      const ralplanWasActive = existsSync(ralplanStatePath);
+
+      if (ralplanWasActive) {
+        const artifacts = planningArtifacts.readPlanningArtifacts(directory);
+        const planningComplete = planningArtifacts.isPlanningComplete(artifacts);
+        const context = { planningComplete, priorSkill: 'ralplan' };
+
+        const isTeamFollowup = followupPlanner.isApprovedExecutionFollowupShortcut('team', prompt, context);
+        const isRalphFollowup = followupPlanner.isApprovedExecutionFollowupShortcut('ralph', prompt, context);
+
+        if (isTeamFollowup) {
+          console.log(JSON.stringify(createHookOutput(createSkillInvocation('team', prompt))));
+          return;
+        }
+        if (isRalphFollowup) {
+          console.log(JSON.stringify(createHookOutput(createSkillInvocation('ralph', prompt))));
+          return;
+        }
+      }
+    }
+
     // Record detected keywords to flow trace
     if (tracer) {
       for (const match of resolved) {
@@ -485,13 +585,13 @@ async function main() {
 
     // Handle cancel specially - clear states and emit
     if (resolved.length > 0 && resolved[0].name === 'cancel') {
-      clearStateFiles(directory, ['ralph', 'autopilot', 'ultrawork', 'swarm'], sessionId);
+      clearStateFiles(directory, ['ralph', 'autopilot', 'ultrawork', 'swarm', 'ralplan'], sessionId);
       console.log(JSON.stringify(createHookOutput(createSkillInvocation('cancel', prompt))));
       return;
     }
 
     // Activate states for modes that need them (team removed — explicit-only via /team skill)
-    const stateModes = resolved.filter(m => ['ralph', 'autopilot', 'ultrawork'].includes(m.name));
+    const stateModes = resolved.filter(m => ['ralph', 'autopilot', 'ultrawork', 'ralplan'].includes(m.name));
     for (const mode of stateModes) {
       activateState(directory, prompt, mode.name, sessionId);
     }