maskweaver 0.8.1 → 0.8.3

package/README.ko.md

@@ -165,23 +165,22 @@ profile:
 
 **Phase 기반 개발** — "AI가 검증하고, 유저가 확인한다"
 
-Weave는 Maskweaver의 핵심 워크플로우입니다. 작업을 테스트 가능한 Phase로 나누고, 전문가 마스크를 자동 선택하며, 유저에게 전달하기 전에 자체 검증 루프를 실행합니다.
+Weave는 Maskweaver의 핵심 워크플로우입니다. 작업을 테스트 가능한 Phase로 나누고, 전문가 마스크를 자동 선택하며, 유저 전달 전 구조화된 검증 단계를 제공합니다.
 
 #### 명령어
 
 | 명령어 | 설명 |
 |--------|------|
 | `/weave init` | Weave 초기화 (프로젝트당 1회) |
-| `/weave research [docs]` | 문서를 깊게 읽고 `tasks/research.md` 생성 |
-| `/weave prepare [docs]` | (수동 경로) research + baseline spec + phase plan 생성 |
+| `/weave research [docs]` | 문서 + 워크스페이스 맥락을 깊게 읽고 `tasks/research.md` 생성 |
+| `/weave prepare [docs]` | (수동 경로) research + baseline spec + phase plan 생성 (큰 계획은 자동 분할) |
 | `/weave refine-plan` | `tasks/plan-notes.md` 지시문을 active plan에 반영 |
 | `/weave approve-plan` | 구현 전 사람이 계획 승인(게이트) |
-| `/weave flow [docs]` | (권장) 원커맨드 경로: prepare -> approve-plan gate -> craft auto-loop |
+| `/weave flow [docs]` | (권장) 원커맨드 경로: prepare -> auto-approve -> craft -> verify -> finalize |
 | `/weave spec [docs]` | baseline spec만 생성 (선택) |
-| `/weave design [docs]` | 요구사항 분석 → Phase 계획 생성 (`/weave plan`은 별칭/호환) |
-| `/weave craft [P#]` | Phase 실행 계획 생성/실행 + 자동 task loop (phase 생략 시 자동 선택) |
+| `/weave design [docs]` | 요구사항 분석 → Phase 계획 생성 (`/weave plan`은 별칭/호환, 큰 계획은 자동 분할) |
+| `/weave craft [P#]` | Phase 실행 컨텍스트/가이드 생성 |
 | `/weave verify` | 빌드/테스트 검증 실행 (자동 감지) |
-| `/weave approve [P#]` | (기본)검증 후 Phase 완료 처리 (phase 생략 시 자동 선택) |
 | `/weave worktree ...` | git worktree 기반 병렬 작업 관리 |
 | `/weave status` | 프로젝트 진행 상황 및 통계 확인 |
 | `/weave help` | 도움말 표시 |
@@ -194,7 +193,7 @@ Weave는 Maskweaver의 핵심 워크플로우입니다. 작업을 테스트 가
 0. INIT (1회): /weave init
        ↓
 1. 원커맨드(권장): /weave flow docs/
-    - 실행: prepare -> approve-plan gate -> craft auto-loop
+    - 실행: prepare -> auto-approve -> craft -> verify -> finalize
        ↓
    (또는 수동 경로)
        ↓
@@ -208,13 +207,11 @@ Weave는 Maskweaver의 핵심 워크플로우입니다. 작업을 테스트 가
     - craft 실행 전 필수 승인
        ↓
 5. CRAFT: /weave craft
-    - Phase 실행 계획 생성 + 자동 task loop 실행
-    - PASS/FAIL/재시도/re-plan은 craft 루프에서 처리
+     - Phase 실행 계획과 다음 액션 안내 생성
+     - 구현/검증 후 approve-plan으로 phase 완료 처리
+     - `/weave verify`로 빌드/테스트 검증 가능
        ↓
-6. APPROVE: /weave approve
-    - (기본) verify 실행 후 Phase를 completed로 변경
-       ↓
-7. HANDOFF: 유저가 UX/의도 확인 후 다음 Phase로 진행
+6. HANDOFF: 유저가 UX/의도 확인 후 다음 Phase로 진행
 ```
 
 #### 다층 AI 검증 시스템
@@ -363,7 +360,7 @@ import { WeaveOrchestrator, GlobalKnowledge } from 'maskweaver/weave';
 /weave flow docs/
 ```
 
