@su-record/vibe 2.12.5 → 2.13.0

package/hooks/scripts/lib/hook-context.js

@@ -0,0 +1,101 @@
+/**
+ * Hook 실행 컨텍스트 공용 헬퍼 — in-process 평탄화의 기반.
+ *
+ * 훅 스크립트는 두 모드로 실행된다:
+ *   1. in-process: 디스패처가 stdin을 1회 읽고 buildCtx()로 만든 ctx를
+ *      각 스크립트의 run(ctx)에 직접 전달 (자식 spawn 없음)
+ *   2. standalone CLI: antigravity-hooks.json / 기존 테스트가 스크립트를
+ *      직접 실행 — isDirectRun()으로 감지해 stdin/argv/env에서 ctx를 구성
+ *
+ * ctx 형태: { toolName, toolInput, payload, hookInput }
+ *   - toolName: payload.tool_name 우선, argv 폴백 (현행 각 스크립트와 동일 우선순위)
+ *   - toolInput: 문자열 정규화된 tool_input (payload → argv[3] → env.TOOL_INPUT)
+ *   - payload: 파싱된 stdin JSON 또는 null
+ *   - hookInput: stdin 원문 문자열 (code-check의 HOOK_INPUT 사용처 대체)
+ */
+import fs from 'fs';
+import { pathToFileURL } from 'url';
+
+/** stdin을 EOF까지 읽을 때 허용하는 최대 바이트 수 (10MB). */
+const STDIN_MAX_BYTES = 10 * 1024 * 1024;
+
+/**
+ * stdin에서 JSON 페이로드 동기 읽기 (Claude Code 하네스 호환).
+ * fd 0 직접 사용 — Windows는 '/dev/stdin'이 없음.
+ * 64KB 단일 버퍼 대신 EOF까지 청크 반복 읽기 (STDIN_MAX_BYTES 상한).
+ *
+ * @returns {{ raw: string|null, parsed: object|null, truncated: boolean }}
+ *   truncated=true: 페이로드가 STDIN_MAX_BYTES를 초과해 잘림
+ */
+export function readStdinSync() {
+  try {
+    if (process.stdin.isTTY) return { raw: null, parsed: null, truncated: false };
+
+    const chunks = [];
+    let totalBytes = 0;
+    let truncated = false;
+    const chunkSize = 65536;
+    const chunkBuf = Buffer.alloc(chunkSize);
+
+    while (true) {
+      let bytesRead;
+      try {
+        bytesRead = fs.readSync(0, chunkBuf, 0, chunkSize, null);
+      } catch (err) {
+        // EAGAIN: non-blocking stdin에 데이터 없음 → 루프 종료
+        if (err.code === 'EAGAIN') break;
+        throw err;
+      }
+      if (bytesRead === 0) break;
+      totalBytes += bytesRead;
+      if (totalBytes > STDIN_MAX_BYTES) {
+        truncated = true;
+        break;
+      }
+      chunks.push(Buffer.from(chunkBuf.subarray(0, bytesRead)));
+    }
+
+    if (chunks.length === 0) return { raw: null, parsed: null, truncated: false };
+
+    const raw = Buffer.concat(chunks).toString('utf-8');
+    try {
+      return { raw, parsed: JSON.parse(raw), truncated };
+    } catch {
+      return { raw, parsed: null, truncated };
+    }
+  } catch { /* stdin 없음 → 폴백 */ }
+  return { raw: null, parsed: null, truncated: false };
+}
+
+/**
+ * 실행 컨텍스트 구성. 우선순위는 현행 스크립트들과 동일:
+ *   toolName: payload.tool_name → argvToolName
+ *   toolInput: payload.tool_input(문자열화) → argv[3] → env.TOOL_INPUT
+ */
+export function buildCtx({ rawInput = null, payload = null, argvToolName = '', argvToolInput = '' } = {}) {
+  const toolName = payload?.tool_name || argvToolName || '';
+  const toolInput = payload?.tool_input !== undefined && payload?.tool_input !== null
+    ? (typeof payload.tool_input === 'string' ? payload.tool_input : JSON.stringify(payload.tool_input))
+    : (argvToolInput || process.env.TOOL_INPUT || '');
+  return { toolName, toolInput, payload, hookInput: rawInput };
+}
+
+/** standalone CLI 모드용 ctx — stdin/argv/env에서 구성 */
+export function buildCliCtx() {
+  const { raw, parsed } = readStdinSync();
+  return buildCtx({
+    rawInput: raw ?? process.env.HOOK_INPUT ?? null,
+    payload: parsed,
+    argvToolName: process.argv[2] || '',
+    argvToolInput: process.argv[3] || '',
+  });
+}
+
+/** 모듈이 `node <file>`로 직접 실행됐는지 감지 (import 시 false) */
+export function isDirectRun(importMetaUrl) {
+  try {
+    return Boolean(process.argv[1]) && importMetaUrl === pathToFileURL(process.argv[1]).href;
+  } catch {
+    return false;
+  }
+}

