feat: add file upload for materials (PDF/DOCX) with ingestion pipeline

.opencode/commands/weave-approve-plan.md

@@ -0,0 +1,57 @@
+---
+description: 구현 전 계획 승인 게이트 통과
+---
+
+# /weave-approve-plan - 계획 승인
+
+## 개요
+
+`/weave-approve-plan`은 **구현 시작 전 필수 승인 단계**입니다.
+
+- 현재 active plan을 승인 상태로 전환
+- 기본적으로 `tasks/plan-notes.md` 지시문을 먼저 자동 반영(refine) 시도
+  - 변경이 반영되면 승인 단계는 일시 중단되고, 검토 후 다시 approve 실행
+- 필요 시 plan 메모를 승인 코멘트로 함께 기록
+- 승인 전에는 `weave craft`/`weave flow` 실행이 차단됩니다
+
+---
+
+## 사용법
+
+```txt
+/weave-approve-plan
+```
+
+짧은 리뷰 코멘트를 함께 남기려면:
+
+```txt
+weave command=approve-plan planReview="API signature는 변경하지 않는다"
+```
+
+자동 note 반영을 끄고 바로 승인하려면:
+
+```txt
+weave command=approve-plan applyNotes=false
+```
+
+---
+
+## 내부 호출
+
+```txt
+weave command=approve-plan
+```
+
+---
+
+## 다음 단계
+
+```txt
+weave command=craft
+```
+
+또는 원커맨드로 이어서 진행:
+
+```txt
+weave command=flow
+```

.opencode/commands/weave-craft.md

@@ -0,0 +1,43 @@
+---
+description: Phase 실행 준비 (실행 컨텍스트 생성)
+---
+
+# /weave-craft - Phase 실행 준비
+
+## 개요
+
+`/weave-craft`는 활성 플랜의 Phase를 실행 가능한 상태로 준비합니다.
+
+- 대상 phase 자동 선택(또는 직접 지정)
+- phase 상태/실행 계획 로드
+- 구현에 필요한 다음 액션 안내
+
+> 이 명령은 과거 자동 루프를 돌리지 않습니다.
+
+## 사용법
+
+```txt
+/weave-craft $ARGUMENTS
+```
+
+- `$ARGUMENTS` = 선택적 Phase ID (`P1`, `P2` 등)
+
+예시:
+
+```txt
+/weave-craft
+/weave-craft P1
+```
+
+## 내부 호출
+
+```txt
+weave command=craft phaseId="$ARGUMENTS"
+```
+
+## 권장 흐름
+
+1. `weave command=craft`로 phase 실행 컨텍스트 준비
+2. 코드 구현/위임 수행
+3. `weave command=verify`로 검증
+4. `weave command=approve-plan`으로 phase 확정

.opencode/commands/weave-design.md