-한 번에 `prepare -> approve-plan gate -> craft auto-loop`까지 실행합니다.
+한 번에 `prepare -> auto-approve -> craft -> verify -> finalize`까지 실행합니다.
 
 수동 happy path (research + spec + plan 한 번에):
 
@@ -418,47 +415,28 @@ AI 인사이트가 포함된 현대적 감정 일기 앱 구축
 /weave craft
 ```
 
-`/weave craft`는 실행 계획을 생성한 뒤 자동 task loop를 즉시 실행합니다(phase 미지정 시 다음 phase 자동 선택). 구현 반영 후 같은 명령을 다시 실행하면 이어서 진행됩니다.
+`/weave craft`는 phase 실행 컨텍스트를 생성합니다(phase 미지정 시 다음 phase 자동 선택). 구현 반영 후 같은 명령으로 계획을 다시 확인할 수 있습니다.
 
-### 4단계: Craft 루프 이어서 진행
+### 4단계: 구현 진행
 
 ```txt
 weave command=craft phaseId="P1"
-weave command=craft phaseId="P1" taskId="P1-T1"
+weave command=verify
 ```
 
-원커맨드로 계속 이어서 진행하려면:
+원커맨드로 이어서 진행하려면:
 
 ```txt
 weave command=flow
 ```
 
-### 5단계: 검증 및 Phase 완료 처리
+### 5단계: Phase 완료 처리
 
 ```txt
 weave command=verify
