@su-record/vibe 3.2.13 → 3.2.15

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(),
@@ -125,21 +136,27 @@ function detectAnyType(lines) {
 /**
  * P1: console.log 탐지 — 허용 경로가 아닌 곳의 src/ 코드.
  *
- * 코드 확장자에만 적용한다: 마크다운·JSON·텍스트에 인용된 `console.log(` 는
- * 커밋되면 안 되는 디버그 코드가 아니라 문서상의 예시다. 확장자 게이트가 없으면
- * SKILL.md 안의 bash/JS 스니펫이 매 편집마다 P1 으로 주입돼, 고칠 수도 없는
- * 경고가 반복되고 게이트 신뢰도가 떨어진다.
+ * 두 겹의 게이트를 쓴다:
+ *  1. 확장자 — 마크다운·JSON·텍스트에 인용된 `console.log(` 는 커밋되면 안 되는
+ *     디버그 코드가 아니라 문서상의 예시다. 이게 없으면 SKILL.md 안의 스니펫이
+ *     매 편집마다 P1 으로 주입된다.
+ *  2. 코드 구간 — 코드 파일 **안에서도** JSDoc 예시와 사용자에게 출력할 마크다운
+ *     템플릿 리터럴에 `console.log(` 가 등장한다. 원본 라인을 그대로 검사하면
+ *     그것들이 전부 P1 이 되어, 고칠 수 없는 경고가 반복되고 게이트 신뢰도가
+ *     떨어진다 — detectAnyType 이 stripNonCodeLine 을 쓰는 것과 같은 이유다.
+ *     (2026-07-28 감사: 실측 9건 중 7건이 이 오탐이었다)
  *
  * @param {string[]} lines
  * @param {string} filePath
  * @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 = [];
+  const state = { inBlock: false, inTemplate: false };
   lines.forEach((line, i) => {
-    if (/console\.log\(/.test(line)) {
+    const code = stripNonCodeLine(line, state);
+    if (/console\.log\(/.test(code)) {
       findings.push({
         line: i + 1,
         match: line.trim(),

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';
@@ -47,6 +56,44 @@ function isEnabled(hookConfig, name) {
   return true;
 }
 
+/**
+ * guard 크래시를 deny 로 승격할지 — `VIBE_HOOK_FAILCLOSED=0` 이면 끈다.
+ *
+ * fail-closed 는 "검증하지 못했으면 통과시키지 않는다" 는 안전한 기본값이지만,
+ * guard 에 버그가 생기면 Edit·Bash 가 전면 차단되어 guard 소스를 고칠 수단까지
+ * 막힌다. 그래서 탈출구는 선택이 아니라 **복구 유일 수단**이고, 차단 메시지가
+ * 스스로 그 방법을 알려줘야 한다 (교착에 빠진 사용자는 문서를 찾아볼 수 없다).
+ */
+function isFailClosed() {
+  return process.env.VIBE_HOOK_FAILCLOSED !== '0';
+}
+
+/**
+ * step 크래시를 stderr 에 드러낸다. 침묵하면 게이트가 죽은 줄도 모른다.
+ * @param {string} name
+ * @param {unknown} err
+ */
+function reportCrash(name, err) {
+  const message = (err && err.message) || String(err);
+  process.stderr.write(`[vibe] hook step "${name}" crashed: ${message}\n`);
+}
+
+/**
+ * 크래시한 step 의 종료 코드를 정한다.
+ * deny 권한(denyOnExit2)이 있는 guard 만 2(deny)로 승격한다 — 로깅용 step 하나가
+ * 죽었다고 도구 호출을 막을 이유는 없다.
+ * @param {{ name: string, denyOnExit2?: boolean }} step
+ * @returns {number}
+ */
+function crashExitCode(step) {
+  if (!step.denyOnExit2 || !isFailClosed()) return 1;
+  process.stderr.write(
+    `[vibe] blocked: guard "${step.name}" could not complete, so the operation was not verified.\n` +
+    `       To bypass temporarily, re-run with VIBE_HOOK_FAILCLOSED=0\n`
+  );
+  return 2;
+}
+
 async function readStdin() {
   if (process.stdin.isTTY) return '';
   let data = '';
@@ -93,7 +140,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 +152,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)) {
@@ -138,9 +188,11 @@ export async function dispatchInProcess(steps, { argvToolName = '' } = {}) {
     enabledSteps.map(async (step) => {
       try {
         return { step, code: await step.run(ctx) };
-      } catch {
-        // 크래시 격리 — 실패 step은 exit 1 취급, 나머지 step과 디스패처는 계속
-        return { step, code: 1 };
+      } catch (err) {
+        // 크래시 격리는 유지하되 침묵하지 않는다. deny 권한이 있는 guard 는
+        // 검증에 실패한 것이므로 통과시키지 않는다 (fail-closed).
+        reportCrash(step.name, err);
+        return { step, code: crashExitCode(step) };
       }
     })
   );

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.13",
+  "version": "3.2.15",
   "description": "AI Coding Framework for Claude Code — 7+ agents, 52 skills, multi-LLM orchestration",
   "type": "module",
   "main": "dist/cli/index.js",
@@ -21,7 +21,7 @@
     "vibe": "dist/cli/index.js"
   },
   "scripts": {
-    "build": "tsc && chmod +x dist/cli/index.js",
+    "build": "tsc -p tsconfig.build.json && chmod +x dist/cli/index.js",
     "dev": "tsc --watch",
     "gen:skill-docs": "npx tsx scripts/gen-skill-docs.ts",
     "gen:skill-docs:check": "npx tsx scripts/gen-skill-docs.ts --check",
@@ -31,8 +31,9 @@
     "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(()=>{})\"",
+    "postinstall": "node -e \"import('./dist/cli/postinstall/main.js').then(m=>m.main()).catch(e=>process.stderr.write('\\u26a0\\ufe0f  vibe postinstall skipped: '+((e&&e.message)||e)+'\\n   Assets and hooks were not installed. Run: npx vibe upgrade\\n'))\"",
     "release": "pnpm version patch && git push origin main --follow-tags"
   },
   "keywords": [
@@ -66,16 +67,17 @@
     "access": "public"
   },
   "engines": {
-    "node": ">=18.0.0"
+    "node": ">=20.12.0"
   },
+  "packageManager": "pnpm@9.15.9",
   "optionalDependencies": {
-    "@anthropic-ai/claude-agent-sdk": "^0.2.6",
+    "@anthropic-ai/claude-agent-sdk": "^0.2.38",
     "@ast-grep/napi": "^0.40.5"
   },
   "dependencies": {
     "@clack/prompts": "^1.0.0",
     "better-sqlite3": "^12.9.0",
-    "chalk": "^5.3.0",
+    "chalk": "^5.6.2",
     "glob": "^13.0.1",
     "papaparse": "^5.5.3",
     "ts-morph": "^26.0.0",
@@ -84,11 +86,12 @@
   },
   "devDependencies": {
     "@types/better-sqlite3": "^7.6.13",
-    "@types/node": "^22.0.0",
+    "@types/node": "^22.19.10",
     "@types/papaparse": "^5.5.2",
+    "@vitest/coverage-v8": "^4.1.10",
     "ajv": "^8.17.1",
-    "typescript": "^5.5.4",
-    "vitest": "^4.0.9"
+    "typescript": "^5.9.3",
+    "vitest": "^4.1.10"
   },
   "files": [
     "dist/",
@@ -97,6 +100,7 @@
     "agents/",
     "skills/",
     "hooks/",
+    "!hooks/scripts/__tests__",
     ".env.example",
     "CLAUDE.md",
     "README.md",