@@ -0,0 +1,296 @@
+---
+description: 요구사항 분석 및 Phase 계획 수립 (멀티 플랜)
+---
+
+# /weave-design - 요구사항 분석 및 계획 수립
+
+## 개요
+
+유저의 요구사항 문서를 분석하고, Phase별 실행 계획을 수립합니다.
+**멀티 플랜**: 하나의 프로젝트에서 여러 플랜을 동시에 관리할 수 있습니다.
+
+큰 계획(phase/시간 규모가 큰 경우)은 자동으로 여러 shard plan 파일로 분할되며,
+각 shard는 독립적으로 세부 설계(task/checklist)를 갖습니다.
+
+**입력 방식**: 
+- 정확한 경로: `docs/`, `wiki/spec.md`
+- 자연어 힌트: `기획 폴더`, `README`, `아까 만든 문서`
+
+> AI가 자동으로 프로젝트를 탐색하여 관련 문서를 찾습니다.
+
+**Maskweaver 통합**:
+- **Memory**: 과거 유사 프로젝트 검색하여 계획 참조
+- **Masks**: 아키텍처 분석에 Martin Fowler 마스크 자동 선택
+
+---
+
+## 사전 조건
+
+`/weave-init`이 실행되어 있어야 합니다.
+실행되지 않았다면 자동으로 init을 먼저 수행합니다:
+1. `.opencode/weave/state.yaml` 존재 여부 확인
+2. 없으면 → `/weave-init` 절차 자동 실행 후 계속 진행
+
+---
+
+## Expert Summoning Strategy (Critical)
+
+### Principle: Summon Named Experts for Quality
+
+You are the **Mask Weaver**. Your power lies in summoning the right expert for the right task. Don't try to do everything yourself — **delegate to specialists**.
+
+---
+
+### 1. Architecture & Design Decisions → Expert Council
+
+For **critical architectural decisions**, summon multiple experts for consultation:
+
+```
+Complex Architecture Decision:
+
+Task(dummy-human):
+  Mask: Martin Fowler (Enterprise Architecture)
+  Task: "Analyze these requirements and propose a layer structure,
+         key components, and design patterns to use."
+
+Task(dummy-human):
+  Mask: Linus Torvalds (System Performance)
+  Task: "Review the proposed architecture for performance bottlenecks
+         and scalability concerns."
+
+→ Mask Weaver synthesizes both perspectives into final decision.
+```
+
+**Why This Works**:
+- Each expert focuses on their domain of excellence
+- You maintain strategic oversight without context pollution
+- Multiple perspectives prevent blind spots
+
+---
+
+### 2. Technology Choices → Squad Parallel Analysis
+
+For **important technology selections** (framework, database, etc.):
+
+```
+Mask Weaver:
+1. squad start → "Optimal Tech Stack Decision"
+2. squad squad (arch-squad) → "Martin Fowler: Maintainability analysis"
+3. squad squad (perf-squad) → "Linus Torvalds: Performance analysis"
+4. squad squad (dx-squad) → "Dan Abramov: Developer experience analysis"
+
+→ Collect results → Weigh trade-offs → Final decision
+```
+
+---
+
+### 3. When to Summon vs Handle Directly
+
+| Situation | Action |
+|-----------|--------|
+| Reading & summarizing requirements | Handle directly |
+| Obvious tech stack (project already decided) | Handle directly |
+| Architecture trade-offs with long-term impact | **Summon Martin Fowler** |
+| Performance-critical design | **Summon Linus Torvalds** |
+| Multiple valid approaches, need comparison | **Squad council** |
+
+> **Rule of Thumb**: If the decision will be hard to reverse later, summon experts. If it's tactical, handle it yourself.
+
+---
+
+## 실행 흐름
+
+```
+0. INIT CHECK (weave 초기화 확인)
+   ↓
+1. RESOLVE (입력 해석 → 실제 경로 찾기)
+   ↓
+2. INTAKE (문서 분석)
+   ↓
+3. CLARIFY (불명확한 부분 질문)
+   ↓
+4. PLAN (계획서 제시 + 플랜 이름 제안)
+   ↓
+5. FEEDBACK (유저 피드백 → 수정)
+   ↓
+6. APPROVE (승인 시 플랜 파일 생성 + 활성 플랜 설정)
+```
+
+---
+
+## 단계별 상세
+
+### Step 0: INIT CHECK
+
+```
+.opencode/weave/state.yaml 존재?
+  ├─ YES → 계속 진행
+  └─ NO → /weave-init 자동 실행 후 계속
+```
+
+### Step 1: RESOLVE (경로 해석)
+
+**입력 유형별 처리**:
+
+| 입력 타입 | 예시 | 처리 방법 |
+|----------|------|----------|
+| 정확한 경로 | `docs/spec.md` | 그대로 사용 |
+| 디렉토리 힌트 | `기획 폴더`, `스펙 폴더` | docs/, spec/, design/, wiki/ 등 탐색 |
+| 파일 타입 힌트 | `README`, `기획서` | README.md, SPEC.md, *.spec.md 등 검색 |
+| 시간 힌트 | `아까 만든`, `어제 정리한` | 최근 수정된 .md 파일 탐색 |
+| 내용 힌트 | `요구사항`, `기능 목록` | 파일 내용 검색 (grep) |
+
+**탐색 순서**:
+1. 프로젝트 루트의 일반적 문서 위치 확인
+   - `docs/`, `doc/`, `wiki/`, `spec/`, `design/`
+2. 키워드 매칭으로 후보 파일 탐색
+3. 최근 수정 시간 고려 (시간 힌트가 있는 경우)
+4. 후보가 여러 개면 유저에게 확인
+
+---
+
+### Step 2: INTAKE
+
+**수행 작업**:
+1. 해석된 경로의 모든 문서 읽기
+2. 핵심 기능 추출
+3. 기술적 요구사항 식별
+4. 과거 유사 프로젝트 검색 (Memory 시스템)
+
+---
+
+### Step 3: CLARIFY
+
+불명확한 부분을 유저에게 질문합니다.
+
+---
+
+### Step 4: PLAN
+
+**Phase 크기 기준**:
+- 한 Phase = 반나절 ~ 하루 작업량
+- 끝나면 유저가 뭔가 "해볼 수 있어야" 함
+
+**플랜 이름 제안**:
+계획서와 함께 **플랜 이름(kebab-case)**을 제안합니다:
+```markdown
+## 📋 실행 계획서
+
+**플랜 이름**: `emotion-diary` (변경 가능)
+
+### 비전
+[전체 목표 요약]
+
+### Phase 계획
+| Phase | 이름 | 완료 조건 | 예상 시간 |
+|-------|------|----------|----------|
+| P1 | [...] | [...] | 2-3시간 |
+| P2 | [...] | [...] | 2-3시간 |
+
+---
+이 계획이 괜찮으세요? 플랜 이름을 바꾸고 싶다면 말씀해주세요.
+```
+
+---
+
+### Step 5: APPROVE
+
+**플랜 파일 생성**: `.opencode/weave/plans/{plan-name}.yaml`
+
+> ⚠️ **YAML 작성 규칙 (반드시 준수)**
+>
+> `done_when`, `vision` 등 **긴 문자열 값**은 반드시 아래 규칙을 따릅니다:
+>
+> | 상황 | 사용할 표기법 | 예시 |
+> |------|-------------|------|
+> | 한 줄로 끝나는 짧은 값 | double-quote (`"`) | `done_when: "로그인 기능 동작"` |
+> | 여러 줄 또는 긴 값 | block scalar (`\|`) | 아래 예시 참고 |
+> | ❌ 절대 금지 | 여러 줄에 걸친 double-quote | `done_when: "1단계...\n2단계..."` |
+>
+> ```yaml
+> # ✅ 올바른 예시 - 짧은 값
+> done_when: "유저가 감정을 선택할 수 있다"
+>
+> # ✅ 올바른 예시 - 긴 값 (block scalar)
+> done_when: |
+>   1. 유저가 감정을 선택할 수 있다
+>   2. 선택한 감정이 저장된다
+>   3. 저장 확인 메시지가 표시된다
+>
+> # ❌ 잘못된 예시 - 닫는 따옴표가 다른 줄에 있음 (YAML 파싱 실패!)
+> done_when: "1. 유저가 감정을 선택할 수 있다
+>   2. 선택한 감정이 저장된다
+>   3. 저장 확인 메시지가 표시된다"
+> ```
+>
+> **핵심 원칙**: `"` 로 시작했으면 **같은 줄에서** `"` 로 닫아야 합니다. 줄바꿈이 필요하면 `|` 를 사용하세요.
+
+```yaml
+plan_name: "emotion-diary"
+project_name: "감정 일기 앱"
+created_at: "2026-02-06"
+status: "active"     # active | paused | completed | archived
+
+vision: |
+  [전체 비전]
+
+architecture:
+  frontend: "[...]"
+  backend: "[...]"
+  database: "[...]"
+
+phases:
+  - id: "P1"
+    name: "[Phase 이름]"
+    status: "pending"    # pending | in_progress | completed
+    done_when: "[짧으면 한 줄 double-quote, 길면 | 블록 스칼라 사용]"
+    started_at: null
+    completed_at: null
+    masks_used: []
+    checklist:
+      - "[체크 항목 1]"
+      - "[체크 항목 2]"
+    tasks: []
+```
+
+**state.yaml 업데이트**:
+
+```yaml
+active_plan: "emotion-diary"
+```
+
+**완료 메시지**:
+```markdown
+✅ 플랜이 승인되었습니다!
+
+📁 생성된 파일: `.opencode/weave/plans/emotion-diary.yaml`
+📌 활성 플랜으로 설정됨
+
+### 다음 단계
+Phase 1을 시작하려면:
+`/weave-craft P1`
+```
+
+---
+
+## 기존 플랜이 있는 경우
+
+활성 플랜이 이미 존재하면:
+```markdown
+ℹ️ 현재 활성 플랜: `todo-app` (P2 진행 중)
+
+새 플랜을 추가하면 기존 플랜은 유지되고, 새 플랜이 활성 플랜이 됩니다.
+기존 플랜으로 돌아가려면: `/weave-switch todo-app`
+
+계속 진행할까요?
+```
+
+---
+
+## 주의사항
+
+1. **Phase는 작게**: 큰 Phase는 분할
+2. **복잡한 분석은 위임**: Task(dummy-human)으로 전문가 위임
+3. **테스트 가능해야**: 각 Phase 끝에 유저가 확인할 수 있어야
+4. **아키텍처는 유연하게**: "변경 가능"을 명시
+5. **플랜 이름은 kebab-case**: 파일명이 되므로 영문 소문자, 하이픈만 사용

.opencode/commands/weave-flow.md

