@su-record/vibe 2.12.5 → 2.13.0

package/hooks/scripts/__tests__/scope-from-spec.test.js

@@ -0,0 +1,215 @@
+/**
+ * scope-from-spec.js 단위 테스트
+ *
+ * REQ-harness-remediation-009: scope-guard 기본 활성화
+ *  - enabled 미설정(undefined) → sync 실행 (기본 ON)
+ *  - enabled === false → skip (명시적 opt-out)
+ *  - SPEC 없음 → scope.json 생성 안 함 (노이즈 가드)
+ */
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { isScopeGuardEnabled, syncScopeFile, findActiveSpecs } from '../lib/scope-from-spec.js';
+
+// 임시 프로젝트 디렉토리 헬퍼
+function makeTempDir() {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'vibe-scope-test-'));
+}
+
+function cleanDir(dir) {
+  try { fs.rmSync(dir, { recursive: true, force: true }); } catch { /* ignore */ }
+}
+
+// config.json 작성 헬퍼
+function writeConfig(dir, scopeGuard) {
+  const vibeDir = path.join(dir, '.vibe');
+  fs.mkdirSync(vibeDir, { recursive: true });
+  fs.writeFileSync(path.join(vibeDir, 'config.json'), JSON.stringify({ scopeGuard }));
+}
+
+// 최소 SPEC 작성 헬퍼
+function writeSpec(dir, filename, content, status = 'in-progress') {
+  const specsDir = path.join(dir, '.vibe', 'specs');
+  fs.mkdirSync(specsDir, { recursive: true });
+  const frontmatter = status ? `---\nstatus: ${status}\n---\n` : '';
+  fs.writeFileSync(path.join(specsDir, filename), frontmatter + (content || ''));
+}
+
+// ══════════════════════════════════════════════════
+// isScopeGuardEnabled — 기본 ON 동작
+// ══════════════════════════════════════════════════
+describe('isScopeGuardEnabled', () => {
+  let tmpDir;
+  beforeEach(() => { tmpDir = makeTempDir(); });
+  afterEach(() => { cleanDir(tmpDir); });
+
+  it('config 없음 → true (기본 ON)', () => {
+    expect(isScopeGuardEnabled(tmpDir)).toBe(true);
+  });
+
+  it('scopeGuard 키 없는 config → true', () => {
+    writeConfig(tmpDir, undefined);
+    expect(isScopeGuardEnabled(tmpDir)).toBe(true);
+  });
+
+  it('scopeGuard.enabled 없는 config → true', () => {
+    const vibeDir = path.join(tmpDir, '.vibe');
+    fs.mkdirSync(vibeDir, { recursive: true });
+    fs.writeFileSync(path.join(vibeDir, 'config.json'), JSON.stringify({ scopeGuard: {} }));
+    expect(isScopeGuardEnabled(tmpDir)).toBe(true);
+  });
+
+  it('scopeGuard.enabled=true → true', () => {
+    writeConfig(tmpDir, { enabled: true });
+    expect(isScopeGuardEnabled(tmpDir)).toBe(true);
+  });
+
+  it('scopeGuard.enabled=false → false (명시적 opt-out)', () => {
+    writeConfig(tmpDir, { enabled: false });
+    expect(isScopeGuardEnabled(tmpDir)).toBe(false);
+  });
+
+  it('legacy .claude/vibe/config.json에서도 enabled=false 인식', () => {
+    const legacyDir = path.join(tmpDir, '.claude', 'vibe');
+    fs.mkdirSync(legacyDir, { recursive: true });
+    fs.writeFileSync(path.join(legacyDir, 'config.json'), JSON.stringify({ scopeGuard: { enabled: false } }));
+    expect(isScopeGuardEnabled(tmpDir)).toBe(false);
+  });
+});
+
+// ══════════════════════════════════════════════════
+// syncScopeFile — 노이즈 가드: SPEC 없으면 생성 안 함
+// ══════════════════════════════════════════════════
+describe('syncScopeFile — no specs → no scope created', () => {
+  let tmpDir;
+  beforeEach(() => { tmpDir = makeTempDir(); });
+  afterEach(() => { cleanDir(tmpDir); });
+
+  it('SPEC 없음 → skipped-no-specs, scope.json 미생성', () => {
+    fs.mkdirSync(path.join(tmpDir, '.vibe'), { recursive: true });
+    const result = syncScopeFile(tmpDir);
+    expect(result.action).toBe('skipped-no-specs');
+    expect(fs.existsSync(path.join(tmpDir, '.vibe', 'scope.json'))).toBe(false);
+  });
+
+  it('specs 디렉토리 없음 → skipped-no-specs', () => {
+    const result = syncScopeFile(tmpDir);
+    expect(result.action).toBe('skipped-no-specs');
+  });
+});
+
+// ══════════════════════════════════════════════════
+// syncScopeFile — SPEC 있을 때 sync 실행
+// ══════════════════════════════════════════════════
+describe('syncScopeFile — spec exists → scope created', () => {
+  let tmpDir;
+  beforeEach(() => { tmpDir = makeTempDir(); });
+  afterEach(() => { cleanDir(tmpDir); });
+
+  // 파생 glob은 실존 디렉토리만 통과하므로, 참조 경로를 실제로 만들어 준다
+  function materialize(dir, relFile) {
+    const full = path.join(dir, relFile);
+    fs.mkdirSync(path.dirname(full), { recursive: true });
+    fs.writeFileSync(full, '');
+  }
+
+  it('활성 SPEC 있음 → scope.json 생성', () => {
+    writeSpec(tmpDir, 'feature.md', 'edit `src/cli/index.ts`');
+    materialize(tmpDir, 'src/cli/index.ts');
+    const result = syncScopeFile(tmpDir);
+    expect(result.action).toBe('created');
+    const scopeJson = path.join(tmpDir, '.vibe', 'scope.json');
+    expect(fs.existsSync(scopeJson)).toBe(true);
+    const scope = JSON.parse(fs.readFileSync(scopeJson, 'utf-8'));
+    expect(scope.auto).toBe(true);
+    expect(Array.isArray(scope.allow)).toBe(true);
+  });
+
+  it('status 없는 최근 SPEC은 활성 간주 → scope.json 생성', () => {
+    writeSpec(tmpDir, 'no-status.md', 'modify `hooks/scripts/foo.js`', null);
+    materialize(tmpDir, 'hooks/scripts/foo.js');
+    const result = syncScopeFile(tmpDir);
+    expect(result.action).toBe('created');
+  });
+
+  it('status 없는 오래된 SPEC(>14일)은 비활성 → skipped-no-specs', () => {
+    writeSpec(tmpDir, 'stale.md', 'modify `hooks/scripts/foo.js`', null);
+    materialize(tmpDir, 'hooks/scripts/foo.js');
+    const old = new Date(Date.now() - 15 * 24 * 60 * 60 * 1000);
+    fs.utimesSync(path.join(tmpDir, '.vibe', 'specs', 'stale.md'), old, old);
+    const result = syncScopeFile(tmpDir);
+    expect(result.action).toBe('skipped-no-specs');
+  });
+
+  it('활성 SPEC에 산출 가능한 경로 없음 → skipped-no-paths, scope.json 미생성', () => {
+    writeSpec(tmpDir, 'no-paths.md', 'just prose, `nonexistent/dir/file` reference only');
+    const result = syncScopeFile(tmpDir);
+    expect(result.action).toBe('skipped-no-paths');
+    expect(fs.existsSync(path.join(tmpDir, '.vibe', 'scope.json'))).toBe(false);
+  });
+
+  it('경로 산출 불가로 전환되면 기존 auto scope.json 제거', () => {
+    writeSpec(tmpDir, 'feature.md', 'edit `src/cli/index.ts`');
+    materialize(tmpDir, 'src/cli/index.ts');
+    syncScopeFile(tmpDir); // 생성
+    fs.rmSync(path.join(tmpDir, 'src'), { recursive: true, force: true });
+    const result = syncScopeFile(tmpDir);
+    expect(result.action).toBe('removed');
+    expect(fs.existsSync(path.join(tmpDir, '.vibe', 'scope.json'))).toBe(false);
+  });
+
+  it('completed SPEC만 있을 때 → skipped-no-specs (비활성 SPEC은 제외)', () => {
+    writeSpec(tmpDir, 'done.md', 'edit `src/foo.ts`', 'completed');
+    const result = syncScopeFile(tmpDir);
+    expect(result.action).toBe('skipped-no-specs');
+  });
+
+  it('수동 관리 scope.json(auto:false) → 건드리지 않음', () => {
+    writeSpec(tmpDir, 'feature.md', 'edit `src/bar.ts`');
+    const scopeDir = path.join(tmpDir, '.vibe');
+    fs.mkdirSync(scopeDir, { recursive: true });
+    const manual = { auto: false, mode: 'block', allow: ['src/**'], deny: [] };
+    fs.writeFileSync(path.join(scopeDir, 'scope.json'), JSON.stringify(manual));
+    const result = syncScopeFile(tmpDir);
+    expect(result.action).toBe('skipped-manual');
+    const existing = JSON.parse(fs.readFileSync(path.join(scopeDir, 'scope.json'), 'utf-8'));
+    expect(existing.mode).toBe('block'); // 원본 유지
+  });
+
+  it('활성 SPEC 제거 후 재호출 → auto scope.json 삭제', () => {
+    writeSpec(tmpDir, 'feature.md', 'edit `src/cli/index.ts`');
+    materialize(tmpDir, 'src/cli/index.ts');
+    syncScopeFile(tmpDir); // 생성
+    // specs 디렉토리 비우기
+    fs.rmSync(path.join(tmpDir, '.vibe', 'specs'), { recursive: true, force: true });
+    const result = syncScopeFile(tmpDir);
+    expect(result.action).toBe('removed');
+    expect(fs.existsSync(path.join(tmpDir, '.vibe', 'scope.json'))).toBe(false);
+  });
+});
+
+// ══════════════════════════════════════════════════
+// findActiveSpecs — legacy .claude/vibe/specs 폴백
+// ══════════════════════════════════════════════════
+describe('findActiveSpecs — resolution order', () => {
+  let tmpDir;
+  beforeEach(() => { tmpDir = makeTempDir(); });
+  afterEach(() => { cleanDir(tmpDir); });
+
+  it('.vibe/specs 우선', () => {
+    writeSpec(tmpDir, 'main.md', 'content');
+    const specs = findActiveSpecs(tmpDir);
+    expect(specs.length).toBe(1);
+    expect(specs[0]).toContain('.vibe');
+  });
+
+  it('.vibe 없고 .claude/vibe/specs 있으면 legacy 사용', () => {
+    const legacySpecsDir = path.join(tmpDir, '.claude', 'vibe', 'specs');
+    fs.mkdirSync(legacySpecsDir, { recursive: true });
+    fs.writeFileSync(path.join(legacySpecsDir, 'old.md'), '---\nstatus: in-progress\n---\ncontent');
+    const specs = findActiveSpecs(tmpDir);
+    expect(specs.length).toBe(1);
+    expect(specs[0]).toContain('.claude');
+  });
+});

