@su-record/vibe 3.2.0 → 3.2.1

package/hooks/scripts/lib/run-ledger.js

@@ -2,7 +2,7 @@
  * Run Ledger — vibe.run 실행 및 vibe.verify 결과 추적.
  *
  * 파일 위치: <projectDir>/.vibe/metrics/run-ledger.json
- * 형식: { runStarted, runFeature, verifyPassed, verifyAt, stopWarned,
+ * 형식: { runId, runStarted, runFeature, verifyPassed, verifyAt, stopWarned,
  *         verifyRequired, verifyRequiredReason }
  *
  * 모든 함수는 fail-open (try/catch, 오류 시 null/false 반환).
@@ -10,14 +10,56 @@
  */
 
 import fs from 'fs';
-import os from 'os';
+import { randomUUID } from 'crypto';
 import path from 'path';
 
+const EVIDENCE_SCHEMA_VERSION = '1.0.0';
+const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+
 /** 레저 파일 경로 */
 function ledgerPath(projectDir) {
   return path.join(projectDir, '.vibe', 'metrics', 'run-ledger.json');
 }
 
+function evidencePath(projectDir, runId) {
+  if (!UUID_PATTERN.test(runId)) return null;
+  const runsDir = path.resolve(projectDir, '.vibe', 'runs');
+  const target = path.resolve(runsDir, runId, 'evidence.json');
+  return target.startsWith(`${runsDir}${path.sep}`) ? target : null;
+}
+
+function writeJsonAtomic(targetPath, data) {
+  if (!targetPath) return false;
+  const dir = path.dirname(targetPath);
+  fs.mkdirSync(dir, { recursive: true });
+  const tmp = path.join(dir, `.${path.basename(targetPath)}.${process.pid}.${Date.now()}.tmp`);
+  try {
+    fs.writeFileSync(tmp, JSON.stringify(data, null, 2), 'utf-8');
+    fs.renameSync(tmp, targetPath);
+    return true;
+  } catch {
+    try { fs.rmSync(tmp, { force: true }); } catch { /* fail-open */ }
+    return false;
+  }
+}
+
+function withLedgerLock(projectDir, operation) {
+  const lockPath = path.join(projectDir, '.vibe', 'metrics', 'run-ledger.lock');
+  let descriptor;
+  try {
+    fs.mkdirSync(path.dirname(lockPath), { recursive: true });
+    descriptor = fs.openSync(lockPath, 'wx');
+    return operation();
+  } catch {
+    return false;
+  } finally {
+    if (descriptor !== undefined) {
+      fs.closeSync(descriptor);
+      try { fs.rmSync(lockPath, { force: true }); } catch { /* fail-open */ }
+    }
+  }
+}
+
 /**
  * 레저 파일 읽기.
  * @param {string} projectDir
@@ -41,12 +83,61 @@ export function readLedger(projectDir) {
  */
 function writeLedger(projectDir, data) {
   try {
-    const p = ledgerPath(projectDir);
-    fs.mkdirSync(path.dirname(p), { recursive: true });
-    const tmp = path.join(os.tmpdir(), `run-ledger-${process.pid}-${Date.now()}.tmp`);
-    fs.writeFileSync(tmp, JSON.stringify(data, null, 2), 'utf-8');
-    fs.renameSync(tmp, p);
-    return true;
+    return writeJsonAtomic(ledgerPath(projectDir), data);
+  } catch {
+    return false;
+  }
+}
+
+function verificationResults(results) {
+  if (Array.isArray(results)) {
+    return results
+      .filter(item => item
+        && typeof item === 'object'
+        && typeof item.command === 'string'
+        && Number.isInteger(item.exitCode))
+      .map(item => ({
+        command: item.command,
+        exitCode: item.exitCode,
+      }));
+  }
+  return [];
+}
+
+function resolveSpecPath(projectDir, feature) {
+  if (typeof feature !== 'string' || feature.includes('..') || /[\\/]/.test(feature)) {
+    return null;
+  }
+  const flatPath = `.vibe/specs/${feature}.md`;
+  if (fs.existsSync(path.join(projectDir, flatPath))) return flatPath;
+  const splitPath = `.vibe/specs/${feature}/_index.md`;
+  return fs.existsSync(path.join(projectDir, splitPath)) ? splitPath : null;
+}
+
+function buildEvidence(projectDir, ledger, passed, generatedAt) {
+  return {
+    schemaVersion: EVIDENCE_SCHEMA_VERSION,
+    runId: ledger.runId,
+    specPath: resolveSpecPath(projectDir, ledger.runFeature),
+    generatedAt,
+    judges: {
+      deterministic: {
+        authority: 'blocking',
+        verifyPassed: Boolean(passed),
+        verificationResults: verificationResults(ledger.verificationResults),
+      },
+      model: { authority: 'advisory-only', canComplete: false },
+      humanTaste: { authority: 'release-only', canComplete: false },
+    },
+  };
+}
+
+function writeEvidence(projectDir, ledger, passed, generatedAt) {
+  try {
+    return writeJsonAtomic(
+      evidencePath(projectDir, ledger.runId),
+      buildEvidence(projectDir, ledger, passed, generatedAt),
+    );
   } catch {
     return false;
   }
@@ -59,10 +150,12 @@ function writeLedger(projectDir, data) {
  * @returns {boolean} 성공 여부
  */
 export function recordRunStart(projectDir, feature) {
-  try {
+  return withLedgerLock(projectDir, () => {
     const existing = readLedger(projectDir) || {};
+    const { verificationResults: _results, verificationCommands: _commands, ...retained } = existing;
     const next = {
-      ...existing,
+      ...retained,
+      runId: randomUUID(),
       runStarted: new Date().toISOString(),
       runFeature: feature || null,
       verifyPassed: false,
@@ -70,9 +163,7 @@ export function recordRunStart(projectDir, feature) {
       stopWarned: false,
     };
     return writeLedger(projectDir, next);
-  } catch {
-    return false;
-  }
+  });
 }
 
 /**
@@ -80,25 +171,36 @@ export function recordRunStart(projectDir, feature) {
  * pass 시 verifyRequired 상태를 클리어한다.
  * @param {string} projectDir
  * @param {boolean} passed - 검증 통과 여부
+ * @param {{runId?: string, verificationResults?: object[]}} options
  * @returns {boolean} 성공 여부
  */
-export function recordVerify(projectDir, passed) {
-  try {
+export function recordVerify(projectDir, passed, options = {}) {
+  return withLedgerLock(projectDir, () => {
     const existing = readLedger(projectDir) || {};
+    const existingRunId = UUID_PATTERN.test(existing.runId || '') ? existing.runId : null;
+    if (existing.runId !== undefined && !existingRunId) return false;
+    if (existingRunId && options.runId !== existingRunId) return false;
+    const runId = existingRunId || randomUUID();
+    const results = verificationResults(options.verificationResults);
+    if (passed && (results.length === 0 || results.some(result => result.exitCode !== 0))) {
+      return false;
+    }
+    const generatedAt = new Date().toISOString();
     const next = {
       ...existing,
+      runId,
       verifyPassed: Boolean(passed),
-      verifyAt: new Date().toISOString(),
+      verifyAt: generatedAt,
+      verificationResults: results,
     };
     // pass 시 verifyRequired 클리어
     if (passed) {
       next.verifyRequired = false;
       next.verifyRequiredReason = null;
     }
+    if (!writeEvidence(projectDir, next, passed, generatedAt)) return false;
     return writeLedger(projectDir, next);
-  } catch {
-    return false;
-  }
+  });
 }
 
 /**
@@ -144,9 +246,9 @@ export function markStopWarned(projectDir) {
  */
 export function extractRunFeature(prompt) {
   try {
-    const m = prompt.match(/(?:\/|\$)vibe\.run\s+([^\s]+)/i);
+    const m = prompt.match(/(?:\/|\$)vibe\.run\s+(?:"([^"]+)"|'([^']+)'|([^\s]+))/i);
     if (!m) return null;
-    const token = m[1];
+    const token = m[1] || m[2] || m[3];
     // 플래그(-- 시작)나 키워드는 기능명이 아님
     if (token.startsWith('-')) return null;
     return token;

package/hooks/scripts/verify-ledger.js

@@ -2,7 +2,7 @@
 /**
  * verify-ledger CLI — vibe.verify 결과를 run-ledger에 기록.
  *
- * 사용법: node hooks/scripts/verify-ledger.js pass|fail
+ * 사용법: node hooks/scripts/verify-ledger.js pass|fail <run-id> <results-json-path>
  *
  * vibe.verify/SKILL.md 에서 검증 완료 시 호출.
  * stdout 출력은 에이전트가 Bash로 실행하는 컨텍스트이므로 허용.
@@ -10,13 +10,33 @@
  */
 
 import { recordVerify } from './lib/run-ledger.js';
+import fs from 'fs';
 
 const arg = process.argv[2];
+const runId = process.argv[3];
+const resultsPath = process.argv[4];
 const passed = arg === 'pass';
 const projectDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
 
-recordVerify(projectDir, passed);
+function readResults(filePath) {
+  try {
+    if (!filePath) return [];
+    const parsed = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+
+const recorded = recordVerify(projectDir, passed, {
+  runId,
+  verificationResults: readResults(resultsPath),
+});
 
 const status = passed ? 'pass' : 'fail';
-process.stdout.write(`[verify-ledger] recorded: verifyPassed=${passed} (${status})\n`);
+if (recorded) {
+  process.stdout.write(`[verify-ledger] recorded: verifyPassed=${passed} (${status})\n`);
+} else {
+  process.stderr.write('[verify-ledger] WARNING: run-ledger or evidence.json write failed\n');
+}
 process.exit(0);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@su-record/vibe",
-  "version": "3.2.0",
+  "version": "3.2.1",
   "description": "AI Coding Framework for Claude Code — 7+ agents, 60 skills, multi-LLM orchestration",
   "type": "module",
   "main": "dist/cli/index.js",

package/skills/spec/SKILL.md

@@ -54,10 +54,15 @@ Task(subagent_type="Explore",
 `vibe/templates/spec-template.md` 구조로 `.vibe/specs/{feature-name}.md` 를 작성한다. 핵심 요건:
 
 - **Overview / Goal** — 무엇을, 왜. 1-3 문장.
+- **Context Sources** — 입력으로 사용한 파일·문서·URL·관측 상태. 출처 없는 추정은 Assumptions 로 분리.
+- **Requirements** — `REQ-{feature}-NNN` ID와 연결된 Done Criteria를 표로 명시.
 - **Done Criteria** — 결정론적 게이트만. 각 항목은 "명령/관찰로 pass·fail 판정 가능"해야 한다 (테스트 exit code, 빌드 성공, 특정 동작 관찰). "잘 동작한다" 류 서술 금지 — 이것이 루프의 JUDGE 입력이 된다.
+- **Evidence Required** — Done 을 증명할 명령 결과·테스트 리포트·로그·스크린샷·코드 위치.
+- **Human Taste (Non-Blocking)** — UX·브랜드·제품 감각처럼 release 시 사람이 판단할 기준. 완료 게이트로 쓰지 않는다.
 - **Scenarios** — Given-When-Then. Happy path + 주요 edge case. 각 시나리오는 Done Criteria 중 하나에 매핑.
 - **Out of Scope** — 이번에 하지 않는 것을 명시 (비어 있으면 스코프 팽창 신호).
 - **Assumptions** — 3단계에서 채택한 기본값 전부.
+- **Constraints** — 구현·보안·호환성 경계. execution packet으로 압축돼도 반드시 보존한다.
 - **API Contract** (해당 시에만) — 엔드포인트/요청/응답 형태. 이 섹션이 있으면 이후 `/vibe.contract` 가 drift 를 검사한다.
 
 이어서 `.vibe/features/{feature-name}.feature` 를 생성한다: 시나리오 섹션을 gherkin 으로 변환 (Done Criteria ↔ Scenario 매핑 유지). `/vibe.run` 이 이 파일을 구현·검증 단위로 사용한다.
@@ -71,6 +76,8 @@ Task(subagent_type="Explore",
 작성 직후, 아래 체크리스트로 자기 SPEC 을 **1회** 점검하고 걸리는 항목을 즉시 고친다. 외부 LLM 리뷰 없음, 수렴 루프 없음 — 한 번 고치면 끝.
 
 - [ ] 모든 Done Criteria 가 명령/관찰로 판정 가능한가 (모델 자기 보고가 아닌)
+- [ ] Context Sources 와 Assumptions 가 분리됐고, 각 Done Criteria 의 Evidence Required 가 있는가
+- [ ] Human Taste 가 결정론적 완료 게이트에 섞이지 않았는가
 - [ ] 모든 시나리오가 Done Criteria 에 매핑되는가 (고아 시나리오 없음)
 - [ ] 수치가 필요한 곳에 수치가 있는가 (제한·타임아웃·크기 — 없으면 기본값 + Assumptions)
 - [ ] Out of Scope 가 비어 있지 않은가

package/skills/vibe.run/SKILL.md

@@ -201,18 +201,41 @@ Step 3: If neither → Error: "Run /vibe.spec first"
 
 **Split structure:** Load `_index.md` first, then phase files in order. Execute phases sequentially (or per `--phase` flag).
 
+### 1-0. Compile + validate execution packet (MANDATORY)
+
+For a monolithic SPEC, compile it after resolving the canonical path. For a split SPEC, do not compile `_index.md`; defer this step until each active phase file is loaded in Phase Isolation Step B. Compile with `writeExecutionPacket`, then immediately verify the saved artifact with `validateExecutionPacket`.
+
+```bash
+node -e "import('file://{{VIBE_PATH}}/dist/tools/index.js').then(t => {
+  const projectPath=process.cwd(), specPath='.vibe/specs/{feature-name}.md';
+  const profile='{codex-or-claude-code}';
+  const written=t.writeExecutionPacket({projectPath,specPath,profile});
+  if(!written.ok){console.error(JSON.stringify(written.errors));process.exit(1)}
+  const checked=t.validateExecutionPacket({projectPath,specPath,packetPath:written.packetPath});
+  if(!checked.valid){console.error(checked.code);process.exit(1)}
+  console.log(written.packetPath);
+})"
+```
+
+- Codex uses profile `codex`; Claude Code uses `claude-code`.
+- Split SPECs compile each active `phase-N-*.md` immediately before that phase runs; `_index.md` remains the overview ANCHOR and is not treated as a phase contract.
+- Use the packet only when validation returns `valid: true`.
+- `STALE_PACKET`, invalid packet, preservation-audit failure, or budget failure is blocking: recompile from the canonical SPEC and never silently fall back to an unvalidated packet.
+- The packet is a derived execution view. The canonical SPEC remains the ANCHOR and source of truth.
+
 ### 1-1. Phase Isolation Protocol (Large SPEC Guard, MANDATORY for 3+ phases)
 
 ```
 Step A: Read _index.md (overview only — phase list, REQ IDs)
 Step B: For each Phase N:
   1. RE-READ Phase N SPEC section (every time, no memory)
-  2. RE-READ Phase N Feature scenarios
-  3. Extract Phase N scope: files, scenarios, requirements
-  4. Implement Phase N scenarios
-  5. Verify Phase N
-  6. Write Phase Checkpoint → .vibe/checkpoints/
-  7. DISCARD Phase N details from working memory
+  2. Compile + validate Phase N execution packet using the phase file path
+  3. RE-READ Phase N Feature scenarios
+  4. Extract Phase N scope: files, scenarios, requirements
+  5. Implement Phase N scenarios
+  6. Verify Phase N
+  7. Write Phase Checkpoint → .vibe/checkpoints/
+  8. DISCARD Phase N details from working memory
 Step C: Next Phase
 ```
 

package/skills/vibe.trace/SKILL.md

@@ -213,18 +213,18 @@ RTM status === 'empty'
 
 ### Run-ledger flow
 
-`/vibe.verify` records its outcome via `hooks/scripts/verify-ledger.js pass|fail`. This writes `verifyPassed` and `verifyAt` into `.vibe/metrics/run-ledger.json`. Downstream gates consume this record:
+`/vibe.verify` records its outcome through `hooks/scripts/verify-ledger.js`, binding the current run ID and command-result evidence. This writes `verifyPassed` and `verifyAt` into `.vibe/metrics/run-ledger.json`. Downstream gates consume this record:
 
 | Gate | Behavior |
 |------|----------|
 | `auto-commit` | Commits only when `verifyPassed === true` AND `verifyAt > runStarted` |
 | Stop hook | Warns when `runStarted && !verifyPassed`; blocks once if `verifyGate.mode === 'block'` |
 
-**To register a passing trace as verified**, run `/vibe.verify` after `/vibe.trace` reports acceptable coverage. The verify skill calls `verify-ledger.js pass` internally — you do not invoke it manually.
+**To register a passing trace as verified**, run `/vibe.verify` after `/vibe.trace` reports acceptable coverage. The verify skill records the current run ID and command evidence internally — you do not invoke the ledger CLI manually.
 
 ```
 /vibe.trace "login"         → RTM: 9/9 (100%)
-/vibe.verify "login"        → runs checks → calls verify-ledger.js pass
+/vibe.verify "login"        → runs checks → records pass + run ID + command results
                             → .vibe/metrics/run-ledger.json updated
 auto-commit / Stop gate     → verifyPassed=true, gate clears
 ```

package/skills/vibe.verify/SKILL.md

@@ -104,7 +104,7 @@ Load skill `contract` with: check "{feature}"
 
 ### 7. Metrics + Ledger update (MANDATORY final step)
 
-Record run metrics, then write the verify result to the run ledger. This is the machine-readable JUDGE record consumed by the Stop-hook verify gate, auto-commit verify gate, and loop-contract gates.
+Record run metrics, then write the verify result to the run ledger. This is the machine-readable deterministic JUDGE record consumed by the Stop-hook verify gate, auto-commit verify gate, and loop-contract gates. `recordVerify` also writes `.vibe/runs/{run-id}/evidence.json`; Model Judge findings remain advisory-only and Human Taste remains release-only.
 
 ```bash
 # Append step-count history (ok if current-run.json missing)
@@ -113,15 +113,21 @@ const fs=require('fs'),p='.vibe/metrics';
 try{const c=JSON.parse(fs.readFileSync(p+'/current-run.json','utf-8'));
 fs.appendFileSync(p+'/history.jsonl',JSON.stringify({verifiedAt:new Date().toISOString(),feature:c.feature,startedAt:c.startedAt,steps:c.steps||0})+'\n');}catch{}"
 
-# Record verify result — pass | fail (calls recordVerify on the run ledger)
+# Write the exact commands run in steps 2-3 and their exit codes.
+mkdir -p .vibe/metrics
+# Write `.vibe/metrics/verification-results.json` as:
+# [{"command":"npm test","exitCode":0}, ...]
+
+# Bind the result to the current run and its command evidence.
 HOOKS_DIR="${VIBE_PATH:-$(npm root -g 2>/dev/null)/@su-record/vibe}/hooks/scripts"
-[ -f "$HOOKS_DIR/verify-ledger.js" ] && node "$HOOKS_DIR/verify-ledger.js" pass   # or: fail
+RUN_ID=$(node -p "JSON.parse(require('fs').readFileSync('.vibe/metrics/run-ledger.json','utf8')).runId")
+[ -f "$HOOKS_DIR/verify-ledger.js" ] && node "$HOOKS_DIR/verify-ledger.js" pass "$RUN_ID" .vibe/metrics/verification-results.json   # or: fail
 
 # Recipe extraction (best-effort, silent)
 [ -f "$HOOKS_DIR/recipe-extractor.js" ] && node "$HOOKS_DIR/recipe-extractor.js" 2>/dev/null || true
 ```
 
-Use `pass` only when the summary in step 4 is PASS; otherwise `fail`. Skipping this step leaves `verifyPassed` unset and downstream gates will treat the run as unverified.
+Use `pass` only when the summary in step 4 is PASS; otherwise `fail`. A passing record requires at least one command result and every exit code must be zero. A stale run ID, missing evidence, or mismatched result leaves `verifyPassed` unset and downstream gates treat the run as unverified.
 
 ## Failure escalation (convergence-based, no retry cap)
 

package/vibe/rules/loop-contract.md

@@ -17,15 +17,19 @@
   → 루프:
       ANCHOR   디스크에서 재고정: SPEC + run-ledger + scope.json (+ 직전 인박스)
       ACT      파이프라인 실행 (스킬 체인)
-      JUDGE    결정론 판정만 인정: run-ledger verifyPassed │ 테스트 exit code │ RTM status
-               — 모델의 "완료했습니다" 자기 보고는 종료 조건이 될 수 없다
-      RECORD   run-ledger(현재 회전) + loop-history.jsonl(회전 이력, 스케줄 루프)
+      JUDGE    Deterministic Judge(blocking): run-ledger verifyPassed │ 테스트 exit code │ RTM status
+               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 │ 예산 상한
 ```
 
 ### ANCHOR가 컨텍스트 오염 방어인 이유
 루프 상태는 컨텍스트가 아니라 디스크에 산다. 매 회전이 아티팩트에서 다시 시작하므로 컨텍스트가 오염되거나 compact로 소실돼도 루프는 깨지지 않으며, 회전마다 fresh 컨텍스트(서브에이전트)로 돌려도 된다.
 
+### Judge 권한 경계
+종료 권한은 테스트 exit code·run-ledger·RTM 같은 **결정론적 Judge**에만 있다. Model Judge는 누락·모순·위험을 발견하는 보조 수단이며, 발견을 테스트나 관측 가능한 기준으로 내리기 전에는 차단 근거가 아니다. Human Taste는 공개·배포 시점의 사람 판단으로 남고 루프의 완료 상태를 변경하지 않는다.
+
 ### stuck (결정론)
 연속 2회 회전의 발견(discover/findings) 해시가 동일 → 중단하고 사람에게 (`loop-ledger.js check-stuck`이 판정·기록). "다시 해보면 될 것 같다"는 모델 판단으로 무시 금지.
 

package/vibe/templates/spec-template.md

@@ -10,13 +10,29 @@
 
 {What and why — 1-3 sentences.}
 
+### Context Sources
+
+- {File, document, URL, or observed system state used as input}
+
 ### Assumptions
 
 - {Default adopted without asking — e.g., session expiry 24h}
 
+### Constraints
+
+- {Invariant or implementation boundary that every execution packet must preserve}
+
+---
+
+## 2. Requirements
+
+| ID | Requirement | Done Criteria |
+|----|-------------|---------------|
+| REQ-{feature}-001 | {Observable functional requirement} | D1, D2 |
+
 ---
 
-## 2. Done Criteria (deterministic gates)
+## 3. Done Criteria (deterministic gates)
 
 > Each criterion must be judgeable by a command or observable behavior — never by self-report.
 > These are the JUDGE inputs of the loop (`vibe/rules/loop-contract.md`); `/vibe.verify` records the result in `.vibe/metrics/run-ledger.json`.
@@ -26,9 +42,18 @@
 | D1 | {e.g., all scenarios in the feature file pass} | {e.g., `npx vitest run` exit 0} |
 | D2 | {e.g., build succeeds with no type errors} | {e.g., `npm run build` exit 0} |
 
+### Evidence Required
+
+- D1 → {Command result, test report, log, screenshot, or verified code location}
+- D2 → {Evidence required for this specific criterion}
+
+### Human Taste (Non-Blocking)
+
+- {UX, brand, or product-quality review reserved for the release decision; never a loop completion gate}
+
 ---
 
-## 3. Scenarios
+## 4. Scenarios
 
 > Mirrored to `.vibe/features/{feature}.feature` (gherkin). Every scenario maps to a Done criterion.
 
@@ -46,13 +71,13 @@ Scenario: {Edge case title}           # → D1
 
 ---
 
-## 4. Out of Scope
+## 5. Out of Scope
 
 - {Explicitly not doing this time — must not be empty}
 
 ---
 
-## 5. API Contract (only if the feature exposes an API)
+## 6. API Contract (only if the feature exposes an API)
 
 > Presence of this section enables `/vibe.contract` drift detection.
 
@@ -64,8 +89,10 @@ Response: 201 {...}
 
 ---
 
-## 6. Verification
+## 7. Verification
 
 - `/vibe.run "{feature}"` implements scenario-by-scenario, verifying each immediately.
 - `/vibe.verify "{feature}"` judges the Done Criteria and sets `verifyPassed` in the run-ledger.
+- Verification writes `.vibe/runs/{run-id}/evidence.json`; only deterministic Judge results can complete the loop.
+- Model Judge findings are advisory-only. Human Taste is release-only.
 - Gate = all Done Criteria pass (exit codes / observed behavior) — loop continues until gates pass, stuck, or max iterations.