@@ -0,0 +1,48 @@
+---
+description: 원커맨드 실행 (prepare -> auto-approve -> craft -> verify -> finalize)
+---
+
+# /weave-flow - 원커맨드 실행
+
+## 개요
+
+`/weave-flow`는 Weave 기본 경로를 한 번에 실행합니다.
+
+- `prepare` (필요 시): research + spec + plan 생성
+- `refine-plan` (선택): `tasks/plan-notes.md` 지시문 반영
+- `plan gate`: 실행 전 계획 품질 점검 (구현/테스트/검증 커버리지, 실패 시 경고 후 계속 진행)
+- `auto-approve`: flow가 승인 단계를 자동 통과
+- `craft`: 실행 대상 phase의 실행 컨텍스트를 준비
+- `verify`: 기본 quick 검증 실행
+- `finalize`: 검증 통과 시 phase 완료 처리
+
+## 사용법
+
+```txt
+/weave-flow $ARGUMENTS
+```
+
+- 문서 경로를 넘기면 prepare부터 시작
+- 비우면 기존 active plan 재사용
+
+## 내부 호출
+
+```txt
+weave command=flow docsPath="$ARGUMENTS"
+```
+
+또는:
+
+```txt
+weave command=flow
+```
+
+## 산출물
+
+- `tasks/todo.md`: 현재 plan/phase 체크리스트 + 최근 리뷰
+- `tasks/lessons.md`: 실패 패턴과 재발 방지 규칙 기록
+
+## 다음 단계
+
+- 검증 실패 시 수정 후 `/weave-flow` 또는 `weave command=verify` 재실행
+- 진행 상황 확인: `weave command=status`

.opencode/commands/weave-help.md

@@ -0,0 +1,158 @@
+---
+description: Weave 워크플로우 도움말
+---
+
+# /weave-help - Weave 워크플로우 도움말
+
+## Weave란?
+
+Maskweaver의 **Phase-Driven Development** 워크플로우입니다.
+"AI가 검증하고, 유저가 확인한다"
+
+**멀티 플랜**: 하나의 프로젝트에서 여러 플랜을 동시에 관리할 수 있습니다.
+
+---
+
+## 버전 확인
+
+설치된 Maskweaver 버전을 확인하는 방법:
+
+| 방법 | 명령어 |
+|------|--------|
+| CLI | `maskweaver --version` 또는 `maskweaver -V` |
+| npm | `npm list maskweaver` |
+| 채팅 내 | `maskweaver_status` 도구 사용 |
+| Weave | `/weave help` |
+| Node.js | `import { VERSION } from 'maskweaver'` |
+
+---
+
+## 핵심 철학
+
+```
+1. 테스트 먼저 (Protect Before Change)
+2. 작게 자주 (Small & Often)
+3. 동작이 정답 (Working > Perfect)
+```
+
+---
+
+## 명령어 목록
+
+| 명령어 | 설명 |
+|--------|------|
+| `/weave-init` | Weave 초기화 (프로젝트당 1회) |
+| `/weave-research [docs]` | 문서+워크스페이스를 깊게 조사하고 `tasks/research.md` 생성 |
+| `/weave-spec [docs]` | 요구사항 정제 + 검증 기준(AC) 추출 (선택) |
+| `/weave-prepare [docs]` | **research + spec + plan을 한 번에 생성** (큰 계획은 자동 분할) |
+| `/weave-refine-plan` | `tasks/plan-notes.md` 지시문을 plan에 자동 반영 |
+| `/weave-approve-plan` | 구현 전 계획 승인 게이트 통과 |
+| `/weave-flow [docs]` | **원커맨드** prepare → approve-plan gate → craft |
+| `/weave-design [docs]` | 요구사항 분석 → Phase 계획 (새 플랜 생성, 큰 계획은 자동 분할) |
+| `/weave-plan [docs]` | `/weave-design` 별칭 (호환용) |
+| `/weave-craft [phase-id]` | 활성 플랜의 Phase 실행 준비 (실행 컨텍스트 생성) |
+| `/weave-status` | 전체 플랜 목록 + 진행 상황 |
+| `/weave-switch [plan]` | 활성 플랜 전환 / 아카이브 |
+| `/weave-worktree` | git worktree 기반 병렬 작업(기능/Phase) 관리 |
+| `/weave-verify` | 빌드/테스트 검증 실행(프로젝트 유형 자동 감지) |
+| `/weave-help` | 이 도움말 |
+
+---
+
+## 멀티 플랜 워크플로우
+
+```
+/weave-init                    ← 프로젝트 초기화 (1회)
+    ↓
+/weave-flow docs/              ← (원커맨드) prepare→approve-plan gate→craft
+    ↓
+/weave-prepare docs/           ← (수동 경로) research+spec+plan 한 번에 생성
+    ↓
+/weave-refine-plan             ← (선택) plan-notes 기반 자동 정제
+    ↓
+/weave-approve-plan            ← 구현 전 계획 승인 (필수)
+    ↓
+/weave-craft                   ← 다음 Phase 자동 선택 실행 준비
+    ↓
+/weave-design wiki/new-feat    ← 두 번째 플랜 추가 (또는 prepare)
+    ↓
+/weave-switch first-plan       ← 첫 번째 플랜으로 돌아가기
+    ↓
+/weave-status                  ← 전체 상황 확인
+```
+
+### 플랜 상태 흐름
+
+```
+active ──→ paused ──→ active (switch로 전환)
+  │                      │
+  └──→ completed ──→ archived (switch archive)
+                         │
+                         └──→ paused (switch unarchive)
+```
+
+---
+
+## 파일 구조
+
+```
+.opencode/weave/
+├── state.yaml           ← 활성 플랜 추적
+├── specs/
+│   ├── emotion-diary.yaml    ← baseline spec 1
+│   └── todo-app.yaml         ← baseline spec 2
+└── plans/
+    ├── emotion-diary.yaml   ← 플랜 1
+    ├── todo-app.yaml        ← 플랜 2
+    └── auth-module.yaml     ← 플랜 3
+```
+
+---
+
+## Maskweaver 통합 기능
+
+### 마스크 자동 선택
+
+작업 맥락에 따라 전문가 마스크가 자동 선택됩니다:
+- 아키텍처 → Martin Fowler
+- 테스트 → Kent Beck
+- React → Dan Abramov
+- 성능 → Linus Torvalds
+
+### 글로벌 지식 공유
+
+트러블슈팅 경험이 프로젝트 간 공유됩니다:
+- 에러 발생 시 → 과거 솔루션 검색
+- 해결 시 → 새 솔루션 기록
+
+### 다층 자동 검증
+
+Phase 실행 시 자동 검증:
+1. TypeCheck → Lint → Build
+2. Unit Tests → E2E Tests
+3. Screenshot → A11y Check
+
+---
+
+## 빠른 시작
+
+```bash
+# 1. 초기화 (프로젝트당 1회)
+/weave-init
+
+# 2. (추천) spec + plan을 한 번에 생성
+/weave-prepare wiki/
+
+# 3. 계획 검토 후 승인 게이트 통과
+/weave-refine-plan   # (선택) notes 반영
+/weave-approve-plan
+
+# 4. 다음 Phase 자동 선택 실행
+/weave-craft
+
+# 5. 새 기능 추가? 새 플랜!
+/weave-design docs/new-feature
+
+# 6. 플랜 사이 전환
+/weave-switch emotion-diary
+```

.opencode/commands/weave-init.md

