@su-record/vibe 3.2.13 → 3.2.14

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.13",
+  "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/",

package/skills/vibe/SKILL.md

@@ -178,10 +178,11 @@ Phase 4: /vibe.verify → 검증
 스킬 **이름과 인자**가 계약이고, 그것을 실제 호출로 바꾸는 것은 각 하네스의 몫이다.
 
 각 phase 종료 후 JUDGE 단계:
-- 게이트 통과 (P1=0 ∧ verifyPassed) → 루프 종료, Phase 5 보고
+- 게이트 통과 (**측정된** P1=0 ∧ verifyPassed) → 루프 종료, Phase 5 보고. 판정된 P1(리뷰어 findings)은 단독으로 게이트를 막지 않는다 — SSOT: `vibe/rules/loop-contract.md` Judge 권한 경계
 - 게이트 미통과 → RECORD(run-ledger + loop-history.jsonl) 후 다음 ANCHOR로
 - stuck(연속 2회 동일 findings 해시) → **어느 automationLevel 에서도 루프를 종료한다.** `confirm`이면 사용자 질문, `autonomous`이면 질문 없이 TODO 기록 후 다음 독립 단위로. 미달을 완료로 기록하지 않는다 (SSOT: `vibe/rules/loop-contract.md` stuck 절)
 - max_iterations(기본 10) 도달 → 잔여를 인박스로 이월
+- **실행 실패(error)** — 스킬 미설치·도구 부재·파일 없음·명령 비정상 종료는 stuck 이 아니다(해시 비교로 안 잡힌다). 같은 방식으로 재시도하지 않고 루프를 종료한다: `confirm` 이면 원인을 제시하고 조치/건너뛰기/중단을 묻고, `autonomous` 이면 `loop-ledger.js inbox <name> fail "<원인>"` 기록 후 다음 독립 단위로. 실행 실패도 완료로 기록하지 않는다 (SSOT: `vibe/rules/loop-contract.md` 실행 실패 절)
 
 ### Phase 5: 종료 보고
 

package/skills/vibe.clone/references/verification-loops.md

@@ -6,7 +6,8 @@
 ## Phase 4: Compile Gate
 
 ```
-No round cap. Loop until compile succeeds (or stuck → ask user).
+No round cap. Loop until compile succeeds (or stuck → end loop; automationLevel decides
+whether the user is asked — see Termination below).
 
 0. Capture baseline (before Phase 3): record existing tsc + build errors
    → Phase 4 only fixes NEW errors
@@ -33,7 +34,8 @@ Termination:
 **⛔ Skipping Phase 5 makes the entire clone "incomplete".**
 
 ```
-No round cap. Loop until P1=0 (or stuck → ask user).
+No round cap. Loop until P1=0 (or stuck → end loop; automationLevel decides whether the
+user is asked — see Termination below).
 Infrastructure: src/infra/lib/browser/ (Puppeteer + CDP) — same as figma Phase 6.
 
 1. Render scaffolded page in dev server at matching viewport
@@ -52,7 +54,8 @@ Narrowing scope:
 Termination:
   ✅ P1=0 AND no new findings → complete
   ⚠️ Stuck: same findings → ask user (resolve / proceed / abort)