package/hooks/scripts/__tests__/sentinel-guard.test.js

@@ -24,7 +24,6 @@ function runGuard(args = []) {
 
 /**
  * Run sentinel-guard.js with stdin JSON payload.
- * 스크립트가 fs.readSync(0, ...)로 stdin을 읽으므로 execFileSync input 옵션이 동작.
  */
 function runGuardWithStdin(payload) {
   const json = typeof payload === 'string' ? payload : JSON.stringify(payload);
@@ -41,24 +40,25 @@ function runGuardWithStdin(payload) {
 }
 
 // ══════════════════════════════════════════════════
-// Sentinel path protection
+// Sentinel path protection — evolution machinery
 // ══════════════════════════════════════════════════
 describe('sentinel-guard', () => {
-  describe('Write/Edit to sentinel paths via argv', () => {
-    it('should block Write to src/infra/lib/autonomy/', () => {
+  // ─── 실제 보호 경로: src/infra/lib/evolution/ ───
+  describe('Write/Edit to evolution sentinel path via argv', () => {
+    it('should block Write to src/infra/lib/evolution/', () => {
       const result = runGuard([
         'Write',
-        JSON.stringify({ file_path: 'src/infra/lib/autonomy/policy.ts' }),
+        JSON.stringify({ file_path: 'src/infra/lib/evolution/EvolutionOrchestrator.ts' }),
       ]);
       expect(result.exitCode).toBe(2);
       expect(result.stdout).toContain('block');
       expect(result.stdout).toContain('Sentinel files are protected');
     });
 
-    it('should block Edit to sentinel path', () => {
+    it('should block Edit to evolution sentinel path', () => {
       const result = runGuard([
         'Edit',
-        JSON.stringify({ file_path: 'src/infra/lib/autonomy/config.ts' }),
+        JSON.stringify({ file_path: 'src/infra/lib/evolution/GuardAnalyzer.ts' }),
       ]);
       expect(result.exitCode).toBe(2);
       expect(result.stdout).toContain('block');
@@ -67,7 +67,7 @@ describe('sentinel-guard', () => {
     it('should block Write with backslash path separators', () => {
       const result = runGuard([
         'Write',
-        JSON.stringify({ file_path: 'src\\infra\\lib\\autonomy\\file.ts' }),
+        JSON.stringify({ file_path: 'src\\infra\\lib\\evolution\\file.ts' }),
       ]);
       expect(result.exitCode).toBe(2);
       expect(result.stdout).toContain('Sentinel files are protected');
@@ -76,32 +76,62 @@ describe('sentinel-guard', () => {
     it('should block Write with ./ prefix', () => {
       const result = runGuard([
         'Write',
-        JSON.stringify({ file_path: './src/infra/lib/autonomy/index.ts' }),
+        JSON.stringify({ file_path: './src/infra/lib/evolution/index.ts' }),
       ]);
       expect(result.exitCode).toBe(2);
     });
   });
 
+  // ─── 실제 보호 경로: hooks/scripts/lib/ ───
+  describe('Write/Edit to hooks/scripts/lib/ sentinel path', () => {
+    it('should block Write to hooks/scripts/lib/', () => {
+      const result = runGuard([
+        'Write',
+        JSON.stringify({ file_path: 'hooks/scripts/lib/dispatcher.js' }),
+      ]);
+      expect(result.exitCode).toBe(2);
+      expect(result.stdout).toContain('Sentinel files are protected');
+    });
+
+    it('should block Edit to hook-context.js', () => {
+      const result = runGuard([
+        'Edit',
+        JSON.stringify({ file_path: 'hooks/scripts/lib/hook-context.js' }),
+      ]);
+      expect(result.exitCode).toBe(2);
+    });
+  });
+
+  // ─── stdin 경로 ───
   describe('Write/Edit to sentinel paths via stdin', () => {
-    it('should block Edit via stdin payload', () => {
+    it('should block Edit evolution path via stdin payload', () => {
       const result = runGuardWithStdin({
         tool_name: 'Edit',
-        tool_input: { file_path: './src/infra/lib/autonomy/config.ts' },
+        tool_input: { file_path: './src/infra/lib/evolution/InsightStore.ts' },
       });
       expect(result.exitCode).toBe(2);
       expect(result.stdout).toContain('block');
     });
 
-    it('should block Write via stdin payload', () => {
+    it('should block Write evolution path via stdin payload', () => {
       const result = runGuardWithStdin({
         tool_name: 'Write',
-        tool_input: { file_path: 'src/infra/lib/autonomy/policy.ts' },
+        tool_input: { file_path: 'src/infra/lib/evolution/CircuitBreaker.ts' },
       });
       expect(result.exitCode).toBe(2);
       expect(result.stdout).toContain('Sentinel files are protected');
     });
+
+    it('should block Write hooks/scripts/lib/ path via stdin', () => {
+      const result = runGuardWithStdin({
+        tool_name: 'Write',
+        tool_input: { file_path: 'hooks/scripts/lib/run-ledger.js' },
+      });
+      expect(result.exitCode).toBe(2);
+    });
   });
 
+  // ─── 허용 경로 ───
   describe('allowed operations', () => {
     it('should allow Write to non-sentinel paths', () => {
       const result = runGuard([
@@ -114,7 +144,7 @@ describe('sentinel-guard', () => {
     it('should allow Read to sentinel paths (read is not blocked)', () => {
       const result = runGuard([
         'Read',
-        JSON.stringify({ file_path: 'src/infra/lib/autonomy/policy.ts' }),
+        JSON.stringify({ file_path: 'src/infra/lib/evolution/GuardAnalyzer.ts' }),
       ]);
       expect(result.exitCode).toBe(0);
     });
@@ -126,23 +156,40 @@ describe('sentinel-guard', () => {
       ]);
       expect(result.exitCode).toBe(0);
     });
+
+    it('should allow Write to hooks/scripts/ top level (not lib/ subdir)', () => {
+      const result = runGuard([
+        'Write',
+        JSON.stringify({ file_path: 'hooks/scripts/step-counter.js' }),
+      ]);
+      expect(result.exitCode).toBe(0);
+    });
+
+    it('should allow Write to src/infra/lib/ parent (not evolution subdir)', () => {
+      const result = runGuard([
+        'Write',
+        JSON.stringify({ file_path: 'src/infra/lib/constants.ts' }),
+      ]);
+      expect(result.exitCode).toBe(0);
+    });
   });
 
+  // ─── 위험한 bash + sentinel 경로 ───
   describe('dangerous bash commands targeting sentinel paths', () => {
-    it('should block rm -rf targeting sentinel path', () => {
+    it('should block rm -rf targeting evolution path', () => {
       const result = runGuard([
         'Bash',
-        JSON.stringify({ command: 'rm -rf src/infra/lib/autonomy/' }),
+        JSON.stringify({ command: 'rm -rf src/infra/lib/evolution/' }),
       ]);
       expect(result.exitCode).toBe(2);
       expect(result.stdout).toContain('block');
       expect(result.stdout).toContain('Dangerous command targeting sentinel path');
     });
 
-    it('should block kill -9 targeting sentinel path', () => {
+    it('should block rm -rf targeting hooks/scripts/lib/', () => {
       const result = runGuard([
         'Bash',
-        JSON.stringify({ command: 'kill -9 1234 && rm src/infra/lib/autonomy/x' }),
+        JSON.stringify({ command: 'rm -rf hooks/scripts/lib/' }),
       ]);
       expect(result.exitCode).toBe(2);
     });
@@ -164,33 +211,41 @@ describe('sentinel-guard', () => {
     });
   });
 
+  // ─── Bash 명령어 문자열이 sentinel 경로로 시작하는 경우 ───
   describe('Bash command containing sentinel path in command string', () => {
-    it('should block when command string itself starts with sentinel path', () => {
+    it('should block when command string itself starts with evolution sentinel path', () => {
       const result = runGuard([
         'Bash',
-        JSON.stringify({ command: 'src/infra/lib/autonomy/run.sh' }),
+        JSON.stringify({ command: 'src/infra/lib/evolution/run.sh' }),
       ]);
       expect(result.exitCode).toBe(2);
       expect(result.stdout).toContain('Sentinel files are protected');
     });
 
+    it('should block when command string starts with hooks/scripts/lib/', () => {
+      const result = runGuard([
+        'Bash',
+        JSON.stringify({ command: 'hooks/scripts/lib/dispatcher.js' }),
+      ]);
+      expect(result.exitCode).toBe(2);
+    });
+
     it('should not block non-dangerous commands referencing sentinel path mid-string', () => {
-      // isSentinelPath only checks startsWith, and the DANGEROUS_BASH_RE +
-      // includes check requires both a dangerous command and sentinel path
       const result = runGuard([
         'Bash',
-        JSON.stringify({ command: 'cat src/infra/lib/autonomy/policy.ts | wc -l' }),
+        JSON.stringify({ command: 'cat src/infra/lib/evolution/GuardAnalyzer.ts | wc -l' }),
       ]);
       // 'cat' is not a dangerous command, command does not start with sentinel path
       expect(result.exitCode).toBe(0);
     });
   });
 
+  // ─── stdin vs argv 우선순위 ───
   describe('stdin vs argv priority', () => {
     it('should prefer stdin payload over argv', () => {
       const payload = JSON.stringify({
         tool_name: 'Write',
-        tool_input: { file_path: 'src/infra/lib/autonomy/x.ts' },
+        tool_input: { file_path: 'src/infra/lib/evolution/x.ts' },
       });
       try {
         execFileSync('node', [SCRIPT, 'Read', '{}'], {

package/hooks/scripts/__tests__/step-counter.test.js

@@ -75,27 +75,31 @@ describe('step-counter PostToolUse hook', () => {
       expect(data.startedAt).toMatch(/^\d{4}-\d{2}-\d{2}T/);
     });
 
-    it('연속 호출 시 steps 누적', () => {
-      for (let i = 0; i < 3; i++) {
+    it('연속 호출 시 steps 누적 (10이벤트 재작성 주기 고려)', () => {
+      // 10이벤트마다 재작성 — 10회 호출 후에는 steps=10 이 보장됨
+      for (let i = 0; i < 10; i++) {
         runCounter({
           payload: { tool_name: 'Bash', tool_input: { command: 'echo hi' }, tool_response: {} },
           projectDir,
         });
       }
       const data = readJson(runJson);
-      expect(data.steps).toBe(3);
+      expect(data.steps).toBe(10);
     });
 
-    it('손상된 JSON 이 있어도 새로 시작', () => {
+    it('손상된 JSON 이 있어도 새로 시작 (10회 후 재작성으로 확인)', () => {
       fs.mkdirSync(path.join(projectDir, '.vibe', 'metrics'), { recursive: true });
       fs.writeFileSync(runJson, '{ broken json');
-      const r = runCounter({
-        payload: { tool_name: 'Bash', tool_input: {}, tool_response: {} },
-        projectDir,
-      });
-      expect(r.status).toBe(0);
+      // 10회 호출해야 재작성 주기 도달
+      for (let i = 0; i < 10; i++) {
+        runCounter({
+          payload: { tool_name: 'Bash', tool_input: {}, tool_response: {} },
+          projectDir,
+        });
+      }
       const data = readJson(runJson);
-      expect(data.steps).toBe(1);
+      expect(data.steps).toBe(10);
+      expect(data.startedAt).toMatch(/^\d{4}-\d{2}-\d{2}T/);
     });
   });
 
@@ -149,7 +153,8 @@ describe('step-counter PostToolUse hook', () => {
       expect(readJson(runJson).steps).toBe(1);
     });
 
-    it('연속 호출 시 jsonl 누적', () => {
+    it('연속 호출 시 jsonl 누적 (Read는 조기 종료 — 기록 안 됨)', () => {
+      // Read 는 READ_ONLY_TOOLS 조기 종료 → jsonl 미기록
       runCounter({
         payload: { tool_name: 'Read', tool_input: { file_path: 'a.ts' }, tool_response: {} },
         projectDir,
@@ -159,8 +164,8 @@ describe('step-counter PostToolUse hook', () => {
         projectDir,
       });
       const lines = readJsonl(runJsonl);
-      expect(lines).toHaveLength(2);
-      expect(lines.map((l) => l.tool)).toEqual(['Read', 'Edit']);
+      expect(lines).toHaveLength(1);
+      expect(lines[0].tool).toBe('Edit');
     });
   });
 
@@ -322,10 +327,10 @@ describe('step-counter PostToolUse hook', () => {
       // 같은 카테고리 실패 2회
       failBash('a', err, projectDir);
       failBash('b', err, projectDir);
-      // 성공 툴콜로 윈도우 채움 (10줄 이상)
+      // 성공 툴콜로 윈도우 채움 (10줄 이상) — Bash 를 사용 (Read 는 조기 종료로 jsonl 미기록)
       for (let i = 0; i < 10; i++) {
         runCounter({
-          payload: { tool_name: 'Read', tool_input: { file_path: `f${i}.ts` }, tool_response: {} },
+          payload: { tool_name: 'Bash', tool_input: { command: `echo ${i}` }, tool_response: {} },
           projectDir,
         });
       }
@@ -355,4 +360,79 @@ describe('step-counter PostToolUse hook', () => {
       expect(r.status).toBe(0);
     });
   });
+
+  // ───────── 읽기 전용 도구 조기 종료 (defense-in-depth) ─────────
+  describe('읽기 전용 도구 조기 종료', () => {
+    const READ_ONLY = ['Read', 'Grep', 'Glob', 'WebFetch', 'WebSearch', 'TodoWrite', 'ToolSearch', 'ListMcpResourcesTool'];
+
+    it.each(READ_ONLY)('%s 호출 시 파일 미생성 + exit 0', (toolName) => {
+      const r = runCounter({
+        payload: { tool_name: toolName, tool_input: { file_path: 'src/foo.ts' }, tool_response: {} },
+        projectDir,
+      });
+      expect(r.status).toBe(0);
+      // jsonl에 기록하지 않아야 함
+      const jsonlPath = path.join(projectDir, '.vibe', 'metrics', 'current-run.jsonl');
+      expect(fs.existsSync(jsonlPath)).toBe(false);
+      // current-run.json 도 생성하지 않아야 함
+      const jsonPath = path.join(projectDir, '.vibe', 'metrics', 'current-run.json');
+      expect(fs.existsSync(jsonPath)).toBe(false);
+    });
+  });
+
+  // ───────── 쓰기 스로틀 ─────────
+  describe('쓰기 스로틀: jsonl 항상 append, json 조건부 재작성', () => {
+    it('첫 번째 이벤트는 current-run.json 생성 (파일 없음 → 스로틀 없음)', () => {
+      runCounter({
+        payload: { tool_name: 'Bash', tool_input: { command: 'x' }, tool_response: {} },
+        projectDir,
+      });
+      expect(fs.existsSync(runJson)).toBe(true);
+      expect(readJson(runJson).steps).toBe(1);
+    });
+
+    it('10이벤트마다 강제 재작성: 10회 후 steps=jsonl라인수=10', () => {
+      for (let i = 0; i < 10; i++) {
+        runCounter({
+          payload: { tool_name: 'Edit', tool_input: { file_path: 'a.ts' }, tool_response: {} },
+          projectDir,
+        });
+      }
+      // 10번째 이벤트에서 강제 재작성 (10%10===0) — steps = jsonl 라인 수 = 10
+      const data = readJson(runJson);
+      expect(data.steps).toBe(10);
+      // jsonl 도 10줄
+      const lines = readJsonl(runJsonl);
+      expect(lines).toHaveLength(10);
+    });
+
+    it('jsonl 은 스로틀 무관 항상 즉시 append', () => {
+      for (let i = 0; i < 5; i++) {
+        runCounter({
+          payload: { tool_name: 'Bash', tool_input: { command: `cmd-${i}` }, tool_response: {} },
+          projectDir,
+        });
+      }
+      const lines = readJsonl(runJsonl);
+      expect(lines).toHaveLength(5);
+    });
+
+    it('3-fail 감지는 jsonl 기반 — json 스로틀 후에도 동작', () => {
+      const err = "TypeError: Cannot read properties of undefined (reading 'x')";
+      // 3회 실패 (jsonl에 즉시 기록되므로 감지 가능)
+      for (let i = 0; i < 3; i++) {
+        runCounter({
+          payload: {
+            tool_name: 'Bash',
+            tool_input: { command: `run-${i}` },
+            tool_response: { is_error: true, error: err },
+          },
+          projectDir,
+        });
+      }
+      const apDir = path.join(projectDir, '.vibe', 'anti-patterns');
+      const files = fs.existsSync(apDir) ? fs.readdirSync(apDir).filter(f => f.endsWith('.md')) : [];
+      expect(files).toHaveLength(1);
+    });
+  });
 });