@@ -0,0 +1,108 @@
+---
+description: Weave 워크플로우 초기화 (프로젝트별 1회)
+---
+
+# /weave-init - Weave 워크플로우 초기화
+
+## 개요
+
+현재 프로젝트에서 Weave 워크플로우를 사용할 수 있도록 초기화합니다.
+**프로젝트당 1회**만 실행하면 됩니다.
+
+---
+
+## 수행 작업
+
+### 1. `.ignore` 파일 설정
+
+프로젝트 루트에 `.ignore` 파일을 생성/수정하여 `.opencode/weave/` 경로를 AI 도구가 탐색할 수 있도록 합니다.
+
+**왜 필요한가?**
+- `.gitignore`에 `.opencode/`가 있으면 ripgrep 기반 도구(glob, grep, list)가 PLAN 파일을 찾지 못합니다
+- `.ignore` 파일로 이 규칙을 덮어씌워 AI가 접근할 수 있게 합니다
+- Git 추적 상태는 변하지 않습니다 (`.gitignore`는 그대로)
+
+**생성할 내용**:
+```
+# Allow AI tools to access weave plans (overrides .gitignore)
+!.opencode/weave/
+```
+
+만약 `.ignore` 파일이 이미 있다면, `!.opencode/weave/` 줄만 추가합니다 (중복 방지).
+
+### 2. 디렉토리 구조 생성
+
+```bash
+mkdir -p .opencode/weave/plans
+```
+
+### 3. `state.yaml` 초기화
+
+`.opencode/weave/state.yaml` 파일을 생성합니다:
+
+```yaml
+# Weave Multi-Plan State
+# 이 파일은 활성 플랜을 추적합니다
+active_plan: null
+```
+
+### 4. 기존 PLAN.yaml 마이그레이션 (해당 시)
+
+만약 `.opencode/weave/PLAN.yaml` (구버전 단일 플랜)이 존재하면:
+1. 기존 PLAN을 읽어 multi-plan 포맷으로 저장
+2. `state.yaml`의 `active_plan`을 해당 플랜으로 설정
+3. 기존 PLAN.yaml 삭제 (가능한 경우)
+
+### 5. GDC 연동 점검 및 그래프 동기화
+
+`weave init`은 GDC 연동 상태를 확인합니다.
+
+- `.gdc` 워크스페이스 미감지 시:
+  - 안내 메시지 출력 (`gdc init --language <lang>`)
+- 감지 + 연동 활성화 시:
+  - `gdc version --machine`
+  - `gdc sync --machine`
+  - `gdc check --machine`
+  - `gdc stats --machine`
+
+이 단계는 **정보 제공 및 부트스트랩 목적**이며, 실패해도 Weave 초기화 자체는 완료됩니다.
+
+---
+
+## 완료 메시지
+
+```markdown
+## ✅ Weave 초기화 완료!
+
+### 생성된 파일
+- `.ignore` — AI 도구 접근 허용 설정
+- `.opencode/weave/state.yaml` — 플랜 상태 추적
+- `.opencode/weave/plans/` — 플랜 저장 디렉토리
+
+### 다음 단계
+프로젝트 계획을 세우려면:
+`weave command=prepare docsPath="docs/"`
+```
+
+---
+
+## 이미 초기화된 경우
+
+`.opencode/weave/state.yaml`이 이미 존재하면:
+
+```markdown
+ℹ️ 이미 Weave가 초기화되어 있습니다.
+
+활성 플랜: {active_plan 또는 "없음"}
+전체 플랜 수: {plans/ 내 yaml 파일 수}
+
+상태 확인: `/weave-status`
+```
+
+---
+
+## 주의사항
+
+- `.ignore` 파일은 `.gitignore`와 **같은 레벨(프로젝트 루트)**에 생성합니다
+- `.ignore`는 Git이 아니라 ripgrep만 참조하므로 Git 추적에 영향 없음
+- `.ignore` 파일 자체는 `.gitignore`에 넣지 마세요 (AI가 읽어야 하므로)

.opencode/commands/weave-plan.md

@@ -0,0 +1,15 @@
+---
+description: /weave-design의 별칭(호환용)
+---
+
+# /weave-plan - /weave-design 별칭
+
+이 커맨드는 `/weave-design`과 동일합니다.
+
+```txt
+/weave-design [docs-path]
+```
+
+권장 사용:
+
+- 새 기본 경로: `/weave-prepare [docs-path]` → `weave craft P1`

.opencode/commands/weave-prepare.md

@@ -0,0 +1,69 @@
+---
+description: research + spec + plan을 한 번에 생성 (vNext 기본 경로)
+---
+
+# /weave-prepare - spec + plan 통합
+
+## 개요
+
+`/weave-research` + `/weave-spec` + `/weave-design`을 **한 번에** 이어서 수행합니다.
+
+- 문서를 깊게 읽어 **research.md** 아티팩트를 생성합니다
+- 문서에서 요구사항을 추출해 **baseline spec**을 생성합니다
+- 같은 입력으로 Phase 기반 **plan**을 생성합니다 (큰 계획은 shard plan 파일로 자동 분할)
+- 마지막에 승인 단계(`weave approve-plan`)를 안내합니다
+
+> 목적: 작은 기능마다 spec/plan을 두 번 돌리는 마찰을 줄이고,
+> "리서치-계획-승인"을 빠르게 통과할 수 있는 기본 경로(happy path)를 제공합니다.
+
+> 더 단순한 원커맨드가 필요하면 `/weave-flow [docs]`를 사용하세요
+> (`prepare -> auto-approve -> craft -> verify -> finalize`를 한 번에 실행).
+
+---
+
+## 사용법
+
+**사용법**: `/weave-prepare $ARGUMENTS`
+- `$ARGUMENTS` = 문서 경로 (예: `docs/`, `wiki/spec.md`)
+
+예시:
+- `/weave-prepare docs/`
+- `/weave-prepare wiki/spec.md`
+
+---
+
+## 실행
+
+아래 weave tool 호출을 수행합니다:
+
+```txt
+weave command=prepare docsPath="$ARGUMENTS"
+```
+
+옵션(필요 시):
+
+```txt
+weave command=prepare docsPath="$ARGUMENTS" projectName="My Project" planName="emotion-diary"
+```
+
+---
+
+## 생성되는 산출물(기본)
+
+- Research: `tasks/research.md`
+- Spec: `.opencode/weave/specs/{planName}.yaml`
+- Plan: `.opencode/weave/plans/{planName}.yaml` 또는 `.opencode/weave/plans/{planName}-s*.yaml`
+
+> 주의: `.opencode/`가 gitignore 대상일 수 있으므로, AI 도구가 파일을 읽을 수 있게 `/weave-init`의 `.ignore` 설정을 권장합니다.
+
+---
+
+## 다음 단계
+
+준비가 끝나면:
+
+```txt
+weave command=refine-plan   # (선택) plan-notes 반영
+weave command=approve-plan
+weave craft P1
+```

.opencode/commands/weave-refine-plan.md

