@su-record/vibe 2.9.1 → 2.9.3

package/commands/vibe.spec.md

@@ -1,1193 +1,563 @@
 ---
-description: Create SPEC document with Specification Agent
-argument-hint: "feature name"
+description: 프로젝트 명세 통합 진입점 — interview → plan → spec → review → run/figma 전체 워크플로 오케스트레이션
+argument-hint: "(선택) feature name, plan/interview file path, or idea"
 ---
 
 # /vibe.spec
 
-Create a SPEC document (Specification Agent).
+**vibe 워크플로 통합 진입점.** "무엇을 개발할지" 질문으로 시작해서 interview → plan → SPEC 작성 → review → 구현 + UI 디자인까지 전체 흐름을 오케스트레이션한다.
 
 ## Usage
 
 ```
-/vibe.spec "feature-name"                    # Conversation mode (requirements gathering)
-/vibe.spec "feature-name" ultrawork          # Auto: SPEC → Review → Implementation
-/vibe.spec "docs/login-prd.md"               # File path input (auto-detected)
-/vibe.spec + 📎 file attachment              # Use attached file
+/vibe.spec                                       # 빈 시작 — "무엇을 만들까요?"부터
+/vibe.spec "패럴랙스 웹사이트"                     # 아이디어/피처명 지정 시작
+/vibe.spec ".claude/vibe/plans/{feature}.md"     # 기획서 입력 (plan 단계 스킵)
+/vibe.spec ".claude/vibe/interviews/{feature}.md" # interview 입력 (interview 단계 스킵)
+/vibe.spec "docs/prd.md"                         # 외부 PRD/아이디어 파일 입력
+/vibe.spec + 📎 첨부                              # 첨부 기반 시작
+/vibe.spec "feature-name" ultrawork              # 중단 게이트 없이 자동 전 흐름 실행
 ```
 
-### ultrawork Mode
+## Philosophy
 
-When `ultrawork` (or `ulw`) is included, automatically chains:
+> **사용자는 "무엇을 만들지"만 말하면 된다. 어떤 스킬을 언제 부를지는 vibe가 결정한다.**
+
+- **단일 진입점**: `/vibe.spec` 하나로 전체 워크플로 시작. 다른 `/vibe.*` 커맨드 이름 외울 필요 없음.
+- **Smart resume**: 기존 interview/plan/spec 파일 존재 여부로 어느 단계부터 시작할지 자동 판단.
+- **자동 체이닝**: 스킬 `chain-next` 메타데이터 따라 vibe.interview → vibe.plan → vibe.spec → vibe.spec.review 진행.
+- **분기 판단**: 기획서의 `type` 필드로 UI 트랙/로직 트랙 여부 결정.
+- **사용자 제어**: 각 단계 사이에 사용자 확인 지점(stop gate) 제공 (ultrawork 모드는 스킵).
+
+## Flow
 
 ```
-/vibe.spec "feature" ultrawork
+/vibe.spec ["input"?]
+    ↓
+Phase 0: Git branch setup
+    ↓
+Phase 0.5: Input 분석 + Smart resume 결정
+    - 첨부/파일/아이디어 감지
+    - 기존 .claude/vibe/{interviews,plans,specs}/ 확인
+    - 시작 단계 결정: interview | plan | spec | review
+    ↓
+Phase 1: Interview (skill: vibe.interview)
+    - 조건: interview 파일 없음
+    - 사용자 "그만"까지 반복 인터뷰
+    - 출력: .claude/vibe/interviews/{feature}.md
+    ↓
+    [Stop Gate 1] — ultrawork 모드에서는 스킵
+    ↓
+Phase 2: Plan (skill: vibe.plan)
+    - 조건: plan 파일 없음
+    - interview → 마크다운 기획서 정제
+    - 출력: .claude/vibe/plans/{feature}.md
     ↓
-[1] SPEC Creation (this command)
+    [Stop Gate 2 + 분기 판단]
+    기획서 type 읽고 경로 결정:
+      - website/webapp/mobile → UI + Logic 병렬
+      - api/library/feature-data → Logic만
     ↓
-[2] Auto: /vibe.spec.review "{feature}"
+Phase 3: SPEC 작성 (skill: vibe.spec)
+    - PTCF 구조 SPEC 문서 + Feature(BDD) 파일
+    - Parallel research (GPT/Gemini/Claude agents)
+    - Large scope 자동 분할
+    - Ambiguity scan + 품질 게이트(100점, 수렴까지 루프)
+    - 출력: .claude/vibe/specs/{feature}.md + .claude/vibe/features/{feature}.feature
     ↓
-[3] Auto: /vibe.run "{feature}" ultrawork
+Phase 4: SPEC Review (skill: vibe.spec.review)
+    - Race Review (GPT + Gemini, 라운드 수 캡 없음, 수렴까지 루프)
+    - (옵션) Codex adversarial review
+    - 사용자 최종 체크포인트
+    ↓
+Phase 5a: Logic Track → /vibe.run
+Phase 5b: UI Track (병렬, UI 프로젝트만) → /vibe.figma
+    ↓
+Phase 6: Verify (/vibe.verify)
+Phase 7: Trace (/vibe.trace)
+    ↓
+Done
 ```
 
-**No manual intervention between steps.**
-
-> **⏱️ Timer**: Call `getCurrentTime` tool at the START. Record the result as `{start_time}`.
-
-## Input Mode Detection (Auto-detect)
+## Rules Reference
 
-**Input priority:**
+**`~/.claude/vibe/rules/` (global) 준수:**
 
-```
-1. Attachment exists? → Use attached file
-2. Argument is file path? (existence check) → Read file
-3. Otherwise → Conversation mode (start with feature name)
-```
+- `core/development-philosophy.md`
+- `core/quick-start.md` — Korean first
+- `core/communication-guide.md`
 
-| Input | Result |
-|-------|--------|
-| 📎 Attached file | → Analyze attached file |
-| File path (exists) | → Read file (Read tool) |
-| Feature name | → Start conversation mode |
+## Process
 
-**All supported files:**
-- Text: `.md`, `.txt`, `.rst`, `.html`, `.json`, `.yaml`, etc.
-- Documents: `.pdf` (page-by-page analysis)
-- Images: `.png`, `.jpg`, `.jpeg`, `.gif`, `.webp`, `.svg`, etc.
-- Notebooks: `.ipynb` (Jupyter)
-- **All formats Claude can read**
+> **⏱️ Timer**: 시작 시 `getCurrentTime` 호출, `{start_time}`로 기록.
 
-**File input mode flow:**
+### Phase 0: Git Branch Setup (MANDATORY)
 
+```bash
+git branch --show-current
 ```
-/vibe.spec "docs/login-prd.md"
 
-📄 File loaded: docs/login-prd.md (2.3KB)
-
-📋 Parsed requirements:
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-  Feature: Login
-  - Email/password login
-  - Social login (Google, Apple)
-  - Password recovery
-  - Auto login persistence
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+| 현재 | 행동 |
+|-----|-----|
+| `main`/`master` | 임시 이름으로 `git checkout -b vibe/tmp` (이후 feature 이름 확정되면 리네임) |
+| `feature/*`, `plan/*`, `interview/*`, `vibe/*` | 확인: "이 브랜치에서 계속?" |
+| 기타 | 사용자 확인 |
 
-❓ Additional confirmation needed:
-  1. Session expiration time? (default: 24 hours)
-  2. Allow concurrent login?
-  3. Confirm tech stack? (current: React + Supabase)
+### Phase 0.5: Input 분석 + Smart Resume
 
-User: 1 hour, disallow, confirm
+**입력 우선순위:**
 
