docs: add VitePress documentation site

- Add docs directory with VitePress configuration - Add GitHub Actions workflow for docs build and deploy - Support bilingual (English/Chinese) documentation - Include search, custom theme, and responsive design
2026-03-01 15:03:57 +08:00 · 2026-02-28 16:14:09 +08:00
parent ab65caec45
commit c3ddf7e322
136 changed files with 34486 additions and 0 deletions
--- a/docs/skills/claude-collaboration.md
+++ b/docs/skills/claude-collaboration.md
@@ -0,0 +1,332 @@
+# Claude Skills - Team Collaboration
+
+## One-Liner
+
+**Team Collaboration Skills is a multi-role collaborative work orchestration system** — Through coordinator, worker roles, and message bus, it enables parallel processing and state synchronization for complex tasks.
+
+## Pain Points Solved
+
+| Pain Point | Current State | Claude_dms3 Solution |
+|------------|---------------|----------------------|
+| **Single model limitation** | Can only call one AI model | Multi-role parallel collaboration, leveraging各自专长 |
+| **Chaotic task orchestration** | Manual task dependency and state management | Automatic task discovery, dependency resolution, pipeline orchestration |
+| **Fragmented collaboration** | Team members work independently | Unified message bus, shared state, progress sync |
+| **Resource waste** | Repeated context loading | Wisdom accumulation, exploration cache, artifact reuse |
+
+## Skills List
+
+| Skill | Function | Trigger |
+|-------|----------|---------|
+| `team-coordinate` | Universal team coordinator (dynamic role generation) | `/team-coordinate` |
+| `team-lifecycle-v5` | Full lifecycle team (spec→impl→test→review) | `/team-lifecycle` |
+| `team-planex` | Plan-execute pipeline (plan while executing) | `/team-planex` |
+| `team-review` | Code review team (scan→review→fix) | `/team-review` |
+| `team-testing` | Testing team (strategy→generate→execute→analyze) | `/team-testing` |
+
+## Skills Details
+
+### team-coordinate
+
+**One-Liner**: Universal team coordinator — Dynamically generates roles and orchestrates execution based on task analysis
+
+**Trigger**:
+```
+/team-coordinate <task-description>
+/team-coordinate --role=coordinator <task>
+/team-coordinate --role=<worker> --session=<path>
+```
+
+**Features**:
+- Only coordinator is built-in, all worker roles are dynamically generated at runtime
+- Supports inner-loop roles (handle multiple same-prefix tasks)
+- Fast-Advance mechanism skips coordinator to directly spawn successor tasks
+- Wisdom accumulates cross-task knowledge
+
+**Role Registry**:
+| Role | File | Task Prefix | Type |
+|------|------|-------------|------|
+| coordinator | roles/coordinator/role.md | (none) | orchestrator |
+| (dynamic) | `<session>/roles/<role>.md` | (dynamic) | worker |
+
+**Pipeline**:
+```
+Task Analysis → Generate Roles → Initialize Session → Create Task Chain → Spawn First Batch Workers → Loop Progress → Completion Report
+```
+
+**Session Directory**:
+```
+.workflow/.team/TC-<slug>-<date>/
+├── team-session.json           # Session state + dynamic role registry
+├── task-analysis.json          # Phase 1 output
+├── roles/                      # Dynamic role definitions
+├── artifacts/                  # All MD deliverables
+├── wisdom/                     # Cross-task knowledge
+├── explorations/               # Shared exploration cache
+├── discussions/                # Inline discussion records
+└── .msg/                       # Team message bus logs
+```
+
+---
+
+### team-lifecycle-v5
+
+**One-Liner**: Full lifecycle team — Complete pipeline from specification to implementation to testing to review
+
+**Trigger**:
+```
+/team-lifecycle <task-description>
+```
+
+**Features**:
+- Based on team-worker agent architecture, all workers share the same agent definition
+- Role-specific Phase 2-4 loaded from markdown specs
+- Supports specification pipeline, implementation pipeline, frontend pipeline
+
+**Role Registry**:
+| Role | Spec | Task Prefix | Inner Loop |
+|------|------|-------------|------------|
+| coordinator | roles/coordinator/role.md | (none) | - |
+| analyst | role-specs/analyst.md | RESEARCH-* | false |
+| writer | role-specs/writer.md | DRAFT-* | true |
+| planner | role-specs/planner.md | PLAN-* | true |
+| executor | role-specs/executor.md | IMPL-* | true |
+| tester | role-specs/tester.md | TEST-* | false |
+| reviewer | role-specs/reviewer.md | REVIEW-* | false |
+| architect | role-specs/architect.md | ARCH-* | false |
+| fe-developer | role-specs/fe-developer.md | DEV-FE-* | false |
+| fe-qa | role-specs/fe-qa.md | QA-FE-* | false |
+
+**Pipeline Definitions**:
+```
+Specification Pipeline (6 tasks):
+  RESEARCH-001 → DRAFT-001 → DRAFT-002 → DRAFT-003 → DRAFT-004 → QUALITY-001
+
+Implementation Pipeline (4 tasks):
+  PLAN-001 → IMPL-001 → TEST-001 + REVIEW-001
+
+Full Lifecycle (10 tasks):
+  [Spec Pipeline] → PLAN-001 → IMPL-001 → TEST-001 + REVIEW-001
+
+Frontend Pipeline:
+  PLAN-001 → DEV-FE-001 → QA-FE-001 (GC loop, max 2 rounds)
+```
+
+**Quality Gate** (after QUALITY-001 completion):
+```
+═════════════════════════════════════════
+SPEC PHASE COMPLETE
+Quality Gate: <PASS|REVIEW|FAIL> (<score>%)
+
+Dimension Scores:
+  Completeness:  <bar> <n>%
+  Consistency:   <bar> <n>%
+  Traceability:  <bar> <n>%
+  Depth:         <bar> <n>%
+  Coverage:      <bar> <n>%
+
+Available Actions:
+  resume              -> Proceed to implementation
+  improve             -> Auto-improve weakest dimension
+  improve <dimension> -> Improve specific dimension
+  revise <TASK-ID>    -> Revise specific document
+  recheck             -> Re-run quality check
+  feedback <text>     -> Inject feedback, create revision
+═════════════════════════════════════════
+```
+
+**User Commands** (wake paused coordinator):
+| Command | Action |
+|---------|--------|
+| `check` / `status` | Output execution status graph, no progress |
+| `resume` / `continue` | Check worker status, advance next step |
+| `revise <TASK-ID> [feedback]` | Create revision task + cascade downstream |
+| `feedback <text>` | Analyze feedback impact, create targeted revision chain |
+| `recheck` | Re-run QUALITY-001 quality check |
+| `improve [dimension]` | Auto-improve weakest dimension in readiness-report |
+
+---
+
+### team-planex
+
+**One-Liner**: Plan-and-execute team — Planner and executor work in parallel through per-issue beat pipeline
+
+**Trigger**:
+```
+/team-planex <task-description>
+/team-planex --role=planner <input>
+/team-planex --role=executor --input <solution-file>
+```
+
+**Features**:
+- 2-member team (planner + executor), planner serves as lead role
+- Per-issue beat: planner creates EXEC-* task immediately after completing each issue's solution
+- Solution written to intermediate artifact file, executor loads from file
+- Supports multiple execution backends (agent/codex/gemini)
+
+**Role Registry**:
+| Role | File | Task Prefix | Type |
+|------|------|-------------|------|
+| planner | roles/planner.md | PLAN-* | pipeline (lead) |
+| executor | roles/executor.md | EXEC-* | pipeline |
+
+**Input Types**:
+| Input Type | Format | Example |
+|------------|--------|---------|
+| Issue IDs | Direct ID input | `--role=planner ISS-20260215-001 ISS-20260215-002` |
+| Requirement text | `--text '...'` | `--role=planner --text 'Implement user authentication module'` |
+| Plan file | `--plan path` | `--role=planner --plan plan/2026-02-15-auth.md` |
+
+**Wave Pipeline** (per-issue beat):
+```
+Issue 1:  planner plans solution → write artifact → conflict check → create EXEC-* → issue_ready
+                ↓ (executor starts immediately)
+Issue 2:  planner plans solution → write artifact → conflict check → create EXEC-* → issue_ready
+                ↓ (executor consumes in parallel)
+Issue N:  ...
+Final:    planner sends all_planned → executor completes remaining EXEC-* → finish
+```
+
+**Execution Method Selection**:
+| Executor | Backend | Use Case |
+|----------|---------|----------|
+| `agent` | code-developer subagent | Simple tasks, synchronous execution |
+| `codex` | `ccw cli --tool codex --mode write` | Complex tasks, background execution |
+| `gemini` | `ccw cli --tool gemini --mode write` | Analysis tasks, background execution |
+
+**User Commands**:
+| Command | Action |
+|---------|--------|
+| `check` / `status` | Output execution status graph, no progress |
+| `resume` / `continue` | Check worker status, advance next step |
+| `add <issue-ids or --text '...' or --plan path>` | Append new tasks to planner queue |
+
+---
+
+### team-review
+
+**One-Liner**: Code review team — Unified code scanning, vulnerability review, optimization suggestions, and auto-fix
+
+**Trigger**:
+```
+/team-review <target-path>
+/team-review --full <target-path>      # scan + review + fix
+/team-review --fix <review-files>      # fix only
+/team-review -q <target-path>          # quick scan only
+```
+
+**Features**:
+- 4-role team (coordinator, scanner, reviewer, fixer)
+- Multi-dimensional review: security, correctness, performance, maintainability
+- Auto-fix loop (review → fix → verify)
+
+**Role Registry**:
+| Role | File | Task Prefix | Type |
+|------|------|-------------|------|
+| coordinator | roles/coordinator/role.md | RC-* | orchestrator |
+| scanner | roles/scanner/role.md | SCAN-* | read-only analysis |
+| reviewer | roles/reviewer/role.md | REV-* | read-only analysis |
+| fixer | roles/fixer/role.md | FIX-* | code generation |
+
+**Pipeline** (CP-1 Linear):
+```
+coordinator dispatch
+  → SCAN-* (scanner: toolchain + LLM scan)
+  → REV-*  (reviewer: deep analysis + report)
+  → [User confirmation]
+  → FIX-*  (fixer: plan + execute + verify)
+```
+
+**Checkpoints**:
+| Trigger | Location | Behavior |
+|---------|----------|----------|
+| Review→Fix transition | REV-* complete | Pause, show review report, wait for user `resume` to confirm fix |
+| Quick mode (`-q`) | After SCAN-* | Pipeline ends after scan, no review/fix |
+| Fix-only mode (`--fix`) | Entry | Skip scan/review, go directly to fixer |
+
+**Review Dimensions**:
+| Dimension | Check Points |
+|-----------|--------------|
+| Security (sec) | Injection vulnerabilities, sensitive data leakage, permission control |
+| Correctness (cor) | Boundary conditions, error handling, type safety |
+| Performance (perf) | Algorithm complexity, I/O optimization, resource usage |
+| Maintainability (maint) | Code structure, naming conventions, comment quality |
+
+---
+
+### team-testing
+
+**One-Liner**: Testing team — Progressive test coverage through Generator-Critic loop
+
+**Trigger**:
+```
+/team-testing <task-description>
+```
+
+**Features**:
+- 5-role team (coordinator, strategist, generator, executor, analyst)
+- Three pipelines: Targeted, Standard, Comprehensive
+- Generator-Critic loop automatically improves test coverage
+
+**Role Registry**:
+| Role | File | Task Prefix | Type |
+|------|------|-------------|------|
+| coordinator | roles/coordinator.md | (none) | orchestrator |
+| strategist | roles/strategist.md | STRATEGY-* | pipeline |
+| generator | roles/generator.md | TESTGEN-* | pipeline |
+| executor | roles/executor.md | TESTRUN-* | pipeline |
+| analyst | roles/analyst.md | TESTANA-* | pipeline |
+
+**Three Pipelines**:
+```
+Targeted (small scope changes):
+  STRATEGY-001 → TESTGEN-001(L1 unit) → TESTRUN-001
+
+Standard (progressive):
+  STRATEGY-001 → TESTGEN-001(L1) → TESTRUN-001(L1) → TESTGEN-002(L2) → TESTRUN-002(L2) → TESTANA-001
+
+Comprehensive (full coverage):
+  STRATEGY-001 → [TESTGEN-001(L1) + TESTGEN-002(L2)](parallel) → [TESTRUN-001(L1) + TESTRUN-002(L2)](parallel) → TESTGEN-003(L3) → TESTRUN-003(L3) → TESTANA-001
+```
+
+**Generator-Critic Loop**:
+```
+TESTGEN → TESTRUN → (if coverage < target) → TESTGEN-fix → TESTRUN-2
+                   (if coverage >= target) → next layer or TESTANA
+```
+
+**Test Layer Definitions**:
+| Layer | Coverage Target | Example |
+|-------|-----------------|---------|
+| L1: Unit | 80% | Unit tests, function-level tests |
+| L2: Integration | 60% | Integration tests, module interaction |
+| L3: E2E | 40% | End-to-end tests, user scenarios |
+
+**Shared Memory** (shared-memory.json):
+| Role | Field |
+|------|-------|
+| strategist | `test_strategy` |
+| generator | `generated_tests` |
+| executor | `execution_results`, `defect_patterns` |
+| analyst | `analysis_report`, `coverage_history` |
+
+## Related Commands
+
+- [Claude Commands - Workflow](../commands/claude/workflow.md)
+- [Claude Commands - Session](../commands/claude/session.md)
+
+## Best Practices
+
+1. **Choose the right team type**:
+   - General tasks → `team-coordinate`
+   - Full feature development → `team-lifecycle`
+   - Issue batch processing → `team-planex`
+   - Code review → `team-review`
+   - Test coverage → `team-testing`
+
+2. **Leverage inner-loop roles**: For roles with multiple same-prefix serial tasks, set `inner_loop: true` to let a single worker handle all tasks, avoiding repeated spawn overhead
+
+3. **Wisdom accumulation**: All roles in team sessions accumulate knowledge to `wisdom/` directory, subsequent tasks can reuse these patterns, decisions, and conventions
+
+4. **Fast-Advance**: Simple linear successor tasks automatically skip coordinator to spawn directly, reducing coordination overhead
+
+5. **Checkpoint recovery**: All team skills support session recovery, continue interrupted sessions via `--resume` or user command `resume`
--- a/docs/skills/claude-index.md
+++ b/docs/skills/claude-index.md
@@ -0,0 +1,267 @@
+# Claude Skills Overview
+
+## One-Liner
+
+**Claude Skills is an AI skill system for VS Code extension** — Through five categories (team collaboration, workflow, memory management, code review, and meta-skills), it enables complete development flow automation from specification to implementation to testing to review.
+
+## vs Traditional Methods Comparison
+
+| Dimension | Traditional Methods | **Claude_dms3** |
+|-----------|---------------------|-----------------|
+| Task orchestration | Manual management | Automatic pipeline orchestration |
+| AI models | Single model | Multi-model parallel collaboration |
+| Code review | Manual review | 6-dimension automatic review |
+| Knowledge management | Lost per session | Cross-session persistence |
+| Development workflow | Human-driven | AI-driven automation |
+
+## Skills Categories
+
+| Category | Document | Description |
+|----------|----------|-------------|
+| **Team Collaboration** | [collaboration.md](./claude-collaboration.md) | Multi-role collaborative work orchestration system |
+| **Workflow** | [workflow.md](./claude-workflow.md) | Task orchestration and execution pipeline |
+| **Memory Management** | [memory.md](./claude-memory.md) | Cross-session knowledge persistence |
+| **Code Review** | [review.md](./claude-review.md) | Multi-dimensional code quality analysis |
+| **Meta-Skills** | [meta.md](./claude-meta.md) | Create and manage other skills |
+
+## Core Concepts Overview
+
+| Concept | Description | Location/Command |
+|---------|-------------|------------------|
+| **team-coordinate** | Universal team coordinator (dynamic roles) | `/team-coordinate` |
+| **team-lifecycle** | Full lifecycle team | `/team-lifecycle` |
+| **team-planex** | Plan-and-execute team | `/team-planex` |
+| **workflow-plan** | Unified planning skill | `/workflow:plan` |
+| **workflow-execute** | Agent-coordinated execution | `/workflow:execute` |
+| **memory-capture** | Memory capture | `/memory-capture` |
+| **review-code** | Multi-dimensional code review | `/review-code` |
+| **brainstorm** | Brainstorming | `/brainstorm` |
+| **spec-generator** | Specification generator | `/spec-generator` |
+| **ccw-help** | Command help system | `/ccw-help` |
+
+## Team Collaboration Skills
+
+### Team Architecture Models
+
+Claude_dms3 supports two team architecture models:
+
+1. **team-coordinate** (Universal Coordinator)
+   - Only coordinator is built-in
+   - All worker roles are dynamically generated at runtime
+   - Supports dynamic teams for any task type
+
+2. **team-lifecycle-v5** (Full Lifecycle Team)
+   - Based on team-worker agent architecture
+   - All workers share the same agent definition
+   - Role-specific Phase 2-4 loaded from markdown specs
+
+### Team Types Comparison
+
+| Team Type | Roles | Use Case |
+|-----------|-------|----------|
+| **team-coordinate** | coordinator + dynamic roles | General task orchestration |
+| **team-lifecycle** | 9 predefined roles | Spec→Impl→Test→Review |
+| **team-planex** | planner + executor | Plan-and-execute in parallel |
+| **team-review** | coordinator + scanner + reviewer + fixer | Code review and fix |
+| **team-testing** | coordinator + strategist + generator + executor + analyst | Test coverage |
+
+## Workflow Skills
+
+### Workflow Levels
+
+| Level | Name | Workflow | Use Case |
+|-------|------|----------|----------|
+| Level 1 | Lite-Lite-Lite | lite-plan | Super simple quick tasks |
+| Level 2 | Rapid | plan → execute | Bug fixes, simple features |
+| Level 2.5 | Rapid-to-Issue | plan → issue:new | From rapid planning to Issue |
+| Level 3 | Coupled | plan → execute | Complex features (plan+execute+review+test) |
+| Level 4 | Full | brainstorm → plan → execute | Exploratory tasks |
+| With-File | Documented exploration | analyze/brainstorm/debug-with-file | Multi-CLI collaborative analysis |
+
+### Workflow Selection Guide
+
+```
+Task Complexity
+    ↓
+┌───┴────┬────────────┬─────────────┐
+│        │            │             │
+Simple   Medium      Complex      Exploratory
+│        │            │             │
+↓        ↓            ↓             ↓
+lite-plan  plan        plan         brainstorm
+          ↓            ↓             ↓
+       execute    brainstorm     plan
+                     ↓             ↓
+                  plan         execute
+                     ↓
+                  execute
+```
+
+## Memory Management Skills
+
+### Memory Types
+
+| Type | Format | Use Case |
+|------|--------|----------|
+| **Session compression** | Structured text | Full context save after long conversations |
+| **Quick notes** | Notes with tags | Quick capture of ideas and insights |
+
+### Memory Storage
+
+```
+memory/
+├── MEMORY.md           # Main memory file (line limit)
+├── debugging.md        # Debugging patterns and insights
+├── patterns.md         # Code patterns and conventions
+├── conventions.md      # Project conventions
+└── [topic].md         # Other topic files
+```
+
+## Code Review Skills
+
+### Review Dimensions
+
+| Dimension | Check Points | Tool |
+|-----------|--------------|------|
+| **Correctness** | Logic correctness, boundary conditions | review-code |
+| **Readability** | Naming, function length, comments | review-code |
+| **Performance** | Algorithm complexity, I/O optimization | review-code |
+| **Security** | Injection, sensitive data | review-code |
+| **Testing** | Test coverage adequacy | review-code |
+| **Architecture** | Design patterns, layering | review-code |
+
+### Issue Severity Levels
+
+| Level | Prefix | Description | Required Action |
+|-------|--------|-------------|-----------------|
+| Critical | [C] | Blocking issue | Must fix before merge |
+| High | [H] | Important issue | Should fix |
+| Medium | [M] | Suggested improvement | Consider fixing |
+| Low | [L] | Optional optimization | Nice to have |
+| Info | [I] | Informational suggestion | Reference only |
+
+## Meta-Skills
+
+### Meta-Skills List
+
+| Skill | Function | Use Case |
+|-------|----------|----------|
+| **spec-generator** | 6-stage spec generation | Product brief, PRD, Architecture, Epics |
+| **brainstorm** | Multi-role parallel analysis | Multi-perspective brainstorming |
+| **skill-generator** | Skill creation | Generate new Claude Skills |
+| **skill-tuning** | Skill optimization | Diagnose and optimize |
+| **ccw-help** | Command help | Search, recommend, document |
+| **command-generator** | Command generation | Generate Claude commands |
+| **issue-manage** | Issue management | Issue creation and status management |
+
+## Quick Start
+
+### 1. Choose Team Type
+
+```bash
+# General tasks
+/team-coordinate "Build user authentication system"
+
+# Full feature development
+/team-lifecycle "Create REST API for user management"
+
+# Issue batch processing
+/team-planex ISS-20260215-001 ISS-20260215-002
+
+# Code review
+/team-review src/auth/**
+```
+
+### 2. Choose Workflow
+
+```bash
+# Quick task
+/workflow:lite-plan "Fix login bug"
+
+# Full development
+/workflow:plan "Add user notifications"
+/workflow:execute
+
+# TDD development
+/workflow:tdd "Implement payment processing"
+```
+
+### 3. Use Memory Management
+
+```bash
+# Compress session
+/memory-capture compact
+
+# Quick note
+/memory-capture tip "Use Redis for rate limiting" --tag config
+```
+
+### 4. Code Review
+
+```bash
+# Full review (6 dimensions)
+/review-code src/auth/**
+
+# Review specific dimensions
+/review-code --dimensions=sec,perf src/api/
+```
+
+### 5. Meta-Skills
+
+```bash
+# Generate specification
+/spec-generator "Build real-time collaboration platform"
+
+# Brainstorm
+/brainstorm "Design payment system" --count 3
+
+# Get help
+/ccw "Add JWT authentication"
+```
+
+## Best Practices
+
+1. **Team Selection**:
+   - General tasks → `team-coordinate`
+   - Full features → `team-lifecycle`
+   - Issue batching → `team-planex`
+   - Code review → `team-review`
+   - Test coverage → `team-testing`
+
+2. **Workflow Selection**:
+   - Super simple → `workflow-lite-plan`
+   - Complex features → `workflow-plan` → `workflow-execute`
+   - TDD → `workflow-tdd`
+   - Test fixes → `workflow-test-fix`
+
+3. **Memory Management**:
+   - Use `memory-capture compact` after long conversations
+   - Use `memory-capture tip` for quick idea capture
+   - Regularly use `memory-manage full` to merge and compress
+
+4. **Code Review**:
+   - Read specification documents completely before reviewing
+   - Use `--dimensions` to specify focus areas
+   - Quick scan first to identify high-risk areas, then deep review
+
+5. **Meta-Skills**:
+   - Use `spec-generator` for complete spec packages
+   - Use `brainstorm` for multi-perspective analysis
+   - Use `ccw-help` to find appropriate commands
+
+## Related Documentation
+
+- [Claude Commands](../commands/claude/)
+- [Codex Skills](./codex-index.md)
+- [Features](../features/)
+
+## Statistics
+
+| Category | Count |
+|----------|-------|
+| Team Collaboration Skills | 5 |
+| Workflow Skills | 8 |
+| Memory Management Skills | 2 |
+| Code Review Skills | 2 |
+| Meta-Skills | 7 |
+| **Total** | **24+** |
--- a/docs/skills/claude-memory.md
+++ b/docs/skills/claude-memory.md
@@ -0,0 +1,181 @@
+# Claude Skills - Memory Management
+
+## One-Liner
+
+**Memory Management Skills is a cross-session knowledge persistence system** — Through Memory compression, Tips recording, and Memory updates, AI remembers project context across sessions.
+
+## Pain Points Solved
+
+| Pain Point | Current State | Claude_dms3 Solution |
+|------------|---------------|----------------------|
+| **New session amnesia** | Every conversation needs to re-explain project background | Memory persists context |
+| **Knowledge loss** | Valuable insights and decisions disappear with session | Memory compression and Tips recording |
+| **Context window limits** | Context exceeds window after long conversations | Memory extraction and merging |
+| **Difficult knowledge retrieval** | Hard to find historical records | Memory search and embedding |
+
+## Skills List
+
+| Skill | Function | Trigger |
+|-------|----------|---------|
+| `memory-capture` | Unified memory capture (session compression/quick notes) | `/memory-capture` |
+| `memory-manage` | Memory update (full/related/single) | `/memory-manage` |
+
+## Skills Details
+
+### memory-capture
+
+**One-Liner**: Unified memory capture — Dual-mode routing for session compression or quick notes
+
+**Trigger**:
+```
+/memory-capture                              # Interactive mode selection
+/memory-capture compact                      # Session compression mode
+/memory-capture tip "Note content"           # Quick note mode
+/memory-capture "Use Redis" --tag config     # Note with tags
+```
+
+**Features**:
+- Dual-mode routing: Auto-detects user intent, routes to compression mode or notes mode
+- **Compact mode**: Compresses complete session memory to structured text for session recovery
+- **Tips mode**: Quickly records ideas, snippets, insights
+
+**Architecture Overview**:
+```
+┌─────────────────────────────────────────────┐
+│  Memory Capture (Router)                    │
+│  → Parse input → Detect mode → Route to phase│
+└───────────────┬─────────────────────────────┘
+                │
+        ┌───────┴───────┐
+        ↓               ↓
+  ┌───────────┐   ┌───────────┐
+  │  Compact  │   │   Tips    │
+  │  (Phase1) │   │  (Phase2) │
+  │  Full     │   │  Quick    │
+  │  Session  │   │  Note     │
+  └─────┬─────┘   └─────┬─────┘
+        │               │
+        └───────┬───────┘
+                ↓
+        ┌───────────────┐
+        │  core_memory  │
+        │   (import)    │
+        └───────────────┘
+```
+
+**Auto Routing Rules** (priority order):
+| Signal | Route | Example |
+|--------|-------|---------|
+| Keywords: compact, session, 压缩, recovery | → Compact | "Compress current session" |
+| Keywords: tip, note, 记录, 快速 | → Tips | "Record an idea" |
+| Has `--tag` or `--context` flag | → Tips | `"note content" --tag bug` |
+| Short text (<100 chars) + no session keywords | → Tips | "Remember to use Redis" |
+| Ambiguous or no parameters | → **AskUserQuestion** | `/memory-capture` |
+
+**Compact Mode**:
+- Use case: Compress current complete session memory (for session recovery)
+- Input: Optional `"session description"` as supplementary context
+- Output: Structured text + Recovery ID
+- Example: `/memory-capture compact` or `/memory-capture "Completed authentication module"`
+
+**Tips Mode**:
+- Use case: Quickly record a note/idea/tip
+- Input:
+  - Required: `<note content>` - Note text
+  - Optional: `--tag <tag1,tag2>` categories
+  - Optional: `--context <context>` associated code/feature reference
+- Output: Confirmation + ID + tags
+- Example: `/memory-capture tip "Use Redis for rate limiting" --tag config`
+
+**Core Rules**:
+1. **Single-phase execution**: Each call executes only one phase — never both
+2. **Content fidelity**: Phase files contain complete execution details — follow exactly
+3. **Absolute paths**: All file paths in output must be absolute paths
+4. **No summarization**: Compact mode preserves complete plan — never abbreviate
+5. **Speed priority**: Tips mode should be fast — minimal analysis overhead
+
+---
+
+### memory-manage
+
+**One-Liner**: Memory update — Full/related/single update modes
+
+**Trigger**:
+```
+/memory-manage                               # Interactive mode
+/memory-manage full                          # Full update
+/memory-manage related <query>               # Related update
+/memory-manage single <id> <content>         # Single update
+```
+
+**Features**:
+- Three update modes: Full update, related update, single update
+- Memory search and embedding
+- Memory merge and compression
+
+**Update Modes**:
+| Mode | Trigger | Description |
+|------|---------|-------------|
+| **full** | `full` or `-f` | Regenerate all Memory |
+| **related** | `related <query>` or `-r <query>` | Update Memory related to query |
+| **single** | `single <id> <content>` or `-s <id> <content>` | Update single Memory entry |
+
+**Memory Storage**:
+- Location: `C:\Users\dyw\.claude\projects\D--ccw-doc2\memory\`
+- File: MEMORY.md (main memory file, truncated after 200 lines)
+- Topic files: Independent memory files organized by topic
+
+**Memory Types**:
+| Type | Format | Description |
+|------|--------|-------------|
+| `CMEM-YYYYMMDD-HHMMSS` | Timestamp format | Timestamped persistent memory |
+| Topic files | `debugging.md`, `patterns.md` | Memory organized by topic |
+
+**Core Rules**:
+1. **Prefer update**: Update existing memory rather than writing duplicate content
+2. **Topic organization**: Create independent memory files categorized by topic
+3. **Delete outdated**: Delete memory entries that are proven wrong or outdated
+4. **Session-specific**: Don't save session-specific context (current task, in-progress work, temporary state)
+
+## Related Commands
+
+- [Memory Feature Documentation](../features/memory.md)
+- [CCW CLI Tools](../features/cli.md)
+
+## Best Practices
+
+1. **Session compression**: Use `memory-capture compact` after long conversations to save complete context
+2. **Quick notes**: Use `memory-capture tip` to quickly record ideas and insights
+3. **Tag categorization**: Use `--tag` to add tags to notes for later retrieval
+4. **Memory search**: Use `memory-manage related <query>` to find related memories
+5. **Regular merging**: Regularly use `memory-manage full` to merge and compress memories
+
+## Memory File Structure
+
+```
+memory/
+├── MEMORY.md                 # Main memory file (line limit)
+├── debugging.md              # Debugging patterns and insights
+├── patterns.md               # Code patterns and conventions
+├── conventions.md            # Project conventions
+└── [topic].md               # Other topic files
+```
+
+## Usage Examples
+
+```bash
+# Compress current session
+/memory-capture compact
+
+# Quickly record an idea
+/memory-capture tip "Use Redis for rate limiting" --tag config
+
+# Record note with context
+/memory-capture "Authentication module uses JWT" --context "src/auth/"
+
+# Update related memories
+/memory-manage related "authentication"
+
+# Full memory update
+/memory-manage full
+```
--- a/docs/skills/claude-meta.md
+++ b/docs/skills/claude-meta.md
@@ -0,0 +1,439 @@
+# Claude Skills - Meta-Skills
+
+## One-Liner
+
+**Meta-Skills is a tool system for creating and managing other skills** — Through specification generation, skill generation, command generation, and help system, it enables sustainable development of the skill ecosystem.
+
+## Pain Points Solved
+
+| Pain Point | Current State | Claude_dms3 Solution |
+|------------|---------------|----------------------|
+| **Complex skill creation** | Manual skill structure and file creation | Automated skill generation |
+| **Missing specifications** | Project specs scattered everywhere | Unified specification generation system |
+| **Difficult command discovery** | Hard to find appropriate commands | Intelligent command recommendation and search |
+| **Tedious skill tuning** | Skill optimization lacks guidance | Automated diagnosis and tuning |
+
+## Skills List
+
+| Skill | Function | Trigger |
+|-------|----------|---------|
+| `spec-generator` | Specification generator (6-stage document chain) | `/spec-generator <idea>` |
+| `brainstorm` | Brainstorming (multi-role parallel analysis) | `/brainstorm <topic>` |
+| `skill-generator` | Skill generator (meta-skill) | `/skill-generator` |
+| `skill-tuning` | Skill tuning diagnosis | `/skill-tuning <skill-name>` |
+| `command-generator` | Command generator | `/command-generator` |
+| `ccw-help` | CCW command help system | `/ccw-help` |
+| `issue-manage` | Issue management | `/issue-manage` |
+
+## Skills Details
+
+### spec-generator
+
+**One-Liner**: Specification generator — 6-stage document chain generates complete specification package (product brief, PRD, architecture, Epics)
+
+**Trigger**:
+```
+/spec-generator <idea>
+/spec-generator --continue        # Resume from checkpoint
+/spec-generator -y <idea>        # Auto mode
+```
+
+**Features**:
+- 6-stage document chain: Discovery → Requirements expansion → Product brief → PRD → Architecture → Epics → Readiness check
+- Multi-perspective analysis: CLI tools (Gemini/Codex/Claude) provide product, technical, user perspectives
+- Interactive defaults: Each stage provides user confirmation points; `-y` flag enables full auto mode
+- Recoverable sessions: `spec-config.json` tracks completed stages; `-c` flag resumes from checkpoint
+- Documentation only: No code generation or execution — clean handoff to existing execution workflows
+
+**Architecture Overview**:
+```
+Phase 0:   Specification Study (Read specs/ + templates/ - mandatory prerequisite)
+           |
+Phase 1:   Discovery               -> spec-config.json + discovery-context.json
+           |
+Phase 1.5: Req Expansion           -> refined-requirements.json (interactive discussion + CLI gap analysis)
+           |                           (-y auto mode: auto-expansion, skip interaction)
+Phase 2:   Product Brief            -> product-brief.md  (multi-CLI parallel analysis)
+           |
+Phase 3:   Requirements (PRD)      -> requirements/  (_index.md + REQ-*.md + NFR-*.md)
+           |
+Phase 4:   Architecture            -> architecture/  (_index.md + ADR-*.md, multi-CLI review)
+           |
+Phase 5:   Epics & Stories         -> epics/  (_index.md + EPIC-*.md)
+           |
+Phase 6:   Readiness Check         -> readiness-report.md + spec-summary.md
+           |
+           Handoff to execution workflows
+```
+
+**⚠️ Mandatory Prerequisites**:
+
+> **Do not skip**: Before executing any operations, you **must** completely read the following documents.
+
+**Specification Documents** (required):
+| Document | Purpose | Priority |
+|----------|---------|----------|
+| [specs/document-standards.md](specs/document-standards.md) | Document format, frontmatter, naming conventions | **P0 - Read before execution** |
+| [specs/quality-gates.md](specs/quality-gates.md) | Quality gate standards and scoring per stage | **P0 - Read before execution** |
+
+**Template Files** (read before generation):
+| Document | Purpose |
+|----------|---------|
+| [templates/product-brief.md](templates/product-brief.md) | Product brief document template |
+| [templates/requirements-prd.md](templates/requirements-prd.md) | PRD document template |
+| [templates/architecture-doc.md](templates/architecture-doc.md) | Architecture document template |
+| [templates/epics-template.md](templates/epics-template.md) | Epic/Story document template |
+
+**Output Structure**:
+```
+.workflow/.spec/SPEC-{slug}-{YYYY-MM-DD}/
+├── spec-config.json              # Session config + stage status
+├── discovery-context.json        # Codebase exploration results (optional)
+├── refined-requirements.json     # Phase 1.5: Post-discussion confirmed requirements
+├── product-brief.md              # Phase 2: Product brief
+├── requirements/                 # Phase 3: Detailed PRD (directory)
+│   ├── _index.md                 #   Summary, MoSCoW table, traceability, links
+│   ├── REQ-NNN-{slug}.md         #   Single functional requirement
+│   └── NFR-{type}-NNN-{slug}.md  #   Single non-functional requirement
+├── architecture/                 # Phase 4: Architecture decisions (directory)
+│   ├── _index.md                 #   Summary, components, tech stack, links
+│   └── ADR-NNN-{slug}.md         #   Single architecture decision record
+├── epics/                        # Phase 5: Epic/Story breakdown (directory)
+│   ├── _index.md                 #   Epic table, dependency graph, MVP scope
+│   └── EPIC-NNN-{slug}.md        #   Single Epic with Stories
+├── readiness-report.md           # Phase 6: Quality report
+└── spec-summary.md               # Phase 6: One-page executive summary
+```
+
+**Handoff Options** (after Phase 6 completion):
+| Option | Description |
+|--------|-------------|
+| `lite-plan` | Extract first MVP Epic description → direct text input |
+| `plan` / `req-plan` | Create WFS session + .brainstorming/ bridge file |
+| `issue:new` | Create Issue for each Epic |
+
+---
+
+### brainstorm
+
+**One-Liner**: Brainstorming — Interactive framework generation, multi-role parallel analysis, and cross-role synthesis
+
+**Trigger**:
+```
+/brainstorm <topic>
+/brainstorm --count 3 "Build platform"
+/brainstorm -y "GOAL: Build SCOPE: Users" --count 5
+/brainstorm system-architect --session WFS-xxx
+```
+
+**Features**:
+- Dual-mode routing: Interactive mode selection, supports parameter auto-detection
+- **Auto mode**: Phase 2 (artifacts) → Phase 3 (N×Role parallel) → Phase 4 (synthesis)
+- **Single Role mode**: Phase 3 (1×Role analysis)
+- Progressive phase loading: Phase files loaded on-demand via `Ref:` markers
+- Session continuity: All phases share session state via workflow-session.json
+
+**Architecture Overview**:
+```
+┌─────────────────────────────────────────────────────────────┐
+│                    /brainstorm                                │
+│         Unified Entry Point + Interactive Routing             │
+└───────────────────────┬─────────────────────────────────────┘
+                        │
+              ┌─────────┴─────────┐
+              ↓                   ↓
+    ┌─────────────────┐  ┌──────────────────┐
+    │   Auto Mode     │  │ Single Role Mode │
+    │                 │  │                  │
+    └────────┬────────┘  └────────┬─────────┘
+             │                    │
+    ┌────────┼────────┐          │
+    ↓        ↓        ↓          ↓
+ Phase 2  Phase 3  Phase 4    Phase 3
+Artifacts  N×Role  Synthesis  1×Role
+ (7 steps) Analysis  (8 steps) Analysis
+           parallel             (4 steps)
+```
+
+**Available Roles**:
+| Role ID | Title | Focus Areas |
+|---------|-------|-------------|
+| `data-architect` | Data Architect | Data models, storage strategy, data flow |
+| `product-manager` | Product Manager | Product strategy, roadmap, priorities |
+| `product-owner` | Product Owner | Backlog management, user stories, acceptance criteria |
+| `scrum-master` | Scrum Master | Process facilitation, impediment removal |
+| `subject-matter-expert` | Subject Matter Expert | Domain knowledge, business rules, compliance |
+| `system-architect` | System Architect | Technical architecture, scalability, integration |
+| `test-strategist` | Test Strategist | Test strategy, quality assurance |
+| `ui-designer` | UI Designer | Visual design, prototypes, design system |
+| `ux-expert` | UX Expert | User research, information architecture, journeys |
+
+**Output Structure**:
+```
+.workflow/active/WFS-{topic}/
+├── workflow-session.json              # Session metadata
+├── .process/
+│   └── context-package.json           # Phase 0 output (auto mode)
+└── .brainstorming/
+    ├── guidance-specification.md      # Framework (Phase 2, auto mode)
+    ├── feature-index.json             # Feature index (Phase 4, auto mode)
+    ├── synthesis-changelog.md         # Synthesis decision audit trail (Phase 4, auto mode)
+    ├── feature-specs/                 # Feature specifications (Phase 4, auto mode)
+    │   ├── F-001-{slug}.md
+    │   └── F-00N-{slug}.md
+    ├── {role}/                        # Role analysis (immutable after Phase 3)
+    │   ├── {role}-context.md          # Interactive Q&A responses
+    │   ├── analysis.md                # Main/index document
+    │   ├── analysis-cross-cutting.md  # Cross-functional
+    │   └── analysis-F-{id}-{slug}.md  # Per-feature
+    └── synthesis-specification.md     # Synthesis (Phase 4, non-feature mode)
+```
+
+**Core Rules**:
+1. **Start with mode detection**: First action is Phase 1 (parse params + detect mode)
+2. **Interactive routing**: If mode cannot be determined from params, ASK user
+3. **No pre-analysis**: Do not analyze topic before Phase 2
+4. **Parse every output**: Extract required data from each stage
+5. **Auto-continue via TodoList**: Check TodoList status to auto-execute next pending stage
+6. **Parallel execution**: Auto mode Phase 3 simultaneously appends multiple agent tasks for concurrent execution
+
+---
+
+### skill-generator
+
+**One-Liner**: Skill generator — Meta-skill for creating new Claude Code Skills
+
+**Trigger**:
+```
+/skill-generator
+/create skill
+/new skill
+```
+
+**Features**:
+- Meta-skill for creating new Claude Code Skills
+- Configurable execution modes: Sequential (fixed order) or Autonomous (stateless auto-selection)
+- Use cases: Skill scaffolding, Skill creation, building new workflows
+
+**Execution Modes**:
+| Mode | Description | Use Case |
+|------|-------------|----------|
+| **Sequential** | Traditional linear execution, stages execute in numerical prefix order | Pipeline tasks, strong dependencies, fixed outputs |
+| **Autonomous** | Intelligent routing, dynamically selects execution path | Interactive tasks, no strong dependencies, dynamic response |
+
+**Phase 0**: **Mandatory Prerequisite** — Specification study (must complete before continuing)
+
+**⚠️ Mandatory Prerequisites**:
+
+> **Do not skip**: Before executing any operations, you **must** completely read the following documents.
+
+**Core Specifications** (required):
+| Document | Purpose | Priority |
+|----------|---------|----------|
+| [../_shared/SKILL-DESIGN-SPEC.md](../_shared/SKILL-DESIGN-SPEC.md) | General design spec — Defines structure, naming, quality standards for all Skills | **P0 - Critical** |
+| [specs/reference-docs-spec.md](specs/reference-docs-spec.md) | Reference doc generation spec — Ensures generated Skills have appropriate stage-based reference docs | **P0 - Critical** |
+
+**Template Files** (read before generation):
+| Document | Purpose |
+|----------|---------|
+| [templates/skill-md.md](templates/skill-md.md) | SKILL.md entry file template |
+| [templates/sequential-phase.md](templates/sequential-phase.md) | Sequential stage template |
+| [templates/autonomous-orchestrator.md](templates/autonomous-orchestrator.md) | Autonomous orchestrator template |
+| [templates/autonomous-action.md](templates/autonomous-action.md) | Autonomous action template |
+
+**Execution Flow**:
+```
+Phase 0: Specification Study (Mandatory)
+   - Read: ../_shared/SKILL-DESIGN-SPEC.md
+   - Read: All templates/*.md files
+   - Understand: Structure rules, naming conventions, quality standards
+
+Phase 1: Requirement Discovery
+   - AskUserQuestion to collect requirements
+   - Generate: skill-config.json
+
+Phase 2: Structure Generation
+   - Bash: mkdir -p directory structure
+   - Write: SKILL.md
+
+Phase 3: Phase/Action Generation (mode dependent)
+   - Sequential → Generate phases/*.md
+   - Autonomous → Generate orchestrator + actions/*.md
+
+Phase 4: Specifications and Templates
+   - Generate: domain specs, templates
+
+Phase 5: Verification and Documentation
+   - Verify: Completeness check
+   - Generate: README.md, validation-report.json
+```
+
+**Output Structure** (Sequential):
+```
+.claude/skills/{skill-name}/
+├── SKILL.md                        # Entry file
+├── phases/
+│   ├── _orchestrator.md            # Declarative orchestrator
+│   ├── workflow.json               # Workflow definition
+│   ├── 01-{step-one}.md           # Phase 1
+│   ├── 02-{step-two}.md           # Phase 2
+│   └── 03-{step-three}.md         # Phase 3
+├── specs/
+│   ├── {skill-name}-requirements.md
+│   └── quality-standards.md
+├── templates/
+│   └── agent-base.md
+├── scripts/
+└── README.md
+```
+
+---
+
+### ccw-help
+
+**One-Liner**: CCW command help system — Command search, recommendations, documentation viewing
+
+**Trigger**:
+```
+/ccw-help
+/ccw "task description"          # Auto-select workflow and execute
+/ccw-help search <keyword>       # Search commands
+/ccw-help next <command>         # Get next step suggestions
+```
+
+**Features**:
+- Command search, recommendations, documentation viewing
+- Automatic workflow orchestration
+- Beginner onboarding guidance
+
+**Operation Modes**:
+| Mode | Trigger | Description |
+|------|---------|-------------|
+| **Command Search** | "search commands", "find command" | Query command.json, filter relevant commands |
+| **Smart Recommendations** | "next steps", "what's next" | Query flow.next_steps |
+| **Documentation** | "how to use", "how to use" | Read source files, provide context examples |
+| **Beginner Onboarding** | "beginner", "getting started" | Query essential_commands |
+| **CCW Command Orchestration** | "ccw ", "auto workflow" | Analyze intent, auto-select workflow |
+| **Issue Reporting** | "ccw-issue", "report bug" | Collect context, generate issue template |
+
+**Supported Workflows**:
+- **Level 1** (Lite-Lite-Lite): Super simple quick tasks
+- **Level 2** (Rapid/Hotfix): Bug fixes, simple features, documentation
+- **Level 2.5** (Rapid-to-Issue): Bridge from rapid planning to Issue workflow
+- **Level 3** (Coupled): Complex features (plan, execute, review, test)
+- **Level 3 Variants**: TDD, Test-fix, Review, UI design workflows
+- **Level 4** (Full): Exploratory tasks (brainstorm)
+- **With-File Workflows**: Documented exploration (multi-CLI collaboration)
+- **Issue Workflow**: Batch Issue discovery, planning, queuing, execution
+
+**Slash Commands**:
+```bash
+/ccw "task description"          # Auto-select workflow and execute
+/ccw-help                        # Help entry
+/ccw-help search <keyword>       # Search commands
+/ccw-help next <command>         # Next step suggestions
+/ccw-issue                       # Issue report
+```
+
+**CCW Command Examples**:
+```bash
+/ccw "Add user authentication"     # → auto-select level 2-3
+/ccw "Fix memory leak"             # → auto-select bugfix
+/ccw "Implement with TDD"          # → detect TDD workflow
+/ccw "brainstorm: User notification system"  # → detect brainstorm
+```
+
+**Statistics**:
+- **Commands**: 50+
+- **Agents**: 16
+- **Workflows**: 6 main levels + 3 with-file variants
+- **Essential**: 10 core commands
+
+---
+
+### skill-tuning
+
+**One-Liner**: Skill tuning diagnosis — Automated diagnosis and optimization recommendations
+
+**Trigger**:
+```
+/skill-tuning <skill-name>
+```
+
+**Features**:
+- Diagnose Skill issues
+- Provide optimization recommendations
+- Apply optimizations
+- Verify improvements
+
+**Diagnosis Flow**:
+```
+Analyze Skill → Identify issues → Generate recommendations → Apply optimizations → Verify effects
+```
+
+---
+
+### command-generator
+
+**One-Liner**: Command generator — Generate Claude commands
+
+**Trigger**:
+```
+/command-generator
+```
+
+**Features**:
+- Generate commands based on requirements
+- Follow command specifications
+- Generate command documentation
+
+---
+
+### issue-manage
+
+**One-Liner**: Issue management — Issue creation, updates, status management
+
+**Trigger**:
+```
+/issue-manage
+/issue:new
+```
+
+**Features**:
+- Issue creation
+- Issue status management
+- Issue associations and dependencies
+
+## Related Commands
+
+- [Claude Commands - CLI](../commands/claude/cli.md)
+- [CCW CLI Tools](../features/cli.md)
+
+## Best Practices
+
+1. **Specification generation**: Use `spec-generator` to generate complete specification package, then handoff to execution workflows
+2. **Brainstorming**: Use `brainstorm` for multi-role analysis to get comprehensive perspectives
+3. **Skill creation**: Use `skill-generator` to create specification-compliant Skills
+4. **Command help**: Use `ccw-help` to find commands and workflows
+5. **Continuous tuning**: Use `skill-tuning` to regularly optimize Skill performance
+
+## Usage Examples
+
+```bash
+# Generate product specification
+/spec-generator "Build real-time collaboration platform"
+
+# Brainstorm
+/brainstorm "Design payment system" --count 3
+/brainstorm system-architect --session WFS-xxx
+
+# Create new Skill
+/skill-generator
+
+# Get help
+/ccw "Add JWT authentication"
+/ccw-help search "review"
+
+# Manage Issues
+/issue-manage
+```
--- a/docs/skills/claude-review.md
+++ b/docs/skills/claude-review.md
@@ -0,0 +1,238 @@
+# Claude Skills - Code Review
+
+## One-Liner
+
+**Code Review Skills is a multi-dimensional code quality analysis system** — Through structured review dimensions and automated checks, it discovers code issues and provides fix recommendations.
+
+## Pain Points Solved
+
+| Pain Point | Current State | Claude_dms3 Solution |
+|------------|---------------|----------------------|
+| **Incomplete review dimensions** | Manual review easily misses dimensions | 6-dimension automatic review |
+| **Chaotic issue classification** | Hard to distinguish severity | Structured issue classification |
+| **Vague fix recommendations** | Lacks specific fix solutions | Actionable fix recommendations |
+| **Repeated review process** | Each review repeats same steps | Automated scanning and reporting |
+
+## Skills List
+
+| Skill | Function | Trigger |
+|-------|----------|---------|
+| `review-code` | Multi-dimensional code review (6 dimensions) | `/review-code <target>` |
+| `review-cycle` | Code review and fix loop | `/review-cycle <target>` |
+
+## Skills Details
+
+### review-code
+
+**One-Liner**: Multi-dimensional code review — Analyzes correctness, readability, performance, security, testing, architecture six dimensions
+
+**Trigger**:
+```
+/review-code <target-path>
+/review-code src/auth/**
+/review-code --dimensions=sec,perf src/**
+```
+
+**Features**:
+- 6-dimension review: Correctness, readability, performance, security, test coverage, architecture consistency
+- Layered execution: Quick scan identifies high-risk areas, deep review focuses on key issues
+- Structured reports: Classified by severity, provides file locations and fix recommendations
+- State-driven: Autonomous mode, dynamically selects next action based on review progress
+
+**Architecture Overview**:
+```
+┌─────────────────────────────────────────────────────────────────┐
+│  ⚠️ Phase 0: Specification Study (Mandatory Prerequisite)       │
+│              → Read specs/review-dimensions.md                   │
+│              → Understand review dimensions and issue standards  │
+└───────────────┬─────────────────────────────────────────────────┘
+                ↓
+┌─────────────────────────────────────────────────────────────────┐
+│           Orchestrator (State-driven decision)                   │
+│           → Read state → Select review action → Execute → Update│
+└───────────────┬─────────────────────────────────────────────────┘
+                │
+    ┌───────────┼───────────┬───────────┬───────────┐
+    ↓           ↓           ↓           ↓           ↓
+┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐
+│ Collect │ │ Quick   │ │ Deep    │ │ Report  │ │Complete │
+│ Context │ │ Scan    │ │ Review  │ │ Generate│ │         │
+└─────────┘ └─────────┘ └─────────┘ └─────────┘ └─────────┘
+     ↓           ↓           ↓           ↓
+┌─────────────────────────────────────────────────────────────────┐
+│                     Review Dimensions                            │
+│  ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐            │
+│  │Correctness│ │Readability│ │Performance│ │ Security │            │
+│  └──────────┘ └──────────┘ └──────────┘ └──────────┘            │
+│  ┌──────────┐ ┌──────────┐                                       │
+│  │ Testing  │ │Architecture│                                      │
+│  └──────────┘ └──────────┘                                       │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+**⚠️ Mandatory Prerequisites**:
+
+> **Do not skip**: Before executing any review operations, you **must** completely read the following documents.
+
+**Specification Documents** (required):
+| Document | Purpose | Priority |
+|----------|---------|----------|
+| [specs/review-dimensions.md](specs/review-dimensions.md) | Review dimension definitions and checkpoints | **P0 - Highest** |
+| [specs/issue-classification.md](specs/issue-classification.md) | Issue classification and severity standards | **P0 - Highest** |
+| [specs/quality-standards.md](specs/quality-standards.md) | Review quality standards | P1 |
+
+**Template Files** (read before generation):
+| Document | Purpose |
+|----------|---------|
+| [templates/review-report.md](templates/review-report.md) | Review report template |
+| [templates/issue-template.md](templates/issue-template.md) | Issue record template |
+
+**Execution Flow**:
+```
+Phase 0: Specification Study (Mandatory - Do not skip)
+  → Read: specs/review-dimensions.md
+  → Read: specs/issue-classification.md
+  → Understand review standards and issue classification
+
+Action: collect-context
+  → Collect target files/directories
+  → Identify tech stack and language
+  → Output: state.context
+
+Action: quick-scan
+  → Quick scan overall structure
+  → Identify high-risk areas
+  → Output: state.risk_areas, state.scan_summary
+
+Action: deep-review (per dimension)
+  → Deep review per dimension
+  → Record discovered issues
+  → Output: state.findings[]
+
+Action: generate-report
+  → Aggregate all findings
+  → Generate structured report
+  → Output: review-report.md
+
+Action: complete
+  → Save final state
+  → Output review summary
+```
+
+**Review Dimensions**:
+| Dimension | Focus Areas | Key Checks |
+|-----------|-------------|------------|
+| **Correctness** | Logic correctness | Boundary conditions, error handling, null checks |
+| **Readability** | Code readability | Naming conventions, function length, comment quality |
+| **Performance** | Performance efficiency | Algorithm complexity, I/O optimization, resource usage |
+| **Security** | Security | Injection risks, sensitive data, permission control |
+| **Testing** | Test coverage | Test adequacy, boundary coverage, maintainability |
+| **Architecture** | Architecture consistency | Design patterns, layering, dependency management |
+
+**Issue Severity Levels**:
+| Level | Prefix | Description | Required Action |
+|-------|--------|-------------|-----------------|
+| **Critical** | [C] | Blocking issue, must fix immediately | Must fix before merge |
+| **High** | [H] | Important issue, needs fix | Should fix |
+| **Medium** | [M] | Suggested improvement | Consider fixing |
+| **Low** | [L] | Optional optimization | Nice to have |
+| **Info** | [I] | Informational suggestion | Reference only |
+
+**Output Structure**:
+```
+.workflow/.scratchpad/review-code-{timestamp}/
+├── state.json                    # Review state
+├── context.json                  # Target context
+├── findings/                     # Issue findings
+│   ├── correctness.json
+│   ├── readability.json
+│   ├── performance.json
+│   ├── security.json
+│   ├── testing.json
+│   └── architecture.json
+└── review-report.md              # Final review report
+```
+
+---
+
+### review-cycle
+
+**One-Liner**: Code review and fix loop — Complete cycle of reviewing code, discovering issues, fixing and verifying
+
+**Trigger**:
+```
+/review-cycle <target-path>
+/review-cycle --full <target-path>
+```
+
+**Features**:
+- Review code to discover issues
+- Generate fix recommendations
+- Execute fixes
+- Verify fix effectiveness
+- Loop until passing
+
+**Loop Flow**:
+```
+Review Code → Find Issues → [Has issues] → Fix Code → Verify → [Still has issues] → Fix Code
+                          ↑______________|
+```
+
+**Use Cases**:
+- Self-review before PR
+- Code quality improvement
+- Refactoring verification
+- Security audit
+
+## Related Commands
+
+- [Claude Commands - Workflow](../commands/claude/workflow.md)
+- [Team Review Collaboration](./claude-collaboration.md#team-review)
+
+## Best Practices
+
+1. **Read specifications completely**: Must read specs/ documents before executing review
+2. **Multi-dimensional review**: Use `--dimensions` to specify focus areas, or use default all dimensions
+3. **Quick scan**: Use quick-scan first to identify high-risk areas, then deep review
+4. **Structured reports**: Use generated review-report.md as fix guide
+5. **Continuous improvement**: Use review-cycle to continuously improve until quality standards are met
+
+## Usage Examples
+
+```bash
+# Full review (6 dimensions)
+/review-code src/auth/**
+
+# Review only security and performance
+/review-code --dimensions=sec,perf src/api/
+
+# Review and fix loop
+/review-cycle --full src/utils/
+
+# Review specific file
+/review-code src/components/Header.tsx
+```
+
+## Issue Report Example
+
+```
+### [C] SQL Injection Risk
+
+**Location**: `src/auth/login.ts:45`
+
+**Issue**: User input directly concatenated into SQL query without sanitization.
+
+**Severity**: Critical - Must fix before merge
+
+**Recommendation**:
+```typescript
+// Before (vulnerable):
+const query = `SELECT * FROM users WHERE username='${username}'`;
+
+// After (safe):
+const query = 'SELECT * FROM users WHERE username = ?';
+await db.query(query, [username]);
+```
+
+**Reference**: [specs/review-dimensions.md](specs/review-dimensions.md) - Security section
+```
--- a/docs/skills/claude-workflow.md
+++ b/docs/skills/claude-workflow.md
@@ -0,0 +1,347 @@
+# Claude Skills - Workflow
+
+## One-Liner
+
+**Workflow Skills is a task orchestration and execution pipeline system** — Complete automation from planning to execution to verification.
+
+## Pain Points Solved
+
+| Pain Point | Current State | Claude_dms3 Solution |
+|------------|---------------|----------------------|
+| **Manual task breakdown** | Manual decomposition, easy to miss | Automated task generation and dependency management |
+| **Scattered execution state** | Tools independent, state not unified | Unified session management, TodoWrite tracking |
+| **Difficult interruption recovery** | Hard to resume after interruption | Session persistence, checkpoint recovery |
+| **Missing quality verification** | No quality check after completion | Built-in quality gates, verification reports |
+
+## Skills List
+
+| Skill | Function | Trigger |
+|-------|----------|---------|
+| `workflow-plan` | Unified planning skill (4-stage workflow) | `/workflow:plan` |
+| `workflow-execute` | Agent-coordinated execution | `/workflow:execute` |
+| `workflow-lite-plan` | Lightweight quick planning | `/workflow:lite-plan` |
+| `workflow-multi-cli-plan` | Multi-CLI collaborative planning | `/workflow:multi-cli-plan` |
+| `workflow-tdd` | TDD workflow | `/workflow:tdd` |
+| `workflow-test-fix` | Test-fix workflow | `/workflow:test-fix` |
+| `workflow-skill-designer` | Skill design workflow | `/workflow:skill-designer` |
+| `workflow-wave-plan` | Wave batch planning | `/workflow:wave-plan` |
+
+## Skills Details
+
+### workflow-plan
+
+**One-Liner**: Unified planning skill — 4-stage workflow, plan verification, interactive re-planning
+
+**Trigger**:
+```
+/workflow:plan <task-description>
+/workflow:plan-verify --session <session-id>
+/workflow:replan --session <session-id> [task-id] "requirements"
+```
+
+**Features**:
+- 4-stage workflow: Session discovery → Context collection → Conflict resolution → Task generation
+- Plan verification (Phase 5): Read-only verification + quality gates
+- Interactive re-planning (Phase 6): Boundary clarification → Impact analysis → Backup → Apply → Verify
+
+**Mode Detection**:
+```javascript
+// Skill trigger determines mode
+skillName === 'workflow:plan-verify' → 'verify'
+skillName === 'workflow:replan' → 'replan'
+default → 'plan'
+```
+
+**Core Rules**:
+1. **Pure coordinator**: SKILL.md only routes and coordinates, execution details in phase files
+2. **Progressive phase loading**: Read phase documents only when phase is about to execute
+3. **Multi-mode routing**: Single skill handles plan/verify/replan via mode detection
+4. **Task append model**: Subcommand tasks are appended, executed sequentially, then collapsed
+5. **Auto-continue**: Automatically execute next pending phase after each phase completes
+6. **Accumulated state**: planning-notes.md carries context across phases for N+1 decisions
+
+**Plan Mode Data Flow**:
+```
+User Input (task description)
+    ↓
+[Convert to structured format]
+    ↓ Structured description:
+    ↓   GOAL: [goal]
+    ↓   SCOPE: [scope]
+    ↓   CONTEXT: [context]
+    ↓
+Phase 1: session:start --auto "structured-description"
+    ↓ Output: sessionId
+    ↓ Write: planning-notes.md (user intent section)
+    ↓
+Phase 2: context-gather --session sessionId "structured-description"
+    ↓ Input: sessionId + structured description
+    ↓ Output: contextPath + conflictRisk
+    ↓ Update: planning-notes.md
+    ↓
+Phase 3: conflict-resolution [condition: conflictRisk ≥ medium]
+    ↓ Input: sessionId + contextPath + conflictRisk
+    ↓ Output: Modified brainstorm artifacts
+    ↓ Skip if conflictRisk is none/low → go directly to Phase 4
+    ↓
+Phase 4: task-generate-agent --session sessionId
+    ↓ Input: sessionId + planning-notes.md + context-package.json
+    ↓ Output: IMPL_PLAN.md, task JSONs, TODO_LIST.md
+    ↓
+Plan Confirmation (User Decision Gate):
+    ├─ "Verify plan quality" (recommended) → Phase 5
+    ├─ "Start execution" → Skill(skill="workflow-execute")
+    └─ "Review status only" → Inline show session status
+```
+
+**TodoWrite Mode**:
+- **Task append** (during phase execution): Subtasks appended to coordinator's TodoWrite
+- **Task collapse** (after subtask completion): Remove detailed subtasks, collapse to phase summary
+- **Continuous execution**: Auto-proceed to next pending phase after completion
+
+---
+
+### workflow-execute
+
+**One-Liner**: Agent-coordinated execution — Systematic task discovery, agent coordination, and state tracking
+
+**Trigger**:
+```
+/workflow:execute
+/workflow:execute --resume-session="WFS-auth"
+/workflow:execute --yes
+/workflow:execute -y --with-commit
+```
+
+**Features**:
+- Session discovery: Identify and select active workflow sessions
+- Execution strategy resolution: Extract execution model from IMPL_PLAN.md
+- TodoWrite progress tracking: Real-time progress tracking throughout workflow execution
+- Agent orchestration: Coordinate specialized agents with full context
+- Autonomous completion: Execute all tasks until workflow completes or reaches blocking state
+
+**Auto Mode Defaults** (`--yes` or `-y`):
+- **Session selection**: Auto-select first (latest) active session
+- **Completion selection**: Auto-complete session (run `/workflow:session:complete --yes`)
+
+**Execution Process**:
+```
+Phase 1: Discovery
+   ├─ Count active sessions
+   └─ Decision:
+      ├─ count=0 → Error: No active sessions
+      ├─ count=1 → Auto-select session → Phase 2
+      └─ count>1 → AskUserQuestion (max 4 options) → Phase 2
+
+Phase 2: Plan Document Verification
+   ├─ Check IMPL_PLAN.md exists
+   ├─ Check TODO_LIST.md exists
+   └─ Verify .task/ contains IMPL-*.json files
+
+Phase 3: TodoWrite Generation
+   ├─ Update session status to "active"
+   ├─ Parse TODO_LIST.md for task status
+   ├─ Generate TodoWrite for entire workflow
+   └─ Prepare session context paths
+
+Phase 4: Execution Strategy Selection & Task Execution
+   ├─ Step 4A: Parse execution strategy from IMPL_PLAN.md
+   └─ Step 4B: Lazy load execution tasks
+      └─ Loop:
+         ├─ Get next in_progress task from TodoWrite
+         ├─ Lazy load task JSON
+         ├─ Start agent with task context
+         ├─ Mark task complete
+         ├─ [with-commit] Commit changes based on summary
+         └─ Advance to next task
+
+Phase 5: Completion
+   ├─ Update task status
+   ├─ Generate summary
+   └─ AskUserQuestion: Select next action
+```
+
+**Execution Models**:
+| Model | Condition | Mode |
+|-------|-----------|------|
+| Sequential | IMPL_PLAN specifies or no clear parallelization guidance | Execute one by one |
+| Parallel | IMPL_PLAN specifies parallelization opportunities | Execute independent task groups in parallel |
+| Phased | IMPL_PLAN specifies phase breakdown | Execute by phase, respect phase boundaries |
+| Intelligent Fallback | IMPL_PLAN lacks execution strategy details | Analyze task structure, apply intelligent defaults |
+
+**Lazy Loading Strategy**:
+- **TODO_LIST.md**: Phase 3 read (task metadata, status, dependencies)
+- **IMPL_PLAN.md**: Phase 2 check existence, Phase 4A parse execution strategy
+- **Task JSONs**: Lazy load — read only when task is about to execute
+
+**Auto Commit Mode** (`--with-commit`):
+```bash
+# 1. Read summary from .summaries/{task-id}-summary.md
+# 2. Extract files from "Files Modified" section
+# 3. Commit: git add <files> && git commit -m "{type}: {title} - {summary}"
+```
+
+---
+
+### workflow-lite-plan
+
+**One-Liner**: Lightweight quick planning — Quick planning and execution for super simple tasks
+
+**Trigger**:
+```
+/workflow:lite-plan <simple-task>
+```
+
+**Features**:
+- For Level 1 (Lite-Lite-Lite) workflow
+- Minimal planning overhead for super simple quick tasks
+- Direct text input, no complex analysis
+
+**Use Cases**:
+- Small bug fixes
+- Simple documentation updates
+- Configuration adjustments
+- Single function modifications
+
+---
+
+### workflow-multi-cli-plan
+
+**One-Liner**: Multi-CLI collaborative planning — Analysis and planning with multiple CLI tools collaborating
+
+**Trigger**:
+```
+/workflow:multi-cli-plan <task>
+```
+
+**Features**:
+- Call multiple CLI tools (Gemini, Codex, Claude) for parallel analysis
+- Synthesize input from multiple perspectives
+- Generate comprehensive plan
+
+**Use Cases**:
+- Tasks requiring multi-perspective analysis
+- Complex architecture decisions
+- Cross-domain problems
+
+---
+
+### workflow-tdd
+
+**One-Liner**: TDD workflow — Test-driven development process
+
+**Trigger**:
+```
+/workflow:tdd <feature-description>
+```
+
+**Features**:
+- Write tests first
+- Implement functionality
+- Run tests to verify
+- Loop until passing
+
+**Pipeline**:
+```
+Plan Tests → Write Tests → [Fail] → Implement Feature → [Pass] → Complete
+                    ↑___________|
+```
+
+---
+
+### workflow-test-fix
+
+**One-Liner**: Test-fix workflow — Diagnosis and fixing of failing tests
+
+**Trigger**:
+```
+/workflow:test-fix <failing-tests>
+```
+
+**Features**:
+- Diagnose test failure causes
+- Fix code or tests
+- Verify fixes
+- Loop until passing
+
+**Pipeline**:
+```
+Diagnose Failure → Identify Root Cause → [Code Issue] → Fix Code → Verify
+                          ↑___________|
+```
+
+---
+
+### workflow-skill-designer
+
+**One-Liner**: Skill design workflow — Create new Claude Code Skills
+
+**Trigger**:
+```
+/workflow:skill-designer <skill-idea>
+```
+
+**Features**:
+- Requirement discovery
+- Structure generation
+- Phase/action generation
+- Specification and template generation
+- Verification and documentation
+
+**Output Structure**:
+```
+.claude/skills/{skill-name}/
+├── SKILL.md              # Entry file
+├── phases/
+│   ├── orchestrator.md   # Orchestrator
+│   └── actions/          # Action files
+├── specs/                # Specification documents
+├── templates/            # Template files
+└── README.md
+```
+
+---
+
+### workflow-wave-plan
+
+**One-Liner**: Wave batch planning — Parallel processing planning for batch issues
+
+**Trigger**:
+```
+/workflow:wave-plan <issue-list>
+```
+
+**Features**:
+- Batch issue analysis
+- Parallelization opportunity identification
+- Wave scheduling (batch by batch)
+- Execution queue generation
+
+**Wave Model**:
+```
+Wave 1: Issue 1-5 → Parallel planning → Parallel execution
+Wave 2: Issue 6-10 → Parallel planning → Parallel execution
+...
+```
+
+## Related Commands
+
+- [Claude Commands - Workflow](../commands/claude/workflow.md)
+- [Claude Skills - Team Collaboration](./claude-collaboration.md)
+
+## Best Practices
+
+1. **Choose the right workflow**:
+   - Super simple tasks → `workflow-lite-plan`
+   - Complex features → `workflow-plan` → `workflow-execute`
+   - TDD development → `workflow-tdd`
+   - Test fixes → `workflow-test-fix`
+   - Skill creation → `workflow-skill-designer`
+
+2. **Leverage auto mode**: Use `--yes` or `-y` to skip interactive confirmations, use defaults
+
+3. **Session management**: All workflows support session persistence, can resume after interruption
+
+4. **TodoWrite tracking**: Use TodoWrite to view workflow execution progress in real-time
+
+5. **Lazy Loading**: Task JSONs are lazy loaded, read only during execution, improving performance
--- a/docs/skills/codex-index.md
+++ b/docs/skills/codex-index.md
@@ -0,0 +1,489 @@
+# Codex Skills Overview
+
+## One-Liner
+
+**Codex Skills is a specialized skill system for the Codex model** — implementing multi-agent parallel development and collaborative analysis through lifecycle, workflow, and specialized skill categories.
+
+## vs Claude Skills Comparison
+
+| Dimension | Claude Skills | Codex Skills |
+|-----------|---------------|--------------|
+| **Model** | Claude model | Codex model |
+| **Architecture** | team-worker agent architecture | spawn-wait-close agent pattern |
+| **Subagents** | discuss/explore subagents (inline calls) | discuss/explore subagents (independent calls) |
+| **Coordinator** | Built-in coordinator + dynamic roles | Main process inline orchestration |
+| **State Management** | team-session.json | state file |
+| **Cache** | explorations/cache-index.json | shared discoveries.ndjson |
+
+## Skill Categories
+
+| Category | Document | Description |
+|----------|----------|-------------|
+| **Lifecycle** | [lifecycle.md](./codex-lifecycle.md) | Full lifecycle orchestration |
+| **Workflow** | [workflow.md](./codex-workflow.md) | Parallel development and collaborative workflows |
+| **Specialized** | [specialized.md](./codex-specialized.md) | Specialized skills |
+
+## Core Concepts Overview
+
+| Concept | Description | Location/Command |
+|---------|-------------|------------------|
+| **team-lifecycle** | Full lifecycle orchestrator | `/team-lifecycle` |
+| **parallel-dev-cycle** | Parallel development cycle | `/parallel-dev-cycle` |
+| **analyze-with-file** | Collaborative analysis | `/analyze-with-file` |
+| **brainstorm-with-file** | Brainstorming | `/brainstorm-with-file` |
+| **debug-with-file** | Hypothesis-driven debugging | `/debug-with-file` |
+
+## Lifecycle Skills
+
+### team-lifecycle
+
+**One-Liner**: Full lifecycle orchestrator — spawn-wait-close pipeline for spec/implementation/test
+
+**Triggers**:
+```
+/team-lifecycle <task-description>
+```
+
+**Features**:
+- 5-phase pipeline: requirements clarification → session initialization → task chain creation → pipeline coordination → completion report
+- **Inline discuss**: Production roles (analyst, writer, reviewer) inline invoke discuss subagents, reducing spec pipeline from 12 beats to 6
+- **Shared explore cache**: All agents share centralized `explorations/` directory, eliminating duplicate codebase exploration
+- **Fast-advance spawning**: Immediately spawn next linear successor after agent completion
+- **Consensus severity routing**: Discussion results routed through HIGH/MEDIUM/LOW severity levels
+
+**Agent Registry**:
+| Agent | Role | Mode |
+|-------|------|------|
+| analyst | Seed analysis, context collection, DISCUSS-001 | 2.8 Inline Subagent |
+| writer | Documentation generation, DISCUSS-002 to DISCUSS-005 | 2.8 Inline Subagent |
+| planner | Multi-angle exploration, plan generation | 2.9 Cached Exploration |
+| executor | Code implementation | 2.1 Standard |
+| tester | Test-fix loop | 2.3 Deep Interaction |
+| reviewer | Code review + spec quality, DISCUSS-006 | 2.8 Inline Subagent |
+| architect | Architecture consultation (on-demand) | 2.1 Standard |
+| fe-developer | Frontend implementation | 2.1 Standard |
+| fe-qa | Frontend QA, GC loop | 2.3 Deep Interaction |
+
+**Pipeline Definition**:
+```
+Spec-only (6 beats):
+  RESEARCH-001(+D1) → DRAFT-001(+D2) → DRAFT-002(+D3) → DRAFT-003(+D4) → DRAFT-004(+D5) → QUALITY-001(+D6)
+
+Impl-only (3 beats):
+  PLAN-001 → IMPL-001 → TEST-001 || REVIEW-001
+
+Full-lifecycle (9 beats):
+  [Spec pipeline] → PLAN-001 → IMPL-001 → TEST-001 || REVIEW-001
+```
+
+**Beat Cycle**:
+```
+event (phase advance / user resume)
+      ↓
+  [Orchestrator]
+      +-- read state file
+      +-- find ready tasks
+      +-- spawn agent(s)
+      +-- wait(agent_ids, timeout)
+      +-- process results
+      +-- update state file
+      +-- close completed agents
+      +-- fast-advance: spawn next
+      +-- yield (wait for next event)
+```
+
+**Session Directory**:
+```
+.workflow/.team/TLS-<slug>-<date>/
+├── team-session.json           # Pipeline state
+├── spec/                       # Specification artifacts
+├── discussions/                # Discussion records
+├── explorations/               # Shared exploration cache
+├── architecture/               # Architecture assessments
+├── analysis/                   # Analyst design intelligence
+├── qa/                         # QA audit reports
+└── wisdom/                     # Cross-task knowledge accumulation
+```
+
+---
+
+### parallel-dev-cycle
+
+**One-Liner**: Multi-agent parallel development cycle — requirements analysis, exploration planning, code development, validation
+
+**Triggers**:
+```
+/parallel-dev-cycle TASK="Implement feature"
+/parallel-dev-cycle --cycle-id=cycle-v1-20260122-abc123
+/parallel-dev-cycle --auto TASK="Add OAuth"
+```
+
+**Features**:
+- 4 specialized workers: RA (requirements), EP (exploration), CD (development), VAS (validation)
+- Main process inline orchestration (no separate orchestrator agent)
+- Each agent maintains one main document (complete rewrite per iteration) + auxiliary log (append)
+- Automatically archive old versions to `history/` directory
+
+**Workers**:
+| Worker | Main Document | Auxiliary Log |
+|--------|---------------|---------------|
+| RA | requirements.md | changes.log |
+| EP | exploration.md, architecture.md, plan.json | changes.log |
+| CD | implementation.md, issues.md | changes.log, debug-log.ndjson |
+| VAS | summary.md, test-results.json | changes.log |
+
+**Shared Discovery Board**:
+- All agents share real-time discovery board `coordination/discoveries.ndjson`
+- Agents read at start, append discoveries during work
+- Eliminates redundant codebase exploration
+
+**Session Structure**:
+```
+{projectRoot}/.workflow/.cycle/
+├── {cycleId}.json                     # Main state file
+├── {cycleId}.progress/
+│   ├── ra/                         # RA agent artifacts
+│   │   ├── requirements.md        # Current version (complete rewrite)
+│   │   ├── changes.log           # NDJSON full history (append)
+│   │   └── history/              # Archived snapshots
+│   ├── ep/                         # EP agent artifacts
+│   ├── cd/                         # CD agent artifacts
+│   ├── vas/                        # VAS agent artifacts
+│   └── coordination/               # Coordination data
+│       ├── discoveries.ndjson      # Shared discovery board
+│       ├── timeline.md             # Execution timeline
+│       └── decisions.log            # Decision log
+```
+
+**Execution Flow**:
+```
+Phase 1: Session initialization
+    ↓ cycleId, state, progressDir
+
+Phase 2: Agent execution (parallel)
+    ├─ Spawn RA → EP → CD → VAS
+    └─ Wait for all agents to complete
+
+Phase 3: Result aggregation & iteration
+    ├─ Parse PHASE_RESULT
+    ├─ Detect issues (test failures, blockers)
+    ├─ Issues AND iteration < max?
+    │   ├─ Yes → Send feedback, loop back to Phase 2
+    │   └─ No → Proceed to Phase 4
+    └─ Output: parsedResults, iteration status
+
+Phase 4: Completion and summary
+    ├─ Generate unified summary report
+    ├─ Update final state
+    ├─ Close all agents
+    └─ Output: Final cycle report
+```
+
+**Version Control**:
+- 1.0.0: Initial cycle → 1.x.0: Each iteration (minor version increment)
+- Each iteration: Archive old version → Complete rewrite → Append changes.log
+
+## Workflow Skills
+
+### analyze-with-file
+
+**One-Liner**: Collaborative analysis — interactive analysis with documented discussions, inline exploration, and evolving understanding
+
+**Triggers**:
+```
+/analyze-with-file TOPIC="<question>"
+/analyze-with-file TOPIC="--depth=deep"
+```
+
+**Core Workflow**:
+```
+Topic → Explore → Discuss → Document → Refine → Conclude → (Optional) Quick Execute
+```
+
+**Key Features**:
+- **Documented discussion timeline**: Capture understanding evolution across all phases
+- **Decision logging at every key point**: Force recording of key findings, direction changes, trade-offs
+- **Multi-perspective analysis**: Support up to 4 analysis perspectives (serial, inline)
+- **Interactive discussion**: Multi-round Q&A, user feedback and direction adjustment
+- **Quick execute**: Direct conversion of conclusions to executable tasks
+
+**Decision Recording Protocol**:
+| Trigger | Content to Record | Target Section |
+|---------|-------------------|----------------|
+| Direction choice | Choice, reason, alternatives | `#### Decision Log` |
+| Key findings | Finding, impact scope, confidence | `#### Key Findings` |
+| Assumption change | Old assumption → New understanding, reason, impact | `#### Corrected Assumptions` |
+| User feedback | User's raw input, adoption/adjustment reason | `#### User Input` |
+
+---
+
+### brainstorm-with-file
+
+**One-Liner**: Multi-perspective brainstorming — 4 perspectives (Product, Technical, Risk, User) parallel analysis
+
+**Triggers**:
+```
+/brainstorm-with-file TOPIC="<idea>"
+```
+
+**Features**:
+- 4-perspective parallel analysis: Product, Technical, Risk, User
+- Consistency scoring and convergence determination
+- Feasibility recommendations and action items
+
+**Perspectives**:
+| Perspective | Focus Areas |
+|-------------|-------------|
+| **Product** | Market fit, user value, business viability |
+| **Technical** | Feasibility, tech debt, performance, security |
+| **Risk** | Risk identification, dependencies, failure modes |
+| **User** | Usability, user experience, adoption barriers |
+
+---
+
+### debug-with-file
+
+**One-Liner**: Hypothesis-driven debugging — documented exploration, understanding evolution, analysis-assisted correction
+
+**Triggers**:
+```
+/debug-with-file BUG="<bug description>"
+```
+
+**Core Workflow**:
+```
+Explore → Document → Log → Analyze → Correct Understanding → Fix → Verify
+```
+
+**Key Enhancements**:
+- **understanding.md**: Timeline of exploration and learning
+- **Analysis-assisted correction**: Verify and correct assumptions
+- **Consolidation**: Simplify proven-misunderstood concepts to avoid confusion
+- **Learning preservation**: Retain insights from failed attempts
+
+**Session Folder Structure**:
+```
+{projectRoot}/.workflow/.debug/DBG-{slug}-{date}/
+├── debug.log           # NDJSON log (execution evidence)
+├── understanding.md    # Exploration timeline + consolidated understanding
+└── hypotheses.json     # Hypothesis history (with determination)
+```
+
+**Modes**:
+| Mode | Trigger Condition |
+|------|-------------------|
+| **Explore** | No session or no understanding.md |
+| **Continue** | Session exists but no debug.log content |
+| **Analyze** | debug.log has content |
+
+---
+
+### collaborative-plan-with-file
+
+**One-Liner**: Collaborative planning — multi-agent collaborative planning (alternative to team-planex)
+
+**Triggers**:
+```
+/collaborative-plan-with-file <task>
+```
+
+**Features**:
+- Multi-agent collaborative planning
+- planner and executor work in parallel
+- Intermediate artifact files pass solution
+
+---
+
+### unified-execute-with-file
+
+**One-Liner**: Universal execution engine — alternative to workflow-execute
+
+**Triggers**:
+```
+/unified-execute-with-file <session>
+```
+
+**Features**:
+- Universal execution engine
+- Support multiple task types
+- Automatic session recovery
+
+---
+
+### roadmap-with-file
+
+**One-Liner**: Requirement roadmap planning
+
+**Triggers**:
+```
+/roadmap-with-file <requirements>
+```
+
+**Features**:
+- Requirement to roadmap planning
+- Priority sorting
+- Milestone definition
+
+---
+
+### review-cycle
+
+**One-Liner**: Review cycle (Codex version)
+
+**Triggers**:
+```
+/review-cycle <target>
+```
+
+**Features**:
+- Code review
+- Fix loop
+- Verify fix effectiveness
+
+---
+
+### workflow-test-fix-cycle
+
+**One-Liner**: Test-fix workflow
+
+**Triggers**:
+```
+/workflow-test-fix-cycle <failing-tests>
+```
+
+**Features**:
+- Diagnose test failure causes
+- Fix code or tests
+- Verify fixes
+- Loop until passing
+
+## Specialized Skills
+
+### clean
+
+**One-Liner**: Intelligent code cleanup
+
+**Triggers**:
+```
+/clean <target>
+```
+
+**Features**:
+- Automated code cleanup
+- Code formatting
+- Dead code removal
+
+---
+
+### csv-wave-pipeline
+
+**One-Liner**: CSV wave processing pipeline
+
+**Triggers**:
+```
+/csv-wave-pipeline <csv-file>
+```
+
+**Features**:
+- CSV data processing
+- Wave processing
+- Data transformation and export
+
+---
+
+### memory-compact
+
+**One-Liner**: Memory compression (Codex version)
+
+**Triggers**:
+```
+/memory-compact
+```
+
+**Features**:
+- Memory compression and merging
+- Clean redundant data
+- Optimize storage
+
+---
+
+### ccw-cli-tools
+
+**One-Liner**: CLI tool execution specification
+
+**Triggers**:
+```
+/ccw-cli-tools <command>
+```
+
+**Features**:
+- Standardized CLI tool execution
+- Parameter specification
+- Unified output format
+
+---
+
+### issue-discover
+
+**One-Liner**: Issue discovery
+
+**Triggers**:
+```
+/issue-discover <context>
+```
+
+**Features**:
+- Discover issues from context
+- Issue classification
+- Priority assessment
+
+## Related Documentation
+
+- [Claude Skills](./claude-index.md)
+- [Feature Documentation](../features/)
+
+## Best Practices
+
+1. **Choose the right team type**:
+   - Full lifecycle → `team-lifecycle`
+   - Parallel development → `parallel-dev-cycle`
+   - Collaborative analysis → `analyze-with-file`
+
+2. **Leverage Inline Discuss**: Production roles inline invoke discuss subagents, reducing orchestration overhead
+
+3. **Shared Cache**: Utilize shared exploration cache to avoid duplicate codebase exploration
+
+4. **Fast-Advance**: Linear successor tasks automatically skip orchestrator, improving efficiency
+
+5. **Consensus Routing**: Understand consensus routing behavior for different severity levels
+
+## Usage Examples
+
+```bash
+# Full lifecycle development
+/team-lifecycle "Build user authentication API"
+
+# Parallel development
+/parallel-dev-cycle TASK="Implement notifications"
+
+# Collaborative analysis
+/analyze-with-file TOPIC="How to optimize database queries?"
+
+# Brainstorming
+/brainstorm-with-file TOPIC="Design payment system"
+
+# Debugging
+/debug-with-file BUG="System crashes intermittently"
+
+# Test-fix
+/workflow-test-fix-cycle "Unit tests failing"
+```
+
+## Statistics
+
+| Category | Count |
+|----------|-------|
+| Lifecycle | 2 |
+| Workflow | 8 |
+| Specialized | 6 |
+| **Total** | **16+** |
--- a/docs/skills/codex-lifecycle.md
+++ b/docs/skills/codex-lifecycle.md
@@ -0,0 +1,415 @@
+# Codex Skills - Lifecycle Category
+
+## One-Liner
+
+**Lifecycle Codex Skills is a full lifecycle orchestration system** — implementing complete development flow automation from specification to implementation to testing to review through team-lifecycle and parallel-dev-cycle.
+
+## vs Traditional Methods Comparison
+
+| Dimension | Traditional Methods | **Codex Skills** |
+|-----------|---------------------|------------------|
+| Pipeline orchestration | Manual task management | Automatic spawn-wait-close pipeline |
+| Agent communication | Direct communication | Subagent inline calls |
+| Codebase exploration | Repeated exploration | Shared cache system |
+| Coordination overhead | Coordinate every step | Fast-advance linear skip |
+
+## Skills List
+
+| Skill | Function | Trigger |
+| --- | --- | --- |
+| `team-lifecycle` | Full lifecycle orchestrator | `/team-lifecycle <task>` |
+| `parallel-dev-cycle` | Multi-agent parallel development cycle | `/parallel-dev-cycle TASK="..."` |
+
+## Skills Details
+
+### team-lifecycle
+
+**One-Liner**: Full lifecycle orchestrator — spawn-wait-close pipeline for spec/implementation/test
+
+**Architecture Overview**:
+```
+-------------------------------------------------------------+
+|  Team Lifecycle Orchestrator                                  |
+|  Phase 1 -> Phase 2 -> Phase 3 -> Phase 4 -> Phase 5         |
+|  Require    Init       Dispatch   Coordinate   Report         |
+----------+------------------------------------------------+--+
+           |
+     +-----+------+----------+-----------+-----------+
+     v            v          v           v           v
+---------+ +---------+ +---------+ +---------+ +---------+
+| Phase 1 | | Phase 2 | | Phase 3 | | Phase 4 | | Phase 5 |
+| Require | | Init    | | Dispatch| | Coord   | | Report  |
+---------+ +---------+ +---------+ +---------+ +---------+
+     |            |          |          |||          |
+  params       session     tasks     agents      summary
+                                    /  |  \
+                              spawn  wait  close
+                              /        |        \
+                       +------+   +-------+   +--------+
+                       |agent1|   |agent2 |   |agent N |
+                       +------+   +-------+   +--------+
+                          |           |            |
+                     (may call discuss/explore subagents internally)
+```
+
+**Key Design Principles**:
+
+1. **Inline discuss subagent**: Production roles (analyst, writer, reviewer) inline invoke discuss subagents, reducing spec pipeline from 12 beats to 6
+2. **Shared explore cache**: All agents share centralized `explorations/` directory, eliminating duplicate codebase exploration
+3. **Fast-advance spawning**: Immediately spawn next linear successor after agent completion
+4. **Consensus severity routing**: Discussion results routed through HIGH/MEDIUM/LOW severity levels
+5. **Beat model**: Each pipeline step is a beat — spawn agent, wait for results, process output, spawn next
+
+**Agent Registry**:
+| Agent | Role File | Responsibility | Mode |
+|-------|-----------|----------------|------|
+| analyst | ~/.codex/agents/analyst.md | Seed analysis, context collection, DISCUSS-001 | 2.8 Inline Subagent |
+| writer | ~/.codex/agents/writer.md | Documentation generation, DISCUSS-002 to DISCUSS-005 | 2.8 Inline Subagent |
+| planner | ~/.codex/agents/planner.md | Multi-angle exploration, plan generation | 2.9 Cached Exploration |
+| executor | ~/.codex/agents/executor.md | Code implementation | 2.1 Standard |
+| tester | ~/.codex/agents/tester.md | Test-fix loop | 2.3 Deep Interaction |
+| reviewer | ~/.codex/agents/reviewer.md | Code review + spec quality, DISCUSS-006 | 2.8 Inline Subagent |
+| architect | ~/.codex/agents/architect.md | Architecture consultation (on-demand) | 2.1 Standard |
+| fe-developer | ~/.codex/agents/fe-developer.md | Frontend implementation | 2.1 Standard |
+| fe-qa | ~/.codex/agents/fe-qa.md | Frontend QA, GC loop | 2.3 Deep Interaction |
+
+**Subagent Registry**:
+| Subagent | Agent File | Callable By | Purpose |
+|----------|------------|-------------|---------|
+| discuss | ~/.codex/agents/discuss-agent.md | analyst, writer, reviewer | Multi-perspective critique via CLI tool |
+| explore | ~/.codex/agents/explore-agent.md | analyst, planner, any agent | Codebase exploration with shared cache |
+
+**Pipeline Definition**:
+```
+Spec-only (6 beats):
+  RESEARCH-001(+D1) → DRAFT-001(+D2) → DRAFT-002(+D3) → DRAFT-003(+D4) → DRAFT-004(+D5) → QUALITY-001(+D6)
+
+Impl-only (3 beats):
+  PLAN-001 → IMPL-001 → TEST-001 || REVIEW-001
+
+Full-lifecycle (9 beats):
+  [Spec pipeline] → PLAN-001 → IMPL-001 → TEST-001 || REVIEW-001
+```
+
+**Beat Cycle**:
+```
+event (phase advance / user resume)
+      ↓
+  [Orchestrator]
+      +-- read state file
+      +-- find ready tasks
+      +-- spawn agent(s)
+      +-- wait(agent_ids, timeout)
+      +-- process results (consensus routing, artifacts)
+      +-- update state file
+      +-- close completed agents
+      +-- fast-advance: immediately spawn next if linear successor
+      +-- yield (wait for next event or user command)
+```
+
+**Fast-Advance Decision Table**:
+| Condition | Action |
+|-----------|--------|
+| 1 ready task, simple linear successor, no checkpoint | Immediately `spawn_agent` next task (fast-advance) |
+| Multiple ready tasks (parallel window) | Batch spawn all ready tasks, then `wait` all |
+| No ready tasks, other agents running | Yield, wait for those agents to complete |
+| No ready tasks, nothing running | Pipeline complete, enter Phase 5 |
+| Checkpoint task complete (e.g., QUALITY-001) | Pause, output checkpoint message, wait for user |
+
+**Consensus Severity Routing**:
+| Verdict | Severity | Orchestrator Action |
+|---------|----------|---------------------|
+| consensus_reached | - | Proceed normally, fast-advance to next task |
+| consensus_blocked | LOW | Treat as reached with notes, proceed |
+| consensus_blocked | MEDIUM | Log warning to `wisdom/issues.md`, include divergences in next task context, continue |
+| consensus_blocked | HIGH | Create revision task or pause waiting for user |
+| consensus_blocked | HIGH (DISCUSS-006) | Always pause waiting for user decision (final sign-off gate) |
+
+**Revision Task Creation** (HIGH severity, non-DISCUSS-006):
+```javascript
+const revisionTask = {
+  id: "<original-task-id>-R1",
+  owner: "<same-agent-role>",
+  blocked_by: [],
+  description: "Revision of <original-task-id>: address consensus-blocked divergences.\n"
+    + "Session: <session-dir>\n"
+    + "Original artifact: <artifact-path>\n"
+    + "Divergences: <divergence-details>\n"
+    + "Action items: <action-items-from-discuss>\n"
+    + "InlineDiscuss: <same-round-id>",
+  status: "pending",
+  is_revision: true
+}
+```
+
+**Session Directory Structure**:
+```
+.workflow/.team/TLS-<slug>-<date>/
+├── team-session.json           # Pipeline state (replaces TaskCreate/TaskList)
+├── spec/                       # Specification artifacts
+│   ├── spec-config.json
+│   ├── discovery-context.json
+│   ├── product-brief.md
+│   ├── requirements/
+│   ├── architecture/
+│   ├── epics/
+│   ├── readiness-report.md
+│   └── spec-summary.md
+├── discussions/                # Discussion records (written by discuss subagents)
+├── plan/                       # Plan artifacts
+│   ├── plan.json
+│   └── tasks/                  # Detailed task specifications
+├── explorations/               # Shared exploration cache
+│   ├── cache-index.json        # { angle -> file_path }
+│   └── explore-<angle>.json
+├── architecture/               # Architect assessments + design-tokens.json
+├── analysis/                   # Analyst design-intelligence.json (UI mode)
+├── qa/                         # QA audit reports
+├── wisdom/                     # Cross-task knowledge accumulation
+│   ├── learnings.md            # Patterns and insights
+│   ├── decisions.md            # Architecture and design decisions
+│   ├── conventions.md          # Codebase conventions
+│   └── issues.md               # Known risks and issues
+└── shared-memory.json          # Cross-agent state
+```
+
+**State File Schema** (team-session.json):
+```json
+{
+  "session_id": "TLS-<slug>-<date>",
+  "mode": "<spec-only | impl-only | full-lifecycle | fe-only | fullstack | full-lifecycle-fe>",
+  "scope": "<project description>",
+  "status": "<active | paused | completed>",
+  "started_at": "<ISO8601>",
+  "updated_at": "<ISO8601>",
+  "tasks_total": 0,
+  "tasks_completed": 0,
+  "pipeline": [
+    {
+      "id": "RESEARCH-001",
+      "owner": "analyst",
+      "status": "pending | in_progress | completed | failed",
+      "blocked_by": [],
+      "description": "...",
+      "inline_discuss": "DISCUSS-001",
+      "agent_id": null,
+      "artifact_path": null,
+      "discuss_verdict": null,
+      "discuss_severity": null,
+      "started_at": null,
+      "completed_at": null,
+      "revision_of": null,
+      "revision_count": 0
+    }
+  ],
+  "active_agents": [],
+  "completed_tasks": [],
+  "revision_chains": {},
+  "wisdom_entries": [],
+  "checkpoints_hit": [],
+  "gc_loop_count": 0
+}
+```
+
+**User Commands**:
+| Command | Action |
+|---------|--------|
+| `check` / `status` | Output execution status graph (read-only, no progress) |
+| `resume` / `continue` | Check agent status, advance pipeline |
+| New session request | Phase 0 detection, enter normal Phase 1-5 flow |
+
+**Status Graph Output Format**:
+```
+[orchestrator] Pipeline Status
+[orchestrator] Mode: <mode> | Progress: <completed>/<total> (<percent>%)
+
+[orchestrator] Execution Graph:
+  Spec Phase:
+    [V RESEARCH-001(+D1)] -> [V DRAFT-001(+D2)] -> [>>> DRAFT-002(+D3)]
+    -> [o DRAFT-003(+D4)] -> [o DRAFT-004(+D5)] -> [o QUALITY-001(+D6)]
+
+  V=completed  >>>=running  o=pending  .=not created
+
+[orchestrator] Active Agents:
+  > <task-id> (<agent-role>) - running <elapsed>
+
+[orchestrator] Commands: 'resume' to advance | 'check' to refresh
+```
+
+---
+
+### parallel-dev-cycle
+
+**One-Liner**: Multi-agent parallel development cycle — requirements analysis, exploration planning, code development, validation
+
+**Architecture Overview**:
+```
+┌─────────────────────────────────────────────────────────────┐
+│                    User Input (Task)                        │
+└────────────────────────────┬────────────────────────────────┘
+                             │
+                             v
+              ┌──────────────────────────────┐
+              │  Main Flow (Inline Orchestration)  │
+              │  Phase 1 → 2 → 3 → 4              │
+              └──────────────────────────────┘
+                             │
+        ┌────────────────────┼────────────────────┐
+        │                    │                    │
+        v                    v                    v
+    ┌────────┐         ┌────────┐         ┌────────┐
+    │  RA    │         │  EP    │         │  CD    │
+    │Agent   │         │Agent   │         │Agent   │
+    └────────┘         └────────┘         └────────┘
+        │                    │                    │
+        └────────────────────┼────────────────────┘
+                             │
+                             v
+                         ┌────────┐
+                         │  VAS   │
+                         │ Agent  │
+                         └────────┘
+                             │
+                             v
+              ┌──────────────────────────────┐
+              │    Summary Report            │
+              │  & Markdown Docs             │
+              └──────────────────────────────┘
+```
+
+**Key Design Principles**:
+
+1. **Main document + auxiliary log**: Each agent maintains one main document (complete rewrite per iteration) and auxiliary log (append)
+2. **Version-based overwriting**: Main document completely rewritten each iteration; log append-only
+3. **Automatic archiving**: Old main document versions automatically archived to `history/` directory
+4. **Complete audit trail**: Changes.log (NDJSON) retains all change history
+5. **Parallel coordination**: Four agents started simultaneously; coordinated via shared state and inline main flow
+6. **File references**: Use short file paths rather than content passing
+7. **Self-enhancement**: RA agent proactively expands requirements based on context
+8. **Shared discovery board**: All agents share exploration discoveries via `discoveries.ndjson`
+
+**Workers**:
+| Worker | Main Document (rewrite each iteration) | Append Log |
+|--------|----------------------------------------|------------|
+| **RA** | requirements.md | changes.log |
+| **EP** | exploration.md, architecture.md, plan.json | changes.log |
+| **CD** | implementation.md, issues.md | changes.log, debug-log.ndjson |
+| **VAS** | summary.md, test-results.json | changes.log |
+
+**Shared Discovery Board**:
+- All agents share real-time discovery board `coordination/discoveries.ndjson`
+- Agents read at start, append discoveries during work
+- Eliminates redundant codebase exploration
+
+**Discovery Types**:
+| Type | Dedup Key | Writer | Readers |
+|------|-----------|--------|---------|
+| `tech_stack` | singleton | RA | EP, CD, VAS |
+| `project_config` | `data.path` | RA | EP, CD |
+| `existing_feature` | `data.name` | RA, EP | CD |
+| `architecture` | singleton | EP | CD, VAS |
+| `code_pattern` | `data.name` | EP, CD | CD, VAS |
+| `integration_point` | `data.file` | EP | CD |
+| `test_command` | singleton | CD, VAS | VAS, CD |
+| `blocker` | `data.issue` | Any | All |
+
+**Execution Flow**:
+```
+Phase 1: Session initialization
+    ├─ Create new cycle OR resume existing cycle
+    ├─ Initialize state file and directory structure
+    └─ Output: cycleId, state, progressDir
+
+Phase 2: Agent execution (parallel)
+    ├─ Attached task: spawn RA → spawn EP → spawn CD → spawn VAS → wait all
+    ├─ Parallel spawn RA, EP, CD, VAS agents
+    ├─ Wait for all agents to complete (with timeout handling)
+    └─ Output: agentOutputs (4 agent results)
+
+Phase 3: Result aggregation & iteration
+    ├─ Parse PHASE_RESULT from each agent
+    ├─ Detect issues (test failures, blockers)
+    ├─ Decision: Issues found AND iteration < max?
+    │   ├─ Yes → Send feedback via send_input, loop back to Phase 2
+    │   └─ No → Proceed to Phase 4
+    └─ Output: parsedResults, iteration status
+
+Phase 4: Completion and summary
+    ├─ Generate unified summary report
+    ├─ Update final state
+    ├─ Close all agents
+    └─ Output: Final cycle report and continuation instructions
+```
+
+**Session Structure**:
+```
+{projectRoot}/.workflow/.cycle/
+├── {cycleId}.json                     # Main state file
+├── {cycleId}.progress/
+│   ├── ra/                         # RA agent artifacts
+│   │   ├── requirements.md        # Current version (complete rewrite)
+│   │   ├── changes.log           # NDJSON full history (append)
+│   │   └── history/              # Archived snapshots
+│   ├── ep/                         # EP agent artifacts
+│   │   ├── exploration.md        # Codebase exploration report
+│   │   ├── architecture.md       # Architecture design
+│   │   ├── plan.json             # Structured task list (current version)
+│   │   ├── changes.log           # NDJSON full history
+│   │   └── history/
+│   ├── cd/                         # CD agent artifacts
+│   │   ├── implementation.md     # Current version
+│   │   ├── debug-log.ndjson      # Debug hypothesis tracking
+│   │   ├── changes.log           # NDJSON full history
+│   │   └── history/
+│   ├── vas/                        # VAS agent artifacts
+│   │   ├── summary.md            # Current version
+│   │   ├── changes.log           # NDJSON full history
+│   │   └── history/
+│   └── coordination/               # Coordination data
+│       ├── discoveries.ndjson      # Shared discovery board (all agents append)
+│       ├── timeline.md             # Execution timeline
+│       └── decisions.log            # Decision log
+```
+
+**Version Control**:
+- 1.0.0: Initial cycle → 1.x.0: Each iteration (minor version increment)
+- Each iteration: Archive old version → Complete rewrite → Append changes.log
+
+## Related Commands
+
+- [Codex Skills - Workflow](./codex-workflow.md)
+- [Codex Skills - Specialized](./codex-specialized.md)
+- [Claude Skills - Team Collaboration](./claude-collaboration.md)
+
+## Best Practices
+
+1. **Choose the right team type**:
+   - Full feature development → `team-lifecycle`
+   - Parallel development cycle → `parallel-dev-cycle`
+
+2. **Leverage Inline Discuss**: Production roles inline invoke discuss subagents, reducing orchestration overhead
+
+3. **Shared Cache**: Utilize shared exploration cache to avoid duplicate codebase exploration
+
+4. **Fast-Advance**: Linear successor tasks automatically skip orchestrator, improving efficiency
+
+5. **Consensus Routing**: Understand consensus routing behavior for different severity levels
+
+## Usage Examples
+
+```bash
+# Full lifecycle development
+/team-lifecycle "Build user authentication API"
+
+# Specification pipeline
+/team-lifecycle --mode=spec-only "Design payment system"
+
+# Parallel development
+/parallel-dev-cycle TASK="Implement notifications"
+
+# Continue cycle
+/parallel-dev-cycle --cycle-id=cycle-v1-20260122-abc123
+
+# Auto mode
+/parallel-dev-cycle --auto TASK="Add OAuth"
+```
--- a/docs/skills/codex-specialized.md
+++ b/docs/skills/codex-specialized.md
@@ -0,0 +1,235 @@
+# Codex Skills - Specialized Category
+
+## One-Liner
+
+**Specialized Codex Skills is a toolset for specific domains** — solving domain-specific problems through specialized skills like code cleanup, data pipelines, memory management, CLI tools, and issue discovery.
+
+## Skills List
+
+| Skill | Function | Trigger |
+| --- | --- | --- |
+| `clean` | Intelligent code cleanup | `/clean <target>` |
+| `csv-wave-pipeline` | CSV wave processing pipeline | `/csv-wave-pipeline <csv-file>` |
+| `memory-compact` | Memory compression | `/memory-compact` |
+| `ccw-cli-tools` | CLI tool execution specification | `/ccw-cli-tools <command>` |
+| `issue-discover` | Issue discovery | `/issue-discover <context>` |
+
+## Skills Details
+
+### clean
+
+**One-Liner**: Intelligent code cleanup — automated code cleanup, formatting, dead code removal
+
+**Features**:
+- Automated code cleanup
+- Code formatting
+- Dead code removal
+- Import sorting
+- Comment organization
+
+**Cleanup Types**:
+| Type | Description |
+|------|-------------|
+| **Format** | Unify code format |
+| **Dead Code** | Remove unused code |
+| **Imports** | Sort and remove unused imports |
+| **Comments** | Organize and remove outdated comments |
+| **Naming** | Unify naming conventions |
+
+**Usage Examples**:
+```bash
+# Clean current directory
+/clean .
+
+# Clean specific directory
+/clean src/
+
+# Format only
+/clean --format-only src/
+
+# Remove dead code only
+/clean --dead-code-only src/
+```
+
+---
+
+### csv-wave-pipeline
+
+**One-Liner**: CSV wave processing pipeline — CSV data processing, wave processing, data conversion and export
+
+**Features**:
+- CSV data reading and parsing
+- Wave processing (batch processing for large data)
+- Data conversion and validation
+- Export to multiple formats
+
+**Processing Flow**:
+```
+Read CSV → Validate Data → Wave Processing → Convert Data → Export Results
+```
+
+**Output Formats**:
+| Format | Description |
+|--------|-------------|
+| CSV | Standard CSV format |
+| JSON | JSON array |
+| NDJSON | NDJSON (one JSON per line) |
+| Excel | Excel file |
+
+**Usage Examples**:
+```bash
+# Process CSV
+/csv-wave-pipeline data.csv
+
+# Specify output format
+/csv-wave-pipeline data.csv --output-format=json
+
+# Specify wave batch size
+/csv-wave-pipeline data.csv --batch-size=1000
+```
+
+---
+
+### memory-compact
+
+**One-Liner**: Memory compression (Codex version) — Memory compression and merging, cleanup redundant data, optimize storage
+
+**Features**:
+- Memory compression and merging
+- Clean redundant data
+- Optimize storage
+- Generate Memory summary
+
+**Compression Types**:
+| Type | Description |
+|------|-------------|
+| **Merge** | Merge similar entries |
+| **Deduplicate** | Remove duplicate entries |
+| **Archive** | Archive old entries |
+| **Summary** | Generate summary |
+
+**Usage Examples**:
+```bash
+# Compress Memory
+/memory-compact
+
+# Merge similar entries
+/memory-compact --merge
+
+# Generate summary
+/memory-compact --summary
+```
+
+---
+
+### ccw-cli-tools
+
+**One-Liner**: CLI tool execution specification — standardized CLI tool execution, parameter specification, unified output format
+
+**Features**:
+- Standardized CLI tool execution
+- Parameter specification
+- Unified output format
+- Error handling
+
+**Supported CLI Tools**:
+| Tool | Description |
+|------|-------------|
+| gemini | Gemini CLI |
+| codex | Codex CLI |
+| claude | Claude CLI |
+| qwen | Qwen CLI |
+
+**Execution Specification**:
+```javascript
+{
+  "tool": "gemini",
+  "mode": "write",
+  "prompt": "...",
+  "context": "...",
+  "output": "..."
+}
+```
+
+**Usage Examples**:
+```bash
+# Execute CLI tool
+/ccw-cli-tools --tool=gemini --mode=write "Implement feature"
+
+# Batch execution
+/ccw-cli-tools --batch tasks.json
+```
+
+---
+
+### issue-discover
+
+**One-Liner**: Issue discovery — discover issues from context, issue classification, priority assessment
+
+**Features**:
+- Discover issues from context
+- Issue classification
+- Priority assessment
+- Generate issue reports
+
+**Issue Types**:
+| Type | Description |
+|------|-------------|
+| **Bug** | Defect or error |
+| **Feature** | New feature request |
+| **Improvement** | Improvement suggestion |
+| **Task** | Task |
+| **Documentation** | Documentation issue |
+
+**Priority Assessment**:
+| Priority | Criteria |
+|----------|----------|
+| **Critical** | Blocking issue |
+| **High** | Important issue |
+| **Medium** | Normal issue |
+| **Low** | Low priority |
+
+**Usage Examples**:
+```bash
+# Discover issues from codebase
+/issue-discover src/
+
+# Discover issues from documentation
+/issue-discover docs/
+
+# Discover issues from test results
+/issue-discover test-results/
+```
+
+## Related Commands
+
+- [Codex Skills - Lifecycle](./codex-lifecycle.md)
+- [Codex Skills - Workflow](./codex-workflow.md)
+- [Claude Skills - Meta](./claude-meta.md)
+
+## Best Practices
+
+1. **Code cleanup**: Regularly use `clean` to clean up code
+2. **Data processing**: Use `csv-wave-pipeline` for processing large data
+3. **Memory management**: Regularly use `memory-compact` to optimize Memory
+4. **CLI tools**: Use `ccw-cli-tools` for standardized CLI execution
+5. **Issue discovery**: Use `issue-discover` to discover and classify issues
+
+## Usage Examples
+
+```bash
+# Clean code
+/clean src/
+
+# Process CSV
+/csv-wave-pipeline data.csv --output-format=json
+
+# Compress Memory
+/memory-compact --merge
+
+# Execute CLI tool
+/ccw-cli-tools --tool=gemini "Analyze code"
+
+# Discover issues
+/issue-discover src/
+```
--- a/docs/skills/codex-workflow.md
+++ b/docs/skills/codex-workflow.md
@@ -0,0 +1,366 @@
+# Codex Skills - Workflow Category
+
+## One-Liner
+
+**Workflow Codex Skills is a collaborative analysis and parallel development workflow system** — enabling efficient team collaboration through documented discussions, multi-perspective analysis, and collaborative planning.
+
+## Pain Points Solved
+
+| Pain Point | Current State | Codex Skills Solution |
+| --- | --- | --- |
+| **Discussion process lost** | Only conclusions saved from discussions | Documented discussion timeline |
+| **Repeated exploration** | Codebase re-explored for each analysis | Shared discovery board |
+| **Blind debugging** | No hypothesis verification mechanism | Hypothesis-driven debugging |
+| **Fragmented collaboration** | Roles work independently | Multi-perspective parallel analysis |
+
+## Skills List
+
+| Skill | Function | Trigger |
+| --- | --- | --- |
+| `analyze-with-file` | Collaborative analysis (4 perspectives) | `/analyze-with-file TOPIC="..."` |
+| `brainstorm-with-file` | Brainstorming (4 perspectives) | `/brainstorm-with-file TOPIC="..."` |
+| `debug-with-file` | Hypothesis-driven debugging | `/debug-with-file BUG="..."` |
+| `collaborative-plan-with-file` | Collaborative planning | `/collaborative-plan-with-file <task>` |
+| `unified-execute-with-file` | Universal execution engine | `/unified-execute-with-file <session>` |
+| `roadmap-with-file` | Requirement roadmap | `/roadmap-with-file <requirements>` |
+| `review-cycle` | Review cycle | `/review-cycle <target>` |
+| `workflow-test-fix-cycle` | Test-fix workflow | `/workflow-test-fix-cycle <tests>` |
+
+## Skills Details
+
+### analyze-with-file
+
+**One-Liner**: Collaborative analysis — interactive analysis with documented discussions, inline exploration, and evolving understanding
+
+**Core Workflow**:
+```
+Topic → Explore → Discuss → Document → Refine → Conclude → (Optional) Quick Execute
+```
+
+**Key Features**:
+- **Documented discussion timeline**: Capture understanding evolution across all phases
+- **Decision logging at every key point**: Force recording of key findings, direction changes, trade-offs
+- **Multi-perspective analysis**: Support up to 4 analysis perspectives (serial, inline)
+- **Interactive discussion**: Multi-round Q&A, user feedback and direction adjustment
+- **Quick execute**: Direct conversion of conclusions to executable tasks
+
+**Decision Recording Protocol**:
+| Trigger | Content to Record | Target Section |
+|------|-------------------|----------------|
+| **Direction choice** | Choice, reason, alternatives | `#### Decision Log` |
+| **Key findings** | Finding, impact scope, confidence | `#### Key Findings` |
+| **Assumption change** | Old assumption → New understanding, reason, impact | `#### Corrected Assumptions` |
+| **User feedback** | User's raw input, adoption/adjustment reason | `#### User Input` |
+
+**Analysis Perspectives** (serial, inline):
+| Perspective | CLI Tool | Role | Focus Areas |
+|------------|----------|------|-------------|
+| Product | gemini | Product Manager | Market fit, user value, business viability |
+| Technical | codex | Tech Lead | Feasibility, tech debt, performance, security |
+| Quality | claude | QA Lead | Completeness, testability, consistency |
+| Risk | gemini | Risk Analyst | Risk identification, dependencies, failure modes |
+
+**Session Folder Structure**:
+```
+{projectRoot}/.workflow/.analyze/ANL-{slug}-{date}/
+├── discussion.md               # Discussion timeline + understanding evolution
+├── explorations/               # Codebase exploration reports
+│   ├── exploration-summary.md
+│   ├── relevant-files.md
+│   └── patterns.md
+└── conclusion.md               # Final conclusion + Quick execute task
+```
+
+**Execution Flow**:
+```
+Phase 1: Topic Analysis
+    ├─ Detect depth mode (quick/standard/deep)
+    ├─ Session detection: {projectRoot}/.workflow/.analyze/ANL-{slug}-{date}/
+    └─ Output: sessionId, depth, continueMode
+
+Phase 2: Exploration
+    ├─ Detect context: discovery-context.json, prep-package.json
+    ├─ Codebase exploration: Glob + Read + Grep tools
+    ├─ Write: explorations/exploration-summary.md
+    └─ Output: explorationResults
+
+Phase 3: Discussion (Multiple Rounds)
+    ├─ Initialize: discussion.md (Section: Exploration Summary)
+    ├─ Round 1: Generate initial analysis based on explorationResults
+    ├─ Iterate: User feedback → Refine understanding → Update discussion.md
+    └─ Per-round update: Decision Log, Key Findings, Current Understanding
+
+Phase 4: Refinement
+    ├─ Merge: explorations/ content merged into discussion.md
+    ├─ Check: All key points recorded
+    └─ Output: refinedDiscussion
+
+Phase 5: Conclusion
+    ├─ Generate: conclusion.md (Executive Summary, Findings, Recommendations)
+    └─ Quick Execute (optional): Generate executable tasks
+
+Phase 6: (Optional) Quick Execute
+    ├─ Convert conclusions to: task JSON or plan file
+    └─ Invoke: workflow-execute or direct execution
+```
+
+**Depth Modes**:
+| Mode | Exploration Scope | Analysis Rounds |
+|------|-------------------|-----------------|
+| quick | Basic search, 10 files | 1 round |
+| standard | Standard exploration, 30 files | 2-3 rounds |
+| deep | Deep exploration, 100+ files | 3-5 rounds |
+
+---
+
+### brainstorm-with-file
+
+**One-Liner**: Multi-perspective brainstorming — 4 perspectives (Product, Technical, Risk, User) parallel analysis
+
+**Key Features**:
+- 4-perspective parallel analysis: Product, Technical, Risk, User
+- Consistency scoring and convergence determination
+- Feasibility recommendations and action items
+
+**Perspectives**:
+| Perspective | Focus Areas |
+|-------------|-------------|
+| **Product** | Market fit, user value, business viability |
+| **Technical** | Feasibility, tech debt, performance, security |
+| **Risk** | Risk identification, dependencies, failure modes |
+| **User** | Usability, user experience, adoption barriers |
+
+**Output Format**:
+```
+## Consensus Determination
+Status: <consensus_reached | consensus_blocked>
+Average Rating: <N>/5
+Convergence Points: <list>
+Divergence Points: <list>
+
+## Feasibility Recommendation
+Recommendation: <proceed | proceed-with-caution | revise | reject>
+Reasoning: <reasoning>
+Action Items: <action items>
+```
+
+---
+
+### debug-with-file
+
+**One-Liner**: Hypothesis-driven debugging — documented exploration, understanding evolution, analysis-assisted correction
+
+**Core Workflow**:
+```
+Explore → Document → Log → Analyze → Correct Understanding → Fix → Verify
+```
+
+**Key Enhancements**:
+- **understanding.md**: Timeline of exploration and learning
+- **Analysis-assisted correction**: Verify and correct assumptions
+- **Consolidation**: Simplify proven-misunderstood concepts to avoid confusion
+- **Learning preservation**: Retain insights from failed attempts
+
+**Session Folder Structure**:
+```
+{projectRoot}/.workflow/.debug/DBG-{slug}-{date}/
+├── debug.log           # NDJSON log (execution evidence)
+├── understanding.md    # Exploration timeline + consolidated understanding
+└── hypotheses.json     # Hypothesis history (with determination)
+```
+
+**Modes**:
+| Mode | Trigger Condition | Behavior |
+|------|-------------------|----------|
+| **Explore** | No session or no understanding.md | Locate error source, record initial understanding, generate hypotheses, add logs |
+| **Continue** | Session exists but no debug.log content | Wait for user reproduction |
+| **Analyze** | debug.log has content | Parse logs, evaluate hypotheses, update understanding |
+
+**Hypothesis Generation**:
+Generate targeted hypotheses based on error patterns:
+
+| Error Pattern | Hypothesis Type |
+|---------------|-----------------|
+| not found / missing / undefined | data_mismatch |
+| 0 / empty / zero / registered | logic_error |
+| timeout / connection / sync | integration_issue |
+| type / format / parse | type_mismatch |
+
+**NDJSON Log Format**:
+```json
+{"sid":"DBG-xxx-2025-01-21","hid":"H1","loc":"file.py:func:42","msg":"Check dict keys","data":{"keys":["a","b"],"target":"c","found":false},"ts":1734567890123}
+```
+
+**Understanding Document Template**:
+```markdown
+# Understanding Document
+
+**Session ID**: DBG-xxx-2025-01-21
+**Bug Description**: [original description]
+**Started**: 2025-01-21T10:00:00+08:00
+
+---
+
+## Exploration Timeline
+
+### Iteration 1 - Initial Exploration (2025-01-21 10:00)
+
+#### Current Understanding
+...
+
+#### Evidence from Code Search
+...
+
+#### Hypotheses Generated
+...
+
+---
+
+## Current Consolidated Understanding
+
+### What We Know
+- [valid understanding points]
+
+### What Was Disproven
+- ~~[disproven assumptions]~~
+
+### Current Investigation Focus
+[current focus]
+```
+
+---
+
+### collaborative-plan-with-file
+
+**One-Liner**: Collaborative planning — multi-agent collaborative planning (alternative to team-planex)
+
+**Features**:
+- Multi-agent collaborative planning
+- planner and executor work in parallel
+- Intermediate artifact files pass solution
+
+**Wave Pipeline** (per-issue beat):
+```
+Issue 1:  planner plans solution → write intermediate artifact → conflict check → create EXEC-* → issue_ready
+                ↓ (executor starts immediately)
+Issue 2:  planner plans solution → write intermediate artifact → conflict check → create EXEC-* → issue_ready
+                ↓ (executor consumes in parallel)
+Issue N:  ...
+Final:    planner sends all_planned → executor completes remaining EXEC-* → finish
+```
+
+---
+
+### unified-execute-with-file
+
+**One-Liner**: Universal execution engine — alternative to workflow-execute
+
+**Features**:
+- Universal execution engine
+- Support multiple task types
+- Automatic session recovery
+
+**Session Discovery**:
+1. Count active sessions in .workflow/active/
+2. Decision:
+   - count=0 → Error: No active session
+   - count=1 → Auto-select session
+   - count>1 → AskUserQuestion (max 4 options)
+
+---
+
+### roadmap-with-file
+
+**One-Liner**: Requirement roadmap planning
+
+**Features**:
+- Requirement to roadmap planning
+- Priority sorting
+- Milestone definition
+
+**Output Structure**:
+```
+.workflow/.roadmap/{session-id}/
+├── roadmap.md                 # Roadmap document
+├── milestones.md              # Milestone definitions
+└── priorities.json            # Priority sorting
+```
+
+---
+
+### review-cycle
+
+**One-Liner**: Review cycle (Codex version)
+
+**Features**:
+- Code review
+- Fix loop
+- Verify fix effectiveness
+
+**Loop Flow**:
+```
+Review code → Find issues → [Has issues] → Fix code → Verify → [Still has issues] → Fix code
+                          ↑______________|
+```
+
+---
+
+### workflow-test-fix-cycle
+
+**One-Liner**: Test-fix workflow
+
+**Features**:
+- Diagnose test failure causes
+- Fix code or tests
+- Verify fixes
+- Loop until passing
+
+**Flow**:
+```
+Diagnose failure → Identify root cause → [Code issue] → Fix code → Verify
+                          ↑___________|
+```
+
+## Related Commands
+
+- [Codex Skills - Lifecycle](./codex-lifecycle.md)
+- [Codex Skills - Specialized](./codex-specialized.md)
+- [Claude Skills - Workflow](./claude-workflow.md)
+
+## Best Practices
+
+1. **Choose the right workflow**:
+   - Collaborative analysis → `analyze-with-file`
+   - Brainstorming → `brainstorm-with-file`
+   - Debugging → `debug-with-file`
+   - Planning → `collaborative-plan-with-file`
+
+2. **Documented discussions**: Utilize documented discussion timeline to capture understanding evolution
+
+3. **Decision logging**: Record decisions at key points to preserve decision history
+
+4. **Hypothesis-driven debugging**: Use hypothesis-driven debugging to systematically solve problems
+
+5. **Multi-perspective analysis**: Leverage multi-perspective parallel analysis for comprehensive understanding
+
+## Usage Examples
+
+```bash
+# Collaborative analysis
+/analyze-with-file TOPIC="How to optimize database queries?"
+
+# Deep analysis
+/analyze-with-file TOPIC="Architecture for microservices" --depth=deep
+
+# Brainstorming
+/brainstorm-with-file TOPIC="Design payment system"
+
+# Debugging
+/debug-with-file BUG="System crashes intermittently"
+
+# Collaborative planning
+/collaborative-plan-with-file "Add user notifications"
+
+# Test-fix
+/workflow-test-fix-cycle "Unit tests failing"
+```
--- a/docs/skills/core-skills.md
+++ b/docs/skills/core-skills.md
--- a/docs/skills/custom.md
+++ b/docs/skills/custom.md
@@ -0,0 +1,270 @@
+# Custom Skill Development
+
+Guide to creating and deploying custom CCW skills.
+
+## Skill Structure
+
+```
+~/.claude/skills/my-skill/
+├── SKILL.md          # Skill definition (required)
+├── index.ts          # Skill logic (optional)
+├── examples/         # Usage examples
+└── README.md         # Documentation
+```
+
+## Creating a Skill
+
+### 1. Define Skill Metadata
+
+Create `SKILL.md` with YAML frontmatter:
+
+```markdown
+---
+name: my-skill
+description: My custom skill for X
+version: 1.0.0
+author: Your Name <email@example.com>
+tags: [custom, automation, frontend]
+category: development
+---
+
+# My Custom Skill
+
+## What It Does
+Detailed description of the skill's purpose and capabilities.
+
+## Usage
+
+\`\`\`javascript
+Skill(skill="my-skill", args="your input here")
+\`\`\`
+
+## Examples
+
+### Example 1: Basic Usage
+\`\`\`javascript
+Skill(skill="my-skill", args="create user form")
+\`\`\`
+
+### Example 2: With Options
+\`\`\`javascript
+Skill(skill="my-skill", args={
+  component: "UserForm",
+  typescript: true,
+  styling: "tailwind"
+})
+\`\`\`
+```
+
+### 2. Implement Skill Logic (Optional)
+
+For complex skills, add `index.ts`:
+
+```typescript
+import type { SkillContext, SkillResult } from '@ccw/types'
+
+interface MySkillOptions {
+  component?: string
+  typescript?: boolean
+  styling?: 'css' | 'tailwind' | 'scss'
+}
+
+export async function execute(
+  args: string | MySkillOptions,
+  context: SkillContext
+): Promise<SkillResult> {
+  // Parse input
+  const options = typeof args === 'string'
+    ? { component: args }
+    : args
+
+  // Execute skill logic
+  const result = await generateComponent(options)
+
+  return {
+    success: true,
+    output: result,
+    metadata: {
+      skill: 'my-skill',
+      version: '1.0.0',
+      timestamp: new Date().toISOString()
+    }
+  }
+}
+
+async function generateComponent(options: MySkillOptions) {
+  // Your implementation here
+  return `// Generated code`
+}
+```
+
+## Skill Categories
+
+### Development
+
+- Component generators
+- API scaffolding
+- Database schema creation
+
+### Documentation
+
+- API docs generation
+- README creation
+- Changelog generation
+
+### DevOps
+
+- CI/CD configuration
+- Dockerfile generation
+- Kubernetes manifests
+
+### Testing
+
+- Test generation
+- Mock creation
+- Coverage reports
+
+## Skill Best Practices
+
+### 1. Clear Purpose
+
+```markdown
+# Good: Clear and specific
+name: generate-react-component
+description: Generate React component with hooks and TypeScript
+
+# Bad: Vague and generic
+name: code-helper
+description: Helps with coding
+```
+
+### 2. Type Safety
+
+```typescript
+// Define clear interfaces
+interface Options {
+  name: string
+  typescript?: boolean
+  styling?: 'css' | 'tailwind'
+}
+
+// Validate input
+function validateOptions(options: any): Options {
+  if (!options.name) {
+    throw new Error('Component name is required')
+  }
+  return options as Options
+}
+```
+
+### 3. Error Handling
+
+```typescript
+try {
+  const result = await generateComponent(options)
+  return { success: true, output: result }
+} catch (error) {
+  return {
+    success: false,
+    error: error.message,
+    suggestion: 'Ensure component name is valid'
+  }
+}
+```
+
+### 4. Documentation
+
+```markdown
+## Usage
+
+\`\`\`javascript
+Skill(skill="my-skill", args="...")
+\`\`\`
+
+## Options
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| name | string | required | Component name |
+| typescript | boolean | true | Use TypeScript |
+
+## Examples
+
+See `examples/` directory for more examples.
+```
+
+## Publishing Skills
+
+### Private Skills
+
+Skills in `~/.claude/skills/` are automatically available.
+
+### Team Skills
+
+Share skills via git:
+
+```bash
+# Create skill repository
+mkdir my-ccw-skills
+cd my-ccw-skills
+git init
+
+# Add skills
+mkdir skills/skill-1
+# ... add skill files
+
+# Share with team
+git remote add origin <repo-url>
+git push -u origin main
+```
+
+Team members install:
+
+```bash
+git clone <repo-url> ~/.claude/skills/team-skills
+```
+
+### Public Skills
+
+Publish to npm:
+
+```json
+{
+  "name": "ccw-skills-my-skill",
+  "version": "1.0.0",
+  "ccw": {
+    "skills": ["my-skill"]
+  }
+}
+```
+
+## Testing Skills
+
+Create tests in `tests/`:
+
+```typescript
+import { describe, it, expect } from 'vitest'
+import { execute } from '../index'
+
+describe('my-skill', () => {
+  it('should generate component', async () => {
+    const result = await execute('UserForm', {})
+    expect(result.success).toBe(true)
+    expect(result.output).toContain('UserForm')
+  })
+})
+```
+
+## Debugging
+
+Enable debug logging:
+
+```bash
+export CCW_DEBUG=1
+ccw skill run my-skill "test input"
+```
+
+::: info See Also
+- [Core Skills](./core-skills.md) - Built-in skill reference
+- [Skills Library](./index.md) - All available skills
+:::
--- a/docs/skills/index.md
+++ b/docs/skills/index.md
@@ -0,0 +1,184 @@
+# Skills Library
+
+Complete reference for all **32 CCW built-in skills** across 3 categories, plus custom skill development.
+
+## What are Skills?
+
+Skills are reusable, domain-specific capabilities that CCW can execute. Each skill is designed for a specific development task or workflow, and can be combined into powerful workflow chains.
+
+## Categories Overview
+
+| Category | Count | Description |
+|----------|-------|-------------|
+| [Standalone](./core-skills.md#standalone-skills) | 11 | Single-purpose skills for specific tasks |
+| [Team](./core-skills.md#team-skills) | 14 | Multi-agent collaborative skills |
+| [Workflow](./core-skills.md#workflow-skills) | 7 | Planning and execution pipeline skills |
+
+## Quick Reference
+
+### Standalone Skills
+
+| Skill | Triggers | Description |
+|-------|----------|-------------|
+| [brainstorm](./core-skills.md#brainstorm) | `brainstorm`, `头脑风暴` | Unified brainstorming with dual-mode operation |
+| [ccw-help](./core-skills.md#ccw-help) | `ccw-help`, `ccw-issue` | Command help system |
+| [memory-capture](./core-skills.md#memory-capture) | `memory capture`, `compact session` | Session compact or quick tips |
+| [memory-manage](./core-skills.md#memory-manage) | `memory manage`, `update claude` | CLAUDE.md updates and docs generation |
+| [issue-manage](./core-skills.md#issue-manage) | `manage issue`, `list issues` | Interactive issue management |
+| [review-code](./core-skills.md#review-code) | `review code`, `code review` | 6-dimensional code review |
+| [review-cycle](./core-skills.md#review-cycle) | `workflow:review-cycle` | Review with automated fix |
+| [skill-generator](./core-skills.md#skill-generator) | `create skill`, `new skill` | Meta-skill for creating skills |
+| [skill-tuning](./core-skills.md#skill-tuning) | `skill tuning`, `tune skill` | Skill diagnosis and optimization |
+| [spec-generator](./core-skills.md#spec-generator) | `generate spec`, `spec generator` | 6-phase specification generation |
+| [software-manual](./core-skills.md#software-manual) | `software manual`, `user guide` | Interactive HTML documentation |
+
+### Team Skills
+
+| Skill | Triggers | Roles | Description |
+|-------|----------|-------|-------------|
+| [team-lifecycle-v4](./core-skills.md#team-lifecycle-v4) | `team lifecycle` | 8 | Full spec/impl/test lifecycle |
+| [team-brainstorm](./core-skills.md#team-brainstorm) | `team brainstorm` | 5 | Multi-angle ideation |
+| [team-frontend](./core-skills.md#team-frontend) | `team frontend` | 6 | Frontend development with UI/UX |
+| [team-issue](./core-skills.md#team-issue) | `team issue` | 6 | Issue resolution pipeline |
+| [team-iterdev](./core-skills.md#team-iterdev) | `team iterdev` | 5 | Generator-critic loop |
+| [team-planex](./core-skills.md#team-planex) | `team planex` | 3 | Plan-and-execute pipeline |
+| [team-quality-assurance](./core-skills.md#team-quality-assurance) | `team qa` | 6 | QA testing workflow |
+| [team-review](./core-skills.md#team-review) | `team-review` | 4 | Code scanning and fix |
+| [team-roadmap-dev](./core-skills.md#team-roadmap-dev) | `team roadmap-dev` | 4 | Roadmap-driven development |
+| [team-tech-debt](./core-skills.md#team-tech-debt) | `tech debt cleanup` | 6 | Tech debt identification |
+| [team-testing](./core-skills.md#team-testing) | `team testing` | 5 | Progressive test coverage |
+| [team-uidesign](./core-skills.md#team-uidesign) | `team uidesign` | 4 | UI design with tokens |
+| [team-ultra-analyze](./core-skills.md#team-ultra-analyze) | `team analyze` | 5 | Deep collaborative analysis |
+
+### Workflow Skills
+
+| Skill | Triggers | Description |
+|-------|----------|-------------|
+| [workflow-plan](./core-skills.md#workflow-plan) | `workflow:plan` | 4-phase planning with verification |
+| [workflow-lite-plan](./core-skills.md#workflow-lite-plan) | `workflow:lite-plan` | Lightweight planning |
+| [workflow-multi-cli-plan](./core-skills.md#workflow-multi-cli-plan) | `workflow:multi-cli-plan` | Multi-CLI collaborative planning |
+| [workflow-execute](./core-skills.md#workflow-execute) | `workflow:execute` | Task execution coordination |
+| [workflow-tdd](./core-skills.md#workflow-tdd) | `workflow:tdd-plan` | TDD with Red-Green-Refactor |
+| [workflow-test-fix](./core-skills.md#workflow-test-fix) | `workflow:test-fix-gen` | Test-fix pipeline |
+| [workflow-skill-designer](./core-skills.md#workflow-skill-designer) | `design workflow skill` | Meta-skill for workflow creation |
+
+## Workflow Combinations
+
+Skills can be combined for powerful workflows. See [Workflow Combinations](./core-skills.md#workflow-combinations) for 15 pre-defined combinations.
+
+### Popular Combinations
+
+#### Full Lifecycle Development
+```bash
+Skill(skill="brainstorm")
+Skill(skill="workflow-plan")
+Skill(skill="workflow-execute")
+Skill(skill="review-cycle")
+```
+
+#### Quick Iteration
+```bash
+Skill(skill="workflow-lite-plan")
+Skill(skill="workflow-execute")
+```
+
+#### Test-Driven Development
+```bash
+Skill(skill="workflow-tdd", args="--mode tdd-plan")
+Skill(skill="workflow-execute")
+Skill(skill="workflow-tdd", args="--mode tdd-verify")
+```
+
+## Using Skills
+
+### CLI Interface
+
+```bash
+# Invoke via ccw command
+ccw --help
+
+# Or use triggers directly
+ccw brainstorm
+ccw team lifecycle
+```
+
+### Programmatic Interface
+
+```javascript
+// Basic usage
+Skill(skill="brainstorm")
+
+// With arguments
+Skill(skill="team-lifecycle-v4", args="Build user authentication")
+
+// With mode selection
+Skill(skill="workflow-plan", args="--mode verify")
+```
+
+## Custom Skills
+
+Create your own skills for team-specific workflows:
+
+### Skill Structure
+
+```
+~/.claude/skills/my-skill/
+├── SKILL.md          # Skill definition
+├── phases/           # Phase files (optional)
+│   ├── phase-1.md
+│   └── phase-2.md
+└── templates/        # Output templates (optional)
+    └── output.md
+```
+
+### Skill Template
+
+```markdown
+---
+name: my-custom-skill
+description: My custom skill for X
+version: 1.0.0
+triggers: [trigger1, trigger2]
+---
+
+# My Custom Skill
+
+## Description
+Detailed description of what this skill does.
+
+## Phases
+1. Phase 1: Description
+2. Phase 2: Description
+
+## Usage
+
+\`\`\`javascript
+Skill(skill="my-custom-skill", args="input")
+\`\`\`
+```
+
+### Best Practices
+
+1. **Single Responsibility**: Each skill should do one thing well
+2. **Clear Triggers**: Define recognizable trigger phrases
+3. **Progressive Phases**: Break complex skills into phases
+4. **Compact Recovery**: Use TodoWrite for progress tracking
+5. **Documentation**: Include usage examples and expected outputs
+
+## Design Patterns
+
+Skills use these proven patterns:
+
+| Pattern | Example |
+|---------|---------|
+| Orchestrator + Workers | team-lifecycle-v4 |
+| Generator-Critic Loop | team-iterdev |
+| Wave Pipeline | team-planex |
+| Red-Green-Refactor | workflow-tdd |
+
+::: info See Also
+- [Core Skills Reference](./core-skills.md) - Detailed skill documentation
+- [Custom Skills](./custom.md) - Skill development guide
+- [CLI Commands](../cli/commands.md) - Command reference
+- [Agents](../agents/builtin.md) - Specialized agents
+:::
--- a/docs/skills/reference.md
+++ b/docs/skills/reference.md
@@ -0,0 +1,168 @@
+# Skills Reference
+
+Quick reference guide for all **32 CCW built-in skills**.
+
+## Core Skills
+
+| Skill | Trigger | Purpose |
+|-------|---------|---------|
+| **brainstorm** | `brainstorm`, `头脑风暴` | Unified brainstorming with dual-mode operation (auto pipeline / single role) |
+| **review-code** | `review code`, `code review`, `审查代码` | Multi-dimensional code review (6 dimensions) |
+| **review-cycle** | `workflow:review-cycle` | Code review + automated fix orchestration |
+| **memory-capture** | `memory capture`, `compact session` | Session compact or quick tips capture |
+| **memory-manage** | `memory manage`, `update claude`, `更新记忆` | CLAUDE.md updates and documentation generation |
+| **spec-generator** | `generate spec`, `create specification` | 6-phase specification generator (brief → PRD → architecture → epics) |
+| **skill-generator** | `create skill`, `new skill` | Meta-skill for creating new Claude Code skills |
+| **skill-tuning** | `skill tuning`, `tune skill` | Universal skill diagnosis and optimization tool |
+| **issue-manage** | `manage issue`, `list issues` | Interactive issue management (CRUD operations) |
+| **ccw-help** | `ccw-help`, `ccw-issue` | CCW command help system |
+| **software-manual** | `software manual`, `user guide` | Generate interactive TiddlyWiki-style HTML manuals |
+
+## Workflow Skills
+
+| Skill | Trigger | Purpose |
+|-------|---------|---------|
+| **workflow-plan** | `workflow:plan`, `workflow:plan-verify`, `workflow:replan` | 4-phase planning workflow with verification and interactive replanning |
+| **workflow-lite-plan** | `workflow:lite-plan`, `workflow:lite-execute` | Lightweight planning and execution skill |
+| **workflow-multi-cli-plan** | `workflow:multi-cli-plan` | Multi-CLI collaborative planning with ACE context engine |
+| **workflow-execute** | `workflow:execute` | Coordinate agent execution for workflow tasks |
+| **workflow-tdd** | `workflow:tdd-plan`, `workflow:tdd-verify` | TDD workflow with Red-Green-Refactor task chain |
+| **workflow-test-fix** | `workflow:test-fix-gen`, `workflow:test-cycle-execute` | Unified test-fix pipeline with adaptive strategy |
+| **workflow-skill-designer** | `design workflow skill`, `create workflow skill` | Meta-skill for designing orchestrator+phases structured workflow skills |
+
+## Team Skills
+
+| Skill | Trigger | Roles | Purpose |
+|-------|---------|-------|---------|
+| **team-lifecycle-v4** | `team lifecycle` | 8 | Full spec/impl/test lifecycle team |
+| **team-lifecycle-v5** | `team lifecycle v5` | variable | Latest lifecycle team (team-worker architecture) |
+| **team-coordinate** | `team coordinate` | variable | Generic team coordination (legacy) |
+| **team-coordinate-v2** | - | variable | team-worker architecture coordination |
+| **team-executor** | `team executor` | variable | Lightweight session execution |
+| **team-executor-v2** | - | variable | team-worker architecture execution |
+| **team-planex** | `team planex` | 3 | Plan-and-execute wave pipeline |
+| **team-iterdev** | `team iterdev` | 5 | Generator-critic loop iterative development |
+| **team-issue** | `team issue` | 6 | Issue resolution pipeline |
+| **team-testing** | `team testing` | 5 | Progressive test coverage team |
+| **team-quality-assurance** | `team qa`, `team quality-assurance` | 6 | QA closed-loop workflow |
+| **team-brainstorm** | `team brainstorm` | 5 | Multi-role collaborative brainstorming |
+| **team-uidesign** | `team ui design` | 4 | UI design team with design token system |
+| **team-frontend** | `team frontend` | 6 | Frontend development with UI/UX integration |
+| **team-review** | `team-review` | 4 | Code scanning and automated fix |
+| **team-roadmap-dev** | `team roadmap-dev` | 4 | Roadmap-driven development |
+| **team-tech-debt** | `tech debt cleanup`, `技术债务` | 6 | Tech debt identification and cleanup |
+| **team-ultra-analyze** | `team ultra-analyze`, `team analyze` | 5 | Deep collaborative analysis |
+
+## Command Generation Skills
+
+| Skill | Trigger | Purpose |
+|-------|---------|---------|
+| **command-generator** | `generate command` | Command file generation meta-skill |
+
+## Skill Categories Summary
+
+| Category | Count | Description |
+|----------|-------|-------------|
+| Core Skills | 11 | Single-purpose skills for specific tasks |
+| Workflow Skills | 7 | Planning and execution pipeline skills |
+| Team Skills | 17+ | Multi-agent collaborative skills |
+| Command Gen Skills | 1 | Command file generation |
+| **Total** | **36+** | |
+
+## Usage
+
+### Basic Invocation
+
+```javascript
+Skill(skill="brainstorm")
+Skill(skill="team-lifecycle-v4", args="Build user authentication system")
+Skill(skill="workflow-plan", args="--mode verify")
+```
+
+### CLI Invocation
+
+```bash
+# Via /ccw orchestrator
+/ccw "brainstorm: user authentication flow"
+/ccw "team planex: OAuth2 implementation"
+
+# Direct skill triggers (in some contexts)
+workflow:plan
+team lifecycle
+```
+
+## Trigger Keywords
+
+| Keyword | Skill |
+|---------|-------|
+| `brainstorm`, `头脑风暴` | brainstorm |
+| `review code`, `code review`, `审查代码` | review-code |
+| `workflow:review-cycle` | review-cycle |
+| `workflow:plan` | workflow-plan |
+| `workflow:lite-plan` | workflow-lite-plan |
+| `workflow:multi-cli-plan` | workflow-multi-cli-plan |
+| `workflow:execute` | workflow-execute |
+| `workflow:tdd-plan` | workflow-tdd |
+| `workflow:test-fix-gen` | workflow-test-fix |
+| `team lifecycle` | team-lifecycle-v4 (or v5) |
+| `team planex` | team-planex |
+| `team iterdev` | team-iterdev |
+| `team issue` | team-issue |
+| `team testing` | team-testing |
+| `team qa`, `team quality-assurance` | team-quality-assurance |
+| `team brainstorm` | team-brainstorm |
+| `team ui design`, `team uidesign` | team-uidesign |
+| `team frontend` | team-frontend |
+| `team-review` | team-review |
+| `team roadmap-dev` | team-roadmap-dev |
+| `tech debt cleanup`, `技术债务` | team-tech-debt |
+| `team analyze` | team-ultra-analyze |
+| `memory capture`, `compact session`, `记录`, `压缩会话` | memory-capture |
+| `memory manage`, `update claude`, `更新记忆`, `生成文档` | memory-manage |
+| `generate spec`, `create specification`, `spec generator` | spec-generator |
+| `create skill`, `new skill` | skill-generator |
+| `skill tuning`, `tune skill`, `skill diagnosis` | skill-tuning |
+| `manage issue`, `list issues`, `edit issue` | issue-manage |
+| `software manual`, `user guide`, `generate manual` | software-manual |
+
+## Team Skill Architecture
+
+### Version History
+
+| Version | Architecture | Status |
+|---------|-------------|--------|
+| v2 | Legacy | Obsolete |
+| v3 | 3-phase lifecycle | Legacy |
+| v4 | 5-phase lifecycle with inline discuss | Stable |
+| **v5** | **team-worker architecture** | **Latest** |
+
+### v5 Team Worker Roles
+
+The latest team-lifecycle-v5 uses the team-worker agent with dynamic role assignment:
+
+| Role | Prefix | Phase |
+|------|--------|-------|
+| doc-analyst | ANALYSIS | Requirements analysis |
+| doc-writer | DRAFT | Document creation |
+| planner | PLAN | Implementation planning |
+| executor | IMPL | Code implementation |
+| tester | TEST | Testing and QA |
+| reviewer | REVIEW | Code review |
+
+## Design Patterns
+
+| Pattern | Skills Using It |
+|---------|----------------|
+| Orchestrator + Workers | team-lifecycle-v4, team-testing, team-quality-assurance |
+| Generator-Critic Loop | team-iterdev |
+| Wave Pipeline | team-planex |
+| Red-Green-Refactor | workflow-tdd |
+| Pure Orchestrator | workflow-plan, workflow-lite-plan |
+| Progressive Phase Loading | workflow-plan, workflow-tdd, team-lifecycle-v5 |
+
+::: info See Also
+- [Core Skills Detail](./core-skills.md) - Detailed skill documentation
+- [Custom Skills](./custom.md) - Create your own skills
+- [CLI Commands](../cli/commands.md) - Command reference
+- [Team Workflows](../workflows/teams.md) - Team workflow patterns
+:::