@@ -0,0 +1,59 @@
+---
+description: plan-notes 지시문을 active plan에 자동 반영
+---
+
+# /weave-refine-plan - 계획 정제(Annotation Cycle)
+
+## 개요
+
+`/weave-refine-plan`은 `tasks/plan-notes.md`의 지시문을 읽어서 active plan YAML에 자동 반영합니다.
+
+- 구현 전에 계획을 여러 번 정제하는 annotation cycle용
+- 반영이 일어나면 plan 승인 상태를 자동으로 해제
+- 반영 후에는 `weave approve-plan`을 다시 실행해야 구현 가능
+
+---
+
+## 기본 사용법
+
+```txt
+/weave-refine-plan
+```
+
+내부 호출:
+
+```txt
+weave command=refine-plan
+```
+
+노트 파일 경로를 바꾸려면:
+
+```txt
+weave command=refine-plan notesPath="tasks/my-plan-notes.md"
+```
+
+---
+
+## 노트 문법 (예시)
+
+`tasks/plan-notes.md`에 아래처럼 작성:
+
+```txt
+@plan vision: 로그인 이후 대시보드 흐름을 단순화한다
+@arch frontend: React + Vite + TanStack Query
+
+@phase P1 done_when: 유저가 이메일/비밀번호로 로그인할 수 있다
+@phase P1 add_checklist: 로그인 실패 메시지가 명확히 보인다
+
+@phase add P4: 운영 모니터링 | done=로그/메트릭 대시보드가 동작한다 | hours=3
+@phase remove P7
+```
+
+---
+
+## 다음 단계
+
+```txt
+weave command=approve-plan
+weave command=craft
+```

.opencode/commands/weave-repair.md

@@ -0,0 +1,70 @@
+---
+description: 깨진 YAML 플랜 파일을 스캔하고 자동 수복
+---
+
+# /weave-repair - YAML 자동 수복
+
+## 개요
+
+Weave 플랜 YAML 파일의 손상을 감지하고 자동으로 수복합니다.
+
+**사용법**:
+- `/weave-repair` — 전체 플랜 파일 스캔 및 수복
+- `/weave-repair $ARGUMENTS` — 특정 파일만 수복 (예: `holon-x-openclaw-evolution-v3`)
+
+---
+
+## 실행 절차
+
+### 1단계: 플랜 파일 스캔
+
+```
+1. .opencode/weave/state.yaml 확인
+2. .opencode/weave/plans/ 디렉토리의 모든 .yaml 파일 목록 확인
+3. .opencode/weave/PLAN.yaml (레거시) 확인
+```
+
+### 2단계: weave tool로 수복 실행
+
+`weave command=repair`를 호출하여 자동 수복을 실행합니다.
+
+### 3단계: 결과 보고
+
+수복 결과를 유저에게 보여줍니다:
+- **OK**: 정상 파일
+- **FIXED**: 자동 수복 성공 (무엇을 고쳤는지 표시)
+- **FAIL**: 자동 수복 불가 (유저에게 복구 옵션 안내)
+
+---
+
+## 자동 수복 가능한 문제
+
+| 문제 | 예시 | 수복 방법 |
+|------|------|----------|
+| 닫히지 않은 따옴표 | `done_when: "1. fs.edit가 SecurityHook에` | 내부 따옴표 이스케이프 후 닫기 |
+| 탭 문자 | 들여쓰기에 탭 사용 | 스페이스 2칸으로 변환 |
+| 줄바꿈 문제 | CR+LF 혼합 | LF로 통일 |
+| 백업 복원 | 파싱 완전 실패 | `.bak` 파일에서 복원 |
+
+---
+
+## 자동 수복 불가한 경우
+
+수복이 불가능한 파일이 있으면 유저에게 다음 옵션을 안내합니다:
+
+1. **원본 요구사항이 있다면**: `/weave-design`으로 플랜 재생성
+2. **`.corrupted` 백업 확인**: plans 디렉토리에 백업 파일 존재 여부
+3. **수동 복구**: 유저가 플랜 내용을 기억하면 그 정보로 YAML 재구성
+
+**유저에게 물어볼 것**:
+- 해당 플랜의 프로젝트 이름이 무엇이었는지
+- 어떤 Phase들이 있었는지
+- 각 Phase의 진행 상태 (완료/진행중/대기)
+
+---
+
+## 참고
+
+- 수복 시 원본 파일은 `.corrupted` 확장자로 백업됩니다
+- 매 저장마다 `.bak` 백업이 자동 생성됩니다
+- `weave status`나 `weave craft` 실행 시에도 YAML 로드 실패하면 자동 수복을 시도합니다

.opencode/commands/weave-research.md

@@ -0,0 +1,51 @@
+---
+description: 문서 + 워크스페이스 맥락을 깊게 조사해 research.md 생성
+---
+
+# /weave-research - 리서치 아티팩트 생성
+
+## 개요
+
+`/weave-research`는 요구사항 문서와 현재 워크스페이스를 함께 조사해, 리뷰 가능한 리서치 문서를 생성합니다.
+
+- 입력 문서를 분석해 핵심 기능/기술 신호를 추출
+- 워크스페이스에서 관련 구현/중복 신호/재사용 후보를 조사
+- 문제 재현 흐름(가능한 범위)과 전/후 맥락을 정리
+- 열려 있는 질문과 환경 리스크를 정리
+- `tasks/research.md`에 영속 아티팩트로 저장
+
+> 구현 전에 리서치를 먼저 고정해두면, 이후 plan 품질과 수정 비용이 크게 줄어듭니다.
+
+---
+
+## 사용법
+
+```txt
+/weave-research $ARGUMENTS
+```
+
+`$ARGUMENTS`는 문서 경로입니다.
+
+예시:
+- `/weave-research docs/`
+- `/weave-research wiki/spec.md`
+
+---
+
+## 내부 호출
+
+```txt
+weave command=research docsPath="$ARGUMENTS"
+```
+
+---
+
+## 다음 단계
+
+리서치 완료 후 권장 순서:
+
+```txt
+weave command=prepare docsPath="$ARGUMENTS"
+weave command=approve-plan
+weave command=craft
+```

.opencode/commands/weave-spec.md