-✅ Requirements confirmed → Run research → Generate SPEC → Review
 ```
-
-**Supported file formats:**
-
-| Format | Extension | Purpose |
-|--------|-----------|---------|
-| Markdown | `.md` | PRD, planning docs, README |
-| Text | `.txt` | Requirements list |
-| PDF | `.pdf` | Planning docs, design documents |
-| Image | `.png`, `.jpg`, `.jpeg`, `.webp` | Wireframes, UI design, screenshots |
-
-**Image input analysis:**
-
-When image files (`.png`, `.jpg`, `.jpeg`, `.webp`) are provided as input, analyze them using the best available method:
-
-- **Gemini Enabled**: `llm-orchestrate.js gemini analyze-image` (Gemini Flash - best image recognition)
-- **Gemini Disabled**: Claude Opus Read tool (built-in multimodal, existing behavior)
-
-**Gemini enabled - analyze via llm-orchestrate.js:**
-
-```bash
-# [LLM_SCRIPT] = {{VIBE_PATH}}/hooks/scripts/llm-orchestrate.js
-node "[LLM_SCRIPT]" gemini analyze-image "./designs/login-wireframe.png" "Analyze this UI design image. Identify all UI elements, layout structure, colors, typography, and component hierarchy. Output a structured breakdown."
+1. 📎 첨부 파일 있음? → 첨부 분석 → feature name 추출
+2. 인자가 파일 경로? → 파일 위치로 시작 단계 결정:
+     .claude/vibe/interviews/*.md → Phase 2 (plan)
+     .claude/vibe/plans/*.md      → Phase 3 (spec)
+     .claude/vibe/specs/*.md      → Phase 4 (review)
+     기타 (.md/.txt/.pdf)         → Phase 2 (plan, 외부 PRD 흡수)
+3. 인자가 feature name? → .claude/vibe/에서 기존 파일 검색
+     existing spec → "리뷰 재실행? 이어서? 재작성?" 물음
+     existing plan → Phase 3 (spec)
+     existing interview → Phase 2 (plan)
+     아무것도 없음 → Phase 1 (interview)
+4. 인자 없음 → Smart Resume Fallback 알고리즘 실행 (아래 참조)
 ```
 
-Parse the JSON result: `{ success: true, analysis: "..." }` → use `analysis` field content.
-
-If `success: false`, fall back to Claude Read tool.
+#### Smart Resume Fallback (인자 없는 `/vibe.spec` 호출 시)
 
-**Gemini disabled - analyze via Claude Read tool:**
+**목적**: feature 이름을 기억하지 못해도 진행 중 작업을 자동 발견해서 이어서 진행할 수 있게 한다.
 
-Use the Read tool directly on the image file. Claude can read images natively.
-
-**Image input example:**
 ```
-/vibe.spec "designs/login-wireframe.png"
-
-🖼️ Image analysis: designs/login-wireframe.png
-   (via Gemini Flash / Claude Opus)
+알고리즘:
 
-📋 Detected UI elements:
-  - Email input field
-  - Password input field
-  - "Login" button
-  - "Forgot password" link
-  - Social login buttons (Google, Apple)
-
-❓ Confirmation needed:
-  1. Feature name? (e.g., "login")
-  2. Additional requirements?
-
-→ Generate SPEC
-```
+Step 1) .claude/vibe/.last-feature 확인 (pointer 파일)
+  - 파일 없음 → Step 2로
+  - 존재 → 해당 feature의 상태 요약 출력 + 확인 질문:
+      "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+       🔄 마지막 작업: {feature-name}
+       ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+       ✅ interview: .claude/vibe/interviews/{feature}.md  (status: complete, N일 전)
+       ✅ plan:      .claude/vibe/plans/{feature}.md       (N일 전)
+       ❌ spec:      없음
+       → 다음 단계: Phase 3 (vibe.spec 스킬 — SPEC 작성)
 
-## Rules Reference
+       이어서 진행할까요?
+         Enter / yes → 이어서 진행
+         list        → 다른 진행 중 작업 목록 보기
+         new         → 새 아이디어로 시작
+         abort       → 종료"
 
-**Must follow `~/.claude/vibe/rules/` (global):**
-- `core/development-philosophy.md` - Surgical precision, simplicity
-- `core/quick-start.md` - Korean first, DRY, SRP
-- `core/communication-guide.md` - Communication principles
+  - yes → Phase 0.5의 인자 분석 경로 3번 (feature name)으로 진입
+  - list → Step 2로
+  - new → Step 3으로
+  - abort → 종료
 
-## Description
+Step 2) 진행 중 작업 목록 표시 (.claude/vibe/ 디렉토리 스캔)
+  수집:
+    features = {} (feature name → {hasInterview, hasPlan, hasSpec, mtime})
+    for each file in .claude/vibe/interviews/*.md:
+      feature = basename without .md
+      features[feature].hasInterview = true
+      features[feature].interviewMtime = file.mtime
+      features[feature].interviewStatus = frontmatter의 status (complete/partial)
+    동일하게 plans/*.md, specs/*.md 스캔
 
-Collect requirements through conversation with the user and create an **AI-executable PTCF structured SPEC document**.
+  정렬: 가장 최근 작업 (max mtime) 순
+  최대 10개까지 표시
 
-> **PTCF**: Persona, Task, Context, Format - Google Gemini prompt optimization framework
+  진행 중 작업 0개 → Step 3으로
+  1개 이상 → 목록 출력 + 선택 질문:
+    "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+     🔍 진행 중인 작업
+     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
-## External LLM Integration (GPT/Gemini)
+     1. bean-landing      [interview: partial]        2일 전
+     2. todo-app          [plan: complete]            어제
+     3. payment-api       [spec: complete]            방금 전
+     ─────────────────────────────────────────────
+     n. ➕ 새로 시작
+     a. 종료
 
-When GPT/Gemini are enabled, they are automatically utilized during SPEC creation:
+     선택 번호 또는 feature 이름을 입력하세요:"
 
-```
-/vibe.spec "feature"
-      ↓
-[Claude] Draft SPEC
-      ↓
-[Parallel Research] GPT + Gemini + Claude agents (8 parallel)
-      ↓
-[SPEC Review] GPT + Gemini parallel review
-      ↓
-[Claude] Finalize SPEC
-```
+  사용자 응답 처리:
+    - 숫자 (1~N) → 해당 feature 선택 → 인자 분석 경로 3번으로
+    - 정확한 feature 이름 → 인자 분석 경로 3번으로
+    - "n" 또는 "new" → Step 3으로
+    - "a" 또는 "abort" → 종료
+    - 자유 텍스트 (매칭 없음) → "{입력}은 기존 feature가 아닙니다. 새로 시작할까요? (y/n)" 확인
 
-**Setup:**
-```bash
-vibe gpt key <key>      # Enable GPT
-vibe gemini key <key>   # Enable Gemini
-vibe status         # Check current settings
+Step 3) 빈 시작 (기존 동작)
+  "👋 무엇을 만들고 싶으신가요?" 질문 → Phase 1 (interview)
 ```
 
-## Process
+#### `.last-feature` 포인터 파일 갱신 규칙
 
-### 0. Git Branch Setup (MANDATORY - Execute First!)
+```
+경로: .claude/vibe/.last-feature
+형식: 한 줄, feature name만 저장
+     예: "bean-landing\n"
 
-> ⚠️ **CRITICAL: You MUST execute this step FIRST before anything else!**
-> This is NOT optional documentation - you must RUN these git commands.
+⚠ 이 파일은 **개인 작업 포인터**이므로 git에 커밋하지 않는다.
+   `.gitignore` 에 `.claude/vibe/.last-feature` 엔트리 필수.
 
-**Step 0 is BLOCKING - do not proceed to Step 1 until branch is ready.**
+갱신 시점:
+  - Phase 1 (interview) 진입 시 → feature name 결정되면 즉시 기록
+  - Phase 2 (plan) 진입 시 → 기록 (이미 맞으면 no-op)
+  - Phase 3 (spec) 진입 시 → 기록
+  - Phase 4 (review) 진입 시 → 기록
 
-**Execute these commands using Bash tool:**
+즉, 어느 Phase에서 멈추든 다음 /vibe.spec 호출 시 이 feature가 1순위로 제안된다.
 
-```bash
-# 1. Check current branch
-git branch --show-current
+삭제 시점:
+  - Phase 7 (trace) 완료 시 → 파일 삭제 (워크플로 완주)
+  - 사용자가 명시적으로 종료/abort 선택 시 → 삭제하지 않음 (재개 가능하게)
 ```
 
-**Then based on result:**
-
-| Current Branch | Action |
-|----------------|--------|
-| `main` or `master` | **MUST** create feature branch: `git checkout -b feature/{feature-name}` |
-| `feature/*` | Ask user: "Continue on this branch or create new?" |
-| Other | Ask user to confirm |
-
-**Example execution:**
+**출력 예시:**
 
 ```
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-🌿 GIT BRANCH SETUP
+🔍 Input 분석
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
-Current branch: main
-
-Creating feature branch...
-$ git checkout -b feature/login-page
-
-✅ Switched to new branch: feature/login-page
+입력: "패럴랙스 웹사이트"
+분류: 신규 아이디어
+기존 파일: 없음
 
+→ 시작 단계: Phase 1 (vibe.interview)
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 ```
 
-**Branch naming rules:**
-- Convert to lowercase: `Login Page` → `login-page`
-- Replace spaces with hyphens
-- Prefix with `feature/`
-- Example: `feature/passkey-auth`, `feature/dark-mode`
-
-### 1. Project Analysis
-
-**Existing project** (`vibe init`):
-- Reference `CLAUDE.md` file (tech stack)
-- **Delegate codebase analysis to explorer agent** — do NOT read project files in main session:
-
-```text
-Task(subagent_type="explorer-low",
-  prompt="Analyze project structure: package.json, pyproject.toml, pubspec.yaml, go.mod.
-  Find existing implementations related to [FEATURE]. Return: tech stack, relevant files, patterns used.
-  Keep summary under 200 tokens.")
-```
-
-**New project** (`vibe init <project-name>`):
-- Suggest tech stack (2-3 options)
-
-### 2. Collect Requirements via Conversation
-
-**Principles:**
-- Ask **one question at a time**
-- Present options **with numbers** + "Feel free to describe in your own words"
-- **Natural conversation** without fixed order
-
-**Required confirmations:**
-- Purpose (Why): Why is it needed?
-- User (Who): Who will use it?
-- Feature scope (What): What features are needed?
-- Tech stack: Confirm existing stack or suggest new
-- Design reference: UI/UX to reference
+### Phase 1: Interview (조건부)
 
-### 2.1 Critical Requirements Confirmation (askUser) - v2.6.1
+**진입 조건:** interview 파일이 아직 없음
 
-**🚨 IMPORTANT: Use `askUser` tool for CRITICAL requirements that must not be missed**
+**진입 방식:**
 
-After initial conversation, use the structured `askUser` tool for:
-- 🔐 Authentication: method, MFA, password policy
-- 🛡️ Security: rate limiting, session management
-- ⏱️ Session: duration, concurrent login policy
-- 📊 Data Model: required fields, relationships
+1. **인자 있음** (`/vibe.spec "아이디어"`)
+   → `vibe.interview` 스킬 로드 + 아이디어 전달
 
-**When to use askUser vs conversation:**
+2. **인자 없음** (`/vibe.spec`)
+   → **Smart Resume Fallback 먼저** (Phase 0.5 참조):
+     - `.last-feature` 있고 사용자가 "이어서" 선택 → 해당 feature로 진입 (이 Phase 1 건너뛸 수 있음)
+     - 진행 중 작업 목록에서 선택 → 해당 feature로 진입
+     - "new" 선택 or 진행 중 작업 없음 → 아래 질문으로 빈 시작
+   → 빈 시작 질문:
+   ```
+   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+   👋 무엇을 만들고 싶으신가요?
+   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
-| Scenario | Method |
-|----------|--------|
-| Exploratory (feature scope, style) | Natural conversation |
-| **Critical** (auth, security, session) | `askUser` tool |
-| Optional (performance, integration) | Natural conversation |
+   예:
+   - "패럴랙스 웹사이트"
+   - "할 일 관리 앱"
+   - "Stripe 결제 연동 API"
+   - 또는 자유롭게 설명
 
-**Usage:**
+   (파일/이미지 첨부도 가능)
+   ```
+   → 사용자 응답 → `vibe.interview` 스킬 로드
 
-```typescript
-import { askUser, askUserQuick } from '@su-record/vibe/tools';
+**스킬 로드:**
 
-// Quick helper for common scenarios
-const result = await askUserQuick.login('my-login-feature');
-console.log(result.content[0].text);
-
-// Custom categories
-const result = await askUser({
-  featureName: 'user-dashboard',
-  categories: ['authentication', 'security', 'session', 'data_model'],
-  context: 'Building a user dashboard with role-based access',
-});
+```
+Load skill `vibe.interview` with input: {user_idea}
 ```
 
-**Available categories:**
-- `authentication`: Auth methods, MFA
-- `security`: Password policy, rate limiting
-- `session`: Session expiry, concurrent login
-- `data_model`: User profile fields
-- `performance`: Response time targets
-- `integration`: External service integration
+> **`.last-feature` 갱신**: vibe.interview 스킬이 feature name을 확정하는 즉시 `.claude/vibe/.last-feature` 에 한 줄로 기록. 이후 Phase 2/3/4 진입 시에도 동일 기록 유지 (값이 같으면 no-op).
 
-**Example output:**
+`vibe.interview` 스킬이 자체적으로:
+- 프로젝트 타입 감지 (website/webapp/mobile/api/library/feature)
+- 타입별 체크리스트 로드 (`skills/vibe.interview/checklists/{type}.md`)
+- 반복 인터뷰 실행 (사용자 "그만"까지)
+- `.claude/vibe/interviews/{feature-name}.md` 저장
+
+**Stop Gate 1**: Interview 완료 후 (ultrawork 모드 스킵)
 
 ```
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-📋 Requirements Confirmation
-Feature: login
+✅ Interview 완료
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
-## 🔐 Authentication
-
-### 🔐 Q-AUTHENTICATION-001
+📄 .claude/vibe/interviews/{feature}.md
+   Required: N/M | Optional: K/L | Discovered: X
 
-**Which authentication methods should be supported?**
-(Multiple selection allowed)
+다음 단계: 기획서 작성
+  1. 계속 진행 (기본)
+  2. Interview만 저장하고 종료
+  3. Interview 수정 후 다시 (vibe.interview 재실행)
 
-1. **Email/Password** ✓
-2. **Google Social Login**
-3. **Apple Social Login**
-...
-
-**Required**
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-Total 6 questions (Required: 4)
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Enter → 계속
 ```
 
-**Response parsing:**
+### Phase 2: Plan (조건부)
 
-```typescript
-import { parseUserResponse } from '@su-record/vibe/tools';
+**진입 조건:** plan 파일이 아직 없음
 
-// User responds: "1, 2, 4" (selected option numbers)
-const response = parseUserResponse(question, "1, 2, 4");
-// { questionId: "Q-AUTH-001", value: ["email_password", "social_google", "passkey"], timestamp: "..." }
 ```
-
-**ultrawork mode:**
-- askUser is **skipped** in ultrawork mode
-- Uses default values from templates automatically
-
-### 2.5. Reference Documents via config.json (MANDATORY after tech stack confirmed)
-
-**🚨 CRITICAL: Read config.json references IMMEDIATELY after tech stack is confirmed**
-
-Reference documents are automatically generated in `config.json` based on the stack detected during `vibe init`:
-
-```json
-// .claude/vibe/config.json
-{
-  "language": "ko",
-  "stacks": [
-    { "type": "typescript-react", "path": "package.json" }
-  ],
-  "references": {
-    "rules": [
-      "~/.claude/vibe/rules/code-quality.md",
-      "~/.claude/vibe/rules/error-handling.md",
-      "~/.claude/vibe/rules/security.md"
-    ],
-    "languages": [
-      "~/.claude/vibe/languages/typescript-react.md"
-    ],
-    "templates": [
-      "~/.claude/vibe/templates/spec-template.md",
-      "~/.claude/vibe/templates/feature-template.md",
-      "~/.claude/vibe/templates/constitution-template.md"
-    ]
-  }
-}
+Load skill `vibe.plan` with input: .claude/vibe/interviews/{feature}.md
 ```
 
-**Workflow:**
-
-1. Read `.claude/vibe/config.json`
-2. Extract `references.languages[]` paths
-3. Read each language document for stack-specific guidelines
+`vibe.plan` 스킬이 자체적으로:
+- 템플릿 로드 (`~/.claude/vibe/templates/plan-template.md`)
+- Interview 섹션별 정제
+- UI 섹션 조건부 포함 (type 기반)
+- `.claude/vibe/plans/{feature}.md` 저장
 
-**Example:**
-```bash
-# 1. Check references in config.json
-Read .claude/vibe/config.json
+**Stop Gate 2**: 기획서 완료 후 + 분기 판단 (ultrawork 모드 스킵)
 
-# 2. Reference documents specified in references.languages
-Read ~/.claude/vibe/languages/typescript-react.md
 ```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+✅ 기획서 완성
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
-**Important:**
-
-- No manual mapping needed - config.json contains all reference paths
-- `config.json.references` is automatically referenced when running `/vibe.run`
-- Not copied to project (referenced from global package)
-
-### 3. Parallel Research (v2.5.0) - MANDATORY AFTER requirements confirmed
-
-**🚨🚨🚨 ABSOLUTE RULES FOR RESEARCH PHASE 🚨🚨🚨**
-
-**STOP! Before doing ANY research, read this carefully:**
-
-1. **DO NOT** use Task tool to spawn research agents
-2. **DO NOT** use context7 MCP directly for research
-3. **DO NOT** use WebSearch tool directly for research
-4. **YOU MUST** use Bash tool to call llm-orchestrate.js directly
-
-**🚨🚨🚨 CRITICAL: NO FILE CREATION DURING RESEARCH 🚨🚨🚨**
-
-5. **DO NOT** create any files in project root during research
-6. **DO NOT** create SECURITY_*.md, RESEARCH_*.md, SUMMARY_*.md files
-7. **DO NOT** use Write tool during research phase
-8. **ALL research results** must be returned as text output only
-9. **Files are ONLY created** in Step 4 (SPEC) and Step 5 (Feature) in `.claude/vibe/` directory
-
-**When to trigger:**
-1. ✅ Feature type decided (e.g., "passkey authentication")
-2. ✅ Tech stack confirmed (e.g., "React + Supabase")
-3. ✅ Language guide copied (step 2.5)
-4. ✅ Core requirements collected
-
-**→ IMMEDIATELY run these 6 Bash commands IN PARALLEL (all at once):**
-
-**Step 0: Script path:**
-- `[LLM_SCRIPT]` = `{{VIBE_PATH}}/hooks/scripts/llm-orchestrate.js`
-
-**Run all 4 in PARALLEL (each as separate Bash tool call):**
-```bash
-# 1. GPT: Best practices (codex — code review & analysis)
-node "[LLM_SCRIPT]" gpt-codex orchestrate-json "Best practices for [FEATURE] with [STACK]. Focus: architecture patterns, code conventions. Return JSON: {patterns: [], antiPatterns: [], libraries: []}"
+📄 .claude/vibe/plans/{feature}.md
+Type: {type}
 
-# 2. GPT: Security (codex — code review & analysis)
-node "[LLM_SCRIPT]" gpt-codex orchestrate-json "Security vulnerabilities for [FEATURE] with [STACK]. Focus: CVE database, known exploits. Return JSON: {vulnerabilities: [], mitigations: [], checklist: []}"
+{type ∈ UI}:
+자동 경로: SPEC 작성 → Review → Logic Track + UI Track 병렬 실행
+  1. 계속 (권장)
+  2. Logic Track만 (SPEC만)
+  3. UI Track만 (/vibe.figma 바로)
+  4. 여기서 종료
 
-# 3. Gemini: Best practices
-node "[LLM_SCRIPT]" gemini orchestrate-json "Best practices for [FEATURE] with [STACK]. Focus: latest trends, framework updates. Return JSON: {patterns: [], antiPatterns: [], libraries: []}"
+{type ∈ non-UI}:
+자동 경로: SPEC 작성 → Review → Logic Track
+  1. 계속 (권장)
+  2. 여기서 종료
 
-# 4. Gemini: Security
-node "[LLM_SCRIPT]" gemini orchestrate-json "Security advisories for [FEATURE] with [STACK]. Focus: latest patches, recent incidents. Return JSON: {advisories: [], patches: [], incidents: []}"
+Enter → 계속
 ```
 
-**Concrete example - run all 4 in parallel:**
-```bash
-# GPT best practices (codex — code review & analysis)
-node "[LLM_SCRIPT]" gpt-codex orchestrate-json "Best practices for passkey authentication with React, Supabase. Focus: architecture patterns, code conventions. Return JSON: {patterns: [], antiPatterns: [], libraries: []}"
+### Phase 3: SPEC 작성
 
-# GPT security (codex — code review & analysis)
-node "[LLM_SCRIPT]" gpt-codex orchestrate-json "Security vulnerabilities for passkey authentication with React, Supabase. Focus: CVE database, known exploits. Return JSON: {vulnerabilities: [], mitigations: [], checklist: []}"
+**진입 조건:** spec 파일이 아직 없음 (또는 재작성 요청)
 
-# Gemini best practices
-node "[LLM_SCRIPT]" gemini orchestrate-json "Best practices for passkey authentication with React, Supabase. Focus: latest trends, framework updates. Return JSON: {patterns: [], antiPatterns: [], libraries: []}"
-
-# Gemini security
-node "[LLM_SCRIPT]" gemini orchestrate-json "Security advisories for passkey authentication with React, Supabase. Focus: latest patches, recent incidents. Return JSON: {advisories: [], patches: [], incidents: []}"
+```
+Load skill `vibe.spec` with input: .claude/vibe/plans/{feature}.md
 ```
 
-**ALSO run Claude research agents in parallel using Task tool:**
-
-| Claude Agent | Role | Source |
-|--------------|------|--------|
-| `best-practices-agent` | Best practices for [feature] + [stack] | WebSearch |
-| `framework-docs-agent` | Latest docs via context7 | context7 MCP |
-| `codebase-patterns-agent` | Similar patterns in existing codebase | Glob, Grep |
-| `security-advisory-agent` | Security advisories for [feature] | WebSearch |
-
-**Total: 4 GPT/Gemini calls (Bash) + 4 Claude agents (Task) = 8 parallel research tasks**
-
-**🚨 GPT/Gemini MUST be called via Bash with llm-orchestrate.js! 🚨**
-
-#### 3.0.1 Agent Teams — Research Collaboration
-
-> **Agent Teams**: 개별 리서치 결과를 실제 팀으로 교차 검증하여 더 깊은 인사이트를 도출합니다.
-> 설정: `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1` + `teammateMode: in-process` (`~/.claude/settings.json` 전역 — postinstall 자동 설정)
-
-**팀 구성:**
-
-| 팀원 | 역할 |
-|------|------|
-| best-practices (리더) | 패턴/안티패턴 종합, 충돌 해결, 최종 요약 |
-| security-advisory | 보안 관점 검증, 보안 리스크 식별 |
-| codebase-patterns | 기존 코드와의 일관성 검증 |
-| framework-docs | 최신 문서/API 변경사항 확인 |
-
-**실행 순서:**
-
-1. `TeamCreate(team_name="research-{feature}")` — 팀 + 공유 태스크 리스트 생성
-2. 4개 팀원 병렬 생성 — 각각 `Task(team_name=..., name=..., subagent_type=...)` 으로 spawn
-3. 팀원들이 공유 TaskList에서 작업을 claim하고, SendMessage로 상호 검증
-4. 리더(best-practices)가 최종 통합 요약 작성 → SPEC Context에 반영
-5. 모든 팀원 shutdown_request → TeamDelete로 정리
+`vibe.spec` 스킬이 PTCF 구조 SPEC 문서 + Feature(BDD) 파일 생성.
 
-**팀원 spawn 패턴:**
+**핵심 단계** (상세는 `skills/vibe.spec/SKILL.md` 참조):
 
-```text
-TeamCreate(team_name="research-{feature}", description="Research collaboration for {feature}")
+1. Project analysis (explorer agent)
+2. config.json references 로드
+3. Parallel research (GPT + Gemini + Claude agents, 8개 병렬)
+4. UI/UX Design Intelligence (UI 키워드 시 자동)
+5. PTCF SPEC 작성 (Large scope 자동 분할)
+6. Feature file (BDD) 생성
+7. Ambiguity scan
+8. Quality gate (100점, 수렴까지 루프)
 
-# 4개 병렬 spawn
-Task(team_name="research-{feature}", name="best-practices", subagent_type="best-practices-agent",
-  prompt="리서치 팀 리더. 10개 병렬 리서치 결과를 종합하세요.
-  리서치 결과: {all_research_results}
-  역할: 패턴/안티패턴 종합, 팀원 간 충돌 해결, 최종 통합 요약 작성.
-  TaskList를 확인하고 작업을 claim하세요. 팀원에게 SendMessage로 검증을 요청하세요.
-  모든 작업 완료 후 최종 요약을 작성하세요.")
+**출력:**
 
-Task(team_name="research-{feature}", name="security-advisory", subagent_type="security-advisory-agent",
-  prompt="리서치 팀 보안 담당. 리서치 결과: {all_research_results}
-  역할: 보안 관점에서 모든 권장사항 검증.
-  보안 리스크 발견 시 best-practices에게 SendMessage로 알리세요.
-  TaskList에서 보안 관련 작업을 claim하세요.")
+- `.claude/vibe/specs/{feature-name}.md` (또는 split folder)
+- `.claude/vibe/features/{feature-name}.feature` (또는 split folder)
 
-Task(team_name="research-{feature}", name="codebase-patterns", subagent_type="codebase-patterns-agent",
-  prompt="리서치 팀 코드베이스 담당. 리서치 결과: {all_research_results}
-  역할: 권장사항이 기존 코드 패턴과 호환되는지 검증.
-  비호환 발견 시 best-practices에게 SendMessage로 알리세요.
-  TaskList에서 호환성 관련 작업을 claim하세요.")
+### Phase 4: SPEC Review
 
-Task(team_name="research-{feature}", name="framework-docs", subagent_type="framework-docs-agent",
-  prompt="리서치 팀 문서 담당. 리서치 결과: {all_research_results}
-  역할: 최신 API/문서와 권장사항 대조 검증.
-  폐기/변경된 API 발견 시 best-practices에게 SendMessage로 알리세요.
-  TaskList에서 문서 검증 관련 작업을 claim하세요.")
 ```
-
-**팀원 간 통신 예시:**
-
-```text
-security-advisory → best-practices: "JWT 라이브러리 권장사항에 CVE-2024-xxxx 취약점. 대안 필요"
-codebase-patterns → best-practices: "기존 코드가 class 패턴인데 함수형 권장은 비호환. 점진적 마이그레이션 제안"
-framework-docs → best-practices: "React 19에서 useEffect 패턴 변경됨. 리서치 결과의 패턴은 구버전"
-best-practices → broadcast: "최종 합의: JWT는 jose 라이브러리로 교체, 함수형 전환은 신규 파일만 적용"
+Load skill `vibe.spec.review` with feature: {feature-name}
 ```
 
-**토론 결과는 SPEC의 Context 섹션에 반영됩니다.**
-
-#### 3.1 Result Merge Rules
-
-| Area | Merge Strategy |
-|------|----------------|
-| Best Practices | Deduplicate, keep most detailed |
-| Security | ALL included (no dedup for safety) |
-| Libraries | Consensus recommendations |
-
-**IMPORTANT:**
-- ❌ DO NOT skip research step
-- ❌ DO NOT ask user "should I run research?"
-- ✅ ALWAYS run after requirements confirmed
-- ✅ Show "Running parallel research (Claude + GPT + Gemini)..." message
-- ✅ Include all agent + LLM results in SPEC Context
-- ✅ Run all 4 Bash LLM calls in parallel + 4 Task agents in parallel
-
-**Research results are reflected in SPEC's Context section.**
+`vibe.spec.review` 스킬이 Race Review + 품질 검증 + 사용자 체크포인트 실행.
 
-### 3.2 UI/UX Design Intelligence (Auto-triggered)
+**핵심 단계** (상세는 `skills/vibe.spec.review/SKILL.md` 참조):
 
-> **조건**: SPEC 컨텍스트에 UI/UX 키워드 포함 시 자동 실행 (website, landing, dashboard, app, e-commerce, portfolio, SaaS, mobile app, web app, UI, UX, frontend, 디자인)
-> **비활성화**: `.claude/vibe/config.json`에 `"uiUxAnalysis": false` 설정
+1. SPEC/Feature 파일 로드 (single/split 자동 감지)
+2. Quality Validation (100점 게이트, 수렴까지 auto-fix 루프)
+3. Race Review (GPT + Gemini parallel, 라운드 수 캡 없음, P1=0 + 수렴 시 종료)
+4. (옵션) Codex adversarial review
+5. Review Debate Team (2+ P1/P2 이슈 시)
+6. 사용자 최종 체크포인트
 
-**UI/UX 키워드 감지 시, 리서치와 병렬로 3개 에이전트 순차 실행:**
+### Phase 5a: Logic Track
 
 ```
-[Parallel Research] GPT + Gemini + Claude agents
-        ↓ (동시 실행)
-[UI/UX Intelligence]
-  ① ui-industry-analyzer (Haiku) → 산업 분석 + 디자인 전략
-        ↓
-  ②③ 병렬 실행:
-    ② ui-design-system-gen (Sonnet) → MASTER.md 생성
-    ③ ui-layout-architect (Haiku) → 레이아웃 설계
+/vibe.run "{feature-name}"
 ```
 
-**실행 방법:**
+SPEC → 코드 구현.
 
-1. **① ui-industry-analyzer** — Task(haiku) 에이전트로 실행:
-```text
-Task(subagent_type="ui-industry-analyzer",
-  prompt="Analyze product: [USER_DESCRIPTION]. Use core_ui_search to detect category, style priority, color mood, typography mood. Save result to .claude/vibe/design-system/{project}/analysis-result.json")
-```
+### Phase 5b: UI Track (type ∈ {website, webapp, mobile}일 때만)
 
-2. **②③ 병렬 실행** — ①의 결과를 입력으로:
-```text
-# ② 디자인 시스템 생성 (Sonnet)
-Task(subagent_type="ui-design-system-gen",
-  prompt="Generate design system from analysis-result.json for project '{project}'. Use core_ui_search for style/color/typography, then core_ui_generate_design_system and core_ui_persist_design_system.")
+**5a와 병렬 실행** (또는 순차 — 사용자 선택):
 
-# ③ 레이아웃 설계 (Haiku) — 병렬 실행
-Task(subagent_type="ui-layout-architect",
-  prompt="Design layout from analysis-result.json for project '{project}'. Use core_ui_search for landing patterns and dashboard layout.")
 ```
-
-3. **결과를 SPEC Context에 주입:**
-```markdown
-### Design System (Auto-generated)
-- Category: {①의 category}
-- Style: {①의 style_priority}
-- MASTER.md: .claude/vibe/design-system/{project}/MASTER.md
-- Layout: {③의 pattern + sections}
+/vibe.figma
 ```
 
-### 4. Write SPEC Document (PTCF Structure)
-
-#### 4.0 Large Scope Detection & Auto-Split (MANDATORY)
-
-**🚨 CRITICAL: Automatically split SPEC when scope is large**
+**`/vibe.figma`에 전달할 컨텍스트:**
 
-**❌ DO NOT ask user for confirmation - auto-split silently**
+- `.claude/vibe/plans/{feature}.md` 경로
+- 기획서의 §7 Look & Feel, §8 레이아웃, §9 반응형 섹션을 Phase 1 스토리보드 입력으로 사용
 
-**Detection criteria (ANY triggers split):**
-
-| Criteria | Threshold |
-|----------|-----------|
-| Phases | 5+ phases |
-| Files to create | 15+ files |
-| Platforms | 2+ platforms |
-| Major features | 4+ distinct features |
-
-**Auto-split output (SPEC + Feature files must match):**
+### Phase 6: Verify
 
 ```
-.claude/vibe/specs/{feature-name}/
-├── _index.md           # Master SPEC
-├── phase-1-setup.md
-├── phase-2-core.md
-└── ...
-
-.claude/vibe/features/{feature-name}/
-├── _index.feature      # Master Feature
-├── phase-1-setup.feature
-├── phase-2-core.feature
-└── ...
+/vibe.verify "{feature-name}"
 ```
 
-**🚨 CRITICAL: Each SPEC phase file MUST have a matching Feature file**
-
-**Master SPEC (`_index.md`):**
+UI + 로직 + 연결 검증 (후속 PR에서 3축 확장 예정).
 
-```markdown
-# SPEC: {feature-name} (Master)
+### Phase 7: Trace
 
-## Overview
-- Total phases: N
-- Dependencies: [list]
-
-## Sub-SPECs
-
-| Order | SPEC File | Feature File | Status |
-|-------|-----------|--------------|--------|
-| 1 | phase-1-setup.md | phase-1-setup.feature | ⬜ |
-| 2 | phase-2-core.md | phase-2-core.feature | ⬜ |
-
-## Shared Context
-- Tech Stack: [all phases]
-- Constraints: [all phases]
 ```
-
-**Master Feature (`_index.feature`):**
-
-```markdown
-# Feature: {feature-name} (Master)
-
-**Master SPEC**: `.claude/vibe/specs/{feature-name}/_index.md`
-
-## Sub-Features
-
-| Order | Feature File | SPEC File | Status |
-|-------|--------------|-----------|--------|
-| 1 | phase-1-setup.feature | phase-1-setup.md | ⬜ |
-| 2 | phase-2-core.feature | phase-2-core.md | ⬜ |
-
-## Overall User Story
-**As a** {user}
-**I want** {complete feature}
-**So that** {value}
-```
-
-**Small scope (default):**
-
-Create `.claude/vibe/specs/{feature-name}.md`:
-
-```markdown
----
-status: pending
-currentPhase: 0
-totalPhases: 3
-createdAt: {ISO-timestamp}
-lastUpdated: {ISO-timestamp}
----
-
-# SPEC: {feature-name}
-
-## Persona
-<role>
-Define AI role and expertise for implementation
-- Senior developer on the project
-- Follow existing code patterns
-- Write testable code
-</role>
-
-## Context
-<context>
-### Background
-- Why this feature is needed
-- Who will use it
-
-### Tech Stack
-- Backend: {technology}
-- Frontend: {technology}
-- Database: {technology}
-
-### Related Code
-- `src/xxx/`: Existing implementation to reference
-- `src/yyy/`: Files to modify
-
-### Design Reference
-- {Reference app/service}
-</context>
-
-## Task
-<task>
-### Phase 1: {phase-name}
-1. [ ] {specific task}
-   - File: `path/to/file`
-   - Verify: `command`
-2. [ ] {specific task}
-
-### Phase 2: {phase-name}
-1. [ ] {specific task}
-2. [ ] {specific task}
-
-### Phase 3: Testing and Verification
-1. [ ] Unit Tests
-2. [ ] Integration Tests
-</task>
-
-## Constraints
-<constraints>
-- Follow existing code patterns
-- Localize error messages
-- Separate configuration via environment variables
-- {other constraints}
-</constraints>
-
-## Output Format
-<output_format>
-### Files to Create
-- `path/to/new/file.ts`
-- `path/to/new/file.test.ts`
-
-### Files to Modify
-- `path/to/existing/file.ts`
-
-### Verification Commands
-- `npm test`
-- `npm run build`
-</output_format>
-
-## Acceptance Criteria
-<acceptance>
-- [ ] {verifiable criterion 1}
-- [ ] {verifiable criterion 2}
-- [ ] All tests pass
-- [ ] Build succeeds
-</acceptance>
+/vibe.trace "{feature-name}"
 ```
 
-### 5. Create Feature File (BDD) - Required
-
-**🚨 CRITICAL: Feature files MUST match SPEC file structure**
-
-| SPEC Structure | Feature Structure |
-|----------------|-------------------|
-| Single file (`{feature}.md`) | Single file (`{feature}.feature`) |
-| Split (`{feature}/_index.md` + phases) | Split (`{feature}/_index.feature` + phases) |
-
-#### 5.1 Single File (Small Scope)
-
-Create `.claude/vibe/features/{feature-name}.feature`:
+SPEC ↔ 구현 추적.
 
-**Creation rules:**
-1. Convert each SPEC Acceptance Criteria → one Scenario
-2. Include Happy Path (normal case) + Edge Case (exception case)
-3. Follow Given-When-Then format
+> **Phase 7 완료 시**: `.claude/vibe/.last-feature` 삭제 (워크플로 완주 — 다음 `/vibe.spec` 호출은 빈 시작 또는 진행 중 작업 목록에서 시작).
 
-```markdown
-# Feature: {feature-name}
+## ultrawork 모드
 
-**SPEC**: `.claude/vibe/specs/{feature-name}.md`
+`ultrawork` (또는 `ulw`)가 인자에 포함되면:
 
-## User Story
-**As a** {user}
-**I want** {feature}
-**So that** {value}
-
-## Scenarios
-
-### Scenario 1: {Happy Path}
-\`\`\`gherkin
-Scenario: {title}
-  Given {precondition}
-  When {action}
-  Then {result}
-\`\`\`
-**Verification**: SPEC AC #1
-
-### Scenario 2: {Edge Case}
-...
-
-## Coverage
-| Scenario | SPEC AC | Status |
-|----------|---------|--------|
-| 1 | AC-1 | ⬜ |
-```
-
-#### 5.2 Split Files (Large Scope)
-
-When SPEC is split into phases, Feature files MUST also be split:
+- **모든 Stop Gate 스킵**
+- interview → plan → spec → review → run → (figma 병렬) 전체 자동 실행
+- askUser 체크포인트 스킵, 기본값 사용
+- 수동 개입 없이 완주
 
 ```
-.claude/vibe/features/{feature-name}/
-├── _index.feature        # Master: links to all phase features
-├── phase-1-setup.feature # Scenarios for phase-1-setup.md
-├── phase-2-core.feature  # Scenarios for phase-2-core.md
-└── ...
+/vibe.spec "패럴랙스 웹사이트" ultrawork
 ```
 
-**Phase Feature file structure:**
+## Smart Resume 예시
 
-```markdown
-# Feature: {feature-name} - Phase {N}: {phase-name}
-
-**SPEC**: `.claude/vibe/specs/{feature-name}/phase-{N}-{name}.md`
-**Master Feature**: `.claude/vibe/features/{feature-name}/_index.feature`
-
-## User Story (Phase Scope)
-**As a** {user}
-**I want** {phase-specific feature}
-**So that** {phase-specific value}
-
-## Scenarios
-
-### Scenario 1: {Phase Happy Path}
-...
-
-## Coverage
-| Scenario | SPEC AC | Status |
-|----------|---------|--------|
-| 1 | Phase {N} AC-1 | ⬜ |
+### 예시 1: 신규 프로젝트
 ```
+User: /vibe.spec "원두 브랜드 랜딩"
 
-### 6. Ambiguity Scan - Required
-
-After creating SPEC draft, **must perform systematic ambiguity check**.
-
-#### 6.1 Mandatory Check Categories
+Claude: 🔍 Input 분석
+        입력: "원두 브랜드 랜딩"
+        분류: 신규 아이디어
+        기존 파일: 없음
+        → 시작 단계: Phase 1 (vibe.interview)
 
-| Category | Check Items | Red Flags |
-|----------|-------------|-----------|
-| **Functional Scope** | Missing features, unclear behavior | "etc.", "other", "if needed" |
-| **Data Model** | Undefined entities, relationships | Undefined types, missing fields |
-| **Non-Functional** | Performance, security requirements | Performance requirements without numbers |
-| **Edge Cases** | Boundary conditions, errors | 0 failure scenarios |
-| **Integration Points** | External APIs, contracts | API version/endpoint undefined |
-| **User Input** | Validation rules, limits | Input limits not specified |
-| **State Management** | State transitions, persistence | Missing state diagram |
-
-#### 6.2 Forbidden Ambiguous Terms
-
-If the following terms exist in SPEC, **clarification is mandatory**:
-
-| Forbidden Term | Replacement Method |
-|----------------|-------------------|
-| "appropriately", "properly" | Provide specific criteria (e.g., "within 3 seconds") |
-| "quickly", "rapidly" | Specify with numbers (e.g., "under 100ms") |
-| "various", "multiple" | List specific items |
-| "etc.", "other" | Specify complete list or limit scope |
-| "if needed", "depending on situation" | Specify conditions (e.g., "when credits < 10") |
-| "later", "in the future" | Explicitly exclude from current scope |
-
-#### 6.3 Check Process
-
-```
-1. Write SPEC draft
-      ↓
-2. Auto-scan for forbidden terms
-      ↓
-3. Review checklist by category
-      ↓
-4. List discovered ambiguities
-      ↓
-5. Auto-fixable items → Fix immediately
-   Needs user confirmation → Ask question
-      ↓
-6. Re-verify (max 2 rounds — remaining ambiguities → user confirmation or TODO)
+        [vibe.interview 스킬 로드]
+        Type: website 감지 → checklists/website.md 로드
+        ...
 ```
 
-#### 6.4 Auto-Fix for Common Ambiguities
-
-| Ambiguity Type | Auto-Fix Method |
-|----------------|-----------------|
-| Timeout undefined | Apply default 30 seconds |
-| Retry count undefined | Apply default 3 retries |
-| Pagination undefined | Apply default 20 items/page |
-| Input length undefined | Text 500 chars, password 8-64 chars |
-| File size undefined | Image 5MB, video 100MB |
-
-#### 6.5 Ambiguity Output Format
-
-```markdown
-## 🔍 Ambiguity Scan Results
-
-### Found Issues: 3
-
-#### 1. Functional Scope
-- ⚠️ "Login failure behavior" not defined
-  → **Auto-fix**: Apply 5-minute lockout after 3 failures
-- ⚠️ "Session expiration handling" unclear
-  → **Question**: Session expiration time? (30min/1hour/24hours)
-
-#### 2. Edge Cases
-- ⚠️ Concurrent login permission undefined
-  → **Question**: Allow concurrent login? (Y/N)
-
-### Auto-fixed: 1
-### Needs clarification: 2
+### 예시 2: 기획서에서 시작
 ```
+User: /vibe.spec ".claude/vibe/plans/bean-landing.md"
 
-### 7. Quality Validation (Self-Check)
-
-**Must perform self-quality check after SPEC completion**
-
-#### 7.1 Quality Checklist (Required Items)
-
-| Category | Check Item | Weight |
-|----------|------------|--------|
-| **Completeness** | All user flows included in Task | 15% |
-| **Completeness** | All ACs converted to Feature scenarios | 10% |
-| **Clarity** | No ambiguous terms (e.g., "appropriately", "quickly") | 10% |
-| **Clarity** | All numbers/limits specified (e.g., "max 500 chars") | 10% |
-| **Testability** | All ACs are auto-testable | 10% |
-| **Security** | Authentication/authorization requirements defined | 10% |
-| **Security** | Sensitive data handling method specified | 5% |
-| **Error Handling** | Major failure scenarios defined | 10% |
-| **Error Handling** | User error messages specified | 5% |
-| **Performance** | Response time/throughput targets specified | 5% |
-| **Edge Cases** | Boundary condition handling defined | 5% |
-| **Dependencies** | External systems/APIs specified | 5% |
-
-#### 7.2 Quality Score Calculation
+Claude: 🔍 Input 분석
+        입력: plan 파일 경로
+        분류: 기존 기획서
+        Feature: bean-landing
+        → 시작 단계: Phase 3 (vibe.spec)
 
+        [vibe.spec 스킬 로드]
+        기획서 읽기 → research → PTCF 작성 ...
 ```
-Score = Σ(Check item met × Weight) / 100
 
-Grades:
-- 95-100: ✅ EXCELLENT - Ready to start implementation
-- 90-94:  ⚠️ GOOD - Minor improvements required before implementation
-- 80-89:  ⚠️ FAIR - Significant improvements required
-- 0-79:   ❌ POOR - Rewrite required
+### 예시 3: 기존 feature 재개
 ```
+User: /vibe.spec "bean-landing"
 
-#### 7.3 Quality Gate (Auto-verification)
-
-**Minimum 95 points required to complete SPEC draft**
+Claude: 🔍 Input 분석
+        입력: feature name
+        기존 파일 검색...
+          ✅ interview: .claude/vibe/interviews/bean-landing.md
+          ✅ plan: .claude/vibe/plans/bean-landing.md
+          ❌ spec: 없음
+        → 시작 단계: Phase 3 (vibe.spec)
 
+        [vibe.spec 스킬 로드]
+        ...
 ```
-SPEC writing complete
-      ↓
-[Calculate Quality Score]
-      ↓
-Score < 95? → Show missing items → Attempt auto-fix → Re-evaluate
-      ↓
-Score ≥ 95 → SPEC Draft Complete → Handoff to /vibe.spec.review
-```
-
-#### 7.4 Auto-Fix for Low Score
-
-If score is below 95, attempt automatic fixes:
-
-| Missing Item | Auto-Fix Method |
-|--------------|-----------------|
-| Missing AC | Auto-generate AC based on Task |
-| Numbers not specified | Apply project defaults (e.g., timeout 30s) |
-| Missing error handling | Add common error scenarios |
-| Missing performance targets | Apply industry standard criteria |
-
-### 8. SPEC Draft Complete - Handoff to Review
-
-**🚨 IMPORTANT: GPT/Gemini review is now a SEPARATE command**
-
-After SPEC draft is complete (score ≥ 95):
-
-**If `ultrawork` mode:**
-- ❌ DO NOT show handoff message
-- ❌ DO NOT ask for confirmation
-- ✅ Immediately proceed to `/vibe.spec.review "{feature-name}"`
-- ✅ After review passes, immediately proceed to `/vibe.run "{feature-name}" ultrawork`
-
-**If normal mode:**
-Output the handoff message:
 
+### 예시 4: SPEC 리뷰 재실행
 ```
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-✅ SPEC DRAFT COMPLETE: {feature-name}
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+User: /vibe.spec "bean-landing"
 
-📋 SPEC: .claude/vibe/specs/{feature-name}.md
-📋 Feature: .claude/vibe/features/{feature-name}.feature
-📊 Quality Score: {score}/100
-⏱️ Started: {start_time}
-⏱️ Completed: {getCurrentTime 결과}
+Claude: 🔍 Input 분석
+        기존 파일:
+          ✅ spec: .claude/vibe/specs/bean-landing.md
+          ✅ feature: .claude/vibe/features/bean-landing.feature
 
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-⚠️ NEXT STEP: Run SPEC review
-
-Option 1 (same session):
-  /vibe.spec.review "{feature-name}"
-
-Option 2 (recommended for large context):
-  /new → /vibe.spec.review "{feature-name}"
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+        이미 SPEC이 존재합니다. 어떻게 진행할까요?
+        1. SPEC 리뷰 (Phase 4: vibe.spec.review 스킬 로드)
+        2. /vibe.run 실행 (구현)
+        3. SPEC 재작성 (기존 백업 후 새로 작성)
+        4. 종료
 ```
 
-**Tip:** New session recommended when context > 50% to ensure review accuracy
-
-## Output (MANDATORY File Creation)
-
-**🚨 CRITICAL: Files MUST be created in these EXACT paths. NO exceptions.**
-
-### Small Scope (Single File)
-
-| File | Path | When |
-|------|------|------|
-| SPEC | `.claude/vibe/specs/{feature-name}.md` | After quality validation (Step 7) |
-| Feature | `.claude/vibe/features/{feature-name}.feature` | Immediately after SPEC |
-
-### Large Scope (Split Files)
-
-| File | Path | When |
-|------|------|------|
-| Master SPEC | `.claude/vibe/specs/{feature-name}/_index.md` | After quality validation |
-| Phase SPEC | `.claude/vibe/specs/{feature-name}/phase-{N}-{name}.md` | Per phase |
-| Master Feature | `.claude/vibe/features/{feature-name}/_index.feature` | After Master SPEC |
-| Phase Feature | `.claude/vibe/features/{feature-name}/phase-{N}-{name}.feature` | Per phase SPEC |
-
-**❌ FORBIDDEN:**
+### 예시 5: feature 이름을 잊고 인자 없이 호출 (Smart Resume Fallback)
+```
+User: /vibe.spec
 
-- Creating files in project root (e.g., `feature-name.md`)
-- Creating files outside `.claude/vibe/` directory
-- Skipping file creation
-- Using different file names than feature-name
-- Creating split SPEC without matching split Feature files
+Claude: (.last-feature 읽기 → "bean-landing" 발견)
 
-**✅ REQUIRED:**
+        🔄 마지막 작업: bean-landing
+        ✅ interview: .claude/vibe/interviews/bean-landing.md  (status: partial, 2일 전)
+        ❌ plan:      없음
+        ❌ spec:      없음
+        → 다음 단계: Phase 2 (vibe.plan — 기획서 작성)
 
-- Use Write tool to create files
-- Verify directories exist (create if needed)
-- Confirm file creation in response
-- **Each SPEC file must have a matching Feature file**
+        이어서 진행할까요?
+          Enter / yes → 이어서 진행
+          list        → 다른 진행 중 작업 목록 보기
+          new         → 새 아이디어로 시작
+          abort       → 종료
 
-### File Creation Template
+User: yes
 
-**Single file:**
-```
-1. Write .claude/vibe/specs/{feature-name}.md
-2. Write .claude/vibe/features/{feature-name}.feature
-3. Confirm: "✅ Created: specs/{feature-name}.md + features/{feature-name}.feature"
+Claude: [Phase 2 진입]
+        .last-feature = bean-landing
+        [vibe.plan 스킬 로드]
+        ...
 ```
 
-**Split files:**
+### 예시 6: 여러 feature 중 선택 (Fallback list 모드)
 ```
-1. Write .claude/vibe/specs/{feature-name}/_index.md
-2. Write .claude/vibe/specs/{feature-name}/phase-1-setup.md
-3. Write .claude/vibe/specs/{feature-name}/phase-2-core.md
-4. Write .claude/vibe/features/{feature-name}/_index.feature
-5. Write .claude/vibe/features/{feature-name}/phase-1-setup.feature
-6. Write .claude/vibe/features/{feature-name}/phase-2-core.feature
-7. Confirm: "✅ Created: {N} SPEC files + {N} Feature files"
-```
-
-## Example
+User: /vibe.spec
 
-```
-User: /vibe.spec "brick-game"
+Claude: (.last-feature 없음 → 디렉토리 스캔)
 
-Claude:
-You're making a brick game! What style are you thinking of?
+        🔍 진행 중인 작업
 
-1. Classic Breakout style
-2. Arkanoid (with power-up items)
-3. Custom style with special gameplay
+        1. bean-landing      [interview: partial]        2일 전
+        2. todo-app          [plan: complete]            어제
+        3. payment-api       [spec: complete]            방금 전
+        ─────────────────────────────────────────────
+        n. ➕ 새로 시작
+        a. 종료
 
-Feel free to describe in your own words.
-
-User: 1
-
-Claude: What platform will it run on?
-
-1. Web (browser)
-2. Mobile (iOS/Android)
-3. Desktop
-
-User: 1
-
-Claude:
-Here are tech stack suggestions for web game development:
-
-1. **Phaser.js** (Recommended) - Game framework with built-in physics engine
-2. **Canvas + JavaScript** - Lightweight with fine control
-3. **PixiJS + Matter.js** - High-performance rendering
-
-User: 1
-
-Claude: What design style?
-
-1. Retro pixel (Atari Breakout)
-2. Neon graphics (Arkanoid)
-3. Modern 3D effects
+        선택 번호 또는 feature 이름을 입력하세요:
 
 User: 2
 
-[Conversation continues...]
-
-Claude: SPEC draft created. Running ambiguity scan.
-
-## 🔍 Ambiguity Scan Results
-
-### Functional Scope
-- ⚠️ Game over condition not defined (ball drop vs lives system)
-- ⚠️ Stage clear condition unclear
-
-### Edge Cases
-- ⚠️ Ball reflection angle when hitting paddle edge
-- ⚠️ Multiple brick collision handling
-
-Please clarify the above items.
-
-User: 3 lives, clear when all bricks destroyed, edge reflects at 45 degrees
-
-Claude: Thank you. SPEC has been refined.
-
-🔍 Re-check result: 0 ambiguities
-📊 Quality score: 92/100 (A)
-
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-🔍 SPEC REVIEW (Gemini)
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-📤 Sending SPEC...
-📝 Gemini feedback:
-  1. [Edge] Ball speed increase logic undefined
-  2. [Security] Need score manipulation prevention
-
-✅ 2 improvements auto-applied
-🔍 Re-verifying... ✅ Passed
-
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-✅ SPEC Complete!
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-📄 .claude/vibe/specs/brick-game.md (PTCF structure)
-📄 .claude/vibe/features/brick-game.feature
-📊 Quality score: 95/100 (A) ← Improved after review
+Claude: Feature: todo-app 선택
+        ✅ plan 완성 → Phase 3 (vibe.spec) 진입
+        .last-feature = todo-app
+        ...
 ```
 
-## Core Tools (Semantic Analysis & Memory)
+## Rollback / Resume
 
-### Tool Invocation
-All tools are called via:
-```bash
-node -e "import('{{VIBE_PATH_URL}}/node_modules/@su-record/vibe/dist/tools/index.js').then(t => t.TOOL_NAME({...args}).then(r => console.log(r.content[0].text)))"
-```
-
-### Recommended Tools for SPEC Creation
-
-| Tool | Purpose | When to Use |
-|------|---------|-------------|
-| `findSymbol` | Find symbol definitions | Locate existing implementations to reference |
-| `findReferences` | Find all references | Understand how existing code is used |
-| `analyzeComplexity` | Code complexity analysis | Evaluate complexity of code to modify |
-| `saveMemory` | Save important decisions | Store confirmed requirements, design decisions |
-| `recallMemory` | Recall saved memory | Retrieve previous project decisions |
-
-### Example Tool Usage in SPEC Creation
-
-**1. Find existing auth implementation:**
-```bash
-node -e "import('{{VIBE_PATH_URL}}/node_modules/@su-record/vibe/dist/tools/index.js').then(t => t.findSymbol({symbolName: 'login', searchPath: 'src/'}).then(r => console.log(r.content[0].text)))"
-```
+- 각 Phase 종료 시 상태가 `.claude/vibe/{interviews,plans,specs,features}/`에 저장됨
+- **`.claude/vibe/.last-feature` pointer**가 각 Phase 진입 시 갱신되어 "가장 최근에 작업한 feature" 추적 (Phase 7 완주 시 삭제)
+- 중단 시 다시 `/vibe.spec`으로 돌아오면 Smart Resume Fallback 동작:
+  - 인자 있음 (`/vibe.spec "feature-name"` 또는 파일 경로) → 해당 feature의 가장 진행된 단계 다음으로 바로 진입
+  - 인자 없음 → `.last-feature` 우선 제안 → 거부하면 진행 중 작업 목록 제시 → 또 거부하면 빈 시작
+- 수동 개입 필요시 스킬 직접 호출 가능 (`Load skill vibe.interview` 등)
 
-**2. Save confirmed requirements:**
-```bash
-node -e "import('{{VIBE_PATH_URL}}/node_modules/@su-record/vibe/dist/tools/index.js').then(t => t.saveMemory({key: 'brick-game-requirements', value: 'Platform: Web, Stack: Phaser.js, Style: Neon', category: 'spec', projectPath: process.cwd()}).then(r => console.log(r.content[0].text)))"
-```
+## Next Step
 
-**3. Recall previous decisions:**
-```bash
-node -e "import('{{VIBE_PATH_URL}}/node_modules/@su-record/vibe/dist/tools/index.js').then(t => t.recallMemory({key: 'brick-game-requirements', projectPath: process.cwd()}).then(r => console.log(r.content[0].text)))"
 ```
+# 전형적인 사용
+/vibe.spec "프로젝트 아이디어"
 
-## Next Step
+# 중간 단계 재개
+/vibe.spec "feature-name"
 
-```
-/vibe.run "brick-game"
+# ultrawork 자동 완주
+/vibe.spec "feature-name" ultrawork
 ```
 
 ---