package/hooks/scripts/lib/pr-gate-runner.js

@@ -0,0 +1,62 @@
+/**
+ * PR 테스트 게이트 공유 헬퍼 — pr-test-gate.js와 pre-tool-guard.js가 공용.
+ *
+ * 테스트 커맨드 감지 → 실행 → 결과 반환.
+ * exit code를 직접 호출하지 않고 결과 객체를 반환한다 (호출자가 판단).
+ */
+import { execSync } from 'child_process';
+import { existsSync, readFileSync } from 'fs';
+import path from 'path';
+
+/**
+ * 프로젝트에서 실행할 테스트 커맨드를 감지한다.
+ *
+ * @param {string} projectDir
+ * @returns {string|null}
+ */
+export function detectTestCommand(projectDir) {
+  const pkgPath = path.join(projectDir, 'package.json');
+  if (existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+      if (pkg.scripts?.test && pkg.scripts.test !== 'echo "Error: no test specified" && exit 1') {
+        return 'npm test';
+      }
+    } catch { /* ignore */ }
+  }
+  // Python
+  if (existsSync(path.join(projectDir, 'pytest.ini')) || existsSync(path.join(projectDir, 'pyproject.toml'))) {
+    return 'python -m pytest --tb=short -q';
+  }
+  // Go
+  if (existsSync(path.join(projectDir, 'go.mod'))) {
+    return 'go test ./...';
+  }
+  return null;
+}
+
+/**
+ * 테스트 게이트를 실행한다.
+ *
+ * @param {string} projectDir
+ * @returns {{ passed: boolean, testCmd: string|null, output: string }}
+ *   testCmd=null 이면 테스트 없음 → passed=true (통과)
+ */
+export function runPrTestGate(projectDir) {
+  const testCmd = detectTestCommand(projectDir);
+  if (!testCmd) {
+    return { passed: true, testCmd: null, output: '' };
+  }
+
+  try {
+    execSync(testCmd, {
+      cwd: projectDir,
+      stdio: ['ignore', 'pipe', 'pipe'],
+      timeout: 120000,
+    });
+    return { passed: true, testCmd, output: '' };
+  } catch (err) {
+    const output = err.stdout ? err.stdout.toString().split('\n').slice(-5).join('\n') : '';
+    return { passed: false, testCmd, output };
+  }
+}

package/hooks/scripts/lib/run-ledger.js