@@ -0,0 +1,227 @@
+---
+description: 요구사항 정제 및 검증 기준 추출
+---
+
+# /weave-spec - 요구사항 정제
+
+## 개요
+
+기획 문서나 자연어 요구사항을 **구조화된 명세**로 정제합니다.
+각 요구사항에서 **검증 기준(Acceptance Criteria)**을 추출하여, 이후 구현 완료의 성공 판정 기준으로 사용합니다.
+
+**입력 방식**: `/weave-design`과 동일
+- 정확한 경로: `docs/`, `wiki/spec.md`
+- 자연어 힌트: `기획 폴더`, `README`
+
+> 이 커맨드는 **선택 사항**입니다. `/weave-design`을 바로 실행해도 됩니다.
+> 요구사항이 복잡하거나, 구현 완료 기준을 명확히 하고 싶을 때 사용합니다.
+
+---
+
+## 실행
+
+```txt
+weave command=spec docsPath="$ARGUMENTS"
+```
+
+---
+
+## 사전 조건
+
+`/weave-init`이 실행되어 있어야 합니다.
+실행되지 않았다면 자동으로 init을 먼저 수행합니다.
+
+---
+
+## 실행 흐름
+
+```
+0. INIT CHECK
+   ↓
+1. RESOLVE (입력 해석 → 실제 경로 찾기)
+   ↓
+2. ANALYZE (문서에서 요구사항 추출)
+   ↓
+3. STRUCTURE (요구사항 분류 + 검증 기준 도출)
+   ↓
+4. REVIEW (유저에게 제시 → 피드백)
+   ↓
+5. SAVE (스펙 파일 생성)
+```
+
+---
+
+## 단계별 상세
+
+### Step 0: INIT CHECK
+
+`.opencode/weave/state.yaml` 존재 확인. 없으면 `/weave-init` 자동 실행.
+
+### Step 1: RESOLVE
+
+`/weave-design`과 동일한 경로 해석 로직. (정확한 경로, 디렉토리 힌트, 시간 힌트, 내용 힌트 등)
+
+### Step 2: ANALYZE
+
+**수행 작업**:
+1. 해석된 경로의 모든 문서 읽기
+2. 기능 요구사항과 비기능 요구사항 분리
+3. 암묵적 요구사항 식별 (명시되지 않았지만 당연히 필요한 것)
+4. 요구사항 간 의존관계 파악
+5. 과거 유사 프로젝트 검색 (Memory 시스템)
+
+### Step 3: STRUCTURE
+
+각 요구사항을 정제하고, **검증 기준**을 도출합니다.
+
+#### 요구사항 분류
+
+| 분류 | 설명 | 예시 |
+|------|------|------|
+| `functional` | 시스템이 해야 하는 동작 | 사용자가 로그인할 수 있다 |
+| `constraint` | 기술적/비즈니스 제약 | 데이터를 외부 서버로 전송하지 않는다 |
+| `performance` | 성능 요구 | 목록 로딩 2초 이내 |
+| `ux` | 사용성/접근성 요구 | 모바일에서도 사용 가능해야 한다 |
+
+#### 우선순위 (MoSCoW)
+
+| 값 | 의미 |
+|----|------|
+| `must` | 없으면 출시 불가 |
+| `should` | 강력히 권장, 가능하면 포함 |
+| `could` | 있으면 좋지만 없어도 됨 |
+| `wont` | 이번 범위에서 명시적으로 제외 |
+
+#### 검증 기준 유형
+
+| type | 의미 | 실행 방법 |
+|------|------|----------|
+| `e2e` | 브라우저/UI 시나리오 테스트 | Playwright, Cypress 등 |
+| `integration` | API/서비스 간 통합 테스트 | supertest, httpx, curl 등 |
+| `script` | CLI/스크립트 실행 결과 확인 | shell script, node script |
+| `performance` | 성능 기준 충족 | benchmark, lighthouse 등 |
+| `manual` | 자동화 불가, 사용자 확인 | 체크리스트로 유저 핸드오프에 포함 |
+
+#### 검증 기준 작성 원칙
+
+- **모호하지 않을 것**: "잘 동작한다" ✗ → "저장 후 목록에서 확인 가능" ✓
+- **실행 가능할 것**: 구체적인 입력과 기대 결과를 명시
+- **독립적일 것**: 하나의 기준이 하나의 시나리오만 검증
+- **유형은 정직하게**: E2E가 불가능한 것은 `manual`로. 억지로 자동화하지 않음
+
+### Step 4: REVIEW
+
+구조화된 명세를 유저에게 제시합니다:
+
+```markdown
+## 요구사항 명세
+
+**스펙 이름**: `emotion-diary` (변경 가능)
+
+### 기능 요구사항 (Functional)
+
+**R1** [must]: 사용자가 감정을 선택하고 일기를 저장할 수 있다
+- [e2e] 감정 선택 → 텍스트 입력 → 저장 → 목록에서 확인
+- [e2e] 빈 텍스트로 저장 시도 → 에러 메시지 표시
+
+**R2** [must]: 저장된 일기 목록을 조회할 수 있다
+- [e2e] 저장된 일기 3개가 목록에 최신순으로 표시
+
+### 비기능 요구사항
+
+**R3** [should]: 일기 목록이 2초 이내에 로딩된다
+- [performance] 100개 일기 기준 로딩 시간 < 2000ms
+
+**R4** [could]: 오프라인에서도 저장된 일기를 조회할 수 있다
+- [manual] 네트워크 차단 후 기존 일기 목록 접근 가능
+
+---
+빠진 요구사항이 있거나, 검증 기준을 수정하고 싶으면 말씀해주세요.
+```
+
+### Step 5: SAVE
+
+유저 승인 시 스펙 파일을 생성합니다.
+
+**파일 경로**: `.opencode/weave/specs/{spec-name}.yaml`
+
+```yaml
+spec_name: "emotion-diary"
+project_name: "감정 일기 앱"
+created_at: "2026-02-06"
+source_docs:
+  - "docs/requirements.md"
+
+requirements:
+  - id: R1
+    description: "사용자가 감정을 선택하고 일기를 저장할 수 있다"
+    category: functional
+    priority: must
+    acceptance:
+      - id: AC-R1-1
+        scenario: "감정 선택 → 텍스트 입력 → 저장 → 목록에서 확인"
+        type: e2e
+      - id: AC-R1-2
+        scenario: "빈 텍스트로 저장 시도 → 에러 메시지 표시"
+        type: e2e
+
+  - id: R2
+    description: "저장된 일기 목록을 조회할 수 있다"
+    category: functional
+    priority: must
+    acceptance:
+      - id: AC-R2-1
+        scenario: "저장된 일기 3개가 목록에 최신순으로 표시"
+        type: e2e
+
+  - id: R3
+    description: "일기 목록이 2초 이내에 로딩된다"
+    category: performance
+    priority: should
+    acceptance:
+      - id: AC-R3-1
+        scenario: "100개 일기 기준 로딩 시간 < 2000ms"
+        type: performance
+
+  - id: R4
+    description: "오프라인에서도 저장된 일기를 조회할 수 있다"
+    category: constraint
+    priority: could
+    acceptance:
+      - id: AC-R4-1
+        scenario: "네트워크 차단 후 기존 일기 목록 접근 가능"
+        type: manual
+```
+
+**완료 메시지**:
+```markdown
+## 요구사항 명세가 생성되었습니다
+
+📁 파일: `.opencode/weave/specs/emotion-diary.yaml`
+📊 요구사항: 4개 (functional 2, performance 1, constraint 1)
+🎯 검증 기준: 5개 (e2e 3, performance 1, manual 1)
+
+### 다음 단계
+이 명세를 기반으로 실행 계획을 세우려면:
+`/weave-design emotion-diary`
+```
+
+---
+
+## 완료 후 검증 (필수)
+
+스펙 파일 생성 후, 반드시 다음을 확인합니다:
+
+1. **스펙 파일 존재 확인**: `.opencode/weave/specs/{spec-name}.yaml` 존재 검증
+2. **YAML 파싱 가능 확인**: 파일 내용이 유효한 YAML인지 검증
+3. **검증 실패 시**: 유저에게 오류를 알리고 재생성 시도
+
+---
+
+## 핵심 원칙
+
+1. **명세만 수립, 계획/구현 금지**: Phase 분할이나 코드 구현은 하지 않음
+2. **검증 기준은 구체적으로**: 입력 → 기대결과 형태로 작성
+3. **유형은 정직하게**: 자동화 불가능하면 `manual`. 억지로 끼워맞추지 않음
+4. **스펙 이름은 kebab-case**: 이후 `/weave-design`의 플랜 이름으로 사용됨
+5. **wont도 기록**: 명시적으로 제외한 것을 기록해야 나중에 "왜 안 했어?"를 방지

