@su-record/vibe 3.2.12 → 3.2.14

package/hooks/scripts/__tests__/fixtures/seq-harness.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+/**
+ * dispatch() 를 실제 계약대로 (CLI spawn + stdin) 구동하는 테스트 하네스.
+ * 스텝 3개를 dispatch 에 넘기고, 각 스텝은 seq-step.js 가 트레이스를 남긴다.
+ */
+import { dispatch } from '../../lib/dispatcher.js';
+
+await dispatch([
+  { name: 'seq-a', script: '__tests__/fixtures/seq-step.js', args: ['a'] },
+  { name: 'seq-b', script: '__tests__/fixtures/seq-step.js', args: ['b'] },
+  { name: 'seq-c', script: '__tests__/fixtures/seq-step.js', args: ['c'] },
+]);
+process.exit(0);

package/hooks/scripts/__tests__/fixtures/seq-step.js

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+/**
+ * dispatch() 순차 실행 회귀 테스트용 스텝 픽스처.
+ *
+ * 실행 구간의 시작/끝을 VIBE_SEQ_TRACE 파일에 append 한다.
+ * 순차 실행이면 트레이스는 `a:start,a:end,b:start,b:end` 처럼 구간이 겹치지 않고,
+ * 병렬 실행이면 `a:start,b:start,...` 로 인터리빙된다.
+ */
+import fs from 'fs';
+
+const name = process.argv[2] || '?';
+const tracePath = process.env.VIBE_SEQ_TRACE;
+const holdMs = Number(process.env.VIBE_SEQ_HOLD_MS || 120);
+
+fs.appendFileSync(tracePath, `${name}:start\n`);
+
+// 동기 홀드 — 병렬 실행 시 다른 스텝의 start 가 이 구간 안에 끼어들도록 만든다.
+const until = Date.now() + holdMs;
+while (Date.now() < until) { /* busy wait */ }
+
+fs.appendFileSync(tracePath, `${name}:end\n`);
+process.exit(0);

package/hooks/scripts/__tests__/stop-dispatcher-sequential.test.js

@@ -0,0 +1,74 @@
+/**
+ * dispatch() 순차 실행 계약 회귀 테스트
+ *
+ * stop-dispatcher.js 는 "auto-commit 의 git cascade 와 겹쳐 프로세스 폭주" 를 막기 위해
+ * 순차 실행을 계약으로 문서화한다(stop-dispatcher.js 헤더). 그러나 dispatch() 가
+ * Promise.all 로 구현돼 있어 실제로는 병렬이었다 — 이 테스트가 그 회귀를 막는다.
+ *
+ * 검증 대상은 내부 구현이 아니라 관측 가능한 실행 구간 겹침이다.
+ */
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { execFileSync } from 'child_process';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const FIXTURES = path.resolve(__dirname, 'fixtures');
+const HARNESS = path.join(FIXTURES, 'seq-harness.js');
+
+let traceDir;
+let tracePath;
+
+beforeEach(() => {
+  traceDir = fs.mkdtempSync(path.join(os.tmpdir(), 'vibe-seq-'));
+  tracePath = path.join(traceDir, 'trace.log');
+  fs.writeFileSync(tracePath, '');
+});
+
+afterEach(() => {
+  fs.rmSync(traceDir, { recursive: true, force: true });
+});
+
+function runHarness() {
+  execFileSync('node', [HARNESS], {
+    encoding: 'utf-8',
+    input: JSON.stringify({ tool_name: 'Stop' }),
+    timeout: 20000,
+    env: {
+      ...process.env,
+      VIBE_SEQ_TRACE: tracePath,
+      VIBE_SEQ_HOLD_MS: '120',
+      // config.json 이 없는 디렉터리 → 모든 step enabled
+      CLAUDE_PROJECT_DIR: traceDir,
+    },
+  });
+  return fs.readFileSync(tracePath, 'utf-8').trim().split('\n').filter(Boolean);
+}
+
+describe('dispatch() 순차 실행 계약', () => {
+  it('스텝 실행 구간이 겹치지 않는다 (start 직후 항상 같은 스텝의 end)', () => {
+    const trace = runHarness();
+
+    expect(trace).toHaveLength(6);
+    for (let i = 0; i < trace.length; i += 2) {
+      const [startName, startMark] = trace[i].split(':');
+      const [endName, endMark] = trace[i + 1].split(':');
+      expect(startMark).toBe('start');
+      expect(endMark).toBe('end');
+      // 병렬이면 여기서 다른 스텝의 start 가 끼어든다
+      expect(endName).toBe(startName);
+    }
+  });
+
+  it('선언된 순서(a → b → c)를 그대로 지킨다', () => {
+    const trace = runHarness();
+
+    expect(trace).toEqual([
+      'a:start', 'a:end',
+      'b:start', 'b:end',
+      'c:start', 'c:end',
+    ]);
+  });
+});