@@ -0,0 +1,169 @@
+/**
+ * Run Ledger — vibe.run 실행 및 vibe.verify 결과 추적.
+ *
+ * 파일 위치: <projectDir>/.vibe/metrics/run-ledger.json
+ * 형식: { runStarted, runFeature, verifyPassed, verifyAt, stopWarned,
+ *         verifyRequired, verifyRequiredReason }
+ *
+ * 모든 함수는 fail-open (try/catch, 오류 시 null/false 반환).
+ * 원자적 쓰기: 임시 파일 → rename 방식 사용.
+ */
+
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+
+/** 레저 파일 경로 */
+function ledgerPath(projectDir) {
+  return path.join(projectDir, '.vibe', 'metrics', 'run-ledger.json');
+}
+
+/**
+ * 레저 파일 읽기.
+ * @param {string} projectDir
+ * @returns {{ runStarted: string|null, runFeature: string|null, verifyPassed: boolean, verifyAt: string|null, stopWarned: boolean, verifyRequired: boolean, verifyRequiredReason: string|null }|null}
+ */
+export function readLedger(projectDir) {
+  try {
+    const p = ledgerPath(projectDir);
+    if (!fs.existsSync(p)) return null;
+    return JSON.parse(fs.readFileSync(p, 'utf-8'));
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * 레저 파일 원자적 쓰기 (임시 파일 write → rename).
+ * @param {string} projectDir
+ * @param {object} data
+ * @returns {boolean} 성공 여부
+ */
+function writeLedger(projectDir, data) {
+  try {
+    const p = ledgerPath(projectDir);
+    fs.mkdirSync(path.dirname(p), { recursive: true });
+    const tmp = path.join(os.tmpdir(), `run-ledger-${process.pid}-${Date.now()}.tmp`);
+    fs.writeFileSync(tmp, JSON.stringify(data, null, 2), 'utf-8');
+    fs.renameSync(tmp, p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * vibe.run 시작 기록 — runStarted를 현재 시각으로 세팅하고 verifyPassed를 리셋.
+ * @param {string} projectDir
+ * @param {string|null} feature - 프롬프트에서 추출된 기능명 (없으면 null)
+ * @returns {boolean} 성공 여부
+ */
+export function recordRunStart(projectDir, feature) {
+  try {
+    const existing = readLedger(projectDir) || {};
+    const next = {
+      ...existing,
+      runStarted: new Date().toISOString(),
+      runFeature: feature || null,
+      verifyPassed: false,
+      verifyAt: null,
+      stopWarned: false,
+    };
+    return writeLedger(projectDir, next);
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * vibe.verify 결과 기록.
+ * pass 시 verifyRequired 상태를 클리어한다.
+ * @param {string} projectDir
+ * @param {boolean} passed - 검증 통과 여부
+ * @returns {boolean} 성공 여부
+ */
+export function recordVerify(projectDir, passed) {
+  try {
+    const existing = readLedger(projectDir) || {};
+    const next = {
+      ...existing,
+      verifyPassed: Boolean(passed),
+      verifyAt: new Date().toISOString(),
+    };
+    // pass 시 verifyRequired 클리어
+    if (passed) {
+      next.verifyRequired = false;
+      next.verifyRequiredReason = null;
+    }
+    return writeLedger(projectDir, next);
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * P1 이슈 발견 시 verify-required 상태 기록.
+ * @param {string} projectDir
+ * @param {string} reason - 이슈 사유
+ * @returns {boolean} 성공 여부
+ */
+export function recordVerifyRequired(projectDir, reason) {
+  try {
+    const existing = readLedger(projectDir) || {};
+    const next = {
+      ...existing,
+      verifyRequired: true,
+      verifyRequiredReason: reason || 'P1 issue detected',
+    };
+    return writeLedger(projectDir, next);
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * stop 경고 플래그 세팅 (루프 방지).
+ * @param {string} projectDir
+ * @returns {boolean} 성공 여부
+ */
+export function markStopWarned(projectDir) {
+  try {
+    const existing = readLedger(projectDir) || {};
+    const next = { ...existing, stopWarned: true };
+    return writeLedger(projectDir, next);
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * 프롬프트에서 vibe.run 기능명 추출.
+ * "/vibe.run some-feature ..." 또는 "$vibe.run some-feature ..." 형태에서 첫 토큰 추출.
+ * @param {string} prompt
+ * @returns {string|null}
+ */
+export function extractRunFeature(prompt) {
+  try {
+    const m = prompt.match(/(?:\/|\$)vibe\.run\s+([^\s]+)/i);
+    if (!m) return null;
+    const token = m[1];
+    // 플래그(-- 시작)나 키워드는 기능명이 아님
+    if (token.startsWith('-')) return null;
+    return token;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * 프롬프트에 vibe.run 호출이 포함되는지 확인 (단어 경계 매칭, 대소문자 무관).
+ * @param {string} prompt
+ * @returns {boolean}
+ */
+export function isVibeRunPrompt(prompt) {
+  try {
+    return /(?:^|[\s,;|&(])[$\/]vibe\.run(?:\b|$)/i.test(prompt);
+  } catch {
+    return false;
+  }
+}

package/hooks/scripts/lib/scope-from-spec.js

@@ -12,12 +12,26 @@ import path from 'path';
 
 const ACTIVE_STATUSES = new Set(['pending', 'in-progress', 'in_progress', 'active', 'running']);
 
+// status frontmatter 없는 SPEC을 활성으로 간주하는 최대 나이.
+// 오래된 status-없는 SPEC이 영구 활성으로 남아 stale scope를 만드는 것을 방지한다.
+const NO_STATUS_ACTIVE_MAX_AGE_DAYS = 14;
+const DAY_MS = 24 * 60 * 60 * 1000;
+
+function isRecentlyModified(file) {
+  try {
+    return Date.now() - fs.statSync(file).mtimeMs <= NO_STATUS_ACTIVE_MAX_AGE_DAYS * DAY_MS;
+  } catch {
+    return false;
+  }
+}
+
 /**
  * scope-guard auto-derive 활성 여부.
  *
- * 기본값은 **off**. 사용자가 `.vibe/config.json` 의 `scopeGuard.enabled = true` 로
- * 명시적으로 켤 때만 SPEC → scope.json 자동 합성을 수행한다. 이전 동작(자동 ON)은
- * SPEC 외부 파일 편집에 매번 경고를 띄워 다수 사용자에게 노이즈가 됐기 때문.
+ * 기본값은 **on**. `.vibe/config.json` 의 `scopeGuard.enabled = false` 로
+ * 명시적으로 끌 때만 SPEC → scope.json 자동 합성을 건너뛴다.
+ * 노이즈 가드: SPEC 파일이 존재할 때만 scope.json 을 생성하며,
+ * SPEC 없이 scope.json 생성이 필요한 경우 수동 작성(auto:false)을 사용한다.
  *
  * 이미 `auto: false` scope.json 을 직접 만들어 둔 사용자는 영향 없음 — scope-guard.js
  * 자체는 scope.json 존재 여부만 본다.
@@ -31,10 +45,10 @@ export function isScopeGuardEnabled(projectDir) {
     for (const p of candidates) {
       if (!fs.existsSync(p)) continue;
       const cfg = JSON.parse(fs.readFileSync(p, 'utf-8'));
-      if (cfg && cfg.scopeGuard && cfg.scopeGuard.enabled === true) return true;
+      if (cfg && cfg.scopeGuard && cfg.scopeGuard.enabled === false) return false;
     }
   } catch { /* ignore */ }
-  return false;
+  return true;
 }
 
 /**
@@ -181,7 +195,7 @@ export function findActiveSpecs(projectDir) {
       const content = fs.readFileSync(f, 'utf-8');
       const fm = readFrontmatter(content);
       const status = (fm.status || '').toLowerCase();
-      if (!fm.status) return true; // status 없으면 활성 간주
+      if (!fm.status) return isRecentlyModified(f); // status 없으면 최근 수정분만 활성 간주
       return ACTIVE_STATUSES.has(status);
     } catch { return false; }
   });
@@ -215,6 +229,7 @@ export function synthesizeScope(specFiles, { projectDir } = {}) {
   return {
     auto: true,
     mode: 'warn',
+    derivedCount: verified.length,
     allow,
     deny: [],
     reason: sourceNames.length > 0
@@ -262,6 +277,23 @@ export function syncScopeFile(projectDir) {
   }
 
   const next = synthesizeScope(specs, { projectDir });
+
+  // SPEC은 있으나 경로를 산출하지 못함 → defaultAllow만 남은 scope는
+  // 모든 소스 편집에 경고를 띄우는 노이즈가 된다. 생성하지 않고, 기존
+  // 자동 생성 파일이 있으면 제거한다.
+  if (next.derivedCount === 0) {
+    if (fs.existsSync(scopePath)) {
+      try {
+        const existing = JSON.parse(fs.readFileSync(scopePath, 'utf-8'));
+        if (existing.auto === true) {
+          fs.unlinkSync(scopePath);
+          return { action: 'removed', path: scopePath };
+        }
+      } catch { /* ignore */ }
+    }
+    return { action: 'skipped-no-paths', path: scopePath };
+  }
+
   const nextStr = JSON.stringify(next, null, 2);
 
   // 변경 없음 체크 (generatedAt 제외)
@@ -288,7 +320,7 @@ import { fileURLToPath } from 'url';
 if (process.argv[1] && fileURLToPath(import.meta.url) === path.resolve(process.argv[1])) {
   const dir = process.argv[2] || process.env.CLAUDE_PROJECT_DIR || process.cwd();
   if (!isScopeGuardEnabled(dir)) {
-    console.log('[scope-sync] · scopeGuard.enabled !== true — skipping (set in .vibe/config.json to opt in)');
+    console.log('[scope-sync] · scopeGuard.enabled=false — skipping (explicitly opted out in .vibe/config.json)');
     process.exit(0);
   }
   const result = syncScopeFile(dir);
@@ -299,6 +331,7 @@ if (process.argv[1] && fileURLToPath(import.meta.url) === path.resolve(process.a
     removed: '✓ scope.json removed (no active SPECs)',
     'skipped-manual': '· scope.json is manually managed (auto=false)',
     'skipped-no-specs': '· no active SPECs — scope.json not generated',
+    'skipped-no-paths': '· active SPECs contain no derivable paths — scope.json not generated',
   }[result.action] || result.action;
   console.log(`[scope-sync] ${label}`);
 }

package/hooks/scripts/post-edit-dispatcher.js

@@ -1,27 +1,100 @@
 #!/usr/bin/env node
 /**
- * PostToolUse dispatcher — Write/Edit 이후 순차 실행.
+ * PostToolUse dispatcher — Write/Edit 이후 후처리.
  *
- * 기존: PostToolUse.Write|Edit 배열에 3개 스크립트가 병렬 spawn (프로세스 피크 3배)
- *       + PostToolUse.Edit 추가로 post-edit.js 1개 더
- * 현재: 단일 디스패처에서 순차 실행. config.hooks.{name}.enabled로 개별 토글.
+ * in-process 평탄화 (2026-06): 자식 node spawn 없이 import 실행.
+ * 실작업(prettier/vitest 등)은 각 step이 자체 timeout을 가진 비동기 자식으로
+ * 실행하므로 step 간 병렬성(Promise.all)은 spawn 시절과 동일하게 유지된다.
  *
- * 실행 순서:
- *   1. auto-format — 코드 스타일 정규화
- *   2. code-check — 린트/품질 검사
- *   3. auto-test — 관련 테스트 실행
- *   4. post-edit — Edit 전용 후처리 (Write에서는 스크립트 내부에서 스킵)
+ * 실행 step (모두 비차단, config.hooks.{name}.enabled로 개별 토글):
+ *   auto-format — 코드 스타일 정규화 (변경 시 finding 반환)
+ *   code-check  — 린트/품질 검사 + P1 이슈 verifyRequired 기록
+ *   auto-test   — 관련 테스트 실행 (debounce 지원)
+ *   post-edit   — console.log 감지
  *
- * 실패 격리: 한 스크립트 실패해도 다음은 계속 진행.
+ * 출력 계약 (Claude Code PostToolUse):
+ *   findings 있음 → stdout에 JSON hookSpecificOutput 1개 출력, exit 0
+ *   findings 없음 → stdout 없음, exit 0
+ *   절대 exit 2 없음 — 차단은 downstream 게이트에서 (SPEC 설계 원칙)
+ *
+ * Codex 경로: codex-hook-adapter.js가 이 스크립트를 spawn하고
+ *   combinedOutput(stdout+stderr)을 writeAdditionalContext로 래핑함.
+ *   → stdout이 JSON hookSpecificOutput이면 어댑터가 이중 래핑함.
+ *   → 어댑터에서 JSON hookSpecificOutput 형식 감지 후 bypass 처리.
+ *
+ * 실패 격리: step별 try/catch — 한 step이 throw해도 나머지는 계속 진행.
  */
-import { dispatch } from './lib/dispatcher.js';
-
-try {
-  await dispatch([
-    { name: 'auto-format', script: 'auto-format.js' },
-    { name: 'code-check',  script: 'code-check.js'  },
-    { name: 'auto-test',   script: 'auto-test.js'   },
-    { name: 'post-edit',   script: 'post-edit.js'   },
-  ]);
-} catch { /* noise suppression */ }
+import { readStdinSync, buildCtx } from './lib/hook-context.js';
+import { readProjectConfig } from './utils.js';
+import fs from 'fs';
+import path from 'path';
+
+// ─── step 임포트 ─────────────────────────────────────────────────────
+import { run as autoFormat } from './auto-format.js';
+import { run as codeCheck } from './code-check.js';
+import { run as autoTest } from './auto-test.js';
+import { run as postEdit } from './post-edit.js';
+
+// ─── 설정 로딩 ────────────────────────────────────────────────────────
+function loadHookConfig() {
+  try {
+    return readProjectConfig()?.hooks || {};
+  } catch {
+    return {};
+  }
+}
+
+function isEnabled(hookConfig, name) {
+  const entry = hookConfig[name];
+  if (entry && typeof entry === 'object' && entry.enabled === false) return false;
+  return true;
+}
+
+// ─── 메인 ─────────────────────────────────────────────────────────────
+const { raw, parsed } = readStdinSync();
+const ctx = buildCtx({ rawInput: raw, payload: parsed });
+const hookConfig = loadHookConfig();
+
+const steps = [
+  { name: 'auto-format', run: autoFormat },
+  { name: 'code-check',  run: codeCheck  },
+  { name: 'auto-test',   run: autoTest   },
+  { name: 'post-edit',   run: postEdit   },
+];
+
+const enabledSteps = steps.filter(s => isEnabled(hookConfig, s.name));
+
+// 모든 step을 병렬 실행해 findings 수집
+const results = await Promise.all(
+  enabledSteps.map(async (step) => {
+    try {
+      const result = await step.run(ctx);
+      // findings 배열을 반환하는 새 구조 지원 + 구형 숫자 반환 폴백
+      if (result && typeof result === 'object' && Array.isArray(result.findings)) {
+        return result.findings;
+      }
+      return [];
+    } catch {
+      // 크래시 격리 — 해당 step만 건너뜀
+      return [];
+    }
+  })
+);
+
+const allFindings = results.flat().filter(f => typeof f === 'string' && f.trim().length > 0);
+
+// findings가 있을 때만 stdout 출력
+// Claude Code: JSON hookSpecificOutput → 모델이 additionalContext로 인식
+// findings 없음: 조용히 종료
+if (allFindings.length > 0) {
+  const summary = allFindings.join('\n');
+  const output = JSON.stringify({
+    hookSpecificOutput: {
+      hookEventName: 'PostToolUse',
+      additionalContext: summary,
+    },
+  });
+  process.stdout.write(output + '\n');
+}
+
 process.exit(0);

package/hooks/scripts/post-edit.js

@@ -3,33 +3,54 @@
  *
  * NOTE: tsc, prettier 제거 — 빌드/커밋 시점에 실행하므로 Edit마다 불필요
  * grep spawn 대신 fs.readFileSync + regex로 프로세스 오버헤드 제거
+ *
+ * findings를 console.log가 아닌 반환값으로 전달.
+ * (console.log 출력은 CC PostToolUse에서 transcript-only — 모델이 보지 못함)
  */
 import { existsSync, readFileSync } from 'fs';
 import path from 'path';
+import { buildCliCtx, isDirectRun } from './lib/hook-context.js';
 
-process.on('uncaughtException', () => {});
-process.on('unhandledRejection', () => {});
-
-const CONSOLE_LOG_RE = /console\.log/;
+const CONSOLE_LOG_RE = /console\.log\(/;
 const CODE_EXT_RE = /\.(ts|tsx|js|jsx|mjs|cjs)$/;
 
-try {
-  const input = JSON.parse(process.env.TOOL_INPUT || '{}');
-  const filePath = input.file_path || input.path || '';
+/**
+ * in-process 진입점 — console.log 감지만 수행.
+ * findings 배열 반환 (디스패처가 수집해 additionalContext에 주입).
+ * @param {{ toolInput: string }} ctx
+ * @returns {Promise<{ exitCode: number, findings: string[] }>}
+ */
+export async function run(ctx) {
+  const findings = [];
+  try {
+    const input = JSON.parse(ctx.toolInput || '{}');
+    const filePath = input.file_path || input.path || '';
 
-  if (filePath && CODE_EXT_RE.test(filePath)) {
-    const resolved = path.resolve(filePath);
-    if (existsSync(resolved)) {
-      const lines = readFileSync(resolved, 'utf-8').split('\n');
-      const hits = [];
-      for (let i = 0; i < lines.length && hits.length < 3; i++) {
-        if (CONSOLE_LOG_RE.test(lines[i])) hits.push(i + 1);
-      }
-      if (hits.length > 0) {
-        console.log(`[POST-EDIT] ${path.basename(resolved)}: console.log at line ${hits.join(',')}`);
+    if (filePath && CODE_EXT_RE.test(filePath)) {
+      const resolved = path.resolve(filePath);
+      if (existsSync(resolved)) {
+        const lines = readFileSync(resolved, 'utf-8').split('\n');
+        const hits = [];
+        for (let i = 0; i < lines.length && hits.length < 3; i++) {
+          if (CONSOLE_LOG_RE.test(lines[i])) hits.push(i + 1);
+        }
+        if (hits.length > 0) {
+          findings.push(`[POST-EDIT] ${path.basename(resolved)}: console.log at line ${hits.join(',')}`);
+        }
       }
     }
+  } catch {
+    // 조용히 실패
   }
-} catch {
-  // 조용히 실패
+  return { exitCode: 0, findings };
+}
+
+// standalone CLI 모드 — 전역 예외 흡수는 단독 프로세스일 때만 등록
+// (in-process import 시 디스패처의 전역 핸들러를 오염시키지 않도록)
+if (isDirectRun(import.meta.url)) {
+  process.on('uncaughtException', () => {});
+  process.on('unhandledRejection', () => {});
+  const { exitCode, findings } = await run(buildCliCtx());
+  if (findings.length > 0) process.stdout.write(findings.join('\n') + '\n');
+  process.exit(exitCode);
 }