-weave command=approve
+weave command=approve-plan
 ```
 
-진행 상황 출력:
-```markdown
-### Task 진행 상황
-
-#### Task 1: EmotionButton 컴포넌트
-- [x] 마스크: 🧪 켄트 벡
-- [x] 테스트 작성
-- [x] 구현
-- [x] 검증 완료 ✅
-
-#### Task 2: 상태 관리
-- [x] 마스크: ⚛️ 댄 아브라모프
-- [x] 테스트 작성
-- [x] 구현
-- [ ] 검증 중 🔄 (재시도 2/5)
-  - 💡 유사 솔루션 발견: "React 상태 타이밍 이슈"
-  - 수정: useEffect 의존성 배열 추가
-```
-
 ### 6단계: 핸드오프 & 검증
 
 모든 검증이 통과되면:

package/README.md

@@ -184,23 +184,22 @@ Smart subagents for cost-efficient multi-agent workflows:
 
 **Phase-Driven Development** — "AI verifies, Human validates"
 
-Weave is Maskweaver's flagship workflow. It breaks work into testable phases, auto-selects expert masks, and runs self-verification loops before handing off to you.
+Weave is Maskweaver's flagship workflow. It breaks work into testable phases, auto-selects expert masks, and provides structured verification before handoff.
 
 #### Commands
 
 | Command | Description |
 |---------|-------------|
 | `/weave init` | Initialize Weave (once per repo) |
-| `/weave research [docs]` | Deep-read docs and generate persistent `tasks/research.md` |
-| `/weave prepare [docs]` | (Manual path) Generate research + baseline spec + phase plan |
+| `/weave research [docs]` | Deep-read docs + workspace context and generate persistent `tasks/research.md` |
+| `/weave prepare [docs]` | (Manual path) Generate research + baseline spec + phase plan (auto-split if oversized) |
 | `/weave refine-plan` | Apply structured plan notes (`tasks/plan-notes.md`) to active plan |
 | `/weave approve-plan` | Explicit human approval gate before implementation |
-| `/weave flow [docs]` | (Recommended) One-command path: prepare -> approve-plan gate -> craft auto-loop |
+| `/weave flow [docs]` | (Recommended) One-command path: prepare -> auto-approve -> craft -> verify -> finalize |
 | `/weave spec [docs]` | Generate baseline spec only (optional) |
-| `/weave design [docs]` | Analyze requirements → Generate phase plan (`/weave plan` is an alias) |
-| `/weave craft [P#]` | Generate/run execution plan + auto task loop (auto-select next phase if omitted) |
+| `/weave design [docs]` | Analyze requirements → Generate phase plan (`/weave plan` alias, auto-split if oversized) |
+| `/weave craft [P#]` | Prepare phase execution context and guidance |
 | `/weave verify` | Run build/test verification (auto-detect) |
-| `/weave approve [P#]` | Verify (default) + mark phase complete (auto phase if omitted) |
 | `/weave worktree ...` | Manage git worktrees for parallel work |
 | `/weave status` | View project progress and stats |
 | `/weave help` | Show documentation |
@@ -213,7 +212,7 @@ Weave is Maskweaver's flagship workflow. It breaks work into testable phases, au
 0. INIT (once): /weave init
        ↓
 1. ONE-COMMAND (recommended): /weave flow docs/
-    - runs: prepare -> approve-plan gate -> craft auto-loop
+    - runs: prepare -> auto-approve -> craft -> verify -> finalize
        ↓
    (or manual path)
        ↓
@@ -227,13 +226,11 @@ Weave is Maskweaver's flagship workflow. It breaks work into testable phases, au
     - required before craft execution
        ↓
 5. CRAFT: /weave craft
-     - Generates an execution plan + runs auto task loop
-     - PASS/FAIL/retry/re-plan are handled in the craft loop
+     - Generates an execution plan and next actions
+     - Implement/verify changes, then finalize with approve-plan
+     - Use `/weave verify` anytime for build/test checks
        ↓
-6. APPROVE: /weave approve
-      - Runs verification (full by default) and marks the phase completed
-       ↓
-7. HANDOFF: You validate UX/intent and move to next phase
+6. HANDOFF: You validate UX/intent and move to next phase
 ```
 
 #### Multi-Layer AI Verification
@@ -382,7 +379,7 @@ Fastest path (one command):
 /weave flow docs/
 ```
 
-This runs `prepare -> approve-plan gate -> craft auto-loop` in one shot.
+This runs `prepare -> auto-approve -> craft -> verify -> finalize` in one shot.
 
 Manual happy path (research + spec + plan in one command):
 
@@ -437,13 +434,13 @@ Start with the first phase:
 /weave craft
 ```
 
-`/weave craft` returns an execution plan and immediately runs the auto task loop. Re-run `/weave craft` after implementation updates to continue the same phase.
+`/weave craft` returns execution context for the phase. Implement changes, then rerun `/weave craft` if you want to refresh the plan view.
 
-### Step 4: Continue the Craft Loop
+### Step 4: Continue Implementation
 
 ```txt
 weave command=craft phaseId="P1"
-weave command=craft phaseId="P1" taskId="P1-T1"
+weave command=verify
 ```
 
 One-command resume:
@@ -452,32 +449,13 @@ One-command resume:
 weave command=flow
 ```
 
-### Step 5: Verify and Approve the Phase
+### Step 5: Finalize the Phase
 
 ```txt
 weave command=verify
-weave command=approve
+weave command=approve-plan
 ```
 
-Progress output:
-```markdown
-### Task Progress
-
-#### Task 1: EmotionButton Component
-- [x] Mask: 🧪 Kent Beck
-- [x] Tests written
-- [x] Implementation
-- [x] Verified ✅
-
-#### Task 2: State Management
-- [x] Mask: ⚛️ Dan Abramov
-- [x] Tests written
-- [x] Implementation
-- [ ] Verifying 🔄 (retry 2/5)
-  - 💡 Similar solution found: "React state timing issue"
-  - Fix: Added useEffect dependency array
-```
-
 ### Step 6: Handoff & Validate
 
 When all verifications pass:

package/assets/commands/weave-craft.md

@@ -1,415 +1,43 @@
----
-description: Phase 실행 (Build + Self-Verify Loop with Mask auto-selection)
----
-
-# /weave-craft - Phase 실행
-
-## 개요
-
-**활성 플랜**의 특정 Phase를 실행합니다.
-AI가 자동으로 검증 루프를 돌리고, 완료되면 유저에게 전달합니다.
-
-**사용법**: `/weave-craft $ARGUMENTS`
-- `$ARGUMENTS` = 선택적 Phase ID (예: `P1`, `P2`)
-- 비우면 다음 실행 가능한 Phase를 자동 선택합니다.
+---
+description: Phase 실행 준비 (실행 컨텍스트 생성)
+---
 
-> prepare부터 craft auto-loop까지 한 번에 실행하려면 `/weave-flow [docs]`를 사용하세요.
-
-**Maskweaver 통합**:
-- **Masks**: Task별 전문가 마스크 자동 선택
-- **Global Knowledge**: 과거 트러블슈팅 경험 검색/기록
-- **Verify**: 다층 AI 자동 검증 시스템
-
----
-
-## 사전 조건: 활성 플랜 확인
-
-실행 전 반드시:
-
-```
-1. .opencode/weave/state.yaml 읽기
-2. active_plan 값 확인
-3. .opencode/weave/plans/{active_plan}.yaml 읽기
-4. 해당 Phase 상태 확인
-```
-
-**활성 플랜이 없는 경우**:
-```markdown
-❌ 활성 플랜이 없습니다.
-
-플랜을 먼저 만들어주세요: `/weave-design [docs]`
-또는 기존 플랜을 선택하세요: `/weave-switch`
-```
-
-**요청한 Phase가 없는 경우**:
-```markdown
-❌ 플랜 `emotion-diary`에 Phase P7이 없습니다.
-
-사용 가능한 Phase:
-- P1: 감정 선택 UI ✅
-- P2: 감정 저장 🔄
-- P3: 히스토리 뷰 ⏳
-```
-
----
-
-## 실행 흐름
+# /weave-craft - Phase 실행 준비
 
-```
-0. LOAD PLAN (활성 플랜 + Phase 정보 로드)
-   ↓
-1. GENERATE EXECUTION PLAN (자동 분석)
-   ├─ 각 Task의 복잡도 판단 (simple/standard/complex)
-   ├─ 에이전트 티어 선택 (flash/human/premium)
-   ├─ 전문가 마스크 자동 선택
-   ├─ 글로벌 지식에서 트러블슈팅 힌트 검색
-   └─ 병렬 실행 가능 여부 분석
-   ↓
-2. DELEGATE (실행 계획에 따라 작업 위임)
-   ├─ simple  → dummy-flash  (빠르고 저렴)
-   ├─ standard → dummy-human  (범용)
-   └─ complex  → dummy-premium (강력한 추론)
-   ↓
-3. BUILD + SELF-VERIFY LOOP
-   ├─ 각 Task에 대해:
-   │   ├─ 적합한 마스크 자동 선택
-   │   ├─ 테스트 먼저 (Red)
-   │   ├─ 최소 구현 (Green)
-   │   ├─ 정리 (Refactor)
-   │   └─ AI 자동 검증 → PASS/FAIL
-   │       ├─ PASS → `weave craft ...` 재실행으로 상태 업데이트 (옵션: quick verify/commit)
-   │       └─ FAIL → 실패 기록 + 글로벌 지식 검색 → 수정 → `weave craft ...` 재실행
-   └─ 5회 초과 → 유저에게 도움 요청
-   ↓
-4. UPDATE PLAN (Phase 상태 업데이트)
-   ↓
-5. USER HANDOFF (검증 완료 → 유저 테스트)
-```
-
-> 참고: Phase 완료 처리는 `weave approve`가 담당합니다.
-> 기본적으로 full verify를 수행하고, 통과해야 Phase를 completed로 바꿉니다.
-
----
-
-## Step 0: LOAD PLAN
-
-```yaml
-# 1. state.yaml에서 활성 플랜 확인
-active_plan: "emotion-diary"
-
-# 2. plans/emotion-diary.yaml에서 Phase 정보 로드
-# 3. Phase 상태가 pending 또는 in_progress인지 확인
-# 4. completed인 Phase를 재실행하려면 유저에게 확인
-```
-
----
-
-## Expert Summoning Strategy for Execution (Core)
-
-### Principle: The Right Expert for Each Task
-
-You are the **Mask Weaver**. During execution, your role is to **orchestrate experts**, not to do everything yourself. Each domain has its master — summon them.
-
----
-
-### 1. Task Complexity → Execution Strategy
-
-**The Orchestrator automatically assesses task complexity and selects the agent tier.**
+## 개요
 
-When `weave craft P1` is called, the system generates an execution plan like:
+`/weave-craft`는 활성 플랜의 Phase를 실행 가능한 상태로 준비합니다.
 
-```markdown
-## Phase P1: Emotion Selection UI
+- 대상 phase 자동 선택(또는 직접 지정)
+- phase 상태/실행 계획 로드
+- 구현에 필요한 다음 액션 안내
 
-### Execution Plan
-| # | Task              | Complexity | Agent Tier | Mask          |
-|---|-------------------|-----------|------------|---------------|
-| 1 | Update imports    | simple    | flash      | auto          |
-| 2 | Build component   | standard  | human      | dan-abramov   |
-| 3 | Auth refactoring  | complex   | premium    | martin-fowler |
-```
-
-**Agent Tier Selection Rules:**
+> 이 명령은 과거 자동 루프를 돌리지 않습니다.
 
-| Complexity | Agent Tier | Use When |
-|-----------|------------|----------|
-| simple | `dummy-flash` | File renames, import fixes, formatting, config changes, lint fixes |
-| standard | `dummy-human` | Component implementation, API endpoints, tests, validation |
-| complex | `dummy-premium` | Architecture refactoring, debugging, auth, state management, performance |
+## 사용법
 
-#### Handle Directly (Simple Tasks)
-
-```
-Examples:
-- Simple file creation
-- Minor styling adjustments
-- Configuration changes
-- Straightforward bug fixes
-
-→ You handle these quickly without delegation.
-```
-
-#### Summon Expert (Complex Single Task)
-
-For **substantial implementation work**, summon the domain expert:
-
-```
-Complex Business Logic:
-
-Task(dummy-human):
-  Mask: Kent Beck
-  Task: "Implement the payment validation logic using TDD.
-         Write tests first, cover edge cases, keep it simple."
-
-Complex State Management:
-
-Task(dummy-human):
-  Mask: Dan Abramov
-  Task: "Design the global state architecture for this feature.
-         Consider React patterns and performant updates."
-
-Performance-Critical Code:
-
-Task(dummy-human):
-  Mask: Linus Torvalds
-  Task: "Optimize this data processing function.
-         Focus on memory efficiency and computational complexity."
-
-→ You receive the completed work and integrate it.
-```
-
-#### Squad Parallel Execution (Multiple Independent Tasks)
-
-When a Phase has **several independent tasks**, run them in parallel:
-
-```
-Phase with Frontend + Backend + Tests:
-
-Mask Weaver:
-1. squad start → "Phase P1 Parallel Execution"
-2. squad squad (ui-squad) → "Dan Abramov: Build the React components"
-3. squad squad (api-squad) → "Martin Fowler: Implement the API layer"
-4. squad squad (test-squad) → "Kent Beck: Write comprehensive test suite"
-
-→ Collect all results → Integrate → Run unified verification
-```
-
----
-
-### 2. Expert Selection Guide
-
-| Task Type | Summon | Why |
-|-----------|--------|-----|
-| Business logic, algorithms | **Kent Beck** | TDD ensures correctness, simplicity |
-| React components, state | **Dan Abramov** | React patterns, hooks, performance |
-| API design, services | **Martin Fowler** | Clean architecture, separation |
-| Performance optimization | **Linus Torvalds** | System-level efficiency |
-| Database, queries | **Martin Fowler** | Data modeling, query patterns |
-| ML/AI features | **Andrew Ng** | ML best practices |
-| DevOps, infrastructure | **Linus Torvalds** | Pragmatic tooling |
-
----
-
-### 3. Execution Decision Flow
-
-```
-Execution Plan Generated (automatic)
-    ↓
-For each task in plan:
-    ↓
-Check Agent Tier:
-    ├─ flash (simple) → Handle directly or Task(dummy-flash)
-    ├─ human (standard) → Task(dummy-human) with mask
-    └─ premium (complex) → Task(dummy-premium) with mask
-    ↓
-Multiple independent tasks in same wave?
-    ├─ YES → Run in parallel (Squad system)
-    └─ NO → Run sequentially
+```txt
+/weave-craft $ARGUMENTS
 ```
-
----
-
-### 4. Expert Rotation on Failure
-
-If you're **stuck on the same error twice**, try a different perspective:
-
-```
-Stuck on React state bug:
-- First attempt: Dan Abramov approach
-- Still failing → Summon Kent Beck
-  "Review this from a TDD perspective"
-
-Stuck on performance issue:
-- First attempt: Linus Torvalds approach  
-- Still failing → Summon Martin Fowler
-  "Maybe this is an architecture problem, not just optimization."
-```
-
----
-
-## AI 자동 검증 시스템 (Multi-Layer)
-
-| Layer | 검증 유형 | 도구 | 실패 시 동작 |
-|-------|----------|------|-------------|
-| 1 | TypeCheck | `tsc --noEmit` | 재시도 (코드 수정) |
-| 2 | Lint | `npm run lint` | 재시도 (코드 수정) |
-| 3 | Build | `npm run build` | 재시도 (코드 수정) |
-| 4 | Unit Tests | `npm test` | 재시도 (테스트/코드 수정) |
-| 5 | E2E Tests | `playwright test` | 재시도 (앱/테스트 수정) |
-| 6 | Screenshot | Playwright / browser | 시각적 확인 |
-| 7 | API Check | `fetch` / `curl` | 재시도 (서버/라우트 수정) |
-| 8 | A11y | axe-core / Lighthouse | 재시도 (접근성 개선) |
-
-### 검증 재시도 루프
-
-```
-검증 실행
-    ↓
-실패?
-    ├─ YES → 글로벌 지식에서 유사 해결책 검색
-    │         → 해결책 적용
-    │         → 재시도 카운터 < 5? → 다시 검증
-    │         → 5회 초과 → 유저에게 도움 요청
-    └─ NO → 다음 Layer
-```
-
----
-
-## Step 4: UPDATE PLAN
-
-Phase 완료 시 플랜 파일을 업데이트합니다.
-
-> ⚠️ **YAML 작성 규칙 (반드시 준수)**
->
-> 플랜 YAML을 직접 수정할 때, `done_when` 등 문자열 값은 반드시 아래 규칙을 따릅니다:
->
-> - **짧은 값** (한 줄): double-quote 사용 → `done_when: "로그인 기능 동작"`
-> - **긴 값** (여러 줄): block scalar(`|`) 사용 → `done_when: |` 후 들여쓰기된 내용
-> - **❌ 절대 금지**: double-quote(`"`)로 시작한 문자열을 다른 줄에서 닫는 것
->
-> **핵심**: `"` 로 시작했으면 **같은 줄에서** `"` 로 닫기. 줄바꿈이 필요하면 `|` 사용.
-
-```yaml
-# .opencode/weave/plans/{active_plan}.yaml 내 해당 Phase 업데이트:
-phases:
-  - id: "P1"
-    status: "completed"         # pending → in_progress → completed
-    done_when: "유저가 감정을 선택할 수 있다"  # 짧으면 한 줄 quote
-    started_at: "2026-02-06T10:30:00"
-    completed_at: "2026-02-06T13:00:00"
-    masks_used:
-      - name: "kent-beck"
-        tasks: 2
-        effectiveness: 0.9
-      - name: "dan-abramov"
-        tasks: 1
-        effectiveness: 0.85
-    retry_count: 1
-    issues:
-      - "JSON 직렬화 오류 → useEffect 의존성 추가로 해결"
-```
-
----
-
-## 유저 핸드오프
-
-모든 Task 통과 후:
-
-### 1. AI 사전 체험 (Virtual User Test)
-
-코드 검증이 끝나면, **가상의 대상 사용자 페르소나**를 만들어 주관적 항목을 먼저 평가한다.
 
-#### 페르소나 생성 기준
+- `$ARGUMENTS` = 선택적 Phase ID (`P1`, `P2` 등)
 
-플랜의 목적과 대상 사용자를 기반으로 적절한 페르소나를 구성한다:
+예시:
 
-```yaml
-virtual_user:
-  name: "직장인 김지수 (30대)"           # 프로젝트 대상에 맞는 가상 인물
-  context: "퇴근 후 하루를 정리하며 감정 기록"  # 사용 맥락
-  goals: "간단하고 빠르게 오늘의 감정을 남기고 싶다"
-  tech_level: "일반 사용자"               # 기술 수준
+```txt
+/weave-craft
+/weave-craft P1
 ```
 
-#### 평가 항목
-
-페르소나 관점에서 다음을 평가한다:
-
-| 항목 | 평가 관점 |
-|------|----------|
-| **느낌/톤** | UI 분위기가 프로젝트 의도와 맞는가? (스크린샷 기반) |
-| **사용 흐름** | 핵심 동작이 직관적으로 완료되는가? (클릭 수, 동선) |
-| **기능 일치** | 플랜에 정의된 기능이 실제로 동작하는가? |
-| **첫인상** | 처음 본 사용자가 헤매지 않을까? |
-
-#### 평가 방법
-
-- **스크린샷 촬영**: 브라우저로 주요 화면을 캡처하여 시각적으로 확인
-- **동선 시뮬레이션**: 핵심 시나리오를 실제로 클릭하며 체험
-- **플랜 대조**: 원래 요구사항과 구현 결과를 항목별로 비교
-
-### 2. 핸드오프 메시지 형식
-
-```markdown
-## ✅ Phase P1 검증 완료!
-
-**플랜**: `emotion-diary`
-
-### AI 자동 테스트 결과
-| 테스트 | 결과 |
-|--------|------|
-| Build | ✅ 성공 |
-| Unit Tests | ✅ 15/15 |
-| Lint | ✅ 통과 |
-
-### 사용된 마스크
-- Kent Beck (테스트)
-- Dan Abramov (React 컴포넌트)
-
-### 접속
-http://localhost:5173
-
-### AI 사전 체험 결과
-
-> 💡 **"직장인 김지수 (30대)"** 관점으로 먼저 사용해봤습니다.
-> 한번 확인해보세요.
-
-| 항목 | AI 평가 | 비고 |
-|------|---------|------|
-| 느낌/톤 | ✅ 부드러운 파스텔 톤이 감정 기록 앱에 적합해 보입니다 | 스크린샷 첨부 |
-| 사용 흐름 | ⚠️ 감정 선택 → 저장까지 3탭인데, 2탭이면 더 자연스러울 것 같습니다 | 중간 확인 화면 생략 검토 |
-| 기능 일치 | ✅ 감정 선택 UI가 플랜대로 동작합니다 | - |
-| 첫인상 | ✅ 아이콘만으로 감정이 구분됩니다 | - |
-
-> 위 내용은 AI가 가상 사용자로서 판단한 것입니다.
-> 실제 느낌과 다를 수 있으니 직접 확인 부탁드립니다.
+## 내부 호출
 
-**다음**: `/weave-craft P2` | **상태**: `/weave-status`
+```txt
+weave command=craft phaseId="$ARGUMENTS"
 ```
 
-### 3. 핵심 원칙
+## 권장 흐름
 
-- **빈 체크박스를 던지지 않는다**: AI가 먼저 체험하고 소견을 제시한다
-- **단정하지 않는다**: "~해 보입니다", "~인 것 같습니다" 톤으로 제안한다
-- **유저 판단을 대체하지 않는다**: 최종 확인은 반드시 유저 몫
-- **구체적 근거를 붙인다**: 스크린샷, 클릭 수, 플랜 대조 등 판단 근거를 함께 제시
-
----
-
-## 코드 품질 체크
-
-각 Task 완료 시 적용:
-
-```yaml
-SOLID:
-  - "한 함수/클래스가 여러 일을 하지 않는가?"
-  - "새 기능 추가 시 기존 코드 수정 최소화?"
-
-KISS:
-  - "더 간단한 방법이 있는가?"
-  - "불필요한 추상화가 있는가?"
-
-DRY:
-  - "같은 코드가 반복되는가?"
-  - "공통 함수로 추출할 것이 있는가?"
-```
+1. `weave command=craft`로 phase 실행 컨텍스트 준비
+2. 코드 구현/위임 수행
+3. `weave command=verify`로 검증
+4. `weave command=approve-plan`으로 phase 확정