.opencode/commands/weave-status.md

@@ -0,0 +1,155 @@
+---
+description: 전체 플랜 목록 및 진행 상황 확인
+---
+
+# /weave-status - 진행 상황 확인
+
+## 개요
+
+전체 플랜 목록과 활성 플랜의 Phase 진행 상황을 확인합니다.
+
+**사용법**:
+- `/weave-status` — 전체 개요 (모든 플랜 + 활성 플랜 상세)
+- `/weave-status $ARGUMENTS` — 특정 플랜 또는 Phase 상세
+  - `$ARGUMENTS` = 플랜 이름 (예: `emotion-diary`)
+  - `$ARGUMENTS` = Phase ID (예: `P2`, 활성 플랜의 Phase)
+
+---
+
+## 데이터 로드 방법 (필수)
+
+**반드시 이 순서로 파일을 읽어야 합니다**:
+
+```
+1. .opencode/weave/state.yaml 읽기 → active_plan 확인
+2. .opencode/weave/plans/ 디렉토리의 모든 .yaml 파일 목록 확인
+3. 각 플랜 파일 읽어서 상태 집계
+```
+
+**state.yaml이 없는 경우**:
+```markdown
+📋 Weave가 초기화되지 않았습니다.
+
+시작하려면: `/weave-init`
+```
+
+**플랜이 하나도 없는 경우**:
+```markdown
+📋 아직 플랜이 없습니다.
+
+새 플랜을 만들려면: `/weave-design [docs-path]`
+```
+
+---
+
+## 출력: 전체 개요 (`/weave-status`)
+
+```markdown
+## 📊 Weave 상태
+
+### 활성 플랜: `emotion-diary`
+**감정 일기 앱** — 진행률 40%
+
+[████████░░░░░░░░░░░░] 2/5
+
+| Phase | 이름 | 상태 | 마스크 |
+|-------|------|------|--------|
+| P1 | 감정 선택 UI | ✅ 완료 (2.5h) | kent-beck, dan-abramov |
+| P2 | 감정 저장 | 🔄 진행 중 | kent-beck |
+| P3 | 히스토리 뷰 | ⏳ 대기 | |
+| P4 | 통계 시각화 | ⏳ 대기 | |
+| P5 | 테마 설정 | ⏳ 대기 | |
+
+**다음**: `/weave-craft P2`
+
+---
+
+### 전체 플랜 목록
+
+| 플랜 | 프로젝트 | 상태 | 진행률 |
+|------|---------|------|--------|
+| 📌 `emotion-diary` | 감정 일기 앱 | active | 40% (2/5) |
+| `todo-app` | Todo 앱 | paused | 60% (3/5) |
+| `auth-module` | 인증 모듈 | completed | 100% (4/4) |
+
+플랜 전환: `/weave-switch [플랜이름]`
+```
+
+---
+
+## 출력: 특정 플랜 상세 (`/weave-status {plan-name}`)
+
+```markdown
+## 📊 플랜: `todo-app`
+
+**Todo 앱** — 상태: paused — 진행률 60%
+
+[████████████░░░░░░░░] 3/5
+
+### 비전
+사용자가 간단하게 할 일을 관리할 수 있는 웹 앱
+
+### Phases
+| Phase | 이름 | 상태 | 소요 시간 | 마스크 |
+|-------|------|------|----------|--------|
+| P1 | 기본 UI | ✅ 완료 | 2h | dan-abramov |
+| P2 | CRUD API | ✅ 완료 | 3h | martin-fowler |
+| P3 | 필터/정렬 | ✅ 완료 | 1.5h | kent-beck |
+| P4 | 드래그 정렬 | ⏳ 대기 | | |
+| P5 | PWA 지원 | ⏳ 대기 | | |
+
+### 아키텍처
+- Frontend: React + TypeScript
+- Backend: Express.js
+- Database: SQLite
+
+이 플랜으로 전환: `/weave-switch todo-app`
+```
+
+---
+
+## 출력: 특정 Phase 상세 (`/weave-status P2`)
+
+활성 플랜의 해당 Phase를 상세 표시:
+
+```markdown
+## Phase P2: 감정 저장
+
+**플랜**: `emotion-diary`
+**상태**: 🔄 진행 중
+**시작**: 2026-02-06 10:30
+**경과**: 1.5시간
+
+### 사용된 마스크
+- Kent Beck
+
+### 발생한 이슈
+- 1회 재시도: JSON 직렬화 오류 → 해결됨
+
+### 다음
+`/weave-craft P2` — 계속 진행
+```
+
+---
+
+## 상태 아이콘
+
+| 아이콘 | 상태 |
+|--------|------|
+| ✅ | 완료 (completed) |
+| 🔄 | 진행 중 (in_progress) |
+| ⏳ | 대기 (pending) |
+| 🚫 | 차단됨 (의존성 미완료) |
+| 📌 | 활성 플랜 표시 |
+| ⏸️ | 일시정지 (paused) |
+
+---
+
+## 플랜 상태 종류
+
+| 상태 | 의미 |
+|------|------|
+| `active` | 현재 작업 중인 플랜 |
+| `paused` | 일시 중단 (다른 플랜 작업 중) |
+| `completed` | 모든 Phase 완료 |
+| `archived` | 보관됨 (목록에서 숨김, --all로 표시) |

.opencode/commands/weave-switch.md

