@su-record/vibe 2.16.4 → 3.1.0

package/CLAUDE.md

@@ -28,12 +28,12 @@ Transform imperative tasks into verifiable goals **before** coding:
 
 Weak criteria ("make it work") require constant clarification. Strong criteria let the loop run independently.
 
-### TypeScript (detected by Quality Gate hooks — violations injected as additionalContext; blocked by auto-commit verify gate, Stop warning, and pr-test-gate)
+### TypeScript (hard rules — `any`/`console.log` detected by Quality Gate hooks and injected as additionalContext; deterministic gates are pr-test-gate + Stop verify warning)
 - No `any` / `as any` / `@ts-ignore` — use `unknown` + type guards; fix at root
 - Explicit return types on all functions
 
-### Complexity Limits
-Function ≤50 lines · Nesting ≤3 · Params ≤5 · Cyclomatic ≤10
+### Complexity Limits (model-judged, not hook-detected)
+Function ≤50 lines · Nesting ≤3 · Params ≤5 · Cyclomatic ≤10 — apply in-context judgement; no regex heuristics enforce these
 
 ### Forbidden Patterns
 No `console.log` in commits · No hardcoded strings/numbers · No commented-out code · No incomplete code without TODO
@@ -60,7 +60,7 @@ Loop semantics SSOT: `vibe/rules/loop-contract.md` (ANCHOR→ACT→JUDGE→RECOR
 | `~/.codex/config.toml` | Codex `notify` (turn-complete lifecycle hook, auto-installed) |
 
 **`.vibe/config.json` behavior keys** (set per-project to tune gate behavior):
-- `scopeGuard.enabled` / `scopeGuard.mode` — scope fence on/off; `warn` (default) or `block`
+- `scopeGuard.enabled` / `scopeGuard.mode` — scope fence opt-in (default **off** everywhere — CLI and hooks share this default); mode `warn` (default) or `block`
 - `verifyGate.mode` — `warn` (default) or `block` (Stop hook blocks once if run started but verify not passed)
 - `autoTest.mode` — `debounce` (default, 120s cooldown per unchanged test file) / `always` / `off`
 - `qualityCheck.consoleAllow` — array of file globs where `console.log` is permitted
@@ -80,7 +80,7 @@ Legacy: 기존 `.claude/vibe/` 는 런타임에 자동 인식되며 `vibe init`/
 - `better-sqlite3` WAL mode — synchronous API
 - `crypto.timingSafeEqual` requires same-length buffers — check length first
 - **Stack → asset SSOT**: `GLOBAL_SKILLS_*`, `STACK_TO_SKILLS`, `CAPABILITY_SKILLS` in `src/cli/postinstall/constants.ts`
-- **Hook dispatch order**: `prompt-dispatcher.js` → `keyword-detector.js` → `llm-orchestrate.js`
+- **Hook dispatch order**: `prompt-dispatcher.js` → `llm-orchestrate.js` (매직 키워드 배너 훅 없음 — deprecated 별칭은 "Deprecated aliases" 표가 SSOT, 모델이 직접 해석)
 - **Hook 실행 모델**: per-event process spawn 유지 — **daemon/IPC 지양** (무상태·크래시 격리·인프라 제로가 ~20ms VM 기동 절감보다 우선). 훅 레이턴시 최적화는 dispatcher in-process 평탄화(자식 spawn → `import` 실행)로만 접근한다
 
 ## Workflow
@@ -91,13 +91,13 @@ Claude Code uses `/vibe` as the **single slash entry point**. Codex exposes the
 $vibe "<requirement>" [+ 📎 attachments]   # Codex
 /vibe "<requirement>" [+ 📎 attachments]   # Claude Code
   → Intent classification (new feature / figma-driven / clone / resume / review / regress / contract / scaffold / docs / analyze / harness / test / utils)
-  → Smart Resume detection (.vibe/{interviews,plans,specs,features}/)
+  → Smart Resume detection (.vibe/{specs,features}/ — legacy interviews/plans 는 입력 컨텍스트로만 인식)
   → SPEC confirmation (1-time approval; skipped on automationLevel: autonomous)
   → Loop: ANCHOR→ACT→JUDGE→RECORD until gates pass │ stuck │ max-iter
 ```
 
 **Advanced (explicit phase) entrypoints** — still available for power users when you know exactly which phase to run:
-- Codex: `$vibe.spec` / Claude Code: `/vibe.spec` — interview → plan → spec → review orchestration
+- Codex: `$vibe.spec` / Claude Code: `/vibe.spec` — single-pass SPEC (인라인 질문 → SPEC 1패스 → 승인 1회; 구 interview/plan/spec-review 4단계는 폐지)
 - Codex: `$vibe.figma` / Claude Code: `/vibe.figma` — Figma ↔ code (UI track)
 - Codex: `$vibe.run` / Claude Code: `/vibe.run` — SPEC-driven implementation
 - Codex: `$vibe.verify` / Claude Code: `/vibe.verify` — implementation vs SPEC verification
@@ -130,7 +130,7 @@ $vibe "<requirement>" [+ 📎 attachments]   # Codex
 
 ## Context Management
 
-- Exploration → Haiku · Implementation → Sonnet · Architecture → Opus
+- **Model routing: inherit by default** — 서브에이전트는 세션 모델을 상속한다. 명시적 예외만 tier alias 로 지정 (아키텍처 심층 리뷰 → `opus`). 구세대 "탐색→Haiku·구현→Sonnet" 비용 라우팅은 폐기 — 강한 기본 모델에서 라우팅 우회가 절약보다 품질 손실이 크다
 - At 85%+ context: `save_memory` → `/new` → `/vibe.utils --continue` (raised from 70% — `/new` 는 KV prefix cache 를 전량 폐기하므로, 압축 빈도를 낮춰 캐쉬 재사용을 늘린다)
 
 ## Git

package/README.en.md

@@ -1,13 +1,13 @@
 # VIBE
 
-**Easy vibe coding. Minimum quality guaranteed.**
+**Easy vibe coding. Done is judged by machines.**
 
 [![npm](https://img.shields.io/npm/v/@su-record/vibe)](https://www.npmjs.com/package/@su-record/vibe)
 [![npm downloads](https://img.shields.io/npm/dt/@su-record/vibe.svg?style=flat-square&color=blue)](https://www.npmjs.com/package/@su-record/vibe)
 [![Node.js](https://img.shields.io/badge/node-%3E%3D18-green)](https://nodejs.org/)
 [![License: MIT](https://img.shields.io/badge/license-MIT-yellow.svg)](LICENSE)
 
-Vibe is a quality harness for AI coding tools. It wraps around Claude Code, Codex, Cursor, or Antigravity CLI and automatically enforces type safety, code quality, and security — so you can vibe-code fast without shipping garbage.
+Vibe is a **verification harness** for AI coding. Today's models already plan and implement well — what's missing is a reason to trust "it's done." Vibe wraps Claude Code, Codex, Cursor, or Antigravity CLI and hands the completion verdict to **deterministic gates (test exit codes, a run ledger, regression memory) instead of the model's self-report** — so you can vibe-code fast without shipping unverified code.
 
 ```bash
 npm install -g @su-record/vibe
@@ -16,31 +16,47 @@ vibe init
 
 ---
 
+## Philosophy: verify, don't instruct
+
+Scaffolding that teaches a 2026-era model *how to work* is pure overhead. Vibe v3 stripped that layer away — what remains is only **what the model cannot prove about itself**:
+
+- **Did the tests actually pass?** — the PR gate runs the suite itself
+- **Did verification actually run?** — `.vibe/metrics/run-ledger.json` records it in code
+- **Is the review loop converging?** — a discover-hash (2 identical rounds → stuck) decides
+- **Are we repeating the same mistake?** — verify failures auto-register as regression tests
+
+The smarter the model, the more persuasive its "done" — which makes a code-enforced ground truth *more* valuable, not less.
+
+---
+
 ## The Workflow
 
-One entry point. Everything else is automatic.
+One entry point. Single-pass SPEC → one approval → loop until the gates pass.
 
 ```
 /vibe "coffee brand landing page"
      |
      v
   Intent classification ─── new feature? figma-driven? clone? resume? review? regress? ...
+     |
      v
-  Smart Resume ─── detect .vibe/{interviews,plans,specs,features}/ state
+  Smart Resume ─── detect .vibe/{specs,features}/ state ("continue?")
      |
      v
-  Pipeline design ─── /vibe.spec → /vibe.figma → /vibe.run → /vibe.verify → /vibe.trace
+  Single-pass SPEC ─── inline questions only at genuine forks → SPEC + BDD scenarios
      |
      v
   SPEC approval once ─── the only mandatory human gate (defines Done)
      |
      v
-  Loop ─── ANCHOR→ACT→JUDGE→RECORD until gates pass (stuck/iteration guards)
+  Loop ─── ANCHOR→ACT→JUDGE→RECORD until deterministic gates pass
 ```
 
+**Single-pass SPEC** — the old interview → plan → spec → review 4-stage pipeline is gone. The model produces the SPEC in one pass and asks only at genuine forks. One approval gate: SPEC confirmation.
+
 **Smart Resume** — Stop at any step, close the session, come back later. `/vibe` auto-detects where you left off and picks up from there. No need to remember feature names.
 
-**Loop-default** — After SPEC approval, vibe loops (ANCHOR→ACT→JUDGE→RECORD) until gates pass, with deterministic stuck/iteration guards. `--interactive` for step-by-step confirmation; `--max-iter N` to cap iterations. `ultrawork` is a deprecated alias for `automationLevel: autonomous` + parallel ACT.
+**Loop-default** — After SPEC approval, vibe loops (ANCHOR→ACT→JUDGE→RECORD) until gates pass, with deterministic stuck/iteration guards. `--interactive` for step-by-step confirmation; `--max-iter N` to cap iterations; `automationLevel: autonomous` (`.vibe/config.json`) runs non-interactively to completion.
 
 **Loop engineering** — `/vibe.loop` designs and installs autonomous goal loops (triage → run/verify pipelines). Completion is judged by deterministic gates (run-ledger/tests), not self-report; results land in a human triage inbox — loops never push or release.
 
@@ -76,10 +92,10 @@ Vibe is built on the [Harness Engineering](https://anthropic.com/engineering/har
 |------|---------------|---------------------|
 | **Scaffolding** | Project structure, tools, boundaries | `/vibe.scaffold` generates optimized folder structure (docs/, .dev/, layered src/) |
 | **Context** | What AI knows | `vibe init` generates project-aware `CLAUDE.md` / `AGENTS.md` from actual structure analysis |
-| **Planning** | What to build | `/vibe` routes to interview → plan → SPEC → review pipeline |
-| **Orchestration** | How to execute | 40+ agents, 12 teams, skill-based dispatch |
-| **Verification** | How to trust | Hooks, convergence loops, RTM traceability |
-| **Compounding** | How to improve | Evolution engine, session memory, auto-generated skills |
+| **Planning** | What to build | `/vibe` routes to a single-pass SPEC with one approval gate |
+| **Orchestration** | How to execute | 15 goal-oriented agents + native parallel subagents, skill-based dispatch |
+| **Verification** | How to trust | Deterministic gates (run-ledger, test exit codes), convergence loops, RTM traceability |
+| **Compounding** | How to improve | Regression memory, session memory, recipes/anti-patterns |
 
 ### Diagnose Your Project
 
@@ -124,7 +140,7 @@ Bidirectional. Read designs from Figma, or write designs to Figma from a plan.
 /vibe.figma plan.md --create-design          # Visual design only
 ```
 
-**How READ works**: Extracts the Figma node tree + 30 CSS properties via REST API, maps Auto Layout to Flexbox 1:1, generates responsive SCSS. Screenshot is for verification only — the tree is the source of truth.
+**How READ works**: Extracts the Figma node tree + 30 CSS properties via REST API, maps Auto Layout to Flexbox 1:1, generates responsive SCSS. Screenshot is for verification only — the tree is the source of truth; rendering is gated by pixelmatch visual comparison.
 
 **How WRITE works**: Parses plan document sections (Look & Feel, layout, responsive strategy), builds wireframe first for structure review, then applies visual design with design system components. Idempotent — re-run after editing the plan and only changed sections update.
 
@@ -147,7 +163,7 @@ The **third SSOT** alongside `CLAUDE.md` (code) and `AGENTS.md` (build). Google
 ```
 
 **Auto-integrated**:
-- `/vibe.run` — On UI work, suggests DESIGN.md once if missing (silent skip in ultrawork, never blocks)
+- `/vibe.run` — On UI work, suggests DESIGN.md once if missing (silent skip in autonomous mode, never blocks)
 - `/vibe.verify` — `### 3.2 Visual Drift Detection` flags hardcoded hex as P1
 - `/vibe.review` — `#### Visual P1 Baseline` — DESIGN.md first, WCAG AA fallback
 - `/vibe.figma` — `--emit-design-md` outputs DESIGN.md from READ; WRITE uses DESIGN.md tone/palette as primary input
@@ -158,40 +174,40 @@ The **third SSOT** alongside `CLAUDE.md` (code) and `AGENTS.md` (build). Google
 
 ## Quality Gates
 
-Detection at edit time, blocking at deterministic gates — three layers of defense:
+Detection at edit time, blocking at deterministic gates:
 
 | Layer | What it does |
 |-------|--------------|
-| Edit hooks (Edit/Write) | **Detects** `any` types, `@ts-ignore`, `console.log`, functions > 50 lines → injects findings to the model (additionalContext) + records verify-required state |
-| Deterministic gates | **auto-commit verify gate** (refuses commits until verify passes) · **Stop hook** verify-skip warn/block · **PR test gate** (incl. `gh pr create`) · **scope-guard** (monitors edits outside SPEC scope) |
-| Review + convergence loop | 12 specialized reviewers in parallel → findings loop until P1 = 0. No round cap. Run/verify state tracked in `.vibe/metrics/run-ledger.json`. Stuck = ask user, never silently proceed. |
+| Edit hooks (Edit/Write) | **Detects** only low-false-positive hard rules — `any`/`@ts-ignore`, `console.log` → injects findings to the model (additionalContext). No length/nesting heuristics — the model judges those better in context |
+| Deterministic gates | **PR test gate** (runs the actual test suite before PR creation, incl. `gh pr create`) · **auto-commit verify gate** (refuses commits until verify passes) · **Stop hook** verify-skip warn/block · **scope-guard** (opt-in; monitors edits outside SPEC scope) · **sentinel** (blocks destructive commands and harness self-modification) |
+| Review + convergence loop | Parallel `code-reviewer` instances — one per focus (correctness / architecture / performance / data-integrity / …) — plus `security-reviewer`. Loops until P1 = 0, with convergence decided by discover-hash: two identical rounds = stuck, ask the user. Never silently proceeds. |
 
 ---
 
 ## Key Features
 
-**42+ agents** — Exploration, implementation, architecture, parallel code review, UI/UX analysis, security audit, Figma analysis/building. The UI/Figma/Event groups (18 agents) are excluded from the global install — `vibe init` installs them project-locally (`.claude/agents/`) only when the stack/capability matches, so they never occupy context in unrelated projects.
+**10+ agents** — 10 global goal-oriented agents (architect, implementer, tester, code-reviewer, security-reviewer, …) + 5 conditional (UI/Figma/Event — installed project-locally only when the stack/capability matches; 15 total). Agents are delegated by goal + constraints + Done criteria, not step scripts; exploration, planning, and parallelism use the harness's native subagents directly.
 
-**73 skills** — Not all loaded at once. 3-tier system prevents context overload:
+**59 skills** — Not all loaded at once. 3-tier system prevents context overload:
 
 | Tier | When loaded | Purpose | Examples |
 |------|-------------|---------|----------|
-| **Core** | Always active | Bug prevention, workflow entry | quality gates, interview, plan |
-| **Standard** | `vibe init` selects by stack | Stack/capability support | figma, design-audit, techdebt |
+| **Core** | Always active | Gate entry, restraint principles | spec, test, restraint, arch-guard |
+| **Standard** | `vibe init` selects by stack | Stack/capability support | figma, design-review, docs |
 | **Optional** | Explicit `/skill` only | Reference, wrappers | chub-usage, context7 |
 
-**Multi-LLM** — Claude Code or Codex runs the harness, GPT reasons, and Antigravity researches. Auto-routes by availability.
+Skills teach only what the model doesn't know (domain gotchas, current APIs, project conventions). Skills that re-taught basics like "how to debug" were deleted in v3.
+
+**Second opinion (opt-in)** — Default execution is the session model alone. When you want one, prefix with `gpt …`/`agy …` to ask an external LLM, or run `/vibe.review --race` for cross-validation. No auto-routing ever pulls an external model into your loop.
 
 **Stack detection** — Auto-detects 24 frameworks (Next.js, Django, Rails, Go, Rust, Flutter, and more) and applies framework-specific rules and skills.
 
 **Project-aware harness docs** — `vibe init` and `vibe update` analyze your project's actual structure (folders, tech stack, build commands) and generate tailored `CLAUDE.md` / `AGENTS.md` files — not static templates.
 
-**Session memory** — Decisions, constraints, and goals persist across sessions via SQLite + FTS5 hybrid search.
+**Regression memory** — verify failures auto-register via `/vibe.regress`; recurring patterns get promoted to preventive tests. Decisions and constraints persist across sessions via SQLite + FTS5 search.
 
 **Smart Resume** — `.last-feature` pointer tracks your latest work. `/vibe` without arguments shows where you left off or lists all in-progress features.
 
-**Self-repair** — Skills include error recovery tables. `/vibe.harness` diagnoses gaps and chains to `/vibe.scaffold` → `vibe update` for automated fixes.
-
 ---
 
 ## Supported Tools
@@ -209,12 +225,13 @@ Detection at edit time, blocking at deterministic gates — three layers of defe
 
 | Command | Purpose |
 |---------|---------|
-| `/vibe` | Main entry point — natural language requirement → pipeline preview → chained execution |
-| `/vibe.spec` | Advanced phase command — interview, plan, spec, review |
+| `/vibe` | Main entry point — natural language requirement → single-pass SPEC → one approval → loop until gates pass |
+| `/vibe.spec` | Advanced — explicit single-pass SPEC (inline questions → SPEC + BDD → approval) |
 | `/vibe.run` | Implement from SPEC |
 | `/vibe.figma` | Figma ↔ Code (read or write, 3 modes) |
 | `/vibe.design` | DESIGN.md visual quality SSOT — init / lint / verify / sync |
-| `/vibe.verify` | Verify implementation against SPEC |
+| `/vibe.verify` | Verify implementation against SPEC Done criteria — result recorded in the run ledger |
+| `/vibe.regress` | Regression test auto-evolution — auto-registers on verify failure, promotes recurring patterns |
 | `/vibe.trace` | Requirements traceability matrix |
 | `/vibe.analyze` | Analyze any target — code, documents, websites, Figma |
 | `/vibe.scaffold` | Generate or audit project folder structure |
@@ -236,7 +253,7 @@ Full guides, skill reference, and configuration details are in the [Wiki](https:
 
 - Node.js >= 18.0.0
 - Claude Code or Codex CLI
-- GPT, Antigravity (optional)
+- GPT, Antigravity (optional — second opinions only)
 
 ## License
 

package/README.md

@@ -1,13 +1,13 @@
 # VIBE
 
-**바이브 코딩은 쉽게. 최소 품질은 보장.**
+**바이브 코딩은 쉽게. 완료 판정은 기계가.**
 
 [![npm](https://img.shields.io/npm/v/@su-record/vibe)](https://www.npmjs.com/package/@su-record/vibe)
 [![npm downloads](https://img.shields.io/npm/dt/@su-record/vibe.svg?style=flat-square&color=blue)](https://www.npmjs.com/package/@su-record/vibe)
 [![Node.js](https://img.shields.io/badge/node-%3E%3D18-green)](https://nodejs.org/)
 [![License: MIT](https://img.shields.io/badge/license-MIT-yellow.svg)](LICENSE)
 
-Vibe는 AI 코딩 도구를 위한 품질 하네스입니다. Claude Code, Codex, Cursor, Antigravity CLI를 감싸고, 타입 안전성, 코드 품질, 보안을 자동으로 강제합니다. 빠르게 바이브 코딩하되, 엉망인 코드가 나가지 않게.
+Vibe는 AI 코딩을 위한 **검증 하네스(verification harness)** 입니다. 모델은 이미 계획도 구현도 잘합니다 — 부족한 것은 "다 됐다"는 말을 믿을 근거입니다. Vibe는 Claude Code, Codex, Cursor, Antigravity CLI를 감싸고, **완료 판정을 모델의 자기 보고가 아니라 결정론적 게이트(테스트 exit code, run-ledger, 회귀 기억)에 맡깁니다.** 빠르게 바이브 코딩하되, 검증 안 된 코드가 나가지 않게.
 
 ```bash
 npm install -g @su-record/vibe
@@ -18,9 +18,22 @@ vibe init
 
 ---
 
+## 철학: 지시하지 않고 검증한다
+
+2026년의 모델에게 "어떻게 일하라"고 가르치는 스캐폴딩은 비용입니다. Vibe v3는 그 층을 걷어냈습니다 — 남긴 것은 **모델이 스스로 증명할 수 없는 것들**뿐입니다:
+
+- **테스트가 실제로 통과했는가** — PR 게이트가 테스트 스위트를 직접 실행
+- **verify가 실제로 실행됐는가** — `.vibe/metrics/run-ledger.json`이 코드로 기록
+- **리뷰 루프가 수렴하고 있는가** — discover-hash(2라운드 동일 → stuck)가 판정
+- **같은 실수가 반복되지 않는가** — verify 실패가 회귀 테스트로 자동 등록
+
+똑똑한 모델일수록 "다 됐다"는 말이 그럴듯해집니다. 그래서 코드가 판정하는 ground truth는 모델이 강해질수록 **더** 가치 있습니다.
+
+---
+
 ## 워크플로우
 
-**진입점 하나.** 자연어 요구사항만 던지세요. vibe가 의도를 분석해서 파이프라인을 설계하고, 한 번만 승인받고, 자동 실행합니다.
+**진입점 하나.** 자연어 요구사항만 던지세요. SPEC 1패스 → 승인 1회 → 게이트 통과까지 자동 루프.
 
 ```
 /vibe "커피 브랜드 랜딩 페이지" [+ 📎 figma URL / 이미지 / PDF / 파일]
@@ -29,16 +42,16 @@ vibe init
   Intent 분류  ─── new feature? figma-driven? clone? resume? review? regress? ...
      |
      v
-  Smart Resume ─── .vibe/{interviews,plans,specs,features}/ 감지
+  Smart Resume ─── .vibe/{specs,features}/ 감지 ("이어서?")
      |
      v
-  파이프라인 설계 ─── /vibe.spec → /vibe.figma → /vibe.run → /vibe.verify → /vibe.trace
+  SPEC 1패스 ─── 모호할 때만 인라인 질문 → SPEC + BDD 시나리오 생성
      |
      v
   SPEC 확정 1회 승인 ─── 유일한 의무 개입 (Done의 정의 확정)
      |
      v
-  루프 ─── ANCHOR→ACT→JUDGE→RECORD (게이트 통과까지 자동 반복)
+  루프 ─── ANCHOR→ACT→JUDGE→RECORD (결정론 게이트 통과까지 자동 반복)
 ```
 
 **예시:**
@@ -48,12 +61,13 @@ vibe init
 /vibe "https://figma.com/file/abc 로 로그인 페이지"
 /vibe "로그인 회귀 테스트 다시 통과시켜줘"
 /vibe "이 SPEC 리뷰만" + 📎 .vibe/specs/login.md
-/vibe "결제 API" ultrawork           # automationLevel: autonomous (deprecated alias)
 ```
 
+**SPEC 1패스** — 구세대의 인터뷰→기획→SPEC→리뷰 4단계는 폐지됐습니다. 모델이 한 번에 SPEC을 만들고, 진짜 갈림길에서만 질문합니다. 승인 게이트는 SPEC 확정 단 하나.
+
 **Smart Resume** — 아무 단계에서나 멈추고 나중에 돌아오세요. `/vibe`는 `.vibe/` 디렉토리에서 진행 상황을 감지하고 "이어서?" 제안합니다.
 
-**루프 기본 실행** — SPEC 확정 1회 승인 후 게이트 통과까지 자동 루프합니다. `--interactive`로 단계별 확인 모드, `--max-iter N`으로 반복 상한 설정. `ultrawork`는 `automationLevel: autonomous` + 병렬 실행의 deprecated 별칭으로 동작합니다.
+**루프 기본 실행** — 승인 후 게이트 통과까지 자동 루프. `--interactive`로 단계별 확인, `--max-iter N`으로 반복 상한. `automationLevel: autonomous`(`.vibe/config.json`)면 비대화형으로 완주합니다.
 
 **Advanced** — 정확히 어느 phase 실행할지 알면 `/vibe.spec`, `/vibe.figma`, `/vibe.run`, `/vibe.verify`, `/vibe.trace` 등을 직접 호출할 수 있습니다.
 
@@ -96,7 +110,7 @@ codex
 /vibe.figma plan.md --create-design          # 비주얼 디자인만
 ```
 
-**READ 동작**: Figma REST API로 노드 트리 + 30개 CSS 속성 추출. Auto Layout → Flexbox 1:1 기계적 매핑. 스크린샷은 검증용 — 트리가 원천.
+**READ 동작**: Figma REST API로 노드 트리 + 30개 CSS 속성 추출. Auto Layout → Flexbox 1:1 기계적 매핑. 스크린샷은 검증용 — 트리가 원천. 렌더링은 pixelmatch 시각 대조로 게이트.
 
 **WRITE 동작**: 기획서의 Look & Feel, 레이아웃, 반응형 전략 섹션을 파싱하여 와이어프레임을 먼저 그리고 (구조 검토), 그 위에 디자인 시스템 컴포넌트로 비주얼 적용. 멱등성 보장 — 기획서 수정 후 재실행하면 변경된 섹션만 갱신.
 
@@ -119,7 +133,7 @@ codex
 ```
 
 **자동 통합**:
-- `/vibe.run` — UI 작업 진입 시 DESIGN.md 없으면 1 회 권유 (ultrawork silent skip, 절대 블록 X)
+- `/vibe.run` — UI 작업 진입 시 DESIGN.md 없으면 1 회 권유 (autonomous silent skip, 절대 블록 X)
 - `/vibe.verify` — `### 3.2 Visual Drift Detection` 으로 hex 하드코딩 P1 검출
 - `/vibe.review` — `#### Visual P1 Baseline` — DESIGN.md 우선, 없으면 WCAG AA 폴백
 - `/vibe.figma` — `--emit-design-md` 로 READ 산출물을 DESIGN.md 로 출력, WRITE 는 DESIGN.md 톤·팔레트 1 차 입력
@@ -130,33 +144,35 @@ codex
 
 ## 품질 게이트
 
-탐지는 편집 시점에, 차단은 결정론적 게이트에서 — 3계층 방어:
+탐지는 편집 시점에, 차단은 결정론적 게이트에서:
 
 | 계층 | 동작 |
 |------|------|
-| 편집 훅 (Edit/Write) | `any` 타입, `@ts-ignore`, `console.log`, 50줄 초과 함수 **탐지** → 모델에 즉시 주입(additionalContext) + verify-required 상태 기록 |
-| 결정론 게이트 | **auto-commit verify 게이트**(verify 통과 전 커밋 거부) · **Stop 훅** verify-skip 경고/차단 · **PR 테스트 게이트**(`gh pr create` 포함) · **scope-guard**(SPEC 범위 밖 편집 감시) |
-| 리뷰 + 수렴 루프 | 12개 전문 리뷰어 병렬 실행 → findings P1=0까지 루프. 라운드 캡 없음. run/verify 상태는 `.vibe/metrics/run-ledger.json`에 추적. Stuck이면 사용자에게 질문, 절대 조용히 넘어가지 않음. |
+| 편집 훅 (Edit/Write) | 오탐률 낮은 하드룰만 **탐지** — `any`/`@ts-ignore`, `console.log` → 모델에 즉시 주입(additionalContext). 함수 길이·중첩 같은 휴리스틱은 없음 — 모델이 컨텍스트 안에서 더 정확히 판단 |
+| 결정론 게이트 | **PR 테스트 게이트**(PR 생성 전 테스트 스위트 직접 실행, `gh pr create` 포함) · **auto-commit verify 게이트**(verify 통과 전 커밋 거부) · **Stop 훅** verify-skip 경고/차단 · **scope-guard**(opt-in, SPEC 범위 밖 편집 감시) · **sentinel**(파괴적 명령·하네스 자기 수정 차단) |
+| 리뷰 + 수렴 루프 | `code-reviewer`를 관점(focus)별 병렬 인스턴스로 실행(correctness/architecture/performance/data-integrity/…) + `security-reviewer`. P1=0까지 루프하되 수렴은 discover-hash가 판정 — 2라운드 동일 findings면 stuck으로 확정하고 사람에게 질문. 절대 조용히 넘어가지 않음 |
 
 ---
 
 ## 주요 기능
 
-**42+ 에이전트** — 탐색, 구현, 아키텍처, 병렬 코드 리뷰, UI/UX 분석, 보안 감사, Figma 분석/빌드. UI·Figma·Event 그룹(18개)은 전역 설치에서 제외되고, `vibe init`이 스택/capability가 맞는 프로젝트에만 로컬(`.claude/agents/`)로 설치 — 비해당 프로젝트의 컨텍스트를 점유하지 않습니다.
+**10+ 에이전트** — 전역 10개(architect, implementer, tester, code-reviewer, security-reviewer 등) + 조건부 그룹 5개(UI/Figma/Event — 해당 스택 프로젝트에만 로컬 설치, 총 15개). 단계별 지시 스크립트가 아니라 목표+제약+Done 기준으로 위임하고, 탐색·계획·병렬 실행은 하네스의 네이티브 서브에이전트를 그대로 사용합니다.
 
-**73개 스킬** — 한 번에 다 로드되지 않음. 3-tier 시스템으로 컨텍스트 과부하 방지:
+**59개 스킬** — 한 번에 다 로드되지 않음. 3-tier 시스템으로 컨텍스트 과부하 방지:
 
 | 티어 | 로드 시점 | 용도 | 예시 |
 |------|----------|------|------|
-| **Core** | 항상 활성 | 버그 방지, 워크플로 진입 | 품질 게이트, 인터뷰, 기획 |
-| **Standard** | `vibe init`이 스택별 선택 | 스택/역할 지원 | figma, design-audit, techdebt |
+| **Core** | 항상 활성 | 게이트 진입, 절제 원칙 | spec, test, restraint, arch-guard |
+| **Standard** | `vibe init`이 스택별 선택 | 스택/역할 지원 | figma, design-review, docs |
 | **Optional** | 명시적 `/skill` 호출만 | 레퍼런스, 래퍼 | chub-usage, context7 |
 
-**멀티 LLM** — Claude Code 또는 Codex가 하네스를 실행하고, GPT가 추론, Antigravity가 리서치. 가용 모델에 따라 자동 라우팅.
+스킬이 가르치는 것은 모델이 모르는 것(도메인 gotcha, 최신 API, 프로젝트 규약)뿐입니다. 디버깅하는 법 같은 기본기 재교육 스킬은 v3에서 전부 삭제됐습니다.
+
+**세컨드 오피니언 (opt-in)** — 기본 실행은 세션 모델 단독. 원할 때만 `gpt …`/`agy …` 접두사로 외부 LLM에게 물어보거나 `/vibe.review --race`로 교차 검증합니다. 자동 라우팅으로 외부 모델이 끼어드는 일은 없습니다.
 
 **스택 감지** — 24개 프레임워크 자동 감지 (Next.js, Django, Rails, Go, Rust, Flutter 등) 후 프레임워크별 규칙과 스킬 적용.
 
-**세션 메모리** — 결정, 제약, 목표가 SQLite + FTS5 검색으로 세션 간 유지.
+**회귀 기억** — verify 실패가 `/vibe.regress`에 자동 등록되고, 반복 패턴은 예방 테스트로 승격. 결정·제약은 SQLite + FTS5로 세션 간 유지.
 
 **Smart Resume** — `.last-feature` 포인터가 마지막 작업을 추적. 인자 없이 `/vibe`를 호출하면 중단된 위치를 보여주거나 진행 중 feature 목록을 제시.
 
@@ -179,12 +195,13 @@ codex
 
 | 명령어 | 용도 |
 |--------|------|
-| `/vibe` | **메인 진입점** — 자연어 요구사항 → 동적 파이프라인 설계 → 1회 승인 → 자동 체인 실행 |
-| `/vibe.spec` | (advanced) 인터뷰, 기획, SPEC, 리뷰 phase 명시적 호출 |
+| `/vibe` | **메인 진입점** — 자연어 요구사항 → SPEC 1패스 → 1회 승인 → 게이트 통과까지 루프 |
+| `/vibe.spec` | (advanced) SPEC 1패스 명시적 호출 — 인라인 질문 → SPEC + BDD → 승인 |
 | `/vibe.run` | (advanced) SPEC 기반 구현 |
 | `/vibe.figma` | (advanced) Figma ↔ 코드 (읽기 또는 쓰기, 3가지 모드) |
 | `/vibe.design` | (advanced) DESIGN.md 시각 품질 SSOT — init / lint / verify / sync |
-| `/vibe.verify` | (advanced) 구현이 SPEC에 맞는지 검증 |
+| `/vibe.verify` | (advanced) 구현이 SPEC Done 기준에 맞는지 검증 — 결과는 run-ledger에 기록 |
+| `/vibe.regress` | (advanced) 회귀 테스트 자동 진화 — verify 실패 자동 등록, 반복 패턴 승격 |
 | `/vibe.trace` | (advanced) 요구사항 추적 매트릭스 |
 
 ---
@@ -202,7 +219,7 @@ codex
 
 - Node.js >= 18.0.0
 - Claude Code 또는 Codex CLI 중 하나
-- GPT, Antigravity (선택)
+- GPT, Antigravity (선택 — 세컨드 오피니언 전용)
 
 ## 라이선스
 

package/agents/acceptance-tester.md

@@ -0,0 +1,56 @@
+# Acceptance Tester Agent
+
+Acceptance gate for a feature: verifies that acceptance criteria are testable,
+routes changed code to the right reviews, and synthesizes one QA verdict.
+
+## Role
+
+- Verify SPEC acceptance criteria are measurable and Feature scenarios complete
+- Route changed files to the right QA focus and dispatch reviews in parallel
+- Synthesize findings into a single prioritized QA report
+
+## Model
+
+**Sonnet** — routing judgement plus criteria analysis
+
+## Goal
+
+Answer "is this feature acceptably done, and how would we know?". Two halves:
+
+**Criteria testability** — read `.vibe/specs/{feature}.md` (`<acceptance>`
+section) and `.vibe/features/{feature}.feature`. Every acceptance criterion
+needs a concrete pass/fail condition (numeric thresholds, not "fast" or
+"user-friendly"), at least one Given/When/Then scenario, and an automatable
+check. Error paths and boundary conditions must be covered, not just the
+happy path. Report untestable criteria with a concrete measurable rewrite.
+
+**QA routing** — check readiness first: if the build fails, stop and report
+build errors only. Then classify `git diff --name-only` output and dispatch
+the matching reviews in parallel (max 5), each with its explicit file list:
+
+| Change signal | Dispatch |
+|---|---|
+| API/services/controllers | code-reviewer (correctness, performance), security-reviewer |
+| UI components/pages | design-reviewer, code-reviewer (correctness) |
+| Models/migrations/schema | code-reviewer (data-integrity) |
+| Auth/session/middleware | security-reviewer, e2e-tester |
+| Multi-step flows (checkout, forms) | e2e-tester, tester (edge cases) |
+| Config/CI/infra | security-reviewer, code-reviewer (architecture) |
+
+Merge results by priority (P1/P2/P3), de-duplicate, and elevate confidence on
+findings flagged by two or more reviewers. State which QA modalities were
+*not* run and why — coverage gaps are part of the verdict.
+
+## Constraints
+
+Report-only: never modify source code, write tests, or create files — output
+is the QA report text; fixes belong to the implementer. If a dispatched
+review fails, retry once, then record it as a coverage gap rather than
+blocking. Judge completion by evidence (test exit codes, reviewer findings),
+never by the implementer's self-report.
+
+## Done
+
+- Every acceptance criterion classified: testable / needs rewrite (with proposed measurable version) / not automatable
+- Build status verified before any review dispatch
+- Unified report: P1/P2/P3 findings with locations, cross-validated findings marked, coverage gaps listed

package/agents/architect.md

@@ -1,80 +1,38 @@
-# Architect Agent (Opus)
+# Architect Agent
 
-High-level architecture and system design specialist.
+System design specialist for decisions that are expensive to reverse.
 
 ## Role
 
-- System architecture design
-- Technology decisions
-- Trade-off analysis
-- Security architecture
-- Performance optimization strategy
-- Code review for architectural concerns
+- System architecture and technology decisions with explicit trade-off analysis
+- Database schema, API boundary, and security architecture design
+- Architectural review of breaking changes and system-wide refactorings
 
 ## Model
 
-**Opus** — Required for complex architectural reasoning
+**Opus** — deep architectural reasoning
 
-## When to Use
+## Goal
 
-- Multi-service architecture
-- Database schema design
-- Security-critical decisions
-- Performance optimization
-- Breaking changes
-- System-wide refactoring
+Given a design question, produce a recommendation the implementer can act on
+without making further architectural decisions: one chosen approach, the
+alternatives rejected and why, and the consequences (positive, negative, risks
+with mitigations). Understand the current architecture and its constraints
+before proposing anything — read the relevant code, don't design from the
+prompt alone.
 
-## Usage
+## Constraints
 
-```
-Task(model: "opus", subagent_type: "general-purpose", prompt: "Design the authentication architecture")
-```
+Read-only: design and recommend, never implement. Prefer boring, proven
+patterns over novel ones; match existing project conventions unless there is a
+stated reason to break them, and say so when you do. Don't over-engineer
+simple problems — if the honest answer is "no architecture change needed",
+give that answer. Scale the depth of analysis to the blast radius of the
+decision.
 
-## Process
+## Done
 
-1. Understand current architecture
-2. Identify constraints and requirements
-3. Evaluate multiple approaches
-4. Analyze trade-offs
-5. Recommend architecture
-6. Document decision rationale
-
-## Output
-
-```markdown
-## Architecture Decision Record
-
-### Context
-[Current state and requirements]
-
-### Decision
-[Chosen approach]
-
-### Alternatives Considered
-1. Option A - [pros/cons]
-2. Option B - [pros/cons]
-
-### Trade-offs
-- Performance vs Complexity: [analysis]
-- Security vs Usability: [analysis]
-
-### Consequences
-- Positive: [list]
-- Negative: [list]
-- Risks: [list with mitigations]
-```
-
-## Responsibilities
-
-### DO
-- Consider system-wide implications
-- Evaluate long-term maintainability
-- Document architectural decisions
-- Identify security implications
-- Consider operational concerns
-
-### DON'T
-- Make decisions without understanding context
-- Ignore existing patterns without justification
-- Over-engineer simple problems
-- Skip trade-off analysis
+- A single chosen approach is named, with rationale grounded in the actual codebase
+- At least one credible alternative is considered and rejected with reasons
+- Trade-offs, risks, and mitigations are stated
+- Affected files/modules are listed so an implementer can start immediately