package/hooks/scripts/code-check.js

@@ -10,11 +10,10 @@
  * (run-ledger verifyRequired)를 태우지 않는다 — 그 게이트는 결정론적
  * 검증 흐름(vibe.verify) 전용이다.
  */
-import { getToolsBaseUrl, PROJECT_DIR, readProjectConfig } from './utils.js';
+import { getToolsBaseUrl, PROJECT_DIR } from './utils.js';
 import { readFileSync } from 'fs';
-import path from 'path';
 import { buildCliCtx, isDirectRun } from './lib/hook-context.js';
-import { globToRegExp } from './lib/glob.js';
+import { CODE_EXT_RE, shouldCheckConsole } from './lib/console-allow.js';
 
 const BASE_URL = getToolsBaseUrl();
 
@@ -31,50 +30,6 @@ const P1_DETECTORS = [
 ];
 
 const TS_EXT_RE = /\.(ts|tsx)$/;
-const CODE_EXT_RE = /\.(ts|tsx|js|jsx|mjs|cjs)$/;
-
-// console.log 기본 허용 경로 (glob 패턴 → 정규식으로 변환)
-const DEFAULT_CONSOLE_ALLOW_GLOBS = [
-  'hooks/scripts/**',
-  'scripts/**',
-  '**/cli/**',
-  '**/*.test.*',
-  '**/*.spec.*',
-  '**/__tests__/**',
-];
-
-/**
- * .vibe/config.json의 qualityCheck.consoleAllow 글로브 목록 로드.
- * 기본 글로브와 병합하여 반환.
- * @returns {RegExp[]}
- */
-function loadConsoleAllowPatterns() {
-  try {
-    const cfg = readProjectConfig();
-    const extra = cfg?.qualityCheck?.consoleAllow;
-    const globs = Array.isArray(extra)
-      ? [...DEFAULT_CONSOLE_ALLOW_GLOBS, ...extra]
-      : DEFAULT_CONSOLE_ALLOW_GLOBS;
-    return globs.map(g => globToRegExp(g));
-  } catch {
-    return DEFAULT_CONSOLE_ALLOW_GLOBS.map(g => globToRegExp(g));
-  }
-}
-
-/**
- * 파일 경로가 console.log 허용 경로인지 판단.
- * @param {string} filePath - 절대 또는 프로젝트 상대 경로
- * @returns {boolean}
- */
-function isConsoleAllowed(filePath) {
-  try {
-    const rel = path.relative(PROJECT_DIR, path.resolve(filePath)).replace(/\\/g, '/');
-    const patterns = loadConsoleAllowPatterns();
-    return patterns.some(re => re.test(rel));
-  } catch {
-    return false;
-  }
-}
 
 /**
  * hook ctx에서 수정된 파일 경로 추출.
@@ -99,16 +54,72 @@ function classifyObservation(files) {
   return { type: 'feature', title: 'Code modified' };
 }
 
+/**
+ * 백슬래시로 이스케이프되지 않은 첫 token 위치. 없으면 -1.
+ * 템플릿 리터럴 안의 \` 를 종료 백틱으로 오인하지 않기 위해 필요하다.
+ * @param {string} str
+ * @param {string} token
+ * @returns {number}
+ */
+function findUnescaped(str, token) {
+  for (let i = 0; i < str.length; i++) {
+    if (str[i] === '\\') { i++; continue; }
+    if (str.startsWith(token, i)) return i;
+  }
+  return -1;
+}
+
+/**
+ * 한 줄에서 코드가 아닌 구간(주석·문자열·템플릿 리터럴)을 지운다.
+ * 여러 줄에 걸친 블록 주석·템플릿 리터럴을 잇기 위해 state를 받고 갱신해 돌려준다.
+ * @param {string} line
+ * @param {{ inBlock: boolean, inTemplate: boolean }} state - 제자리 갱신
+ * @returns {string} 코드 구간만 남은 문자열
+ */
+function stripNonCodeLine(line, state) {
+  let rest = line;
+  let code = '';
+  while (rest.length > 0) {
+    if (state.inBlock || state.inTemplate) {
+      const closer = state.inBlock ? '*/' : '`';
+      const end = findUnescaped(rest, closer);
+      if (end === -1) break;
+      if (state.inBlock) state.inBlock = false;
+      else state.inTemplate = false;
+      rest = rest.slice(end + closer.length);
+      continue;
+    }
+    const opener = rest.match(/\/\*|\/\/|`|'|"/);
+    if (!opener) return code + rest;
+    code += rest.slice(0, opener.index);
+    const token = opener[0];
+    rest = rest.slice(opener.index + token.length);
+    if (token === '//') break;
+    if (token === '/*') { state.inBlock = true; continue; }
+    if (token === '`') { state.inTemplate = true; continue; }
+    const close = findUnescaped(rest, token); // 홑/겹따옴표는 줄을 넘지 않는다
+    rest = close === -1 ? '' : rest.slice(close + 1);
+  }
+  return code;
+}
+
 /**
  * P1: any 타입 탐지 — .ts/.tsx 전용, 단어 경계 기반.
+ *
+ * 주석·문자열·템플릿 리터럴은 제외한다: `any` 를 **금지하는** 문서 문장이
+ * 그 자체로 P1 이 되면, 고칠 수도 없는 경고가 그 파일을 편집할 때마다
+ * 주입돼 게이트 신뢰도가 떨어진다 (detectConsoleLogs의 확장자 게이트와 같은 이유).
+ *
  * @param {string[]} lines
  * @returns {Array<{ line: number, match: string, severity: 'P1' }>}
  */
 function detectAnyType(lines) {
   const findings = [];
+  const state = { inBlock: false, inTemplate: false };
   lines.forEach((line, i) => {
+    const code = stripNonCodeLine(line, state);
     for (const re of P1_DETECTORS) {
-      if (re.test(line)) {
+      if (re.test(code)) {
         findings.push({
           line: i + 1,
           match: line.trim(),
@@ -135,8 +146,7 @@ function detectAnyType(lines) {
  * @returns {Array<{ line: number, match: string, severity: 'P1' }>}
  */
 function detectConsoleLogs(lines, filePath) {
-  if (!CODE_EXT_RE.test(filePath)) return [];
-  if (isConsoleAllowed(filePath)) return [];
+  if (!shouldCheckConsole(filePath)) return [];
   const findings = [];
   lines.forEach((line, i) => {
     if (/console\.log\(/.test(line)) {

package/hooks/scripts/lib/anchor.js

@@ -0,0 +1,74 @@
+/**
+ * ANCHOR — 루프 회전 시작 시 디스크에서 상태를 재고정한다.
+ *
+ * loop-contract 는 ANCHOR 를 컨텍스트 오염 방어의 근거로 규정하는데, JUDGE·RECORD·stuck 과
+ * 달리 실행 수단이 없어 모델 재량으로 남아 있었다 (감사 2026-07-28 L3). 재고정 대상이
+ * 무엇인지 결정론적으로 답하는 것이 이 모듈의 역할이다 — 파일 내용을 해석하지는 않는다.
+ */
+import fs from 'fs';
+import path from 'path';
+import { readLedger } from './run-ledger.js';
+
+/** 우선순위대로 첫 번째로 존재하는 경로를 고른다 */
+function firstExisting(projectDir, candidates) {
+  for (const rel of candidates) {
+    if (fs.existsSync(path.join(projectDir, rel))) return rel;
+  }
+  return null;
+}
+
+/** `.vibe/.last-feature` 에 기록된 직전 feature 이름 */
+function readLastFeature(projectDir) {
+  try {
+    const raw = fs.readFileSync(path.join(projectDir, '.vibe', '.last-feature'), 'utf-8').trim();
+    return raw.length > 0 ? raw : null;
+  } catch {
+    return null;
+  }
+}
+
+/** SPEC 경로 — 신규 레이아웃 우선, 레거시 폴백 */
+function findSpec(projectDir, feature) {
+  if (!feature) return null;
+  return firstExisting(projectDir, [
+    path.join('.vibe', 'specs', `${feature}.md`),
+    path.join('.vibe', 'specs', feature, '_index.md'),
+    path.join('.claude', 'vibe', 'specs', `${feature}.md`),
+    path.join('.claude', 'specs', `${feature}.md`),
+  ]);
+}
+
+/** 인박스에서 가장 최근 블록(다음 `## ` 직전까지) */
+function readLatestInboxBlock(projectDir) {
+  try {
+    const raw = fs.readFileSync(path.join(projectDir, '.vibe', 'loops', 'inbox.md'), 'utf-8');
+    const start = raw.indexOf('## ');
+    if (start === -1) return null;
+    const next = raw.indexOf('\n## ', start + 3);
+    return (next === -1 ? raw.slice(start) : raw.slice(start, next)).trim() || null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * 재고정 번들 — loop-contract ANCHOR 절이 지정한 SPEC + run-ledger + scope.json + 직전 인박스.
+ *
+ * @param {string} projectDir
+ * @param {string} [feature] - 생략 시 `.vibe/.last-feature`
+ * @returns {{ feature: string|null, spec: string|null, scope: string|null,
+ *             ledger: object|null, latestInbox: string|null, missing: string[] }}
+ */
+export function buildAnchor(projectDir, feature) {
+  const resolved = feature || readLastFeature(projectDir);
+  const spec = findSpec(projectDir, resolved);
+  const scope = firstExisting(projectDir, [path.join('.vibe', 'scope.json')]);
+  const ledger = readLedger(projectDir);
+
+  const missing = [];
+  if (!resolved) missing.push('feature');
+  if (!spec) missing.push('spec');
+  if (!ledger) missing.push('run-ledger');
+
+  return { feature: resolved, spec, scope, ledger, latestInbox: readLatestInboxBlock(projectDir), missing };
+}

package/hooks/scripts/lib/console-allow.js

@@ -0,0 +1,66 @@
+/**
+ * console.log 탐지의 적용 범위 판단 — code-check.js·post-edit.js 공용 (중복 제거).
+ *
+ * 두 훅이 같은 검사를 각자 들고 있으면 한쪽의 허용 경로 설계가 다른 쪽 경고에
+ * 무력화된다. 범위 규칙은 여기 하나만 둔다.
+ */
+import path from 'path';
+import { PROJECT_DIR, readProjectConfig } from '../utils.js';
+import { globToRegExp } from './glob.js';
+
+/**
+ * 코드 확장자 — 마크다운·JSON·텍스트에 인용된 `console.log(` 는 커밋되면 안 되는
+ * 디버그 코드가 아니라 문서상의 예시다.
+ */
+export const CODE_EXT_RE = /\.(ts|tsx|js|jsx|mjs|cjs)$/;
+
+// console.log 기본 허용 경로 (glob 패턴 → 정규식으로 변환)
+const DEFAULT_CONSOLE_ALLOW_GLOBS = [
+  'hooks/scripts/**',
+  'scripts/**',
+  '**/cli/**',
+  '**/*.test.*',
+  '**/*.spec.*',
+  '**/__tests__/**',
+];
+
+/**
+ * .vibe/config.json의 qualityCheck.consoleAllow 글로브 목록 로드.
+ * 기본 글로브와 병합하여 반환.
+ * @returns {RegExp[]}
+ */
+function loadConsoleAllowPatterns() {
+  try {
+    const cfg = readProjectConfig();
+    const extra = cfg?.qualityCheck?.consoleAllow;
+    const globs = Array.isArray(extra)
+      ? [...DEFAULT_CONSOLE_ALLOW_GLOBS, ...extra]
+      : DEFAULT_CONSOLE_ALLOW_GLOBS;
+    return globs.map(g => globToRegExp(g));
+  } catch {
+    return DEFAULT_CONSOLE_ALLOW_GLOBS.map(g => globToRegExp(g));
+  }
+}
+
+/**
+ * 파일 경로가 console.log 허용 경로인지 판단.
+ * @param {string} filePath - 절대 또는 프로젝트 상대 경로
+ * @returns {boolean}
+ */
+export function isConsoleAllowed(filePath) {
+  try {
+    const rel = path.relative(PROJECT_DIR, path.resolve(filePath)).replace(/\\/g, '/');
+    return loadConsoleAllowPatterns().some(re => re.test(rel));
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * console.log 검사 대상 파일인지 — 코드 확장자이면서 허용 경로가 아닌 경우.
+ * @param {string} filePath
+ * @returns {boolean}
+ */
+export function shouldCheckConsole(filePath) {
+  return CODE_EXT_RE.test(filePath) && !isConsoleAllowed(filePath);
+}

package/hooks/scripts/lib/dispatcher.js

@@ -1,5 +1,5 @@
 /**
- * Hook dispatcher library — 여러 hook script를 단일 이벤트에서 병렬 실행.
+ * Hook dispatcher library — 여러 hook script를 단일 이벤트에서 실행.
  *
  * 목적:
  * - stdin을 한 번만 읽어 각 자식에 동일 버퍼로 pipe (중복 파싱/읽기 방지)
@@ -7,14 +7,23 @@
  * - 한 스크립트 실패가 다른 스크립트를 막지 않도록 cascade 격리
  * - PreToolUse 계열: 자식 중 하나라도 exit 2(deny)면 상위에 전파
  *
- * 직렬 → 병렬 전환 (2026-04):
- *   기존 직렬 실행은 tool당 150~300ms 누적 오버헤드를 유발.
- *   PreToolUse 가드는 모두 독립적 검증자이므로 병렬화해도 의미상 문제 없음.
- *   트레이드오프:
- *     - early-deny 낭비: sentinel-guard가 block이어도 pre-tool/scope-guard가
- *       이미 spawn됨. 실측 μs 수준이라 무시.
- *     - stderr 인터리빙: 가드 2개가 동시 block 시 경고 메시지가 섞일 수 있음.
- *       각 메시지는 자체적으로 완결된 라인이라 가독성 문제 없음.
+ * 실행 모델이 둘로 갈린다 — 스텝이 서로 독립인지가 기준:
+ *
+ *   dispatch()          = 순차 (spawn). 유일한 사용처인 Stop 은 스텝끼리
+ *                         부작용을 공유한다(auto-commit 의 git 상태를
+ *                         devlog-gen 이 읽는다). 병렬화하면 auto-commit 의
+ *                         git cascade 와 겹쳐 프로세스가 폭주하고,
+ *                         devlog 가 커밋 이전 상태를 관측한다.
+ *                         회귀 방지: __tests__/stop-dispatcher-sequential.test.js
+ *
+ *   dispatchInProcess() = 병렬 (import). PreToolUse 가드는 모두 독립적
+ *                         검증자라 순서가 의미 없고, 직렬 실행은 tool당
+ *                         150~300ms 누적 오버헤드를 유발한다.
+ *                         트레이드오프:
+ *                           - early-deny 낭비: sentinel-guard가 block이어도
+ *                             pre-tool/scope-guard가 이미 실행됨. 실측 μs 수준.
+ *                           - stderr 인터리빙: 가드 2개가 동시 block 시 경고가
+ *                             섞일 수 있음. 각 메시지가 완결된 라인이라 무해.
  */
 import { spawn } from 'child_process';
 import path from 'path';
@@ -93,7 +102,11 @@ function buildChildEnv(stdinData) {
 }
 
 /**
- * 디스패처 실행 — 활성화된 스텝을 병렬로 spawn.
+ * 디스패처 실행 — 활성화된 스텝을 선언 순서대로 **순차** spawn.
+ *
+ * 순차인 이유는 파일 상단 주석 참고 — 스텝이 git 상태 같은 부작용을 공유한다.
+ * 앞 스텝이 실패해도 다음 스텝은 계속 실행한다(cascade 격리 유지).
+ *
  * @param {Array<{name: string, script: string, args?: string[], denyOnExit2?: boolean, timeoutMs?: number}>} steps
  */
 export async function dispatch(steps) {
@@ -101,12 +114,11 @@ export async function dispatch(steps) {
   const hookConfig = loadHookConfig();
 
   const enabledSteps = steps.filter(s => isEnabled(hookConfig, s.name));
-  const results = await Promise.all(
-    enabledSteps.map(step =>
-      runScript(step.script, step.args || [], stdinData, step.timeoutMs || 30000)
-        .then(code => ({ step, code }))
-    )
-  );
+  const results = [];
+  for (const step of enabledSteps) {
+    const code = await runScript(step.script, step.args || [], stdinData, step.timeoutMs || 30000);
+    results.push({ step, code });
+  }
 
   // 하나라도 deny(exit 2) 반환 → 상위에 전파
   if (results.some(({ step, code }) => step.denyOnExit2 && code === 2)) {

package/hooks/scripts/lib/inbox.js

@@ -0,0 +1,60 @@
+/**
+ * 루프 인박스 — 사람 리뷰 큐(`.vibe/loops/inbox.md`) 기록.
+ *
+ * loop-history.jsonl 은 결정론적으로 기록되는데 인박스만 모델이 마크다운을 직접
+ * prepend 하고 있었다 (감사 2026-07-28 L5). 블록 형식과 최신순 정렬을 코드가 보장한다.
+ *
+ * fail-open — 기록 실패가 루프를 멈추지 않는다.
+ */
+import fs from 'fs';
+import path from 'path';
+
+const HEADER = '# Loop Inbox\n\n> 루프가 남긴 사람 리뷰 큐. 최신 항목이 위에 온다.\n';
+
+function inboxPath(projectDir) {
+  return path.join(projectDir, '.vibe', 'loops', 'inbox.md');
+}
+
+/**
+ * 인박스 블록을 최상단에 prepend 한다.
+ *
+ * @param {string} projectDir
+ * @param {{ loop: string, result: 'ok'|'fail'|'stuck', at: string, lines?: string[] }} entry
+ *        at 은 호출자가 넘긴다 — 이 모듈은 시각을 직접 읽지 않는다 (테스트 결정성)
+ * @returns {boolean} 성공 여부
+ */
+export function prependInboxBlock(projectDir, entry) {
+  try {
+    if (!entry?.loop || !entry?.result || !entry?.at) return false;
+
+    const body = (entry.lines ?? []).map(l => `- ${l}`).join('\n');
+    const block = `## ${entry.loop} — ${entry.at} — ${entry.result}\n${body}\n`;
+
+    const target = inboxPath(projectDir);
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+
+    const existing = fs.existsSync(target) ? fs.readFileSync(target, 'utf-8') : '';
+    const blocksStart = existing.indexOf('## ');
+    const head = blocksStart === -1 ? HEADER : existing.slice(0, blocksStart);
+    const rest = blocksStart === -1 ? '' : existing.slice(blocksStart);
+
+    fs.writeFileSync(target, `${head}\n${block}\n${rest}`.replace(/\n{3,}/g, '\n\n'), 'utf-8');
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * 아직 처리되지 않은 블록 수 — `## ` 로 시작하는 줄의 개수.
+ * @param {string} projectDir
+ * @returns {number}
+ */
+export function countInboxBlocks(projectDir) {
+  try {
+    const raw = fs.readFileSync(inboxPath(projectDir), 'utf-8');
+    return raw.split('\n').filter(l => l.startsWith('## ')).length;
+  } catch {
+    return 0;
+  }
+}

package/hooks/scripts/loop-ledger.js

@@ -6,12 +6,17 @@
  *   node hooks/scripts/loop-ledger.js start <name>
  *   node hooks/scripts/loop-ledger.js end <name> <ok|fail|stuck> [summary]
  *   node hooks/scripts/loop-ledger.js check-stuck <name> <discoverHash>
+ *   node hooks/scripts/loop-ledger.js anchor [feature]
+ *   node hooks/scripts/loop-ledger.js inbox <name> <ok|fail|stuck> [line...]
  *
  * check-stuck: 'stuck' 또는 'ok'를 stdout에 출력하고 항상 exit 0.
+ * anchor: 재고정 번들 JSON을 stdout에 출력한다 (loop-contract ANCHOR 절).
  * 항상 exit 0 (fail-open).
  */
 
 import { appendLoopEvent, isStuck } from './lib/loop-ledger.js';
+import { buildAnchor } from './lib/anchor.js';
+import { prependInboxBlock } from './lib/inbox.js';
 
 const [, , subcommand, ...args] = process.argv;
 const projectDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
@@ -47,9 +52,27 @@ if (subcommand === 'start') {
   appendLoopEvent(projectDir, { loop, event: 'discover', discoverHash });
   process.stdout.write(stuck ? 'stuck\n' : 'ok\n');
 
+} else if (subcommand === 'anchor') {
+  // 회전 시작 시 디스크 재고정 — 모델이 무엇을 다시 읽어야 하는지 결정론적으로 답한다
+  process.stdout.write(JSON.stringify(buildAnchor(projectDir, args[0]), null, 2) + '\n');
+
+} else if (subcommand === 'inbox') {
+  const [loop, result, ...lines] = args;
+  if (!loop || !result) {
+    process.stdout.write('[loop-ledger] error: inbox 에 루프 이름과 결과(ok|fail|stuck)가 필요합니다\n');
+    process.exit(0);
+  }
+  const at = new Date().toISOString();
+  const ok = prependInboxBlock(projectDir, { loop, result, at, lines });
+  process.stdout.write(
+    ok ? `[loop-ledger] inbox recorded: loop=${loop} result=${result}\n`
+       : '[loop-ledger] WARNING: inbox write failed\n'
+  );
+
 } else {
   process.stdout.write(
-    '[loop-ledger] 사용법: start <name> | end <name> <ok|fail|stuck> [summary] | check-stuck <name> <hash>\n'
+    '[loop-ledger] 사용법: start <name> | end <name> <ok|fail|stuck> [summary] | '
+    + 'check-stuck <name> <hash> | anchor [feature] | inbox <name> <ok|fail|stuck> [line...]\n'
   );
 }
 

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

@@ -10,7 +10,10 @@
  *   auto-format — 코드 스타일 정규화 (변경 시 finding 반환)
  *   code-check  — 하드룰(any/console.log) 탐지 (additionalContext 주입만, 커밋 게이트 미연동)
  *   auto-test   — 관련 테스트 실행 (debounce 지원)
- *   post-edit   — console.log 감지
+ *
+ * post-edit.js 는 여기서 돌리지 않는다 — console.log 감지는 code-check 가 같은
+ * 허용 경로 규칙(lib/console-allow.js)으로 이미 수행한다. 둘 다 돌리면 허용
+ * 경로에서도 경고가 남는다. post-edit.js 는 antigravity-hooks.json 단독 등록용.
  *
  * 출력 계약 (Claude Code PostToolUse):
  *   findings 있음 → stdout에 JSON hookSpecificOutput 1개 출력, exit 0
@@ -33,7 +36,6 @@ import path from 'path';
 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() {
@@ -59,7 +61,6 @@ 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));

package/hooks/scripts/post-edit.js

@@ -10,9 +10,9 @@
 import { existsSync, readFileSync } from 'fs';
 import path from 'path';
 import { buildCliCtx, isDirectRun } from './lib/hook-context.js';
+import { shouldCheckConsole } from './lib/console-allow.js';
 
 const CONSOLE_LOG_RE = /console\.log\(/;
-const CODE_EXT_RE = /\.(ts|tsx|js|jsx|mjs|cjs)$/;
 
 /**
  * in-process 진입점 — console.log 감지만 수행.
@@ -25,7 +25,7 @@ export async function run(ctx) {
   try {
     const filePath = ctx.filePath;
 
-    if (filePath && CODE_EXT_RE.test(filePath)) {
+    if (filePath && shouldCheckConsole(filePath)) {
       const resolved = path.resolve(filePath);
       if (existsSync(resolved)) {
         const lines = readFileSync(resolved, 'utf-8').split('\n');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@su-record/vibe",
-  "version": "3.2.12",
+  "version": "3.2.14",
   "description": "AI Coding Framework for Claude Code — 7+ agents, 52 skills, multi-LLM orchestration",
   "type": "module",
   "main": "dist/cli/index.js",
@@ -31,6 +31,7 @@
     "validate:counts": "npx tsx scripts/validate-counts.ts",
     "test": "vitest run",
     "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
     "prepublishOnly": "pnpm build",
     "postinstall": "node -e \"import('./dist/cli/postinstall/main.js').then(m=>m.main()).catch(()=>{})\"",
     "release": "pnpm version patch && git push origin main --follow-tags"
@@ -66,7 +67,7 @@
     "access": "public"
   },
   "engines": {
-    "node": ">=18.0.0"
+    "node": ">=20.12.0"
   },
   "optionalDependencies": {
     "@anthropic-ai/claude-agent-sdk": "^0.2.6",
@@ -86,9 +87,10 @@
     "@types/better-sqlite3": "^7.6.13",
     "@types/node": "^22.0.0",
     "@types/papaparse": "^5.5.2",
+    "@vitest/coverage-v8": "^4.0.9",
     "ajv": "^8.17.1",
     "typescript": "^5.5.4",
-    "vitest": "^4.0.9"
+    "vitest": "^4.1.10"
   },
   "files": [
     "dist/",