-  automationLevel: autonomous → on stuck, record TODO without prompting and complete
+  automationLevel: autonomous → on stuck, record TODO without prompting and end the loop
+     as `stuck` — never record unresolved P1 as complete (SSOT: vibe/rules/loop-contract.md)
 
 Responsive: after MO verification → change viewport → repeat against PC screenshot
 Post-merge (Phase 3C): re-run at BOTH viewports (375×812 vs mo/screenshot.png,

package/skills/vibe.loop/SKILL.md

@@ -69,6 +69,9 @@ node -e "import('{{VIBE_PATH_URL}}/node_modules/@su-record/vibe/dist/tools/index
 `status: paused` 루프는 즉시 종료. 실행 순서는 **전부 의무**이며 생략 불가:
 
 ```
+0. ANCHOR   node "$HOOKS_DIR/loop-ledger.js" anchor [feature]
+             → missing[] 이 비어 있지 않으면 없는 아티팩트를 기억으로 메우지 않는다.
+               재고정 실패를 인박스에 남기고 종료한다.
 1. 검증     validateLoopDefinition 통과 확인 (위 design 3의 명령) — 실패 시 인박스에 기록 후 종료
 2. 시작 기록  node "$HOOKS_DIR/loop-ledger.js" start <name>
 3. DISCOVER  정의의 discover 지시 실행 → 일거리 목록 산출
@@ -84,10 +87,10 @@ node -e "import('{{VIBE_PATH_URL}}/node_modules/@su-record/vibe/dist/tools/index
              · tests:  정의의 test_command 실행 → exit 0 만 성공
              · none:   판정 생략(보고만). "코드를 보니 잘 된 것 같다"는 판정이 아니다.
 7. 종료 기록  node "$HOOKS_DIR/loop-ledger.js" end <name> <ok|fail|stuck> "<한 줄 요약>"
-8. 인박스    $INBOX 상단에 결과 블록 prepend:
-             ## <name> — <ISO 시각> — <ok|fail|stuck>
-             - 발견: N건 / 처리: M건 / 검증: <기준과 결과>
-             - 리뷰 필요: <항목들 — 없으면 "없음">
+8. 인박스    node "$HOOKS_DIR/loop-ledger.js" inbox <name> <ok|fail|stuck> \
+               "발견: N건 / 처리: M건 / 검증: <기준과 결과>" \
+               "리뷰 필요: <항목들 — 없으면 없음>"
+             → 블록 형식과 최신순 정렬은 명령이 보장한다. 손으로 마크다운을 쓰지 않는다.
 ```
 
 **금지**: `git push`, `gh pr merge`, `npm publish`, 버전 범프, 릴리즈 — 루프는 커밋까지만 가며(auto-commit verify 게이트 통과 시), 그 이상은 인박스를 본 사람이 한다.

package/skills/vibe.review/SKILL.md

@@ -79,7 +79,11 @@ user-invocable: true
 
 - **P1 = 0 means MERGE READY** — mergeable even with remaining P2/P3
 - **P1 = 0 after auto-fix means DONE** — record P2 auto-fix failures as TODO and stop
-- **Final P1 list unchanged after Review Debate → DONE** — no new findings = converged
+- **P1 = 0 AND final P1 list unchanged after Review Debate → DONE** — converged
+- **P1 > 0 AND final P1 list unchanged → STUCK, not DONE** — 같은 발견이 2회 연속이면
+  루프는 종료하되 **완료로 기록하지 않는다**. `confirm` 이면 사용자에게 묻고, `autonomous`
+  이면 TODO 로 남긴다 (SSOT: `vibe/rules/loop-contract.md` stuck 절). "목록이 안 바뀌었으니
+  수렴했다" 는 남은 P1 을 완료로 포장하는 것이다
 
 ### Anti-Patterns (FORBIDDEN)
 

package/skills/vibe.run/references/e2e-and-autofix.md

@@ -34,7 +34,7 @@ Scenario verification failed
 
 **Stakes 프로파일 (SSOT: `vibe/rules/loop-contract.md` Stakes 표):**
 - `demo`/`prototype` → max_iterations 1, 리뷰 1패스, **검증 스크립트 신규 생성 금지** — 검증은 기존 테스트 러너·브라우저 게이트만 사용한다. 새 verify_*.py / 검증 전용 스크립트 파일을 만들지 않는다.
-- JUDGE 검증 산출물 절제 (모든 stakes): 이번 feature 신규 검증 코드 바이트 합이 신규 구현 코드 바이트 합을 초과하면 (`git diff --numstat` 기준) P2 경고를 run-ledger 에 기록한다. advisory — 게이트 통과 여부는 불변.
+- JUDGE 검증 산출물 절제 (모든 stakes): 이번 feature 신규 검증 코드 줄 수가 신규 구현 코드 줄 수를 초과하면 (`git diff --numstat` 기준) **최종 보고에 P2 경고 1줄**을 적는다. run-ledger 에는 적재하지 않는다 (경고 필드 없음). advisory — 게이트 통과 여부는 불변.
 
 ---
 

package/skills/vibe.run/references/process-steps.md

@@ -173,7 +173,7 @@ node -e "import('{{VIBE_PATH_URL}}/node_modules/@su-record/vibe/dist/tools/index
 
 > Default SPEC path is `.vibe/specs/<feature>.md`. `status === 'empty'` must be treated as failed/not-applicable — never as 100% pass.
 
-JUDGE: `coveragePercent === 100` → 루프 종료. stuck(연속 2회 동일 커버리지) → automationLevel confirm이면 사용자 질문; autonomous이면 TODO + done.
+JUDGE: `coveragePercent === 100` → 루프 종료. stuck(연속 2회 동일 발견 해시 — `loop-ledger.js check-stuck`; 커버리지 수치가 아니라 발견으로 판정한다) → **어느 automationLevel 에서도 루프를 종료한다**; confirm이면 사용자 질문, autonomous이면 TODO 기록 후 다음 독립 단위로. 미달 커버리지를 완료로 기록하지 않는다 (SSOT: `vibe/rules/loop-contract.md`).
 
 ---
 

package/vibe/constitution.md

@@ -81,7 +81,7 @@ All reference documents are stored globally and specified in `.vibe/config.json`
 - **DRY**: Don't Repeat Yourself
 - **SRP**: Single Responsibility Principle
 - **YAGNI**: You Aren't Gonna Need It
-- **Functions ≤30 lines** (recommended), ≤50 lines (allowed)
+- **Functions ≤50 lines** (SSOT: `CLAUDE.md` Complexity Limits)
 - **Cyclomatic Complexity ≤10**
 - **Cognitive Complexity ≤15**
 

package/vibe/rules/loop-contract.md

@@ -21,15 +21,35 @@
                Model Judge(advisory-only): 발견을 제안하지만 완료 권한 없음
                Human Taste(release-only): UX·브랜드·제품 감각을 판단하지만 루프 완료 권한 없음
       RECORD   run-ledger + `.vibe/runs/{run-id}/evidence.json` + loop-history.jsonl
-  → 종료(EXIT): 게이트 전부 통과 │ stuck │ max_iterations │ 예산 상한
+  → 종료(EXIT): 게이트 전부 통과 │ stuck │ max_iterations │ 예산 상한 │ 실행 실패(error)
 ```
 
 ### ANCHOR가 컨텍스트 오염 방어인 이유
 루프 상태는 컨텍스트가 아니라 디스크에 산다. 매 회전이 아티팩트에서 다시 시작하므로 컨텍스트가 오염되거나 compact로 소실돼도 루프는 깨지지 않으며, 회전마다 fresh 컨텍스트(서브에이전트)로 돌려도 된다.
 
+**재고정은 명령으로 한다** — 모델의 기억이 아니라 디스크가 답한다:
+
+```bash
+node "$HOOKS_DIR/loop-ledger.js" anchor [feature]
+# → { feature, spec, scope, ledger, latestInbox, missing[] }
+```
+
+`missing` 이 비어 있지 않으면 그 회전은 재고정에 실패한 것이다 — 없는 아티팩트를 기억으로 메우지 않는다. JUDGE·RECORD·stuck 이 전부 명령으로 판정되는데 ANCHOR만 산문 지시로 남아 있으면, 정작 오염 방어의 근거가 되는 단계가 가장 약해진다.
+
 ### Judge 권한 경계
 종료 권한은 테스트 exit code·run-ledger·RTM 같은 **결정론적 Judge**에만 있다. Model Judge는 누락·모순·위험을 발견하는 보조 수단이며, 발견을 테스트나 관측 가능한 기준으로 내리기 전에는 차단 근거가 아니다. Human Taste는 공개·배포 시점의 사람 판단으로 남고 루프의 완료 상태를 변경하지 않는다.
 
+#### P1 은 출처가 둘이다 — exit 기준은 이를 구분한다
+
+"P1" 이 가리키는 것이 두 가지이고, 위 권한 경계는 그중 하나에만 적용된다.
+
+| 출처 | 예 | 성격 | exit 게이트 |
+|---|---|---|---|
+| **측정된 P1** | clone Phase 5 `pixelmatch diffRatio > 0.05`, computed CSS delta > 2px, contract drift, 테스트 실패 | 결정론 | **차단한다** — 게이트 통과 = 측정 P1 0 |
+| **판정된 P1** | `vibe.review` 리뷰어 findings | Model Judge | **단독으로 차단하지 않는다** — 테스트·관측 기준으로 내려야 게이트가 된다 |
+
+판정된 P1 이 남았는데 내릴 기준이 없으면, 그것은 게이트 실패가 아니라 **인박스로 가는 리뷰 항목**이다. 동일한 판정 P1 이 2회 연속 반복되면 stuck 이며 — 완료가 아니다 (아래 stuck 절).
+
 ### stuck (결정론)
 연속 2회 회전의 발견(discover/findings) 해시가 동일 → **그 루프는 종료한다** (`loop-ledger.js check-stuck`이 판정·기록). "다시 해보면 될 것 같다"는 모델 판단으로 무시 금지.
 
@@ -42,12 +62,25 @@
 
 > `autonomous` 의 "계속" 은 **stuck 난 루프를 더 돌린다는 뜻이 아니다** — 2회 연속 동일 발견은 정의상 재시도가 무의미하다. 같은 목표를 붙잡지 않고 다음 단위로 넘어간다는 뜻이며, 미달은 TODO/인박스에 남는다. 미달 상태를 **완료로 기록하지 않는다.**
 
+### 실행 실패 (error) — stuck 과 다른 종료 사유
+
+stuck 은 **같은 발견이 반복되는** 상태다. 스킬이 로드되지 않거나, 도구가 없거나, 파일이 없거나, 명령이 비정상 종료하는 것은 stuck 이 아니라 **실행 실패**이며 해시 비교로는 잡히지 않는다. 재시도 대상도 아니다 — 환경이 바뀌지 않는 한 결과가 같다.
+
+| | 루프 | 사람에게 질문 | 그 다음 |
+|---|---|---|---|
+| `confirm` | 종료 | **한다** (원인 제시 + 조치 요청 / 건너뛰기 / 중단) | 사용자 응답에 따름 |
+| `autonomous` | 종료 | 하지 않음 | 인박스에 원인 기록 후 **다음 독립 단위로** |
+
+- 실패한 단계를 **같은 방식으로 재시도하지 않는다.** 재시도가 의미 있으려면 무엇이 달라지는지 말할 수 있어야 한다 (`vibe.review` 의 escalation ladder 가 그 예 — 재시도 1회 → 다른 하네스 1회 → TODO).
+- 실행 실패도 **완료가 아니다.** stuck 과 동일하게, 미달 상태를 완료로 기록하지 않는다.
+- 원인은 인박스에 남긴다: `loop-ledger.js inbox <name> fail "<원인 한 줄>"`.
+
 ## 파라미터 (기본값)
 
 | 파라미터 | 기본 | 의미 |
 |---|---|---|
 | `max_iterations` | 10 | 회전 상한. 도달 시 잔여를 인박스로 이월 |
-| `exit` | 게이트 통과 (P1=0 ∧ verifyPassed) | 종료 기준. coverage 100% 등으로 상향 가능 |
+| `exit` | 게이트 통과 (**측정된** P1=0 ∧ verifyPassed) | 종료 기준. coverage 100% 등으로 상향 가능. 판정된 P1 은 위 Judge 권한 경계 표를 따른다 |
 | `--interactive` | off | 단계별 확인 모드 (회전마다 사람 승인 — 과거의 기본값) |
 | `--max-iter N` | — | 회전 상한 명시 (N=1이면 1회 시도) |
 | `automationLevel` | `confirm` | `confirm`(SPEC·stuck에서 질문) / `autonomous`(질문 없이 TODO 기록 후 다음 단위로, 비대화형) — `.vibe/config.json`. **어느 값에서도 stuck 은 루프를 종료한다** (위 stuck 절) |
@@ -69,7 +102,11 @@
 
 ### JUDGE 검증 산출물 절제 (모든 stakes 공통)
 
-JUDGE는 이번 feature의 **신규 생성 파일** 기준으로 검증 코드 총량(테스트·검증 스크립트)과 구현 코드 총량을 `git diff --numstat` 로 비교한다. 검증 코드 바이트 합 > 구현 코드 바이트 합이면 **P2 경고**를 run-ledger 에 기록한다 (restraint 원칙의 프로세스 적용). 경고는 advisory — 게이트 통과 여부를 바꾸지 않는다.
+검증은 실패 비용보다 싸야 한다 — 검증 코드가 구현 코드보다 커지면 그 루프는 남는 장사가 아니다.
+
+JUDGE는 이번 feature의 **신규 생성 파일** 기준으로 검증 코드 총량(테스트·검증 스크립트)과 구현 코드 총량을 `git diff --numstat` 로 비교하고, 검증 코드 줄 수가 구현 코드 줄 수를 넘으면 **최종 보고에 P2 경고 1줄**을 적는다 (restraint 원칙의 프로세스 적용).
+
+> ⚠️ 이 경고는 **보고용이며 어디에도 적재되지 않는다.** run-ledger 스키마(`runId`·`runStarted`·`runFeature`·`verifyPassed`·`verifyAt`·`stopWarned`·`verifyRequired`·`verifyRequiredReason`)에는 경고 필드가 없다 — 기록을 지시하면 갈 곳 없는 지시가 된다. 게이트 통과 여부를 바꾸지 않는다.
 
 ## 금지 (루프 권한 경계)
 

package/vibe/rules/quality/checklist.md

@@ -28,7 +28,7 @@ const typeSafety = {
 ```typescript
 const codeStructure = {
   singleResponsibility: true,    // ✅ Single Responsibility Principle
-  functionUnder30Lines: true,    // ✅ Functions ≤30 lines (recommended), 50 allowed
+  functionUnder50Lines: true,    // ✅ Functions ≤50 lines
   maxNesting3Levels: true,       // ✅ Max nesting 3 levels
   cyclomaticComplexity: 10,      // ✅ Cyclomatic complexity ≤ 10
   cognitiveComplexity: 15,       // ✅ Cognitive complexity ≤ 15
@@ -171,7 +171,7 @@ const bundleOptimization = {
 
 ```text
 [ ] Follow Single Responsibility Principle
-[ ] Keep function length ≤30 lines (max 50)
+[ ] Keep function length ≤50 lines
 [ ] Nesting depth ≤3 levels
 [ ] Extract magic numbers to constants
 [ ] Ensure type safety
@@ -266,7 +266,7 @@ npm run format:check
 ```text
 ✅ Only modified requested scope?
 ✅ No any types?
-✅ Functions ≤30 lines? (max 50)
+✅ Functions ≤50 lines?
 ✅ Nesting ≤3 levels?
 ✅ Error handling implemented?
 ✅ Magic numbers extracted to constants?

package/vibe/templates/constitution-template.md

@@ -99,7 +99,7 @@ All reference documents are stored globally and specified in `.vibe/config.json`
 - **DRY**: Don't Repeat Yourself
 - **SRP**: Single Responsibility Principle
 - **YAGNI**: You Aren't Gonna Need It
-- **Functions ≤30 lines** (recommended), ≤50 lines (allowed)
+- **Functions ≤50 lines** (SSOT: `CLAUDE.md` Complexity Limits)
 - **Cyclomatic Complexity ≤10**
 - **Cognitive Complexity ≤15**