@su-record/vibe 2.12.4 → 2.13.0

package/hooks/hooks.json

@@ -1,5 +1,5 @@
 {
-  "_comment": "Dispatcher pattern — PreToolUse/PostToolUse/Stop는 단일 디스패처가 stdin을 한 번 읽어 순차 실행 (병렬 spawn 폭주 제거, cascade 격리, config.hooks.{name}.enabled 토글 지원). UserPromptSubmit은 VIBE_HOOK_DEPTH 재귀 가드 탑재된 prompt-dispatcher 사용.",
+  "_comment": "Dispatcher pattern — PreToolUse/PostToolUse/Stop는 단일 디스패처가 stdin을 한 번 읽어 순차 실행 (병렬 spawn 폭주 제거, cascade 격리, config.hooks.{name}.enabled 토글 지원). UserPromptSubmit은 VIBE_HOOK_DEPTH 재귀 가드 탑재된 prompt-dispatcher 사용. SessionStart matcher가 compact를 제외하는 이유: session-start.js가 컨텍스트 앞단에 현재 시각/24h 카운트 등 동적 값을 주입하므로, compact마다 재발화하면 압축 후 프리픽스가 매번 달라져 prefix cache를 무효화한다.",
   "permissions": {
     "allow": [],
     "deny": [],
@@ -8,6 +8,7 @@
   "hooks": {
     "SessionStart": [
       {
+        "matcher": "startup|resume|clear",
         "hooks": [
           {
             "type": "command",
@@ -65,6 +66,7 @@
         ]
       },
       {
+        "matcher": "Edit|Write|Bash|Task|SlashCommand|NotebookEdit",
         "hooks": [
           {
             "type": "command",
@@ -74,14 +76,6 @@
       }
     ],
     "UserPromptSubmit": [
-      {
-        "hooks": [
-          {
-            "type": "command",
-            "command": "echo '[INTERRUPT RULE] If this message follows a user interrupt (Ctrl+C/Escape), the previous task is CANCELLED. Do NOT resume interrupted work. Respond ONLY to this new message.'"
-          }
-        ]
-      },
       {
         "hooks": [
           {

package/hooks/scripts/__tests__/.vibe/command-log.txt

@@ -0,0 +1,39 @@
+[2026-06-10T07:48:43.637Z] rm -rf /
+[2026-06-10T07:48:43.682Z] ls -la
+[2026-06-10T07:48:43.728Z] rm -rf src/infra/lib/autonomy/
+[2026-06-10T07:48:46.450Z] rm -rf /
+[2026-06-10T07:48:46.533Z] ls -la
+[2026-06-10T07:48:46.615Z] rm -rf src/infra/lib/autonomy/
+[2026-06-10T23:31:11.461Z] rm -rf /
+[2026-06-10T23:31:11.532Z] ls -la
+[2026-06-10T23:31:11.610Z] rm -rf src/infra/lib/autonomy/
+[2026-06-11T00:54:20.384Z] rm -rf /
+[2026-06-11T00:54:20.472Z] ls -la
+[2026-06-11T00:54:20.544Z] rm -rf src/infra/lib/autonomy/
+[2026-06-11T00:55:23.164Z] rm -rf /
+[2026-06-11T00:55:23.258Z] ls -la
+[2026-06-11T00:55:23.351Z] rm -rf src/infra/lib/autonomy/
+[2026-06-11T01:04:45.163Z] rm -rf /
+[2026-06-11T01:04:45.246Z] ls -la
+[2026-06-11T01:04:45.326Z] rm -rf src/infra/lib/autonomy/
+[2026-06-11T01:05:19.173Z] rm -rf /
+[2026-06-11T01:05:19.280Z] ls -la
+[2026-06-11T01:05:19.346Z] rm -rf src/infra/lib/autonomy/
+[2026-06-11T01:20:55.438Z] rm -rf /
+[2026-06-11T01:20:55.530Z] ls -la
+[2026-06-11T01:20:55.622Z] rm -rf src/infra/lib/autonomy/
+[2026-06-11T01:21:25.176Z] rm -rf /
+[2026-06-11T01:21:25.271Z] ls -la
+[2026-06-11T01:21:25.380Z] rm -rf src/infra/lib/evolution/
+[2026-06-11T01:21:40.631Z] rm -rf /
+[2026-06-11T01:21:40.715Z] ls -la
+[2026-06-11T01:21:40.789Z] rm -rf src/infra/lib/evolution/
+[2026-06-11T01:21:58.442Z] rm -rf /
+[2026-06-11T01:21:58.547Z] ls -la
+[2026-06-11T01:21:58.640Z] rm -rf src/infra/lib/evolution/
+[2026-06-11T01:22:15.393Z] rm -rf /
+[2026-06-11T01:22:15.536Z] ls -la
+[2026-06-11T01:22:15.628Z] rm -rf src/infra/lib/evolution/
+[2026-06-11T01:30:46.209Z] rm -rf /
+[2026-06-11T01:30:46.279Z] ls -la
+[2026-06-11T01:30:46.366Z] rm -rf src/infra/lib/evolution/

package/hooks/scripts/__tests__/auto-test-debounce.test.js

@@ -0,0 +1,145 @@
+/**
+ * auto-test.js debounce 테스트
+ *
+ * 검증 대상:
+ *   - debounce 모드에서 쿨다운 내 + 소스 미변경 → 스킵
+ *   - 쿨다운 만료 → 재실행
+ *   - 소스 변경 → 재실행
+ *   - mode='off' → 실행 안 함
+ *   - mode='always' → debounce 없이 항상 실행 시도
+ */
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { fileURLToPath } from 'url';
+import path from 'path';
+import fs from 'fs';
+import os from 'os';
+import { createHash } from 'crypto';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+let tmpDir;
+beforeEach(() => {
+  tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'vibe-autotest-debounce-'));
+});
+afterEach(() => {
+  try { fs.rmSync(tmpDir, { recursive: true, force: true }); } catch { /* ignore */ }
+});
+
+// debounce 로직 단위 테스트 (auto-test.js와 동일 알고리즘)
+const DEBOUNCE_COOLDOWN_MS = 120_000;
+
+function fileHash(filePath) {
+  try {
+    const content = fs.readFileSync(filePath, 'utf-8');
+    return createHash('sha256').update(content).digest('hex').slice(0, 16);
+  } catch {
+    return '';
+  }
+}
+
+function makeDebounceHelpers(stateFile) {
+  function readState() {
+    try {
+      if (fs.existsSync(stateFile)) return JSON.parse(fs.readFileSync(stateFile, 'utf-8'));
+    } catch { /* ignore */ }
+    return {};
+  }
+
+  function writeState(state) {
+    try {
+      fs.mkdirSync(path.dirname(stateFile), { recursive: true });
+      fs.writeFileSync(stateFile, JSON.stringify(state, null, 2), 'utf-8');
+    } catch { /* ignore */ }
+  }
+
+  function shouldSkip(testFile, srcFile) {
+    try {
+      const state = readState();
+      const entry = state[testFile];
+      if (!entry) return false;
+      const elapsed = Date.now() - entry.lastRun;
+      if (elapsed > DEBOUNCE_COOLDOWN_MS) return false;
+      const currentHash = fileHash(srcFile);
+      if (currentHash !== entry.srcHash) return false;
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  function updateState(testFile, srcFile) {
+    const state = readState();
+    state[testFile] = { lastRun: Date.now(), srcHash: fileHash(srcFile) };
+    writeState(state);
+  }
+
+  return { shouldSkip, updateState, readState };
+}
+
+describe('auto-test debounce: 핵심 로직', () => {
+  it('첫 실행: state 없음 → 스킵 안 함', () => {
+    const stateFile = path.join(tmpDir, 'auto-test-state.json');
+    const { shouldSkip } = makeDebounceHelpers(stateFile);
+    const testFile = path.join(tmpDir, 'foo.test.ts');
+    const srcFile = path.join(tmpDir, 'foo.ts');
+    fs.writeFileSync(srcFile, 'const x = 1;\n', 'utf-8');
+    expect(shouldSkip(testFile, srcFile)).toBe(false);
+  });
+
+  it('state 업데이트 후 쿨다운 내 + 소스 미변경 → 스킵', () => {
+    const stateFile = path.join(tmpDir, 'auto-test-state.json');
+    const { shouldSkip, updateState } = makeDebounceHelpers(stateFile);
+    const testFile = path.join(tmpDir, 'foo.test.ts');
+    const srcFile = path.join(tmpDir, 'foo.ts');
+    fs.writeFileSync(srcFile, 'const x = 1;\n', 'utf-8');
+    updateState(testFile, srcFile);
+    // 소스 변경 없음 + 즉시 재호출 → 스킵
+    expect(shouldSkip(testFile, srcFile)).toBe(true);
+  });
+
+  it('소스 변경 후 → 스킵 안 함 (재실행)', () => {
+    const stateFile = path.join(tmpDir, 'auto-test-state.json');
+    const { shouldSkip, updateState } = makeDebounceHelpers(stateFile);
+    const testFile = path.join(tmpDir, 'foo.test.ts');
+    const srcFile = path.join(tmpDir, 'foo.ts');
+    fs.writeFileSync(srcFile, 'const x = 1;\n', 'utf-8');
+    updateState(testFile, srcFile);
+    // 소스 변경
+    fs.writeFileSync(srcFile, 'const x = 2;\n', 'utf-8');
+    expect(shouldSkip(testFile, srcFile)).toBe(false);
+  });
+
+  it('쿨다운 만료 → 스킵 안 함 (재실행)', () => {
+    const stateFile = path.join(tmpDir, 'auto-test-state.json');
+    const { shouldSkip, updateState, readState } = makeDebounceHelpers(stateFile);
+    const testFile = path.join(tmpDir, 'foo.test.ts');
+    const srcFile = path.join(tmpDir, 'foo.ts');
+    fs.writeFileSync(srcFile, 'const x = 1;\n', 'utf-8');
+    updateState(testFile, srcFile);
+
+    // lastRun을 과거로 조작 (쿨다운 초과)
+    const state = readState();
+    state[testFile].lastRun = Date.now() - DEBOUNCE_COOLDOWN_MS - 1000;
+    fs.mkdirSync(path.dirname(stateFile), { recursive: true });
+    fs.writeFileSync(stateFile, JSON.stringify(state), 'utf-8');
+
+    expect(shouldSkip(testFile, srcFile)).toBe(false);
+  });
+
+  it('state 파일 없어도 fail-open (스킵 안 함)', () => {
+    const stateFile = path.join(tmpDir, 'nonexistent', 'state.json');
+    const { shouldSkip } = makeDebounceHelpers(stateFile);
+    const testFile = path.join(tmpDir, 'foo.test.ts');
+    const srcFile = path.join(tmpDir, 'foo.ts');
+    expect(shouldSkip(testFile, srcFile)).toBe(false);
+  });
+});
+
+describe('auto-test: state 파일 경로 패턴', () => {
+  it('state 파일이 .vibe/metrics/ 하위에 위치', () => {
+    // 경로 패턴 검증 (실제 PROJECT_DIR은 다름)
+    const expectedPattern = /\.vibe[/\\]metrics[/\\]auto-test-state\.json$/;
+    const stateFile = path.join('/some/project', '.vibe', 'metrics', 'auto-test-state.json');
+    expect(expectedPattern.test(stateFile)).toBe(true);
+  });
+});

package/hooks/scripts/__tests__/code-check-detectors.test.js

@@ -0,0 +1,155 @@
+/**
+ * code-check.js 정밀 탐지기 테스트
+ *
+ * 검증 대상:
+ *   - any 탐지: 단어 경계 기반 (false positive: 'company', 'anything' 등)
+ *   - any 탐지: `: any`, `as any`, `@ts-ignore`, `<any>` (true positive)
+ *   - console.log 정책: 경로별 허용/차단
+ *   - run-ledger verifyRequired round-trip + pass 시 clear
+ *   - auto-commit verifyRequired skip
+ */
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { fileURLToPath } from 'url';
+import path from 'path';
+import fs from 'fs';
+import os from 'os';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+// ─── any 탐지 정규식 (code-check.js와 동일) ──────────────────────────────
+const P1_DETECTORS = [
+  /:\s*any\b/,
+  /\bas\s+any\b/,
+  /<any[\s,>]/,
+  /@ts-ignore\b/,
+];
+
+function detectsAny(line) {
+  return P1_DETECTORS.some(re => re.test(line));
+}
+
+describe('any 탐지: true positive', () => {
+  it(': any — 타입 어노테이션', () => {
+    expect(detectsAny('function foo(x: any): void {}')).toBe(true);
+  });
+
+  it(': any — 공백 포함', () => {
+    expect(detectsAny('const x:  any = 1;')).toBe(true);
+  });
+
+  it('as any — 타입 캐스트', () => {
+    expect(detectsAny('const y = x as any;')).toBe(true);
+  });
+
+  it('<any> — 제네릭', () => {
+    expect(detectsAny('const z = foo<any>();')).toBe(true);
+  });
+
+  it('<any, — 제네릭 다중 파라미터', () => {
+    expect(detectsAny('const m = new Map<any, string>();')).toBe(true);
+  });
+
+  it('@ts-ignore — 라인 직전', () => {
+    expect(detectsAny('// @ts-ignore')).toBe(true);
+  });
+
+  it('@ts-ignore — 인라인', () => {
+    expect(detectsAny('  @ts-ignore  ')).toBe(true);
+  });
+});
+
+describe('any 탐지: false negative (탐지 안 됨)', () => {
+  it('"company" 단어 포함 — 탐지 안 됨', () => {
+    expect(detectsAny('const company = "Acme";')).toBe(false);
+  });
+
+  it('"anything" 식별자 — 탐지 안 됨', () => {
+    expect(detectsAny('if (anything) return;')).toBe(false);
+  });
+
+  it('"manyThings" — 탐지 안 됨', () => {
+    expect(detectsAny('const manyThings = [];')).toBe(false);
+  });
+
+  it('"fantasy" — 탐지 안 됨', () => {
+    expect(detectsAny('const fantasy = "world";')).toBe(false);
+  });
+
+  it('문자열 리터럴 "any" — 정규식은 문자열 내부도 매칭할 수 있음 (알려진 한계, 문서화)', () => {
+    // NOTE: 현재 구현은 문자열 내 "any"를 완전히 제외하지 않음.
+    // 실제 코드에서 ": any" 패턴이 문자열로 존재하는 경우는 극히 드물어 허용.
+    // 이 테스트는 동작을 문서화하는 것이 목적.
+    const result = detectsAny('const msg = "type: any is bad";');
+    // 문자열 내 ": any" 도 탐지될 수 있음 — false positive지만 드문 케이스
+    expect(typeof result).toBe('boolean');
+  });
+});
+
+// ─── console.log 경로 정책 ────────────────────────────────────────────────
+describe('console.log 허용 경로 정책', () => {
+  // 허용 glob 패턴 (code-check.js 기본값과 동일)
+  const DEFAULT_ALLOW_GLOBS = [
+    'hooks/scripts/**',
+    'scripts/**',
+    '**/cli/**',
+    '**/*.test.*',
+    '**/*.spec.*',
+    '**/__tests__/**',
+  ];
+
+  function globToRegExp(glob) {
+    const normalized = glob.replace(/\\/g, '/');
+    let out = '';
+    for (let i = 0; i < normalized.length; i++) {
+      const c = normalized[i];
+      if (c === '*') {
+        if (normalized[i + 1] === '*') {
+          out += '.*';
+          i++;
+          if (normalized[i + 1] === '/') i++;
+        } else {
+          out += '[^/]*';
+        }
+      } else if (c === '?') {
+        out += '[^/]';
+      } else if ('.+^$()|{}[]\\'.includes(c)) {
+        out += '\\' + c;
+      } else {
+        out += c;
+      }
+    }
+    return new RegExp('^' + out + '$');
+  }
+
+  function isConsoleAllowed(relPath) {
+    return DEFAULT_ALLOW_GLOBS.some(g => globToRegExp(g).test(relPath));
+  }
+
+  it('hooks/scripts/auto-test.js → 허용', () => {
+    expect(isConsoleAllowed('hooks/scripts/auto-test.js')).toBe(true);
+  });
+
+  it('hooks/scripts/lib/run-ledger.js → 허용', () => {
+    expect(isConsoleAllowed('hooks/scripts/lib/run-ledger.js')).toBe(true);
+  });
+
+  it('src/cli/index.ts → 허용 (**/cli/**)', () => {
+    expect(isConsoleAllowed('src/cli/index.ts')).toBe(true);
+  });
+
+  it('src/tools/foo.test.ts → 허용 (**/*.test.*)', () => {
+    expect(isConsoleAllowed('src/tools/foo.test.ts')).toBe(true);
+  });
+
+  it('src/__tests__/bar.ts → 허용 (**/__tests__/**)', () => {
+    expect(isConsoleAllowed('src/__tests__/bar.ts')).toBe(true);
+  });
+
+  it('src/tools/convention/validateCodeQuality.ts → 차단', () => {
+    expect(isConsoleAllowed('src/tools/convention/validateCodeQuality.ts')).toBe(false);
+  });
+
+  it('src/infra/orchestrator/index.ts → 차단', () => {
+    expect(isConsoleAllowed('src/infra/orchestrator/index.ts')).toBe(false);
+  });
+});

package/hooks/scripts/__tests__/dispatcher-inprocess.test.js

@@ -0,0 +1,99 @@
+/**
+ * in-process 디스패처 외부 계약 테스트
+ *
+ * SPEC: .vibe/specs/hook-dispatcher-inprocess.md
+ * 디스패처를 Claude Code와 동일하게 CLI로 spawn하여 검증한다 —
+ * 내부 구현(in-process)이 아니라 외부 계약(exit code, stdout 주입)이 대상.
+ */
+import { describe, it, expect } from 'vitest';
+import { execFileSync } from 'child_process';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const PRE_DISPATCHER = path.resolve(__dirname, '..', 'pre-tool-dispatcher.js');
+const POST_DISPATCHER = path.resolve(__dirname, '..', 'post-edit-dispatcher.js');
+
+/**
+ * 디스패처를 stdin 페이로드와 함께 실행. { stdout, exitCode } 반환.
+ */
+function runDispatcher(script, args, payload) {
+  const input = typeof payload === 'string' ? payload : JSON.stringify(payload);
+  try {
+    const stdout = execFileSync('node', [script, ...args], {
+      encoding: 'utf-8',
+      input,
+      timeout: 15000,
+      // scope.json이 없는 격리된 cwd에서 실행 (scope-guard no-op 보장)
+      env: { ...process.env, CLAUDE_PROJECT_DIR: __dirname },
+    });
+    return { stdout: stdout.trim(), exitCode: 0 };
+  } catch (err) {
+    return { stdout: (err.stdout || '').trim(), exitCode: err.status };
+  }
+}
+
+describe('pre-tool-dispatcher (in-process)', () => {
+  it('AC-1: 위험 Bash 명령은 exit 2로 deny', () => {
+    const { exitCode } = runDispatcher(PRE_DISPATCHER, ['Bash'], {
+      tool_name: 'Bash',
+      tool_input: { command: 'rm -rf /' },
+    });
+    expect(exitCode).toBe(2);
+  });
+
+  it('AC-2: sentinel 경로 Edit은 exit 2 + stdout에 block JSON 주입', () => {
+    // 실제 sentinel 경로: src/infra/lib/evolution/ (autonomy/ 는 팬텀 경로였음)
+    const { stdout, exitCode } = runDispatcher(PRE_DISPATCHER, ['Edit'], {
+      tool_name: 'Edit',
+      tool_input: { file_path: 'src/infra/lib/evolution/GuardAnalyzer.ts', old_string: 'a', new_string: 'b' },
+    });
+    expect(exitCode).toBe(2);
+    expect(stdout).toContain('"decision":"block"');
+  });
+
+  it('AC-3: 안전한 Bash 명령은 exit 0', () => {
+    const { exitCode } = runDispatcher(PRE_DISPATCHER, ['Bash'], {
+      tool_name: 'Bash',
+      tool_input: { command: 'ls -la' },
+    });
+    expect(exitCode).toBe(0);
+  });
+
+  it('AC-3: 안전한 Edit은 exit 0 (scope.json 없음 → scope-guard no-op)', () => {
+    const { exitCode } = runDispatcher(PRE_DISPATCHER, ['Edit'], {
+      tool_name: 'Edit',
+      tool_input: { file_path: 'src/cli/index.ts', old_string: 'a', new_string: 'b' },
+    });
+    expect(exitCode).toBe(0);
+  });
+
+  it('AC-2 변형: 위험 명령이 sentinel 경로를 노리면 sentinel-guard가 차단', () => {
+    // 실제 sentinel 경로: src/infra/lib/evolution/
+    const { exitCode } = runDispatcher(PRE_DISPATCHER, ['Bash'], {
+      tool_name: 'Bash',
+      tool_input: { command: 'rm -rf src/infra/lib/evolution/' },
+    });
+    expect(exitCode).toBe(2);
+  });
+});
+
+describe('post-edit-dispatcher (in-process)', () => {
+  it('AC-4: 손상된 stdin(비JSON)에도 exit 0 (fail-open)', () => {
+    const { exitCode } = runDispatcher(POST_DISPATCHER, [], 'not-json');
+    expect(exitCode).toBe(0);
+  });
+
+  it('AC-4: 빈 페이로드에도 exit 0', () => {
+    const { exitCode } = runDispatcher(POST_DISPATCHER, [], {});
+    expect(exitCode).toBe(0);
+  });
+
+  it('존재하지 않는 파일 경로 페이로드에도 exit 0 (step 내부 격리)', () => {
+    const { exitCode } = runDispatcher(POST_DISPATCHER, [], {
+      tool_name: 'Edit',
+      tool_input: { file_path: '/nonexistent/__vibe_test__.xyz' },
+    });
+    expect(exitCode).toBe(0);
+  });
+});

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

@@ -0,0 +1,139 @@
+/**
+ * post-edit-dispatcher 계약 테스트
+ *
+ * 검증 대상:
+ *   - findings 있음 → stdout에 JSON hookSpecificOutput 출력, exit 0
+ *   - findings 없음 → stdout 없음, exit 0
+ *   - 손상된 stdin에도 exit 0 (fail-open)
+ *   - additionalContext 형식 정확성
+ */
+import { describe, it, expect } from 'vitest';
+import { spawnSync } from 'child_process';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import fs from 'fs';
+import os from 'os';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const DISPATCHER = path.resolve(__dirname, '..', 'post-edit-dispatcher.js');
+
+/**
+ * 디스패처를 stdin 페이로드와 함께 실행.
+ * @param {object|string} payload
+ * @param {string} [projectDir]
+ * @returns {{ stdout: string, stderr: string, exitCode: number }}
+ */
+function runDispatcher(payload, projectDir) {
+  const input = typeof payload === 'string' ? payload : JSON.stringify(payload);
+  const env = {
+    ...process.env,
+    CLAUDE_PROJECT_DIR: projectDir || __dirname,
+  };
+  const result = spawnSync('node', [DISPATCHER], {
+    input,
+    encoding: 'utf-8',
+    timeout: 30000,
+    env,
+  });
+  return {
+    stdout: (result.stdout || '').trim(),
+    stderr: (result.stderr || '').trim(),
+    exitCode: result.status ?? 0,
+  };
+}
+
+describe('post-edit-dispatcher: 출력 형식', () => {
+  it('빈 페이로드 → exit 0, stdout 없음 (findings 없음)', () => {
+    const { stdout, exitCode } = runDispatcher({});
+    expect(exitCode).toBe(0);
+    expect(stdout).toBe('');
+  });
+
+  it('손상된 stdin(비JSON) → exit 0 (fail-open)', () => {
+    const { exitCode } = runDispatcher('not-json');
+    expect(exitCode).toBe(0);
+  });
+
+  it('존재하지 않는 파일 경로 → exit 0', () => {
+    const { exitCode } = runDispatcher({
+      tool_name: 'Edit',
+      tool_input: { file_path: '/nonexistent/__vibe_test__.xyz' },
+    });
+    expect(exitCode).toBe(0);
+  });
+});
+
+describe('post-edit-dispatcher: JSON hookSpecificOutput 형식', () => {
+  let tmpDir;
+  let tsFile;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'vibe-dispatcher-test-'));
+    tsFile = path.join(tmpDir, 'test-file.ts');
+  });
+
+  afterEach(() => {
+    try { fs.rmSync(tmpDir, { recursive: true, force: true }); } catch { /* ignore */ }
+  });
+
+  it('P1 이슈가 있는 TS 파일 → JSON hookSpecificOutput 출력', () => {
+    // any 타입이 포함된 TS 파일 생성
+    fs.writeFileSync(tsFile, 'function foo(x: any): any { return x; }\n', 'utf-8');
+
+    const { stdout, exitCode } = runDispatcher({
+      tool_name: 'Edit',
+      tool_input: { file_path: tsFile },
+    }, tmpDir);
+
+    expect(exitCode).toBe(0);
+    if (stdout) {
+      // stdout이 있으면 JSON hookSpecificOutput 형식이어야 함
+      let parsed;
+      try {
+        parsed = JSON.parse(stdout);
+      } catch {
+        // plain text일 수도 있음 (code-check 모듈 로드 실패 시)
+        return;
+      }
+      if (parsed.hookSpecificOutput) {
+        expect(parsed.hookSpecificOutput.hookEventName).toBe('PostToolUse');
+        expect(typeof parsed.hookSpecificOutput.additionalContext).toBe('string');
+        expect(parsed.hookSpecificOutput.additionalContext.length).toBeGreaterThan(0);
+      }
+    }
+  });
+
+  it('findings 있으면 additionalContext에 요약 포함', () => {
+    fs.writeFileSync(tsFile, 'const x: any = 1;\n', 'utf-8');
+
+    const { stdout, exitCode } = runDispatcher({
+      tool_name: 'Edit',
+      tool_input: { file_path: tsFile },
+    }, tmpDir);
+
+    expect(exitCode).toBe(0);
+    if (stdout) {
+      try {
+        const parsed = JSON.parse(stdout);
+        if (parsed.hookSpecificOutput?.additionalContext) {
+          // any 탐지 관련 내용이 포함되어야 함
+          expect(parsed.hookSpecificOutput.additionalContext).toContain('any');
+        }
+      } catch { /* JSON 아닐 수 있음 */ }
+    }
+  });
+});
+
+describe('post-edit-dispatcher: additionalContext JSON 계약', () => {
+  it('JSON 구조가 올바른 hookSpecificOutput 스키마를 따름', () => {
+    // 직접 JSON 생성해 스키마 검증
+    const output = {
+      hookSpecificOutput: {
+        hookEventName: 'PostToolUse',
+        additionalContext: 'P1 any-type line 1: x: any',
+      },
+    };
+    expect(output.hookSpecificOutput.hookEventName).toBe('PostToolUse');
+    expect(typeof output.hookSpecificOutput.additionalContext).toBe('string');
+  });
+});