@@ -0,0 +1,170 @@
+---
+description: 활성 플랜 전환, 목록 조회, 아카이브
+---
+
+# /weave-switch - 플랜 전환
+
+## 개요
+
+멀티 플랜 환경에서 활성 플랜을 전환하거나, 플랜을 관리합니다.
+
+**사용법**:
+- `/weave-switch` — 전체 플랜 목록 표시 (선택 UI)
+- `/weave-switch $ARGUMENTS`
+  - `$ARGUMENTS` = 플랜 이름 → 해당 플랜으로 전환
+  - `$ARGUMENTS` = `archive {plan-name}` → 플랜 아카이브
+  - `$ARGUMENTS` = `unarchive {plan-name}` → 아카이브 해제
+
+---
+
+## 데이터 로드
+
+```
+1. .opencode/weave/state.yaml 읽기 → active_plan 확인
+2. .opencode/weave/plans/ 내 모든 .yaml 파일 읽기
+3. 각 플랜의 plan_name, project_name, status, phases 집계
+```
+
+---
+
+## 플랜 목록 (`/weave-switch` 인자 없음)
+
+```markdown
+## 🔀 플랜 전환
+
+### 활성 플랜
+📌 `emotion-diary` — 감정 일기 앱 (P2 진행 중, 40%)
+
+### 전환 가능한 플랜
+| # | 플랜 | 프로젝트 | 상태 | 진행률 |
+|---|------|---------|------|--------|
+| 1 | `todo-app` | Todo 앱 | paused | 60% |
+| 2 | `auth-module` | 인증 모듈 | completed | 100% |
+
+### 아카이브된 플랜
+| 플랜 | 프로젝트 | 완료일 |
+|------|---------|--------|
+| `old-prototype` | 프로토타입 v1 | 2026-01-15 |
+
+전환하려면: `/weave-switch todo-app`
+아카이브 해제: `/weave-switch unarchive old-prototype`
+```
+
+---
+
+## 플랜 전환 (`/weave-switch {plan-name}`)
+
+### 수행 작업
+
+1. `.opencode/weave/plans/{plan-name}.yaml` 존재 여부 확인
+2. 현재 활성 플랜의 상태를 `paused`로 변경 (active였던 경우)
+3. 대상 플랜의 상태를 `active`로 변경
+4. `state.yaml`의 `active_plan`을 업데이트
+
+### 출력
+
+```markdown
+## ✅ 플랜이 전환되었습니다
+
+📌 `emotion-diary` → `todo-app`
+
+**이전 플랜**: `emotion-diary` (P2 진행 중) → paused
+**현재 플랜**: `todo-app` (P4 대기 중) → active
+
+### 현재 상태
+[████████████░░░░░░░░] 3/5
+
+다음 Phase: `/weave-craft P4`
+돌아가려면: `/weave-switch emotion-diary`
+```
+
+### 에러 케이스
+
+**존재하지 않는 플랜**:
+```markdown
+❌ 플랜 `xyz`를 찾을 수 없습니다.
+
+사용 가능한 플랜:
+- `emotion-diary` (active)
+- `todo-app` (paused)
+
+전체 목록: `/weave-switch`
+```
+
+**이미 활성 플랜인 경우**:
+```markdown
+ℹ️ `emotion-diary`는 이미 활성 플랜입니다.
+
+상태 확인: `/weave-status`
+```
+
+---
+
+## 플랜 아카이브 (`/weave-switch archive {plan-name}`)
+
+### 수행 작업
+
+1. 대상 플랜의 `status`를 `archived`로 변경
+2. 활성 플랜이 아카이브되면 → `state.yaml`의 `active_plan`을 `null`로
+
+### 출력
+
+```markdown
+## 📦 플랜이 아카이브되었습니다
+
+`old-prototype` → archived
+
+아카이브된 플랜은 `/weave-status`에서 숨겨집니다.
+복원하려면: `/weave-switch unarchive old-prototype`
+```
+
+### 활성 플랜을 아카이브하려는 경우
+
+```markdown
+⚠️ `emotion-diary`는 현재 활성 플랜입니다.
+
+아카이브하면 활성 플랜이 없어집니다.
+계속할까요? (예/아니오)
+```
+
+---
+
+## 플랜 아카이브 해제 (`/weave-switch unarchive {plan-name}`)
+
+### 수행 작업
+
+1. 대상 플랜의 `status`를 `paused`로 변경
+2. 활성 플랜으로 자동 전환하지는 않음 (명시적으로 switch 필요)
+
+### 출력
+
+```markdown
+## 📦 아카이브가 해제되었습니다
+
+`old-prototype` → paused
+
+활성 플랜으로 전환하려면: `/weave-switch old-prototype`
+```
+
+---
+
+## state.yaml 변경 예시
+
+전환 전:
+```yaml
+active_plan: "emotion-diary"
+```
+
+전환 후:
+```yaml
+active_plan: "todo-app"
+```
+
+플랜 파일 변경:
+```yaml
+# plans/emotion-diary.yaml
+status: "paused"     # active → paused
+
+# plans/todo-app.yaml
+status: "active"     # paused → active
+```

.opencode/commands/weave-verify.md

@@ -0,0 +1,44 @@
+---
+description: 프로젝트 유형 자동 감지 기반 검증 실행 (build/test)
+---
+
+# /weave-verify - 검증 실행
+
+## 개요
+
+현재 worktree(프로젝트 루트)에서 **빌드/테스트 검증**을 실행합니다.
+
+Weave는 특정 생태계(npm)만 가정하지 않고, 프로젝트 루트의 증거를 기반으로 검증 커맨드를 추천/실행합니다.
+
+- Node: `package.json scripts` 기반(`npm|pnpm|yarn|bun` 자동 감지)
+- Go: `go build ./...`, `go test ./...`
+- Rust: `cargo check`, `cargo test`
+- Python: `pytest` 또는 `python -m unittest` (+ optional ruff/mypy)
+- .NET: `dotnet build`, `dotnet test`
+
+---
+
+## 실행
+
+```txt
+weave command=verify
+```
+
+프로젝트 타입 힌트를 주고 싶으면:
+
+```txt
+weave command=verify projectType="go"
+```
+
+빠르게(typecheck+tests만) 돌리려면:
+
+```txt
+weave command=verify verifyMode="quick"
+```
+
+---
+
+## 결과
+
+- PASS면 `✅ Verification passed.`
+- FAIL이면 실패한 레이어와 로그(tail)를 출력합니다

.opencode/commands/weave-worktree.md

@@ -0,0 +1,69 @@
+---
+description: git worktree 기반 병렬 작업(기능/Phase) 관리
+---
+
+# /weave-worktree - 병렬 작업용 worktree
+
+## 개요
+
+`git worktree`를 이용해 **작업 디렉토리를 분리**하고, 여러 기능/Phase를 병렬로 진행할 수 있게 합니다.
+
+- 각 worktree는 서로 다른 브랜치 + 파일 시스템 분리
+- 충돌/오염을 줄이고, 동시에 여러 기능을 안전하게 개발할 수 있습니다
+
+Weave는 worktree 생성 시 `.opencode/weave` 아티팩트를 자동 bootstrap(복사/생성)하여,
+"weave init은 프로젝트당 1회" 원칙을 유지합니다.
+
+---
+
+## 사용법
+
+### 1) worktree 생성
+
+```txt
+weave command=worktree worktreeAction=create name="feature-login"
+```
+
+### 2) 목록 보기
+
+```txt
+weave command=worktree worktreeAction=list
+```
+
+### 3) 경로 확인(열기)
+
+```txt
+weave command=worktree worktreeAction=open name="feature-login"
+```
+
+해당 폴더로 이동한 뒤, 평소처럼 진행하면 됩니다:
+
+```txt
+/weave-prepare docs/
+weave craft P1
+```
+
+### 4) 병합 가이드
+
+```txt
+weave command=worktree worktreeAction=merge name="feature-login"
+```
+
+### 5) worktree 제거
+
+```txt
+weave command=worktree worktreeAction=remove name="feature-login"
+```
+
+브랜치까지 삭제하려면:
+
+```txt
+weave command=worktree worktreeAction=remove name="feature-login" deleteBranch=true
+```
+
+---
+
+## 주의(권장 정책)
+
+- 같은 파일/설정(package-lock, tsconfig 등)을 동시에 바꾸는 작업은 병렬 worktree라도 merge conflict 가능성이 큽니다
+- DB 마이그레이션/스키마 변경은 원칙적으로 순차 진행을 권장합니다