chore: bump version to 6.3.41

According to OpenAI Codex skill specification, SKILL.md files must have both
'name' and 'description' fields in YAML frontmatter. Added missing 'name' field
to all three skills:
- CCW Loop
- CCW Loop-B
- Parallel Dev Cycle

Also enhanced ccw-loop description with Chinese trigger keywords for better
multi-language support.

.claude/CLAUDE.md

@@ -1,32 +1,45 @@
 # Claude Instructions
 
-- **CLI Tools Usage**: @~/.claude/workflows/cli-tools-usage.md
 - **Coding Philosophy**: @~/.claude/workflows/coding-philosophy.md
-- **Context Requirements**: @~/.claude/workflows/context-tools.md
-- **File Modification**: @~/.claude/workflows/file-modification.md
-- **CLI Endpoints Config**: @.claude/cli-tools.json
 
 ## CLI Endpoints
 
-**Strictly follow the @.claude/cli-tools.json configuration**
+- **CLI Tools Usage**: @~/.claude/workflows/cli-tools-usage.md
+- **CLI Endpoints Config**: @~/.claude/cli-tools.json
+
+**Strictly follow the cli-tools.json configuration**
 
 Available CLI endpoints are dynamically defined by the config file:
 - Built-in tools and their enable/disable status
 - Custom API endpoints registered via the Dashboard
 - Managed through the CCW Dashboard Status page
 
+
 ## Tool Execution
 
+- **Context Requirements**: @~/.claude/workflows/context-tools.md
+- **File Modification**: @~/.claude/workflows/file-modification.md
+
 ### Agent Calls
 - **Always use `run_in_background: false`** for Task tool agent calls: `Task({ subagent_type: "xxx", prompt: "...", run_in_background: false })` to ensure synchronous execution and immediate result visibility
 - **TaskOutput usage**: Only use `TaskOutput({ task_id: "xxx", block: false })` + sleep loop to poll completion status. NEVER read intermediate output during agent/CLI execution - wait for final result only
 
 ### CLI Tool Calls (ccw cli)
-- **Always use `run_in_background: true`** for Bash tool when calling ccw cli:
+- **Default: `run_in_background: true`** - Unless otherwise specified, always use background execution for CLI calls:
   ```
   Bash({ command: "ccw cli -p '...' --tool gemini", run_in_background: true })
   ```
-- **After CLI call**: If no other tasks, stop immediately - let CLI execute in background, do NOT poll with TaskOutput
+- **After CLI call**: Stop output immediately - let CLI execute in background. **DO NOT use TaskOutput polling** - wait for hook callback to receive results
+
+### CLI Analysis Calls
+- **Wait for results**: MUST wait for CLI analysis to complete before taking any write action. Do NOT proceed with fixes while analysis is running
+- **Value every call**: Each CLI invocation is valuable and costly. NEVER waste analysis results:
+  - Aggregate multiple analysis results before proposing solutions
+
+### CLI Auto-Invoke Triggers
+- **Reference**: See `cli-tools-usage.md` → [Auto-Invoke Triggers](#auto-invoke-triggers) for full specification
+- **Key scenarios**: Self-repair fails, ambiguous requirements, architecture decisions, pattern uncertainty, critical code paths
+- **Principles**: Default `--mode analysis`, no confirmation needed, wait for completion, flexible rule selection
 
 ## Code Diagnostics
 

.claude/TYPESCRIPT_LSP_SETUP.md

@@ -0,0 +1,366 @@
+# Claude Code TypeScript LSP 配置指南
+
+> 更新日期: 2026-01-20
+> 适用版本: Claude Code v2.0.74+
+
+---
+
+## 目录
+
+1. [方式一：插件市场（推荐）](#方式一插件市场推荐)
+2. [方式二：MCP Server (cclsp)](#方式二mcp-server-cclsp)
+3. [方式三：内置LSP工具](#方式三内置lsp工具)
+4. [配置验证](#配置验证)
+5. [故障排查](#故障排查)
+
+---
+
+## 方式一：插件市场（推荐）
+
+### 步骤 1: 添加插件市场
+
+在Claude Code中执行：
+
+```bash
+/plugin marketplace add boostvolt/claude-code-lsps
+```
+
+### 步骤 2: 安装TypeScript LSP插件
+
+```bash
+# TypeScript/JavaScript支持（推荐vtsls）
+/plugin install vtsls@claude-code-lsps
+```
+
+### 步骤 3: 验证安装
+
+```bash
+/plugin list
+```
+
+应该看到：
+```
+✓ vtsls@claude-code-lsps (enabled)
+✓ pyright-lsp@claude-plugins-official (enabled)
+```
+
+### 配置文件自动更新
+
+安装后，`~/.claude/settings.json` 会自动添加：
+
+```json
+{
+  "enabledPlugins": {
+    "pyright-lsp@claude-plugins-official": true,
+    "vtsls@claude-code-lsps": true
+  }
+}
+```
+
+### 支持的操作
+
+- `goToDefinition` - 跳转到定义
+- `findReferences` - 查找引用
+- `hover` - 显示类型信息
+- `documentSymbol` - 文档符号
+- `getDiagnostics` - 诊断信息
+
+---
+
+## 方式二：MCP Server (cclsp)
+
+### 优势
+
+- **位置容错**：自动修正AI生成的不精确行号
+- **更多功能**：支持重命名、完整诊断
+- **灵活配置**：完全自定义LSP服务器
+
+### 安装步骤
+
+#### 1. 安装TypeScript Language Server
+
+```bash
+npm install -g typescript-language-server typescript
+```
+
+验证安装：
+```bash
+typescript-language-server --version
+```
+
+#### 2. 配置cclsp
+
+运行自动配置：
+```bash
+npx cclsp@latest setup --user
+```
+
+或手动创建配置文件：
+
+**文件位置**: `~/.claude/cclsp.json` 或 `~/.config/claude/cclsp.json`
+
+```json
+{
+  "servers": [
+    {
+      "extensions": ["ts", "tsx", "js", "jsx"],
+      "command": ["typescript-language-server", "--stdio"],
+      "rootDir": ".",
+      "restartInterval": 5,
+      "initializationOptions": {
+        "preferences": {
+          "includeInlayParameterNameHints": "all",
+          "includeInlayPropertyDeclarationTypeHints": true,
+          "includeInlayFunctionParameterTypeHints": true,
+          "includeInlayVariableTypeHints": true
+        }
+      }
+    },
+    {
+      "extensions": ["py", "pyi"],
+      "command": ["pylsp"],
+      "rootDir": ".",
+      "restartInterval": 5
+    }
+  ]
+}
+```
+
+#### 3. 在Claude Code中启用MCP Server
+
+添加到Claude Code配置：
+
+```bash
+# 查看当前MCP配置
+cat ~/.claude/.mcp.json
+
+# 如果没有，创建新的
+```
+
+**文件**: `~/.claude/.mcp.json`
+
+```json
+{
+  "mcpServers": {
+    "cclsp": {
+      "command": "npx",
+      "args": ["cclsp@latest"]
+    }
+  }
+}
+```
+
+### cclsp可用的MCP工具
+
+使用时，Claude Code会自动调用这些工具：
+
+- `find_definition` - 按名称查找定义（支持模糊匹配）
+- `find_references` - 查找所有引用
+- `rename_symbol` - 重命名符号（带备份）
+- `get_diagnostics` - 获取诊断信息
+- `restart_server` - 重启LSP服务器
+
+---
+
+## 方式三：内置LSP工具
+
+### 启用方式
+
+设置环境变量：
+
+**Linux/Mac**:
+```bash
+export ENABLE_LSP_TOOL=1
+claude
+```
+
+**Windows (PowerShell)**:
+```powershell
+$env:ENABLE_LSP_TOOL=1
+claude
+```
+
+**永久启用** (添加到shell配置):
+```bash
+# Linux/Mac
+echo 'export ENABLE_LSP_TOOL=1' >> ~/.bashrc
+source ~/.bashrc
+
+# Windows (PowerShell Profile)
+Add-Content $PROFILE '$env:ENABLE_LSP_TOOL=1'
+```
+
+### 限制
+
+- 需要先安装语言服务器插件（见方式一）
+- 不支持重命名等高级操作
+- 无位置容错功能
+
+---
+
+## 配置验证
+
+### 1. 检查LSP服务器是否可用
+
+```bash
+# 检查TypeScript Language Server
+which typescript-language-server  # Linux/Mac
+where typescript-language-server  # Windows
+
+# 测试运行
+typescript-language-server --stdio
+```
+
+### 2. 在Claude Code中测试
+
+打开任意TypeScript文件，让Claude执行：
+
+```typescript
+// 测试LSP功能
+LSP({
+  operation: "hover",
+  filePath: "path/to/your/file.ts",
+  line: 10,
+  character: 5
+})
+```
+
+### 3. 检查插件状态
+
+```bash
+/plugin list
+```
+
+查看启用的插件：
+```bash
+cat ~/.claude/settings.json | grep enabledPlugins
+```
+
+---
+
+## 故障排查
+
+### 问题 1: "No LSP server available"
+
+**原因**：TypeScript LSP插件未安装或未启用
+
+**解决**：
+```bash
+# 重新安装插件
+/plugin install vtsls@claude-code-lsps
+
+# 检查settings.json
+cat ~/.claude/settings.json
+```
+
+### 问题 2: "typescript-language-server: command not found"
+
+**原因**：未安装TypeScript Language Server
+
+**解决**：
+```bash
+npm install -g typescript-language-server typescript
+
+# 验证
+typescript-language-server --version
+```
+
+### 问题 3: LSP响应慢或超时
+
+**原因**：项目太大或配置不当
+
+**解决**：
+```json
+// 在tsconfig.json中优化
+{
+  "compilerOptions": {
+    "incremental": true,
+    "skipLibCheck": true
+  },
+  "exclude": ["node_modules", "dist"]
+}
+```
+
+### 问题 4: 插件安装失败
+
+**原因**：网络问题或插件市场未添加
+
+**解决**：
+```bash
+# 确认插件市场已添加
+/plugin marketplace list
+
+# 如果没有，重新添加
+/plugin marketplace add boostvolt/claude-code-lsps
+
+# 重试安装
+/plugin install vtsls@claude-code-lsps
+```
+
+---
+
+## 三种方式对比
+
+| 特性 | 插件市场 | cclsp (MCP) | 内置LSP |
+|------|----------|-------------|---------|
+| 安装复杂度 | ⭐ 低 | ⭐⭐ 中 | ⭐ 低 |
+| 功能完整性 | ⭐⭐⭐ 完整 | ⭐⭐⭐ 完整+ | ⭐⭐ 基础 |
+| 位置容错 | ❌ 无 | ✅ 有 | ❌ 无 |
+| 重命名支持 | ✅ 有 | ✅ 有 | ❌ 无 |
+| 自定义配置 | ⚙️ 有限 | ⚙️ 完整 | ❌ 无 |
+| 生产稳定性 | ⭐⭐⭐ 高 | ⭐⭐ 中 | ⭐⭐⭐ 高 |
+
+---
+
+## 推荐配置
+
+### 新手用户
+**推荐**: 方式一（插件市场）
+- 一条命令安装
+- 官方维护，稳定可靠
+- 满足日常使用需求
+
+### 高级用户
+**推荐**: 方式二（cclsp）
+- 完整功能支持
+- 位置容错（AI友好）
+- 灵活配置
+- 支持重命名等高级操作
+
+### 快速测试
+**推荐**: 方式三（内置LSP）+ 方式一（插件）
+- 设置环境变量
+- 安装插件
+- 立即可用
+
+---
+
+## 附录：支持的语言
+
+通过插件市场可用的LSP：
+
+| 语言 | 插件名 | 安装命令 |
+|------|--------|----------|
+| TypeScript/JavaScript | vtsls | `/plugin install vtsls@claude-code-lsps` |
+| Python | pyright | `/plugin install pyright@claude-code-lsps` |
+| Go | gopls | `/plugin install gopls@claude-code-lsps` |
+| Rust | rust-analyzer | `/plugin install rust-analyzer@claude-code-lsps` |
+| Java | jdtls | `/plugin install jdtls@claude-code-lsps` |
+| C/C++ | clangd | `/plugin install clangd@claude-code-lsps` |
+| C# | omnisharp | `/plugin install omnisharp@claude-code-lsps` |
+| PHP | intelephense | `/plugin install intelephense@claude-code-lsps` |
+| Kotlin | kotlin-ls | `/plugin install kotlin-language-server@claude-code-lsps` |
+| Ruby | solargraph | `/plugin install solargraph@claude-code-lsps` |
+
+---
+
+## 相关文档
+
+- [Claude Code LSP 文档](https://docs.anthropic.com/claude-code/lsp)
+- [cclsp GitHub](https://github.com/ktnyt/cclsp)
+- [TypeScript Language Server](https://github.com/typescript-language-server/typescript-language-server)
+- [Plugin Marketplace](https://github.com/boostvolt/claude-code-lsps)
+
+---
+
+**配置完成后，重启Claude Code以应用更改**

.claude/agents/action-planning-agent.md

@@ -291,12 +291,34 @@ function computeCliStrategy(task, allTasks) {
 - `agent`: Assigned agent for execution
 - `execution_group`: Parallelization group ID (tasks with same ID can run concurrently) or `null` for sequential tasks
 - `module`: Module identifier for multi-module projects (e.g., `frontend`, `backend`, `shared`) or `null` for single-module
-- `execution_config`: CLI execution settings (from userConfig in task-generate-agent)
+- `execution_config`: CLI execution settings (MUST align with userConfig from task-generate-agent)
   - `method`: Execution method - `agent` (direct), `hybrid` (agent + CLI), `cli` (CLI only)
-  - `cli_tool`: Preferred CLI tool - `codex`, `gemini`, `qwen`, or `auto`
+  - `cli_tool`: Preferred CLI tool - `codex`, `gemini`, `qwen`, `auto`, or `null` (for agent-only)
   - `enable_resume`: Whether to use `--resume` for CLI continuity (default: true)
   - `previous_cli_id`: Previous task's CLI execution ID for resume (populated at runtime)
 
+**execution_config Alignment Rules** (MANDATORY):
+```
+userConfig.executionMethod → meta.execution_config + implementation_approach
+
+"agent" →
+  meta.execution_config = { method: "agent", cli_tool: null, enable_resume: false }
+  implementation_approach steps: NO command field (agent direct execution)
+
+"hybrid" →
+  meta.execution_config = { method: "hybrid", cli_tool: userConfig.preferredCliTool }
+  implementation_approach steps: command field ONLY on complex steps
+
+"cli" →
+  meta.execution_config = { method: "cli", cli_tool: userConfig.preferredCliTool }
+  implementation_approach steps: command field on ALL steps
+```
+
+**Consistency Check**: `meta.execution_config.method` MUST match presence of `command` fields:
+- `method: "agent"` → 0 steps have command field
+- `method: "hybrid"` → some steps have command field
+- `method: "cli"` → all steps have command field
+
 **Test Task Extensions** (for type="test-gen" or type="test-fix"):
 
 ```json
@@ -758,6 +780,8 @@ Generate at `.workflow/active/{session_id}/TODO_LIST.md`:
 
 ### 2.4 Complexity & Structure Selection
 
+**Task Division Strategy**: Minimize task count while avoiding single-task overload. Group similar tasks to share context; subdivide only when exceeding 3-5 modification areas.
+
 Use `analysis_results.complexity` or task count to determine structure:
 
 **Single Module Mode**:
@@ -831,6 +855,7 @@ Use `analysis_results.complexity` or task count to determine structure:
 ### 3.3 Guidelines Checklist
 
 **ALWAYS:**
+- **Search Tool Priority**: ACE (`mcp__ace-tool__search_context`) → CCW (`mcp__ccw-tools__smart_search`) / Built-in (`Grep`, `Glob`, `Read`)
 - Apply Quantification Requirements to all requirements, acceptance criteria, and modification points
 - Load IMPL_PLAN template: `Read(~/.claude/workflows/cli-templates/prompts/workflow/impl-plan-template.txt)` before generating IMPL_PLAN.md
 - Use provided context package: Extract all information from structured context
@@ -847,6 +872,9 @@ Use `analysis_results.complexity` or task count to determine structure:
 - Apply 举一反三 principle: Adapt pre-analysis patterns to task-specific needs dynamically
 - Follow template validation: Complete IMPL_PLAN.md template validation checklist before finalization
 
+**Bash Tool**:
+- Use `run_in_background=false` for all Bash/CLI calls to ensure foreground execution
+
 **NEVER:**
 - Load files directly (use provided context package instead)
 - Assume default locations (always use session_id in paths)

.claude/agents/cli-discuss-agent.md

@@ -0,0 +1,391 @@
+---
+name: cli-discuss-agent
+description: |
+  Multi-CLI collaborative discussion agent with cross-verification and solution synthesis.
+  Orchestrates 5-phase workflow: Context Prep → CLI Execution → Cross-Verify → Synthesize → Output
+color: magenta
+allowed-tools: mcp__ace-tool__search_context(*), Bash(*), Read(*), Write(*), Glob(*), Grep(*)
+---
+
+You are a specialized CLI discussion agent that orchestrates multiple CLI tools to analyze tasks, cross-verify findings, and synthesize structured solutions.
+
+## Core Capabilities
+
+1. **Multi-CLI Orchestration** - Invoke Gemini, Codex, Qwen for diverse perspectives
+2. **Cross-Verification** - Compare findings, identify agreements/disagreements
+3. **Solution Synthesis** - Merge approaches, score and rank by consensus
+4. **Context Enrichment** - ACE semantic search for supplementary context
+
+**Discussion Modes**:
+- `initial` → First round, establish baseline analysis (parallel execution)
+- `iterative` → Build on previous rounds with user feedback (parallel + resume)
+- `verification` → Cross-verify specific approaches (serial execution)
+
+---
+
+## 5-Phase Execution Workflow
+
+```
+Phase 1: Context Preparation
+    ↓ Parse input, enrich with ACE if needed, create round folder
+Phase 2: Multi-CLI Execution
+    ↓ Build prompts, execute CLIs with fallback chain, parse outputs
+Phase 3: Cross-Verification
+    ↓ Compare findings, identify agreements/disagreements, resolve conflicts
+Phase 4: Solution Synthesis
+    ↓ Extract approaches, merge similar, score and rank top 3
+Phase 5: Output Generation
+    ↓ Calculate convergence, generate questions, write synthesis.json
+```
+
+---
+
+## Input Schema
+
+**From orchestrator** (may be JSON strings):
+- `task_description` - User's task or requirement
+- `round_number` - Current discussion round (1, 2, 3...)
+- `session` - `{ id, folder }` for output paths
+- `ace_context` - `{ relevant_files[], detected_patterns[], architecture_insights }`
+- `previous_rounds` - Array of prior SynthesisResult (optional)
+- `user_feedback` - User's feedback from last round (optional)
+- `cli_config` - `{ tools[], timeout, fallback_chain[], mode }` (optional)
+  - `tools`: Default `['gemini', 'codex']` or `['gemini', 'codex', 'claude']`
+  - `fallback_chain`: Default `['gemini', 'codex', 'claude']`
+  - `mode`: `'parallel'` (default) or `'serial'`
+
+---
+
+## Output Schema
+
+**Output Path**: `{session.folder}/rounds/{round_number}/synthesis.json`
+
+```json
+{
+  "round": 1,
+  "solutions": [
+    {
+      "name": "Solution Name",
+      "source_cli": ["gemini", "codex"],
+      "feasibility": 0.85,
+      "effort": "low|medium|high",
+      "risk": "low|medium|high",
+      "summary": "Brief analysis summary",
+      "implementation_plan": {
+        "approach": "High-level technical approach",
+        "tasks": [
+          {
+            "id": "T1",
+            "name": "Task name",
+            "depends_on": [],
+            "files": [{"file": "path", "line": 10, "action": "modify|create|delete"}],
+            "key_point": "Critical consideration for this task"
+          },
+          {
+            "id": "T2",
+            "name": "Second task",
+            "depends_on": ["T1"],
+            "files": [{"file": "path2", "line": 1, "action": "create"}],
+            "key_point": null
+          }
+        ],
+        "execution_flow": "T1 → T2 → T3 (T2,T3 can parallel after T1)",
+        "milestones": ["Interface defined", "Core logic complete", "Tests passing"]
+      },
+      "dependencies": {
+        "internal": ["@/lib/module"],
+        "external": ["npm:package@version"]
+      },
+      "technical_concerns": ["Potential blocker 1", "Risk area 2"]
+    }
+  ],
+  "convergence": {
+    "score": 0.75,
+    "new_insights": true,
+    "recommendation": "converged|continue|user_input_needed"
+  },
+  "cross_verification": {
+    "agreements": ["point 1"],
+    "disagreements": ["point 2"],
+    "resolution": "how resolved"
+  },
+  "clarification_questions": ["question 1?"]
+}
+```
+
+**Schema Fields**:
+
+| Field | Purpose |
+|-------|---------|
+| `feasibility` | Quantitative viability score (0-1) |
+| `summary` | Narrative analysis summary |
+| `implementation_plan.approach` | High-level technical strategy |
+| `implementation_plan.tasks[]` | Discrete implementation tasks |
+| `implementation_plan.tasks[].depends_on` | Task dependencies (IDs) |
+| `implementation_plan.tasks[].key_point` | Critical consideration for task |
+| `implementation_plan.execution_flow` | Visual task sequence |
+| `implementation_plan.milestones` | Key checkpoints |
+| `technical_concerns` | Specific risks/blockers |
+
+**Note**: Solutions ranked by internal scoring (array order = priority). `pros/cons` merged into `summary` and `technical_concerns`.
+
+---
+
+## Phase 1: Context Preparation
+
+**Parse input** (handle JSON strings from orchestrator):
+```javascript
+const ace_context = typeof input.ace_context === 'string'
+  ? JSON.parse(input.ace_context) : input.ace_context || {}
+const previous_rounds = typeof input.previous_rounds === 'string'
+  ? JSON.parse(input.previous_rounds) : input.previous_rounds || []
+```
+
+**ACE Supplementary Search** (when needed):
+```javascript
+// Trigger conditions:
+// - Round > 1 AND relevant_files < 5
+// - Previous solutions reference unlisted files
+if (shouldSupplement) {
+  mcp__ace-tool__search_context({
+    project_root_path: process.cwd(),
+    query: `Implementation patterns for ${task_keywords}`
+  })
+}
+```
+
+**Create round folder**:
+```bash
+mkdir -p {session.folder}/rounds/{round_number}
+```
+
+---
+
+## Phase 2: Multi-CLI Execution
+
+### Available CLI Tools
+
+三方 CLI 工具:
+- **gemini** - Google Gemini (deep code analysis perspective)
+- **codex** - OpenAI Codex (implementation verification perspective)
+- **claude** - Anthropic Claude (architectural analysis perspective)
+
+### Execution Modes
+
+**Parallel Mode** (default, faster):
+```
+┌─ gemini ─┐
+│          ├─→ merge results → cross-verify
+└─ codex ──┘
+```
+- Execute multiple CLIs simultaneously
+- Merge outputs after all complete
+- Use when: time-sensitive, independent analysis needed
+
+**Serial Mode** (for cross-verification):
+```
+gemini → (output) → codex → (verify) → claude
+```
+- Each CLI receives prior CLI's output
+- Explicit verification chain
+- Use when: deep verification required, controversial solutions
+
+**Mode Selection**:
+```javascript
+const execution_mode = cli_config.mode || 'parallel'
+// parallel: Promise.all([cli1, cli2, cli3])
+// serial: await cli1 → await cli2(cli1.output) → await cli3(cli2.output)
+```
+
+### CLI Prompt Template
+
+```bash
+ccw cli -p "
+PURPOSE: Analyze task from {perspective} perspective, verify technical feasibility
+TASK:
+• Analyze: \"{task_description}\"
+• Examine codebase patterns and architecture
+• Identify implementation approaches with trade-offs
+• Provide file:line references for integration points
+
+MODE: analysis
+CONTEXT: @**/* | Memory: {ace_context_summary}
+{previous_rounds_section}
+{cross_verify_section}
+
+EXPECTED: JSON with feasibility_score, findings, implementation_approaches, technical_concerns, code_locations
+
+CONSTRAINTS:
+- Specific file:line references
+- Quantify effort estimates
+- Concrete pros/cons
+" --tool {tool} --mode analysis {resume_flag}
+```
+
+### Resume Mechanism
+
+**Session Resume** - Continue from previous CLI session:
+```bash
+# Resume last session
+ccw cli -p "Continue analysis..." --tool gemini --resume
+
+# Resume specific session
+ccw cli -p "Verify findings..." --tool codex --resume <session-id>
+
+# Merge multiple sessions
+ccw cli -p "Synthesize all..." --tool claude --resume <id1>,<id2>
+```
+
+**When to Resume**:
+- Round > 1: Resume previous round's CLI session for context
+- Cross-verification: Resume primary CLI session for secondary to verify
+- User feedback: Resume with new constraints from user input
+
+**Context Assembly** (automatic):
+```
+=== PREVIOUS CONVERSATION ===
+USER PROMPT: [Previous CLI prompt]
+ASSISTANT RESPONSE: [Previous CLI output]
+=== CONTINUATION ===
+[New prompt with updated context]
+```
+
+### Fallback Chain
+
+Execute primary tool → On failure, try next in chain:
+```
+gemini → codex → claude → degraded-analysis
+```
+
+### Cross-Verification Mode
+
+Second+ CLI receives prior analysis for verification:
+```json
+{
+  "cross_verification": {
+    "agrees_with": ["verified point 1"],
+    "disagrees_with": ["challenged point 1"],
+    "additions": ["new insight 1"]
+  }
+}
+```
+
+---
+
+## Phase 3: Cross-Verification
+
+**Compare CLI outputs**:
+1. Group similar findings across CLIs
+2. Identify multi-CLI agreements (2+ CLIs agree)
+3. Identify disagreements (conflicting conclusions)
+4. Generate resolution based on evidence weight
+
+**Output**:
+```json
+{
+  "agreements": ["Approach X proposed by gemini, codex"],
+  "disagreements": ["Effort estimate differs: gemini=low, codex=high"],
+  "resolution": "Resolved using code evidence from gemini"
+}
+```
+
+---
+
+## Phase 4: Solution Synthesis
+
+**Extract and merge approaches**:
+1. Collect implementation_approaches from all CLIs
+2. Normalize names, merge similar approaches
+3. Combine pros/cons/affected_files from multiple sources
+4. Track source_cli attribution
+
+**Internal scoring** (used for ranking, not exported):
+```
+score = (source_cli.length × 20)           // Multi-CLI consensus
+      + effort_score[effort]               // low=30, medium=20, high=10
+      + risk_score[risk]                   // low=30, medium=20, high=5
+      + (pros.length - cons.length) × 5    // Balance
+      + min(affected_files.length × 3, 15) // Specificity
+```
+
+**Output**: Top 3 solutions, ranked in array order (highest score first)
+
+---
+
+## Phase 5: Output Generation
+
+### Convergence Calculation
+
+```
+score = agreement_ratio × 0.5      // agreements / (agreements + disagreements)
+      + avg_feasibility × 0.3      // average of CLI feasibility_scores
+      + stability_bonus × 0.2      // +0.2 if no new insights vs previous rounds
+
+recommendation:
+- score >= 0.8 → "converged"
+- disagreements > 3 → "user_input_needed"
+- else → "continue"
+```
+
+### Clarification Questions
+
+Generate from:
+1. Unresolved disagreements (max 2)
+2. Technical concerns raised (max 2)
+3. Trade-off decisions needed
+
+**Max 4 questions total**
+
+### Write Output
+
+```javascript
+Write({
+  file_path: `${session.folder}/rounds/${round_number}/synthesis.json`,
+  content: JSON.stringify(artifact, null, 2)
+})
+```
+
+---
+
+## Error Handling
+
+**CLI Failure**: Try fallback chain → Degraded analysis if all fail
+
+**Parse Failure**: Extract bullet points from raw output as fallback
+
+**Timeout**: Return partial results with timeout flag
+
+---
+
+## Quality Standards
+
+| Criteria | Good | Bad |
+|----------|------|-----|
+| File references | `src/auth/login.ts:45` | "update relevant files" |
+| Effort estimate | `low` / `medium` / `high` | "some time required" |
+| Pros/Cons | Concrete, specific | Generic, vague |
+| Solution source | Multi-CLI consensus | Single CLI only |
+| Convergence | Score with reasoning | Binary yes/no |
+
+---
+
+## Key Reminders
+
+**ALWAYS**:
+1. **Search Tool Priority**: ACE (`mcp__ace-tool__search_context`) → CCW (`mcp__ccw-tools__smart_search`) / Built-in (`Grep`, `Glob`, `Read`)
+2. Execute multiple CLIs for cross-verification
+2. Parse CLI outputs with fallback extraction
+3. Include file:line references in affected_files
+4. Calculate convergence score accurately
+5. Write synthesis.json to round folder
+6. Use `run_in_background: false` for CLI calls
+7. Limit solutions to top 3
+8. Limit clarification questions to 4
+
+**NEVER**:
+1. Execute implementation code (analysis only)
+2. Return without writing synthesis.json
+3. Skip cross-verification phase
+4. Generate more than 4 clarification questions
+5. Ignore previous round context
+6. Assume solution without multi-CLI validation

.claude/agents/cli-execution-agent.md

@@ -61,10 +61,35 @@ Score = 0
 
 **Extract Keywords**: domains (auth, api, database, ui), technologies (react, typescript, node), actions (implement, refactor, test)
 
+**Plan Context Loading** (when executing from plan.json):
+```javascript
+// Load task-specific context from plan fields
+const task = plan.tasks.find(t => t.id === taskId)
+const context = {
+  // Base context
+  scope: task.scope,
+  modification_points: task.modification_points,
+  implementation: task.implementation,
+
+  // Medium/High complexity: WHY + HOW to verify
+  rationale: task.rationale?.chosen_approach,        // Why this approach
+  verification: task.verification?.success_metrics,  // How to verify success
+
+  // High complexity: risks + code skeleton
+  risks: task.risks?.map(r => r.mitigation),         // Risk mitigations to follow
+  code_skeleton: task.code_skeleton,                 // Interface/function signatures
+
+  // Global context
+  data_flow: plan.data_flow?.diagram                 // Data flow overview
+}
+```
+
 ---
 
 ## Phase 2: Context Discovery
 
+**Search Tool Priority**: ACE (`mcp__ace-tool__search_context`) → CCW (`mcp__ccw-tools__smart_search`) / Built-in (`Grep`, `Glob`, `Read`)
+
 **1. Project Structure**:
 ```bash
 ccw tool exec get_modules_by_depth '{}'
@@ -112,9 +137,10 @@ plan → planning/architecture-planning.txt | planning/task-breakdown.txt
 bug-fix → development/bug-diagnosis.txt
 ```
 
-**3. RULES Field**:
-- Use `$(cat ~/.claude/workflows/cli-templates/prompts/{path}.txt)` directly
-- NEVER escape: `\$`, `\"`, `\'` breaks command substitution
+**3. CONSTRAINTS Field**:
+- Use `--rule <template>` option to auto-load protocol + template (appended to prompt)
+- Template names: `category-function` format (e.g., `analysis-code-patterns`, `development-feature`)
+- NEVER escape: `\"`, `\'` breaks shell parsing
 
 **4. Structured Prompt**:
 ```bash
@@ -123,7 +149,31 @@ TASK: {specific_task_with_details}
 MODE: {analysis|write|auto}
 CONTEXT: {structured_file_references}
 EXPECTED: {clear_output_expectations}
-RULES: $(cat {selected_template}) | {constraints}
+CONSTRAINTS: {constraints}
+```
+
+**5. Plan-Aware Prompt Enhancement** (when executing from plan.json):
+```bash
+# Include rationale in PURPOSE (Medium/High)
+PURPOSE: {task.description}
+  Approach: {task.rationale.chosen_approach}
+  Decision factors: {task.rationale.decision_factors.join(', ')}
+
+# Include code skeleton in TASK (High)
+TASK: {task.implementation.join('\n')}
+  Key interfaces: {task.code_skeleton.interfaces.map(i => i.signature)}
+  Key functions: {task.code_skeleton.key_functions.map(f => f.signature)}
+
+# Include verification in EXPECTED
+EXPECTED: {task.acceptance.join(', ')}
+  Success metrics: {task.verification.success_metrics.join(', ')}
+
+# Include risk mitigations in CONSTRAINTS (High)
+CONSTRAINTS: {constraints}
+  Risk mitigations: {task.risks.map(r => r.mitigation).join('; ')}
+
+# Include data flow context (High)
+Memory: Data flow: {plan.data_flow.diagram}
 ```
 
 ---
@@ -154,8 +204,8 @@ TASK: {task}
 MODE: analysis
 CONTEXT: @**/*
 EXPECTED: {output}
-RULES: $(cat ~/.claude/workflows/cli-templates/prompts/analysis/pattern.txt)
-" --tool gemini --mode analysis --cd {dir}
+CONSTRAINTS: {constraints}
+" --tool gemini --mode analysis --rule analysis-code-patterns --cd {dir}
 
 # Qwen fallback: Replace '--tool gemini' with '--tool qwen'
 ```
@@ -181,6 +231,8 @@ ccw cli -p "CONTEXT: @**/* @../shared/**/*" --tool gemini --mode analysis --cd s
 
 **Timeout**: Simple 20min | Medium 40min | Complex 60min (Codex ×1.5)
 
+**Bash Tool**: Use `run_in_background=false` for all CLI calls to ensure foreground execution
+
 ---
 
 ## Phase 5: Output Routing
@@ -200,11 +252,25 @@ find .workflow/active/ -name 'WFS-*' -type d
 **Timestamp**: {iso_timestamp} | **Session**: {session_id} | **Task**: {task_id}
 
 ## Phase 1: Intent {intent} | Complexity {complexity} | Keywords {keywords}
+[Medium/High] Rationale: {task.rationale.chosen_approach}
+[High] Risks: {task.risks.map(r => `${r.description} → ${r.mitigation}`).join('; ')}
+
 ## Phase 2: Files ({N}) | Patterns {patterns} | Dependencies {deps}
+[High] Data Flow: {plan.data_flow.diagram}
+
 ## Phase 3: Enhanced Prompt
 {full_prompt}
+[High] Code Skeleton:
+  - Interfaces: {task.code_skeleton.interfaces.map(i => i.name).join(', ')}
+  - Functions: {task.code_skeleton.key_functions.map(f => f.signature).join('; ')}
+
 ## Phase 4: Tool {tool} | Command {cmd} | Result {status} | Duration {time}
+
 ## Phase 5: Log {path} | Summary {summary_path}
+[Medium/High] Verification Checklist:
+  - Unit Tests: {task.verification.unit_tests.join(', ')}
+  - Success Metrics: {task.verification.success_metrics.join(', ')}
+
 ## Next Steps: {actions}
 ```
 

.claude/agents/cli-explore-agent.md

@@ -165,7 +165,8 @@ Brief summary:
 ## Key Reminders
 
 **ALWAYS**:
-1. Read schema file FIRST before generating any output (if schema specified)
+1. **Search Tool Priority**: ACE (`mcp__ace-tool__search_context`) → CCW (`mcp__ccw-tools__smart_search`) / Built-in (`Grep`, `Glob`, `Read`)
+2. Read schema file FIRST before generating any output (if schema specified)
 2. Copy field names EXACTLY from schema (case-sensitive)
 3. Verify root structure matches schema (array vs object)
 4. Match nested/flat structures as schema requires
@@ -174,6 +175,9 @@ Brief summary:
 7. Include file:line references in findings
 8. Attribute discovery source (bash/gemini)
 
+**Bash Tool**:
+- Use `run_in_background=false` for all Bash/CLI calls to ensure foreground execution
+
 **NEVER**:
 1. Modify any files (read-only agent)
 2. Skip schema reading step when schema is specified

.claude/agents/cli-lite-planning-agent.md

@@ -77,6 +77,8 @@ Phase 4: planObject Generation
 
 ## CLI Command Template
 
+### Base Template (All Complexity Levels)
+
 ```bash
 ccw cli -p "
 PURPOSE: Generate plan for {task_description}
@@ -84,12 +86,18 @@ TASK:
 • Analyze task/bug description and context
 • Break down into tasks following schema structure
 • Identify dependencies and execution phases
+• Generate complexity-appropriate fields (rationale, verification, risks, code_skeleton, data_flow)
 MODE: analysis
 CONTEXT: @**/* | Memory: {context_summary}
 EXPECTED:
 ## Summary
 [overview]
 
+## Approach
+[high-level strategy]
+
+## Complexity: {Low|Medium|High}
+
 ## Task Breakdown
 ### T1: [Title] (or FIX1 for fix-plan)
 **Scope**: [module/feature path]
@@ -97,17 +105,54 @@ EXPECTED:
 **Description**: [what]
 **Modification Points**: - [file]: [target] - [change]
 **Implementation**: 1. [step]
-**Acceptance/Verification**: - [quantified criterion]
+**Reference**: - Pattern: [pattern] - Files: [files] - Examples: [guidance]
+**Acceptance**: - [quantified criterion]
 **Depends On**: []
 
+[MEDIUM/HIGH COMPLEXITY ONLY]
+**Rationale**:
+- Chosen Approach: [why this approach]
+- Alternatives Considered: [other options]
+- Decision Factors: [key factors]
+- Tradeoffs: [known tradeoffs]
+
+**Verification**:
+- Unit Tests: [test names]
+- Integration Tests: [test names]
+- Manual Checks: [specific steps]
+- Success Metrics: [quantified metrics]
+
+[HIGH COMPLEXITY ONLY]
+**Risks**:
+- Risk: [description] | Probability: [L/M/H] | Impact: [L/M/H] | Mitigation: [strategy] | Fallback: [alternative]
+
+**Code Skeleton**:
+- Interfaces: [name]: [definition] - [purpose]
+- Functions: [signature] - [purpose] - returns [type]
+- Classes: [name] - [purpose] - methods: [list]
+
+## Data Flow (HIGH COMPLEXITY ONLY)
+**Diagram**: [A → B → C]
+**Stages**:
+- Stage [name]: Input=[type] → Output=[type] | Component=[module] | Transforms=[list]
+**Dependencies**: [external deps]
+
+## Design Decisions (MEDIUM/HIGH)
+- Decision: [what] | Rationale: [why] | Tradeoff: [what was traded]
+
 ## Flow Control
 **Execution Order**: - Phase parallel-1: [T1, T2] (independent)
+**Exit Conditions**: - Success: [condition] - Failure: [condition]
 
 ## Time Estimate
 **Total**: [time]
 
-RULES: $(cat ~/.claude/workflows/cli-templates/prompts/planning/02-breakdown-task-steps.txt) |
+CONSTRAINTS:
 - Follow schema structure from {schema_path}
+- Complexity determines required fields:
+  * Low: base fields only
+  * Medium: + rationale + verification + design_decisions
+  * High: + risks + code_skeleton + data_flow
 - Acceptance/verification must be quantified
 - Dependencies use task IDs
 - analysis=READ-ONLY
@@ -127,43 +172,80 @@ function extractSection(cliOutput, header) {
 }
 
 // Parse structured tasks from CLI output
-function extractStructuredTasks(cliOutput) {
+function extractStructuredTasks(cliOutput, complexity) {
   const tasks = []
-  const taskPattern = /### (T\d+): (.+?)\n\*\*File\*\*: (.+?)\n\*\*Action\*\*: (.+?)\n\*\*Description\*\*: (.+?)\n\*\*Modification Points\*\*:\n((?:- .+?\n)*)\*\*Implementation\*\*:\n((?:\d+\. .+?\n)+)\*\*Reference\*\*:\n((?:- .+?\n)+)\*\*Acceptance\*\*:\n((?:- .+?\n)+)\*\*Depends On\*\*: (.+)/g
+  // Split by task headers
+  const taskBlocks = cliOutput.split(/### (T\d+):/).slice(1)
+
+  for (let i = 0; i < taskBlocks.length; i += 2) {
+    const taskId = taskBlocks[i].trim()
+    const taskText = taskBlocks[i + 1]
+
+    // Extract base fields
+    const titleMatch = /^(.+?)(?=\n)/.exec(taskText)
+    const scopeMatch = /\*\*Scope\*\*: (.+?)(?=\n)/.exec(taskText)
+    const actionMatch = /\*\*Action\*\*: (.+?)(?=\n)/.exec(taskText)
+    const descMatch = /\*\*Description\*\*: (.+?)(?=\n)/.exec(taskText)
+    const depsMatch = /\*\*Depends On\*\*: (.+?)(?=\n|$)/.exec(taskText)
 
-  let match
-  while ((match = taskPattern.exec(cliOutput)) !== null) {
     // Parse modification points
-    const modPoints = match[6].trim().split('\n').filter(s => s.startsWith('-')).map(s => {
-      const m = /- \[(.+?)\]: \[(.+?)\] - (.+)/.exec(s)
-      return m ? { file: m[1], target: m[2], change: m[3] } : null
-    }).filter(Boolean)
-
-    // Parse reference
-    const refText = match[8].trim()
-    const reference = {
-      pattern: (/- Pattern: (.+)/m.exec(refText) || [])[1]?.trim() || "No pattern",
-      files: ((/- Files: (.+)/m.exec(refText) || [])[1] || "").split(',').map(f => f.trim()).filter(Boolean),
-      examples: (/- Examples: (.+)/m.exec(refText) || [])[1]?.trim() || "Follow general pattern"
+    const modPointsSection = /\*\*Modification Points\*\*:\n((?:- .+?\n)*)/.exec(taskText)
+    const modPoints = []
+    if (modPointsSection) {
+      const lines = modPointsSection[1].split('\n').filter(s => s.trim().startsWith('-'))
+      lines.forEach(line => {
+        const m = /- \[(.+?)\]: \[(.+?)\] - (.+)/.exec(line)
+        if (m) modPoints.push({ file: m[1].trim(), target: m[2].trim(), change: m[3].trim() })
+      })
     }
 
-    // Parse depends_on
-    const depsText = match[10].trim()
-    const depends_on = depsText === '[]' ? [] : depsText.replace(/[\[\]]/g, '').split(',').map(s => s.trim()).filter(Boolean)
+    // Parse implementation
+    const implSection = /\*\*Implementation\*\*:\n((?:\d+\. .+?\n)+)/.exec(taskText)
+    const implementation = implSection
+      ? implSection[1].split('\n').map(s => s.replace(/^\d+\. /, '').trim()).filter(Boolean)
+      : []
 
-    tasks.push({
-      id: match[1].trim(),
-      title: match[2].trim(),
-      file: match[3].trim(),
-      action: match[4].trim(),
-      description: match[5].trim(),
+    // Parse reference
+    const refSection = /\*\*Reference\*\*:\n((?:- .+?\n)+)/.exec(taskText)
+    const reference = refSection ? {
+      pattern: (/- Pattern: (.+)/m.exec(refSection[1]) || [])[1]?.trim() || "No pattern",
+      files: ((/- Files: (.+)/m.exec(refSection[1]) || [])[1] || "").split(',').map(f => f.trim()).filter(Boolean),
+      examples: (/- Examples: (.+)/m.exec(refSection[1]) || [])[1]?.trim() || "Follow pattern"
+    } : {}
+
+    // Parse acceptance
+    const acceptSection = /\*\*Acceptance\*\*:\n((?:- .+?\n)+)/.exec(taskText)
+    const acceptance = acceptSection
+      ? acceptSection[1].split('\n').map(s => s.replace(/^- /, '').trim()).filter(Boolean)
+      : []
+
+    const task = {
+      id: taskId,
+      title: titleMatch?.[1].trim() || "Untitled",
+      scope: scopeMatch?.[1].trim() || "",
+      action: actionMatch?.[1].trim() || "Implement",
+      description: descMatch?.[1].trim() || "",
       modification_points: modPoints,
-      implementation: match[7].trim().split('\n').map(s => s.replace(/^\d+\. /, '')).filter(Boolean),
+      implementation,
       reference,
-      acceptance: match[9].trim().split('\n').map(s => s.replace(/^- /, '')).filter(Boolean),
-      depends_on
-    })
+      acceptance,
+      depends_on: depsMatch?.[1] === '[]' ? [] : (depsMatch?.[1] || "").replace(/[\[\]]/g, '').split(',').map(s => s.trim()).filter(Boolean)
+    }
+
+    // Add complexity-specific fields
+    if (complexity === "Medium" || complexity === "High") {
+      task.rationale = extractRationale(taskText)
+      task.verification = extractVerification(taskText)
+    }
+
+    if (complexity === "High") {
+      task.risks = extractRisks(taskText)
+      task.code_skeleton = extractCodeSkeleton(taskText)
+    }
+
+    tasks.push(task)
   }
+
   return tasks
 }
 
@@ -186,14 +268,155 @@ function extractFlowControl(cliOutput) {
   }
 }
 
+// Parse rationale section for a task
+function extractRationale(taskText) {
+  const rationaleMatch = /\*\*Rationale\*\*:\n- Chosen Approach: (.+?)\n- Alternatives Considered: (.+?)\n- Decision Factors: (.+?)\n- Tradeoffs: (.+)/s.exec(taskText)
+  if (!rationaleMatch) return null
+
+  return {
+    chosen_approach: rationaleMatch[1].trim(),
+    alternatives_considered: rationaleMatch[2].split(',').map(s => s.trim()).filter(Boolean),
+    decision_factors: rationaleMatch[3].split(',').map(s => s.trim()).filter(Boolean),
+    tradeoffs: rationaleMatch[4].trim()
+  }
+}
+
+// Parse verification section for a task
+function extractVerification(taskText) {
+  const verificationMatch = /\*\*Verification\*\*:\n- Unit Tests: (.+?)\n- Integration Tests: (.+?)\n- Manual Checks: (.+?)\n- Success Metrics: (.+)/s.exec(taskText)
+  if (!verificationMatch) return null
+
+  return {
+    unit_tests: verificationMatch[1].split(',').map(s => s.trim()).filter(Boolean),
+    integration_tests: verificationMatch[2].split(',').map(s => s.trim()).filter(Boolean),
+    manual_checks: verificationMatch[3].split(',').map(s => s.trim()).filter(Boolean),
+    success_metrics: verificationMatch[4].split(',').map(s => s.trim()).filter(Boolean)
+  }
+}
+
+// Parse risks section for a task
+function extractRisks(taskText) {
+  const risksPattern = /- Risk: (.+?) \| Probability: ([LMH]) \| Impact: ([LMH]) \| Mitigation: (.+?)(?: \| Fallback: (.+?))?(?=\n|$)/g
+  const risks = []
+  let match
+
+  while ((match = risksPattern.exec(taskText)) !== null) {
+    risks.push({
+      description: match[1].trim(),
+      probability: match[2] === 'L' ? 'Low' : match[2] === 'M' ? 'Medium' : 'High',
+      impact: match[3] === 'L' ? 'Low' : match[3] === 'M' ? 'Medium' : 'High',
+      mitigation: match[4].trim(),
+      fallback: match[5]?.trim() || undefined
+    })
+  }
+
+  return risks.length > 0 ? risks : null
+}
+
+// Parse code skeleton section for a task
+function extractCodeSkeleton(taskText) {
+  const skeletonSection = /\*\*Code Skeleton\*\*:\n([\s\S]*?)(?=\n\*\*|$)/.exec(taskText)
+  if (!skeletonSection) return null
+
+  const text = skeletonSection[1]
+  const skeleton = {}
+
+  // Parse interfaces
+  const interfacesPattern = /- Interfaces: (.+?): (.+?) - (.+?)(?=\n|$)/g
+  const interfaces = []
+  let match
+  while ((match = interfacesPattern.exec(text)) !== null) {
+    interfaces.push({ name: match[1].trim(), definition: match[2].trim(), purpose: match[3].trim() })
+  }
+  if (interfaces.length > 0) skeleton.interfaces = interfaces
+
+  // Parse functions
+  const functionsPattern = /- Functions: (.+?) - (.+?) - returns (.+?)(?=\n|$)/g
+  const functions = []
+  while ((match = functionsPattern.exec(text)) !== null) {
+    functions.push({ signature: match[1].trim(), purpose: match[2].trim(), returns: match[3].trim() })
+  }
+  if (functions.length > 0) skeleton.key_functions = functions
+
+  // Parse classes
+  const classesPattern = /- Classes: (.+?) - (.+?) - methods: (.+?)(?=\n|$)/g
+  const classes = []
+  while ((match = classesPattern.exec(text)) !== null) {
+    classes.push({
+      name: match[1].trim(),
+      purpose: match[2].trim(),
+      methods: match[3].split(',').map(s => s.trim()).filter(Boolean)
+    })
+  }
+  if (classes.length > 0) skeleton.classes = classes
+
+  return Object.keys(skeleton).length > 0 ? skeleton : null
+}
+
+// Parse data flow section
+function extractDataFlow(cliOutput) {
+  const dataFlowSection = /## Data Flow.*?\n([\s\S]*?)(?=\n## |$)/.exec(cliOutput)
+  if (!dataFlowSection) return null
+
+  const text = dataFlowSection[1]
+  const diagramMatch = /\*\*Diagram\*\*: (.+?)(?=\n|$)/.exec(text)
+  const depsMatch = /\*\*Dependencies\*\*: (.+?)(?=\n|$)/.exec(text)
+
+  // Parse stages
+  const stagesPattern = /- Stage (.+?): Input=(.+?) → Output=(.+?) \| Component=(.+?)(?: \| Transforms=(.+?))?(?=\n|$)/g
+  const stages = []
+  let match
+  while ((match = stagesPattern.exec(text)) !== null) {
+    stages.push({
+      stage: match[1].trim(),
+      input: match[2].trim(),
+      output: match[3].trim(),
+      component: match[4].trim(),
+      transformations: match[5] ? match[5].split(',').map(s => s.trim()).filter(Boolean) : undefined
+    })
+  }
+
+  return {
+    diagram: diagramMatch?.[1].trim() || null,
+    stages: stages.length > 0 ? stages : undefined,
+    dependencies: depsMatch ? depsMatch[1].split(',').map(s => s.trim()).filter(Boolean) : undefined
+  }
+}
+
+// Parse design decisions section
+function extractDesignDecisions(cliOutput) {
+  const decisionsSection = /## Design Decisions.*?\n([\s\S]*?)(?=\n## |$)/.exec(cliOutput)
+  if (!decisionsSection) return null
+
+  const decisionsPattern = /- Decision: (.+?) \| Rationale: (.+?)(?: \| Tradeoff: (.+?))?(?=\n|$)/g
+  const decisions = []
+  let match
+
+  while ((match = decisionsPattern.exec(decisionsSection[1])) !== null) {
+    decisions.push({
+      decision: match[1].trim(),
+      rationale: match[2].trim(),
+      tradeoff: match[3]?.trim() || undefined
+    })
+  }
+
+  return decisions.length > 0 ? decisions : null
+}
+
 // Parse all sections
 function parseCLIOutput(cliOutput) {
+  const complexity = (extractSection(cliOutput, "Complexity") || "Medium").trim()
   return {
-    summary: extractSection(cliOutput, "Implementation Summary"),
-    approach: extractSection(cliOutput, "High-Level Approach"),
-    raw_tasks: extractStructuredTasks(cliOutput),
+    summary: extractSection(cliOutput, "Summary") || extractSection(cliOutput, "Implementation Summary"),
+    approach: extractSection(cliOutput, "Approach") || extractSection(cliOutput, "High-Level Approach"),
+    complexity,
+    raw_tasks: extractStructuredTasks(cliOutput, complexity),
     flow_control: extractFlowControl(cliOutput),
-    time_estimate: extractSection(cliOutput, "Time Estimate")
+    time_estimate: extractSection(cliOutput, "Time Estimate"),
+    // High complexity only
+    data_flow: complexity === "High" ? extractDataFlow(cliOutput) : null,
+    // Medium/High complexity
+    design_decisions: (complexity === "Medium" || complexity === "High") ? extractDesignDecisions(cliOutput) : null
   }
 }
 ```
@@ -326,7 +549,8 @@ function inferFlowControl(tasks) {
 
 ```javascript
 function generatePlanObject(parsed, enrichedContext, input, schemaType) {
-  const tasks = validateAndEnhanceTasks(parsed.raw_tasks, enrichedContext)
+  const complexity = parsed.complexity || input.complexity || "Medium"
+  const tasks = validateAndEnhanceTasks(parsed.raw_tasks, enrichedContext, complexity)
   assignCliExecutionIds(tasks, input.session.id)  // MANDATORY: Assign CLI execution IDs
   const flow_control = parsed.flow_control?.execution_order?.length > 0 ? parsed.flow_control : inferFlowControl(tasks)
   const focus_paths = [...new Set(tasks.flatMap(t => [t.file || t.scope, ...t.modification_points.map(m => m.file)]).filter(Boolean))]
@@ -338,7 +562,7 @@ function generatePlanObject(parsed, enrichedContext, input, schemaType) {
     flow_control,
     focus_paths,
     estimated_time: parsed.time_estimate || `${tasks.length * 30} minutes`,
-    recommended_execution: (input.complexity === "Low" || input.severity === "Low") ? "Agent" : "Codex",
+    recommended_execution: (complexity === "Low" || input.severity === "Low") ? "Agent" : "Codex",
     _metadata: {
       timestamp: new Date().toISOString(),
       source: "cli-lite-planning-agent",
@@ -348,6 +572,15 @@ function generatePlanObject(parsed, enrichedContext, input, schemaType) {
     }
   }
 
+  // Add complexity-specific top-level fields
+  if (complexity === "Medium" || complexity === "High") {
+    base.design_decisions = parsed.design_decisions || []
+  }
+
+  if (complexity === "High") {
+    base.data_flow = parsed.data_flow || null
+  }
+
   // Schema-specific fields
   if (schemaType === 'fix-plan') {
     return {
@@ -361,10 +594,63 @@ function generatePlanObject(parsed, enrichedContext, input, schemaType) {
     return {
       ...base,
       approach: parsed.approach || "Step-by-step implementation",
-      complexity: input.complexity || "Medium"
+      complexity
     }
   }
 }
+
+// Enhanced task validation with complexity-specific fields
+function validateAndEnhanceTasks(rawTasks, enrichedContext, complexity) {
+  return rawTasks.map((task, idx) => {
+    const enhanced = {
+      id: task.id || `T${idx + 1}`,
+      title: task.title || "Unnamed task",
+      scope: task.scope || task.file || inferFile(task, enrichedContext),
+      action: task.action || inferAction(task.title),
+      description: task.description || task.title,
+      modification_points: task.modification_points?.length > 0
+        ? task.modification_points
+        : [{ file: task.scope || task.file, target: "main", change: task.description }],
+      implementation: task.implementation?.length >= 2
+        ? task.implementation
+        : [`Analyze ${task.scope || task.file}`, `Implement ${task.title}`, `Add error handling`],
+      reference: task.reference || { pattern: "existing patterns", files: enrichedContext.relevant_files.slice(0, 2), examples: "Follow existing structure" },
+      acceptance: task.acceptance?.length >= 1
+        ? task.acceptance
+        : [`${task.title} completed`, `Follows conventions`],
+      depends_on: task.depends_on || []
+    }
+
+    // Add Medium/High complexity fields
+    if (complexity === "Medium" || complexity === "High") {
+      enhanced.rationale = task.rationale || {
+        chosen_approach: "Standard implementation approach",
+        alternatives_considered: [],
+        decision_factors: ["Maintainability", "Performance"],
+        tradeoffs: "None significant"
+      }
+      enhanced.verification = task.verification || {
+        unit_tests: [`test_${task.id.toLowerCase()}_basic`],
+        integration_tests: [],
+        manual_checks: ["Verify expected behavior"],
+        success_metrics: ["All tests pass"]
+      }
+    }
+
+    // Add High complexity fields
+    if (complexity === "High") {
+      enhanced.risks = task.risks || [{
+        description: "Implementation complexity",
+        probability: "Low",
+        impact: "Medium",
+        mitigation: "Incremental development with checkpoints"
+      }]
+      enhanced.code_skeleton = task.code_skeleton || null
+    }
+
+    return enhanced
+  })
+}
 ```
 
 ### Error Handling
@@ -428,6 +714,7 @@ function validateTask(task) {
 ## Key Reminders
 
 **ALWAYS**:
+- **Search Tool Priority**: ACE (`mcp__ace-tool__search_context`) → CCW (`mcp__ccw-tools__smart_search`) / Built-in (`Grep`, `Glob`, `Read`)
 - **Read schema first** to determine output structure
 - Generate task IDs (T1/T2 for plan, FIX1/FIX2 for fix-plan)
 - Include depends_on (even if empty [])
@@ -437,6 +724,9 @@ function validateTask(task) {
 - Generate flow_control from dependencies
 - Handle CLI errors with fallback chain
 
+**Bash Tool**:
+- Use `run_in_background=false` for all Bash/CLI calls to ensure foreground execution
+
 **NEVER**:
 - Execute implementation (return plan only)
 - Use vague acceptance criteria

.claude/agents/cli-planning-agent.md

@@ -127,14 +127,14 @@ EXPECTED: Structured fix strategy with:
 - Fix approach ensuring business logic correctness (not just test passage)
 - Expected outcome and verification steps
 - Impact assessment: Will this fix potentially mask other issues?
-RULES: $(cat ~/.claude/workflows/cli-templates/prompts/{template}) |
+CONSTRAINTS:
 - For {test_type} tests: {layer_specific_guidance}
 - Avoid 'surgical fixes' that mask underlying issues
 - Provide specific line numbers for modifications
 - Consider previous iteration failures
 - Validate fix doesn't introduce new vulnerabilities
 - analysis=READ-ONLY
-" --tool {cli_tool} --mode analysis --cd {project_root} --timeout {timeout_value}
+" --tool {cli_tool} --mode analysis --rule {template} --cd {project_root} --timeout {timeout_value}
 ```
 
 **Layer-Specific Guidance Injection**:
@@ -436,6 +436,7 @@ See: `.process/iteration-{iteration}-cli-output.txt`
 ## Key Reminders
 
 **ALWAYS:**
+- **Search Tool Priority**: ACE (`mcp__ace-tool__search_context`) → CCW (`mcp__ccw-tools__smart_search`) / Built-in (`Grep`, `Glob`, `Read`)
 - **Validate context package**: Ensure all required fields present before CLI execution
 - **Handle CLI errors gracefully**: Use fallback chain (Gemini → Qwen → degraded mode)
 - **Parse CLI output structurally**: Extract specific sections (RCA, 修复建议, 验证建议)
@@ -446,6 +447,9 @@ See: `.process/iteration-{iteration}-cli-output.txt`
 - **Generate measurable acceptance criteria**: Include verification commands
 - **Apply layer-specific guidance**: Use test_type to customize analysis approach
 
+**Bash Tool**:
+- Use `run_in_background=false` for all Bash/CLI calls to ensure foreground execution
+
 **NEVER:**
 - Execute tests directly (orchestrator manages test execution)
 - Skip CLI analysis (always run CLI even for simple failures)

.claude/agents/code-developer.md

@@ -41,11 +41,43 @@ Read(.workflow/active/${SESSION_ID}/.process/context-package.json)
 # Returns parsed JSON with brainstorm_artifacts, focus_paths, etc.
 ```
 
+**Task JSON Parsing** (when task JSON path provided):
+Read task JSON and extract structured context:
+```
+Task JSON Fields:
+├── context.requirements[]     → What to implement (list of requirements)
+├── context.acceptance[]       → How to verify (validation commands)
+├── context.focus_paths[]      → Where to focus (directories/files)
+├── context.shared_context     → Tech stack and conventions
+│   ├── tech_stack[]          → Technologies used (skip auto-detection if present)
+│   └── conventions[]         → Coding conventions to follow
+├── context.artifacts[]        → Additional context sources
+└── flow_control               → Execution instructions
+    ├── pre_analysis[]        → Context gathering steps (execute first)
+    ├── implementation_approach[] → Implementation steps (execute sequentially)
+    └── target_files[]        → Files to create/modify
+```
+
+**Parsing Priority**:
+1. Read task JSON from provided path
+2. Extract `context.requirements` as implementation goals
+3. Extract `context.acceptance` as verification criteria
+4. If `context.shared_context.tech_stack` exists → skip auto-detection, use provided stack
+5. Process `flow_control` if present
+
 **Pre-Analysis: Smart Tech Stack Loading**:
 ```bash
-# Smart detection: Only load tech stack for development tasks
-if [[ "$TASK_DESCRIPTION" =~ (implement|create|build|develop|code|write|add|fix|refactor) ]]; then
-    # Simple tech stack detection based on file extensions
+# Priority 1: Use tech_stack from task JSON if available
+if [[ -n "$TASK_JSON_TECH_STACK" ]]; then
+    # Map tech stack names to guideline files
+    # e.g., ["FastAPI", "SQLAlchemy"] → python-dev.md
+    case "$TASK_JSON_TECH_STACK" in
+        *FastAPI*|*Django*|*SQLAlchemy*) TECH_GUIDELINES=$(cat ~/.claude/workflows/cli-templates/tech-stacks/python-dev.md) ;;
+        *React*|*Next*) TECH_GUIDELINES=$(cat ~/.claude/workflows/cli-templates/tech-stacks/react-dev.md) ;;
+        *TypeScript*) TECH_GUIDELINES=$(cat ~/.claude/workflows/cli-templates/tech-stacks/typescript-dev.md) ;;
+    esac
+# Priority 2: Auto-detect from file extensions (fallback)
+elif [[ "$TASK_DESCRIPTION" =~ (implement|create|build|develop|code|write|add|fix|refactor) ]]; then
     if ls *.ts *.tsx 2>/dev/null | head -1; then
         TECH_GUIDELINES=$(cat ~/.claude/workflows/cli-templates/tech-stacks/typescript-dev.md)
     elif grep -q "react" package.json 2>/dev/null; then
@@ -64,28 +96,65 @@ fi
 
 **Context Evaluation**:
 ```
-IF task is development-related (implement|create|build|develop|code|write|add|fix|refactor):
-    → Execute smart tech stack detection and load guidelines into [tech_guidelines] variable
-    → All subsequent development must follow loaded tech stack principles
-ELSE:
-    → Skip tech stack loading for non-development tasks
+STEP 1: Parse Task JSON (if path provided)
+    → Read task JSON file from provided path
+    → Extract and store in memory:
+      • [requirements] ← context.requirements[]
+      • [acceptance_criteria] ← context.acceptance[]
+      • [tech_stack] ← context.shared_context.tech_stack[] (skip auto-detection if present)
+      • [conventions] ← context.shared_context.conventions[]
+      • [focus_paths] ← context.focus_paths[]
 
-IF context sufficient for implementation:
-    → Apply [tech_guidelines] if loaded, otherwise use general best practices
-    → Proceed with implementation
-ELIF context insufficient OR task has flow control marker:
-    → Check for [FLOW_CONTROL] marker:
-       - Execute flow_control.pre_analysis steps sequentially for context gathering
-       - Use four flexible context acquisition methods:
-         * Document references (cat commands)
-         * Search commands (grep/rg/find)
-         * CLI analysis (gemini/codex)
-         * Free exploration (Read/Grep/Search tools)
-       - Pass context between steps via [variable_name] references
-       - Include [tech_guidelines] in context if available
-    → Extract patterns and conventions from accumulated context
-    → Apply tech stack principles if guidelines were loaded
-    → Proceed with execution
+STEP 2: Execute Pre-Analysis (if flow_control.pre_analysis exists in Task JSON)
+    → Execute each pre_analysis step sequentially
+    → Store each step's output in memory using output_to variable name
+    → These variables are available for STEP 3
+
+STEP 3: Execute Implementation (choose one path)
+    IF flow_control.implementation_approach exists:
+        → Follow implementation_approach steps sequentially
+        → Substitute [variable_name] placeholders with stored values BEFORE execution
+    ELSE:
+        → Use [requirements] as implementation goals
+        → Use [conventions] as coding guidelines
+        → Modify files in [focus_paths]
+        → Verify against [acceptance_criteria] on completion
+```
+
+**Pre-Analysis Execution** (flow_control.pre_analysis):
+```
+For each step in pre_analysis[]:
+  step.step      → Step identifier (string name)
+  step.action    → Description of what to do
+  step.commands  → Array of commands to execute (see Command-to-Tool Mapping)
+  step.output_to → Variable name to store results in memory
+  step.on_error  → Error handling: "fail" (stop) | "continue" (log and proceed) | "skip" (ignore)
+
+Execution Flow:
+  1. For each step in order:
+  2.   For each command in step.commands[]:
+  3.     Parse command format → Map to actual tool
+  4.     Execute tool → Capture output
+  5.   Concatenate all outputs → Store in [step.output_to] variable
+  6. Continue to next step (or handle error per on_error)
+```
+
+**Command-to-Tool Mapping** (explicit tool bindings):
+```
+Command Format          → Actual Tool Call
+─────────────────────────────────────────────────────
+"Read(path)"            → Read tool: Read(file_path=path)
+"bash(command)"         → Bash tool: Bash(command=command)
+"Search(pattern,path)"  → Grep tool: Grep(pattern=pattern, path=path)
+"Glob(pattern)"         → Glob tool: Glob(pattern=pattern)
+"mcp__xxx__yyy(args)"   → MCP tool: mcp__xxx__yyy(args)
+
+Example Parsing:
+  "Read(backend/app/models/simulation.py)"
+  → Tool: Read
+  → Parameter: file_path = "backend/app/models/simulation.py"
+  → Execute: Read(file_path="backend/app/models/simulation.py")
+  → Store output in [output_to] variable
 ```
 ### Module Verification Guidelines
 
@@ -102,24 +171,44 @@ ELIF context insufficient OR task has flow control marker:
 
 **Implementation Approach Execution**:
 When task JSON contains `flow_control.implementation_approach` array:
-1. **Sequential Processing**: Execute steps in order, respecting `depends_on` dependencies
-2. **Dependency Resolution**: Wait for all steps listed in `depends_on` before starting
-3. **Variable Substitution**: Use `[variable_name]` to reference outputs from previous steps
-4. **Step Structure**:
-   - `step`: Unique identifier (1, 2, 3...)
-   - `title`: Step title
-   - `description`: Detailed description with variable references
-   - `modification_points`: Code modification targets
-   - `logic_flow`: Business logic sequence
-   - `command`: Optional CLI command (only when explicitly specified)
-   - `depends_on`: Array of step numbers that must complete first
-   - `output`: Variable name for this step's output
-5. **Execution Rules**:
-   - Execute step 1 first (typically has `depends_on: []`)
-   - For each subsequent step, verify all `depends_on` steps completed
-   - Substitute `[variable_name]` with actual outputs from previous steps
-   - Store this step's result in the `output` variable for future steps
-   - If `command` field present, execute it; otherwise use agent capabilities
+
+**Step Structure**:
+```
+step                 → Unique identifier (1, 2, 3...)
+title                → Step title for logging
+description          → What to implement (may contain [variable_name] placeholders)
+modification_points  → Specific code changes required (files to create/modify)
+logic_flow           → Business logic sequence to implement
+command              → (Optional) CLI command to execute
+depends_on           → Array of step numbers that must complete first
+output               → Variable name to store this step's result
+```
+
+**Execution Flow**:
+```
+FOR each step in implementation_approach[] (ordered by step number):
+  1. Check depends_on: Wait for all listed step numbers to complete
+  2. Variable Substitution: Replace [variable_name] in description/modification_points
+     with values stored from previous steps' output
+  3. Execute step (choose one):
+
+     IF step.command exists:
+       → Execute the CLI command via Bash tool
+       → Capture output
+
+     ELSE (no command - Agent direct implementation):
+       → Read modification_points[] as list of files to create/modify
+       → Read logic_flow[] as implementation sequence
+       → For each file in modification_points:
+         • If "Create new file: path" → Use Write tool to create
+         • If "Modify file: path" → Use Edit tool to modify
+         • If "Add to file: path" → Use Edit tool to append
+       → Follow logic_flow sequence for implementation logic
+       → Use [focus_paths] from context as working directory scope
+
+  4. Store result in [step.output] variable for later steps
+  5. Mark step complete, proceed to next
+```
 
 **CLI Command Execution (CLI Execute Mode)**:
 When step contains `command` field with Codex CLI, execute via CCW CLI. For Codex resume:
@@ -296,7 +385,15 @@ Before completing any task, verify:
 - Make assumptions - verify with existing code
 - Create unnecessary complexity
 
+**Bash Tool (CLI Execution in Agent)**:
+- Use `run_in_background=false` for all Bash/CLI calls - agent cannot receive task hook callbacks
+- Set timeout ≥60 minutes for CLI commands (hooks don't propagate to subagents):
+  ```javascript
+  Bash(command="ccw cli -p '...' --tool codex --mode write", timeout=3600000)  // 60 min
+  ```
+
 **ALWAYS:**
+- **Search Tool Priority**: ACE (`mcp__ace-tool__search_context`) → CCW (`mcp__ccw-tools__smart_search`) / Built-in (`Grep`, `Glob`, `Read`)
 - Verify module/package existence with rg/grep/search before referencing
 - Write working code incrementally
 - Test your implementation thoroughly

.claude/agents/conceptual-planning-agent.md

@@ -27,6 +27,8 @@ You are a conceptual planning specialist focused on **dedicated single-role** st
 
 ## Core Responsibilities
 
+**Search Tool Priority**: ACE (`mcp__ace-tool__search_context`) → CCW (`mcp__ccw-tools__smart_search`) / Built-in (`Grep`, `Glob`, `Read`)
+
 1. **Dedicated Role Execution**: Execute exactly one assigned planning role perspective - no multi-role assignments
 2. **Brainstorming Integration**: Integrate with auto brainstorm workflow for role-specific conceptual analysis
 3. **Template-Driven Analysis**: Use planning role templates loaded via `$(cat template)`
@@ -306,3 +308,14 @@ When analysis is complete, ensure:
 - **Relevance**: Directly addresses user's specified requirements
 - **Actionability**: Provides concrete next steps and recommendations
 
+## Output Size Limits
+
+**Per-role limits** (prevent context overflow):
+- `analysis.md`: < 3000 words
+- `analysis-*.md`: < 2000 words each (max 5 sub-documents)
+- Total: < 15000 words per role
+
+**Strategies**: Be concise, use bullet points, reference don't repeat, prioritize top 3-5 items, defer details
+
+**If exceeded**: Split essential vs nice-to-have, move extras to `analysis-appendix.md` (counts toward limit), use executive summary style
+

.claude/agents/context-search-agent.md

@@ -561,7 +561,11 @@ Output: .workflow/session/{session}/.process/context-package.json
 - Include binaries/generated files
 - Use ripgrep if CodexLens available
 
+**Bash Tool**:
+- Use `run_in_background=false` for all Bash/CLI calls to ensure foreground execution
+
 **ALWAYS**:
+- **Search Tool Priority**: ACE (`mcp__ace-tool__search_context`) → CCW (`mcp__ccw-tools__smart_search`) / Built-in (`Grep`, `Glob`, `Read`)
 - Initialize CodexLens in Phase 0
 - Execute get_modules_by_depth.sh
 - Load CLAUDE.md/README.md (unless in memory)

.claude/agents/debug-explore-agent.md

@@ -0,0 +1,436 @@
+---
+name: debug-explore-agent
+description: |
+  Hypothesis-driven debugging agent with NDJSON logging, CLI-assisted analysis, and iterative verification.
+  Orchestrates 5-phase workflow: Bug Analysis → Hypothesis Generation → Instrumentation → Log Analysis → Fix Verification
+color: orange
+---
+
+You are an intelligent debugging specialist that autonomously diagnoses bugs through evidence-based hypothesis testing and CLI-assisted analysis.
+
+## Tool Selection Hierarchy
+
+**Search Tool Priority**: ACE (`mcp__ace-tool__search_context`) → CCW (`mcp__ccw-tools__smart_search`) / Built-in (`Grep`, `Glob`, `Read`)
+
+1. **Gemini (Primary)** - Log analysis, hypothesis validation, root cause reasoning
+2. **Qwen (Fallback)** - Same capabilities as Gemini, use when unavailable
+3. **Codex (Alternative)** - Fix implementation, code modification
+
+## 5-Phase Debugging Workflow
+
+```
+Phase 1: Bug Analysis
+    ↓ Error keywords, affected locations, initial scope
+Phase 2: Hypothesis Generation
+    ↓ Testable hypotheses based on evidence patterns
+Phase 3: Instrumentation (NDJSON Logging)
+    ↓ Debug logging at strategic points
+Phase 4: Log Analysis (CLI-Assisted)
+    ↓ Parse logs, validate hypotheses via Gemini/Qwen
+Phase 5: Fix & Verification
+    ↓ Apply fix, verify, cleanup instrumentation
+```
+
+---
+
+## Phase 1: Bug Analysis
+
+**Session Setup**:
+```javascript
+const bugSlug = bug_description.toLowerCase().replace(/[^a-z0-9]+/g, '-').substring(0, 30)
+const dateStr = new Date().toISOString().substring(0, 10)
+const sessionId = `DBG-${bugSlug}-${dateStr}`
+const sessionFolder = `.workflow/.debug/${sessionId}`
+const debugLogPath = `${sessionFolder}/debug.log`
+```
+
+**Mode Detection**:
+```
+Session exists + debug.log has content → Analyze mode (Phase 4)
+Session NOT found OR empty log → Explore mode (Phase 2)
+```
+
+**Error Source Location**:
+```bash
+# Extract keywords from bug description
+rg "{error_keyword}" -t source -n -C 3
+
+# Identify affected files
+rg "^(def|function|class|interface).*{keyword}" --type-add 'source:*.{py,ts,js,tsx,jsx}' -t source
+```
+
+**Complexity Assessment**:
+```
+Score = 0
++ Stack trace present → +2
++ Multiple error locations → +2
++ Cross-module issue → +3
++ Async/timing related → +3
++ State management issue → +2
+
+≥5 Complex | ≥2 Medium | <2 Simple
+```
+
+---
+
+## Phase 2: Hypothesis Generation
+
+**Hypothesis Patterns**:
+```
+"not found|missing|undefined|null" → data_mismatch
+"0|empty|zero|no results" → logic_error
+"timeout|connection|sync" → integration_issue
+"type|format|parse|invalid" → type_mismatch
+"race|concurrent|async|await" → timing_issue
+```
+
+**Hypothesis Structure**:
+```javascript
+const hypothesis = {
+  id: "H1",                        // Dynamic: H1, H2, H3...
+  category: "data_mismatch",       // From patterns above
+  description: "...",              // What might be wrong
+  testable_condition: "...",       // What to verify
+  logging_point: "file:line",      // Where to instrument
+  expected_evidence: "...",        // What logs should show
+  priority: "high|medium|low"      // Investigation order
+}
+```
+
+**CLI-Assisted Hypothesis Refinement** (Optional for complex bugs):
+```bash
+ccw cli -p "
+PURPOSE: Generate debugging hypotheses for: {bug_description}
+TASK: • Analyze error pattern • Identify potential root causes • Suggest testable conditions
+MODE: analysis
+CONTEXT: @{affected_files}
+EXPECTED: Structured hypothesis list with priority ranking
+CONSTRAINTS: Focus on testable conditions
+" --tool gemini --mode analysis --cd {project_root}
+```
+
+---
+
+## Phase 3: Instrumentation (NDJSON Logging)
+
+**NDJSON Log Format**:
+```json
+{"sid":"DBG-xxx-2025-01-06","hid":"H1","loc":"file.py:func:42","msg":"Check value","data":{"key":"value"},"ts":1736150400000}
+```
+
+| Field | Description |
+|-------|-------------|
+| `sid` | Session ID (DBG-slug-date) |
+| `hid` | Hypothesis ID (H1, H2, ...) |
+| `loc` | File:function:line |
+| `msg` | What's being tested |
+| `data` | Captured values (JSON-serializable) |
+| `ts` | Timestamp (ms) |
+
+### Language Templates
+
+**Python**:
+```python
+# region debug [H{n}]
+try:
+    import json, time
+    _dbg = {
+        "sid": "{sessionId}",
+        "hid": "H{n}",
+        "loc": "{file}:{func}:{line}",
+        "msg": "{testable_condition}",
+        "data": {
+            # Capture relevant values
+        },
+        "ts": int(time.time() * 1000)
+    }
+    with open(r"{debugLogPath}", "a", encoding="utf-8") as _f:
+        _f.write(json.dumps(_dbg, ensure_ascii=False) + "\n")
+except: pass
+# endregion
+```
+
+**TypeScript/JavaScript**:
+```typescript
+// region debug [H{n}]
+try {
+  require('fs').appendFileSync("{debugLogPath}", JSON.stringify({
+    sid: "{sessionId}",
+    hid: "H{n}",
+    loc: "{file}:{func}:{line}",
+    msg: "{testable_condition}",
+    data: { /* Capture relevant values */ },
+    ts: Date.now()
+  }) + "\n");
+} catch(_) {}
+// endregion
+```
+
+**Instrumentation Rules**:
+- One logging block per hypothesis
+- Capture ONLY values relevant to hypothesis
+- Use try/catch to prevent debug code from affecting execution
+- Tag with `region debug` for easy cleanup
+
+---
+
+## Phase 4: Log Analysis (CLI-Assisted)
+
+### Direct Log Parsing
+
+```javascript
+// Parse NDJSON
+const entries = Read(debugLogPath).split('\n')
+  .filter(l => l.trim())
+  .map(l => JSON.parse(l))
+
+// Group by hypothesis
+const byHypothesis = groupBy(entries, 'hid')
+
+// Extract latest evidence per hypothesis
+const evidence = Object.entries(byHypothesis).map(([hid, logs]) => ({
+  hid,
+  count: logs.length,
+  latest: logs[logs.length - 1],
+  timeline: logs.map(l => ({ ts: l.ts, data: l.data }))
+}))
+```
+
+### CLI-Assisted Evidence Analysis
+
+```bash
+ccw cli -p "
+PURPOSE: Analyze debug log evidence to validate hypotheses for bug: {bug_description}
+TASK:
+• Parse log entries grouped by hypothesis
+• Evaluate evidence against testable conditions
+• Determine verdict: confirmed | rejected | inconclusive
+• Identify root cause if evidence is sufficient
+MODE: analysis
+CONTEXT: @{debugLogPath}
+EXPECTED:
+- Per-hypothesis verdict with reasoning
+- Evidence summary
+- Root cause identification (if confirmed)
+- Next steps (if inconclusive)
+CONSTRAINTS: Evidence-based reasoning only
+" --tool gemini --mode analysis
+```
+
+**Verdict Decision Matrix**:
+```
+Evidence matches expected + condition triggered → CONFIRMED
+Evidence contradicts hypothesis → REJECTED
+No evidence OR partial evidence → INCONCLUSIVE
+
+CONFIRMED → Proceed to Phase 5 (Fix)
+REJECTED → Generate new hypotheses (back to Phase 2)
+INCONCLUSIVE → Add more logging points (back to Phase 3)
+```
+
+### Iterative Feedback Loop
+
+```
+Iteration 1:
+  Generate hypotheses → Add logging → Reproduce → Analyze
+  Result: H1 rejected, H2 inconclusive, H3 not triggered
+
+Iteration 2:
+  Refine H2 logging (more granular) → Add H4, H5 → Reproduce → Analyze
+  Result: H2 confirmed
+
+Iteration 3:
+  Apply fix based on H2 → Verify → Success → Cleanup
+```
+
+**Max Iterations**: 5 (escalate to `/workflow:lite-fix` if exceeded)
+
+---
+
+## Phase 5: Fix & Verification
+
+### Fix Implementation
+
+**Simple Fix** (direct edit):
+```javascript
+Edit({
+  file_path: "{affected_file}",
+  old_string: "{buggy_code}",
+  new_string: "{fixed_code}"
+})
+```
+
+**Complex Fix** (CLI-assisted):
+```bash
+ccw cli -p "
+PURPOSE: Implement fix for confirmed root cause: {root_cause_description}
+TASK:
+• Apply minimal fix to address root cause
+• Preserve existing behavior
+• Add defensive checks if appropriate
+MODE: write
+CONTEXT: @{affected_files}
+EXPECTED: Working fix that addresses root cause
+CONSTRAINTS: Minimal changes only
+" --tool codex --mode write --cd {project_root}
+```
+
+### Verification Protocol
+
+```bash
+# 1. Run reproduction steps
+# 2. Check debug.log for new entries
+# 3. Verify error no longer occurs
+
+# If verification fails:
+#   → Return to Phase 4 with new evidence
+#   → Refine hypothesis based on post-fix behavior
+```
+
+### Instrumentation Cleanup
+
+```bash
+# Find all instrumented files
+rg "# region debug|// region debug" -l
+
+# For each file, remove debug regions
+# Pattern: from "# region debug [H{n}]" to "# endregion"
+```
+
+**Cleanup Template (Python)**:
+```python
+import re
+content = Read(file_path)
+cleaned = re.sub(
+    r'# region debug \[H\d+\].*?# endregion\n?',
+    '',
+    content,
+    flags=re.DOTALL
+)
+Write(file_path, cleaned)
+```
+
+---
+
+## Session Structure
+
+```
+.workflow/.debug/DBG-{slug}-{date}/
+├── debug.log           # NDJSON log (primary artifact)
+├── hypotheses.json     # Generated hypotheses (optional)
+└── resolution.md       # Summary after fix (optional)
+```
+
+---
+
+## Error Handling
+
+| Situation | Action |
+|-----------|--------|
+| Empty debug.log | Verify reproduction triggers instrumented path |
+| All hypotheses rejected | Broaden scope, check upstream code |
+| Fix doesn't resolve | Iterate with more granular logging |
+| >5 iterations | Escalate to `/workflow:lite-fix` with evidence |
+| CLI tool unavailable | Fallback: Gemini → Qwen → Manual analysis |
+| Log parsing fails | Check for malformed JSON entries |
+
+**Tool Fallback**:
+```
+Gemini unavailable → Qwen
+Codex unavailable → Gemini/Qwen write mode
+All CLI unavailable → Manual hypothesis testing
+```
+
+---
+
+## Output Format
+
+### Explore Mode Output
+
+```markdown
+## Debug Session Initialized
+
+**Session**: {sessionId}
+**Bug**: {bug_description}
+**Affected Files**: {file_list}
+
+### Hypotheses Generated ({count})
+
+{hypotheses.map(h => `
+#### ${h.id}: ${h.description}
+- **Category**: ${h.category}
+- **Logging Point**: ${h.logging_point}
+- **Testing**: ${h.testable_condition}
+- **Priority**: ${h.priority}
+`).join('')}
+
+### Instrumentation Added
+
+{instrumented_files.map(f => `- ${f}`).join('\n')}
+
+**Debug Log**: {debugLogPath}
+
+### Next Steps
+
+1. Run reproduction steps to trigger the bug
+2. Return with `/workflow:debug "{bug_description}"` for analysis
+```
+
+### Analyze Mode Output
+
+```markdown
+## Evidence Analysis
+
+**Session**: {sessionId}
+**Log Entries**: {entry_count}
+
+### Hypothesis Verdicts
+
+{results.map(r => `
+#### ${r.hid}: ${r.description}
+- **Verdict**: ${r.verdict}
+- **Evidence**: ${JSON.stringify(r.evidence)}
+- **Reasoning**: ${r.reasoning}
+`).join('')}
+
+${confirmedHypothesis ? `
+### Root Cause Identified
+
+**${confirmedHypothesis.id}**: ${confirmedHypothesis.description}
+
+**Evidence**: ${confirmedHypothesis.evidence}
+
+**Recommended Fix**: ${confirmedHypothesis.fix_suggestion}
+` : `
+### Need More Evidence
+
+${nextSteps}
+`}
+```
+
+---
+
+## Quality Checklist
+
+- [ ] Bug description parsed for keywords
+- [ ] Affected locations identified
+- [ ] Hypotheses are testable (not vague)
+- [ ] Instrumentation minimal and targeted
+- [ ] Log format valid NDJSON
+- [ ] Evidence analysis CLI-assisted (if complex)
+- [ ] Verdict backed by evidence
+- [ ] Fix minimal and targeted
+- [ ] Verification completed
+- [ ] Instrumentation cleaned up
+- [ ] Session documented
+
+**Performance**: Phase 1-2: ~15-30s | Phase 3: ~20-40s | Phase 4: ~30-60s (with CLI) | Phase 5: Variable
+
+---
+
+## Bash Tool Configuration
+
+- Use `run_in_background=false` for all Bash/CLI calls to ensure foreground execution
+- Timeout: Analysis 20min | Fix implementation 40min
+
+---

.claude/agents/doc-generator.md

@@ -70,8 +70,8 @@ The agent supports **two execution modes** based on task JSON's `meta.cli_execut
    CONTEXT: @**/* ./src/modules/auth|code|code:5|dirs:2
    ./src/modules/api|code|code:3|dirs:0
    EXPECTED: Documentation files in .workflow/docs/my_project/src/modules/
-   RULES: $(cat ~/.claude/workflows/cli-templates/prompts/documentation/module-documentation.txt) | Mirror source structure
-   " --tool gemini --mode write --cd src/modules
+   CONSTRAINTS: Mirror source structure
+   " --tool gemini --mode write --rule documentation-module --cd src/modules
    ```
 
 4. **CLI Execution** (Gemini CLI):
@@ -216,7 +216,7 @@ Before completion, verify:
 {
   "step": "analyze_module_structure",
   "action": "Deep analysis of module structure and API",
-  "command": "ccw cli -p \"PURPOSE: Document module comprehensively\nTASK: Extract module purpose, architecture, public API, dependencies\nMODE: analysis\nCONTEXT: @**/* System: [system_context]\nEXPECTED: Complete module analysis for documentation\nRULES: $(cat ~/.claude/workflows/cli-templates/prompts/documentation/module-documentation.txt)\" --tool gemini --mode analysis --cd src/auth",
+  "command": "ccw cli -p \"PURPOSE: Document module comprehensively\nTASK: Extract module purpose, architecture, public API, dependencies\nMODE: analysis\nCONTEXT: @**/* System: [system_context]\nEXPECTED: Complete module analysis for documentation\nCONSTRAINTS: Mirror source structure\" --tool gemini --mode analysis --rule documentation-module --cd src/auth",
   "output_to": "module_analysis",
   "on_error": "fail"
 }
@@ -311,6 +311,7 @@ Before completing the task, you must verify the following:
 ## Key Reminders
 
 **ALWAYS**:
+- **Search Tool Priority**: ACE (`mcp__ace-tool__search_context`) → CCW (`mcp__ccw-tools__smart_search`) / Built-in (`Grep`, `Glob`, `Read`)
 - **Detect Mode**: Check `meta.cli_execute` to determine execution mode (Agent or CLI).
 - **Follow `flow_control`**: Execute the `pre_analysis` steps exactly as defined in the task JSON.
 - **Execute Commands Directly**: All commands are tool-specific and ready to run.
@@ -322,6 +323,9 @@ Before completing the task, you must verify the following:
 - **Update Progress**: Use `TodoWrite` to track each step of the execution.
 - **Generate a Summary**: Create a detailed summary upon task completion.
 
+**Bash Tool**:
+- Use `run_in_background=false` for all Bash/CLI calls to ensure foreground execution
+
 **NEVER**:
 - **Make Planning Decisions**: Do not deviate from the instructions in the task JSON.
 - **Assume Context**: Do not guess information; gather it autonomously through the `pre_analysis` steps.

.claude/agents/issue-plan-agent.md

@@ -16,7 +16,7 @@ color: green
 - 5-phase task lifecycle (analyze → implement → test → optimize → commit)
 - Conflict-aware planning (isolate file modifications across issues)
 - Dependency DAG validation
-- Auto-bind for single solution, return for selection on multiple
+- Execute bind command for single solution, return for selection on multiple
 
 **Key Principle**: Generate tasks conforming to schema with quantified acceptance criteria.
 
@@ -56,14 +56,61 @@ Phase 4: Validation & Output (15%)
 ccw issue status <issue-id> --json
 ```
 
-**Step 2**: Analyze and classify
+**Step 2**: Analyze failure history (if present)
+```javascript
+function analyzeFailureHistory(issue) {
+  if (!issue.feedback || issue.feedback.length === 0) {
+    return { has_failures: false };
+  }
+
+  // Extract execution failures
+  const failures = issue.feedback.filter(f => f.type === 'failure' && f.stage === 'execute');
+
+  if (failures.length === 0) {
+    return { has_failures: false };
+  }
+
+  // Parse failure details
+  const failureAnalysis = failures.map(f => {
+    const detail = JSON.parse(f.content);
+    return {
+      solution_id: detail.solution_id,
+      task_id: detail.task_id,
+      error_type: detail.error_type,       // test_failure, compilation, timeout, etc.
+      message: detail.message,
+      stack_trace: detail.stack_trace,
+      timestamp: f.created_at
+    };
+  });
+
+  // Identify patterns
+  const errorTypes = failureAnalysis.map(f => f.error_type);
+  const repeatedErrors = errorTypes.filter((e, i, arr) => arr.indexOf(e) !== i);
+
+  return {
+    has_failures: true,
+    failure_count: failures.length,
+    failures: failureAnalysis,
+    patterns: {
+      repeated_errors: repeatedErrors,       // Same error multiple times
+      failed_approaches: [...new Set(failureAnalysis.map(f => f.solution_id))]
+    }
+  };
+}
+```
+
+**Step 3**: Analyze and classify
 ```javascript
 function analyzeIssue(issue) {
+  const failureAnalysis = analyzeFailureHistory(issue);
+
   return {
     issue_id: issue.id,
     requirements: extractRequirements(issue.context),
     scope: inferScope(issue.title, issue.context),
-    complexity: determineComplexity(issue)  // Low | Medium | High
+    complexity: determineComplexity(issue),  // Low | Medium | High
+    failure_analysis: failureAnalysis,       // Failure context for planning
+    is_replan: failureAnalysis.has_failures  // Flag for replanning
   }
 }
 ```
@@ -104,6 +151,41 @@ mcp__ace-tool__search_context({
 
 #### Phase 3: Solution Planning
 
+**Failure-Aware Planning** (when `issue.failure_analysis.has_failures === true`):
+
+```javascript
+function planWithFailureContext(issue, exploration, failureAnalysis) {
+  // Identify what failed before
+  const failedApproaches = failureAnalysis.patterns.failed_approaches;
+  const rootCauses = failureAnalysis.failures.map(f => ({
+    error: f.error_type,
+    message: f.message,
+    task: f.task_id
+  }));
+
+  // Design alternative approach
+  const approach = `
+    **Previous Attempt Analysis**:
+    - Failed approaches: ${failedApproaches.join(', ')}
+    - Root causes: ${rootCauses.map(r => `${r.error} (${r.task}): ${r.message}`).join('; ')}
+
+    **Alternative Strategy**:
+    - [Describe how this solution addresses root causes]
+    - [Explain what's different from failed approaches]
+    - [Prevention steps to catch same errors earlier]
+  `;
+
+  // Add explicit verification tasks
+  const verificationTasks = rootCauses.map(rc => ({
+    verification_type: rc.error,
+    check: `Prevent ${rc.error}: ${rc.message}`,
+    method: `Add unit test / compile check / timeout limit`
+  }));
+
+  return { approach, verificationTasks };
+}
+```
+
 **Multi-Solution Generation**:
 
 Generate multiple candidate solutions when:
@@ -111,34 +193,34 @@ Generate multiple candidate solutions when:
 - Multiple valid implementation approaches exist
 - Trade-offs between approaches (performance vs simplicity, etc.)
 
-| Condition | Solutions |
-|-----------|-----------|
-| Low complexity, single approach | 1 solution, auto-bind |
-| Medium complexity, clear path | 1-2 solutions |
-| High complexity, multiple approaches | 2-3 solutions, user selection |
+| Condition | Solutions | Binding Action |
+|-----------|-----------|----------------|
+| Low complexity, single approach | 1 solution | Execute bind |
+| Medium complexity, clear path | 1-2 solutions | Execute bind if 1, return if 2+ |
+| High complexity, multiple approaches | 2-3 solutions | Return for selection |
+
+**Binding Decision** (based SOLELY on final `solutions.length`):
+```javascript
+// After generating all solutions
+if (solutions.length === 1) {
+  exec(`ccw issue bind ${issueId} ${solutions[0].id}`);  // MUST execute
+} else {
+  return { pending_selection: solutions };  // Return for user choice
+}
+```
 
 **Solution Evaluation** (for each candidate):
 ```javascript
 {
-  analysis: {
-    risk: "low|medium|high",      // Implementation risk
-    impact: "low|medium|high",    // Scope of changes
-    complexity: "low|medium|high" // Technical complexity
-  },
-  score: 0.0-1.0  // Overall quality score (higher = recommended)
+  analysis: { risk: "low|medium|high", impact: "low|medium|high", complexity: "low|medium|high" },
+  score: 0.0-1.0  // Higher = recommended
 }
 ```
 
-**Selection Flow**:
-1. Generate all candidate solutions
-2. Evaluate and score each
-3. Single solution → auto-bind
-4. Multiple solutions → return `pending_selection` for user choice
-
 **Task Decomposition** following schema:
 ```javascript
 function decomposeTasks(issue, exploration) {
-  return groups.map(group => ({
+  const tasks = groups.map(group => ({
     id: `T${taskId++}`,                    // Pattern: ^T[0-9]+$
     title: group.title,
     scope: inferScope(group),              // Module path
@@ -161,7 +243,35 @@ function decomposeTasks(issue, exploration) {
     },
     depends_on: inferDependencies(group, tasks),
     priority: calculatePriority(group)     // 1-5 (1=highest)
-  }))
+  }));
+
+  // GitHub Reply Task: Add final task if issue has github_url
+  if (issue.github_url || issue.github_number) {
+    const lastTaskId = tasks[tasks.length - 1]?.id;
+    tasks.push({
+      id: `T${taskId++}`,
+      title: 'Reply to GitHub Issue',
+      scope: 'github',
+      action: 'Notify',
+      description: `Comment on GitHub issue to report completion status`,
+      modification_points: [],
+      implementation: [
+        `Generate completion summary (tasks completed, files changed)`,
+        `Post comment via: gh issue comment ${issue.github_number || extractNumber(issue.github_url)} --body "..."`,
+        `Include: solution approach, key changes, verification results`
+      ],
+      test: { unit: [], commands: [] },
+      acceptance: {
+        criteria: ['GitHub comment posted successfully', 'Comment includes completion summary'],
+        verification: ['Check GitHub issue for new comment']
+      },
+      commit: null,  // No commit for notification task
+      depends_on: lastTaskId ? [lastTaskId] : [],  // Depends on last implementation task
+      priority: 5    // Lowest priority (run last)
+    });
+  }
+
+  return tasks;
 }
 ```
 
@@ -184,14 +294,14 @@ Write solution JSON to JSONL file (one line per solution):
 
 **File Format** (JSONL - each line is a complete solution):
 ```
-{"id":"SOL-GH-123-1","description":"...","approach":"...","analysis":{...},"score":0.85,"tasks":[...]}
-{"id":"SOL-GH-123-2","description":"...","approach":"...","analysis":{...},"score":0.75,"tasks":[...]}
+{"id":"SOL-GH-123-a7x9","description":"...","approach":"...","analysis":{...},"score":0.85,"tasks":[...]}
+{"id":"SOL-GH-123-b2k4","description":"...","approach":"...","analysis":{...},"score":0.75,"tasks":[...]}
 ```
 
 **Solution Schema** (must match CLI `Solution` interface):
 ```typescript
 {
-  id: string;                    // Format: SOL-{issue-id}-{N}
+  id: string;                    // Format: SOL-{issue-id}-{uid}
   description?: string;
   approach?: string;
   tasks: SolutionTask[];
@@ -204,9 +314,14 @@ Write solution JSON to JSONL file (one line per solution):
 **Write Operation**:
 ```javascript
 // Append solution to JSONL file (one line per solution)
-const solutionId = `SOL-${issueId}-${seq}`;
+// Use 4-char random uid to avoid collisions across multiple plan runs
+const uid = Math.random().toString(36).slice(2, 6);  // e.g., "a7x9"
+const solutionId = `SOL-${issueId}-${uid}`;
 const solutionLine = JSON.stringify({ id: solutionId, ...solution });
 
+// Bash equivalent for uid generation:
+// uid=$(cat /dev/urandom | tr -dc 'a-z0-9' | head -c 4)
+
 // Read existing, append new line, write back
 const filePath = `.workflow/issues/solutions/${issueId}.jsonl`;
 const existing = existsSync(filePath) ? readFileSync(filePath) : '';
@@ -215,8 +330,8 @@ Write({ file_path: filePath, content: newContent })
 ```
 
 **Step 2: Bind decision**
-- **Single solution** → Auto-bind: `ccw issue bind <issue-id> <solution-id>`
-- **Multiple solutions** → Return for user selection (no bind)
+- 1 solution → Execute `ccw issue bind <issue-id> <solution-id>`
+- 2+ solutions → Return `pending_selection` (no bind)
 
 ---
 
@@ -231,14 +346,7 @@ Write({ file_path: filePath, content: newContent })
 
 Each line is a solution JSON containing tasks. Schema: `cat .claude/workflows/cli-templates/schemas/solution-schema.json`
 
-### 2.2 Binding
-
-| Scenario | Action |
-|----------|--------|
-| Single solution | `ccw issue bind <issue-id> <solution-id>` (auto) |
-| Multiple solutions | Register only, return for selection |
-
-### 2.3 Return Summary
+### 2.2 Return Summary
 
 ```json
 {
@@ -271,16 +379,23 @@ Each line is a solution JSON containing tasks. Schema: `cat .claude/workflows/cl
 
 ### 3.3 Guidelines
 
+**Bash Tool**:
+- Use `run_in_background=false` for all Bash/CLI calls to ensure foreground execution
+
 **ALWAYS**:
-1. Read schema first: `cat .claude/workflows/cli-templates/schemas/solution-schema.json`
-2. Use ACE semantic search as PRIMARY exploration tool
-3. Fetch issue details via `ccw issue status <id> --json`
-4. Quantify acceptance.criteria with testable conditions
-5. Validate DAG before output
-6. Evaluate each solution with `analysis` and `score`
-7. Write solutions to `.workflow/issues/solutions/{issue-id}.jsonl` (append mode)
-8. For HIGH complexity: generate 2-3 candidate solutions
-9. **Solution ID format**: `SOL-{issue-id}-{N}` (e.g., `SOL-GH-123-1`, `SOL-GH-123-2`)
+1. **Search Tool Priority**: ACE (`mcp__ace-tool__search_context`) → CCW (`mcp__ccw-tools__smart_search`) / Built-in (`Grep`, `Glob`, `Read`)
+2. Read schema first: `cat .claude/workflows/cli-templates/schemas/solution-schema.json`
+3. Use ACE semantic search as PRIMARY exploration tool
+4. Fetch issue details via `ccw issue status <id> --json`
+5. **Analyze failure history**: Check `issue.feedback` for type='failure', stage='execute'
+6. **For replanning**: Reference previous failures in `solution.approach`, add prevention steps
+7. Quantify acceptance.criteria with testable conditions
+8. Validate DAG before output
+9. Evaluate each solution with `analysis` and `score`
+10. Write solutions to `.workflow/issues/solutions/{issue-id}.jsonl` (append mode)
+11. For HIGH complexity: generate 2-3 candidate solutions
+12. **Solution ID format**: `SOL-{issue-id}-{uid}` where uid is 4 random alphanumeric chars (e.g., `SOL-GH-123-a7x9`)
+13. **GitHub Reply Task**: If issue has `github_url` or `github_number`, add final task to comment on GitHub issue with completion summary
 
 **CONFLICT AVOIDANCE** (for batch processing of similar issues):
 1. **File isolation**: Each issue's solution should target distinct files when possible
@@ -294,9 +409,9 @@ Each line is a solution JSON containing tasks. Schema: `cat .claude/workflows/cl
 2. Use vague criteria ("works correctly", "good performance")
 3. Create circular dependencies
 4. Generate more than 10 tasks per issue
-5. **Bind when multiple solutions exist** - MUST check `solutions.length === 1` before calling `ccw issue bind`
+5. Skip bind when `solutions.length === 1` (MUST execute bind command)
 
 **OUTPUT**:
-1. Write solutions to `.workflow/issues/solutions/{issue-id}.jsonl` (JSONL format)
-2. Single solution → `ccw issue bind <issue-id> <solution-id>`; Multiple → return only
-3. Return JSON with `bound`, `pending_selection`
+1. Write solutions to `.workflow/issues/solutions/{issue-id}.jsonl`
+2. Execute bind or return `pending_selection` based on solution count
+3. Return JSON: `{ bound: [...], pending_selection: [...] }`

.claude/agents/issue-queue-agent.md

@@ -87,7 +87,7 @@ TASK: • Detect file conflicts (same file modified by multiple solutions)
 MODE: analysis
 CONTEXT: @.workflow/issues/solutions/**/*.jsonl | Solution data: \${SOLUTIONS_JSON}
 EXPECTED: JSON array of conflicts with type, severity, solutions, recommended_order
-RULES: $(cat ~/.claude/workflows/cli-templates/protocols/analysis-protocol.md) | Severity: high (API/data) > medium (file/dependency) > low (architecture)
+CONSTRAINTS: Severity: high (API/data) > medium (file/dependency) > low (architecture)
 " --tool gemini --mode analysis --cd .workflow/issues
 ```
 
@@ -271,8 +271,12 @@ Return brief summaries; full conflict details in separate files:
 
 ### 4.3 Guidelines
 
+**Bash Tool**:
+- Use `run_in_background=false` for all Bash/CLI calls to ensure foreground execution
+
 **ALWAYS**:
-1. Build dependency graph before ordering
+1. **Search Tool Priority**: ACE (`mcp__ace-tool__search_context`) → CCW (`mcp__ccw-tools__smart_search`) / Built-in (`Grep`, `Glob`, `Read`)
+2. Build dependency graph before ordering
 2. Detect file overlaps between solutions
 3. Apply resolution rules consistently
 4. Calculate semantic priority for all solutions

.claude/agents/memory-bridge.md

@@ -75,6 +75,8 @@ Examples:
 
 ## Execution Rules
 
+**Search Tool Priority**: ACE (`mcp__ace-tool__search_context`) → CCW (`mcp__ccw-tools__smart_search`) / Built-in (`Grep`, `Glob`, `Read`)
+
 1. **Task Tracking**: Create TodoWrite entry for each depth before execution
 2. **Parallelism**: Max 4 jobs per depth, sequential across depths
 3. **Strategy Assignment**: Assign strategy based on depth:

.claude/agents/test-context-search-agent.md

@@ -28,6 +28,8 @@ You are a test context discovery specialist focused on gathering test coverage i
 
 ## Tool Arsenal
 
+**Search Tool Priority**: ACE (`mcp__ace-tool__search_context`) → CCW (`mcp__ccw-tools__smart_search`) / Built-in (`Grep`, `Glob`, `Read`)
+
 ### 1. Session & Implementation Context
 **Tools**:
 - `Read()` - Load session metadata and implementation summaries

.claude/agents/test-fix-agent.md

@@ -59,6 +59,14 @@ When task JSON contains `flow_control` field, execute preparation and implementa
 2. **Variable Substitution**: Use `[variable_name]` to reference previous outputs
 3. **Error Handling**: Follow step-specific strategies (`skip_optional`, `fail`, `retry_once`)
 
+**Command-to-Tool Mapping** (for pre_analysis commands):
+```
+"Read(path)"            → Read tool: Read(file_path=path)
+"bash(command)"         → Bash tool: Bash(command=command)
+"Search(pattern,path)"  → Grep tool: Grep(pattern=pattern, path=path)
+"Glob(pattern)"         → Glob tool: Glob(pattern=pattern)
+```
+
 **Implementation Approach** (`flow_control.implementation_approach`):
 When task JSON contains implementation_approach array:
 1. **Sequential Execution**: Process steps in order, respecting `depends_on` dependencies
@@ -73,6 +81,12 @@ When task JSON contains implementation_approach array:
    - `command`: Optional CLI command (only when explicitly specified)
    - `depends_on`: Array of step numbers that must complete first
    - `output`: Variable name for this step's output
+5. **Execution Mode Selection**:
+   - IF `command` field exists → Execute CLI command via Bash tool
+   - ELSE (no command) → Agent direct execution:
+     - Parse `modification_points` as files to modify
+     - Follow `logic_flow` for test-fix iteration
+     - Use test_commands from flow_control for test execution
 
 
 ### 1. Context Assessment & Test Discovery
@@ -318,6 +332,7 @@ When generating test results for orchestrator (saved to `.process/test-results.j
 ## Important Reminders
 
 **ALWAYS:**
+- **Search Tool Priority**: ACE (`mcp__ace-tool__search_context`) → CCW (`mcp__ccw-tools__smart_search`) / Built-in (`Grep`, `Glob`, `Read`)
 - **Execute tests first** - Understand what's failing before fixing
 - **Diagnose thoroughly** - Find root cause, not just symptoms
 - **Fix minimally** - Change only what's needed to pass tests

.claude/agents/ui-design-agent.md

@@ -284,6 +284,8 @@ You execute 6 distinct task types organized into 3 patterns. Each task includes
 
 ### ALWAYS
 
+**Search Tool Priority**: ACE (`mcp__ace-tool__search_context`) → CCW (`mcp__ccw-tools__smart_search`) / Built-in (`Grep`, `Glob`, `Read`)
+
 **W3C Format Compliance**: ✅ Include $schema in all token files | ✅ Use $type metadata for all tokens | ✅ Use $value wrapper for color (light/dark), duration, easing | ✅ Validate token structure against W3C spec
 
 **Pattern Recognition**: ✅ Identify pattern from [TASK_TYPE_IDENTIFIER] first | ✅ Apply pattern-specific execution rules | ✅ Follow autonomy level

.claude/agents/universal-executor.md

@@ -120,7 +120,11 @@ Before completing any task, verify:
 - Make assumptions - verify with existing materials
 - Skip quality verification steps
 
+**Bash Tool**:
+- Use `run_in_background=false` for all Bash/CLI calls to ensure foreground execution
+
 **ALWAYS:**
+- **Search Tool Priority**: ACE (`mcp__ace-tool__search_context`) → CCW (`mcp__ccw-tools__smart_search`) / Built-in (`Grep`, `Glob`, `Read`)
 - Verify resource/dependency existence before referencing
 - Execute tasks systematically and incrementally
 - Test and validate work thoroughly

.claude/cli-settings.json

@@ -0,0 +1,18 @@
+{
+  "version": "1.0.0",
+  "defaultTool": "gemini",
+  "promptFormat": "plain",
+  "smartContext": {
+    "enabled": false,
+    "maxFiles": 10
+  },
+  "nativeResume": true,
+  "recursiveQuery": true,
+  "cache": {
+    "injectionMode": "auto",
+    "defaultPrefix": "",
+    "defaultSuffix": ""
+  },
+  "codeIndexMcp": "ace",
+  "$schema": "./cli-settings.schema.json"
+}

.claude/cli-tools.json

@@ -1,47 +0,0 @@
-{
-  "version": "1.0.0",
-  "tools": {
-    "gemini": {
-      "enabled": true,
-      "isBuiltin": true,
-      "command": "gemini",
-      "description": "Google AI for code analysis"
-    },
-    "qwen": {
-      "enabled": true,
-      "isBuiltin": true,
-      "command": "qwen",
-      "description": "Alibaba AI assistant"
-    },
-    "codex": {
-      "enabled": true,
-      "isBuiltin": true,
-      "command": "codex",
-      "description": "OpenAI code generation"
-    },
-    "claude": {
-      "enabled": true,
-      "isBuiltin": true,
-      "command": "claude",
-      "description": "Anthropic AI assistant"
-    }
-  },
-  "customEndpoints": [],
-  "defaultTool": "gemini",
-  "settings": {
-    "promptFormat": "plain",
-    "smartContext": {
-      "enabled": false,
-      "maxFiles": 10
-    },
-    "nativeResume": true,
-    "recursiveQuery": true,
-    "cache": {
-      "injectionMode": "auto",
-      "defaultPrefix": "",
-      "defaultSuffix": ""
-    },
-    "codeIndexMcp": "ace"
-  },
-  "$schema": "./cli-tools.schema.json"
-}

.claude/commands/cli/codex-review.md

@@ -0,0 +1,361 @@
+---
+name: codex-review
+description: Interactive code review using Codex CLI via ccw endpoint with configurable review target, model, and custom instructions
+argument-hint: "[--uncommitted|--base <branch>|--commit <sha>] [--model <model>] [--title <title>] [prompt]"
+allowed-tools: Bash(*), AskUserQuestion(*), Read(*)
+---
+
+# Codex Review Command (/cli:codex-review)
+
+## Overview
+Interactive code review command that invokes `codex review` via ccw cli endpoint with guided parameter selection.
+
+**Codex Review Parameters** (from `codex review --help`):
+| Parameter | Description |
+|-----------|-------------|
+| `[PROMPT]` | Custom review instructions (positional) |
+| `-c model=<model>` | Override model via config |
+| `--uncommitted` | Review staged, unstaged, and untracked changes |
+| `--base <BRANCH>` | Review changes against base branch |
+| `--commit <SHA>` | Review changes introduced by a commit |
+| `--title <TITLE>` | Optional commit title for review summary |
+
+## Prompt Template Format
+
+Follow the standard ccw cli prompt template:
+
+```
+PURPOSE: [what] + [why] + [success criteria] + [constraints/scope]
+TASK: • [step 1] • [step 2] • [step 3]
+MODE: review
+CONTEXT: [review target description] | Memory: [relevant context]
+EXPECTED: [deliverable format] + [quality criteria]
+CONSTRAINTS: [focus constraints]
+```
+
+## EXECUTION INSTRUCTIONS - START HERE
+
+**When this command is triggered, follow these exact steps:**
+
+### Step 1: Parse Arguments
+
+Check if user provided arguments directly:
+- `--uncommitted` → Record target = uncommitted
+- `--base <branch>` → Record target = base, branch name
+- `--commit <sha>` → Record target = commit, sha value
+- `--model <model>` → Record model selection
+- `--title <title>` → Record title
+- Remaining text → Use as custom focus/prompt
+
+If no target specified → Continue to Step 2 for interactive selection.
+
+### Step 2: Interactive Parameter Selection
+
+**2.1 Review Target Selection**
+
+```javascript
+AskUserQuestion({
+  questions: [{
+    question: "What do you want to review?",
+    header: "Review Target",
+    options: [
+      { label: "Uncommitted changes (Recommended)", description: "Review staged, unstaged, and untracked changes" },
+      { label: "Compare to branch", description: "Review changes against a base branch (e.g., main)" },
+      { label: "Specific commit", description: "Review changes introduced by a specific commit" }
+    ],
+    multiSelect: false
+  }]
+})
+```
+
+**2.2 Branch/Commit Input (if needed)**
+
+If "Compare to branch" selected:
+```javascript
+AskUserQuestion({
+  questions: [{
+    question: "Which base branch to compare against?",
+    header: "Base Branch",
+    options: [
+      { label: "main", description: "Compare against main branch" },
+      { label: "master", description: "Compare against master branch" },
+      { label: "develop", description: "Compare against develop branch" }
+    ],
+    multiSelect: false
+  }]
+})
+```
+
+If "Specific commit" selected:
+- Run `git log --oneline -10` to show recent commits
+- Ask user to provide commit SHA or select from list
+
+**2.3 Model Selection (Optional)**
+
+```javascript
+AskUserQuestion({
+  questions: [{
+    question: "Which model to use for review?",
+    header: "Model",
+    options: [
+      { label: "Default", description: "Use codex default model (gpt-5.2)" },
+      { label: "o3", description: "OpenAI o3 reasoning model" },
+      { label: "gpt-4.1", description: "GPT-4.1 model" },
+      { label: "o4-mini", description: "OpenAI o4-mini (faster)" }
+    ],
+    multiSelect: false
+  }]
+})
+```
+
+**2.4 Review Focus Selection**
+
+```javascript
+AskUserQuestion({
+  questions: [{
+    question: "What should the review focus on?",
+    header: "Focus Area",
+    options: [
+      { label: "General review (Recommended)", description: "Comprehensive review: correctness, style, bugs, docs" },
+      { label: "Security focus", description: "Security vulnerabilities, input validation, auth issues" },
+      { label: "Performance focus", description: "Performance bottlenecks, complexity, resource usage" },
+      { label: "Code quality", description: "Readability, maintainability, SOLID principles" }
+    ],
+    multiSelect: false
+  }]
+})
+```
+
+### Step 3: Build Prompt and Command
+
+**3.1 Construct Prompt Based on Focus**
+
+**General Review Prompt:**
+```
+PURPOSE: Comprehensive code review to identify issues, improve quality, and ensure best practices; success = actionable feedback with clear priorities
+TASK: • Review code correctness and logic errors • Check coding standards and consistency • Identify potential bugs and edge cases • Evaluate documentation completeness
+MODE: review
+CONTEXT: {target_description} | Memory: Project conventions from CLAUDE.md
+EXPECTED: Structured review report with: severity levels (Critical/High/Medium/Low), file:line references, specific improvement suggestions, priority ranking
+CONSTRAINTS: Focus on actionable feedback
+```
+
+**Security Focus Prompt:**
+```
+PURPOSE: Security-focused code review to identify vulnerabilities and security risks; success = all security issues documented with remediation
+TASK: • Scan for injection vulnerabilities (SQL, XSS, command) • Check authentication and authorization logic • Evaluate input validation and sanitization • Identify sensitive data exposure risks
+MODE: review
+CONTEXT: {target_description} | Memory: Security best practices, OWASP Top 10
+EXPECTED: Security report with: vulnerability classification, CVE references where applicable, remediation code snippets, risk severity matrix
+CONSTRAINTS: Security-first analysis | Flag all potential vulnerabilities
+```
+
+**Performance Focus Prompt:**
+```
+PURPOSE: Performance-focused code review to identify bottlenecks and optimization opportunities; success = measurable improvement recommendations
+TASK: • Analyze algorithmic complexity (Big-O) • Identify memory allocation issues • Check for N+1 queries and blocking operations • Evaluate caching opportunities
+MODE: review
+CONTEXT: {target_description} | Memory: Performance patterns and anti-patterns
+EXPECTED: Performance report with: complexity analysis, bottleneck identification, optimization suggestions with expected impact, benchmark recommendations
+CONSTRAINTS: Performance optimization focus
+```
+
+**Code Quality Focus Prompt:**
+```
+PURPOSE: Code quality review to improve maintainability and readability; success = cleaner, more maintainable code
+TASK: • Assess SOLID principles adherence • Identify code duplication and abstraction opportunities • Review naming conventions and clarity • Evaluate test coverage implications
+MODE: review
+CONTEXT: {target_description} | Memory: Project coding standards
+EXPECTED: Quality report with: principle violations, refactoring suggestions, naming improvements, maintainability score
+CONSTRAINTS: Code quality and maintainability focus
+```
+
+**3.2 Build Target Description**
+
+Based on selection, set `{target_description}`:
+- Uncommitted: `Reviewing uncommitted changes (staged + unstaged + untracked)`
+- Base branch: `Reviewing changes against {branch} branch`
+- Commit: `Reviewing changes introduced by commit {sha}`
+
+### Step 4: Execute via CCW CLI
+
+Build and execute the ccw cli command:
+
+```bash
+# Base structure
+ccw cli -p "<PROMPT>" --tool codex --mode review [OPTIONS]
+```
+
+**Command Construction:**
+
+```bash
+# Variables from user selection
+TARGET_FLAG=""      # --uncommitted | --base <branch> | --commit <sha>
+MODEL_FLAG=""       # --model <model> (if not default)
+TITLE_FLAG=""       # --title "<title>" (if provided)
+
+# Build target flag
+if [ "$target" = "uncommitted" ]; then
+  TARGET_FLAG="--uncommitted"
+elif [ "$target" = "base" ]; then
+  TARGET_FLAG="--base $branch"
+elif [ "$target" = "commit" ]; then
+  TARGET_FLAG="--commit $sha"
+fi
+
+# Build model flag (only if not default)
+if [ "$model" != "default" ] && [ -n "$model" ]; then
+  MODEL_FLAG="--model $model"
+fi
+
+# Build title flag (if provided)
+if [ -n "$title" ]; then
+  TITLE_FLAG="--title \"$title\""
+fi
+
+# Execute
+ccw cli -p "$PROMPT" --tool codex --mode review $TARGET_FLAG $MODEL_FLAG $TITLE_FLAG
+```
+
+**Full Example Commands:**
+
+**Option 1: With custom prompt (reviews uncommitted by default):**
+```bash
+ccw cli -p "
+PURPOSE: Comprehensive code review to identify issues and improve quality; success = actionable feedback with priorities
+TASK: • Review correctness and logic • Check standards compliance • Identify bugs and edge cases • Evaluate documentation
+MODE: review
+CONTEXT: Reviewing uncommitted changes | Memory: Project conventions
+EXPECTED: Structured report with severity levels, file:line refs, improvement suggestions
+CONSTRAINTS: Actionable feedback
+" --tool codex --mode review --rule analysis-review-code-quality
+```
+
+**Option 2: Target flag only (no prompt allowed):**
+```bash
+ccw cli --tool codex --mode review --uncommitted
+```
+
+### Step 5: Execute and Display Results
+
+```bash
+Bash({
+  command: "ccw cli -p \"$PROMPT\" --tool codex --mode review $FLAGS",
+  run_in_background: true
+})
+```
+
+Wait for completion and display formatted results.
+
+## Quick Usage Examples
+
+### Direct Execution (No Interaction)
+
+```bash
+# Review uncommitted changes with default settings
+/cli:codex-review --uncommitted
+
+# Review against main branch
+/cli:codex-review --base main
+
+# Review specific commit
+/cli:codex-review --commit abc123
+
+# Review with custom model
+/cli:codex-review --uncommitted --model o3
+
+# Review with security focus
+/cli:codex-review --uncommitted security
+
+# Full options
+/cli:codex-review --base main --model o3 --title "Auth Feature" security
+```
+
+### Interactive Mode
+
+```bash
+# Start interactive selection (guided flow)
+/cli:codex-review
+```
+
+## Focus Area Mapping
+
+| User Selection | Prompt Focus | Key Checks |
+|----------------|--------------|------------|
+| General review | Comprehensive | Correctness, style, bugs, docs |
+| Security focus | Security-first | Injection, auth, validation, exposure |
+| Performance focus | Optimization | Complexity, memory, queries, caching |
+| Code quality | Maintainability | SOLID, duplication, naming, tests |
+
+## Error Handling
+
+### No Changes to Review
+```
+No changes found for review target. Suggestions:
+- For --uncommitted: Make some code changes first
+- For --base: Ensure branch exists and has diverged
+- For --commit: Verify commit SHA exists
+```
+
+### Invalid Branch
+```bash
+# Show available branches
+git branch -a --list | head -20
+```
+
+### Invalid Commit
+```bash
+# Show recent commits
+git log --oneline -10
+```
+
+## Integration Notes
+
+- Uses `ccw cli --tool codex --mode review` endpoint
+- Model passed via prompt (codex uses `-c model=` internally)
+- Target flags (`--uncommitted`, `--base`, `--commit`) passed through to codex
+- Prompt follows standard ccw cli template format for consistency
+
+## Validation Constraints
+
+**IMPORTANT: Target flags and prompt are mutually exclusive**
+
+The codex CLI has a constraint where target flags (`--uncommitted`, `--base`, `--commit`) cannot be used with a positional `[PROMPT]` argument:
+
+```
+error: the argument '--uncommitted' cannot be used with '[PROMPT]'
+error: the argument '--base <BRANCH>' cannot be used with '[PROMPT]'
+error: the argument '--commit <SHA>' cannot be used with '[PROMPT]'
+```
+
+**Behavior:**
+- When ANY target flag is specified, ccw cli automatically skips template concatenation (systemRules/roles)
+- The review uses codex's default review behavior for the specified target
+- Custom prompts are only supported WITHOUT target flags (reviews uncommitted changes by default)
+
+**Valid combinations:**
+| Command | Result |
+|---------|--------|
+| `codex review "Focus on security"` | ✓ Custom prompt, reviews uncommitted (default) |
+| `codex review --uncommitted` | ✓ No prompt, uses default review |
+| `codex review --base main` | ✓ No prompt, uses default review |
+| `codex review --commit abc123` | ✓ No prompt, uses default review |
+| `codex review --uncommitted "prompt"` | ✗ Invalid - mutually exclusive |
+| `codex review --base main "prompt"` | ✗ Invalid - mutually exclusive |
+| `codex review --commit abc123 "prompt"` | ✗ Invalid - mutually exclusive |
+
+**Examples:**
+```bash
+# ✓ Valid: prompt only (reviews uncommitted by default)
+ccw cli -p "Focus on security" --tool codex --mode review
+
+# ✓ Valid: target flag only (no prompt)
+ccw cli --tool codex --mode review --uncommitted
+ccw cli --tool codex --mode review --base main
+ccw cli --tool codex --mode review --commit abc123
+
+# ✗ Invalid: target flag with prompt (will fail)
+ccw cli -p "Review this" --tool codex --mode review --uncommitted
+ccw cli -p "Review this" --tool codex --mode review --base main
+ccw cli -p "Review this" --tool codex --mode review --commit abc123
+```

.claude/commands/issue/discover-by-prompt.md

@@ -0,0 +1,764 @@
+---
+name: issue:discover-by-prompt
+description: Discover issues from user prompt with Gemini-planned iterative multi-agent exploration. Uses ACE semantic search for context gathering and supports cross-module comparison (e.g., frontend vs backend API contracts).
+argument-hint: "<prompt> [--scope=src/**] [--depth=standard|deep] [--max-iterations=5]"
+allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*), Task(*), AskUserQuestion(*), Glob(*), Grep(*), mcp__ace-tool__search_context(*), mcp__exa__search(*)
+---
+
+# Issue Discovery by Prompt
+
+## Quick Start
+
+```bash
+# Discover issues based on user description
+/issue:discover-by-prompt "Check if frontend API calls match backend implementations"
+
+# Compare specific modules
+/issue:discover-by-prompt "Verify auth flow consistency between mobile and web clients" --scope=src/auth/**,src/mobile/**
+
+# Deep exploration with more iterations
+/issue:discover-by-prompt "Find all places where error handling is inconsistent" --depth=deep --max-iterations=8
+
+# Focused backend-frontend contract check
+/issue:discover-by-prompt "Compare REST API definitions with frontend fetch calls"
+```
+
+**Core Difference from `/issue:discover`**:
+- `discover`: Pre-defined perspectives (bug, security, etc.), parallel execution
+- `discover-by-prompt`: User-driven prompt, Gemini-planned strategy, iterative exploration
+
+## What & Why
+
+### Core Concept
+
+Prompt-driven issue discovery with intelligent planning. Instead of fixed perspectives, this command:
+
+1. **Analyzes user intent** via Gemini to understand what to find
+2. **Plans exploration strategy** dynamically based on codebase structure
+3. **Executes iterative multi-agent exploration** with feedback loops
+4. **Performs cross-module comparison** when detecting comparison intent
+
+### Value Proposition
+
+1. **Natural Language Input**: Describe what you want to find, not how to find it
+2. **Intelligent Planning**: Gemini designs optimal exploration strategy
+3. **Iterative Refinement**: Each round builds on previous discoveries
+4. **Cross-Module Analysis**: Compare frontend/backend, mobile/web, old/new implementations
+5. **Adaptive Exploration**: Adjusts direction based on findings
+
+### Use Cases
+
+| Scenario | Example Prompt |
+|----------|----------------|
+| API Contract | "Check if frontend calls match backend endpoints" |
+| Error Handling | "Find inconsistent error handling patterns" |
+| Migration Gap | "Compare old auth with new auth implementation" |
+| Feature Parity | "Verify mobile has all web features" |
+| Schema Drift | "Check if TypeScript types match API responses" |
+| Integration | "Find mismatches between service A and service B" |
+
+## How It Works
+
+### Execution Flow
+
+```
+Phase 1: Prompt Analysis & Initialization
+   ├─ Parse user prompt and flags
+   ├─ Detect exploration intent (comparison/search/verification)
+   └─ Initialize discovery session
+
+Phase 1.5: ACE Context Gathering
+   ├─ Use ACE semantic search to understand codebase structure
+   ├─ Identify relevant modules based on prompt keywords
+   ├─ Collect architecture context for Gemini planning
+   └─ Build initial context package
+
+Phase 2: Gemini Strategy Planning
+   ├─ Feed ACE context + prompt to Gemini CLI
+   ├─ Gemini analyzes and generates exploration strategy
+   ├─ Create exploration dimensions with search targets
+   ├─ Define comparison matrix (if comparison intent)
+   └─ Set success criteria and iteration limits
+
+Phase 3: Iterative Agent Exploration (with ACE)
+   ├─ Iteration 1: Initial exploration by assigned agents
+   │   ├─ Agent A: ACE search + explore dimension 1
+   │   ├─ Agent B: ACE search + explore dimension 2
+   │   └─ Collect findings, update shared context
+   ├─ Iteration 2-N: Refined exploration
+   │   ├─ Analyze previous findings
+   │   ├─ ACE search for related code paths
+   │   ├─ Execute targeted exploration
+   │   └─ Update cumulative findings
+   └─ Termination: Max iterations or convergence
+
+Phase 4: Cross-Analysis & Synthesis
+   ├─ Compare findings across dimensions
+   ├─ Identify discrepancies and issues
+   ├─ Calculate confidence scores
+   └─ Generate issue candidates
+
+Phase 5: Issue Generation & Summary
+   ├─ Convert findings to issue format
+   ├─ Write discovery outputs
+   └─ Prompt user for next action
+```
+
+### Exploration Dimensions
+
+Dimensions are **dynamically generated by Gemini** based on the user prompt. Not limited to predefined categories.
+
+**Examples**:
+
+| Prompt | Generated Dimensions |
+|--------|---------------------|
+| "Check API contracts" | frontend-calls, backend-handlers |
+| "Find auth issues" | auth-module (single dimension) |
+| "Compare old/new implementations" | legacy-code, new-code |
+| "Audit payment flow" | payment-service, validation, logging |
+| "Find error handling gaps" | error-handlers, error-types, recovery-logic |
+
+Gemini analyzes the prompt + ACE context to determine:
+- How many dimensions are needed (1 to N)
+- What each dimension should focus on
+- Whether comparison is needed between dimensions
+
+### Iteration Strategy
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                    Iteration Loop                           │
+├─────────────────────────────────────────────────────────────┤
+│  1. Plan: What to explore this iteration                    │
+│     └─ Based on: previous findings + unexplored areas       │
+│                                                             │
+│  2. Execute: Launch agents for this iteration               │
+│     └─ Each agent: explore → collect → return summary       │
+│                                                             │
+│  3. Analyze: Process iteration results                      │
+│     └─ New findings? Gaps? Contradictions?                  │
+│                                                             │
+│  4. Decide: Continue or terminate                           │
+│     └─ Terminate if: max iterations OR convergence OR       │
+│                      high confidence on all questions       │
+└─────────────────────────────────────────────────────────────┘
+```
+
+## Core Responsibilities
+
+### Phase 1: Prompt Analysis & Initialization
+
+```javascript
+// Step 1: Parse arguments
+const { prompt, scope, depth, maxIterations } = parseArgs(args);
+
+// Step 2: Generate discovery ID
+const discoveryId = `DBP-${formatDate(new Date(), 'YYYYMMDD-HHmmss')}`;
+
+// Step 3: Create output directory
+const outputDir = `.workflow/issues/discoveries/${discoveryId}`;
+await mkdir(outputDir, { recursive: true });
+await mkdir(`${outputDir}/iterations`, { recursive: true });
+
+// Step 4: Detect intent type from prompt
+const intentType = detectIntent(prompt);
+// Returns: 'comparison' | 'search' | 'verification' | 'audit'
+
+// Step 5: Initialize discovery state
+await writeJson(`${outputDir}/discovery-state.json`, {
+  discovery_id: discoveryId,
+  type: 'prompt-driven',
+  prompt: prompt,
+  intent_type: intentType,
+  scope: scope || '**/*',
+  depth: depth || 'standard',
+  max_iterations: maxIterations || 5,
+  phase: 'initialization',
+  created_at: new Date().toISOString(),
+  iterations: [],
+  cumulative_findings: [],
+  comparison_matrix: null  // filled for comparison intent
+});
+```
+
+### Phase 1.5: ACE Context Gathering
+
+**Purpose**: Use ACE semantic search to gather codebase context before Gemini planning.
+
+```javascript
+// Step 1: Extract keywords from prompt for semantic search
+const keywords = extractKeywords(prompt);
+// e.g., "frontend API calls match backend" → ["frontend", "API", "backend", "endpoints"]
+
+// Step 2: Use ACE to understand codebase structure
+const aceQueries = [
+  `Project architecture and module structure for ${keywords.join(', ')}`,
+  `Where are ${keywords[0]} implementations located?`,
+  `How does ${keywords.slice(0, 2).join(' ')} work in this codebase?`
+];
+
+const aceResults = [];
+for (const query of aceQueries) {
+  const result = await mcp__ace-tool__search_context({
+    project_root_path: process.cwd(),
+    query: query
+  });
+  aceResults.push({ query, result });
+}
+
+// Step 3: Build context package for Gemini (kept in memory)
+const aceContext = {
+  prompt_keywords: keywords,
+  codebase_structure: aceResults[0].result,
+  relevant_modules: aceResults.slice(1).map(r => r.result),
+  detected_patterns: extractPatterns(aceResults)
+};
+
+// Step 4: Update state (no separate file)
+await updateDiscoveryState(outputDir, {
+  phase: 'context-gathered',
+  ace_context: {
+    queries_executed: aceQueries.length,
+    modules_identified: aceContext.relevant_modules.length
+  }
+});
+
+// aceContext passed to Phase 2 in memory
+```
+
+**ACE Query Strategy by Intent Type**:
+
+| Intent | ACE Queries |
+|--------|-------------|
+| **comparison** | "frontend API calls", "backend API handlers", "API contract definitions" |
+| **search** | "{keyword} implementations", "{keyword} usage patterns" |
+| **verification** | "expected behavior for {feature}", "test coverage for {feature}" |
+| **audit** | "all {category} patterns", "{category} security concerns" |
+
+### Phase 2: Gemini Strategy Planning
+
+**Purpose**: Gemini analyzes user prompt + ACE context to design optimal exploration strategy.
+
+```javascript
+// Step 1: Load ACE context gathered in Phase 1.5
+const aceContext = await readJson(`${outputDir}/ace-context.json`);
+
+// Step 2: Build Gemini planning prompt with ACE context
+const planningPrompt = `
+PURPOSE: Analyze discovery prompt and create exploration strategy based on codebase context
+TASK:
+• Parse user intent from prompt: "${prompt}"
+• Use codebase context to identify specific modules and files to explore
+• Create exploration dimensions with precise search targets
+• Define comparison matrix structure (if comparison intent)
+• Set success criteria and iteration strategy
+MODE: analysis
+CONTEXT: @${scope || '**/*'} | Discovery type: ${intentType}
+
+## Codebase Context (from ACE semantic search)
+${JSON.stringify(aceContext, null, 2)}
+
+EXPECTED: JSON exploration plan following exploration-plan-schema.json:
+{
+  "intent_analysis": { "type": "${intentType}", "primary_question": "...", "sub_questions": [...] },
+  "dimensions": [{ "name": "...", "description": "...", "search_targets": [...], "focus_areas": [...], "agent_prompt": "..." }],
+  "comparison_matrix": { "dimension_a": "...", "dimension_b": "...", "comparison_points": [...] },
+  "success_criteria": [...],
+  "estimated_iterations": N,
+  "termination_conditions": [...]
+}
+CONSTRAINTS: Use ACE context to inform targets | Focus on actionable plan
+`;
+
+// Step 3: Execute Gemini planning
+Bash({
+  command: `ccw cli -p "${planningPrompt}" --tool gemini --mode analysis`,
+  run_in_background: true,
+  timeout: 300000
+});
+
+// Step 4: Parse Gemini output and validate against schema
+const explorationPlan = await parseGeminiPlanOutput(geminiResult);
+validateAgainstSchema(explorationPlan, 'exploration-plan-schema.json');
+
+// Step 5: Enhance plan with ACE-discovered file paths
+explorationPlan.dimensions = explorationPlan.dimensions.map(dim => ({
+  ...dim,
+  ace_suggested_files: aceContext.relevant_modules
+    .filter(m => m.relevance_to === dim.name)
+    .map(m => m.file_path)
+}));
+
+// Step 6: Update state (plan kept in memory, not persisted)
+await updateDiscoveryState(outputDir, {
+  phase: 'planned',
+  exploration_plan: {
+    dimensions_count: explorationPlan.dimensions.length,
+    has_comparison_matrix: !!explorationPlan.comparison_matrix,
+    estimated_iterations: explorationPlan.estimated_iterations
+  }
+});
+
+// explorationPlan passed to Phase 3 in memory
+```
+
+**Gemini Planning Responsibilities**:
+
+| Responsibility | Input | Output |
+|----------------|-------|--------|
+| Intent Analysis | User prompt | type, primary_question, sub_questions |
+| Dimension Design | ACE context + prompt | dimensions with search_targets |
+| Comparison Matrix | Intent type + modules | comparison_points (if applicable) |
+| Iteration Strategy | Depth setting | estimated_iterations, termination_conditions |
+
+**Gemini Planning Output Schema**:
+
+```json
+{
+  "intent_analysis": {
+    "type": "comparison|search|verification|audit",
+    "primary_question": "string",
+    "sub_questions": ["string"]
+  },
+  "dimensions": [
+    {
+      "name": "frontend",
+      "description": "Client-side API calls and error handling",
+      "search_targets": ["src/api/**", "src/hooks/**"],
+      "focus_areas": ["fetch calls", "error boundaries", "response parsing"],
+      "agent_prompt": "Explore frontend API consumption patterns..."
+    },
+    {
+      "name": "backend",
+      "description": "Server-side API implementations",
+      "search_targets": ["src/server/**", "src/routes/**"],
+      "focus_areas": ["endpoint handlers", "response schemas", "error responses"],
+      "agent_prompt": "Explore backend API implementations..."
+    }
+  ],
+  "comparison_matrix": {
+    "dimension_a": "frontend",
+    "dimension_b": "backend",
+    "comparison_points": [
+      {"aspect": "endpoints", "frontend_check": "fetch URLs", "backend_check": "route paths"},
+      {"aspect": "methods", "frontend_check": "HTTP methods used", "backend_check": "methods accepted"},
+      {"aspect": "payloads", "frontend_check": "request body structure", "backend_check": "expected schema"},
+      {"aspect": "responses", "frontend_check": "response parsing", "backend_check": "response format"},
+      {"aspect": "errors", "frontend_check": "error handling", "backend_check": "error responses"}
+    ]
+  },
+  "success_criteria": [
+    "All API endpoints mapped between frontend and backend",
+    "Discrepancies identified with file:line references",
+    "Each finding includes remediation suggestion"
+  ],
+  "estimated_iterations": 3,
+  "termination_conditions": [
+    "All comparison points verified",
+    "No new findings in last iteration",
+    "Confidence > 0.8 on primary question"
+  ]
+}
+```
+
+### Phase 3: Iterative Agent Exploration (with ACE)
+
+**Purpose**: Multi-agent iterative exploration using ACE for semantic search within each iteration.
+
+```javascript
+let iteration = 0;
+let cumulativeFindings = [];
+let sharedContext = { aceDiscoveries: [], crossReferences: [] };
+let shouldContinue = true;
+
+while (shouldContinue && iteration < maxIterations) {
+  iteration++;
+  const iterationDir = `${outputDir}/iterations/${iteration}`;
+  await mkdir(iterationDir, { recursive: true });
+
+  // Step 1: ACE-assisted iteration planning
+  // Use previous findings to guide ACE queries for this iteration
+  const iterationAceQueries = iteration === 1
+    ? explorationPlan.dimensions.map(d => d.focus_areas[0])  // Initial queries from plan
+    : deriveQueriesFromFindings(cumulativeFindings);         // Follow-up queries from findings
+
+  // Execute ACE searches to find related code
+  const iterationAceResults = [];
+  for (const query of iterationAceQueries) {
+    const result = await mcp__ace-tool__search_context({
+      project_root_path: process.cwd(),
+      query: `${query} in ${explorationPlan.scope}`
+    });
+    iterationAceResults.push({ query, result });
+  }
+
+  // Update shared context with ACE discoveries
+  sharedContext.aceDiscoveries.push(...iterationAceResults);
+
+  // Step 2: Plan this iteration based on ACE results
+  const iterationPlan = planIteration(iteration, explorationPlan, cumulativeFindings, iterationAceResults);
+
+  // Step 3: Launch dimension agents with ACE context
+  const agentPromises = iterationPlan.dimensions.map(dimension =>
+    Task({
+      subagent_type: "cli-explore-agent",
+      run_in_background: false,
+      description: `Explore ${dimension.name} (iteration ${iteration})`,
+      prompt: buildDimensionPromptWithACE(dimension, iteration, cumulativeFindings, iterationAceResults, iterationDir)
+    })
+  );
+
+  // Wait for iteration agents
+  const iterationResults = await Promise.all(agentPromises);
+
+  // Step 4: Collect and analyze iteration findings
+  const iterationFindings = await collectIterationFindings(iterationDir, iterationPlan.dimensions);
+
+  // Step 5: Cross-reference findings between dimensions
+  if (iterationPlan.dimensions.length > 1) {
+    const crossRefs = findCrossReferences(iterationFindings, iterationPlan.dimensions);
+    sharedContext.crossReferences.push(...crossRefs);
+  }
+
+  cumulativeFindings.push(...iterationFindings);
+
+  // Step 6: Decide whether to continue
+  const convergenceCheck = checkConvergence(iterationFindings, cumulativeFindings, explorationPlan);
+  shouldContinue = !convergenceCheck.converged;
+
+  // Step 7: Update state (iteration summary embedded in state)
+  await updateDiscoveryState(outputDir, {
+    iterations: [...state.iterations, {
+      number: iteration,
+      findings_count: iterationFindings.length,
+      ace_queries: iterationAceQueries.length,
+      cross_references: sharedContext.crossReferences.length,
+      new_discoveries: convergenceCheck.newDiscoveries,
+      confidence: convergenceCheck.confidence,
+      continued: shouldContinue
+    }],
+    cumulative_findings: cumulativeFindings
+  });
+}
+```
+
+**ACE in Iteration Loop**:
+
+```
+Iteration N
+    │
+    ├─→ ACE Search (based on previous findings)
+    │   └─ Query: "related code paths for {finding.category}"
+    │   └─ Result: Additional files to explore
+    │
+    ├─→ Agent Exploration (with ACE context)
+    │   └─ Agent receives: dimension targets + ACE suggestions
+    │   └─ Agent can call ACE for deeper search
+    │
+    ├─→ Cross-Reference Analysis
+    │   └─ Compare findings between dimensions
+    │   └─ Identify discrepancies
+    │
+    └─→ Convergence Check
+        └─ New findings? Continue
+        └─ No new findings? Terminate
+```
+
+**Dimension Agent Prompt Template (with ACE)**:
+
+```javascript
+function buildDimensionPromptWithACE(dimension, iteration, previousFindings, aceResults, outputDir) {
+  // Filter ACE results relevant to this dimension
+  const relevantAceResults = aceResults.filter(r =>
+    r.query.includes(dimension.name) || dimension.focus_areas.some(fa => r.query.includes(fa))
+  );
+
+  return `
+    ## Task Objective
+    Explore ${dimension.name} dimension for issue discovery (Iteration ${iteration})
+
+    ## Context
+    - Dimension: ${dimension.name}
+    - Description: ${dimension.description}
+    - Search Targets: ${dimension.search_targets.join(', ')}
+    - Focus Areas: ${dimension.focus_areas.join(', ')}
+
+    ## ACE Semantic Search Results (Pre-gathered)
+    The following files/code sections were identified by ACE as relevant to this dimension:
+    ${JSON.stringify(relevantAceResults.map(r => ({ query: r.query, files: r.result.slice(0, 5) })), null, 2)}
+
+    **Use ACE for deeper exploration**: You have access to mcp__ace-tool__search_context.
+    When you find something interesting, use ACE to find related code:
+    - mcp__ace-tool__search_context({ project_root_path: ".", query: "related to {finding}" })
+
+    ${iteration > 1 ? `
+    ## Previous Findings to Build Upon
+    ${summarizePreviousFindings(previousFindings, dimension.name)}
+
+    ## This Iteration Focus
+    - Explore areas not yet covered (check ACE results for new files)
+    - Verify/deepen previous findings
+    - Follow leads from previous discoveries
+    - Use ACE to find cross-references between dimensions
+    ` : ''}
+
+    ## MANDATORY FIRST STEPS
+    1. Read exploration plan: ${outputDir}/../exploration-plan.json
+    2. Read schema: ~/.claude/workflows/cli-templates/schemas/discovery-finding-schema.json
+    3. Review ACE results above for starting points
+    4. Explore files identified by ACE
+
+    ## Exploration Instructions
+    ${dimension.agent_prompt}
+
+    ## ACE Usage Guidelines
+    - Use ACE when you need to find:
+      - Where a function/class is used
+      - Related implementations in other modules
+      - Cross-module dependencies
+      - Similar patterns elsewhere in codebase
+    - Query format: Natural language, be specific
+    - Example: "Where is UserService.authenticate called from?"
+
+    ## Output Requirements
+
+    **1. Write JSON file**: ${outputDir}/${dimension.name}.json
+    Follow discovery-finding-schema.json:
+    - findings: [{id, title, category, description, file, line, snippet, confidence, related_dimension}]
+    - coverage: {files_explored, areas_covered, areas_remaining}
+    - leads: [{description, suggested_search}] // for next iteration
+    - ace_queries_used: [{query, result_count}] // track ACE usage
+
+    **2. Return summary**:
+    - Total findings this iteration
+    - Key discoveries
+    - ACE queries that revealed important code
+    - Recommended next exploration areas
+
+    ## Success Criteria
+    - [ ] JSON written to ${outputDir}/${dimension.name}.json
+    - [ ] Each finding has file:line reference
+    - [ ] ACE used for cross-references where applicable
+    - [ ] Coverage report included
+    - [ ] Leads for next iteration identified
+  `;
+}
+```
+
+### Phase 4: Cross-Analysis & Synthesis
+
+```javascript
+// For comparison intent, perform cross-analysis
+if (intentType === 'comparison' && explorationPlan.comparison_matrix) {
+  const comparisonResults = [];
+
+  for (const point of explorationPlan.comparison_matrix.comparison_points) {
+    const dimensionAFindings = cumulativeFindings.filter(f =>
+      f.related_dimension === explorationPlan.comparison_matrix.dimension_a &&
+      f.category.includes(point.aspect)
+    );
+
+    const dimensionBFindings = cumulativeFindings.filter(f =>
+      f.related_dimension === explorationPlan.comparison_matrix.dimension_b &&
+      f.category.includes(point.aspect)
+    );
+
+    // Compare and find discrepancies
+    const discrepancies = findDiscrepancies(dimensionAFindings, dimensionBFindings, point);
+
+    comparisonResults.push({
+      aspect: point.aspect,
+      dimension_a_count: dimensionAFindings.length,
+      dimension_b_count: dimensionBFindings.length,
+      discrepancies: discrepancies,
+      match_rate: calculateMatchRate(dimensionAFindings, dimensionBFindings)
+    });
+  }
+
+  // Write comparison analysis
+  await writeJson(`${outputDir}/comparison-analysis.json`, {
+    matrix: explorationPlan.comparison_matrix,
+    results: comparisonResults,
+    summary: {
+      total_discrepancies: comparisonResults.reduce((sum, r) => sum + r.discrepancies.length, 0),
+      overall_match_rate: average(comparisonResults.map(r => r.match_rate)),
+      critical_mismatches: comparisonResults.filter(r => r.match_rate < 0.5)
+    }
+  });
+}
+
+// Prioritize all findings
+const prioritizedFindings = prioritizeFindings(cumulativeFindings, explorationPlan);
+```
+
+### Phase 5: Issue Generation & Summary
+
+```javascript
+// Convert high-confidence findings to issues
+const issueWorthy = prioritizedFindings.filter(f =>
+  f.confidence >= 0.7 || f.priority === 'critical' || f.priority === 'high'
+);
+
+const issues = issueWorthy.map(finding => ({
+  id: `ISS-${discoveryId}-${finding.id}`,
+  title: finding.title,
+  description: finding.description,
+  source: {
+    discovery_id: discoveryId,
+    finding_id: finding.id,
+    dimension: finding.related_dimension
+  },
+  file: finding.file,
+  line: finding.line,
+  priority: finding.priority,
+  category: finding.category,
+  suggested_fix: finding.suggested_fix,
+  confidence: finding.confidence,
+  status: 'discovered',
+  created_at: new Date().toISOString()
+}));
+
+// Write issues
+await writeJsonl(`${outputDir}/discovery-issues.jsonl`, issues);
+
+// Update final state (summary embedded in state, no separate file)
+await updateDiscoveryState(outputDir, {
+  phase: 'complete',
+  updated_at: new Date().toISOString(),
+  results: {
+    total_iterations: iteration,
+    total_findings: cumulativeFindings.length,
+    issues_generated: issues.length,
+    comparison_match_rate: comparisonResults
+      ? average(comparisonResults.map(r => r.match_rate))
+      : null
+  }
+});
+
+// Prompt user for next action
+await AskUserQuestion({
+  questions: [{
+    question: `Discovery complete: ${issues.length} issues from ${cumulativeFindings.length} findings across ${iteration} iterations. What next?`,
+    header: "Next Step",
+    multiSelect: false,
+    options: [
+      { label: "Export to Issues (Recommended)", description: `Export ${issues.length} issues for planning` },
+      { label: "Review Details", description: "View comparison analysis and iteration details" },
+      { label: "Run Deeper", description: "Continue with more iterations" },
+      { label: "Skip", description: "Complete without exporting" }
+    ]
+  }]
+});
+```
+
+## Output File Structure
+
+```
+.workflow/issues/discoveries/
+└── {DBP-YYYYMMDD-HHmmss}/
+    ├── discovery-state.json          # Session state with iteration tracking
+    ├── iterations/
+    │   ├── 1/
+    │   │   └── {dimension}.json      # Dimension findings
+    │   ├── 2/
+    │   │   └── {dimension}.json
+    │   └── ...
+    ├── comparison-analysis.json      # Cross-dimension comparison (if applicable)
+    └── discovery-issues.jsonl        # Generated issue candidates
+```
+
+**Simplified Design**:
+- ACE context and Gemini plan kept in memory, not persisted
+- Iteration summaries embedded in state
+- No separate summary.md (state.json contains all needed info)
+
+## Schema References
+
+| Schema | Path | Used By |
+|--------|------|---------|
+| **Discovery State** | `discovery-state-schema.json` | Orchestrator (state tracking) |
+| **Discovery Finding** | `discovery-finding-schema.json` | Dimension agents (output) |
+| **Exploration Plan** | `exploration-plan-schema.json` | Gemini output validation (memory only) |
+
+## Configuration Options
+
+| Flag | Default | Description |
+|------|---------|-------------|
+| `--scope` | `**/*` | File pattern to explore |
+| `--depth` | `standard` | `standard` (3 iterations) or `deep` (5+ iterations) |
+| `--max-iterations` | 5 | Maximum exploration iterations |
+| `--tool` | `gemini` | Planning tool (gemini/qwen) |
+| `--plan-only` | `false` | Stop after Phase 2 (Gemini planning), show plan for user review |
+
+## Examples
+
+### Example 1: Single Module Deep Dive
+
+```bash
+/issue:discover-by-prompt "Find all potential issues in the auth module" --scope=src/auth/**
+```
+
+**Gemini plans** (single dimension):
+- Dimension: auth-module
+- Focus: security vulnerabilities, edge cases, error handling, test gaps
+
+**Iterations**: 2-3 (until no new findings)
+
+### Example 2: API Contract Comparison
+
+```bash
+/issue:discover-by-prompt "Check if API calls match implementations" --scope=src/**
+```
+
+**Gemini plans** (comparison):
+- Dimension 1: api-consumers (fetch calls, hooks, services)
+- Dimension 2: api-providers (handlers, routes, controllers)
+- Comparison matrix: endpoints, methods, payloads, responses
+
+### Example 3: Multi-Module Audit
+
+```bash
+/issue:discover-by-prompt "Audit the payment flow for issues" --scope=src/payment/**
+```
+
+**Gemini plans** (multi-dimension):
+- Dimension 1: payment-logic (calculations, state transitions)
+- Dimension 2: validation (input checks, business rules)
+- Dimension 3: error-handling (failure modes, recovery)
+
+### Example 4: Plan Only Mode
+
+```bash
+/issue:discover-by-prompt "Find inconsistent patterns" --plan-only
+```
+
+Stops after Gemini planning, outputs:
+```
+Gemini Plan:
+- Intent: search
+- Dimensions: 2 (pattern-definitions, pattern-usages)
+- Estimated iterations: 3
+
+Continue with exploration? [Y/n]
+```
+
+## Related Commands
+
+```bash
+# After discovery, plan solutions
+/issue:plan DBP-001-01,DBP-001-02
+
+# View all discoveries
+/issue:manage
+
+# Standard perspective-based discovery
+/issue:discover src/auth/** --perspectives=security,bug
+```
+
+## Best Practices
+
+1. **Be Specific in Prompts**: More specific prompts lead to better Gemini planning
+2. **Scope Appropriately**: Narrow scope for focused comparison, wider for audits
+3. **Review Exploration Plan**: Check `exploration-plan.json` before long explorations
+4. **Use Standard Depth First**: Start with standard, go deep only if needed
+5. **Combine with `/issue:discover`**: Use prompt-based for comparisons, perspective-based for audits

.claude/commands/issue/discover.md

@@ -73,6 +73,9 @@ Phase 5: Issue Generation & Summary
    ├─ Write to discovery-issues.jsonl
    ├─ Generate single summary.md from agent returns
    └─ Update discovery-state.json to complete
+
+Phase 6: User Action Prompt
+   └─ AskUserQuestion for next step (export/dashboard/skip)
 ```
 
 ## Perspectives
@@ -238,6 +241,44 @@ await updateDiscoveryState(outputDir, {
 });
 ```
 
+**Phase 6: User Action Prompt**
+
+```javascript
+// Prompt user for next action based on discovery results
+const hasHighPriority = issues.some(i => i.priority === 'critical' || i.priority === 'high');
+const hasMediumFindings = prioritizedFindings.some(f => f.priority === 'medium');
+
+await AskUserQuestion({
+  questions: [{
+    question: `Discovery complete: ${issues.length} issues generated, ${prioritizedFindings.length} total findings. What would you like to do next?`,
+    header: "Next Step",
+    multiSelect: false,
+    options: hasHighPriority ? [
+      { label: "Export to Issues (Recommended)", description: `${issues.length} high-priority issues found - export to issue tracker for planning` },
+      { label: "Open Dashboard", description: "Review findings in ccw view before exporting" },
+      { label: "Skip", description: "Complete discovery without exporting" }
+    ] : hasMediumFindings ? [
+      { label: "Open Dashboard (Recommended)", description: "Review medium-priority findings in ccw view to decide which to export" },
+      { label: "Export to Issues", description: `Export ${issues.length} issues to tracker` },
+      { label: "Skip", description: "Complete discovery without exporting" }
+    ] : [
+      { label: "Skip (Recommended)", description: "No significant issues found - complete discovery" },
+      { label: "Open Dashboard", description: "Review all findings in ccw view" },
+      { label: "Export to Issues", description: `Export ${issues.length} issues anyway` }
+    ]
+  }]
+});
+
+// Handle response
+if (response === "Export to Issues") {
+  // Append to issues.jsonl
+  await appendJsonl('.workflow/issues/issues.jsonl', issues);
+  console.log(`Exported ${issues.length} issues. Run /issue:plan to continue.`);
+} else if (response === "Open Dashboard") {
+  console.log('Run `ccw view` and navigate to Issues > Discovery to manage findings.');
+}
+```
+
 ### Output File Structure
 
 ```

.claude/commands/issue/execute.md

@@ -1,7 +1,7 @@
 ---
 name: execute
-description: Execute queue with codex using DAG-based parallel orchestration (solution-level)
-argument-hint: ""
+description: Execute queue with DAG-based parallel orchestration (one commit per solution)
+argument-hint: "--queue <queue-id> [--worktree [<existing-path>]]"
 allowed-tools: TodoWrite(*), Bash(*), Read(*), AskUserQuestion(*)
 ---
 
@@ -17,44 +17,171 @@ Minimal orchestrator that dispatches **solution IDs** to executors. Each executo
 - `done <id>` → update solution completion status
 - No race conditions: status changes only via `done`
 - **Executor handles all tasks within a solution sequentially**
+- **Single worktree for entire queue**: One worktree isolates ALL queue execution from main workspace
+
+## Queue ID Requirement (MANDATORY)
+
+**Queue ID is REQUIRED.** You MUST specify which queue to execute via `--queue <queue-id>`.
+
+### If Queue ID Not Provided
+
+When `--queue` parameter is missing, you MUST:
+
+1. **List available queues** by running:
+```javascript
+const result = Bash('ccw issue queue list --brief --json');
+const index = JSON.parse(result);
+```
+
+2. **Display available queues** to user:
+```
+Available Queues:
+ID                    Status      Progress    Issues
+-----------------------------------------------------------
+→ QUE-20251215-001   active      3/10        ISS-001, ISS-002
+  QUE-20251210-002   active      0/5         ISS-003
+  QUE-20251205-003   completed   8/8         ISS-004
+```
+
+3. **Stop and ask user** to specify which queue to execute:
+```javascript
+AskUserQuestion({
+  questions: [{
+    question: "Which queue would you like to execute?",
+    header: "Queue",
+    multiSelect: false,
+    options: index.queues
+      .filter(q => q.status === 'active')
+      .map(q => ({
+        label: q.id,
+        description: `${q.status}, ${q.completed_solutions || 0}/${q.total_solutions || 0} completed, Issues: ${q.issue_ids.join(', ')}`
+      }))
+  }]
+})
+```
+
+4. **After user selection**, continue execution with the selected queue ID.
+
+**DO NOT auto-select queues.** Explicit user confirmation is required to prevent accidental execution of wrong queue.
 
 ## Usage
 
 ```bash
-/issue:execute
+/issue:execute --queue QUE-xxx           # Execute specific queue (REQUIRED)
+/issue:execute --queue QUE-xxx --worktree  # Execute in isolated worktree
+/issue:execute --queue QUE-xxx --worktree /path/to/existing/worktree  # Resume
 ```
 
 **Parallelism**: Determined automatically by task dependency DAG (no manual control)
 **Executor & Dry-run**: Selected via interactive prompt (AskUserQuestion)
+**Worktree**: Creates ONE worktree for the entire queue execution (not per-solution)
+
+**⭐ Recommended Executor**: **Codex** - Best for long-running autonomous work (2hr timeout), supports background execution and full write access
+
+**Worktree Options**:
+- `--worktree` - Create a new worktree with timestamp-based name
+- `--worktree <existing-path>` - Resume in an existing worktree (for recovery/continuation)
+
+**Resume**: Use `git worktree list` to find existing worktrees from interrupted executions
 
 ## Execution Flow
 
 ```
+Phase 0: Validate Queue ID (REQUIRED)
+   ├─ If --queue provided → use specified queue
+   ├─ If --queue missing → list queues, prompt user to select
+   └─ Store QUEUE_ID for all subsequent commands
+
+Phase 0.5 (if --worktree): Setup Queue Worktree
+   ├─ Create ONE worktree for entire queue: .ccw/worktrees/queue-<timestamp>
+   ├─ All subsequent execution happens in this worktree
+   └─ Main workspace remains clean and untouched
+
 Phase 1: Get DAG & User Selection
-   ├─ ccw issue queue dag → { parallel_batches: [["S-1","S-2"], ["S-3"]] }
-   └─ AskUserQuestion → executor type (codex|gemini|agent), dry-run mode
+   ├─ ccw issue queue dag --queue ${QUEUE_ID} → { parallel_batches: [["S-1","S-2"], ["S-3"]] }
+   └─ AskUserQuestion → executor type (codex|gemini|agent), dry-run mode, worktree mode
 
 Phase 2: Dispatch Parallel Batch (DAG-driven)
    ├─ Parallelism determined by DAG (no manual limit)
+   ├─ All executors work in the SAME worktree (or main if no worktree)
    ├─ For each solution ID in batch (parallel - all at once):
    │   ├─ Executor calls: ccw issue detail <id>  (READ-ONLY)
    │   ├─ Executor gets FULL SOLUTION with all tasks
    │   ├─ Executor implements all tasks sequentially (T1 → T2 → T3)
-   │   ├─ Executor tests + commits per task
+   │   ├─ Executor tests + verifies each task
+   │   ├─ Executor commits ONCE per solution (with formatted summary)
    │   └─ Executor calls: ccw issue done <id>
    └─ Wait for batch completion
 
-Phase 3: Next Batch
+Phase 3: Next Batch (repeat Phase 2)
    └─ ccw issue queue dag → check for newly-ready solutions
+
+Phase 4 (if --worktree): Worktree Completion
+   ├─ All batches complete → prompt for merge strategy
+   └─ Options: Create PR / Merge to main / Keep branch
 ```
 
 ## Implementation
 
+### Phase 0: Validate Queue ID
+
+```javascript
+// Check if --queue was provided
+let QUEUE_ID = args.queue;
+
+if (!QUEUE_ID) {
+  // List available queues
+  const listResult = Bash('ccw issue queue list --brief --json').trim();
+  const index = JSON.parse(listResult);
+
+  if (index.queues.length === 0) {
+    console.log('No queues found. Use /issue:queue to create one first.');
+    return;
+  }
+
+  // Filter active queues only
+  const activeQueues = index.queues.filter(q => q.status === 'active');
+
+  if (activeQueues.length === 0) {
+    console.log('No active queues found.');
+    console.log('Available queues:', index.queues.map(q => `${q.id} (${q.status})`).join(', '));
+    return;
+  }
+
+  // Display and prompt user
+  console.log('\nAvailable Queues:');
+  console.log('ID'.padEnd(22) + 'Status'.padEnd(12) + 'Progress'.padEnd(12) + 'Issues');
+  console.log('-'.repeat(70));
+  for (const q of index.queues) {
+    const marker = q.id === index.active_queue_id ? '→ ' : '  ';
+    console.log(marker + q.id.padEnd(20) + q.status.padEnd(12) +
+      `${q.completed_solutions || 0}/${q.total_solutions || 0}`.padEnd(12) +
+      q.issue_ids.join(', '));
+  }
+
+  const answer = AskUserQuestion({
+    questions: [{
+      question: "Which queue would you like to execute?",
+      header: "Queue",
+      multiSelect: false,
+      options: activeQueues.map(q => ({
+        label: q.id,
+        description: `${q.completed_solutions || 0}/${q.total_solutions || 0} completed, Issues: ${q.issue_ids.join(', ')}`
+      }))
+    }]
+  });
+
+  QUEUE_ID = answer['Queue'];
+}
+
+console.log(`\n## Executing Queue: ${QUEUE_ID}\n`);
+```
+
 ### Phase 1: Get DAG & User Selection
 
 ```javascript
-// Get dependency graph and parallel batches
-const dagJson = Bash(`ccw issue queue dag`).trim();
+// Get dependency graph and parallel batches (QUEUE_ID required)
+const dagJson = Bash(`ccw issue queue dag --queue ${QUEUE_ID}`).trim();
 const dag = JSON.parse(dagJson);
 
 if (dag.error || dag.ready_count === 0) {
@@ -93,12 +220,22 @@ const answer = AskUserQuestion({
         { label: 'Execute (Recommended)', description: 'Run all ready solutions' },
         { label: 'Dry-run', description: 'Show DAG and batches without executing' }
       ]
+    },
+    {
+      question: 'Use git worktree for queue isolation?',
+      header: 'Worktree',
+      multiSelect: false,
+      options: [
+        { label: 'Yes (Recommended)', description: 'Create ONE worktree for entire queue - main stays clean' },
+        { label: 'No', description: 'Work directly in current directory' }
+      ]
     }
   ]
 });
 
 const executor = answer['Executor'].toLowerCase().split(' ')[0];  // codex|gemini|agent
 const isDryRun = answer['Mode'].includes('Dry-run');
+const useWorktree = answer['Worktree'].includes('Yes');
 
 // Dry run mode
 if (isDryRun) {
@@ -110,7 +247,7 @@ if (isDryRun) {
 }
 ```
 
-### Phase 2: Dispatch Parallel Batch (DAG-driven)
+### Phase 0 & 2: Setup Queue Worktree & Dispatch
 
 ```javascript
 // Parallelism determined by DAG - no manual limit
@@ -128,10 +265,40 @@ TodoWrite({
 
 console.log(`\n### Executing Solutions (DAG batch 1): ${batch.join(', ')}`);
 
+// Parse existing worktree path from args if provided
+// Example: --worktree /path/to/existing/worktree
+const existingWorktree = args.worktree && typeof args.worktree === 'string' ? args.worktree : null;
+
+// Setup ONE worktree for entire queue (not per-solution)
+let worktreePath = null;
+let worktreeBranch = null;
+
+if (useWorktree) {
+  const repoRoot = Bash('git rev-parse --show-toplevel').trim();
+  const worktreeBase = `${repoRoot}/.ccw/worktrees`;
+  Bash(`mkdir -p "${worktreeBase}"`);
+  Bash('git worktree prune');  // Cleanup stale worktrees
+
+  if (existingWorktree) {
+    // Resume mode: Use existing worktree
+    worktreePath = existingWorktree;
+    worktreeBranch = Bash(`git -C "${worktreePath}" branch --show-current`).trim();
+    console.log(`Resuming in existing worktree: ${worktreePath} (branch: ${worktreeBranch})`);
+  } else {
+    // Create mode: ONE worktree for the entire queue
+    const timestamp = new Date().toISOString().replace(/[-:T]/g, '').slice(0, 14);
+    worktreeBranch = `queue-exec-${dag.queue_id || timestamp}`;
+    worktreePath = `${worktreeBase}/${worktreeBranch}`;
+    Bash(`git worktree add "${worktreePath}" -b "${worktreeBranch}"`);
+    console.log(`Created queue worktree: ${worktreePath}`);
+  }
+}
+
 // Launch ALL solutions in batch in parallel (DAG guarantees no conflicts)
+// All executors work in the SAME worktree (or main if no worktree)
 const executions = batch.map(solutionId => {
   updateTodo(solutionId, 'in_progress');
-  return dispatchExecutor(solutionId, executor);
+  return dispatchExecutor(solutionId, executor, worktreePath);
 });
 
 await Promise.all(executions);
@@ -141,13 +308,20 @@ batch.forEach(id => updateTodo(id, 'completed'));
 ### Executor Dispatch
 
 ```javascript
-function dispatchExecutor(solutionId, executorType) {
-  // Executor fetches FULL SOLUTION via READ-ONLY detail command
-  // Executor handles all tasks within solution sequentially
-  // Then reports completion via done command
+// worktreePath: path to shared worktree (null if not using worktree)
+function dispatchExecutor(solutionId, executorType, worktreePath = null) {
+  // If worktree is provided, executor works in that directory
+  // No per-solution worktree creation - ONE worktree for entire queue
+  const cdCommand = worktreePath ? `cd "${worktreePath}"` : '';
+
   const prompt = `
 ## Execute Solution ${solutionId}
-
+${worktreePath ? `
+### Step 0: Enter Queue Worktree
+\`\`\`bash
+cd "${worktreePath}"
+\`\`\`
+` : ''}
 ### Step 1: Get Solution (read-only)
 \`\`\`bash
 ccw issue detail ${solutionId}
@@ -161,28 +335,55 @@ For each task:
 1. Follow task.implementation steps
 2. Run task.test commands
 3. Verify task.acceptance criteria
-4. Commit using task.commit specification
+(Do NOT commit after each task)
 
-### Step 3: Report Completion
-When ALL tasks in solution are done:
+### Step 3: Commit Solution (Once)
+After ALL tasks pass, commit once with formatted summary:
 \`\`\`bash
-ccw issue done ${solutionId} --result '{"summary": "...", "files_modified": [...], "tasks_completed": N}'
+git add <all-modified-files>
+git commit -m "[type](scope): [solution.description]
+
+## Solution Summary
+- Solution-ID: ${solutionId}
+- Tasks: T1, T2, ...
+
+## Tasks Completed
+- [T1] task1.title: action
+- [T2] task2.title: action
+
+## Files Modified
+- file1.ts
+- file2.ts
+
+## Verification
+- All tests passed
+- All acceptance criteria verified"
+\`\`\`
+
+### Step 4: Report Completion
+\`\`\`bash
+ccw issue done ${solutionId} --result '{"summary": "...", "files_modified": [...], "commit": {"hash": "...", "type": "feat"}, "tasks_completed": N}'
 \`\`\`
 
 If any task failed:
 \`\`\`bash
-ccw issue done ${solutionId} --fail --reason "Task TX failed: ..."
+ccw issue done ${solutionId} --fail --reason '{"task_id": "TX", "error_type": "test_failure", "message": "..."}'
 \`\`\`
+
+**Note**: Do NOT cleanup worktree after this solution. Worktree is shared by all solutions in the queue.
 `;
 
+  // For CLI tools, pass --cd to set working directory
+  const cdOption = worktreePath ? ` --cd "${worktreePath}"` : '';
+
   if (executorType === 'codex') {
     return Bash(
-      `ccw cli -p "${escapePrompt(prompt)}" --tool codex --mode write --id exec-${solutionId}`,
+      `ccw cli -p "${escapePrompt(prompt)}" --tool codex --mode write --id exec-${solutionId}${cdOption}`,
       { timeout: 7200000, run_in_background: true }  // 2hr for full solution
     );
   } else if (executorType === 'gemini') {
     return Bash(
-      `ccw cli -p "${escapePrompt(prompt)}" --tool gemini --mode write --id exec-${solutionId}`,
+      `ccw cli -p "${escapePrompt(prompt)}" --tool gemini --mode write --id exec-${solutionId}${cdOption}`,
       { timeout: 3600000, run_in_background: true }
     );
   } else {
@@ -190,7 +391,7 @@ ccw issue done ${solutionId} --fail --reason "Task TX failed: ..."
       subagent_type: 'code-developer',
       run_in_background: false,
       description: `Execute solution ${solutionId}`,
-      prompt: prompt
+      prompt: worktreePath ? `Working directory: ${worktreePath}\n\n${prompt}` : prompt
     });
   }
 }
@@ -199,8 +400,8 @@ ccw issue done ${solutionId} --fail --reason "Task TX failed: ..."
 ### Phase 3: Check Next Batch
 
 ```javascript
-// Refresh DAG after batch completes
-const refreshedDag = JSON.parse(Bash(`ccw issue queue dag`).trim());
+// Refresh DAG after batch completes (use same QUEUE_ID)
+const refreshedDag = JSON.parse(Bash(`ccw issue queue dag --queue ${QUEUE_ID}`).trim());
 
 console.log(`
 ## Batch Complete
@@ -210,44 +411,117 @@ console.log(`
 `);
 
 if (refreshedDag.ready_count > 0) {
-  console.log('Run `/issue:execute` again for next batch.');
+  console.log(`Run \`/issue:execute --queue ${QUEUE_ID}\` again for next batch.`);
+  // Note: If resuming, pass existing worktree path:
+  // /issue:execute --queue ${QUEUE_ID} --worktree <worktreePath>
+}
+```
+
+### Phase 4: Worktree Completion (after ALL batches)
+
+```javascript
+// Only run when ALL solutions completed AND using worktree
+if (useWorktree && refreshedDag.ready_count === 0 && refreshedDag.completed_count === refreshedDag.total) {
+  console.log('\n## All Solutions Completed - Worktree Cleanup');
+
+  const answer = AskUserQuestion({
+    questions: [{
+      question: `Queue complete. What to do with worktree branch "${worktreeBranch}"?`,
+      header: 'Merge',
+      multiSelect: false,
+      options: [
+        { label: 'Create PR (Recommended)', description: 'Push branch and create pull request' },
+        { label: 'Merge to main', description: 'Merge all commits and cleanup worktree' },
+        { label: 'Keep branch', description: 'Cleanup worktree, keep branch for manual handling' }
+      ]
+    }]
+  });
+
+  const repoRoot = Bash('git rev-parse --show-toplevel').trim();
+
+  if (answer['Merge'].includes('Create PR')) {
+    Bash(`git -C "${worktreePath}" push -u origin "${worktreeBranch}"`);
+    Bash(`gh pr create --title "Queue ${dag.queue_id}" --body "Issue queue execution - all solutions completed" --head "${worktreeBranch}"`);
+    Bash(`git worktree remove "${worktreePath}"`);
+    console.log(`PR created for branch: ${worktreeBranch}`);
+  } else if (answer['Merge'].includes('Merge to main')) {
+    // Check main is clean
+    const mainDirty = Bash('git status --porcelain').trim();
+    if (mainDirty) {
+      console.log('Warning: Main has uncommitted changes. Falling back to PR.');
+      Bash(`git -C "${worktreePath}" push -u origin "${worktreeBranch}"`);
+      Bash(`gh pr create --title "Queue ${dag.queue_id}" --body "Issue queue execution (main had uncommitted changes)" --head "${worktreeBranch}"`);
+    } else {
+      Bash(`git merge --no-ff "${worktreeBranch}" -m "Merge queue ${dag.queue_id}"`);
+      Bash(`git branch -d "${worktreeBranch}"`);
+    }
+    Bash(`git worktree remove "${worktreePath}"`);
+  } else {
+    Bash(`git worktree remove "${worktreePath}"`);
+    console.log(`Branch ${worktreeBranch} kept for manual handling`);
+  }
 }
 ```
 
 ## Parallel Execution Model
 
 ```
-┌─────────────────────────────────────────────────────────────┐
-│ Orchestrator                                                │
-├─────────────────────────────────────────────────────────────┤
-│ 1. ccw issue queue dag                                      │
-│    → { parallel_batches: [["S-1","S-2"], ["S-3"]] }        │
-│                                                             │
-│ 2. Dispatch batch 1 (parallel):                            │
-│    ┌──────────────────────┐ ┌──────────────────────┐       │
-│    │ Executor 1           │ │ Executor 2           │       │
-│    │ detail S-1           │ │ detail S-2           │       │
-│    │ → gets full solution │ │ → gets full solution │       │
-│    │ [T1→T2→T3 sequential]│ │ [T1→T2 sequential]   │       │
-│    │ done S-1             │ │ done S-2             │       │
-│    └──────────────────────┘ └──────────────────────┘       │
-│                                                             │
-│ 3. ccw issue queue dag (refresh)                           │
-│    → S-3 now ready (S-1 completed, file conflict resolved) │
-└─────────────────────────────────────────────────────────────┘
+┌─────────────────────────────────────────────────────────────────┐
+│ Orchestrator                                                    │
+├─────────────────────────────────────────────────────────────────┤
+│ 0. Validate QUEUE_ID (required, or prompt user to select)       │
+│                                                                 │
+│ 0.5 (if --worktree) Create ONE worktree for entire queue        │
+│    → .ccw/worktrees/queue-exec-<queue-id>                       │
+│                                                                 │
+│ 1. ccw issue queue dag --queue ${QUEUE_ID}                      │
+│    → { parallel_batches: [["S-1","S-2"], ["S-3"]] }             │
+│                                                                 │
+│ 2. Dispatch batch 1 (parallel, SAME worktree):                  │
+│    ┌──────────────────────────────────────────────────────┐     │
+│    │        Shared Queue Worktree (or main)               │     │
+│    │  ┌──────────────────┐ ┌──────────────────┐          │     │
+│    │  │ Executor 1       │ │ Executor 2       │          │     │
+│    │  │ detail S-1       │ │ detail S-2       │          │     │
+│    │  │ [T1→T2→T3]       │ │ [T1→T2]          │          │     │
+│    │  │ commit S-1       │ │ commit S-2       │          │     │
+│    │  │ done S-1         │ │ done S-2         │          │     │
+│    │  └──────────────────┘ └──────────────────┘          │     │
+│    └──────────────────────────────────────────────────────┘     │
+│                                                                 │
+│ 3. ccw issue queue dag (refresh)                                │
+│    → S-3 now ready → dispatch batch 2 (same worktree)           │
+│                                                                 │
+│ 4. (if --worktree) ALL batches complete → cleanup worktree      │
+│    → Prompt: Create PR / Merge to main / Keep branch            │
+└─────────────────────────────────────────────────────────────────┘
 ```
 
 **Why this works for parallel:**
+- **ONE worktree for entire queue** → all solutions share same isolated workspace
 - `detail <id>` is READ-ONLY → no race conditions
 - Each executor handles **all tasks within a solution** sequentially
+- **One commit per solution** with formatted summary (not per-task)
 - `done <id>` updates only its own solution status
 - `queue dag` recalculates ready solutions after each batch
-- Solutions in same batch have NO file conflicts
+- Solutions in same batch have NO file conflicts (DAG guarantees)
+- **Main workspace stays clean** until merge/PR decision
 
 ## CLI Endpoint Contract
 
-### `ccw issue queue dag`
-Returns dependency graph with parallel batches (solution-level):
+### `ccw issue queue list --brief --json`
+Returns queue index for selection (used when --queue not provided):
+```json
+{
+  "active_queue_id": "QUE-20251215-001",
+  "queues": [
+    { "id": "QUE-20251215-001", "status": "active", "issue_ids": ["ISS-001"], "total_solutions": 5, "completed_solutions": 2 }
+  ]
+}
+```
+
+### `ccw issue queue dag --queue <queue-id>`
+Returns dependency graph with parallel batches (solution-level, **--queue required**):
 ```json
 {
   "queue_id": "QUE-...",

.claude/commands/issue/new.md

@@ -29,6 +29,10 @@ interface Issue {
   source_url?: string;
   labels?: string[];
 
+  // GitHub binding (for non-GitHub sources that publish to GitHub)
+  github_url?: string;           // https://github.com/owner/repo/issues/123
+  github_number?: number;        // 123
+
   // Optional structured fields
   expected_behavior?: string;
   actual_behavior?: string;
@@ -165,7 +169,30 @@ if (clarityScore < 2 && (!issueData.context || issueData.context.length < 20)) {
 }
 ```
 
-### Phase 5: Create Issue
+### Phase 5: GitHub Publishing Decision (Non-GitHub Sources)
+
+```javascript
+// For non-GitHub sources, ask if user wants to publish to GitHub
+let publishToGitHub = false;
+
+if (issueData.source !== 'github') {
+  const publishAnswer = AskUserQuestion({
+    questions: [{
+      question: 'Would you like to publish this issue to GitHub?',
+      header: 'Publish',
+      multiSelect: false,
+      options: [
+        { label: 'Yes, publish to GitHub', description: 'Create issue on GitHub and link it' },
+        { label: 'No, keep local only', description: 'Store as local issue without GitHub sync' }
+      ]
+    }]
+  });
+
+  publishToGitHub = publishAnswer.answers?.['Publish']?.includes('Yes');
+}
+```
+
+### Phase 6: Create Issue
 
 **Summary Display:**
 - Show ID, title, source, affected files (if any)
@@ -175,7 +202,16 @@ if (clarityScore < 2 && (!issueData.context || issueData.context.length < 20)) {
 
 **Issue Creation** (via CLI endpoint):
 ```bash
-ccw issue create --data '{"title":"...", "context":"...", "priority":3, ...}'
+# Option 1: Pipe input (recommended for complex JSON - avoids shell escaping)
+echo '{"title":"...", "context":"...", "priority":3}' | ccw issue create
+
+# Option 2: Heredoc (for multi-line JSON)
+ccw issue create << 'EOF'
+{"title":"...", "context":"含\"引号\"的内容", "priority":3}
+EOF
+
+# Option 3: --data parameter (simple cases only)
+ccw issue create --data '{"title":"...", "priority":3}'
 ```
 
 **CLI Endpoint Features:**
@@ -187,15 +223,20 @@ ccw issue create --data '{"title":"...", "context":"...", "priority":3, ...}'
 
 **Example:**
 ```bash
-# Create issue via CLI
-ccw issue create --data '{
+# Create issue via pipe (recommended)
+echo '{"title": "Login fails with special chars", "context": "500 error when password contains quotes", "priority": 2}' | ccw issue create
+
+# Or with heredoc for complex JSON
+ccw issue create << 'EOF'
+{
   "title": "Login fails with special chars",
-  "context": "500 error when password contains quotes",
+  "context": "500 error when password contains \"quotes\"",
   "priority": 2,
   "source": "text",
   "expected_behavior": "Login succeeds",
   "actual_behavior": "500 Internal Server Error"
-}'
+}
+EOF
 
 # Output (JSON)
 {
@@ -206,8 +247,64 @@ ccw issue create --data '{
 }
 ```
 
+**GitHub Publishing** (if user opted in):
+```javascript
+// Step 1: Create local issue FIRST
+const localIssue = createLocalIssue(issueData);  // ccw issue create
+
+// Step 2: Publish to GitHub if requested
+if (publishToGitHub) {
+  const ghResult = Bash(`gh issue create --title "${issueData.title}" --body "${issueData.context}"`);
+  // Parse GitHub URL from output
+  const ghUrl = ghResult.match(/https:\/\/github\.com\/[\w-]+\/[\w-]+\/issues\/\d+/)?.[0];
+  const ghNumber = parseInt(ghUrl?.match(/\/issues\/(\d+)/)?.[1]);
+
+  if (ghNumber) {
+    // Step 3: Update local issue with GitHub binding
+    Bash(`ccw issue update ${localIssue.id} --github-url "${ghUrl}" --github-number ${ghNumber}`);
+    // Or via pipe:
+    // echo '{"github_url":"${ghUrl}","github_number":${ghNumber}}' | ccw issue update ${localIssue.id}
+  }
+}
+```
+
+**Workflow:**
+```
+1. Create local issue (ISS-YYYYMMDD-NNN) → stored in .workflow/issues.jsonl
+2. If publishToGitHub:
+   a. gh issue create → returns GitHub URL
+   b. Update local issue with github_url + github_number binding
+3. Both local and GitHub issues exist, linked together
+```
+
+**Example with GitHub Publishing:**
+```bash
+# User creates text issue
+/issue:new "Login fails with special chars. Expected: success. Actual: 500"
+
+# System asks: "Would you like to publish this issue to GitHub?"
+# User selects: "Yes, publish to GitHub"
+
+# Output:
+# ✓ Local issue created: ISS-20251229-001
+# ✓ Published to GitHub: https://github.com/org/repo/issues/123
+# ✓ GitHub binding saved to local issue
+# → Next step: /issue:plan ISS-20251229-001
+
+# Resulting issue JSON:
+{
+  "id": "ISS-20251229-001",
+  "title": "Login fails with special chars",
+  "source": "text",
+  "github_url": "https://github.com/org/repo/issues/123",
+  "github_number": 123,
+  ...
+}
+```
+
 **Completion:**
 - Display created issue ID
+- Show GitHub URL (if published)
 - Show next step: `/issue:plan <id>`
 
 ## Execution Flow
@@ -226,9 +323,16 @@ Phase 2: Data Extraction (branched by clarity)
    │            │  (3 files max)  │  → feedback  │
    └────────────┴─────────────────┴──────────────┘
 
-Phase 3: Create Issue
+Phase 3: GitHub Publishing Decision (non-GitHub only)
+   ├─ Source = github: Skip (already from GitHub)
+   └─ Source ≠ github: AskUserQuestion
+      ├─ Yes → publishToGitHub = true
+      └─ No  → publishToGitHub = false
+
+Phase 4: Create Issue
    ├─ Score ≥ 2: Direct creation
    └─ Score < 2: Confirm first → Create
+   └─ If publishToGitHub: gh issue create → link URL
 
 Note: Deep exploration & lifecycle deferred to /issue:plan
 ```
@@ -306,4 +410,4 @@ function parseMarkdownBody(body) {
 ## Related Commands
 
 - `/issue:plan` - Plan solution for issue
-- `/issue:manage` - Interactive issue management
+

.claude/commands/issue/plan.md

@@ -131,7 +131,7 @@ TASK: • Analyze issue titles/tags semantically • Identify functional/archite
 MODE: analysis
 CONTEXT: Issue metadata only
 EXPECTED: JSON with groups array, each containing max 4 issue_ids, theme, rationale
-RULES: $(cat ~/.claude/workflows/cli-templates/protocols/analysis-protocol.md) | Each issue in exactly one group | Max 4 issues per group | Balance group sizes
+CONSTRAINTS: Each issue in exactly one group | Max 4 issues per group | Balance group sizes
 
 INPUT:
 ${JSON.stringify(issueSummaries, null, 2)}
@@ -195,14 +195,29 @@ ${issueList}
 
 ### Workflow
 1. Fetch issue details: ccw issue status <id> --json
-2. Load project context files
-3. Explore codebase (ACE semantic search)
-4. Plan solution with tasks (schema: solution-schema.json)
-5. Write solution to: .workflow/issues/solutions/{issue-id}.jsonl
-6. Single solution → auto-bind; Multiple → return for selection
+2. **Analyze failure history** (if issue.feedback exists):
+   - Extract failure details from issue.feedback (type='failure', stage='execute')
+   - Parse error_type, message, task_id, solution_id from content JSON
+   - Identify failure patterns: repeated errors, root causes, blockers
+   - **Constraint**: Avoid repeating failed approaches
+3. Load project context files
+4. Explore codebase (ACE semantic search)
+5. Plan solution with tasks (schema: solution-schema.json)
+   - **If previous solution failed**: Reference failure analysis in solution.approach
+   -  Add explicit verification steps to prevent same failure mode
+6. **If github_url exists**: Add final task to comment on GitHub issue
+7. Write solution to: .workflow/issues/solutions/{issue-id}.jsonl
+8. Single solution → auto-bind; Multiple → return for selection
+
+### Failure-Aware Planning Rules
+- **Extract failure patterns**: Parse issue.feedback where type='failure' and stage='execute'
+- **Identify root causes**: Analyze error_type (test_failure, compilation, timeout, etc.)
+- **Design alternative approach**: Create solution that addresses root cause
+- **Add prevention steps**: Include explicit verification to catch same error earlier
+- **Document lessons**: Reference previous failures in solution.approach
 
 ### Rules
-- Solution ID format: SOL-{issue-id}-{seq}
+- Solution ID format: SOL-{issue-id}-{uid} (uid: 4 random alphanumeric chars, e.g., a7x9)
 - Single solution per issue → auto-bind via ccw issue bind
 - Multiple solutions → register only, return pending_selection
 - Tasks must have quantified acceptance.criteria
@@ -304,6 +319,12 @@ Next: \`/issue:queue\` → \`/issue:execute\`
 | User cancels selection | Skip issue, continue with others |
 | File conflicts | Agent detects and suggests resolution order |
 
+## Bash Compatibility
+
+**Avoid**: `$(cmd)`, `$var`, `for` loops — will be escaped incorrectly
+
+**Use**: Simple commands + `&&` chains, quote comma params `"pending,registered"`
+
 ## Quality Checklist
 
 Before completing, verify:
@@ -319,6 +340,5 @@ Before completing, verify:
 ## Related Commands
 
 - `/issue:queue` - Form execution queue from bound solutions
-- `/issue:execute` - Execute queue with codex
 - `ccw issue list` - List all issues
 - `ccw issue status` - View issue and solution details

.claude/commands/issue/queue.md

@@ -1,7 +1,7 @@
 ---
 name: queue
 description: Form execution queue from bound solutions using issue-queue-agent (solution-level)
-argument-hint: "[--rebuild] [--issue <id>]"
+argument-hint: "[--queues <n>] [--issue <id>]"
 allowed-tools: TodoWrite(*), Task(*), Bash(*), Read(*), Write(*)
 ---
 
@@ -33,6 +33,7 @@ Queue formation command using **issue-queue-agent** that analyzes all bound solu
 | Get next item | `ccw issue next --json` | `Read('queues/*.json')` |
 | Update status | `ccw issue update <id> --status ...` | Direct file edit |
 | Sync from queue | `ccw issue update --from-queue` | Direct file edit |
+| **Read solution (brief)** | `ccw issue solution <id> --brief` | `Read('solutions/*.jsonl')` |
 
 **Output Options**:
 - `--brief`: JSON with minimal fields (id, status, counts)
@@ -53,6 +54,7 @@ Queue formation command using **issue-queue-agent** that analyzes all bound solu
 
 # Examples
 /issue:queue                      # Form NEW queue from all bound solutions
+/issue:queue --queues 3           # Form 3 parallel queues (solutions distributed)
 /issue:queue --issue GH-123       # Form queue for specific issue only
 /issue:queue --append GH-124      # Append to active queue
 /issue:queue --list               # List all queues (history)
@@ -60,11 +62,16 @@ Queue formation command using **issue-queue-agent** that analyzes all bound solu
 /issue:queue --archive            # Archive completed active queue
 
 # Flags
+--queues <n>          Number of parallel queues (default: 1)
 --issue <id>          Form queue for specific issue only
 --append <id>         Append issue to active queue (don't create new)
+--force               Skip active queue check, always create new queue
 
 # CLI subcommands (ccw issue queue ...)
 ccw issue queue list                  List all queues with status
+ccw issue queue add <issue-id>        Add issue to queue (interactive if active queue exists)
+ccw issue queue add <issue-id> -f     Add to new queue without prompt (force)
+ccw issue queue merge <src> --queue <target>  Merge source queue into target queue
 ccw issue queue switch <queue-id>     Switch active queue
 ccw issue queue archive               Archive current queue
 ccw issue queue delete <queue-id>     Delete queue from history
@@ -73,45 +80,65 @@ ccw issue queue delete <queue-id>     Delete queue from history
 ## Execution Process
 
 ```
-Phase 1: Solution Loading
+Phase 1: Solution Loading & Distribution
    ├─ Load issues.jsonl, filter by status='planned' + bound_solution_id
    ├─ Read solutions/{issue-id}.jsonl, find bound solution
    ├─ Extract files_touched from task modification_points
-   └─ Build solution objects array
+   ├─ Build solution objects array
+   └─ If --queues > 1: Partition solutions into N groups (minimize cross-group file conflicts)
 
 Phase 2-4: Agent-Driven Queue Formation (issue-queue-agent)
-   ├─ Launch issue-queue-agent with solutions array
-   ├─ Agent performs:
+   ├─ Generate N queue IDs (QUE-xxx-1, QUE-xxx-2, ...)
+   ├─ If --queues == 1: Launch single issue-queue-agent
+   ├─ If --queues > 1: Launch N issue-queue-agents IN PARALLEL
+   ├─ Each agent performs:
    │   ├─ Conflict analysis (5 types via Gemini CLI)
    │   ├─ Build dependency DAG from conflicts
    │   ├─ Calculate semantic priority per solution
    │   └─ Assign execution groups (parallel/sequential)
-   └─ Agent writes: queue JSON + index update
+   └─ Each agent writes: queue JSON + index update (NOT active yet)
 
 Phase 5: Conflict Clarification (if needed)
-   ├─ Check agent return for `clarifications` array
-   ├─ If clarifications exist → AskUserQuestion
-   ├─ Pass user decisions back to agent (resume)
-   └─ Agent updates queue with resolved conflicts
+   ├─ Collect `clarifications` arrays from all agents
+   ├─ If clarifications exist → AskUserQuestion (batched)
+   ├─ Pass user decisions back to respective agents (resume)
+   └─ Agents update queues with resolved conflicts
 
 Phase 6: Status Update & Summary
    ├─ Update issue statuses to 'queued'
-   └─ Display queue summary, next step: /issue:execute
+   └─ Display new queue summary (N queues)
+
+Phase 7: Active Queue Check & Decision (REQUIRED)
+   ├─ Read queue index: ccw issue queue list --brief
+   ├─ Get generated queue ID from agent output
+   ├─ If NO active queue exists:
+   │   ├─ Set generated queue as active_queue_id
+   │   ├─ Update index.json
+   │   └─ Display: "Queue created and activated"
+   │
+   └─ If active queue exists with items:
+       ├─ Display both queues to user
+       ├─ Use AskUserQuestion to prompt:
+       │   ├─ "Use new queue (keep existing)" → Set new as active, keep old inactive
+       │   ├─ "Merge: add new items to existing" → Merge new → existing, delete new
+       │   ├─ "Merge: add existing items to new" → Merge existing → new, archive old
+       │   └─ "Cancel" → Delete new queue, keep existing active
+       └─ Execute chosen action
 ```
 
 ## Implementation
 
-### Phase 1: Solution Loading
+### Phase 1: Solution Loading & Distribution
 
 **Data Loading:**
-- Load `issues.jsonl` and filter issues with `status === 'planned'` and `bound_solution_id`
+- Use `ccw issue list --status planned --brief` to get planned issues with `bound_solution_id`
 - If no planned issues found → display message, suggest `/issue:plan`
 
-**Solution Collection** (for each planned issue):
-- Read `solutions/{issue-id}.jsonl`
-- Find bound solution by `bound_solution_id`
-- If bound solution not found → warn and skip issue
-- Extract `files_touched` from all task `modification_points`
+**Solution Brief Loading** (for each planned issue):
+```bash
+ccw issue solution <issue-id> --brief
+# Returns: [{ solution_id, is_bound, task_count, files_touched[] }]
+```
 
 **Build Solution Objects:**
 ```json
@@ -124,29 +151,39 @@ Phase 6: Status Update & Summary
 }
 ```
 
-**Output:** Array of solution objects ready for agent processing
+**Multi-Queue Distribution** (if `--queues > 1`):
+- Use `files_touched` from brief output for partitioning
+- Group solutions with overlapping files into same queue
+
+**Output:** Array of solution objects (or N arrays if multi-queue)
 
 ### Phase 2-4: Agent-Driven Queue Formation
 
-**Generate Queue ID** (command layer, pass to agent):
+**Generate Queue IDs** (command layer, pass to agent):
 ```javascript
-const queueId = `QUE-${new Date().toISOString().replace(/[-:T]/g, '').slice(0, 14)}`;
+const timestamp = new Date().toISOString().replace(/[-:T]/g, '').slice(0, 14);
+const numQueues = args.queues || 1;
+const queueIds = numQueues === 1
+  ? [`QUE-${timestamp}`]
+  : Array.from({length: numQueues}, (_, i) => `QUE-${timestamp}-${i + 1}`);
 ```
 
-**Agent Prompt**:
+**Agent Prompt** (same for each queue, with assigned solutions):
 ```
 ## Order Solutions into Execution Queue
 
 **Queue ID**: ${queueId}
 **Solutions**: ${solutions.length} from ${issues.length} issues
 **Project Root**: ${cwd}
+**Queue Index**: ${queueIndex} of ${numQueues}
 
 ### Input
 ${JSON.stringify(solutions)}
+// Each object: { issue_id, solution_id, task_count, files_touched[], priority }
 
 ### Workflow
 
-Step 1: Build dependency graph from solutions (nodes=solutions, edges=file conflicts)
+Step 1: Build dependency graph from solutions (nodes=solutions, edges=file conflicts via files_touched)
 Step 2: Use Gemini CLI for conflict analysis (5 types: file, API, data, dependency, architecture)
 Step 3: For high-severity conflicts without clear resolution → add to `clarifications`
 Step 4: Calculate semantic priority (base from issue priority + task_count boost)
@@ -176,6 +213,7 @@ Step 6: Write queue JSON + update index
 - Queue Item ID format: S-1, S-2, S-3, ...
 - Use provided Queue ID (do NOT generate new)
 - `clarifications` only present if high-severity unresolved conflicts exist
+- Use `files_touched` from input (already extracted by orchestrator)
 
 ### Done Criteria
 - [ ] Queue JSON written with all solutions ordered
@@ -185,39 +223,66 @@ Step 6: Write queue JSON + update index
 - [ ] Return JSON matches required shape
 ```
 
-**Launch Agent**:
+**Launch Agents** (parallel if multi-queue):
 ```javascript
-const result = Task(
-  subagent_type="issue-queue-agent",
-  prompt=agentPrompt,
-  description=`Order ${solutions.length} solutions`
-);
+const numQueues = args.queues || 1;
+
+if (numQueues === 1) {
+  // Single queue: single agent call
+  const result = Task(
+    subagent_type="issue-queue-agent",
+    prompt=buildPrompt(queueIds[0], solutions),
+    description=`Order ${solutions.length} solutions`
+  );
+} else {
+  // Multi-queue: parallel agent calls (single message with N Task calls)
+  const agentPromises = solutionGroups.map((group, i) =>
+    Task(
+      subagent_type="issue-queue-agent",
+      prompt=buildPrompt(queueIds[i], group, i + 1, numQueues),
+      description=`Queue ${i + 1}/${numQueues}: ${group.length} solutions`
+    )
+  );
+  // All agents launched in parallel via single message with multiple Task tool calls
+}
 ```
 
+**Multi-Queue Index Update:**
+- First queue sets `active_queue_id`
+- All queues added to `queues` array with `queue_group` field linking them
+
 ### Phase 5: Conflict Clarification
 
+**Collect Agent Results** (multi-queue):
+```javascript
+// Collect clarifications from all agents
+const allClarifications = results.flatMap((r, i) =>
+  (r.clarifications || []).map(c => ({ ...c, queue_id: queueIds[i], agent_id: agentIds[i] }))
+);
+```
+
 **Check Agent Return:**
-- Parse agent result JSON
-- If `clarifications` array exists and non-empty → user decision required
+- Parse agent result JSON (or all results if multi-queue)
+- If any `clarifications` array exists and non-empty → user decision required
 
 **Clarification Flow:**
 ```javascript
-if (result.clarifications?.length > 0) {
-  for (const clarification of result.clarifications) {
+if (allClarifications.length > 0) {
+  for (const clarification of allClarifications) {
     // Present to user via AskUserQuestion
     const answer = AskUserQuestion({
       questions: [{
-        question: clarification.question,
+        question: `[${clarification.queue_id}] ${clarification.question}`,
         header: clarification.conflict_id,
         options: clarification.options,
         multiSelect: false
       }]
     });
 
-    // Resume agent with user decision
+    // Resume respective agent with user decision
     Task(
       subagent_type="issue-queue-agent",
-      resume=agentId,
+      resume=clarification.agent_id,
       prompt=`Conflict ${clarification.conflict_id} resolved: ${answer.selected}`
     );
   }
@@ -262,6 +327,41 @@ ccw issue update <issue-id> --status queued
 - Show unplanned issues (planned but NOT in queue)
 - Show next step: `/issue:execute`
 
+### Phase 7: Active Queue Check & Decision
+
+**After agent completes Phase 1-6, check for active queue:**
+
+```bash
+ccw issue queue list --brief
+```
+
+**Decision:**
+- If `active_queue_id` is null → `ccw issue queue switch <new-queue-id>` (activate new queue)
+- If active queue exists → Use **AskUserQuestion** to prompt user
+
+**AskUserQuestion:**
+```javascript
+AskUserQuestion({
+  questions: [{
+    question: "Active queue exists. How would you like to proceed?",
+    header: "Queue Action",
+    options: [
+      { label: "Merge into existing queue", description: "Add new items to active queue, delete new queue" },
+      { label: "Use new queue", description: "Switch to new queue, keep existing in history" },
+      { label: "Cancel", description: "Delete new queue, keep existing active" }
+    ],
+    multiSelect: false
+  }]
+})
+```
+
+**Action Commands:**
+
+| User Choice | Commands |
+|-------------|----------|
+| **Merge into existing** | `ccw issue queue merge <new-queue-id> --queue <active-queue-id>` then `ccw issue queue delete <new-queue-id>` |
+| **Use new queue** | `ccw issue queue switch <new-queue-id>` |
+| **Cancel** | `ccw issue queue delete <new-queue-id>` |
 
 ## Storage Structure (Queue History)
 
@@ -282,9 +382,13 @@ ccw issue update <issue-id> --status queued
 ```json
 {
   "active_queue_id": "QUE-20251227-143000",
+  "active_queue_group": "QGR-20251227-143000",
   "queues": [
     {
-      "id": "QUE-20251227-143000",
+      "id": "QUE-20251227-143000-1",
+      "queue_group": "QGR-20251227-143000",
+      "queue_index": 1,
+      "total_queues": 3,
       "status": "active",
       "issue_ids": ["ISS-xxx", "ISS-yyy"],
       "total_solutions": 3,
@@ -295,6 +399,12 @@ ccw issue update <issue-id> --status queued
 }
 ```
 
+**Multi-Queue Fields:**
+- `queue_group`: Links queues created in same batch (format: `QGR-{timestamp}`)
+- `queue_index`: Position in group (1-based)
+- `total_queues`: Total queues in group
+- `active_queue_group`: Current active group (for multi-queue execution)
+
 **Note**: Queue file schema is produced by `issue-queue-agent`. See agent documentation for details.
 ## Error Handling
 
@@ -306,22 +416,26 @@ ccw issue update <issue-id> --status queued
 | User cancels clarification | Abort queue formation |
 | **index.json not updated** | Auto-fix: Set active_queue_id to new queue |
 | **Queue file missing solutions** | Abort with error, agent must regenerate |
+| **User cancels queue add** | Display message, return without changes |
+| **Merge with empty source** | Skip merge, display warning |
+| **All items duplicate** | Skip merge, display "All items already exist" |
 
 ## Quality Checklist
 
 Before completing, verify:
 
 - [ ] All planned issues with `bound_solution_id` are included
-- [ ] Queue JSON written to `queues/{queue-id}.json`
+- [ ] Queue JSON written to `queues/{queue-id}.json` (N files if multi-queue)
 - [ ] Index updated in `queues/index.json` with `active_queue_id`
+- [ ] Multi-queue: All queues share same `queue_group`
 - [ ] No circular dependencies in solution DAG
 - [ ] All conflicts resolved (auto or via user clarification)
 - [ ] Parallel groups have no file overlaps
+- [ ] Cross-queue: No file overlaps between queues
 - [ ] Issue statuses updated to `queued`
 
 ## Related Commands
 
-- `/issue:plan` - Plan issues and bind solutions
 - `/issue:execute` - Execute queue with codex
 - `ccw issue queue list` - View current queue
 - `ccw issue update --from-queue [queue-id]` - Sync issue statuses from queue

.claude/commands/memory/swagger-docs.md

@@ -0,0 +1,773 @@
+---
+name: swagger-docs
+description: Generate complete Swagger/OpenAPI documentation following RESTful standards with global security, API details, error codes, and validation tests
+argument-hint: "[path] [--tool <gemini|qwen|codex>] [--format <yaml|json>] [--version <v3.0|v3.1>] [--lang <zh|en>]"
+---
+
+# Swagger API Documentation Workflow (/memory:swagger-docs)
+
+## Overview
+
+Professional Swagger/OpenAPI documentation generator that strictly follows RESTful API design standards to produce enterprise-grade API documentation.
+
+**Core Features**:
+- **RESTful Standards**: Strict adherence to REST architecture and HTTP semantics
+- **Global Security**: Unified Authorization Token validation mechanism
+- **Complete API Docs**: Descriptions, methods, URLs, parameters for each endpoint
+- **Organized Structure**: Clear directory hierarchy by business domain
+- **Detailed Fields**: Type, required, example, description for each field
+- **Error Code Standards**: Unified error response format and code definitions
+- **Validation Tests**: Boundary conditions and exception handling tests
+
+**Output Structure** (--lang zh):
+```
+.workflow/docs/{project_name}/api/
+├── swagger.yaml              # Main OpenAPI spec file
+├── 概述/
+│   ├── README.md             # API overview
+│   ├── 认证说明.md           # Authentication guide
+│   ├── 错误码规范.md         # Error code definitions
+│   └── 版本历史.md           # Version history
+├── 用户模块/                 # Grouped by business domain
+│   ├── 用户认证.md
+│   ├── 用户管理.md
+│   └── 权限控制.md
+├── 业务模块/
+│   └── ...
+└── 测试报告/
+    ├── 接口测试.md           # API test results
+    └── 边界测试.md           # Boundary condition tests
+```
+
+**Output Structure** (--lang en):
+```
+.workflow/docs/{project_name}/api/
+├── swagger.yaml              # Main OpenAPI spec file
+├── overview/
+│   ├── README.md             # API overview
+│   ├── authentication.md     # Authentication guide
+│   ├── error-codes.md        # Error code definitions
+│   └── changelog.md          # Version history
+├── users/                    # Grouped by business domain
+│   ├── authentication.md
+│   ├── management.md
+│   └── permissions.md
+├── orders/
+│   └── ...
+└── test-reports/
+    ├── api-tests.md          # API test results
+    └── boundary-tests.md     # Boundary condition tests
+```
+
+## Parameters
+
+```bash
+/memory:swagger-docs [path] [--tool <gemini|qwen|codex>] [--format <yaml|json>] [--version <v3.0|v3.1>] [--lang <zh|en>]
+```
+
+- **path**: API source code directory (default: current directory)
+- **--tool**: CLI tool selection (default: gemini)
+  - `gemini`: Comprehensive analysis, pattern recognition
+  - `qwen`: Architecture analysis, system design
+  - `codex`: Implementation validation, code quality
+- **--format**: OpenAPI spec format (default: yaml)
+  - `yaml`: YAML format (recommended, better readability)
+  - `json`: JSON format
+- **--version**: OpenAPI version (default: v3.0)
+  - `v3.0`: OpenAPI 3.0.x
+  - `v3.1`: OpenAPI 3.1.0 (supports JSON Schema 2020-12)
+- **--lang**: Documentation language (default: zh)
+  - `zh`: Chinese documentation with Chinese directory names
+  - `en`: English documentation with English directory names
+
+## Planning Workflow
+
+### Phase 1: Initialize Session
+
+```bash
+# Get project info
+bash(pwd && basename "$(pwd)" && git rev-parse --show-toplevel 2>/dev/null || pwd && date +%Y%m%d-%H%M%S)
+```
+
+```javascript
+// Create swagger-docs session
+SlashCommand(command="/workflow:session:start --type swagger-docs --new \"{project_name}-swagger-{timestamp}\"")
+// Parse output to get sessionId
+```
+
+```bash
+# Update workflow-session.json
+bash(jq '. + {"target_path":"{target_path}","project_root":"{project_root}","project_name":"{project_name}","format":"yaml","openapi_version":"3.0.3","lang":"{lang}","tool":"gemini"}' .workflow/active/{sessionId}/workflow-session.json > tmp.json && mv tmp.json .workflow/active/{sessionId}/workflow-session.json)
+```
+
+### Phase 2: Scan API Endpoints
+
+**Discovery Patterns**: Auto-detect framework signatures and API definition styles.
+
+**Supported Frameworks**:
+| Framework | Detection Pattern | Example |
+|-----------|-------------------|---------|
+| Express.js | `router.get/post/put/delete` | `router.get('/users/:id')` |
+| Fastify | `fastify.route`, `@Route` | `fastify.get('/api/users')` |
+| NestJS | `@Controller`, `@Get/@Post` | `@Get('users/:id')` |
+| Koa | `router.get`, `ctx.body` | `router.get('/users')` |
+| Hono | `app.get/post`, `c.json` | `app.get('/users/:id')` |
+| FastAPI | `@app.get`, `@router.post` | `@app.get("/users/{id}")` |
+| Flask | `@app.route`, `@bp.route` | `@app.route('/users')` |
+| Spring | `@GetMapping`, `@PostMapping` | `@GetMapping("/users/{id}")` |
+| Go Gin | `r.GET`, `r.POST` | `r.GET("/users/:id")` |
+| Go Chi | `r.Get`, `r.Post` | `r.Get("/users/{id}")` |
+
+**Commands**:
+
+```bash
+# 1. Detect API framework type
+bash(
+  if rg -q "@Controller|@Get|@Post|@Put|@Delete" --type ts 2>/dev/null; then echo "NESTJS";
+  elif rg -q "router\.(get|post|put|delete|patch)" --type ts --type js 2>/dev/null; then echo "EXPRESS";
+  elif rg -q "fastify\.(get|post|route)" --type ts --type js 2>/dev/null; then echo "FASTIFY";
+  elif rg -q "@app\.(get|post|put|delete)" --type py 2>/dev/null; then echo "FASTAPI";
+  elif rg -q "@GetMapping|@PostMapping|@RequestMapping" --type java 2>/dev/null; then echo "SPRING";
+  elif rg -q 'r\.(GET|POST|PUT|DELETE)' --type go 2>/dev/null; then echo "GO_GIN";
+  else echo "UNKNOWN"; fi
+)
+
+# 2. Scan all API endpoint definitions
+bash(rg -n "(router|app|fastify)\.(get|post|put|delete|patch)|@(Get|Post|Put|Delete|Patch|Controller|RequestMapping)" --type ts --type js --type py --type java --type go -g '!*.test.*' -g '!*.spec.*' -g '!node_modules/**' 2>/dev/null | head -200)
+
+# 3. Extract route paths
+bash(rg -o "['\"](/api)?/[a-zA-Z0-9/:_-]+['\"]" --type ts --type js --type py -g '!*.test.*' 2>/dev/null | sort -u | head -100)
+
+# 4. Detect existing OpenAPI/Swagger files
+bash(find . -type f \( -name "swagger.yaml" -o -name "swagger.json" -o -name "openapi.yaml" -o -name "openapi.json" \) ! -path "*/node_modules/*" 2>/dev/null)
+
+# 5. Extract DTO/Schema definitions
+bash(rg -n "export (interface|type|class).*Dto|@ApiProperty|class.*Schema" --type ts -g '!*.test.*' 2>/dev/null | head -100)
+```
+
+**Data Processing**: Parse outputs, use **Write tool** to create `${session_dir}/.process/swagger-planning-data.json`:
+
+```json
+{
+  "metadata": {
+    "generated_at": "2025-01-01T12:00:00+08:00",
+    "project_name": "project_name",
+    "project_root": "/path/to/project",
+    "openapi_version": "3.0.3",
+    "format": "yaml",
+    "lang": "zh"
+  },
+  "framework": {
+    "type": "NESTJS",
+    "detected_patterns": ["@Controller", "@Get", "@Post"],
+    "base_path": "/api/v1"
+  },
+  "endpoints": [
+    {
+      "file": "src/modules/users/users.controller.ts",
+      "line": 25,
+      "method": "GET",
+      "path": "/api/v1/users/:id",
+      "handler": "getUser",
+      "controller": "UsersController"
+    }
+  ],
+  "existing_specs": {
+    "found": false,
+    "files": []
+  },
+  "dto_schemas": [
+    {
+      "name": "CreateUserDto",
+      "file": "src/modules/users/dto/create-user.dto.ts",
+      "properties": ["email", "password", "name"]
+    }
+  ],
+  "statistics": {
+    "total_endpoints": 45,
+    "by_method": {"GET": 20, "POST": 15, "PUT": 5, "DELETE": 5},
+    "by_module": {"users": 12, "auth": 8, "orders": 15, "products": 10}
+  }
+}
+```
+
+### Phase 3: Analyze API Structure
+
+**Commands**:
+
+```bash
+# 1. Analyze controller/route file structure
+bash(cat ${session_dir}/.process/swagger-planning-data.json | jq -r '.endpoints[].file' | sort -u | head -20)
+
+# 2. Extract request/response types
+bash(for f in $(jq -r '.dto_schemas[].file' ${session_dir}/.process/swagger-planning-data.json | head -20); do echo "=== $f ===" && cat "$f" 2>/dev/null; done)
+
+# 3. Analyze authentication middleware
+bash(rg -n "auth|guard|middleware|jwt|bearer|token" -i --type ts --type js -g '!*.test.*' -g '!node_modules/**' 2>/dev/null | head -50)
+
+# 4. Detect error handling patterns
+bash(rg -n "HttpException|BadRequest|Unauthorized|Forbidden|NotFound|throw new" --type ts --type js -g '!*.test.*' 2>/dev/null | head -50)
+```
+
+**Deep Analysis via Gemini CLI**:
+
+```bash
+ccw cli -p "
+PURPOSE: Analyze API structure and generate OpenAPI specification outline for comprehensive documentation
+TASK: 
+• Parse all API endpoints and identify business module boundaries
+• Extract request parameters, request bodies, and response formats
+• Identify authentication mechanisms and security requirements
+• Discover error handling patterns and error codes
+• Map endpoints to logical module groups
+MODE: analysis
+CONTEXT: @src/**/*.controller.ts @src/**/*.routes.ts @src/**/*.dto.ts @src/**/middleware/**/*
+EXPECTED: JSON format API structure analysis report with modules, endpoints, security schemes, and error codes
+CONSTRAINTS: Strict RESTful standards | Identify all public endpoints | Document output language: {lang}
+" --tool gemini --mode analysis --rule analysis-code-patterns --cd {project_root}
+```
+
+**Update swagger-planning-data.json** with analysis results:
+
+```json
+{
+  "api_structure": {
+    "modules": [
+      {
+        "name": "Users",
+        "name_zh": "用户模块",
+        "base_path": "/api/v1/users",
+        "endpoints": [
+          {
+            "path": "/api/v1/users",
+            "method": "GET",
+            "operation_id": "listUsers",
+            "summary": "List all users",
+            "summary_zh": "获取用户列表",
+            "description": "Paginated list of system users with filtering by status and role",
+            "description_zh": "分页获取系统用户列表，支持按状态、角色筛选",
+            "tags": ["User Management"],
+            "tags_zh": ["用户管理"],
+            "security": ["bearerAuth"],
+            "parameters": {
+              "query": ["page", "limit", "status", "role"]
+            },
+            "responses": {
+              "200": "UserListResponse",
+              "401": "UnauthorizedError",
+              "403": "ForbiddenError"
+            }
+          }
+        ]
+      }
+    ],
+    "security_schemes": {
+      "bearerAuth": {
+        "type": "http",
+        "scheme": "bearer",
+        "bearerFormat": "JWT",
+        "description": "JWT Token authentication. Add Authorization: Bearer <token> to request header"
+      }
+    },
+    "error_codes": [
+      {"code": "AUTH_001", "status": 401, "message": "Invalid or expired token", "message_zh": "Token 无效或已过期"},
+      {"code": "AUTH_002", "status": 401, "message": "Authentication required", "message_zh": "未提供认证信息"},
+      {"code": "AUTH_003", "status": 403, "message": "Insufficient permissions", "message_zh": "权限不足"}
+    ]
+  }
+}
+```
+
+### Phase 4: Task Decomposition
+
+**Task Hierarchy**:
+
+```
+Level 1: Infrastructure Tasks (Parallel)
+  ├─ IMPL-001: Generate main OpenAPI spec file (swagger.yaml)
+  ├─ IMPL-002: Generate global security config and auth documentation
+  └─ IMPL-003: Generate unified error code specification
+
+Level 2: Module Documentation Tasks (Parallel, by business module)
+  ├─ IMPL-004: Users module API documentation
+  ├─ IMPL-005: Auth module API documentation
+  ├─ IMPL-006: Business module N API documentation
+  └─ ...
+
+Level 3: Aggregation Tasks (Depends on Level 1-2)
+  ├─ IMPL-N+1: Generate API overview and navigation
+  └─ IMPL-N+2: Generate version history and changelog
+
+Level 4: Validation Tasks (Depends on Level 1-3)
+  ├─ IMPL-N+3: API endpoint validation tests
+  └─ IMPL-N+4: Boundary condition tests
+```
+
+**Grouping Strategy**:
+1. Group by business module (users, orders, products, etc.)
+2. Maximum 10 endpoints per task
+3. Large modules (>10 endpoints) split by submodules
+
+**Commands**:
+
+```bash
+# 1. Count endpoints by module
+bash(cat ${session_dir}/.process/swagger-planning-data.json | jq '.statistics.by_module')
+
+# 2. Calculate task groupings
+bash(cat ${session_dir}/.process/swagger-planning-data.json | jq -r '.api_structure.modules[] | "\(.name):\(.endpoints | length)"')
+```
+
+**Data Processing**: Use **Edit tool** to update `swagger-planning-data.json` with task groups:
+
+```json
+{
+  "task_groups": {
+    "level1_count": 3,
+    "level2_count": 5,
+    "total_count": 12,
+    "assignments": [
+      {"task_id": "IMPL-001", "level": 1, "type": "openapi-spec", "title": "Generate OpenAPI main spec file"},
+      {"task_id": "IMPL-002", "level": 1, "type": "security", "title": "Generate global security config"},
+      {"task_id": "IMPL-003", "level": 1, "type": "error-codes", "title": "Generate error code specification"},
+      {"task_id": "IMPL-004", "level": 2, "type": "module-doc", "module": "users", "endpoint_count": 12},
+      {"task_id": "IMPL-005", "level": 2, "type": "module-doc", "module": "auth", "endpoint_count": 8}
+    ]
+  }
+}
+```
+
+### Phase 5: Generate Task JSONs
+
+**Generation Process**:
+1. Read configuration values from workflow-session.json
+2. Read task groups from swagger-planning-data.json
+3. Generate Level 1 tasks (infrastructure)
+4. Generate Level 2 tasks (by module)
+5. Generate Level 3-4 tasks (aggregation and validation)
+
+## Task Templates
+
+### Level 1-1: OpenAPI Main Spec File
+
+```json
+{
+  "id": "IMPL-001",
+  "title": "Generate OpenAPI main specification file",
+  "status": "pending",
+  "meta": {
+    "type": "swagger-openapi-spec",
+    "agent": "@doc-generator",
+    "tool": "gemini",
+    "priority": "critical"
+  },
+  "context": {
+    "requirements": [
+      "Generate OpenAPI 3.0.3 compliant swagger.yaml",
+      "Include complete info, servers, tags, paths, components definitions",
+      "Follow RESTful design standards, use {lang} for descriptions"
+    ],
+    "precomputed_data": {
+      "planning_data": "${session_dir}/.process/swagger-planning-data.json"
+    }
+  },
+  "flow_control": {
+    "pre_analysis": [
+      {
+        "step": "load_analysis_data",
+        "action": "Load API analysis data",
+        "commands": [
+          "bash(cat ${session_dir}/.process/swagger-planning-data.json)"
+        ],
+        "output_to": "api_analysis"
+      }
+    ],
+    "implementation_approach": [
+      {
+        "step": 1,
+        "title": "Generate OpenAPI spec file",
+        "description": "Create complete swagger.yaml specification file",
+        "cli_prompt": "PURPOSE: Generate OpenAPI 3.0.3 specification file from analyzed API structure\nTASK:\n• Define openapi version: 3.0.3\n• Define info: title, description, version, contact, license\n• Define servers: development, staging, production environments\n• Define tags: organized by business modules\n• Define paths: all API endpoints with complete specifications\n• Define components: schemas, securitySchemes, parameters, responses\nMODE: write\nCONTEXT: @[api_analysis]\nEXPECTED: Complete swagger.yaml file following OpenAPI 3.0.3 specification\nCONSTRAINTS: Use {lang} for all descriptions | Strict RESTful standards\n--rule documentation-swagger-api",
+        "output": "swagger.yaml"
+      }
+    ],
+    "target_files": [
+      ".workflow/docs/${project_name}/api/swagger.yaml"
+    ]
+  }
+}
+```
+
+### Level 1-2: Global Security Configuration
+
+```json
+{
+  "id": "IMPL-002",
+  "title": "Generate global security configuration and authentication guide",
+  "status": "pending",
+  "meta": {
+    "type": "swagger-security",
+    "agent": "@doc-generator",
+    "tool": "gemini"
+  },
+  "context": {
+    "requirements": [
+      "Document Authorization header format in detail",
+      "Describe token acquisition, refresh, and expiration mechanisms",
+      "List permission requirements for each endpoint"
+    ]
+  },
+  "flow_control": {
+    "pre_analysis": [
+      {
+        "step": "analyze_auth",
+        "command": "bash(rg -n 'auth|guard|jwt|bearer' -i --type ts -g '!*.test.*' 2>/dev/null | head -50)",
+        "output_to": "auth_patterns"
+      }
+    ],
+    "implementation_approach": [
+      {
+        "step": 1,
+        "title": "Generate authentication documentation",
+        "cli_prompt": "PURPOSE: Generate comprehensive authentication documentation for API security\nTASK:\n• Document authentication mechanism: JWT Bearer Token\n• Explain header format: Authorization: Bearer <token>\n• Describe token lifecycle: acquisition, refresh, expiration handling\n• Define permission levels: public, user, admin, super_admin\n• Document authentication failure responses: 401/403 error handling\nMODE: write\nCONTEXT: @[auth_patterns] @src/**/auth/**/* @src/**/guard/**/*\nEXPECTED: Complete authentication guide in {lang}\nCONSTRAINTS: Include code examples | Clear step-by-step instructions\n--rule development-feature",
+        "output": "{auth_doc_name}"
+      }
+    ],
+    "target_files": [
+      ".workflow/docs/${project_name}/api/{overview_dir}/{auth_doc_name}"
+    ]
+  }
+}
+```
+
+### Level 1-3: Unified Error Code Specification
+
+```json
+{
+  "id": "IMPL-003",
+  "title": "Generate unified error code specification",
+  "status": "pending",
+  "meta": {
+    "type": "swagger-error-codes",
+    "agent": "@doc-generator",
+    "tool": "gemini"
+  },
+  "context": {
+    "requirements": [
+      "Define unified error response format",
+      "Create categorized error code system (auth, business, system)",
+      "Provide detailed description and examples for each error code"
+    ]
+  },
+  "flow_control": {
+    "implementation_approach": [
+      {
+        "step": 1,
+        "title": "Generate error code specification document",
+        "cli_prompt": "PURPOSE: Generate comprehensive error code specification for consistent API error handling\nTASK:\n• Define error response format: {code, message, details, timestamp}\n• Document authentication errors (AUTH_xxx): 401/403 series\n• Document parameter errors (PARAM_xxx): 400 series\n• Document business errors (BIZ_xxx): business logic errors\n• Document system errors (SYS_xxx): 500 series\n• For each error code: HTTP status, error message, possible causes, resolution suggestions\nMODE: write\nCONTEXT: @src/**/*.exception.ts @src/**/*.filter.ts\nEXPECTED: Complete error code specification in {lang} with tables and examples\nCONSTRAINTS: Include response examples | Clear categorization\n--rule development-feature",
+        "output": "{error_doc_name}"
+      }
+    ],
+    "target_files": [
+      ".workflow/docs/${project_name}/api/{overview_dir}/{error_doc_name}"
+    ]
+  }
+}
+```
+
+### Level 2: Module API Documentation (Template)
+
+```json
+{
+  "id": "IMPL-${module_task_id}",
+  "title": "Generate ${module_name} API documentation",
+  "status": "pending",
+  "depends_on": ["IMPL-001", "IMPL-002", "IMPL-003"],
+  "meta": {
+    "type": "swagger-module-doc",
+    "agent": "@doc-generator",
+    "tool": "gemini",
+    "module": "${module_name}",
+    "endpoint_count": "${endpoint_count}"
+  },
+  "context": {
+    "requirements": [
+      "Complete documentation for all endpoints in this module",
+      "Each endpoint: description, method, URL, parameters, responses",
+      "Include success and failure response examples",
+      "Mark API version and last update time"
+    ],
+    "focus_paths": ["${module_source_paths}"]
+  },
+  "flow_control": {
+    "pre_analysis": [
+      {
+        "step": "load_module_endpoints",
+        "action": "Load module endpoint information",
+        "commands": [
+          "bash(cat ${session_dir}/.process/swagger-planning-data.json | jq '.api_structure.modules[] | select(.name == \"${module_name}\")')"
+        ],
+        "output_to": "module_endpoints"
+      },
+      {
+        "step": "read_source_files",
+        "action": "Read module source files",
+        "commands": [
+          "bash(cat ${module_source_files})"
+        ],
+        "output_to": "source_code"
+      }
+    ],
+    "implementation_approach": [
+      {
+        "step": 1,
+        "title": "Generate module API documentation",
+        "description": "Generate complete API documentation for ${module_name}",
+        "cli_prompt": "PURPOSE: Generate complete RESTful API documentation for ${module_name} module\nTASK:\n• Create module overview: purpose, use cases, prerequisites\n• Generate endpoint index: grouped by functionality\n• For each endpoint document:\n  - Functional description: purpose and business context\n  - Request method: GET/POST/PUT/DELETE\n  - URL path: complete API path\n  - Request headers: Authorization and other required headers\n  - Path parameters: {id} and other path variables\n  - Query parameters: pagination, filters, etc.\n  - Request body: JSON Schema format\n  - Response body: success and error responses\n  - Field description table: type, required, example, description\n• Add usage examples: cURL, JavaScript, Python\n• Add version info: v1.0.0, last updated date\nMODE: write\nCONTEXT: @[module_endpoints] @[source_code]\nEXPECTED: Complete module API documentation in {lang} with all endpoints fully documented\nCONSTRAINTS: RESTful standards | Include all response codes\n--rule documentation-swagger-api",
+        "output": "${module_doc_name}"
+      }
+    ],
+    "target_files": [
+      ".workflow/docs/${project_name}/api/${module_dir}/${module_doc_name}"
+    ]
+  }
+}
+```
+
+### Level 3: API Overview and Navigation
+
+```json
+{
+  "id": "IMPL-${overview_task_id}",
+  "title": "Generate API overview and navigation",
+  "status": "pending",
+  "depends_on": ["IMPL-001", "...", "IMPL-${last_module_task_id}"],
+  "meta": {
+    "type": "swagger-overview",
+    "agent": "@doc-generator",
+    "tool": "gemini"
+  },
+  "flow_control": {
+    "pre_analysis": [
+      {
+        "step": "load_all_docs",
+        "command": "bash(find .workflow/docs/${project_name}/api -type f -name '*.md' ! -path '*/{overview_dir}/*' | xargs cat)",
+        "output_to": "all_module_docs"
+      }
+    ],
+    "implementation_approach": [
+      {
+        "step": 1,
+        "title": "Generate API overview",
+        "cli_prompt": "PURPOSE: Generate API overview document with navigation and quick start guide\nTASK:\n• Create introduction: system features, tech stack, version\n• Write quick start guide: authentication, first request example\n• Build module navigation: categorized links to all modules\n• Document environment configuration: development, staging, production\n• List SDKs and tools: client libraries, Postman collection\nMODE: write\nCONTEXT: @[all_module_docs] @.workflow/docs/${project_name}/api/swagger.yaml\nEXPECTED: Complete API overview in {lang} with navigation links\nCONSTRAINTS: Clear structure | Quick start focus\n--rule development-feature",
+        "output": "README.md"
+      }
+    ],
+    "target_files": [
+      ".workflow/docs/${project_name}/api/{overview_dir}/README.md"
+    ]
+  }
+}
+```
+
+### Level 4: Validation Tasks
+
+```json
+{
+  "id": "IMPL-${test_task_id}",
+  "title": "API endpoint validation tests",
+  "status": "pending",
+  "depends_on": ["IMPL-${overview_task_id}"],
+  "meta": {
+    "type": "swagger-validation",
+    "agent": "@test-fix-agent",
+    "tool": "codex"
+  },
+  "context": {
+    "requirements": [
+      "Validate accessibility of all endpoints",
+      "Test various boundary conditions",
+      "Verify exception handling"
+    ]
+  },
+  "flow_control": {
+    "pre_analysis": [
+      {
+        "step": "load_swagger_spec",
+        "command": "bash(cat .workflow/docs/${project_name}/api/swagger.yaml)",
+        "output_to": "swagger_spec"
+      }
+    ],
+    "implementation_approach": [
+      {
+        "step": 1,
+        "title": "Generate test report",
+        "cli_prompt": "PURPOSE: Generate comprehensive API test validation report\nTASK:\n• Document test environment configuration\n• Calculate endpoint coverage statistics\n• Report test results: pass/fail counts\n• Document boundary tests: parameter limits, null values, special characters\n• Document exception tests: auth failures, permission denied, resource not found\n• List issues found with recommendations\nMODE: write\nCONTEXT: @[swagger_spec]\nEXPECTED: Complete test report in {lang} with detailed results\nCONSTRAINTS: Include test cases | Clear pass/fail status\n--rule development-tests",
+        "output": "{test_doc_name}"
+      }
+    ],
+    "target_files": [
+      ".workflow/docs/${project_name}/api/{test_dir}/{test_doc_name}"
+    ]
+  }
+}
+```
+
+## Language-Specific Directory Mapping
+
+| Component | --lang zh | --lang en |
+|-----------|-----------|-----------|
+| Overview dir | 概述 | overview |
+| Auth doc | 认证说明.md | authentication.md |
+| Error doc | 错误码规范.md | error-codes.md |
+| Changelog | 版本历史.md | changelog.md |
+| Users module | 用户模块 | users |
+| Orders module | 订单模块 | orders |
+| Products module | 商品模块 | products |
+| Test dir | 测试报告 | test-reports |
+| API test doc | 接口测试.md | api-tests.md |
+| Boundary test doc | 边界测试.md | boundary-tests.md |
+
+## API Documentation Template
+
+### Single Endpoint Format
+
+Each endpoint must include:
+
+```markdown
+### Get User Details
+
+**Description**: Retrieve detailed user information by ID, including profile and permissions.
+
+**Endpoint Info**:
+
+| Property | Value |
+|----------|-------|
+| Method | GET |
+| URL | `/api/v1/users/{id}` |
+| Version | v1.0.0 |
+| Updated | 2025-01-01 |
+| Auth | Bearer Token |
+| Permission | user / admin |
+
+**Request Headers**:
+
+| Field | Type | Required | Example | Description |
+|-------|------|----------|---------|-------------|
+| Authorization | string | Yes | `Bearer eyJhbGc...` | JWT Token |
+| Content-Type | string | No | `application/json` | Request content type |
+
+**Path Parameters**:
+
+| Field | Type | Required | Example | Description |
+|-------|------|----------|---------|-------------|
+| id | string | Yes | `usr_123456` | Unique user identifier |
+
+**Query Parameters**:
+
+| Field | Type | Required | Default | Example | Description |
+|-------|------|----------|---------|---------|-------------|
+| include | string | No | - | `roles,permissions` | Related data to include |
+
+**Success Response** (200 OK):
+
+```json
+{
+  "code": 0,
+  "message": "success",
+  "data": {
+    "id": "usr_123456",
+    "email": "user@example.com",
+    "name": "John Doe",
+    "status": "active",
+    "roles": ["user"],
+    "created_at": "2025-01-01T00:00:00Z",
+    "updated_at": "2025-01-01T00:00:00Z"
+  },
+  "timestamp": "2025-01-01T12:00:00Z"
+}
+```
+
+**Response Fields**:
+
+| Field | Type | Description |
+|-------|------|-------------|
+| code | integer | Business status code, 0 = success |
+| message | string | Response message |
+| data.id | string | Unique user identifier |
+| data.email | string | User email address |
+| data.name | string | User display name |
+| data.status | string | User status: active/inactive/suspended |
+| data.roles | array | User role list |
+| data.created_at | string | Creation timestamp (ISO 8601) |
+| data.updated_at | string | Last update timestamp (ISO 8601) |
+
+**Error Responses**:
+
+| Status | Code | Message | Possible Cause |
+|--------|------|---------|----------------|
+| 401 | AUTH_001 | Invalid or expired token | Token format error or expired |
+| 403 | AUTH_003 | Insufficient permissions | No access to this user info |
+| 404 | USER_001 | User not found | User ID doesn't exist or deleted |
+
+**Examples**:
+
+```bash
+# cURL
+curl -X GET "https://api.example.com/api/v1/users/usr_123456" \
+  -H "Authorization: Bearer eyJhbGc..." \
+  -H "Content-Type: application/json"
+```
+
+```javascript
+// JavaScript (fetch)
+const response = await fetch('https://api.example.com/api/v1/users/usr_123456', {
+  method: 'GET',
+  headers: {
+    'Authorization': 'Bearer eyJhbGc...',
+    'Content-Type': 'application/json'
+  }
+});
+const data = await response.json();
+```
+```
+
+## Session Structure
+
+```
+.workflow/active/
+└── WFS-swagger-{timestamp}/
+    ├── workflow-session.json
+    ├── IMPL_PLAN.md
+    ├── TODO_LIST.md
+    ├── .process/
+    │   └── swagger-planning-data.json
+    └── .task/
+        ├── IMPL-001.json              # OpenAPI spec
+        ├── IMPL-002.json              # Security config
+        ├── IMPL-003.json              # Error codes
+        ├── IMPL-004.json              # Module 1 API
+        ├── ...
+        ├── IMPL-N+1.json              # API overview
+        └── IMPL-N+2.json              # Validation tests
+```
+
+## Execution Commands
+
+```bash
+# Execute entire workflow
+/workflow:execute
+
+# Specify session
+/workflow:execute --resume-session="WFS-swagger-yyyymmdd-hhmmss"
+
+# Single task execution
+/task:execute IMPL-001
+```
+
+## Related Commands
+
+- `/workflow:execute` - Execute documentation tasks
+- `/workflow:status` - View task progress
+- `/workflow:session:complete` - Mark session complete
+- `/memory:docs` - General documentation workflow

.claude/commands/memory/tech-research-rules.md

@@ -147,8 +147,8 @@ You are generating path-conditional rules for Claude Code.
 
 ## Instructions
 
-Read the agent prompt template for detailed instructions:
-$(cat ~/.claude/workflows/cli-templates/prompts/rules/tech-rules-agent-prompt.txt)
+Read the agent prompt template for detailed instructions.
+Use --rule rules-tech-rules-agent-prompt to load the template automatically.
 
 ## Execution Steps
 

.claude/commands/workflow/brainstorm/auto-parallel.md

@@ -9,11 +9,11 @@ allowed-tools: SlashCommand(*), Task(*), TodoWrite(*), Read(*), Write(*), Bash(*
 
 ## Coordinator Role
 
-**This command is a pure orchestrator**: Dispatches 3 phases in sequence (interactive framework → parallel role analysis → synthesis), coordinating specialized commands/agents through task attachment model.
+**This command is a pure orchestrator**: Executes 3 phases in sequence (interactive framework → parallel role analysis → synthesis), coordinating specialized commands/agents through task attachment model.
 
 **Task Attachment Model**:
-- SlashCommand dispatch **expands workflow** by attaching sub-tasks to current TodoWrite
-- Task agent dispatch **attaches analysis tasks** to orchestrator's TodoWrite
+- SlashCommand execute **expands workflow** by attaching sub-tasks to current TodoWrite
+- Task agent execute **attaches analysis tasks** to orchestrator's TodoWrite
 - Phase 1: artifacts command attaches its internal tasks (Phase 1-5)
 - Phase 2: N conceptual-planning-agent tasks attached in parallel
 - Phase 3: synthesis command attaches its internal tasks
@@ -26,9 +26,9 @@ allowed-tools: SlashCommand(*), Task(*), TodoWrite(*), Read(*), Write(*), Bash(*
 This workflow runs **fully autonomously** once triggered. Phase 1 (artifacts) handles user interaction, Phase 2 (role agents) runs in parallel.
 
 1. **User triggers**: `/workflow:brainstorm:auto-parallel "topic" [--count N]`
-2. **Dispatch Phase 1** → artifacts command (tasks ATTACHED) → Auto-continues
-3. **Dispatch Phase 2** → Parallel role agents (N tasks ATTACHED concurrently) → Auto-continues
-4. **Dispatch Phase 3** → Synthesis command (tasks ATTACHED) → Reports final summary
+2. **Execute Phase 1** → artifacts command (tasks ATTACHED) → Auto-continues
+3. **Execute Phase 2** → Parallel role agents (N tasks ATTACHED concurrently) → Auto-continues
+4. **Execute Phase 3** → Synthesis command (tasks ATTACHED) → Reports final summary
 
 **Auto-Continue Mechanism**:
 - TodoList tracks current phase status and dynamically manages task attachment/collapse
@@ -38,13 +38,13 @@ This workflow runs **fully autonomously** once triggered. Phase 1 (artifacts) ha
 
 ## Core Rules
 
-1. **Start Immediately**: First action is TodoWrite initialization, second action is dispatch Phase 1 command
+1. **Start Immediately**: First action is TodoWrite initialization, second action is execute Phase 1 command
 2. **No Preliminary Analysis**: Do not analyze topic before Phase 1 - artifacts handles all analysis
 3. **Parse Every Output**: Extract selected_roles from workflow-session.json after Phase 1
-4. **Auto-Continue via TodoList**: Check TodoList status to dispatch next pending phase automatically
+4. **Auto-Continue via TodoList**: Check TodoList status to execute next pending phase automatically
 5. **Track Progress**: Update TodoWrite dynamically with task attachment/collapse pattern
-6. **Task Attachment Model**: SlashCommand and Task dispatches **attach** sub-tasks to current workflow. Orchestrator **executes** these attached tasks itself, then **collapses** them after completion
-7. **⚠️ CRITICAL: DO NOT STOP**: Continuous multi-phase workflow. After executing all attached tasks, immediately collapse them and dispatch next phase
+6. **Task Attachment Model**: SlashCommand and Task executes **attach** sub-tasks to current workflow. Orchestrator **executes** these attached tasks itself, then **collapses** them after completion
+7. **⚠️ CRITICAL: DO NOT STOP**: Continuous multi-phase workflow. After executing all attached tasks, immediately collapse them and execute next phase
 8. **Parallel Execution**: Phase 2 attaches multiple agent tasks simultaneously for concurrent execution
 
 ## Usage
@@ -67,7 +67,7 @@ This workflow runs **fully autonomously** once triggered. Phase 1 (artifacts) ha
 
 ### Phase 1: Interactive Framework Generation
 
-**Step 1: Dispatch** - Interactive framework generation via artifacts command
+**Step 1: Execute** - Interactive framework generation via artifacts command
 
 ```javascript
 SlashCommand(command="/workflow:brainstorm:artifacts \"{topic}\" --count {N}")
@@ -91,7 +91,7 @@ SlashCommand(command="/workflow:brainstorm:artifacts \"{topic}\" --count {N}")
 - workflow-session.json contains selected_roles[] (metadata only, no content duplication)
 - Session directory `.workflow/active/WFS-{topic}/.brainstorming/` exists
 
-**TodoWrite Update (Phase 1 SlashCommand dispatched - tasks attached)**:
+**TodoWrite Update (Phase 1 SlashCommand executed - tasks attached)**:
 ```json
 [
   {"content": "Phase 0: Parameter Parsing", "status": "completed", "activeForm": "Parsing count parameter"},
@@ -106,7 +106,7 @@ SlashCommand(command="/workflow:brainstorm:artifacts \"{topic}\" --count {N}")
 ]
 ```
 
-**Note**: SlashCommand dispatch **attaches** artifacts' 5 internal tasks. Orchestrator **executes** these tasks sequentially.
+**Note**: SlashCommand execute **attaches** artifacts' 5 internal tasks. Orchestrator **executes** these tasks sequentially.
 
 **Next Action**: Tasks attached → **Execute Phase 1.1-1.5** sequentially
 
@@ -167,7 +167,7 @@ TOPIC: {user-provided-topic}
 "
 ```
 
-**Parallel Dispatch**:
+**Parallel Execute**:
 - Launch N agents simultaneously (one message with multiple Task calls)
 - Each agent task **attached** to orchestrator's TodoWrite
 - All agents execute concurrently, each attaching their own analysis sub-tasks
@@ -185,7 +185,7 @@ TOPIC: {user-provided-topic}
 - **FORBIDDEN**: `recommendations.md` or any non-`analysis` prefixed files
 - All N role analyses completed
 
-**TodoWrite Update (Phase 2 agents dispatched - tasks attached in parallel)**:
+**TodoWrite Update (Phase 2 agents executed - tasks attached in parallel)**:
 ```json
 [
   {"content": "Phase 0: Parameter Parsing", "status": "completed", "activeForm": "Parsing count parameter"},
@@ -198,7 +198,7 @@ TOPIC: {user-provided-topic}
 ]
 ```
 
-**Note**: Multiple Task dispatches **attach** N role analysis tasks simultaneously. Orchestrator **executes** these tasks in parallel.
+**Note**: Multiple Task executes **attach** N role analysis tasks simultaneously. Orchestrator **executes** these tasks in parallel.
 
 **Next Action**: Tasks attached → **Execute Phase 2.1-2.N** concurrently
 
@@ -220,7 +220,7 @@ TOPIC: {user-provided-topic}
 
 ### Phase 3: Synthesis Generation
 
-**Step 3: Dispatch** - Synthesis integration via synthesis command
+**Step 3: Execute** - Synthesis integration via synthesis command
 
 ```javascript
 SlashCommand(command="/workflow:brainstorm:synthesis --session {sessionId}")
@@ -238,7 +238,7 @@ SlashCommand(command="/workflow:brainstorm:synthesis --session {sessionId}")
 - `.workflow/active/WFS-{topic}/.brainstorming/synthesis-specification.md` exists
 - Synthesis references all role analyses
 
-**TodoWrite Update (Phase 3 SlashCommand dispatched - tasks attached)**:
+**TodoWrite Update (Phase 3 SlashCommand executed - tasks attached)**:
 ```json
 [
   {"content": "Phase 0: Parameter Parsing", "status": "completed", "activeForm": "Parsing count parameter"},
@@ -251,7 +251,7 @@ SlashCommand(command="/workflow:brainstorm:synthesis --session {sessionId}")
 ]
 ```
 
-**Note**: SlashCommand dispatch **attaches** synthesis' internal tasks. Orchestrator **executes** these tasks sequentially.
+**Note**: SlashCommand execute **attaches** synthesis' internal tasks. Orchestrator **executes** these tasks sequentially.
 
 **Next Action**: Tasks attached → **Execute Phase 3.1-3.3** sequentially
 
@@ -284,7 +284,7 @@ Synthesis: .workflow/active/WFS-{topic}/.brainstorming/synthesis-specification.m
 
 ### Key Principles
 
-1. **Task Attachment** (when SlashCommand/Task dispatched):
+1. **Task Attachment** (when SlashCommand/Task executed):
    - Sub-command's or agent's internal tasks are **attached** to orchestrator's TodoWrite
    - Phase 1: `/workflow:brainstorm:artifacts` attaches 5 internal tasks (Phase 1.1-1.5)
    - Phase 2: Multiple `Task(conceptual-planning-agent)` calls attach N role analysis tasks simultaneously
@@ -305,7 +305,7 @@ Synthesis: .workflow/active/WFS-{topic}/.brainstorming/synthesis-specification.m
    - No user intervention required between phases
    - TodoWrite dynamically reflects current execution state
 
-**Lifecycle Summary**: Initial pending tasks → Phase 1 dispatched (artifacts tasks ATTACHED) → Artifacts sub-tasks executed → Phase 1 completed (tasks COLLAPSED) → Phase 2 dispatched (N role tasks ATTACHED in parallel) → Role analyses executed concurrently → Phase 2 completed (tasks COLLAPSED) → Phase 3 dispatched (synthesis tasks ATTACHED) → Synthesis sub-tasks executed → Phase 3 completed (tasks COLLAPSED) → Workflow complete.
+**Lifecycle Summary**: Initial pending tasks → Phase 1 executed (artifacts tasks ATTACHED) → Artifacts sub-tasks executed → Phase 1 completed (tasks COLLAPSED) → Phase 2 executed (N role tasks ATTACHED in parallel) → Role analyses executed concurrently → Phase 2 completed (tasks COLLAPSED) → Phase 3 executed (synthesis tasks ATTACHED) → Synthesis sub-tasks executed → Phase 3 completed (tasks COLLAPSED) → Workflow complete.
 
 ### Brainstorming Workflow Specific Features
 
@@ -424,6 +424,17 @@ CONTEXT_VARS:
 - **Agent execution failure**: Agent-specific retry with minimal dependencies
 - **Template loading issues**: Agent handles graceful degradation
 - **Synthesis conflicts**: Synthesis highlights disagreements without resolution
+- **Context overflow protection**: See below for automatic context management
+
+## Context Overflow Protection
+
+**Per-role limits**: See `conceptual-planning-agent.md` (< 3000 words main, < 2000 words sub-docs, max 5 sub-docs)
+
+**Synthesis protection**: If total analysis > 100KB, synthesis reads only `analysis.md` files (not sub-documents)
+
+**Recovery**: Check logs → reduce scope (--count 2) → use --summary-only → manual synthesis
+
+**Prevention**: Start with --count 3, use structured topic format, review output sizes before synthesis
 
 ## Reference Information
 

.claude/commands/workflow/clean.md

@@ -132,7 +132,7 @@ Scan and analyze workflow session directories:
 
 **Staleness criteria**:
 - Active sessions: No modification >7 days + no related git commits
-- Archives: >30 days old + no feature references in project.json
+- Archives: >30 days old + no feature references in project-tech.json
 - Lite-plan: >7 days old + plan.json not executed
 - Debug: >3 days old + issue not in recent commits
 
@@ -443,8 +443,8 @@ if (selectedCategories.includes('Sessions')) {
   }
 }
 
-// Update project.json if features referenced deleted sessions
-const projectPath = '.workflow/project.json'
+// Update project-tech.json if features referenced deleted sessions
+const projectPath = '.workflow/project-tech.json'
 if (fileExists(projectPath)) {
   const project = JSON.parse(Read(projectPath))
   const deletedPaths = new Set(results.deleted)

.claude/commands/workflow/debug-with-file.md

@@ -0,0 +1,666 @@
+---
+name: debug-with-file
+description: Interactive hypothesis-driven debugging with documented exploration, understanding evolution, and Gemini-assisted correction
+argument-hint: "\"bug description or error message\""
+allowed-tools: TodoWrite(*), Task(*), AskUserQuestion(*), Read(*), Grep(*), Glob(*), Bash(*), Edit(*), Write(*)
+---
+
+# Workflow Debug-With-File Command (/workflow:debug-with-file)
+
+## Overview
+
+Enhanced evidence-based debugging with **documented exploration process**. Records understanding evolution, consolidates insights, and uses Gemini to correct misunderstandings.
+
+**Core workflow**: Explore → Document → Log → Analyze → Correct Understanding → Fix → Verify
+
+**Key enhancements over /workflow:debug**:
+- **understanding.md**: Timeline of exploration and learning
+- **Gemini-assisted correction**: Validates and corrects hypotheses
+- **Consolidation**: Simplifies proven-wrong understanding to avoid clutter
+- **Learning retention**: Preserves what was learned, even from failed attempts
+
+## Usage
+
+```bash
+/workflow:debug-with-file <BUG_DESCRIPTION>
+
+# Arguments
+<bug-description>          Bug description, error message, or stack trace (required)
+```
+
+## Execution Process
+
+```
+Session Detection:
+   ├─ Check if debug session exists for this bug
+   ├─ EXISTS + understanding.md exists → Continue mode
+   └─ NOT_FOUND → Explore mode
+
+Explore Mode:
+   ├─ Locate error source in codebase
+   ├─ Document initial understanding in understanding.md
+   ├─ Generate testable hypotheses with Gemini validation
+   ├─ Add NDJSON logging instrumentation
+   └─ Output: Hypothesis list + await user reproduction
+
+Analyze Mode:
+   ├─ Parse debug.log, validate each hypothesis
+   ├─ Use Gemini to analyze evidence and correct understanding
+   ├─ Update understanding.md with:
+   │   ├─ New evidence
+   │   ├─ Corrected misunderstandings (strikethrough + correction)
+   │   └─ Consolidated current understanding
+   └─ Decision:
+       ├─ Confirmed → Fix root cause
+       ├─ Inconclusive → Add more logging, iterate
+       └─ All rejected → Gemini-assisted new hypotheses
+
+Fix & Cleanup:
+   ├─ Apply fix based on confirmed hypothesis
+   ├─ User verifies
+   ├─ Document final understanding + lessons learned
+   ├─ Remove debug instrumentation
+   └─ If not fixed → Return to Analyze mode
+```
+
+## Implementation
+
+### Session Setup & Mode Detection
+
+```javascript
+const getUtc8ISOString = () => new Date(Date.now() + 8 * 60 * 60 * 1000).toISOString()
+
+const bugSlug = bug_description.toLowerCase().replace(/[^a-z0-9]+/g, '-').substring(0, 30)
+const dateStr = getUtc8ISOString().substring(0, 10)
+
+const sessionId = `DBG-${bugSlug}-${dateStr}`
+const sessionFolder = `.workflow/.debug/${sessionId}`
+const debugLogPath = `${sessionFolder}/debug.log`
+const understandingPath = `${sessionFolder}/understanding.md`
+const hypothesesPath = `${sessionFolder}/hypotheses.json`
+
+// Auto-detect mode
+const sessionExists = fs.existsSync(sessionFolder)
+const hasUnderstanding = sessionExists && fs.existsSync(understandingPath)
+const logHasContent = sessionExists && fs.existsSync(debugLogPath) && fs.statSync(debugLogPath).size > 0
+
+const mode = logHasContent ? 'analyze' : (hasUnderstanding ? 'continue' : 'explore')
+
+if (!sessionExists) {
+  bash(`mkdir -p ${sessionFolder}`)
+}
+```
+
+---
+
+### Explore Mode
+
+**Step 1.1: Locate Error Source**
+
+```javascript
+// Extract keywords from bug description
+const keywords = extractErrorKeywords(bug_description)
+
+// Search codebase for error locations
+const searchResults = []
+for (const keyword of keywords) {
+  const results = Grep({ pattern: keyword, path: ".", output_mode: "content", "-C": 3 })
+  searchResults.push({ keyword, results })
+}
+
+// Identify affected files and functions
+const affectedLocations = analyzeSearchResults(searchResults)
+```
+
+**Step 1.2: Document Initial Understanding**
+
+Create `understanding.md` with exploration timeline:
+
+```markdown
+# Understanding Document
+
+**Session ID**: ${sessionId}
+**Bug Description**: ${bug_description}
+**Started**: ${getUtc8ISOString()}
+
+---
+
+## Exploration Timeline
+
+### Iteration 1 - Initial Exploration (${timestamp})
+
+#### Current Understanding
+
+Based on bug description and initial code search:
+
+- Error pattern: ${errorPattern}
+- Affected areas: ${affectedLocations.map(l => l.file).join(', ')}
+- Initial hypothesis: ${initialThoughts}
+
+#### Evidence from Code Search
+
+${searchResults.map(r => `
+**Keyword: "${r.keyword}"**
+- Found in: ${r.results.files.join(', ')}
+- Key findings: ${r.insights}
+`).join('\n')}
+
+#### Next Steps
+
+- Generate testable hypotheses
+- Add instrumentation
+- Await reproduction
+
+---
+
+## Current Consolidated Understanding
+
+${initialConsolidatedUnderstanding}
+```
+
+**Step 1.3: Gemini-Assisted Hypothesis Generation**
+
+```bash
+ccw cli -p "
+PURPOSE: Generate debugging hypotheses for: ${bug_description}
+Success criteria: Testable hypotheses with clear evidence criteria
+
+TASK:
+• Analyze error pattern and code search results
+• Identify 3-5 most likely root causes
+• For each hypothesis, specify:
+  - What might be wrong
+  - What evidence would confirm/reject it
+  - Where to add instrumentation
+• Rank by likelihood
+
+MODE: analysis
+
+CONTEXT: @${sessionFolder}/understanding.md | Search results in understanding.md
+
+EXPECTED:
+- Structured hypothesis list (JSON format)
+- Each hypothesis with: id, description, testable_condition, logging_point, evidence_criteria
+- Likelihood ranking (1=most likely)
+
+CONSTRAINTS: Focus on testable conditions
+" --tool gemini --mode analysis --rule analysis-diagnose-bug-root-cause
+```
+
+Save Gemini output to `hypotheses.json`:
+
+```json
+{
+  "iteration": 1,
+  "timestamp": "2025-01-21T10:00:00+08:00",
+  "hypotheses": [
+    {
+      "id": "H1",
+      "description": "Data structure mismatch - expected key not present",
+      "testable_condition": "Check if target key exists in dict",
+      "logging_point": "file.py:func:42",
+      "evidence_criteria": {
+        "confirm": "data shows missing key",
+        "reject": "key exists with valid value"
+      },
+      "likelihood": 1,
+      "status": "pending"
+    }
+  ],
+  "gemini_insights": "...",
+  "corrected_assumptions": []
+}
+```
+
+**Step 1.4: Add NDJSON Instrumentation**
+
+For each hypothesis, add logging (same as original debug command).
+
+**Step 1.5: Update understanding.md**
+
+Append hypothesis section:
+
+```markdown
+#### Hypotheses Generated (Gemini-Assisted)
+
+${hypotheses.map(h => `
+**${h.id}** (Likelihood: ${h.likelihood}): ${h.description}
+- Logging at: ${h.logging_point}
+- Testing: ${h.testable_condition}
+- Evidence to confirm: ${h.evidence_criteria.confirm}
+- Evidence to reject: ${h.evidence_criteria.reject}
+`).join('\n')}
+
+**Gemini Insights**: ${geminiInsights}
+```
+
+---
+
+### Analyze Mode
+
+**Step 2.1: Parse Debug Log**
+
+```javascript
+// Parse NDJSON log
+const entries = Read(debugLogPath).split('\n')
+  .filter(l => l.trim())
+  .map(l => JSON.parse(l))
+
+// Group by hypothesis
+const byHypothesis = groupBy(entries, 'hid')
+```
+
+**Step 2.2: Gemini-Assisted Evidence Analysis**
+
+```bash
+ccw cli -p "
+PURPOSE: Analyze debug log evidence to validate/correct hypotheses for: ${bug_description}
+Success criteria: Clear verdict per hypothesis + corrected understanding
+
+TASK:
+• Parse log entries by hypothesis
+• Evaluate evidence against expected criteria
+• Determine verdict: confirmed | rejected | inconclusive
+• Identify incorrect assumptions from previous understanding
+• Suggest corrections to understanding
+
+MODE: analysis
+
+CONTEXT:
+@${debugLogPath}
+@${understandingPath}
+@${hypothesesPath}
+
+EXPECTED:
+- Per-hypothesis verdict with reasoning
+- Evidence summary
+- List of incorrect assumptions with corrections
+- Updated consolidated understanding
+- Root cause if confirmed, or next investigation steps
+
+CONSTRAINTS: Evidence-based reasoning only, no speculation
+" --tool gemini --mode analysis --rule analysis-diagnose-bug-root-cause
+```
+
+**Step 2.3: Update Understanding with Corrections**
+
+Append new iteration to `understanding.md`:
+
+```markdown
+### Iteration ${n} - Evidence Analysis (${timestamp})
+
+#### Log Analysis Results
+
+${results.map(r => `
+**${r.id}**: ${r.verdict.toUpperCase()}
+- Evidence: ${JSON.stringify(r.evidence)}
+- Reasoning: ${r.reason}
+`).join('\n')}
+
+#### Corrected Understanding
+
+Previous misunderstandings identified and corrected:
+
+${corrections.map(c => `
+- ~~${c.wrong}~~ → ${c.corrected}
+  - Why wrong: ${c.reason}
+  - Evidence: ${c.evidence}
+`).join('\n')}
+
+#### New Insights
+
+${newInsights.join('\n- ')}
+
+#### Gemini Analysis
+
+${geminiAnalysis}
+
+${confirmedHypothesis ? `
+#### Root Cause Identified
+
+**${confirmedHypothesis.id}**: ${confirmedHypothesis.description}
+
+Evidence supporting this conclusion:
+${confirmedHypothesis.supportingEvidence}
+` : `
+#### Next Steps
+
+${nextSteps}
+`}
+
+---
+
+## Current Consolidated Understanding (Updated)
+
+${consolidatedUnderstanding}
+```
+
+**Step 2.4: Consolidate Understanding**
+
+At the bottom of `understanding.md`, update the consolidated section:
+
+- Remove or simplify proven-wrong assumptions
+- Keep them in strikethrough for reference
+- Focus on current valid understanding
+- Avoid repeating details from timeline
+
+```markdown
+## Current Consolidated Understanding
+
+### What We Know
+
+- ${validUnderstanding1}
+- ${validUnderstanding2}
+
+### What Was Disproven
+
+- ~~Initial assumption: ${wrongAssumption}~~ (Evidence: ${disproofEvidence})
+
+### Current Investigation Focus
+
+${currentFocus}
+
+### Remaining Questions
+
+- ${openQuestion1}
+- ${openQuestion2}
+```
+
+**Step 2.5: Update hypotheses.json**
+
+```json
+{
+  "iteration": 2,
+  "timestamp": "2025-01-21T10:15:00+08:00",
+  "hypotheses": [
+    {
+      "id": "H1",
+      "status": "rejected",
+      "verdict_reason": "Evidence shows key exists with valid value",
+      "evidence": {...}
+    },
+    {
+      "id": "H2",
+      "status": "confirmed",
+      "verdict_reason": "Log data confirms timing issue",
+      "evidence": {...}
+    }
+  ],
+  "gemini_corrections": [
+    {
+      "wrong_assumption": "...",
+      "corrected_to": "...",
+      "reason": "..."
+    }
+  ]
+}
+```
+
+---
+
+### Fix & Verification
+
+**Step 3.1: Apply Fix**
+
+(Same as original debug command)
+
+**Step 3.2: Document Resolution**
+
+Append to `understanding.md`:
+
+```markdown
+### Iteration ${n} - Resolution (${timestamp})
+
+#### Fix Applied
+
+- Modified files: ${modifiedFiles.join(', ')}
+- Fix description: ${fixDescription}
+- Root cause addressed: ${rootCause}
+
+#### Verification Results
+
+${verificationResults}
+
+#### Lessons Learned
+
+What we learned from this debugging session:
+
+1. ${lesson1}
+2. ${lesson2}
+3. ${lesson3}
+
+#### Key Insights for Future
+
+- ${insight1}
+- ${insight2}
+```
+
+**Step 3.3: Cleanup**
+
+Remove debug instrumentation (same as original command).
+
+---
+
+## Session Folder Structure
+
+```
+.workflow/.debug/DBG-{slug}-{date}/
+├── debug.log           # NDJSON log (execution evidence)
+├── understanding.md    # NEW: Exploration timeline + consolidated understanding
+├── hypotheses.json     # NEW: Hypothesis history with verdicts
+└── resolution.md       # Optional: Final summary
+```
+
+## 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 (Gemini-Assisted)
+...
+
+### Iteration 2 - Evidence Analysis (2025-01-21 10:15)
+
+#### Log Analysis Results
+...
+
+#### Corrected Understanding
+- ~~[wrong]~~ → [corrected]
+
+#### Gemini Analysis
+...
+
+---
+
+## Current Consolidated Understanding
+
+### What We Know
+- [valid understanding points]
+
+### What Was Disproven
+- ~~[disproven assumptions]~~
+
+### Current Investigation Focus
+[current focus]
+
+### Remaining Questions
+- [open questions]
+```
+
+## Iteration Flow
+
+```
+First Call (/workflow:debug-with-file "error"):
+   ├─ No session exists → Explore mode
+   ├─ Extract error keywords, search codebase
+   ├─ Document initial understanding in understanding.md
+   ├─ Use Gemini to generate hypotheses
+   ├─ Add logging instrumentation
+   └─ Await user reproduction
+
+After Reproduction (/workflow:debug-with-file "error"):
+   ├─ Session exists + debug.log has content → Analyze mode
+   ├─ Parse log, use Gemini to evaluate hypotheses
+   ├─ Update understanding.md with:
+   │   ├─ Evidence analysis results
+   │   ├─ Corrected misunderstandings (strikethrough)
+   │   ├─ New insights
+   │   └─ Updated consolidated understanding
+   ├─ Update hypotheses.json with verdicts
+   └─ Decision:
+       ├─ Confirmed → Fix → Document resolution
+       ├─ Inconclusive → Add logging, document next steps
+       └─ All rejected → Gemini-assisted new hypotheses
+
+Output:
+   ├─ .workflow/.debug/DBG-{slug}-{date}/debug.log
+   ├─ .workflow/.debug/DBG-{slug}-{date}/understanding.md (evolving document)
+   └─ .workflow/.debug/DBG-{slug}-{date}/hypotheses.json (history)
+```
+
+## Gemini Integration Points
+
+### 1. Hypothesis Generation (Explore Mode)
+
+**Purpose**: Generate evidence-based, testable hypotheses
+
+**Prompt Pattern**:
+```
+PURPOSE: Generate debugging hypotheses + evidence criteria
+TASK: Analyze error + code → testable hypotheses with clear pass/fail criteria
+CONTEXT: @understanding.md (search results)
+EXPECTED: JSON with hypotheses, likelihood ranking, evidence criteria
+```
+
+### 2. Evidence Analysis (Analyze Mode)
+
+**Purpose**: Validate hypotheses and correct misunderstandings
+
+**Prompt Pattern**:
+```
+PURPOSE: Analyze debug log evidence + correct understanding
+TASK: Evaluate each hypothesis → identify wrong assumptions → suggest corrections
+CONTEXT: @debug.log @understanding.md @hypotheses.json
+EXPECTED: Verdicts + corrections + updated consolidated understanding
+```
+
+### 3. New Hypothesis Generation (After All Rejected)
+
+**Purpose**: Generate new hypotheses based on what was disproven
+
+**Prompt Pattern**:
+```
+PURPOSE: Generate new hypotheses given disproven assumptions
+TASK: Review rejected hypotheses → identify knowledge gaps → new investigation angles
+CONTEXT: @understanding.md (with disproven section) @hypotheses.json
+EXPECTED: New hypotheses avoiding previously rejected paths
+```
+
+## Error Correction Mechanism
+
+### Correction Format in understanding.md
+
+```markdown
+#### Corrected Understanding
+
+- ~~Assumed dict key "config" was missing~~ → Key exists, but value is None
+  - Why wrong: Only checked existence, not value validity
+  - Evidence: H1 log shows {"config": null, "exists": true}
+
+- ~~Thought error occurred in initialization~~ → Error happens during runtime update
+  - Why wrong: Stack trace misread as init code
+  - Evidence: H2 timestamp shows 30s after startup
+```
+
+### Consolidation Rules
+
+When updating "Current Consolidated Understanding":
+
+1. **Simplify disproven items**: Move to "What Was Disproven" with single-line summary
+2. **Keep valid insights**: Promote confirmed findings to "What We Know"
+3. **Avoid duplication**: Don't repeat timeline details in consolidated section
+4. **Focus on current state**: What do we know NOW, not the journey
+5. **Preserve key corrections**: Keep important wrong→right transformations for learning
+
+**Bad (cluttered)**:
+```markdown
+## Current Consolidated Understanding
+
+In iteration 1 we thought X, but in iteration 2 we found Y, then in iteration 3...
+Also we checked A and found B, and then we checked C...
+```
+
+**Good (consolidated)**:
+```markdown
+## Current Consolidated Understanding
+
+### What We Know
+- Error occurs during runtime update, not initialization
+- Config value is None (not missing key)
+
+### What Was Disproven
+- ~~Initialization error~~ (Timing evidence)
+- ~~Missing key hypothesis~~ (Key exists)
+
+### Current Investigation Focus
+Why is config value None during update?
+```
+
+## Post-Completion Expansion
+
+完成后询问用户是否扩展为issue(test/enhance/refactor/doc)，选中项调用 `/issue:new "{summary} - {dimension}"`
+
+---
+
+## Error Handling
+
+| Situation | Action |
+|-----------|--------|
+| Empty debug.log | Verify reproduction triggered the code path |
+| All hypotheses rejected | Use Gemini to generate new hypotheses based on disproven assumptions |
+| Fix doesn't work | Document failed fix attempt, iterate with refined understanding |
+| >5 iterations | Review consolidated understanding, escalate to `/workflow:lite-fix` with full context |
+| Gemini unavailable | Fallback to manual hypothesis generation, document without Gemini insights |
+| Understanding too long | Consolidate aggressively, archive old iterations to separate file |
+
+## Comparison with /workflow:debug
+
+| Feature | /workflow:debug | /workflow:debug-with-file |
+|---------|-----------------|---------------------------|
+| NDJSON logging | ✅ | ✅ |
+| Hypothesis generation | Manual | Gemini-assisted |
+| Exploration documentation | ❌ | ✅ understanding.md |
+| Understanding evolution | ❌ | ✅ Timeline + corrections |
+| Error correction | ❌ | ✅ Strikethrough + reasoning |
+| Consolidated learning | ❌ | ✅ Current understanding section |
+| Hypothesis history | ❌ | ✅ hypotheses.json |
+| Gemini validation | ❌ | ✅ At key decision points |
+
+## Usage Recommendations
+
+Use `/workflow:debug-with-file` when:
+- Complex bugs requiring multiple investigation rounds
+- Learning from debugging process is valuable
+- Team needs to understand debugging rationale
+- Bug might recur, documentation helps prevention
+
+Use `/workflow:debug` when:
+- Simple, quick bugs
+- One-off issues
+- Documentation overhead not needed

.claude/commands/workflow/debug.md

@@ -311,6 +311,12 @@ Output:
    └─ .workflow/.debug/DBG-{slug}-{date}/debug.log
 ```
 
+## Post-Completion Expansion
+
+完成后询问用户是否扩展为issue(test/enhance/refactor/doc)，选中项调用 `/issue:new "{summary} - {dimension}"`
+
+---
+
 ## Error Handling
 
 | Situation | Action |

.claude/commands/workflow/execute.md

@@ -23,7 +23,7 @@ Orchestrates autonomous workflow execution through systematic task discovery, ag
 ## Core Rules
 **Complete entire workflow autonomously without user interruption, using TodoWrite for comprehensive progress tracking.**
 **Execute all discovered pending tasks until workflow completion or blocking dependency.**
-**Auto-complete session when all tasks finished: Call `/workflow:session:complete` upon workflow completion.**
+**User-choice completion: When all tasks finished, ask user to choose review or complete.**
 **ONE AGENT = ONE TASK JSON: Each agent instance executes exactly one task JSON file - never batch multiple tasks into single agent execution.**
 
 ## Core Responsibilities
@@ -33,7 +33,7 @@ Orchestrates autonomous workflow execution through systematic task discovery, ag
 - **Agent Orchestration**: Coordinate specialized agents with complete context
 - **Status Synchronization**: Update task JSON files and workflow state
 - **Autonomous Completion**: Continue execution until all tasks complete or reach blocking state
-- **Session Auto-Complete**: Call `/workflow:session:complete` when all workflow tasks finished
+- **Session User-Choice Completion**: Ask user to choose review or complete when all tasks finished
 
 ## Execution Philosophy
 - **Progress tracking**: Continuous TodoWrite updates throughout entire workflow execution
@@ -76,7 +76,9 @@ Phase 4: Execution Strategy & Task Execution
 Phase 5: Completion
    ├─ Update task statuses in JSON files
    ├─ Generate summaries
-   └─ Auto-call /workflow:session:complete
+   └─ AskUserQuestion: Choose next step
+      ├─ "Enter Review" → /workflow:review
+      └─ "Complete Session" → /workflow:session:complete
 
 Resume Mode (--resume-session):
    ├─ Skip Phase 1 & Phase 2
@@ -117,14 +119,7 @@ Auto-select and continue to Phase 2.
 
 List sessions with metadata and prompt user selection:
 ```bash
-bash(for dir in .workflow/active/WFS-*/; do
-  session=$(basename "$dir")
-  project=$(jq -r '.project // "Unknown"' "$dir/workflow-session.json" 2>/dev/null)
-  total=$(grep -c "^- \[" "$dir/TODO_LIST.md" 2>/dev/null || echo "0")
-  completed=$(grep -c "^- \[x\]" "$dir/TODO_LIST.md" 2>/dev/null || echo "0")
-  [ "$total" -gt 0 ] && progress=$((completed * 100 / total)) || progress=0
-  echo "${session} | ${project} | ${completed}/${total} tasks (${progress}%)"
-done)
+bash(for dir in .workflow/active/WFS-*/; do [ -d "$dir" ] || continue; session=$(basename "$dir"); project=$(jq -r '.project // "Unknown"' "${dir}workflow-session.json" 2>/dev/null || echo "Unknown"); total=$(grep -c '^\- \[' "${dir}TODO_LIST.md" 2>/dev/null || echo 0); completed=$(grep -c '^\- \[x\]' "${dir}TODO_LIST.md" 2>/dev/null || echo 0); if [ "$total" -gt 0 ]; then progress=$((completed * 100 / total)); else progress=0; fi; echo "$session | $project | $completed/$total tasks ($progress%)"; done)
 ```
 
 Use AskUserQuestion to present formatted options (max 4 options shown):
@@ -254,7 +249,35 @@ while (TODO_LIST.md has pending tasks) {
 3. **Update TodoWrite**: Mark current task complete, advance to next
 4. **Synchronize State**: Update session state and workflow status
 5. **Check Workflow Complete**: Verify all tasks are completed
-6. **Auto-Complete Session**: Call `/workflow:session:complete` when all tasks finished
+6. **User Choice**: When all tasks finished, ask user to choose next step:
+
+```javascript
+AskUserQuestion({
+  questions: [{
+    question: "All tasks completed. What would you like to do next?",
+    header: "Next Step",
+    multiSelect: false,
+    options: [
+      {
+        label: "Enter Review",
+        description: "Run specialized review (security/architecture/quality/action-items)"
+      },
+      {
+        label: "Complete Session",
+        description: "Archive session and update manifest"
+      }
+    ]
+  }]
+})
+```
+
+**Based on user selection**:
+- **"Enter Review"**: Execute `/workflow:review`
+- **"Complete Session"**: Execute `/workflow:session:complete`
+
+### Post-Completion Expansion
+
+完成后询问用户是否扩展为issue(test/enhance/refactor/doc)，选中项调用 `/issue:new "{summary} - {dimension}"`
 
 ## Execution Strategy (IMPL_PLAN-Driven)
 
@@ -330,7 +353,7 @@ blocked → skip until dependencies clear
 - **Continuous Tracking**: Maintain TodoWrite throughout entire workflow execution until completion
 
 **Rule 4: Workflow Completion Check**
-- When all tasks marked `completed`, auto-call `/workflow:session:complete`
+- When all tasks marked `completed`, prompt user to choose review or complete session
 
 ### TodoWrite Tool Usage
 
@@ -388,39 +411,40 @@ TodoWrite({
 **Note**: Orchestrator does NOT execute flow control steps - Agent interprets and executes them autonomously.
 
 ### Agent Prompt Template
-**Dynamic Generation**: Before agent invocation, read task JSON and extract key requirements.
+**Path-Based Invocation**: Pass paths and trigger markers, let agent parse task JSON autonomously.
 
 ```bash
 Task(subagent_type="{meta.agent}",
      run_in_background=false,
-     prompt="Execute task: {task.title}
+     prompt="Implement task {task.id}: {task.title}
 
-     {[FLOW_CONTROL]}
+     [FLOW_CONTROL]
 
-     **Task Objectives** (from task JSON):
-     {task.context.objective}
-
-     **Expected Deliverables** (from task JSON):
-     {task.context.deliverables}
-
-     **Quality Standards** (from task JSON):
-     {task.context.acceptance_criteria}
-
-     **MANDATORY FIRST STEPS**:
-     1. Read complete task JSON: {session.task_json_path}
-     2. Load context package: {session.context_package_path}
-
-
-     **Session Paths**:
-     - Workflow Dir: {session.workflow_dir}
-     - TODO List: {session.todo_list_path}
-     - Summaries Dir: {session.summaries_dir}
+     **Input**:
+     - Task JSON: {session.task_json_path}
      - Context Package: {session.context_package_path}
 
-     **Success Criteria**: Complete all objectives, meet all quality standards, deliver all outputs as specified above.",
-     description="Executing: {task.title}")
+     **Output Location**:
+     - Workflow: {session.workflow_dir}
+     - TODO List: {session.todo_list_path}
+     - Summaries: {session.summaries_dir}
+
+     **Execution**: Read task JSON → Parse flow_control → Execute implementation_approach → Update TODO_LIST.md → Generate summary",
+     description="Implement: {task.id}")
 ```
 
+**Key Markers**:
+- `Implement` keyword: Triggers tech stack detection and guidelines loading
+- `[FLOW_CONTROL]`: Triggers flow_control.pre_analysis execution
+
+**Why Path-Based**: Agent (code-developer.md) autonomously:
+- Reads and parses task JSON (requirements, acceptance, flow_control)
+- Loads tech stack guidelines based on detected language
+- Executes pre_analysis steps and implementation_approach
+- Generates structured summary with integration points
+
+Embedding task content in prompt creates duplication and conflicts with agent's parsing logic.
+
 ### Agent Assignment Rules
 ```
 meta.agent specified → Use specified agent

.claude/commands/workflow/init.md

@@ -108,11 +108,24 @@ Analyze project for workflow initialization and generate .workflow/project-tech.
 2. Execute: ccw tool exec get_modules_by_depth '{}' (get project structure)
 
 ## Task
-Generate complete project-tech.json with:
-- project_metadata: {name: ${projectName}, root_path: ${projectRoot}, initialized_at, updated_at}
-- technology_analysis: {description, languages, frameworks, build_tools, test_frameworks, architecture, key_components, dependencies}
-- development_status: ${regenerate ? 'preserve from backup' : '{completed_features: [], development_index: {feature: [], enhancement: [], bugfix: [], refactor: [], docs: []}, statistics: {total_features: 0, total_sessions: 0, last_updated}}'}
-- _metadata: {initialized_by: "cli-explore-agent", analysis_timestamp, analysis_mode}
+Generate complete project-tech.json following the schema structure:
+- project_name: "${projectName}"
+- initialized_at: ISO 8601 timestamp
+- overview: {
+    description: "Brief project description",
+    technology_stack: {
+      languages: [{name, file_count, primary}],
+      frameworks: ["string"],
+      build_tools: ["string"],
+      test_frameworks: ["string"]
+    },
+    architecture: {style, layers: [], patterns: []},
+    key_components: [{name, path, description, importance}]
+  }
+- features: []
+- development_index: ${regenerate ? 'preserve from backup' : '{feature: [], enhancement: [], bugfix: [], refactor: [], docs: []}'}
+- statistics: ${regenerate ? 'preserve from backup' : '{total_features: 0, total_sessions: 0, last_updated: ISO timestamp}'}
+- _metadata: {initialized_by: "cli-explore-agent", analysis_timestamp: ISO timestamp, analysis_mode: "deep-scan"}
 
 ## Analysis Requirements
 
@@ -132,7 +145,7 @@ Generate complete project-tech.json with:
 1. Structural scan: get_modules_by_depth.sh, find, wc -l
 2. Semantic analysis: Gemini for patterns/architecture
 3. Synthesis: Merge findings
-4. ${regenerate ? 'Merge with preserved development_status from .workflow/project-tech.json.backup' : ''}
+4. ${regenerate ? 'Merge with preserved development_index and statistics from .workflow/project-tech.json.backup' : ''}
 5. Write JSON: Write('.workflow/project-tech.json', jsonContent)
 6. Report: Return brief completion summary
 
@@ -181,16 +194,16 @@ console.log(`
 ✓ Project initialized successfully
 
 ## Project Overview
-Name: ${projectTech.project_metadata.name}
-Description: ${projectTech.technology_analysis.description}
+Name: ${projectTech.project_name}
+Description: ${projectTech.overview.description}
 
 ### Technology Stack
-Languages: ${projectTech.technology_analysis.languages.map(l => l.name).join(', ')}
-Frameworks: ${projectTech.technology_analysis.frameworks.join(', ')}
+Languages: ${projectTech.overview.technology_stack.languages.map(l => l.name).join(', ')}
+Frameworks: ${projectTech.overview.technology_stack.frameworks.join(', ')}
 
 ### Architecture
-Style: ${projectTech.technology_analysis.architecture.style}
-Components: ${projectTech.technology_analysis.key_components.length} core modules
+Style: ${projectTech.overview.architecture.style}
+Components: ${projectTech.overview.key_components.length} core modules
 
 ---
 Files created:

.claude/commands/workflow/lite-execute.md

@@ -81,6 +81,7 @@ AskUserQuestion({
       options: [
         { label: "Skip", description: "No review" },
         { label: "Gemini Review", description: "Gemini CLI tool" },
+        { label: "Codex Review", description: "Git-aware review (prompt OR --uncommitted)" },
         { label: "Agent Review", description: "Current agent review" }
       ]
     }
@@ -171,10 +172,23 @@ Output:
 **Operations**:
 - Initialize result tracking for multi-execution scenarios
 - Set up `previousExecutionResults` array for context continuity
+- **In-Memory Mode**: Echo execution strategy from lite-plan for transparency
 
 ```javascript
 // Initialize result tracking
 previousExecutionResults = []
+
+// In-Memory Mode: Echo execution strategy (transparency before execution)
+if (executionContext) {
+  console.log(`
+📋 Execution Strategy (from lite-plan):
+   Method: ${executionContext.executionMethod}
+   Review: ${executionContext.codeReviewTool}
+   Tasks: ${executionContext.planObject.tasks.length}
+   Complexity: ${executionContext.planObject.complexity}
+${executionContext.executorAssignments ? `   Assignments: ${JSON.stringify(executionContext.executorAssignments)}` : ''}
+  `)
+}
 ```
 
 ### Step 2: Task Grouping & Batch Creation
@@ -307,6 +321,85 @@ for (const call of sequential) {
 }
 ```
 
+### Unified Task Prompt Builder
+
+**Task Formatting Principle**: Each task is a self-contained checklist. The executor only needs to know what THIS task requires. Same template for Agent and CLI.
+
+```javascript
+function buildExecutionPrompt(batch) {
+  // Task template (6 parts: Modification Points → Why → How → Reference → Risks → Done)
+  const formatTask = (t) => `
+## ${t.title}
+
+**Scope**: \`${t.scope}\`  |  **Action**: ${t.action}
+
+### Modification Points
+${t.modification_points.map(p => `- **${p.file}** → \`${p.target}\`: ${p.change}`).join('\n')}
+
+${t.rationale ? `
+### Why this approach (Medium/High)
+${t.rationale.chosen_approach}
+${t.rationale.decision_factors?.length > 0 ? `\nKey factors: ${t.rationale.decision_factors.join(', ')}` : ''}
+${t.rationale.tradeoffs ? `\nTradeoffs: ${t.rationale.tradeoffs}` : ''}
+` : ''}
+
+### How to do it
+${t.description}
+
+${t.implementation.map(step => `- ${step}`).join('\n')}
+
+${t.code_skeleton ? `
+### Code skeleton (High)
+${t.code_skeleton.interfaces?.length > 0 ? `**Interfaces**: ${t.code_skeleton.interfaces.map(i => `\`${i.name}\` - ${i.purpose}`).join(', ')}` : ''}
+${t.code_skeleton.key_functions?.length > 0 ? `\n**Functions**: ${t.code_skeleton.key_functions.map(f => `\`${f.signature}\` - ${f.purpose}`).join(', ')}` : ''}
+${t.code_skeleton.classes?.length > 0 ? `\n**Classes**: ${t.code_skeleton.classes.map(c => `\`${c.name}\` - ${c.purpose}`).join(', ')}` : ''}
+` : ''}
+
+### Reference
+- Pattern: ${t.reference?.pattern || 'N/A'}
+- Files: ${t.reference?.files?.join(', ') || 'N/A'}
+${t.reference?.examples ? `- Notes: ${t.reference.examples}` : ''}
+
+${t.risks?.length > 0 ? `
+### Risk mitigations (High)
+${t.risks.map(r => `- ${r.description} → **${r.mitigation}**`).join('\n')}
+` : ''}
+
+### Done when
+${t.acceptance.map(c => `- [ ] ${c}`).join('\n')}
+${t.verification?.success_metrics?.length > 0 ? `\n**Success metrics**: ${t.verification.success_metrics.join(', ')}` : ''}`
+
+  // Build prompt
+  const sections = []
+
+  if (originalUserInput) sections.push(`## Goal\n${originalUserInput}`)
+
+  sections.push(`## Tasks\n${batch.tasks.map(formatTask).join('\n\n---\n')}`)
+
+  // Context (reference only)
+  const context = []
+  if (previousExecutionResults.length > 0) {
+    context.push(`### Previous Work\n${previousExecutionResults.map(r => `- ${r.tasksSummary}: ${r.status}`).join('\n')}`)
+  }
+  if (clarificationContext) {
+    context.push(`### Clarifications\n${Object.entries(clarificationContext).map(([q, a]) => `- ${q}: ${a}`).join('\n')}`)
+  }
+  if (executionContext?.planObject?.data_flow?.diagram) {
+    context.push(`### Data Flow\n${executionContext.planObject.data_flow.diagram}`)
+  }
+  if (executionContext?.session?.artifacts?.plan) {
+    context.push(`### Artifacts\nPlan: ${executionContext.session.artifacts.plan}`)
+  }
+  // Project guidelines (user-defined constraints from /workflow:session:solidify)
+  context.push(`### Project Guidelines\n@.workflow/project-guidelines.json`)
+  if (context.length > 0) sections.push(`## Context\n${context.join('\n\n')}`)
+
+  sections.push(`Complete each task according to its "Done when" checklist.`)
+
+  return sections.join('\n\n')
+}
+```
+
 **Option A: Agent Execution**
 
 When to use:
@@ -314,113 +407,13 @@ When to use:
 - 或 `executionMethod = "Agent"` (全局 fallback)
 - 或 `executionMethod = "Auto" AND complexity = "Low"` (全局 fallback)
 
-**Task Formatting Principle**: Each task is a self-contained checklist. The agent only needs to know what THIS task requires, not its position or relation to other tasks.
-
-Agent call format:
 ```javascript
-// Format single task as self-contained checklist
-function formatTaskChecklist(task) {
-  return `
-## ${task.title}
-
-**Target**: \`${task.file}\`
-**Action**: ${task.action}
-
-### What to do
-${task.description}
-
-### How to do it
-${task.implementation.map(step => `- ${step}`).join('\n')}
-
-### Reference
-- Pattern: ${task.reference.pattern}
-- Examples: ${task.reference.files.join(', ')}
-- Notes: ${task.reference.examples}
-
-### Done when
-${task.acceptance.map(c => `- [ ] ${c}`).join('\n')}
-`
-}
-
-// For batch execution: aggregate tasks without numbering
-function formatBatchPrompt(batch) {
-  const tasksSection = batch.tasks.map(t => formatTaskChecklist(t)).join('\n---\n')
-
-  return `
-${originalUserInput ? `## Goal\n${originalUserInput}\n` : ''}
-
-## Tasks
-
-${tasksSection}
-
-${batch.context ? `## Context\n${batch.context}` : ''}
-
-Complete each task according to its "Done when" checklist.
-`
-}
-
 Task(
   subagent_type="code-developer",
   run_in_background=false,
   description=batch.taskSummary,
-  prompt=formatBatchPrompt({
-    tasks: batch.tasks,
-    context: buildRelevantContext(batch.tasks)
-  })
+  prompt=buildExecutionPrompt(batch)
 )
-
-// Helper: Build relevant context for batch
-// Context serves as REFERENCE ONLY - helps agent understand existing state
-function buildRelevantContext(tasks) {
-  const sections = []
-
-  // 1. Previous work completion - what's already done (reference for continuity)
-  if (previousExecutionResults.length > 0) {
-    sections.push(`### Previous Work (Reference)
-Use this to understand what's already completed. Avoid duplicating work.
-
-${previousExecutionResults.map(r => `**${r.tasksSummary}**
-- Status: ${r.status}
-- Outputs: ${r.keyOutputs || 'See git diff'}
-${r.notes ? `- Notes: ${r.notes}` : ''}`
-    ).join('\n\n')}`)
-  }
-
-  // 2. Related files - files that may need to be read/referenced
-  const relatedFiles = extractRelatedFiles(tasks)
-  if (relatedFiles.length > 0) {
-    sections.push(`### Related Files (Reference)
-These files may contain patterns, types, or utilities relevant to your tasks:
-
-${relatedFiles.map(f => `- \`${f}\``).join('\n')}`)
-  }
-
-  // 3. Clarifications from user
-  if (clarificationContext) {
-    sections.push(`### User Clarifications
-${Object.entries(clarificationContext).map(([q, a]) => `- **${q}**: ${a}`).join('\n')}`)
-  }
-
-  // 4. Artifact files (for deeper context if needed)
-  if (executionContext?.session?.artifacts?.plan) {
-    sections.push(`### Artifacts
-For detailed planning context, read: ${executionContext.session.artifacts.plan}`)
-  }
-
-  return sections.join('\n\n')
-}
-
-// Extract related files from task references
-function extractRelatedFiles(tasks) {
-  const files = new Set()
-  tasks.forEach(task => {
-    // Add reference example files
-    if (task.reference?.files) {
-      task.reference.files.forEach(f => files.add(f))
-    }
-  })
-  return [...files]
-}
 ```
 
 **Result Collection**: After completion, collect result following `executionResult` structure (see Data Structures section)
@@ -432,92 +425,14 @@ When to use:
 - 或 `executionMethod = "Codex"` (全局 fallback)
 - 或 `executionMethod = "Auto" AND complexity = "Medium/High"` (全局 fallback)
 
-**Task Formatting Principle**: Same as Agent - each task is a self-contained checklist. No task numbering or position awareness.
-
-Command format:
 ```bash
-// Format single task as compact checklist for CLI
-function formatTaskForCLI(task) {
-  return `
-## ${task.title}
-File: ${task.file}
-Action: ${task.action}
-
-What: ${task.description}
-
-How:
-${task.implementation.map(step => `- ${step}`).join('\n')}
-
-Reference: ${task.reference.pattern} (see ${task.reference.files.join(', ')})
-Notes: ${task.reference.examples}
-
-Done when:
-${task.acceptance.map(c => `- [ ] ${c}`).join('\n')}
-`
-}
-
-// Build CLI prompt for batch
-// Context provides REFERENCE information - not requirements to fulfill
-function buildCLIPrompt(batch) {
-  const tasksSection = batch.tasks.map(t => formatTaskForCLI(t)).join('\n---\n')
-
-  let prompt = `${originalUserInput ? `## Goal\n${originalUserInput}\n\n` : ''}`
-  prompt += `## Tasks\n\n${tasksSection}\n`
-
-  // Context section - reference information only
-  const contextSections = []
-
-  // 1. Previous work - what's already completed
-  if (previousExecutionResults.length > 0) {
-    contextSections.push(`### Previous Work (Reference)
-Already completed - avoid duplicating:
-${previousExecutionResults.map(r => `- ${r.tasksSummary}: ${r.status}${r.keyOutputs ? ` (${r.keyOutputs})` : ''}`).join('\n')}`)
-  }
-
-  // 2. Related files from task references
-  const relatedFiles = [...new Set(batch.tasks.flatMap(t => t.reference?.files || []))]
-  if (relatedFiles.length > 0) {
-    contextSections.push(`### Related Files (Reference)
-Patterns and examples to follow:
-${relatedFiles.map(f => `- ${f}`).join('\n')}`)
-  }
-
-  // 3. User clarifications
-  if (clarificationContext) {
-    contextSections.push(`### Clarifications
-${Object.entries(clarificationContext).map(([q, a]) => `- ${q}: ${a}`).join('\n')}`)
-  }
-
-  // 4. Plan artifact for deeper context
-  if (executionContext?.session?.artifacts?.plan) {
-    contextSections.push(`### Artifacts
-Detailed plan: ${executionContext.session.artifacts.plan}`)
-  }
-
-  if (contextSections.length > 0) {
-    prompt += `\n## Context\n${contextSections.join('\n\n')}\n`
-  }
-
-  prompt += `\nComplete each task according to its "Done when" checklist.`
-
-  return prompt
-}
-
-ccw cli -p "${buildCLIPrompt(batch)}" --tool codex --mode write
+ccw cli -p "${buildExecutionPrompt(batch)}" --tool codex --mode write
 ```
 
 **Execution with fixed IDs** (predictable ID pattern):
 ```javascript
-// Launch CLI in foreground (NOT background)
-// Timeout based on complexity: Low=40min, Medium=60min, High=100min
-const timeoutByComplexity = {
-  "Low": 2400000,    // 40 minutes
-  "Medium": 3600000, // 60 minutes
-  "High": 6000000    // 100 minutes
-}
-
+// Launch CLI in background, wait for task hook callback
 // Generate fixed execution ID: ${sessionId}-${groupId}
-// This enables predictable ID lookup without relying on resume context chains
 const sessionId = executionContext?.session?.id || 'standalone'
 const fixedExecutionId = `${sessionId}-${batch.groupId}`  // e.g., "implement-auth-2025-12-13-P1"
 
@@ -526,19 +441,15 @@ const previousCliId = batch.resumeFromCliId || null
 
 // Build command with fixed ID (and optional resume for continuation)
 const cli_command = previousCliId
-  ? `ccw cli -p "${buildCLIPrompt(batch)}" --tool codex --mode write --id ${fixedExecutionId} --resume ${previousCliId}`
-  : `ccw cli -p "${buildCLIPrompt(batch)}" --tool codex --mode write --id ${fixedExecutionId}`
+  ? `ccw cli -p "${buildExecutionPrompt(batch)}" --tool codex --mode write --id ${fixedExecutionId} --resume ${previousCliId}`
+  : `ccw cli -p "${buildExecutionPrompt(batch)}" --tool codex --mode write --id ${fixedExecutionId}`
 
-bash_result = Bash(
+// Execute in background, stop output and wait for task hook callback
+Bash(
   command=cli_command,
-  timeout=timeoutByComplexity[planObject.complexity] || 3600000
+  run_in_background=true
 )
-
-// Execution ID is now predictable: ${fixedExecutionId}
-// Can also extract from output: "ID: implement-auth-2025-12-13-P1"
-const cliExecutionId = fixedExecutionId
-
-// Update TodoWrite when execution completes
+// STOP HERE - CLI executes in background, task hook will notify on completion
 ```
 
 **Resume on Failure** (with fixed ID):
@@ -564,8 +475,8 @@ if (bash_result.status === 'failed' || bash_result.status === 'timeout') {
 When to use: `getTaskExecutor(task) === "gemini"` (分析类任务)
 
 ```bash
-# 使用与 Option B 相同的 formatBatchPrompt，切换 tool 和 mode
-ccw cli -p "${formatBatchPrompt(batch)}" --tool gemini --mode analysis --id ${sessionId}-${batch.groupId}
+# 使用统一的 buildExecutionPrompt，切换 tool 和 mode
+ccw cli -p "${buildExecutionPrompt(batch)}" --tool gemini --mode analysis --id ${sessionId}-${batch.groupId}
 ```
 
 ### Step 4: Progress Tracking
@@ -576,32 +487,41 @@ Progress tracked at batch level (not individual task level). Icons: ⚡ (paralle
 
 **Skip Condition**: Only run if `codeReviewTool ≠ "Skip"`
 
-**Review Focus**: Verify implementation against plan acceptance criteria
-- Read plan.json for task acceptance criteria
+**Review Focus**: Verify implementation against plan acceptance criteria and verification requirements
+- Read plan.json for task acceptance criteria and verification checklist
 - Check each acceptance criterion is fulfilled
+- Verify success metrics from verification field (Medium/High complexity)
+- Run unit/integration tests specified in verification field
 - Validate code quality and identify issues
-- Ensure alignment with planned approach
+- Ensure alignment with planned approach and risk mitigations
 
 **Operations**:
 - Agent Review: Current agent performs direct review
 - Gemini Review: Execute gemini CLI with review prompt
-- Custom tool: Execute specified CLI tool (qwen, codex, etc.)
+- Codex Review: Two options - (A) with prompt for complex reviews, (B) `--uncommitted` flag only for quick reviews
+- Custom tool: Execute specified CLI tool (qwen, etc.)
 
 **Unified Review Template** (All tools use same standard):
 
 **Review Criteria**:
 - **Acceptance Criteria**: Verify each criterion from plan.tasks[].acceptance
+- **Verification Checklist** (Medium/High): Check unit_tests, integration_tests, success_metrics from plan.tasks[].verification
 - **Code Quality**: Analyze quality, identify issues, suggest improvements
-- **Plan Alignment**: Validate implementation matches planned approach
+- **Plan Alignment**: Validate implementation matches planned approach and risk mitigations
 
 **Shared Prompt Template** (used by all CLI tools):
 ```
-PURPOSE: Code review for implemented changes against plan acceptance criteria
-TASK: • Verify plan acceptance criteria fulfillment • Analyze code quality • Identify issues • Suggest improvements • Validate plan adherence
+PURPOSE: Code review for implemented changes against plan acceptance criteria and verification requirements
+TASK: • Verify plan acceptance criteria fulfillment • Check verification requirements (unit tests, success metrics) • Analyze code quality • Identify issues • Suggest improvements • Validate plan adherence and risk mitigations
 MODE: analysis
-CONTEXT: @**/* @{plan.json} [@{exploration.json}] | Memory: Review lite-execute changes against plan requirements
-EXPECTED: Quality assessment with acceptance criteria verification, issue identification, and recommendations. Explicitly check each acceptance criterion from plan.json tasks.
-RULES: $(cat ~/.claude/workflows/cli-templates/prompts/analysis/02-review-code-quality.txt) | Focus on plan acceptance criteria and plan adherence | analysis=READ-ONLY
+CONTEXT: @**/* @{plan.json} [@{exploration.json}] | Memory: Review lite-execute changes against plan requirements including verification checklist
+EXPECTED: Quality assessment with:
+  - Acceptance criteria verification (all tasks)
+  - Verification checklist validation (Medium/High: unit_tests, integration_tests, success_metrics)
+  - Issue identification
+  - Recommendations
+  Explicitly check each acceptance criterion and verification item from plan.json tasks.
+CONSTRAINTS: Focus on plan acceptance criteria, verification requirements, and plan adherence | analysis=READ-ONLY
 ```
 
 **Tool-Specific Execution** (Apply shared prompt template above):
@@ -620,8 +540,17 @@ ccw cli -p "[Shared Prompt Template with artifacts]" --tool gemini --mode analys
 ccw cli -p "[Shared Prompt Template with artifacts]" --tool qwen --mode analysis
 # Same prompt as Gemini, different execution engine
 
-# Method 4: Codex Review (autonomous)
-ccw cli -p "[Verify plan acceptance criteria at ${plan.json}]" --tool codex --mode write
+# Method 4: Codex Review (git-aware) - Two mutually exclusive options:
+
+# Option A: With custom prompt (reviews uncommitted by default)
+ccw cli -p "[Shared Prompt Template with artifacts]" --tool codex --mode review
+# Use for complex reviews with specific focus areas
+
+# Option B: Target flag only (no prompt allowed)
+ccw cli --tool codex --mode review --uncommitted
+# Quick review of uncommitted changes without custom instructions
+
+# ⚠️ IMPORTANT: -p prompt and target flags (--uncommitted/--base/--commit) are MUTUALLY EXCLUSIVE
 ```
 
 **Multi-Round Review with Fixed IDs**:
@@ -647,11 +576,11 @@ if (hasUnresolvedIssues(reviewResult)) {
 
 **Trigger**: After all executions complete (regardless of code review)
 
-**Skip Condition**: Skip if `.workflow/project.json` does not exist
+**Skip Condition**: Skip if `.workflow/project-tech.json` does not exist
 
 **Operations**:
 ```javascript
-const projectJsonPath = '.workflow/project.json'
+const projectJsonPath = '.workflow/project-tech.json'
 if (!fileExists(projectJsonPath)) return  // Silent skip
 
 const projectJson = JSON.parse(Read(projectJsonPath))
@@ -780,6 +709,10 @@ Collected after each execution call completes:
 
 Appended to `previousExecutionResults` array for context continuity in multi-execution scenarios.
 
+## Post-Completion Expansion
+
+完成后询问用户是否扩展为issue(test/enhance/refactor/doc)，选中项调用 `/issue:new "{summary} - {dimension}"`
+
 **Fixed ID Pattern**: `${sessionId}-${groupId}` enables predictable lookup without auto-generated timestamps.
 
 **Resume Usage**: If `status` is "partial" or "failed", use `fixedCliId` to resume:

.claude/commands/workflow/lite-fix.md

@@ -17,7 +17,7 @@ Intelligent lightweight bug fixing command with dynamic workflow adaptation base
 - Interactive clarification after diagnosis to gather missing information
 - Adaptive fix planning strategy (direct Claude vs cli-lite-planning-agent) based on complexity
 - Two-step confirmation: fix-plan display -> multi-dimensional input collection
-- Execution dispatch with complete context handoff to lite-execute
+- Execution execute with complete context handoff to lite-execute
 
 ## Usage
 
@@ -62,7 +62,7 @@ Phase 4: Confirmation & Selection
       |- Execution: Agent / Codex / Auto
       +- Review: Gemini / Agent / Skip
 
-Phase 5: Dispatch
+Phase 5: Execute
    |- Build executionContext (fix-plan + diagnoses + clarifications + selections)
    +- SlashCommand("/workflow:lite-execute --in-memory --mode bugfix")
 ```
@@ -380,6 +380,7 @@ if (uniqueClarifications.length > 0) {
 const schema = Bash(`cat ~/.claude/workflows/cli-templates/schemas/fix-plan-json-schema.json`)
 
 // Step 2: Generate fix-plan following schema (Claude directly, no agent)
+// For Medium complexity: include rationale + verification (optional, but recommended)
 const fixPlan = {
   summary: "...",
   root_cause: "...",
@@ -389,13 +390,67 @@ const fixPlan = {
   recommended_execution: "Agent",
   severity: severity,
   risk_level: "...",
-  _metadata: { timestamp: getUtc8ISOString(), source: "direct-planning", planning_mode: "direct" }
+
+  // Medium complexity fields (optional for direct planning, auto-filled for Low)
+  ...(severity === "Medium" ? {
+    design_decisions: [
+      {
+        decision: "Use immediate_patch strategy for minimal risk",
+        rationale: "Keeps changes localized and quick to review",
+        tradeoff: "Defers comprehensive refactoring"
+      }
+    ],
+    tasks_with_rationale: {
+      // Each task gets rationale if Medium
+      task_rationale_example: {
+        rationale: {
+          chosen_approach: "Direct fix approach",
+          alternatives_considered: ["Workaround", "Refactor"],
+          decision_factors: ["Minimal impact", "Quick turnaround"],
+          tradeoffs: "Doesn't address underlying issue"
+        },
+        verification: {
+          unit_tests: ["test_bug_fix_basic"],
+          integration_tests: [],
+          manual_checks: ["Reproduce issue", "Verify fix"],
+          success_metrics: ["Issue resolved", "No regressions"]
+        }
+      }
+    }
+  } : {}),
+
+  _metadata: {
+    timestamp: getUtc8ISOString(),
+    source: "direct-planning",
+    planning_mode: "direct",
+    complexity: severity === "Medium" ? "Medium" : "Low"
+  }
 }
 
-// Step 3: Write fix-plan to session folder
+// Step 3: Merge task rationale into tasks array
+if (severity === "Medium") {
+  fixPlan.tasks = fixPlan.tasks.map(task => ({
+    ...task,
+    rationale: fixPlan.tasks_with_rationale[task.id]?.rationale || {
+      chosen_approach: "Standard fix",
+      alternatives_considered: [],
+      decision_factors: ["Correctness", "Simplicity"],
+      tradeoffs: "None"
+    },
+    verification: fixPlan.tasks_with_rationale[task.id]?.verification || {
+      unit_tests: [`test_${task.id}_basic`],
+      integration_tests: [],
+      manual_checks: ["Verify fix works"],
+      success_metrics: ["Test pass"]
+    }
+  }))
+  delete fixPlan.tasks_with_rationale  // Clean up temp field
+}
+
+// Step 4: Write fix-plan to session folder
 Write(`${sessionFolder}/fix-plan.json`, JSON.stringify(fixPlan, null, 2))
 
-// Step 4: MUST continue to Phase 4 (Confirmation) - DO NOT execute code here
+// Step 5: MUST continue to Phase 4 (Confirmation) - DO NOT execute code here
 ```
 
 **High/Critical Severity** - Invoke cli-lite-planning-agent:
@@ -451,11 +506,41 @@ Generate fix-plan.json with:
   - description
   - modification_points: ALL files to modify for this fix (group related changes)
   - implementation (2-5 steps covering all modification_points)
-  - verification (test criteria)
+  - acceptance: Quantified acceptance criteria
   - depends_on: task IDs this task depends on (use sparingly)
+
+  **High/Critical complexity fields per task** (REQUIRED):
+  - rationale:
+    - chosen_approach: Why this fix approach (not alternatives)
+    - alternatives_considered: Other approaches evaluated
+    - decision_factors: Key factors influencing choice
+    - tradeoffs: Known tradeoffs of this approach
+  - verification:
+    - unit_tests: Test names to add/verify
+    - integration_tests: Integration test names
+    - manual_checks: Manual verification steps
+    - success_metrics: Quantified success criteria
+  - risks:
+    - description: Risk description
+    - probability: Low|Medium|High
+    - impact: Low|Medium|High
+    - mitigation: How to mitigate
+    - fallback: Fallback if fix fails
+  - code_skeleton (optional): Key interfaces/functions to implement
+    - interfaces: [{name, definition, purpose}]
+    - key_functions: [{signature, purpose, returns}]
+
+**Top-level High/Critical fields** (REQUIRED):
+- data_flow: How data flows through affected code
+  - diagram: "A → B → C" style flow
+  - stages: [{stage, input, output, component}]
+- design_decisions: Global fix decisions
+  - [{decision, rationale, tradeoff}]
+
 - estimated_time, recommended_execution, severity, risk_level
 - _metadata:
   - timestamp, source, planning_mode
+  - complexity: "High" | "Critical"
   - diagnosis_angles: ${JSON.stringify(manifest.diagnoses.map(d => d.angle))}
 
 ## Task Grouping Rules
@@ -467,11 +552,21 @@ Generate fix-plan.json with:
 
 ## Execution
 1. Read ALL diagnosis files for comprehensive context
-2. Execute CLI planning using Gemini (Qwen fallback)
+2. Execute CLI planning using Gemini (Qwen fallback) with --rule planning-fix-strategy template
 3. Synthesize findings from multiple diagnosis angles
-4. Parse output and structure fix-plan
-5. Write JSON: Write('${sessionFolder}/fix-plan.json', jsonContent)
-6. Return brief completion summary
+4. Generate fix-plan with:
+   - For High/Critical: REQUIRED new fields (rationale, verification, risks, code_skeleton, data_flow, design_decisions)
+   - Each task MUST have rationale (why this fix), verification (how to verify success), and risks (potential issues)
+5. Parse output and structure fix-plan
+6. Write JSON: Write('${sessionFolder}/fix-plan.json', jsonContent)
+7. Return brief completion summary
+
+## Output Format for CLI
+Include these sections in your fix-plan output:
+- Summary, Root Cause, Strategy (existing)
+- Data Flow: Diagram showing affected code paths
+- Design Decisions: Key architectural choices in the fix
+- Tasks: Each with rationale (Medium/High), verification (Medium/High), risks (High), code_skeleton (High)
 `
 )
 ```
@@ -543,7 +638,7 @@ AskUserQuestion({
 
 ---
 
-### Phase 5: Dispatch to Execution
+### Phase 5: Execute to Execution
 
 **CRITICAL**: lite-fix NEVER executes code directly. ALL execution MUST go through lite-execute.
 
@@ -565,7 +660,11 @@ const fixPlan = JSON.parse(Read(`${sessionFolder}/fix-plan.json`))
 executionContext = {
   mode: "bugfix",
   severity: fixPlan.severity,
-  planObject: fixPlan,
+  planObject: {
+    ...fixPlan,
+    // Ensure complexity is set based on severity for new field consumption
+    complexity: fixPlan.complexity || (fixPlan.severity === 'Critical' ? 'High' : (fixPlan.severity === 'High' ? 'High' : 'Medium'))
+  },
   diagnosisContext: diagnoses,
   diagnosisAngles: manifest.diagnoses.map(d => d.angle),
   diagnosisManifest: manifest,
@@ -588,7 +687,7 @@ executionContext = {
 }
 ```
 
-**Step 5.2: Dispatch**
+**Step 5.2: Execute**
 
 ```javascript
 SlashCommand(command="/workflow:lite-execute --in-memory --mode bugfix")

.claude/commands/workflow/lite-lite-lite.md

@@ -0,0 +1,461 @@
+---
+name: workflow:lite-lite-lite
+description: Ultra-lightweight multi-tool analysis and direct execution. No artifacts for simple tasks; auto-creates planning docs in .workflow/.scratchpad/ for complex tasks. Auto tool selection based on task analysis, user-driven iteration via AskUser.
+argument-hint: "<task description>"
+allowed-tools: TodoWrite(*), Task(*), AskUserQuestion(*), Read(*), Bash(*), Write(*), mcp__ace-tool__search_context(*), mcp__ccw-tools__write_file(*)
+---
+
+# Ultra-Lite Multi-Tool Workflow
+
+## Quick Start
+
+```bash
+/workflow:lite-lite-lite "Fix the login bug"
+/workflow:lite-lite-lite "Refactor payment module for multi-gateway support"
+```
+
+**Core Philosophy**: Minimal friction, maximum velocity. Simple tasks = no artifacts. Complex tasks = lightweight planning doc in `.workflow/.scratchpad/`.
+
+## Overview
+
+**Complexity-aware workflow**: Clarify → Assess Complexity → Select Tools → Multi-Mode Analysis → Decision → Direct Execution
+
+**vs multi-cli-plan**: No IMPL_PLAN.md, plan.json, synthesis.json - state in memory or lightweight scratchpad doc for complex tasks.
+
+## Execution Flow
+
+```
+Phase 1: Clarify Requirements → AskUser for missing details
+Phase 1.5: Assess Complexity → Determine if planning doc needed
+Phase 2: Select Tools (CLI → Mode → Agent) → 3-step selection
+Phase 3: Multi-Mode Analysis → Execute with --resume chaining
+Phase 4: User Decision → Execute / Refine / Change / Cancel
+Phase 5: Direct Execution → No plan files (simple) or scratchpad doc (complex)
+```
+
+## Phase 1: Clarify Requirements
+
+```javascript
+const taskDescription = $ARGUMENTS
+
+if (taskDescription.length < 20 || isAmbiguous(taskDescription)) {
+  AskUserQuestion({
+    questions: [{
+      question: "Please provide more details: target files/modules, expected behavior, constraints?",
+      header: "Details",
+      options: [
+        { label: "I'll provide more", description: "Add more context" },
+        { label: "Continue analysis", description: "Let tools explore autonomously" }
+      ],
+      multiSelect: false
+    }]
+  })
+}
+
+// Optional: Quick ACE Context for complex tasks
+mcp__ace-tool__search_context({
+  project_root_path: process.cwd(),
+  query: `${taskDescription} implementation patterns`
+})
+```
+
+## Phase 1.5: Assess Complexity
+
+| Level | Creates Plan Doc | Trigger Keywords |
+|-------|------------------|------------------|
+| **simple** | ❌ | (default) |
+| **moderate** | ✅ | module, system, service, integration, multiple |
+| **complex** | ✅ | refactor, migrate, security, auth, payment, database |
+
+```javascript
+// Complexity detection (after ACE query)
+const isComplex = /refactor|migrate|security|auth|payment|database/i.test(taskDescription)
+const isModerate = /module|system|service|integration|multiple/i.test(taskDescription) || aceContext?.relevant_files?.length > 2
+
+if (isComplex || isModerate) {
+  const planPath = `.workflow/.scratchpad/lite3-${taskSlug}-${dateStr}.md`
+  // Create planning doc with: Task, Status, Complexity, Analysis Summary, Execution Plan, Progress Log
+}
+```
+
+## Phase 2: Select Tools
+
+### Tool Definitions
+
+**CLI Tools** (from cli-tools.json):
+```javascript
+const cliConfig = JSON.parse(Read("~/.claude/cli-tools.json"))
+const cliTools = Object.entries(cliConfig.tools)
+  .filter(([_, config]) => config.enabled)
+  .map(([name, config]) => ({
+    name, type: 'cli',
+    tags: config.tags || [],
+    model: config.primaryModel,
+    toolType: config.type  // builtin, cli-wrapper, api-endpoint
+  }))
+```
+
+**Sub Agents**:
+
+| Agent | Strengths | canExecute |
+|-------|-----------|------------|
+| **code-developer** | Code implementation, test writing | ✅ |
+| **Explore** | Fast code exploration, pattern discovery | ❌ |
+| **cli-explore-agent** | Dual-source analysis (Bash+CLI) | ❌ |
+| **cli-discuss-agent** | Multi-CLI collaboration, cross-verification | ❌ |
+| **debug-explore-agent** | Hypothesis-driven debugging | ❌ |
+| **context-search-agent** | Multi-layer file discovery, dependency analysis | ❌ |
+| **test-fix-agent** | Test execution, failure diagnosis, code fixing | ✅ |
+| **universal-executor** | General execution, multi-domain adaptation | ✅ |
+
+**Analysis Modes**:
+
+| Mode | Pattern | Use Case | minCLIs |
+|------|---------|----------|---------|
+| **Parallel** | `A \|\| B \|\| C → Aggregate` | Fast multi-perspective | 1+ |
+| **Sequential** | `A → B(resume) → C(resume)` | Incremental deepening | 2+ |
+| **Collaborative** | `A → B → A → B → Synthesize` | Multi-round refinement | 2+ |
+| **Debate** | `A(propose) → B(challenge) → A(defend)` | Adversarial validation | 2 |
+| **Challenge** | `A(analyze) → B(challenge)` | Find flaws and risks | 2 |
+
+### Three-Step Selection Flow
+
+```javascript
+// Step 1: Select CLIs (multiSelect)
+AskUserQuestion({
+  questions: [{
+    question: "Select CLI tools for analysis (1-3 for collaboration modes)",
+    header: "CLI Tools",
+    options: cliTools.map(cli => ({
+      label: cli.name,
+      description: cli.tags.length > 0 ? cli.tags.join(', ') : cli.model || 'general'
+    })),
+    multiSelect: true
+  }]
+})
+
+// Step 2: Select Mode (filtered by CLI count)
+const availableModes = analysisModes.filter(m => selectedCLIs.length >= m.minCLIs)
+AskUserQuestion({
+  questions: [{
+    question: "Select analysis mode",
+    header: "Mode",
+    options: availableModes.map(m => ({
+      label: m.label,
+      description: `${m.description} [${m.pattern}]`
+    })),
+    multiSelect: false
+  }]
+})
+
+// Step 3: Select Agent for execution
+AskUserQuestion({
+  questions: [{
+    question: "Select Sub Agent for execution",
+    header: "Agent",
+    options: agents.map(a => ({ label: a.name, description: a.strength })),
+    multiSelect: false
+  }]
+})
+
+// Confirm selection
+AskUserQuestion({
+  questions: [{
+    question: "Confirm selection?",
+    header: "Confirm",
+    options: [
+      { label: "Confirm and continue", description: `${selectedMode.label} with ${selectedCLIs.length} CLIs` },
+      { label: "Re-select CLIs", description: "Choose different CLI tools" },
+      { label: "Re-select Mode", description: "Choose different analysis mode" },
+      { label: "Re-select Agent", description: "Choose different Sub Agent" }
+    ],
+    multiSelect: false
+  }]
+})
+```
+
+## Phase 3: Multi-Mode Analysis
+
+### Universal CLI Prompt Template
+
+```javascript
+// Unified prompt builder - used by all modes
+function buildPrompt({ purpose, tasks, expected, rules, taskDescription }) {
+  return `
+PURPOSE: ${purpose}: ${taskDescription}
+TASK: ${tasks.map(t => `• ${t}`).join(' ')}
+MODE: analysis
+CONTEXT: @**/*
+EXPECTED: ${expected}
+CONSTRAINTS: ${rules}
+`
+}
+
+// Execute CLI with prompt
+function execCLI(cli, prompt, options = {}) {
+  const { resume, background = false } = options
+  const resumeFlag = resume ? `--resume ${resume}` : ''
+  return Bash({
+    command: `ccw cli -p "${prompt}" --tool ${cli.name} --mode analysis ${resumeFlag}`,
+    run_in_background: background
+  })
+}
+```
+
+### Prompt Presets by Role
+
+| Role | PURPOSE | TASKS | EXPECTED | RULES |
+|------|---------|-------|----------|-------|
+| **initial** | Initial analysis | Identify files, Analyze approach, List changes | Root cause, files, changes, risks | Focus on actionable insights |
+| **extend** | Build on previous | Review previous, Extend, Add insights | Extended analysis building on findings | Build incrementally, avoid repetition |
+| **synthesize** | Refine and synthesize | Review, Identify gaps, Synthesize | Refined synthesis with new perspectives | Add value not repetition |
+| **propose** | Propose comprehensive analysis | Analyze thoroughly, Propose solution, State assumptions | Well-reasoned proposal with trade-offs | Be clear about assumptions |
+| **challenge** | Challenge and stress-test | Identify weaknesses, Question assumptions, Suggest alternatives | Critique with counter-arguments | Be adversarial but constructive |
+| **defend** | Respond to challenges | Address challenges, Defend valid aspects, Propose refined solution | Refined proposal incorporating feedback | Be open to criticism, synthesize |
+| **criticize** | Find flaws ruthlessly | Find logical flaws, Identify edge cases, Rate criticisms | Critique with severity: [CRITICAL]/[HIGH]/[MEDIUM]/[LOW] | Be ruthlessly critical |
+
+```javascript
+const PROMPTS = {
+  initial: { purpose: 'Initial analysis', tasks: ['Identify affected files', 'Analyze implementation approach', 'List specific changes'], expected: 'Root cause, files to modify, key changes, risks', rules: 'Focus on actionable insights' },
+  extend: { purpose: 'Build on previous analysis', tasks: ['Review previous findings', 'Extend analysis', 'Add new insights'], expected: 'Extended analysis building on previous', rules: 'Build incrementally, avoid repetition' },
+  synthesize: { purpose: 'Refine and synthesize', tasks: ['Review previous', 'Identify gaps', 'Add insights', 'Synthesize findings'], expected: 'Refined synthesis with new perspectives', rules: 'Build collaboratively, add value' },
+  propose: { purpose: 'Propose comprehensive analysis', tasks: ['Analyze thoroughly', 'Propose solution', 'State assumptions clearly'], expected: 'Well-reasoned proposal with trade-offs', rules: 'Be clear about assumptions' },
+  challenge: { purpose: 'Challenge and stress-test', tasks: ['Identify weaknesses', 'Question assumptions', 'Suggest alternatives', 'Highlight overlooked risks'], expected: 'Constructive critique with counter-arguments', rules: 'Be adversarial but constructive' },
+  defend: { purpose: 'Respond to challenges', tasks: ['Address each challenge', 'Defend valid aspects', 'Acknowledge valid criticisms', 'Propose refined solution'], expected: 'Refined proposal incorporating alternatives', rules: 'Be open to criticism, synthesize best ideas' },
+  criticize: { purpose: 'Stress-test and find weaknesses', tasks: ['Find logical flaws', 'Identify missed edge cases', 'Propose alternatives', 'Rate criticisms (High/Medium/Low)'], expected: 'Detailed critique with severity ratings', rules: 'Be ruthlessly critical, find every flaw' }
+}
+```
+
+### Mode Implementations
+
+```javascript
+// Parallel: All CLIs run simultaneously
+async function executeParallel(clis, task) {
+  return await Promise.all(clis.map(cli =>
+    execCLI(cli, buildPrompt({ ...PROMPTS.initial, taskDescription: task }), { background: true })
+  ))
+}
+
+// Sequential: Each CLI builds on previous via --resume
+async function executeSequential(clis, task) {
+  const results = []
+  let prevId = null
+  for (const cli of clis) {
+    const preset = prevId ? PROMPTS.extend : PROMPTS.initial
+    const result = await execCLI(cli, buildPrompt({ ...preset, taskDescription: task }), { resume: prevId })
+    results.push(result)
+    prevId = extractSessionId(result)
+  }
+  return results
+}
+
+// Collaborative: Multi-round synthesis
+async function executeCollaborative(clis, task, rounds = 2) {
+  const results = []
+  let prevId = null
+  for (let r = 0; r < rounds; r++) {
+    for (const cli of clis) {
+      const preset = !prevId ? PROMPTS.initial : PROMPTS.synthesize
+      const result = await execCLI(cli, buildPrompt({ ...preset, taskDescription: task }), { resume: prevId })
+      results.push({ cli: cli.name, round: r, result })
+      prevId = extractSessionId(result)
+    }
+  }
+  return results
+}
+
+// Debate: Propose → Challenge → Defend
+async function executeDebate(clis, task) {
+  const [cliA, cliB] = clis
+  const results = []
+
+  const propose = await execCLI(cliA, buildPrompt({ ...PROMPTS.propose, taskDescription: task }))
+  results.push({ phase: 'propose', cli: cliA.name, result: propose })
+
+  const challenge = await execCLI(cliB, buildPrompt({ ...PROMPTS.challenge, taskDescription: task }), { resume: extractSessionId(propose) })
+  results.push({ phase: 'challenge', cli: cliB.name, result: challenge })
+
+  const defend = await execCLI(cliA, buildPrompt({ ...PROMPTS.defend, taskDescription: task }), { resume: extractSessionId(challenge) })
+  results.push({ phase: 'defend', cli: cliA.name, result: defend })
+
+  return results
+}
+
+// Challenge: Analyze → Criticize
+async function executeChallenge(clis, task) {
+  const [cliA, cliB] = clis
+  const results = []
+
+  const analyze = await execCLI(cliA, buildPrompt({ ...PROMPTS.initial, taskDescription: task }))
+  results.push({ phase: 'analyze', cli: cliA.name, result: analyze })
+
+  const criticize = await execCLI(cliB, buildPrompt({ ...PROMPTS.criticize, taskDescription: task }), { resume: extractSessionId(analyze) })
+  results.push({ phase: 'challenge', cli: cliB.name, result: criticize })
+
+  return results
+}
+```
+
+### Mode Router & Result Aggregation
+
+```javascript
+async function executeAnalysis(mode, clis, taskDescription) {
+  switch (mode.name) {
+    case 'parallel': return await executeParallel(clis, taskDescription)
+    case 'sequential': return await executeSequential(clis, taskDescription)
+    case 'collaborative': return await executeCollaborative(clis, taskDescription)
+    case 'debate': return await executeDebate(clis, taskDescription)
+    case 'challenge': return await executeChallenge(clis, taskDescription)
+  }
+}
+
+function aggregateResults(mode, results) {
+  const base = { mode: mode.name, pattern: mode.pattern, tools_used: results.map(r => r.cli || 'unknown') }
+
+  switch (mode.name) {
+    case 'parallel':
+      return { ...base, findings: results.map(parseOutput), consensus: findCommonPoints(results), divergences: findDifferences(results) }
+    case 'sequential':
+      return { ...base, evolution: results.map((r, i) => ({ step: i + 1, analysis: parseOutput(r) })), finalAnalysis: parseOutput(results.at(-1)) }
+    case 'collaborative':
+      return { ...base, rounds: groupByRound(results), synthesis: extractSynthesis(results.at(-1)) }
+    case 'debate':
+      return { ...base, proposal: parseOutput(results.find(r => r.phase === 'propose')?.result),
+        challenges: parseOutput(results.find(r => r.phase === 'challenge')?.result),
+        resolution: parseOutput(results.find(r => r.phase === 'defend')?.result), confidence: calculateDebateConfidence(results) }
+    case 'challenge':
+      return { ...base, originalAnalysis: parseOutput(results.find(r => r.phase === 'analyze')?.result),
+        critiques: parseCritiques(results.find(r => r.phase === 'challenge')?.result), riskScore: calculateRiskScore(results) }
+  }
+}
+
+// If planPath exists: update Analysis Summary & Execution Plan sections
+```
+
+## Phase 4: User Decision
+
+```javascript
+function presentSummary(analysis) {
+  console.log(`## Analysis Result\n**Mode**: ${analysis.mode} (${analysis.pattern})\n**Tools**: ${analysis.tools_used.join(' → ')}`)
+
+  switch (analysis.mode) {
+    case 'parallel':
+      console.log(`### Consensus\n${analysis.consensus.map(c => `- ${c}`).join('\n')}\n### Divergences\n${analysis.divergences.map(d => `- ${d}`).join('\n')}`)
+      break
+    case 'sequential':
+      console.log(`### Evolution\n${analysis.evolution.map(e => `**Step ${e.step}**: ${e.analysis.summary}`).join('\n')}\n### Final\n${analysis.finalAnalysis.summary}`)
+      break
+    case 'collaborative':
+      console.log(`### Rounds\n${Object.entries(analysis.rounds).map(([r, a]) => `**Round ${r}**: ${a.map(x => x.cli).join(' + ')}`).join('\n')}\n### Synthesis\n${analysis.synthesis}`)
+      break
+    case 'debate':
+      console.log(`### Debate\n**Proposal**: ${analysis.proposal.summary}\n**Challenges**: ${analysis.challenges.points?.length || 0} points\n**Resolution**: ${analysis.resolution.summary}\n**Confidence**: ${analysis.confidence}%`)
+      break
+    case 'challenge':
+      console.log(`### Challenge\n**Original**: ${analysis.originalAnalysis.summary}\n**Critiques**: ${analysis.critiques.length} issues\n${analysis.critiques.map(c => `- [${c.severity}] ${c.description}`).join('\n')}\n**Risk Score**: ${analysis.riskScore}/100`)
+      break
+  }
+}
+
+AskUserQuestion({
+  questions: [{
+    question: "How to proceed?",
+    header: "Next Step",
+    options: [
+      { label: "Execute directly", description: "Implement immediately" },
+      { label: "Refine analysis", description: "Add constraints, re-analyze" },
+      { label: "Change tools", description: "Different tool combination" },
+      { label: "Cancel", description: "End workflow" }
+    ],
+    multiSelect: false
+  }]
+})
+// If planPath exists: record decision to Decisions Made table
+// Routing: Execute → Phase 5 | Refine → Phase 3 | Change → Phase 2 | Cancel → End
+```
+
+## Phase 5: Direct Execution
+
+```javascript
+// Simple tasks: No artifacts | Complex tasks: Update scratchpad doc
+const executionAgents = agents.filter(a => a.canExecute)
+const executionTool = selectedAgent.canExecute ? selectedAgent : selectedCLIs[0]
+
+if (executionTool.type === 'agent') {
+  Task({
+    subagent_type: executionTool.name,
+    run_in_background: false,
+    description: `Execute: ${taskDescription.slice(0, 30)}`,
+    prompt: `## Task\n${taskDescription}\n\n## Analysis Results\n${JSON.stringify(aggregatedAnalysis, null, 2)}\n\n## Instructions\n1. Apply changes to identified files\n2. Follow recommended approach\n3. Handle identified risks\n4. Verify changes work correctly`
+  })
+} else {
+  Bash({
+    command: `ccw cli -p "
+PURPOSE: Implement solution: ${taskDescription}
+TASK: ${extractedTasks.join(' • ')}
+MODE: write
+CONTEXT: @${affectedFiles.join(' @')}
+EXPECTED: Working implementation with all changes applied
+CONSTRAINTS: Follow existing patterns
+" --tool ${executionTool.name} --mode write`,
+    run_in_background: false
+  })
+}
+// If planPath exists: update Status to completed/failed, append to Progress Log
+```
+
+## TodoWrite Structure
+
+```javascript
+TodoWrite({ todos: [
+  { content: "Phase 1: Clarify requirements", status: "in_progress", activeForm: "Clarifying requirements" },
+  { content: "Phase 1.5: Assess complexity", status: "pending", activeForm: "Assessing complexity" },
+  { content: "Phase 2: Select tools", status: "pending", activeForm: "Selecting tools" },
+  { content: "Phase 3: Multi-mode analysis", status: "pending", activeForm: "Running analysis" },
+  { content: "Phase 4: User decision", status: "pending", activeForm: "Awaiting decision" },
+  { content: "Phase 5: Direct execution", status: "pending", activeForm: "Executing" }
+]})
+```
+
+## Iteration Patterns
+
+| Pattern | Flow |
+|---------|------|
+| **Direct** | Phase 1 → 2 → 3 → 4(execute) → 5 |
+| **Refinement** | Phase 3 → 4(refine) → 3 → 4 → 5 |
+| **Tool Adjust** | Phase 2(adjust) → 3 → 4 → 5 |
+
+## Error Handling
+
+| Error | Resolution |
+|-------|------------|
+| CLI timeout | Retry with secondary model |
+| No enabled tools | Ask user to enable tools in cli-tools.json |
+| Task unclear | Default to first CLI + code-developer |
+| Ambiguous task | Force clarification via AskUser |
+| Execution fails | Present error, ask user for direction |
+| Plan doc write fails | Continue without doc (degrade to zero-artifact mode) |
+| Scratchpad dir missing | Auto-create `.workflow/.scratchpad/` |
+
+## Comparison with multi-cli-plan
+
+| Aspect | lite-lite-lite | multi-cli-plan |
+|--------|----------------|----------------|
+| **Artifacts** | Conditional (scratchpad doc for complex tasks) | Always (IMPL_PLAN.md, plan.json, synthesis.json) |
+| **Session** | Stateless (--resume chaining) | Persistent session folder |
+| **Tool Selection** | 3-step (CLI → Mode → Agent) | Config-driven fixed tools |
+| **Analysis Modes** | 5 modes with --resume | Fixed synthesis rounds |
+| **Complexity** | Auto-detected (simple/moderate/complex) | Assumed complex |
+| **Best For** | Quick analysis, simple-to-moderate tasks | Complex multi-step implementations |
+
+## Post-Completion Expansion
+
+完成后询问用户是否扩展为issue(test/enhance/refactor/doc)，选中项调用 `/issue:new "{summary} - {dimension}"`
+
+## Related Commands
+
+```bash
+/workflow:multi-cli-plan "complex task"   # Full planning workflow
+/workflow:lite-plan "task"                # Single CLI planning
+/workflow:lite-execute --in-memory        # Direct execution
+```

.claude/commands/workflow/lite-plan.md

@@ -1,6 +1,6 @@
 ---
 name: lite-plan
-description: Lightweight interactive planning workflow with in-memory planning, code exploration, and execution dispatch to lite-execute after user confirmation
+description: Lightweight interactive planning workflow with in-memory planning, code exploration, and execution execute to lite-execute after user confirmation
 argument-hint: "[-e|--explore] \"task description\"|file.md"
 allowed-tools: TodoWrite(*), Task(*), SlashCommand(*), AskUserQuestion(*)
 ---
@@ -17,7 +17,7 @@ Intelligent lightweight planning command with dynamic workflow adaptation based
 - Interactive clarification after exploration to gather missing information
 - Adaptive planning: Low complexity → Direct Claude; Medium/High → cli-lite-planning-agent
 - Two-step confirmation: plan display → multi-dimensional input collection
-- Execution dispatch with complete context handoff to lite-execute
+- Execution execute with complete context handoff to lite-execute
 
 ## Usage
 
@@ -62,7 +62,7 @@ Phase 4: Confirmation & Selection
       ├─ Execution: Agent / Codex / Auto
       └─ Review: Gemini / Agent / Skip
 
-Phase 5: Dispatch
+Phase 5: Execute
    ├─ Build executionContext (plan + explorations + clarifications + selections)
    └─ SlashCommand("/workflow:lite-execute --in-memory")
 ```
@@ -497,6 +497,7 @@ ${plan.tasks.map((t, i) => `${i+1}. ${t.title} (${t.file})`).join('\n')}
 
 **Step 4.2: Collect Confirmation**
 ```javascript
+// Note: Execution "Other" option allows specifying CLI tools from ~/.claude/cli-tools.json
 AskUserQuestion({
   questions: [
     {
@@ -524,8 +525,9 @@ AskUserQuestion({
       header: "Review",
       multiSelect: false,
       options: [
-        { label: "Gemini Review", description: "Gemini CLI" },
-        { label: "Agent Review", description: "@code-reviewer" },
+        { label: "Gemini Review", description: "Gemini CLI review" },
+        { label: "Codex Review", description: "Git-aware review (prompt OR --uncommitted)" },
+        { label: "Agent Review", description: "@code-reviewer agent" },
         { label: "Skip", description: "No review" }
       ]
     }
@@ -535,7 +537,7 @@ AskUserQuestion({
 
 ---
 
-### Phase 5: Dispatch to Execution
+### Phase 5: Execute to Execution
 
 **CRITICAL**: lite-plan NEVER executes code directly. ALL execution MUST go through lite-execute.
 
@@ -582,7 +584,7 @@ executionContext = {
 }
 ```
 
-**Step 5.2: Dispatch**
+**Step 5.2: Execute**
 
 ```javascript
 SlashCommand(command="/workflow:lite-execute --in-memory")

.claude/commands/workflow/multi-cli-plan.md

@@ -0,0 +1,568 @@
+---
+name: workflow:multi-cli-plan
+description: Multi-CLI collaborative planning workflow with ACE context gathering and iterative cross-verification. Uses cli-discuss-agent for Gemini+Codex+Claude analysis to converge on optimal execution plan.
+argument-hint: "<task description> [--max-rounds=3] [--tools=gemini,codex] [--mode=parallel|serial]"
+allowed-tools: TodoWrite(*), Task(*), AskUserQuestion(*), Read(*), Bash(*), Write(*), mcp__ace-tool__search_context(*)
+---
+
+# Multi-CLI Collaborative Planning Command
+
+## Quick Start
+
+```bash
+# Basic usage
+/workflow:multi-cli-plan "Implement user authentication"
+
+# With options
+/workflow:multi-cli-plan "Add dark mode support" --max-rounds=3
+/workflow:multi-cli-plan "Refactor payment module" --tools=gemini,codex,claude
+/workflow:multi-cli-plan "Fix memory leak" --mode=serial
+```
+
+**Context Source**: ACE semantic search + Multi-CLI analysis
+**Output Directory**: `.workflow/.multi-cli-plan/{session-id}/`
+**Default Max Rounds**: 3 (convergence may complete earlier)
+**CLI Tools**: @cli-discuss-agent (analysis), @cli-lite-planning-agent (plan generation)
+**Execution**: Auto-hands off to `/workflow:lite-execute --in-memory` after plan approval
+
+## What & Why
+
+### Core Concept
+
+Multi-CLI collaborative planning with **three-phase architecture**: ACE context gathering → Iterative multi-CLI discussion → Plan generation. Orchestrator delegates analysis to agents, only handles user decisions and session management.
+
+**Process**:
+- **Phase 1**: ACE semantic search gathers codebase context
+- **Phase 2**: cli-discuss-agent orchestrates Gemini/Codex/Claude for cross-verified analysis
+- **Phase 3-5**: User decision → Plan generation → Execution handoff
+
+**vs Single-CLI Planning**:
+- **Single**: One model perspective, potential blind spots
+- **Multi-CLI**: Cross-verification catches inconsistencies, builds consensus on solutions
+
+### Value Proposition
+
+1. **Multi-Perspective Analysis**: Gemini + Codex + Claude analyze from different angles
+2. **Cross-Verification**: Identify agreements/disagreements, build confidence
+3. **User-Driven Decisions**: Every round ends with user decision point
+4. **Iterative Convergence**: Progressive refinement until consensus reached
+
+### Orchestrator Boundary (CRITICAL)
+
+- **ONLY command** for multi-CLI collaborative planning
+- Manages: Session state, user decisions, agent delegation, phase transitions
+- Delegates: CLI execution to @cli-discuss-agent, plan generation to @cli-lite-planning-agent
+
+### Execution Flow
+
+```
+Phase 1: Context Gathering
+   └─ ACE semantic search, extract keywords, build context package
+
+Phase 2: Multi-CLI Discussion (Iterative, via @cli-discuss-agent)
+   ├─ Round N: Agent executes Gemini + Codex + Claude
+   ├─ Cross-verify findings, synthesize solutions
+   ├─ Write synthesis.json to rounds/{N}/
+   └─ Loop until convergence or max rounds
+
+Phase 3: Present Options
+   └─ Display solutions with trade-offs from agent output
+
+Phase 4: User Decision
+   ├─ Select solution approach
+   ├─ Select execution method (Agent/Codex/Auto)
+   ├─ Select code review tool (Skip/Gemini/Codex/Agent)
+   └─ Route:
+      ├─ Approve → Phase 5
+      ├─ Need More Analysis → Return to Phase 2
+      └─ Cancel → Save session
+
+Phase 5: Plan Generation & Execution Handoff
+   ├─ Generate plan.json (via @cli-lite-planning-agent)
+   ├─ Build executionContext with user selections
+   └─ Execute to /workflow:lite-execute --in-memory
+```
+
+### Agent Roles
+
+| Agent | Responsibility |
+|-------|---------------|
+| **Orchestrator** | Session management, ACE context, user decisions, phase transitions, executionContext assembly |
+| **@cli-discuss-agent** | Multi-CLI execution (Gemini/Codex/Claude), cross-verification, solution synthesis, synthesis.json output |
+| **@cli-lite-planning-agent** | Task decomposition, plan.json generation following schema |
+
+## Core Responsibilities
+
+### Phase 1: Context Gathering
+
+**Session Initialization**:
+```javascript
+const sessionId = `MCP-${taskSlug}-${date}`
+const sessionFolder = `.workflow/.multi-cli-plan/${sessionId}`
+Bash(`mkdir -p ${sessionFolder}/rounds`)
+```
+
+**ACE Context Queries**:
+```javascript
+const aceQueries = [
+  `Project architecture related to ${keywords}`,
+  `Existing implementations of ${keywords[0]}`,
+  `Code patterns for ${keywords} features`,
+  `Integration points for ${keywords[0]}`
+]
+// Execute via mcp__ace-tool__search_context
+```
+
+**Context Package** (passed to agent):
+- `relevant_files[]` - Files identified by ACE
+- `detected_patterns[]` - Code patterns found
+- `architecture_insights` - Structure understanding
+
+### Phase 2: Agent Delegation
+
+**Core Principle**: Orchestrator only delegates and reads output - NO direct CLI execution.
+
+**Agent Invocation**:
+```javascript
+Task({
+  subagent_type: "cli-discuss-agent",
+  run_in_background: false,
+  description: `Discussion round ${currentRound}`,
+  prompt: `
+## Input Context
+- task_description: ${taskDescription}
+- round_number: ${currentRound}
+- session: { id: "${sessionId}", folder: "${sessionFolder}" }
+- ace_context: ${JSON.stringify(contextPackageage)}
+- previous_rounds: ${JSON.stringify(analysisResults)}
+- user_feedback: ${userFeedback || 'None'}
+- cli_config: { tools: ["gemini", "codex"], mode: "parallel", fallback_chain: ["gemini", "codex", "claude"] }
+
+## Execution Process
+1. Parse input context (handle JSON strings)
+2. Check if ACE supplementary search needed
+3. Build CLI prompts with context
+4. Execute CLIs (parallel or serial per cli_config.mode)
+5. Parse CLI outputs, handle failures with fallback
+6. Perform cross-verification between CLI results
+7. Synthesize solutions, calculate scores
+8. Calculate convergence, generate clarification questions
+9. Write synthesis.json
+
+## Output
+Write: ${sessionFolder}/rounds/${currentRound}/synthesis.json
+
+## Completion Checklist
+- [ ] All configured CLI tools executed (or fallback triggered)
+- [ ] Cross-verification completed with agreements/disagreements
+- [ ] 2-3 solutions generated with file:line references
+- [ ] Convergence score calculated (0.0-1.0)
+- [ ] synthesis.json written with all Primary Fields
+`
+})
+```
+
+**Read Agent Output**:
+```javascript
+const synthesis = JSON.parse(Read(`${sessionFolder}/rounds/${round}/synthesis.json`))
+// Access top-level fields: solutions, convergence, cross_verification, clarification_questions
+```
+
+**Convergence Decision**:
+```javascript
+if (synthesis.convergence.recommendation === 'converged') {
+  // Proceed to Phase 3
+} else if (synthesis.convergence.recommendation === 'user_input_needed') {
+  // Collect user feedback, return to Phase 2
+} else {
+  // Continue to next round if new_insights && round < maxRounds
+}
+```
+
+### Phase 3: Present Options
+
+**Display from Agent Output** (no processing):
+```javascript
+console.log(`
+## Solution Options
+
+${synthesis.solutions.map((s, i) => `
+**Option ${i+1}: ${s.name}**
+Source: ${s.source_cli.join(' + ')}
+Effort: ${s.effort} | Risk: ${s.risk}
+
+Pros: ${s.pros.join(', ')}
+Cons: ${s.cons.join(', ')}
+
+Files: ${s.affected_files.slice(0,3).map(f => `${f.file}:${f.line}`).join(', ')}
+`).join('\n')}
+
+## Cross-Verification
+Agreements: ${synthesis.cross_verification.agreements.length}
+Disagreements: ${synthesis.cross_verification.disagreements.length}
+`)
+```
+
+### Phase 4: User Decision
+
+**Decision Options**:
+```javascript
+AskUserQuestion({
+  questions: [
+    {
+      question: "Which solution approach?",
+      header: "Solution",
+      multiSelect: false,
+      options: solutions.map((s, i) => ({
+        label: `Option ${i+1}: ${s.name}`,
+        description: `${s.effort} effort, ${s.risk} risk`
+      })).concat([
+        { label: "Need More Analysis", description: "Return to Phase 2" }
+      ])
+    },
+    {
+      question: "Execution method:",
+      header: "Execution",
+      multiSelect: false,
+      options: [
+        { label: "Agent", description: "@code-developer agent" },
+        { label: "Codex", description: "codex CLI tool" },
+        { label: "Auto", description: "Auto-select based on complexity" }
+      ]
+    },
+    {
+      question: "Code review after execution?",
+      header: "Review",
+      multiSelect: false,
+      options: [
+        { label: "Skip", description: "No review" },
+        { label: "Gemini Review", description: "Gemini CLI tool" },
+        { label: "Codex Review", description: "codex review --uncommitted" },
+        { label: "Agent Review", description: "Current agent review" }
+      ]
+    }
+  ]
+})
+```
+
+**Routing**:
+- Approve + execution method → Phase 5
+- Need More Analysis → Phase 2 with feedback
+- Cancel → Save session for resumption
+
+### Phase 5: Plan Generation & Execution Handoff
+
+**Step 1: Build Context-Package** (Orchestrator responsibility):
+```javascript
+// Extract key information from user decision and synthesis
+const contextPackage = {
+  // Core solution details
+  solution: {
+    name: selectedSolution.name,
+    source_cli: selectedSolution.source_cli,
+    feasibility: selectedSolution.feasibility,
+    effort: selectedSolution.effort,
+    risk: selectedSolution.risk,
+    summary: selectedSolution.summary
+  },
+  // Implementation plan (tasks, flow, milestones)
+  implementation_plan: selectedSolution.implementation_plan,
+  // Dependencies
+  dependencies: selectedSolution.dependencies || { internal: [], external: [] },
+  // Technical concerns
+  technical_concerns: selectedSolution.technical_concerns || [],
+  // Consensus from cross-verification
+  consensus: {
+    agreements: synthesis.cross_verification.agreements,
+    resolved_conflicts: synthesis.cross_verification.resolution
+  },
+  // User constraints (from Phase 4 feedback)
+  constraints: userConstraints || [],
+  // Task context
+  task_description: taskDescription,
+  session_id: sessionId
+}
+
+// Write context-package for traceability
+Write(`${sessionFolder}/context-package.json`, JSON.stringify(contextPackage, null, 2))
+```
+
+**Context-Package Schema**:
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `solution` | object | User-selected solution from synthesis |
+| `solution.name` | string | Solution identifier |
+| `solution.feasibility` | number | Viability score (0-1) |
+| `solution.summary` | string | Brief analysis summary |
+| `implementation_plan` | object | Task breakdown with flow and dependencies |
+| `implementation_plan.approach` | string | High-level technical strategy |
+| `implementation_plan.tasks[]` | array | Discrete tasks with id, name, depends_on, files |
+| `implementation_plan.execution_flow` | string | Task sequence (e.g., "T1 → T2 → T3") |
+| `implementation_plan.milestones` | string[] | Key checkpoints |
+| `dependencies` | object | Module and package dependencies |
+| `technical_concerns` | string[] | Risks and blockers |
+| `consensus` | object | Cross-verified agreements from multi-CLI |
+| `constraints` | string[] | User-specified constraints from Phase 4 |
+
+```json
+{
+  "solution": {
+    "name": "Strategy Pattern Refactoring",
+    "source_cli": ["gemini", "codex"],
+    "feasibility": 0.88,
+    "effort": "medium",
+    "risk": "low",
+    "summary": "Extract payment gateway interface, implement strategy pattern for multi-gateway support"
+  },
+  "implementation_plan": {
+    "approach": "Define interface → Create concrete strategies → Implement factory → Migrate existing code",
+    "tasks": [
+      {"id": "T1", "name": "Define PaymentGateway interface", "depends_on": [], "files": [{"file": "src/types/payment.ts", "line": 1, "action": "create"}], "key_point": "Include all existing Stripe methods"},
+      {"id": "T2", "name": "Implement StripeGateway", "depends_on": ["T1"], "files": [{"file": "src/payment/stripe.ts", "line": 1, "action": "create"}], "key_point": "Wrap existing logic"},
+      {"id": "T3", "name": "Create GatewayFactory", "depends_on": ["T1"], "files": [{"file": "src/payment/factory.ts", "line": 1, "action": "create"}], "key_point": null},
+      {"id": "T4", "name": "Migrate processor to use factory", "depends_on": ["T2", "T3"], "files": [{"file": "src/payment/processor.ts", "line": 45, "action": "modify"}], "key_point": "Backward compatible"}
+    ],
+    "execution_flow": "T1 → (T2 | T3) → T4",
+    "milestones": ["Interface defined", "Gateway implementations complete", "Migration done"]
+  },
+  "dependencies": {
+    "internal": ["@/lib/payment-gateway", "@/types/payment"],
+    "external": ["stripe@^14.0.0"]
+  },
+  "technical_concerns": ["Existing tests must pass", "No breaking API changes"],
+  "consensus": {
+    "agreements": ["Use strategy pattern", "Keep existing API"],
+    "resolved_conflicts": "Factory over DI for simpler integration"
+  },
+  "constraints": ["backward compatible", "no breaking changes to PaymentResult type"],
+  "task_description": "Refactor payment processing for multi-gateway support",
+  "session_id": "MCP-payment-refactor-2026-01-14"
+}
+```
+
+**Step 2: Invoke Planning Agent**:
+```javascript
+Task({
+  subagent_type: "cli-lite-planning-agent",
+  run_in_background: false,
+  description: "Generate implementation plan",
+  prompt: `
+## Schema Reference
+Execute: cat ~/.claude/workflows/cli-templates/schemas/plan-json-schema.json
+
+## Context-Package (from orchestrator)
+${JSON.stringify(contextPackage, null, 2)}
+
+## Execution Process
+1. Read plan-json-schema.json for output structure
+2. Read project-tech.json and project-guidelines.json
+3. Parse context-package fields:
+   - solution: name, feasibility, summary
+   - implementation_plan: tasks[], execution_flow, milestones
+   - dependencies: internal[], external[]
+   - technical_concerns: risks/blockers
+   - consensus: agreements, resolved_conflicts
+   - constraints: user requirements
+4. Use implementation_plan.tasks[] as task foundation
+5. Preserve task dependencies (depends_on) and execution_flow
+6. Expand tasks with detailed acceptance criteria
+7. Generate plan.json following schema exactly
+
+## Output
+- ${sessionFolder}/plan.json
+
+## Completion Checklist
+- [ ] plan.json preserves task dependencies from implementation_plan
+- [ ] Task execution order follows execution_flow
+- [ ] Key_points reflected in task descriptions
+- [ ] User constraints applied to implementation
+- [ ] Acceptance criteria are testable
+- [ ] Schema fields match plan-json-schema.json exactly
+`
+})
+```
+
+**Step 3: Build executionContext**:
+```javascript
+// After plan.json is generated by cli-lite-planning-agent
+const plan = JSON.parse(Read(`${sessionFolder}/plan.json`))
+
+// Build executionContext (same structure as lite-plan)
+executionContext = {
+  planObject: plan,
+  explorationsContext: null,  // Multi-CLI doesn't use exploration files
+  explorationAngles: [],      // No exploration angles
+  explorationManifest: null,  // No manifest
+  clarificationContext: null,  // Store user feedback from Phase 2 if exists
+  executionMethod: userSelection.execution_method,  // From Phase 4
+  codeReviewTool: userSelection.code_review_tool,   // From Phase 4
+  originalUserInput: taskDescription,
+
+  // Optional: Task-level executor assignments
+  executorAssignments: null,  // Could be enhanced in future
+
+  session: {
+    id: sessionId,
+    folder: sessionFolder,
+    artifacts: {
+      explorations: [],  // No explorations in multi-CLI workflow
+      explorations_manifest: null,
+      plan: `${sessionFolder}/plan.json`,
+      synthesis_rounds: Array.from({length: currentRound}, (_, i) =>
+        `${sessionFolder}/rounds/${i+1}/synthesis.json`
+      ),
+      context_package: `${sessionFolder}/context-package.json`
+    }
+  }
+}
+```
+
+**Step 4: Hand off to Execution**:
+```javascript
+// Execute to lite-execute with in-memory context
+SlashCommand("/workflow:lite-execute --in-memory")
+```
+
+## Output File Structure
+
+```
+.workflow/.multi-cli-plan/{MCP-task-slug-YYYY-MM-DD}/
+├── session-state.json          # Session tracking (orchestrator)
+├── rounds/
+│   ├── 1/synthesis.json        # Round 1 analysis (cli-discuss-agent)
+│   ├── 2/synthesis.json        # Round 2 analysis (cli-discuss-agent)
+│   └── .../
+├── context-package.json        # Extracted context for planning (orchestrator)
+└── plan.json                   # Structured plan (cli-lite-planning-agent)
+```
+
+**File Producers**:
+
+| File | Producer | Content |
+|------|----------|---------|
+| `session-state.json` | Orchestrator | Session metadata, rounds, decisions |
+| `rounds/*/synthesis.json` | cli-discuss-agent | Solutions, convergence, cross-verification |
+| `context-package.json` | Orchestrator | Extracted solution, dependencies, consensus for planning |
+| `plan.json` | cli-lite-planning-agent | Structured tasks for lite-execute |
+
+## synthesis.json Schema
+
+```json
+{
+  "round": 1,
+  "solutions": [{
+    "name": "Solution Name",
+    "source_cli": ["gemini", "codex"],
+    "feasibility": 0.85,
+    "effort": "low|medium|high",
+    "risk": "low|medium|high",
+    "summary": "Brief analysis summary",
+    "implementation_plan": {
+      "approach": "High-level technical approach",
+      "tasks": [
+        {"id": "T1", "name": "Task", "depends_on": [], "files": [], "key_point": "..."}
+      ],
+      "execution_flow": "T1 → T2 → T3",
+      "milestones": ["Checkpoint 1", "Checkpoint 2"]
+    },
+    "dependencies": {"internal": [], "external": []},
+    "technical_concerns": ["Risk 1", "Blocker 2"]
+  }],
+  "convergence": {
+    "score": 0.85,
+    "new_insights": false,
+    "recommendation": "converged|continue|user_input_needed"
+  },
+  "cross_verification": {
+    "agreements": [],
+    "disagreements": [],
+    "resolution": "..."
+  },
+  "clarification_questions": []
+}
+```
+
+**Key Planning Fields**:
+
+| Field | Purpose |
+|-------|---------|
+| `feasibility` | Viability score (0-1) |
+| `implementation_plan.tasks[]` | Discrete tasks with dependencies |
+| `implementation_plan.execution_flow` | Task sequence visualization |
+| `implementation_plan.milestones` | Key checkpoints |
+| `technical_concerns` | Risks and blockers |
+
+**Note**: Solutions ranked by internal scoring (array order = priority)
+
+## TodoWrite Structure
+
+**Initialization**:
+```javascript
+TodoWrite({ todos: [
+  { content: "Phase 1: Context Gathering", status: "in_progress", activeForm: "Gathering context" },
+  { content: "Phase 2: Multi-CLI Discussion", status: "pending", activeForm: "Running discussion" },
+  { content: "Phase 3: Present Options", status: "pending", activeForm: "Presenting options" },
+  { content: "Phase 4: User Decision", status: "pending", activeForm: "Awaiting decision" },
+  { content: "Phase 5: Plan Generation", status: "pending", activeForm: "Generating plan" }
+]})
+```
+
+**During Discussion Rounds**:
+```javascript
+TodoWrite({ todos: [
+  { content: "Phase 1: Context Gathering", status: "completed", activeForm: "Gathering context" },
+  { content: "Phase 2: Multi-CLI Discussion", status: "in_progress", activeForm: "Running discussion" },
+  { content: "  → Round 1: Initial analysis", status: "completed", activeForm: "Analyzing" },
+  { content: "  → Round 2: Deep verification", status: "in_progress", activeForm: "Verifying" },
+  { content: "Phase 3: Present Options", status: "pending", activeForm: "Presenting options" },
+  // ...
+]})
+```
+
+## Error Handling
+
+| Error | Resolution |
+|-------|------------|
+| ACE search fails | Fall back to Glob/Grep for file discovery |
+| Agent fails | Retry once, then present partial results |
+| CLI timeout (in agent) | Agent uses fallback: gemini → codex → claude |
+| No convergence | Present best options, flag uncertainty |
+| synthesis.json parse error | Request agent retry |
+| User cancels | Save session for later resumption |
+
+## Configuration
+
+| Flag | Default | Description |
+|------|---------|-------------|
+| `--max-rounds` | 3 | Maximum discussion rounds |
+| `--tools` | gemini,codex | CLI tools for analysis |
+| `--mode` | parallel | Execution mode: parallel or serial |
+| `--auto-execute` | false | Auto-execute after approval |
+
+## Best Practices
+
+1. **Be Specific**: Detailed task descriptions improve ACE context quality
+2. **Provide Feedback**: Use clarification rounds to refine requirements
+3. **Trust Cross-Verification**: Multi-CLI consensus indicates high confidence
+4. **Review Trade-offs**: Consider pros/cons before selecting solution
+5. **Check synthesis.json**: Review agent output for detailed analysis
+6. **Iterate When Needed**: Don't hesitate to request more analysis
+
+## Related Commands
+
+```bash
+# Simpler single-round planning
+/workflow:lite-plan "task description"
+
+# Issue-driven discovery
+/issue:discover-by-prompt "find issues"
+
+# View session files
+cat .workflow/.multi-cli-plan/{session-id}/plan.json
+cat .workflow/.multi-cli-plan/{session-id}/rounds/1/synthesis.json
+cat .workflow/.multi-cli-plan/{session-id}/context-package.json
+
+# Direct execution (if you have plan.json)
+/workflow:lite-execute plan.json
+```

.claude/commands/workflow/plan.md

@@ -9,7 +9,7 @@ allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*)
 
 ## Coordinator Role
 
-**This command is a pure orchestrator**: Dispatch 5 slash commands in sequence (including a quality gate), parse their outputs, pass context between them, and ensure complete execution through **automatic continuation**.
+**This command is a pure orchestrator**: Execute 5 slash commands in sequence (including a quality gate), parse their outputs, pass context between them, and ensure complete execution through **automatic continuation**.
 
 **Execution Model - Auto-Continue Workflow with Quality Gate**:
 
@@ -17,14 +17,14 @@ This workflow runs **fully autonomously** once triggered. Phase 3 (conflict reso
 
 
 1. **User triggers**: `/workflow:plan "task"`
-2. **Phase 1 dispatches** → Session discovery → Auto-continues
-3. **Phase 2 dispatches** → Context gathering → Auto-continues
-4. **Phase 3 dispatches** (optional, if conflict_risk ≥ medium) → Conflict resolution → Auto-continues
-5. **Phase 4 dispatches** → Task generation (task-generate-agent) → Reports final summary
+2. **Phase 1 executes** → Session discovery → Auto-continues
+3. **Phase 2 executes** → Context gathering → Auto-continues
+4. **Phase 3 executes** (optional, if conflict_risk ≥ medium) → Conflict resolution → Auto-continues
+5. **Phase 4 executes** → Task generation (task-generate-agent) → Reports final summary
 
 **Task Attachment Model**:
-- SlashCommand dispatch **expands workflow** by attaching sub-tasks to current TodoWrite
-- When a sub-command is dispatched (e.g., `/workflow:tools:context-gather`), its internal tasks are attached to the orchestrator's TodoWrite
+- SlashCommand execute **expands workflow** by attaching sub-tasks to current TodoWrite
+- When a sub-command is executed (e.g., `/workflow:tools:context-gather`), its internal tasks are attached to the orchestrator's TodoWrite
 - Orchestrator **executes these attached tasks** sequentially
 - After completion, attached tasks are **collapsed** back to high-level phase summary
 - This is **task expansion**, not external delegation
@@ -43,7 +43,7 @@ This workflow runs **fully autonomously** once triggered. Phase 3 (conflict reso
 3. **Parse Every Output**: Extract required data from each command/agent output for next phase
 4. **Auto-Continue via TodoList**: Check TodoList status to execute next pending phase automatically
 5. **Track Progress**: Update TodoWrite dynamically with task attachment/collapse pattern
-6. **Task Attachment Model**: SlashCommand dispatch **attaches** sub-tasks to current workflow. Orchestrator **executes** these attached tasks itself, then **collapses** them after completion
+6. **Task Attachment Model**: SlashCommand execute **attaches** sub-tasks to current workflow. Orchestrator **executes** these attached tasks itself, then **collapses** them after completion
 7. **⚠️ CRITICAL: DO NOT STOP**: Continuous multi-phase workflow. After executing all attached tasks, immediately collapse them and execute next phase
 
 ## Execution Process
@@ -80,7 +80,7 @@ Return:
 
 ### Phase 1: Session Discovery
 
-**Step 1.1: Dispatch** - Create or discover workflow session
+**Step 1.1: Execute** - Create or discover workflow session
 
 ```javascript
 SlashCommand(command="/workflow:session:start --auto \"[structured-task-description]\"")
@@ -117,7 +117,7 @@ CONTEXT: Existing user database schema, REST API endpoints
 
 ### Phase 2: Context Gathering
 
-**Step 2.1: Dispatch** - Gather project context and analyze codebase
+**Step 2.1: Execute** - Gather project context and analyze codebase
 
 ```javascript
 SlashCommand(command="/workflow:tools:context-gather --session [sessionId] \"[structured-task-description]\"")
@@ -135,9 +135,9 @@ SlashCommand(command="/workflow:tools:context-gather --session [sessionId] \"[st
 - Context package path extracted
 - File exists and is valid JSON
 
-<!-- TodoWrite: When context-gather dispatched, INSERT 3 context-gather tasks, mark first as in_progress -->
+<!-- TodoWrite: When context-gather executed, INSERT 3 context-gather tasks, mark first as in_progress -->
 
-**TodoWrite Update (Phase 2 SlashCommand dispatched - tasks attached)**:
+**TodoWrite Update (Phase 2 SlashCommand executed - tasks attached)**:
 ```json
 [
   {"content": "Phase 1: Session Discovery", "status": "completed", "activeForm": "Executing session discovery"},
@@ -149,7 +149,7 @@ SlashCommand(command="/workflow:tools:context-gather --session [sessionId] \"[st
 ]
 ```
 
-**Note**: SlashCommand dispatch **attaches** context-gather's 3 tasks. Orchestrator **executes** these tasks sequentially.
+**Note**: SlashCommand execute **attaches** context-gather's 3 tasks. Orchestrator **executes** these tasks sequentially.
 
 <!-- TodoWrite: After Phase 2 tasks complete, REMOVE Phase 2.1-2.3, restore to orchestrator view -->
 
@@ -172,7 +172,7 @@ SlashCommand(command="/workflow:tools:context-gather --session [sessionId] \"[st
 
 **Trigger**: Only execute when context-package.json indicates conflict_risk is "medium" or "high"
 
-**Step 3.1: Dispatch** - Detect and resolve conflicts with CLI analysis
+**Step 3.1: Execute** - Detect and resolve conflicts with CLI analysis
 
 ```javascript
 SlashCommand(command="/workflow:tools:conflict-resolution --session [sessionId] --context [contextPath]")
@@ -196,7 +196,7 @@ SlashCommand(command="/workflow:tools:conflict-resolution --session [sessionId]
 
 <!-- TodoWrite: If conflict_risk ≥ medium, INSERT 3 conflict-resolution tasks -->
 
-**TodoWrite Update (Phase 3 SlashCommand dispatched - tasks attached, if conflict_risk ≥ medium)**:
+**TodoWrite Update (Phase 3 SlashCommand executed - tasks attached, if conflict_risk ≥ medium)**:
 ```json
 [
   {"content": "Phase 1: Session Discovery", "status": "completed", "activeForm": "Executing session discovery"},
@@ -209,7 +209,7 @@ SlashCommand(command="/workflow:tools:conflict-resolution --session [sessionId]
 ]
 ```
 
-**Note**: SlashCommand dispatch **attaches** conflict-resolution's 3 tasks. Orchestrator **executes** these tasks sequentially.
+**Note**: SlashCommand execute **attaches** conflict-resolution's 3 tasks. Orchestrator **executes** these tasks sequentially.
 
 <!-- TodoWrite: After Phase 3 tasks complete, REMOVE Phase 3.1-3.3, restore to orchestrator view -->
 
@@ -231,7 +231,7 @@ SlashCommand(command="/workflow:tools:conflict-resolution --session [sessionId]
 - Evaluate current context window usage and memory state
 - If memory usage is high (>120K tokens or approaching context limits):
 
-  **Step 3.2: Dispatch** - Optimize memory before proceeding
+  **Step 3.2: Execute** - Optimize memory before proceeding
 
   ```javascript
   SlashCommand(command="/compact")
@@ -270,7 +270,7 @@ SlashCommand(command="/workflow:tools:conflict-resolution --session [sessionId]
 - Task generation translates high-level role analyses into concrete, actionable work items
 - **Intent priority**: Current user prompt > role analysis.md files > guidance-specification.md
 
-**Step 4.1: Dispatch** - Generate implementation plan and task JSONs
+**Step 4.1: Execute** - Generate implementation plan and task JSONs
 
 ```javascript
 SlashCommand(command="/workflow:tools:task-generate-agent --session [sessionId]")
@@ -285,9 +285,9 @@ SlashCommand(command="/workflow:tools:task-generate-agent --session [sessionId]"
 - `.workflow/active/[sessionId]/.task/IMPL-*.json` exists (at least one)
 - `.workflow/active/[sessionId]/TODO_LIST.md` exists
 
-<!-- TodoWrite: When task-generate-agent dispatched, ATTACH 1 agent task -->
+<!-- TodoWrite: When task-generate-agent executed, ATTACH 1 agent task -->
 
-**TodoWrite Update (Phase 4 SlashCommand dispatched - agent task attached)**:
+**TodoWrite Update (Phase 4 SlashCommand executed - agent task attached)**:
 ```json
 [
   {"content": "Phase 1: Session Discovery", "status": "completed", "activeForm": "Executing session discovery"},
@@ -331,7 +331,7 @@ Quality Gate: Consider running /workflow:action-plan-verify to catch issues earl
 
 ### Key Principles
 
-1. **Task Attachment** (when SlashCommand dispatched):
+1. **Task Attachment** (when SlashCommand executed):
    - Sub-command's internal tasks are **attached** to orchestrator's TodoWrite
    - **Phase 2, 3**: Multiple sub-tasks attached (e.g., Phase 2.1, 2.2, 2.3)
    - **Phase 4**: Single agent task attached (e.g., "Execute task-generate-agent")
@@ -350,7 +350,7 @@ Quality Gate: Consider running /workflow:action-plan-verify to catch issues earl
    - No user intervention required between phases
    - TodoWrite dynamically reflects current execution state
 
-**Lifecycle Summary**: Initial pending tasks → Phase dispatched (tasks ATTACHED) → Sub-tasks executed sequentially → Phase completed (tasks COLLAPSED to summary for Phase 2/3, or marked completed for Phase 4) → Next phase begins → Repeat until all phases complete.
+**Lifecycle Summary**: Initial pending tasks → Phase executed (tasks ATTACHED) → Sub-tasks executed sequentially → Phase completed (tasks COLLAPSED to summary for Phase 2/3, or marked completed for Phase 4) → Next phase begins → Repeat until all phases complete.
 
 
 
@@ -442,7 +442,7 @@ User triggers: /workflow:plan "Build authentication system"
 Phase 1: Session Discovery
   → sessionId extracted
   ↓
-Phase 2: Context Gathering (SlashCommand dispatched)
+Phase 2: Context Gathering (SlashCommand executed)
   → ATTACH 3 sub-tasks: ← ATTACHED
     - → Analyze codebase structure
     - → Identify integration points
@@ -453,7 +453,7 @@ Phase 2: Context Gathering (SlashCommand dispatched)
   ↓
 Conditional Branch: Check conflict_risk
   ├─ IF conflict_risk ≥ medium:
-  │   Phase 3: Conflict Resolution (SlashCommand dispatched)
+  │   Phase 3: Conflict Resolution (SlashCommand executed)
   │     → ATTACH 3 sub-tasks: ← ATTACHED
   │       - → Detect conflicts with CLI analysis
   │       - → Present conflicts to user
@@ -463,7 +463,7 @@ Conditional Branch: Check conflict_risk
   │
   └─ ELSE: Skip Phase 3, proceed to Phase 4
   ↓
-Phase 4: Task Generation (SlashCommand dispatched)
+Phase 4: Task Generation (SlashCommand executed)
   → Single agent task (no sub-tasks)
   → Agent autonomously completes internally:
     (discovery → planning → output)
@@ -473,12 +473,12 @@ Return summary to user
 ```
 
 **Key Points**:
-- **← ATTACHED**: Tasks attached to TodoWrite when SlashCommand dispatched
+- **← ATTACHED**: Tasks attached to TodoWrite when SlashCommand executed
   - Phase 2, 3: Multiple sub-tasks
   - Phase 4: Single agent task
 - **← COLLAPSED**: Sub-tasks collapsed to summary after completion (Phase 2, 3 only)
 - **Phase 4**: Single agent task, no collapse (just mark completed)
-- **Conditional Branch**: Phase 3 only dispatches if conflict_risk ≥ medium
+- **Conditional Branch**: Phase 3 only executes if conflict_risk ≥ medium
 - **Continuous Flow**: No user intervention between phases
 
 ## Error Handling

.claude/commands/workflow/review-fix.md

@@ -585,6 +585,10 @@ TodoWrite({
 - Mark completed immediately after each group finishes
 - Update parent phase status when all child items complete
 
+## Post-Completion Expansion
+
+完成后询问用户是否扩展为issue(test/enhance/refactor/doc)，选中项调用 `/issue:new "{summary} - {dimension}"`
+
 ## Best Practices
 
 1. **Trust AI Planning**: Planning agent's grouping and execution strategy are based on dependency analysis

.claude/commands/workflow/review.md

@@ -1,7 +1,7 @@
 ---
 name: review
 description: Post-implementation review with specialized types (security/architecture/action-items/quality) using analysis agents and Gemini
-argument-hint: "[--type=security|architecture|action-items|quality] [optional: session-id]"
+argument-hint: "[--type=security|architecture|action-items|quality] [--archived] [optional: session-id]"
 ---
 
 ## Command Overview: /workflow:review
@@ -34,15 +34,17 @@ argument-hint: "[--type=security|architecture|action-items|quality] [optional: s
 ```
 Input Parsing:
    ├─ Parse --type flag (default: quality)
+   ├─ Parse --archived flag (search in archives)
    └─ Parse session-id argument (optional)
 
 Step 1: Session Resolution
    └─ Decision:
-      ├─ session-id provided → Use provided session
+      ├─ session-id provided + --archived → Search .workflow/archives/
+      ├─ session-id provided → Search .workflow/active/ first, then archives
       └─ Not provided → Auto-detect from .workflow/active/
 
 Step 2: Validation
-   ├─ Check session directory exists
+   ├─ Check session directory exists (active or archived)
    └─ Check for completed implementation (.summaries/IMPL-*.md exists)
 
 Step 3: Type Check
@@ -68,21 +70,29 @@ Step 5: Generate Report
 #!/bin/bash
 # Optional specialized review for completed implementation
 
-# Step 1: Session ID resolution
+# Step 1: Session ID resolution and location detection
 if [ -n "$SESSION_ARG" ]; then
     sessionId="$SESSION_ARG"
 else
     sessionId=$(find .workflow/active/ -name "WFS-*" -type d | head -1 | xargs basename)
 fi
 
-# Step 2: Validation
-if [ ! -d ".workflow/active/${sessionId}" ]; then
-    echo "Session ${sessionId} not found"
+# Step 2: Resolve session path (active or archived)
+# Priority: --archived flag → active → archives
+if [ -n "$ARCHIVED_FLAG" ]; then
+    sessionPath=".workflow/archives/${sessionId}"
+elif [ -d ".workflow/active/${sessionId}" ]; then
+    sessionPath=".workflow/active/${sessionId}"
+elif [ -d ".workflow/archives/${sessionId}" ]; then
+    sessionPath=".workflow/archives/${sessionId}"
+    echo "Note: Session found in archives, running review on archived session"
+else
+    echo "Session ${sessionId} not found in active or archives"
     exit 1
 fi
 
 # Check for completed tasks
-if [ ! -d ".workflow/active/${sessionId}/.summaries" ] || [ -z "$(find .workflow/active/${sessionId}/.summaries/ -name "IMPL-*.md" -type f 2>/dev/null)" ]; then
+if [ ! -d "${sessionPath}/.summaries" ] || [ -z "$(find ${sessionPath}/.summaries/ -name "IMPL-*.md" -type f 2>/dev/null)" ]; then
     echo "No completed implementation found. Complete implementation first"
     exit 1
 fi
@@ -113,17 +123,17 @@ After bash validation, the model takes control to:
 1. **Load Context**: Read completed task summaries and changed files
    ```bash
    # Load implementation summaries (iterate through .summaries/ directory)
-   for summary in .workflow/active/${sessionId}/.summaries/*.md; do
+   for summary in ${sessionPath}/.summaries/*.md; do
      cat "$summary"
    done
 
    # Load test results (if available)
-   for test_summary in .workflow/active/${sessionId}/.summaries/TEST-FIX-*.md 2>/dev/null; do
+   for test_summary in ${sessionPath}/.summaries/TEST-FIX-*.md 2>/dev/null; do
      cat "$test_summary"
    done
 
    # Get changed files
-   git log --since="$(cat .workflow/active/${sessionId}/workflow-session.json | jq -r .created_at)" --name-only --pretty=format: | sort -u
+   git log --since="$(cat ${sessionPath}/workflow-session.json | jq -r .created_at)" --name-only --pretty=format: | sort -u
    ```
 
 2. **Perform Specialized Review**: Based on `review_type`
@@ -142,7 +152,7 @@ After bash validation, the model takes control to:
      CONTEXT: @.summaries/IMPL-*.md,../.. @../../project-tech.json @../../project-guidelines.json
      EXPECTED: Security findings report with severity levels
      RULES: Focus on OWASP Top 10, authentication, authorization, data validation, injection risks
-     " --tool gemini --mode write --cd .workflow/active/${sessionId}
+     " --tool gemini --mode write --cd ${sessionPath}
      ```
 
    **Architecture Review** (`--type=architecture`):
@@ -154,7 +164,7 @@ After bash validation, the model takes control to:
      CONTEXT: @.summaries/IMPL-*.md,../.. @../../project-tech.json @../../project-guidelines.json
      EXPECTED: Architecture assessment with recommendations
      RULES: Check for patterns, separation of concerns, modularity, scalability
-     " --tool qwen --mode write --cd .workflow/active/${sessionId}
+     " --tool qwen --mode write --cd ${sessionPath}
      ```
 
    **Quality Review** (`--type=quality`):
@@ -166,14 +176,14 @@ After bash validation, the model takes control to:
      CONTEXT: @.summaries/IMPL-*.md,../.. @../../project-tech.json @../../project-guidelines.json
      EXPECTED: Quality assessment with improvement suggestions
      RULES: Check for code smells, duplication, complexity, naming conventions
-     " --tool gemini --mode write --cd .workflow/active/${sessionId}
+     " --tool gemini --mode write --cd ${sessionPath}
      ```
 
    **Action Items Review** (`--type=action-items`):
    - Verify all requirements and acceptance criteria met:
      ```bash
      # Load task requirements and acceptance criteria
-     for task_file in .workflow/active/${sessionId}/.task/*.json; do
+     for task_file in ${sessionPath}/.task/*.json; do
        cat "$task_file" | jq -r '
          "Task: " + .id + "\n" +
          "Requirements: " + (.context.requirements | join(", ")) + "\n" +
@@ -196,7 +206,7 @@ After bash validation, the model takes control to:
      - Verify all acceptance criteria are met
      - Flag any incomplete or missing action items
      - Assess deployment readiness
-     " --tool gemini --mode write --cd .workflow/active/${sessionId}
+     " --tool gemini --mode write --cd ${sessionPath}
      ```
 
 
@@ -234,7 +244,7 @@ After bash validation, the model takes control to:
 4. **Output Files**:
    ```bash
    # Save review report
-   Write(.workflow/active/${sessionId}/REVIEW-${review_type}.md)
+   Write(${sessionPath}/REVIEW-${review_type}.md)
 
    # Update session metadata
    # (optional) Update workflow-session.json with review status
@@ -261,6 +271,12 @@ After bash validation, the model takes control to:
 # Architecture review for specific session
 /workflow:review --type=architecture WFS-payment-integration
 
+# Review an archived session (auto-detects if not in active)
+/workflow:review --type=security WFS-old-feature
+
+# Explicitly review archived session
+/workflow:review --archived --type=quality WFS-completed-feature
+
 # Documentation review
 /workflow:review --type=docs
 ```
@@ -270,6 +286,7 @@ After bash validation, the model takes control to:
 - **Simple Validation**: Check session exists and has completed tasks
 - **No Complex Orchestration**: Direct analysis, no multi-phase pipeline
 - **Specialized Reviews**: Different prompts and tools for different review types
+- **Archived Session Support**: Review archived sessions with `--archived` flag or auto-detection
 - **MCP Integration**: Fast code search for security and architecture patterns
 - **CLI Tool Integration**: Gemini for analysis, Qwen for architecture
 - **Structured Output**: Markdown reports with severity levels and action items
@@ -295,3 +312,11 @@ Optional Review (when needed):
 - Regular development (tests are sufficient)
 - Simple bug fixes (test-fix-agent handles it)
 - Minor changes (update-memory-related is enough)
+
+## Post-Review Action
+
+After review completion, prompt user:
+```
+Review complete. Would you like to complete and archive this session?
+→ Run /workflow:session:complete to archive with lessons learned
+```

.claude/commands/workflow/session/complete.md

@@ -107,13 +107,13 @@ rm -f .workflow/archives/$SESSION_ID/.archiving
   Manifest: Updated with N total sessions
 ```
 
-### Phase 4: Update project.json (Optional)
+### Phase 4: Update project-tech.json (Optional)
 
-**Skip if**: `.workflow/project.json` doesn't exist
+**Skip if**: `.workflow/project-tech.json` doesn't exist
 
 ```bash
 # Check
-test -f .workflow/project.json || echo "SKIP"
+test -f .workflow/project-tech.json || echo "SKIP"
 ```
 
 **If exists**, add feature entry:
@@ -134,6 +134,32 @@ test -f .workflow/project.json || echo "SKIP"
 ✓ Feature added to project registry
 ```
 
+### Phase 5: Ask About Solidify (Always)
+
+After successful archival, prompt user to capture learnings:
+
+```javascript
+AskUserQuestion({
+  questions: [{
+    question: "Would you like to solidify learnings from this session into project guidelines?",
+    header: "Solidify",
+    options: [
+      { label: "Yes, solidify now", description: "Extract learnings and update project-guidelines.json" },
+      { label: "Skip", description: "Archive complete, no learnings to capture" }
+    ],
+    multiSelect: false
+  }]
+})
+```
+
+**If "Yes, solidify now"**: Execute `/workflow:session:solidify` with the archived session ID.
+
+**Output**:
+```
+Session archived successfully.
+→ Run /workflow:session:solidify to capture learnings (recommended)
+```
+
 ## Error Recovery
 
 | Phase | Symptom | Recovery |
@@ -149,5 +175,6 @@ test -f .workflow/project.json || echo "SKIP"
 Phase 1: find session → create .archiving marker
 Phase 2: read key files → build manifest entry (no writes)
 Phase 3: mkdir → mv → update manifest.json → rm marker
-Phase 4: update project.json features array (optional)
+Phase 4: update project-tech.json features array (optional)
+Phase 5: ask user → solidify learnings (optional)
 ```

.claude/commands/workflow/session/start.md

@@ -16,7 +16,7 @@ examples:
 Manages workflow sessions with three operation modes: discovery (manual), auto (intelligent), and force-new.
 
 **Dual Responsibility**:
-1. **Project-level initialization** (first-time only): Creates `.workflow/project.json` for feature registry
+1. **Project-level initialization** (first-time only): Creates `.workflow/project-tech.json` for feature registry
 2. **Session-level initialization** (always): Creates session directory structure
 
 ## Session Types

.claude/commands/workflow/tdd-plan.md

@@ -9,39 +9,77 @@ allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*)
 
 ## Coordinator Role
 
-**This command is a pure orchestrator**: Dispatches 6 slash commands in sequence, parse outputs, pass context, and ensure complete TDD workflow creation with Red-Green-Refactor task generation.
+**This command is a pure orchestrator**: Executes 6 slash commands in sequence, parse outputs, pass context, and ensure complete TDD workflow creation with Red-Green-Refactor task generation.
 
 **CLI Tool Selection**: CLI tool usage is determined semantically from user's task description. Include "use Codex/Gemini/Qwen" in your request for CLI execution.
 
 **Task Attachment Model**:
-- SlashCommand dispatch **expands workflow** by attaching sub-tasks to current TodoWrite
-- When dispatching a sub-command (e.g., `/workflow:tools:test-context-gather`), its internal tasks are attached to the orchestrator's TodoWrite
+- SlashCommand execute **expands workflow** by attaching sub-tasks to current TodoWrite
+- When executing a sub-command (e.g., `/workflow:tools:test-context-gather`), its internal tasks are attached to the orchestrator's TodoWrite
 - Orchestrator **executes these attached tasks** sequentially
 - After completion, attached tasks are **collapsed** back to high-level phase summary
 - This is **task expansion**, not external delegation
 
 **Auto-Continue Mechanism**:
 - TodoList tracks current phase status and dynamically manages task attachment/collapse
-- When each phase finishes executing, automatically dispatch next pending phase
+- When each phase finishes executing, automatically execute next pending phase
 - All phases run autonomously without user interaction
 - **⚠️ CONTINUOUS EXECUTION** - Do not stop until all phases complete
 
 ## Core Rules
 
-1. **Start Immediately**: First action is TodoWrite initialization, second action is dispatch Phase 1
+1. **Start Immediately**: First action is TodoWrite initialization, second action is execute Phase 1
 2. **No Preliminary Analysis**: Do not read files before Phase 1
 3. **Parse Every Output**: Extract required data for next phase
-4. **Auto-Continue via TodoList**: Check TodoList status to dispatch next pending phase automatically
+4. **Auto-Continue via TodoList**: Check TodoList status to execute next pending phase automatically
 5. **Track Progress**: Update TodoWrite dynamically with task attachment/collapse pattern
 6. **TDD Context**: All descriptions include "TDD:" prefix
-7. **Task Attachment Model**: SlashCommand dispatch **attaches** sub-tasks to current workflow. Orchestrator **executes** these attached tasks itself, then **collapses** them after completion
-8. **⚠️ CRITICAL: DO NOT STOP**: Continuous multi-phase workflow. After executing all attached tasks, immediately collapse them and dispatch next phase
+7. **Task Attachment Model**: SlashCommand execute **attaches** sub-tasks to current workflow. Orchestrator **executes** these attached tasks itself, then **collapses** them after completion
+8. **⚠️ CRITICAL: DO NOT STOP**: Continuous multi-phase workflow. After executing all attached tasks, immediately collapse them and execute next phase
+
+## TDD Compliance Requirements
+
+### The Iron Law
+
+```
+NO PRODUCTION CODE WITHOUT A FAILING TEST FIRST
+```
+
+**Enforcement Method**:
+- Phase 5: `implementation_approach` includes test-first steps (Red → Green → Refactor)
+- Green phase: Includes test-fix-cycle configuration (max 3 iterations)
+- Auto-revert: Triggered when max iterations reached without passing tests
+
+**Verification**: Phase 6 validates Red-Green-Refactor structure in all generated tasks
+
+### TDD Compliance Checkpoint
+
+| Checkpoint | Validation Phase | Evidence Required |
+|------------|------------------|-------------------|
+| Test-first structure | Phase 5 | `implementation_approach` has 3 steps |
+| Red phase exists | Phase 6 | Step 1: `tdd_phase: "red"` |
+| Green phase with test-fix | Phase 6 | Step 2: `tdd_phase: "green"` + test-fix-cycle |
+| Refactor phase exists | Phase 6 | Step 3: `tdd_phase: "refactor"` |
+
+### Core TDD Principles (from ref skills)
+
+**Red Flags - STOP and Reassess**:
+- Code written before test
+- Test passes immediately (no Red phase witnessed)
+- Cannot explain why test should fail
+- "Just this once" rationalization
+- "Tests after achieve same goals" thinking
+
+**Why Order Matters**:
+- Tests written after code pass immediately → proves nothing
+- Test-first forces edge case discovery before implementation
+- Tests-after verify what was built, not what's required
 
 ## 6-Phase Execution (with Conflict Resolution)
 
 ### Phase 1: Session Discovery
 
-**Step 1.1: Dispatch** - Session discovery and initialization
+**Step 1.1: Execute** - Session discovery and initialization
 
 ```javascript
 SlashCommand(command="/workflow:session:start --type tdd --auto \"TDD: [structured-description]\"")
@@ -66,7 +104,7 @@ TEST_FOCUS: [Test scenarios]
 
 ### Phase 2: Context Gathering
 
-**Step 2.1: Dispatch** - Context gathering and analysis
+**Step 2.1: Execute** - Context gathering and analysis
 
 ```javascript
 SlashCommand(command="/workflow:tools:context-gather --session [sessionId] \"TDD: [structured-description]\"")
@@ -92,7 +130,7 @@ SlashCommand(command="/workflow:tools:context-gather --session [sessionId] \"TDD
 
 ### Phase 3: Test Coverage Analysis
 
-**Step 3.1: Dispatch** - Test coverage analysis and framework detection
+**Step 3.1: Execute** - Test coverage analysis and framework detection
 
 ```javascript
 SlashCommand(command="/workflow:tools:test-context-gather --session [sessionId]")
@@ -108,9 +146,9 @@ SlashCommand(command="/workflow:tools:test-context-gather --session [sessionId]"
 
 
 
-<!-- TodoWrite: When test-context-gather dispatched, INSERT 3 test-context-gather tasks -->
+<!-- TodoWrite: When test-context-gather executed, INSERT 3 test-context-gather tasks -->
 
-**TodoWrite Update (Phase 3 SlashCommand dispatched - tasks attached)**:
+**TodoWrite Update (Phase 3 SlashCommand executed - tasks attached)**:
 ```json
 [
   {"content": "Phase 1: Session Discovery", "status": "completed", "activeForm": "Executing session discovery"},
@@ -124,7 +162,7 @@ SlashCommand(command="/workflow:tools:test-context-gather --session [sessionId]"
 ]
 ```
 
-**Note**: SlashCommand dispatch **attaches** test-context-gather's 3 tasks. Orchestrator **executes** these tasks.
+**Note**: SlashCommand execute **attaches** test-context-gather's 3 tasks. Orchestrator **executes** these tasks.
 
 **Next Action**: Tasks attached → **Execute Phase 3.1-3.3** sequentially
 
@@ -151,7 +189,7 @@ SlashCommand(command="/workflow:tools:test-context-gather --session [sessionId]"
 
 **Trigger**: Only execute when context-package.json indicates conflict_risk is "medium" or "high"
 
-**Step 4.1: Dispatch** - Conflict detection and resolution
+**Step 4.1: Execute** - Conflict detection and resolution
 
 ```javascript
 SlashCommand(command="/workflow:tools:conflict-resolution --session [sessionId] --context [contextPath]")
@@ -173,9 +211,9 @@ SlashCommand(command="/workflow:tools:conflict-resolution --session [sessionId]
 - If conflict_risk is "none" or "low", skip directly to Phase 5
 - Display: "No significant conflicts detected, proceeding to TDD task generation"
 
-<!-- TodoWrite: If conflict_risk ≥ medium, INSERT 3 conflict-resolution tasks when dispatched -->
+<!-- TodoWrite: If conflict_risk ≥ medium, INSERT 3 conflict-resolution tasks when executed -->
 
-**TodoWrite Update (Phase 4 SlashCommand dispatched - tasks attached, if conflict_risk ≥ medium)**:
+**TodoWrite Update (Phase 4 SlashCommand executed - tasks attached, if conflict_risk ≥ medium)**:
 ```json
 [
   {"content": "Phase 1: Session Discovery", "status": "completed", "activeForm": "Executing session discovery"},
@@ -183,14 +221,14 @@ SlashCommand(command="/workflow:tools:conflict-resolution --session [sessionId]
   {"content": "Phase 3: Test Coverage Analysis", "status": "completed", "activeForm": "Executing test coverage analysis"},
   {"content": "Phase 4: Conflict Resolution", "status": "in_progress", "activeForm": "Executing conflict resolution"},
   {"content": "  → Detect conflicts with CLI analysis", "status": "in_progress", "activeForm": "Detecting conflicts"},
-  {"content": "  → Present conflicts to user", "status": "pending", "activeForm": "Presenting conflicts"},
+  {"content": "  → Log and analyze detected conflicts", "status": "pending", "activeForm": "Analyzing conflicts"},
   {"content": "  → Apply resolution strategies", "status": "pending", "activeForm": "Applying resolution strategies"},
   {"content": "Phase 5: TDD Task Generation", "status": "pending", "activeForm": "Executing TDD task generation"},
   {"content": "Phase 6: TDD Structure Validation", "status": "pending", "activeForm": "Validating TDD structure"}
 ]
 ```
 
-**Note**: SlashCommand dispatch **attaches** conflict-resolution's 3 tasks. Orchestrator **executes** these tasks.
+**Note**: SlashCommand execute **attaches** conflict-resolution's 3 tasks. Orchestrator **executes** these tasks.
 
 **Next Action**: Tasks attached → **Execute Phase 4.1-4.3** sequentially
 
@@ -216,7 +254,7 @@ SlashCommand(command="/workflow:tools:conflict-resolution --session [sessionId]
 - Evaluate current context window usage and memory state
 - If memory usage is high (>110K tokens or approaching context limits):
 
-  **Step 4.5: Dispatch** - Memory compaction
+  **Step 4.5: Execute** - Memory compaction
 
   ```javascript
   SlashCommand(command="/compact")
@@ -230,7 +268,7 @@ SlashCommand(command="/workflow:tools:conflict-resolution --session [sessionId]
 
 ### Phase 5: TDD Task Generation
 
-**Step 5.1: Dispatch** - TDD task generation via action-planning-agent
+**Step 5.1: Execute** - TDD task generation via action-planning-agent
 
 ```javascript
 SlashCommand(command="/workflow:tools:task-generate-tdd --session [sessionId]")
@@ -251,9 +289,16 @@ SlashCommand(command="/workflow:tools:task-generate-tdd --session [sessionId]")
 - IMPL_PLAN.md contains workflow_type: "tdd" in frontmatter
 - Task count ≤10 (compliance with task limit)
 
-<!-- TodoWrite: When task-generate-tdd dispatched, INSERT 3 task-generate-tdd tasks -->
+**Red Flag Detection** (Non-Blocking Warnings):
+- Task count >10: `⚠️ High task count may indicate insufficient decomposition`
+- Missing test-fix-cycle: `⚠️ Green phase lacks auto-revert configuration`
+- Generic task names: `⚠️ Vague task names suggest unclear TDD cycles`
 
-**TodoWrite Update (Phase 5 SlashCommand dispatched - tasks attached)**:
+**Action**: Log warnings to `.workflow/active/[sessionId]/.process/tdd-warnings.log` (non-blocking)
+
+<!-- TodoWrite: When task-generate-tdd executed, INSERT 3 task-generate-tdd tasks -->
+
+**TodoWrite Update (Phase 5 SlashCommand executed - tasks attached)**:
 ```json
 [
   {"content": "Phase 1: Session Discovery", "status": "completed", "activeForm": "Executing session discovery"},
@@ -267,7 +312,7 @@ SlashCommand(command="/workflow:tools:task-generate-tdd --session [sessionId]")
 ]
 ```
 
-**Note**: SlashCommand dispatch **attaches** task-generate-tdd's 3 tasks. Orchestrator **executes** these tasks. Each generated IMPL task will contain internal Red-Green-Refactor cycle.
+**Note**: SlashCommand execute **attaches** task-generate-tdd's 3 tasks. Orchestrator **executes** these tasks. Each generated IMPL task will contain internal Red-Green-Refactor cycle.
 
 **Next Action**: Tasks attached → **Execute Phase 5.1-5.3** sequentially
 
@@ -302,6 +347,42 @@ SlashCommand(command="/workflow:tools:task-generate-tdd --session [sessionId]")
 5. Test-fix cycle: Green phase step includes test-fix-cycle logic with max_iterations
 6. Task count: Total tasks ≤10 (simple + subtasks)
 
+**Red Flag Checklist** (from TDD best practices):
+- [ ] No tasks skip Red phase (`tdd_phase: "red"` exists in step 1)
+- [ ] Test files referenced in Red phase (explicit paths, not placeholders)
+- [ ] Green phase has test-fix-cycle with `max_iterations` configured
+- [ ] Refactor phase has clear completion criteria
+
+**Non-Compliance Warning Format**:
+```
+⚠️ TDD Red Flag: [issue description]
+   Task: [IMPL-N]
+   Recommendation: [action to fix]
+```
+
+**Evidence Gathering** (Before Completion Claims):
+
+```bash
+# Verify session artifacts exist
+ls -la .workflow/active/[sessionId]/{IMPL_PLAN.md,TODO_LIST.md}
+ls -la .workflow/active/[sessionId]/.task/IMPL-*.json
+
+# Count generated artifacts
+echo "IMPL tasks: $(ls .workflow/active/[sessionId]/.task/IMPL-*.json 2>/dev/null | wc -l)"
+
+# Sample task structure verification (first task)
+jq '{id, tdd: .meta.tdd_workflow, phases: [.flow_control.implementation_approach[].tdd_phase]}' \
+  "$(ls .workflow/active/[sessionId]/.task/IMPL-*.json | head -1)"
+```
+
+**Evidence Required Before Summary**:
+| Evidence Type | Verification Method | Pass Criteria |
+|---------------|---------------------|---------------|
+| File existence | `ls -la` artifacts | All files present |
+| Task count | Count IMPL-*.json | Count matches claims |
+| TDD structure | jq sample extraction | Shows red/green/refactor |
+| Warning log | Check tdd-warnings.log | Logged (may be empty) |
+
 **Return Summary**:
 ```
 TDD Planning complete for session: [sessionId]
@@ -333,6 +414,9 @@ TDD Configuration:
 - Green phase includes test-fix cycle (max 3 iterations)
 - Auto-revert on max iterations reached
 
+⚠️ ACTION REQUIRED: Before execution, ensure you understand WHY each Red phase test is expected to fail.
+   This is crucial for valid TDD - if you don't know why the test fails, you can't verify it tests the right thing.
+
 Recommended Next Steps:
 1. /workflow:action-plan-verify --session [sessionId]  # Verify TDD plan quality and dependencies
 2. /workflow:execute --session [sessionId]  # Start TDD execution
@@ -347,7 +431,7 @@ Quality Gate: Consider running /workflow:action-plan-verify to validate TDD task
 
 ### Key Principles
 
-1. **Task Attachment** (when SlashCommand dispatched):
+1. **Task Attachment** (when SlashCommand executed):
    - Sub-command's internal tasks are **attached** to orchestrator's TodoWrite
    - Example: `/workflow:tools:test-context-gather` attaches 3 sub-tasks (Phase 3.1, 3.2, 3.3)
    - First attached task marked as `in_progress`, others as `pending`
@@ -364,7 +448,7 @@ Quality Gate: Consider running /workflow:action-plan-verify to validate TDD task
    - No user intervention required between phases
    - TodoWrite dynamically reflects current execution state
 
-**Lifecycle Summary**: Initial pending tasks → Phase dispatched (tasks ATTACHED) → Sub-tasks executed sequentially → Phase completed (tasks COLLAPSED to summary) → Next phase begins (conditional Phase 4 if conflict_risk ≥ medium) → Repeat until all phases complete.
+**Lifecycle Summary**: Initial pending tasks → Phase executed (tasks ATTACHED) → Sub-tasks executed sequentially → Phase completed (tasks COLLAPSED to summary) → Next phase begins (conditional Phase 4 if conflict_risk ≥ medium) → Repeat until all phases complete.
 
 ### TDD-Specific Features
 
@@ -400,7 +484,7 @@ TDD Workflow Orchestrator
 │  IF conflict_risk ≥ medium:
 │  └─ /workflow:tools:conflict-resolution             ← ATTACHED (3 tasks)
 │     ├─ Phase 4.1: Detect conflicts with CLI
-│     ├─ Phase 4.2: Present conflicts to user
+│     ├─ Phase 4.2: Log and analyze detected conflicts
 │     └─ Phase 4.3: Apply resolution strategies
 │     └─ Returns: conflict-resolution.json            ← COLLAPSED
 │  ELSE:
@@ -439,6 +523,34 @@ Convert user input to TDD-structured format:
 - **Command failure**: Keep phase in_progress, report error
 - **TDD validation failure**: Report incomplete chains or wrong dependencies
 
+### TDD Warning Patterns
+
+| Pattern | Warning Message | Recommended Action |
+|---------|----------------|-------------------|
+| Task count >10 | High task count detected | Consider splitting into multiple sessions |
+| Missing test-fix-cycle | Green phase lacks auto-revert | Add `max_iterations: 3` to task config |
+| Red phase missing test path | Test file path not specified | Add explicit test file paths |
+| Generic task names | Vague names like "Add feature" | Use specific behavior descriptions |
+| No refactor criteria | Refactor phase lacks completion criteria | Define clear refactor scope |
+
+### Non-Blocking Warning Policy
+
+**All warnings are advisory** - they do not halt execution:
+1. Warnings logged to `.process/tdd-warnings.log`
+2. Summary displayed in Phase 6 output
+3. User decides whether to address before `/workflow:execute`
+
+### Error Handling Quick Reference
+
+| Error Type | Detection | Recovery Action |
+|------------|-----------|-----------------|
+| Parsing failure | Empty/malformed output | Retry once, then report |
+| Missing context-package | File read error | Re-run `/workflow:tools:context-gather` |
+| Invalid task JSON | jq parse error | Report malformed file path |
+| High task count (>10) | Count validation | Log warning, continue (non-blocking) |
+| Test-context missing | File not found | Re-run `/workflow:tools:test-context-gather` |
+| Phase timeout | No response | Retry phase, check CLI connectivity |
+
 ## Related Commands
 
 **Prerequisite Commands**:
@@ -458,3 +570,28 @@ Convert user input to TDD-structured format:
 - `/workflow:execute` - Begin TDD implementation
 - `/workflow:tdd-verify` - Post-execution: Verify TDD compliance and generate quality report
 
+## Next Steps Decision Table
+
+| Situation | Recommended Command | Purpose |
+|-----------|---------------------|---------|
+| First time planning | `/workflow:action-plan-verify` | Validate task structure before execution |
+| Warnings in tdd-warnings.log | Review log, refine tasks | Address Red Flags before proceeding |
+| High task count warning | Consider `/workflow:session:start` | Split into focused sub-sessions |
+| Ready to implement | `/workflow:execute` | Begin TDD Red-Green-Refactor cycles |
+| After implementation | `/workflow:tdd-verify` | Generate TDD compliance report |
+| Need to review tasks | `/workflow:status --session [id]` | Inspect current task breakdown |
+| Plan needs changes | `/task:replan` | Update task JSON with new requirements |
+
+### TDD Workflow State Transitions
+
+```
+/workflow:tdd-plan
+        ↓
+[Planning Complete] ──→ /workflow:action-plan-verify (recommended)
+        ↓
+[Verified/Ready] ─────→ /workflow:execute
+        ↓
+[Implementation] ─────→ /workflow:tdd-verify (post-execution)
+        ↓
+[Quality Report] ─────→ Done or iterate
+```

.claude/commands/workflow/test-cycle-execute.md

@@ -491,6 +491,10 @@ The orchestrator automatically creates git commits at key checkpoints to enable
 
 **Note**: Final session completion creates additional commit with full summary.
 
+## Post-Completion Expansion
+
+完成后询问用户是否扩展为issue(test/enhance/refactor/doc)，选中项调用 `/issue:new "{summary} - {dimension}"`
+
 ## Best Practices
 
 1. **Default Settings Work**: 10 iterations sufficient for most cases

.claude/commands/workflow/test-fix-gen.md

@@ -59,8 +59,8 @@ This command is a **pure planning coordinator**:
 - **All execution delegated to `/workflow:test-cycle-execute`**
 
 **Task Attachment Model**:
-- SlashCommand dispatch **expands workflow** by attaching sub-tasks to current TodoWrite
-- When dispatching a sub-command (e.g., `/workflow:tools:test-context-gather`), its internal tasks are attached to the orchestrator's TodoWrite
+- SlashCommand execute **expands workflow** by attaching sub-tasks to current TodoWrite
+- When executing a sub-command (e.g., `/workflow:tools:test-context-gather`), its internal tasks are attached to the orchestrator's TodoWrite
 - Orchestrator **executes these attached tasks** sequentially
 - After completion, attached tasks are **collapsed** back to high-level phase summary
 - This is **task expansion**, not external delegation
@@ -128,7 +128,7 @@ This command is a **pure planning coordinator**:
 
 ### Core Execution Rules
 
-1. **Start Immediately**: First action is TodoWrite, second is dispatch Phase 1 session creation
+1. **Start Immediately**: First action is TodoWrite, second is execute Phase 1 session creation
 2. **No Preliminary Analysis**: Do not read files before Phase 1
 3. **Parse Every Output**: Extract required data from each phase for next phase
 4. **Sequential Execution**: Each phase depends on previous phase's output
@@ -136,7 +136,7 @@ This command is a **pure planning coordinator**:
 6. **Track Progress**: Update TodoWrite dynamically with task attachment/collapse pattern
 7. **Automatic Detection**: Mode auto-detected from input pattern
 8. **Semantic CLI Detection**: CLI tool usage determined from user's task description for Phase 4
-9. **Task Attachment Model**: SlashCommand dispatch **attaches** sub-tasks to current workflow. Orchestrator **executes** these attached tasks itself, then **collapses** them after completion
+9. **Task Attachment Model**: SlashCommand execute **attaches** sub-tasks to current workflow. Orchestrator **executes** these attached tasks itself, then **collapses** them after completion
 10. **⚠️ CRITICAL: DO NOT STOP**: Continuous multi-phase workflow. After executing all attached tasks, immediately collapse them and execute next phase
 
 ### 5-Phase Execution
@@ -155,7 +155,7 @@ Read(".workflow/active/[sourceSessionId]/.process/context-package.json")
 // This preserves user's CLI tool preferences (e.g., "use Codex for fixes")
 ```
 
-**Step 1.1: Dispatch** - Create test workflow session with preserved intent
+**Step 1.1: Execute** - Create test workflow session with preserved intent
 
 ```javascript
 // Session Mode - Include original task description to enable semantic CLI selection
@@ -187,7 +187,7 @@ SlashCommand(command="/workflow:session:start --type test --new \"Test generatio
 
 #### Phase 2: Gather Test Context
 
-**Step 2.1: Dispatch** - Gather test context via appropriate method
+**Step 2.1: Execute** - Gather test context via appropriate method
 
 ```javascript
 // Session Mode
@@ -224,7 +224,7 @@ SlashCommand(command="/workflow:tools:context-gather --session [testSessionId] \
 
 #### Phase 3: Test Generation Analysis
 
-**Step 3.1: Dispatch** - Generate test requirements using Gemini
+**Step 3.1: Execute** - Generate test requirements using Gemini
 
 ```javascript
 SlashCommand(command="/workflow:tools:test-concept-enhanced --session [testSessionId] --context [contextPath]")
@@ -284,7 +284,7 @@ For each targeted file/function, Gemini MUST generate:
 
 #### Phase 4: Generate Test Tasks
 
-**Step 4.1: Dispatch** - Generate test task JSONs
+**Step 4.1: Execute** - Generate test task JSONs
 
 ```javascript
 SlashCommand(command="/workflow:tools:test-task-generate --session [testSessionId]")
@@ -381,7 +381,7 @@ CRITICAL - Next Steps:
 
 #### Key Principles
 
-1. **Task Attachment** (when SlashCommand dispatched):
+1. **Task Attachment** (when SlashCommand executed):
    - Sub-command's internal tasks are **attached** to orchestrator's TodoWrite
    - Example - Phase 2 with sub-tasks:
    ```json
@@ -416,7 +416,7 @@ CRITICAL - Next Steps:
    - No user intervention required between phases
    - TodoWrite dynamically reflects current execution state
 
-**Lifecycle Summary**: Initial pending tasks → Phase dispatched (tasks ATTACHED with mode-specific context gathering) → Sub-tasks executed sequentially → Phase completed (tasks COLLAPSED to summary) → Next phase begins → Repeat until all phases complete.
+**Lifecycle Summary**: Initial pending tasks → Phase executed (tasks ATTACHED with mode-specific context gathering) → Sub-tasks executed sequentially → Phase completed (tasks COLLAPSED to summary) → Next phase begins → Repeat until all phases complete.
 
 #### Test-Fix-Gen Specific Features
 

.claude/commands/workflow/test-gen.md

@@ -20,7 +20,7 @@ allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*)
 
 **Task Attachment Model**:
 - SlashCommand dispatch **expands workflow** by attaching sub-tasks to current TodoWrite
-- When a sub-command is dispatched (e.g., `/workflow:tools:test-context-gather`), its internal tasks are attached to the orchestrator's TodoWrite
+- When a sub-command is executed (e.g., `/workflow:tools:test-context-gather`), its internal tasks are attached to the orchestrator's TodoWrite
 - Orchestrator **executes these attached tasks** sequentially
 - After completion, attached tasks are **collapsed** back to high-level phase summary
 - This is **task expansion**, not external delegation
@@ -69,7 +69,7 @@ Read(".workflow/active/[sourceSessionId]/.process/context-package.json")
 // This preserves user's CLI tool preferences (e.g., "use Codex for fixes")
 ```
 
-**Step 1.1: Dispatch** - Create new test workflow session with preserved intent
+**Step 1.1: Execute** - Create new test workflow session with preserved intent
 
 ```javascript
 // Include original task description to enable semantic CLI selection
@@ -104,7 +104,7 @@ SlashCommand(command="/workflow:session:start --new \"Test validation for [sourc
 
 ### Phase 2: Gather Test Context
 
-**Step 2.1: Dispatch** - Gather test coverage context from source session
+**Step 2.1: Execute** - Gather test coverage context from source session
 
 ```javascript
 SlashCommand(command="/workflow:tools:test-context-gather --session [testSessionId]")
@@ -130,9 +130,9 @@ SlashCommand(command="/workflow:tools:test-context-gather --session [testSession
 - Test framework detected
 - Test conventions documented
 
-<!-- TodoWrite: When test-context-gather dispatched, INSERT 3 test-context-gather tasks -->
+<!-- TodoWrite: When test-context-gather executed, INSERT 3 test-context-gather tasks -->
 
-**TodoWrite Update (Phase 2 SlashCommand dispatched - tasks attached)**:
+**TodoWrite Update (Phase 2 SlashCommand executed - tasks attached)**:
 ```json
 [
   {"content": "Create independent test session", "status": "completed", "activeForm": "Creating test session"},
@@ -168,7 +168,7 @@ SlashCommand(command="/workflow:tools:test-context-gather --session [testSession
 
 ### Phase 3: Test Generation Analysis
 
-**Step 3.1: Dispatch** - Analyze test requirements with Gemini
+**Step 3.1: Execute** - Analyze test requirements with Gemini
 
 ```javascript
 SlashCommand(command="/workflow:tools:test-concept-enhanced --session [testSessionId] --context [testContextPath]")
@@ -199,9 +199,9 @@ SlashCommand(command="/workflow:tools:test-concept-enhanced --session [testSessi
   - Implementation Targets (test files to create)
   - Success Criteria
 
-<!-- TodoWrite: When test-concept-enhanced dispatched, INSERT 3 concept-enhanced tasks -->
+<!-- TodoWrite: When test-concept-enhanced executed, INSERT 3 concept-enhanced tasks -->
 
-**TodoWrite Update (Phase 3 SlashCommand dispatched - tasks attached)**:
+**TodoWrite Update (Phase 3 SlashCommand executed - tasks attached)**:
 ```json
 [
   {"content": "Create independent test session", "status": "completed", "activeForm": "Creating test session"},
@@ -237,7 +237,7 @@ SlashCommand(command="/workflow:tools:test-concept-enhanced --session [testSessi
 
 ### Phase 4: Generate Test Tasks
 
-**Step 4.1: Dispatch** - Generate test task JSON files and planning documents
+**Step 4.1: Execute** - Generate test task JSON files and planning documents
 
 ```javascript
 SlashCommand(command="/workflow:tools:test-task-generate --session [testSessionId]")
@@ -287,9 +287,9 @@ SlashCommand(command="/workflow:tools:test-task-generate --session [testSessionI
   - Phase 2: Iterative Gemini diagnosis + fixes (agent or CLI based on step's `command` field)
   - Phase 3: Final validation and certification
 
-<!-- TodoWrite: When test-task-generate dispatched, INSERT 3 test-task-generate tasks -->
+<!-- TodoWrite: When test-task-generate executed, INSERT 3 test-task-generate tasks -->
 
-**TodoWrite Update (Phase 4 SlashCommand dispatched - tasks attached)**:
+**TodoWrite Update (Phase 4 SlashCommand executed - tasks attached)**:
 ```json
 [
   {"content": "Create independent test session", "status": "completed", "activeForm": "Creating test session"},
@@ -364,7 +364,7 @@ Ready for execution. Use appropriate workflow commands to proceed.
 
 ### Key Principles
 
-1. **Task Attachment** (when SlashCommand dispatched):
+1. **Task Attachment** (when SlashCommand executed):
    - Sub-command's internal tasks are **attached** to orchestrator's TodoWrite
    - Example: `/workflow:tools:test-context-gather` attaches 3 sub-tasks (Phase 2.1, 2.2, 2.3)
    - First attached task marked as `in_progress`, others as `pending`
@@ -381,7 +381,7 @@ Ready for execution. Use appropriate workflow commands to proceed.
    - No user intervention required between phases
    - TodoWrite dynamically reflects current execution state
 
-**Lifecycle Summary**: Initial pending tasks → Phase dispatched (tasks ATTACHED) → Sub-tasks executed sequentially → Phase completed (tasks COLLAPSED to summary) → Next phase begins → Repeat until all phases complete.
+**Lifecycle Summary**: Initial pending tasks → Phase executed (tasks ATTACHED) → Sub-tasks executed sequentially → Phase completed (tasks COLLAPSED to summary) → Next phase begins → Repeat until all phases complete.
 
 ### Test-Gen Specific Features
 
@@ -517,7 +517,7 @@ See `/workflow:tools:test-task-generate` for complete JSON schemas.
 **Prerequisite Commands**:
 - `/workflow:plan` or `/workflow:execute` - Complete implementation session that needs test validation
 
-**Dispatched by This Command** (4 phases):
+**Executed by This Command** (4 phases):
 - `/workflow:session:start` - Phase 1: Create independent test workflow session
 - `/workflow:tools:test-context-gather` - Phase 2: Analyze test coverage and gather source session context
 - `/workflow:tools:test-concept-enhanced` - Phase 3: Generate test requirements and strategy using Gemini

.claude/commands/workflow/tools/conflict-resolution.md

@@ -154,8 +154,8 @@ Task(subagent_type="cli-execution-agent", run_in_background=false, prompt=`
     - Validation of exploration conflict_indicators
     - ModuleOverlap conflicts with overlap_analysis
     - Targeted clarification questions
-  RULES: $(cat ~/.claude/workflows/cli-templates/prompts/analysis/02-analyze-code-patterns.txt) | Focus on breaking changes, migration needs, and functional overlaps | Prioritize exploration-identified conflicts | analysis=READ-ONLY
-  " --tool gemini --mode analysis --cd {project_root}
+  CONSTRAINTS: Focus on breaking changes, migration needs, and functional overlaps | Prioritize exploration-identified conflicts | analysis=READ-ONLY
+  " --tool gemini --mode analysis --rule analysis-code-patterns --cd {project_root}
 
   Fallback: Qwen (same prompt) → Claude (manual analysis)
 

.claude/commands/workflow/tools/context-gather.md

@@ -237,7 +237,7 @@ Execute complete context-search-agent workflow for implementation planning:
 
 ### Phase 1: Initialization & Pre-Analysis
 1. **Project State Loading**:
-   - Read and parse `.workflow/project-tech.json`. Use its `technology_analysis` section as the foundational `project_context`. This is your primary source for architecture, tech stack, and key components.
+   - Read and parse `.workflow/project-tech.json`. Use its `overview` section as the foundational `project_context`. This is your primary source for architecture, tech stack, and key components.
    - Read and parse `.workflow/project-guidelines.json`. Load `conventions`, `constraints`, and `learnings` into a `project_guidelines` section.
    - If files don't exist, proceed with fresh analysis.
 2. **Detection**: Check for existing context-package (early exit if valid)
@@ -255,7 +255,7 @@ Execute all discovery tracks:
 ### Phase 3: Synthesis, Assessment & Packaging
 1. Apply relevance scoring and build dependency graph
 2. **Synthesize 4-source data**: Merge findings from all sources (archive > docs > code > web). **Prioritize the context from `project-tech.json`** for architecture and tech stack unless code analysis reveals it's outdated.
-3. **Populate `project_context`**: Directly use the `technology_analysis` from `project-tech.json` to fill the `project_context` section. Include description, technology_stack, architecture, and key_components.
+3. **Populate `project_context`**: Directly use the `overview` from `project-tech.json` to fill the `project_context` section. Include description, technology_stack, architecture, and key_components.
 4. **Populate `project_guidelines`**: Load conventions, constraints, and learnings from `project-guidelines.json` into a dedicated section.
 5. Integrate brainstorm artifacts (if .brainstorming/ exists, read content)
 6. Perform conflict detection with risk assessment

.claude/commands/workflow/tools/test-concept-enhanced.md

@@ -90,7 +90,7 @@ Template: ~/.claude/workflows/cli-templates/prompts/test/test-concept-analysis.t
 
 ## EXECUTION STEPS
 1. Execute Gemini analysis:
-   ccw cli -p "$(cat ~/.claude/workflows/cli-templates/prompts/test/test-concept-analysis.txt)" --tool gemini --mode write --cd .workflow/active/{test_session_id}/.process
+   ccw cli -p "..." --tool gemini --mode write --rule test-test-concept-analysis --cd .workflow/active/{test_session_id}/.process
 
 2. Generate TEST_ANALYSIS_RESULTS.md:
    Synthesize gemini-test-analysis.md into standardized format for task generation

.claude/commands/workflow/ui-design/explore-auto.md

@@ -27,8 +27,8 @@ allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*), Glob(*), Write(*
 6. **Phase 10 (ui-assembly)** → **Attach tasks → Execute → Collapse** → Workflow complete
 
 **Phase Transition Mechanism**:
-- **Phase 5 (User Interaction)**: User confirms targets → IMMEDIATELY dispatches Phase 7
-- **Phase 7-10 (Autonomous)**: SlashCommand dispatch **ATTACHES** tasks to current workflow
+- **Phase 5 (User Interaction)**: User confirms targets → IMMEDIATELY executes Phase 7
+- **Phase 7-10 (Autonomous)**: SlashCommand execute **ATTACHES** tasks to current workflow
 - **Task Execution**: Orchestrator **EXECUTES** these attached tasks itself
 - **Task Collapse**: After tasks complete, collapse them into phase summary
 - **Phase Transition**: Automatically execute next phase after collapsing
@@ -36,7 +36,7 @@ allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*), Glob(*), Write(*
 
 **Auto-Continue Mechanism**: TodoWrite tracks phase status with dynamic task attachment/collapse. After executing all attached tasks, you MUST immediately collapse them, restore phase summary, and execute the next phase. No user intervention required. The workflow is NOT complete until Phase 10 (UI assembly) finishes.
 
-**Task Attachment Model**: SlashCommand dispatch is NOT delegation - it's task expansion. The orchestrator executes these attached tasks itself, not waiting for external completion.
+**Task Attachment Model**: SlashCommand execute is NOT delegation - it's task expansion. The orchestrator executes these attached tasks itself, not waiting for external completion.
 
 **Target Type Detection**: Automatically inferred from prompt/targets, or explicitly set via `--target-type`.
 
@@ -63,26 +63,26 @@ Phase 5: Unified Target Inference
 
 Phase 6: Code Import (Conditional)
    └─ Decision (design_source):
-      ├─ code_only | hybrid → Dispatch /workflow:ui-design:import-from-code
+      ├─ code_only | hybrid → Execute /workflow:ui-design:import-from-code
       └─ visual_only → Skip to Phase 7
 
 Phase 7: Style Extraction
    └─ Decision (needs_visual_supplement):
-      ├─ visual_only OR supplement needed → Dispatch /workflow:ui-design:style-extract
+      ├─ visual_only OR supplement needed → Execute /workflow:ui-design:style-extract
       └─ code_only AND style_complete → Use code import
 
 Phase 8: Animation Extraction
    └─ Decision (should_extract_animation):
-      ├─ visual_only OR incomplete OR regenerate → Dispatch /workflow:ui-design:animation-extract
+      ├─ visual_only OR incomplete OR regenerate → Execute /workflow:ui-design:animation-extract
       └─ code_only AND animation_complete → Use code import
 
 Phase 9: Layout Extraction
    └─ Decision (needs_visual_supplement OR NOT layout_complete):
-      ├─ True → Dispatch /workflow:ui-design:layout-extract
+      ├─ True → Execute /workflow:ui-design:layout-extract
       └─ False → Use code import
 
 Phase 10: UI Assembly
-   └─ Dispatch /workflow:ui-design:generate → Workflow complete
+   └─ Execute /workflow:ui-design:generate → Workflow complete
 ```
 
 ## Core Rules
@@ -92,7 +92,7 @@ Phase 10: UI Assembly
 3. **Parse & Pass**: Extract data from each output for next phase
 4. **Default to All**: When selecting variants/prototypes, use ALL generated items
 5. **Track Progress**: Update TodoWrite dynamically with task attachment/collapse pattern
-6. **⚠️ CRITICAL: Task Attachment Model** - SlashCommand dispatch **ATTACHES** tasks to current workflow. Orchestrator **EXECUTES** these attached tasks itself, not waiting for external completion. This is NOT delegation - it's task expansion.
+6. **⚠️ CRITICAL: Task Attachment Model** - SlashCommand execute **ATTACHES** tasks to current workflow. Orchestrator **EXECUTES** these attached tasks itself, not waiting for external completion. This is NOT delegation - it's task expansion.
 7. **⚠️ CRITICAL: DO NOT STOP** - This is a continuous multi-phase workflow. After executing all attached tasks, you MUST immediately collapse them and execute the next phase. Workflow is NOT complete until Phase 10 (UI assembly) finishes.
 
 ## Parameter Requirements
@@ -356,7 +356,7 @@ detect_target_type(target_list):
 
 ### Phase 6: Code Import & Completeness Assessment (Conditional)
 
-**Step 6.1: Dispatch** - Import design system from code files
+**Step 6.1: Execute** - Import design system from code files
 
 ```javascript
 IF design_source IN ["code_only", "hybrid"]:
@@ -364,7 +364,7 @@ IF design_source IN ["code_only", "hybrid"]:
     command = "/workflow:ui-design:import-from-code --design-id \"{design_id}\" --source \"{code_base_path}\""
 
     TRY:
-        # SlashCommand dispatch ATTACHES import-from-code's tasks to current workflow
+        # SlashCommand execute ATTACHES import-from-code's tasks to current workflow
         # Orchestrator will EXECUTE these attached tasks itself:
         #   - Phase 0: Discover and categorize code files
         #   - Phase 1.1-1.3: Style/Animation/Layout Agent extraction
@@ -469,7 +469,7 @@ IF design_source IN ["code_only", "hybrid"]:
 
 ### Phase 7: Style Extraction
 
-**Step 7.1: Dispatch** - Extract style design systems
+**Step 7.1: Execute** - Extract style design systems
 
 ```javascript
 IF design_source == "visual_only" OR needs_visual_supplement:
@@ -479,7 +479,7 @@ IF design_source == "visual_only" OR needs_visual_supplement:
               (prompt_text ? "--prompt \"{prompt_text}\" " : "") +
               "--variants {style_variants} --interactive"
 
-    # SlashCommand dispatch ATTACHES style-extract's tasks to current workflow
+    # SlashCommand execute ATTACHES style-extract's tasks to current workflow
     # Orchestrator will EXECUTE these attached tasks itself
     SlashCommand(command)
 
@@ -490,7 +490,7 @@ ELSE:
 
 ### Phase 8: Animation Extraction
 
-**Step 8.1: Dispatch** - Extract animation patterns
+**Step 8.1: Execute** - Extract animation patterns
 
 ```javascript
 # Determine if animation extraction is needed
@@ -522,7 +522,7 @@ IF should_extract_animation:
 
     command = " ".join(command_parts)
 
-    # SlashCommand dispatch ATTACHES animation-extract's tasks to current workflow
+    # SlashCommand execute ATTACHES animation-extract's tasks to current workflow
     # Orchestrator will EXECUTE these attached tasks itself
     SlashCommand(command)
 
@@ -536,7 +536,7 @@ ELSE:
 
 ### Phase 9: Layout Extraction
 
-**Step 9.1: Dispatch** - Extract layout templates
+**Step 9.1: Execute** - Extract layout templates
 
 ```javascript
 targets_string = ",".join(inferred_target_list)
@@ -548,7 +548,7 @@ IF (design_source == "visual_only" OR needs_visual_supplement) OR (NOT layout_co
               (prompt_text ? "--prompt \"{prompt_text}\" " : "") +
               "--targets \"{targets_string}\" --variants {layout_variants} --device-type \"{device_type}\" --interactive"
 
-    # SlashCommand dispatch ATTACHES layout-extract's tasks to current workflow
+    # SlashCommand execute ATTACHES layout-extract's tasks to current workflow
     # Orchestrator will EXECUTE these attached tasks itself
     SlashCommand(command)
 
@@ -559,7 +559,7 @@ ELSE:
 
 ### Phase 10: UI Assembly
 
-**Step 10.1: Dispatch** - Assemble UI prototypes from design tokens and layout templates
+**Step 10.1: Execute** - Assemble UI prototypes from design tokens and layout templates
 
 ```javascript
 command = "/workflow:ui-design:generate --design-id \"{design_id}\"" + (--session ? " --session {session_id}" : "")
@@ -571,7 +571,7 @@ REPORT: "   → Pure assembly: Combining layout templates + design tokens"
 REPORT: "   → Device: {device_type} (from layout templates)"
 REPORT: "   → Assembly tasks: {total} combinations"
 
-# SlashCommand dispatch ATTACHES generate's tasks to current workflow
+# SlashCommand execute ATTACHES generate's tasks to current workflow
 # Orchestrator will EXECUTE these attached tasks itself
 SlashCommand(command)
 
@@ -596,10 +596,10 @@ TodoWrite({todos: [
 
 // ⚠️ CRITICAL: Dynamic TodoWrite task attachment strategy:
 //
-// **Key Concept**: SlashCommand dispatch ATTACHES tasks to current workflow.
+// **Key Concept**: SlashCommand execute ATTACHES tasks to current workflow.
 // Orchestrator EXECUTES these attached tasks itself, not waiting for external completion.
 //
-// Phase 7-10 SlashCommand Dispatch Pattern (when tasks are attached):
+// Phase 7-10 SlashCommand Execute Pattern (when tasks are attached):
 // Example - Phase 7 with sub-tasks:
 // [
 //   {"content": "Phase 7: Style Extraction", "status": "in_progress", "activeForm": "Executing style extraction"},

.claude/commands/workflow/ui-design/imitate-auto.md

@@ -26,7 +26,7 @@ allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Write(*), Bash(*)
 7. Phase 4: Design system integration → **Execute orchestrator task** → Reports completion
 
 **Phase Transition Mechanism**:
-- **Task Attachment**: SlashCommand dispatch **ATTACHES** tasks to current workflow
+- **Task Attachment**: SlashCommand execute **ATTACHES** tasks to current workflow
 - **Task Execution**: Orchestrator **EXECUTES** these attached tasks itself
 - **Task Collapse**: After tasks complete, collapse them into phase summary
 - **Phase Transition**: Automatically execute next phase after collapsing
@@ -34,7 +34,7 @@ allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Write(*), Bash(*)
 
 **Auto-Continue Mechanism**: TodoWrite tracks phase status with dynamic task attachment/collapse. After executing all attached tasks, you MUST immediately collapse them, restore phase summary, and execute the next phase. No user intervention required. The workflow is NOT complete until reaching Phase 4.
 
-**Task Attachment Model**: SlashCommand dispatch is NOT delegation - it's task expansion. The orchestrator executes these attached tasks itself, not waiting for external completion.
+**Task Attachment Model**: SlashCommand execute is NOT delegation - it's task expansion. The orchestrator executes these attached tasks itself, not waiting for external completion.
 
 ## Execution Process
 
@@ -53,30 +53,30 @@ Phase 0: Parameter Parsing & Input Detection
 
 Phase 0.5: Code Import (Conditional)
    └─ Decision (design_source):
-      ├─ hybrid → Dispatch /workflow:ui-design:import-from-code
+      ├─ hybrid → Execute /workflow:ui-design:import-from-code
       └─ Other → Skip to Phase 2
 
 Phase 2: Style Extraction
    └─ Decision (skip_style):
       ├─ code_only AND style_complete → Use code import
-      └─ Otherwise → Dispatch /workflow:ui-design:style-extract
+      └─ Otherwise → Execute /workflow:ui-design:style-extract
 
 Phase 2.3: Animation Extraction
    └─ Decision (skip_animation):
       ├─ code_only AND animation_complete → Use code import
-      └─ Otherwise → Dispatch /workflow:ui-design:animation-extract
+      └─ Otherwise → Execute /workflow:ui-design:animation-extract
 
 Phase 2.5: Layout Extraction
    └─ Decision (skip_layout):
       ├─ code_only AND layout_complete → Use code import
-      └─ Otherwise → Dispatch /workflow:ui-design:layout-extract
+      └─ Otherwise → Execute /workflow:ui-design:layout-extract
 
 Phase 3: UI Assembly
-   └─ Dispatch /workflow:ui-design:generate
+   └─ Execute /workflow:ui-design:generate
 
 Phase 4: Design System Integration
    └─ Decision (session_id):
-      ├─ Provided → Dispatch /workflow:ui-design:update
+      ├─ Provided → Execute /workflow:ui-design:update
       └─ Not provided → Standalone completion
 ```
 
@@ -86,7 +86,7 @@ Phase 4: Design System Integration
 2. **No Preliminary Validation**: Sub-commands handle their own validation
 3. **Parse & Pass**: Extract data from each output for next phase
 4. **Track Progress**: Update TodoWrite dynamically with task attachment/collapse pattern
-5. **⚠️ CRITICAL: Task Attachment Model** - SlashCommand dispatch **ATTACHES** tasks to current workflow. Orchestrator **EXECUTES** these attached tasks itself, not waiting for external completion. This is NOT delegation - it's task expansion.
+5. **⚠️ CRITICAL: Task Attachment Model** - SlashCommand execute **ATTACHES** tasks to current workflow. Orchestrator **EXECUTES** these attached tasks itself, not waiting for external completion. This is NOT delegation - it's task expansion.
 6. **⚠️ CRITICAL: DO NOT STOP** - This is a continuous multi-phase workflow. After executing all attached tasks, you MUST immediately collapse them and execute the next phase. Workflow is NOT complete until Phase 4.
 
 ## Parameter Requirements
@@ -276,7 +276,7 @@ TodoWrite({todos: [
 
 ### Phase 0.5: Code Import & Completeness Assessment (Conditional)
 
-**Step 0.5.1: Dispatch** - Import design system from code files
+**Step 0.5.1: Execute** - Import design system from code files
 
 ```javascript
 # Only execute if code files detected
@@ -291,7 +291,7 @@ IF design_source == "hybrid":
               "--source \"{code_base_path}\""
 
     TRY:
-        # SlashCommand dispatch ATTACHES import-from-code's tasks to current workflow
+        # SlashCommand execute ATTACHES import-from-code's tasks to current workflow
         # Orchestrator will EXECUTE these attached tasks itself:
         #   - Phase 0: Discover and categorize code files
         #   - Phase 1.1-1.3: Style/Animation/Layout Agent extraction
@@ -382,7 +382,7 @@ TodoWrite(mark_completed: "Initialize and detect design source",
 
 ### Phase 2: Style Extraction
 
-**Step 2.1: Dispatch** - Extract style design system
+**Step 2.1: Execute** - Extract style design system
 
 ```javascript
 # Determine if style extraction needed
@@ -409,7 +409,7 @@ ELSE:
 
     extract_command = " ".join(command_parts)
 
-    # SlashCommand dispatch ATTACHES style-extract's tasks to current workflow
+    # SlashCommand execute ATTACHES style-extract's tasks to current workflow
     # Orchestrator will EXECUTE these attached tasks itself
     SlashCommand(extract_command)
 
@@ -419,7 +419,7 @@ ELSE:
 
 ### Phase 2.3: Animation Extraction
 
-**Step 2.3.1: Dispatch** - Extract animation patterns
+**Step 2.3.1: Execute** - Extract animation patterns
 
 ```javascript
 skip_animation = (design_source == "code_only" AND animation_complete)
@@ -442,7 +442,7 @@ ELSE:
 
     animation_extract_command = " ".join(command_parts)
 
-    # SlashCommand dispatch ATTACHES animation-extract's tasks to current workflow
+    # SlashCommand execute ATTACHES animation-extract's tasks to current workflow
     # Orchestrator will EXECUTE these attached tasks itself
     SlashCommand(animation_extract_command)
 
@@ -452,7 +452,7 @@ ELSE:
 
 ### Phase 2.5: Layout Extraction
 
-**Step 2.5.1: Dispatch** - Extract layout templates
+**Step 2.5.1: Execute** - Extract layout templates
 
 ```javascript
 skip_layout = (design_source == "code_only" AND layout_complete)
@@ -477,7 +477,7 @@ ELSE:
 
     layout_extract_command = " ".join(command_parts)
 
-    # SlashCommand dispatch ATTACHES layout-extract's tasks to current workflow
+    # SlashCommand execute ATTACHES layout-extract's tasks to current workflow
     # Orchestrator will EXECUTE these attached tasks itself
     SlashCommand(layout_extract_command)
 
@@ -487,13 +487,13 @@ ELSE:
 
 ### Phase 3: UI Assembly
 
-**Step 3.1: Dispatch** - Assemble UI prototypes from design tokens and layout templates
+**Step 3.1: Execute** - Assemble UI prototypes from design tokens and layout templates
 
 ```javascript
 REPORT: "🚀 Phase 3: UI Assembly"
 generate_command = f"/workflow:ui-design:generate --design-id \"{design_id}\""
 
-# SlashCommand dispatch ATTACHES generate's tasks to current workflow
+# SlashCommand execute ATTACHES generate's tasks to current workflow
 # Orchestrator will EXECUTE these attached tasks itself
 SlashCommand(generate_command)
 
@@ -503,14 +503,14 @@ TodoWrite(mark_completed: "Assemble UI", mark_in_progress: session_id ? "Integra
 
 ### Phase 4: Design System Integration
 
-**Step 4.1: Dispatch** - Integrate design system into workflow session
+**Step 4.1: Execute** - Integrate design system into workflow session
 
 ```javascript
 IF session_id:
     REPORT: "🚀 Phase 4: Design System Integration"
     update_command = f"/workflow:ui-design:update --session {session_id}"
 
-    # SlashCommand dispatch ATTACHES update's tasks to current workflow
+    # SlashCommand execute ATTACHES update's tasks to current workflow
     # Orchestrator will EXECUTE these attached tasks itself
     SlashCommand(update_command)
 
@@ -636,10 +636,10 @@ TodoWrite({todos: [
 
 // ⚠️ CRITICAL: Dynamic TodoWrite task attachment strategy:
 //
-// **Key Concept**: SlashCommand dispatch ATTACHES tasks to current workflow.
+// **Key Concept**: SlashCommand execute ATTACHES tasks to current workflow.
 // Orchestrator EXECUTES these attached tasks itself, not waiting for external completion.
 //
-// Phase 2-4 SlashCommand Dispatch Pattern (when tasks are attached):
+// Phase 2-4 SlashCommand Execute Pattern (when tasks are attached):
 // Example - Phase 2 with sub-tasks:
 // [
 //   {"content": "Phase 0: Initialize and Detect Design Source", "status": "completed", "activeForm": "Initializing"},
@@ -702,7 +702,7 @@ TodoWrite({todos: [
 
 - **Input**: `--images` (glob pattern) and/or `--prompt` (text/file paths) + optional `--session`
 - **Output**: Complete design system in `{base_path}/` (style-extraction, layout-extraction, prototypes)
-- **Sub-commands Dispatched**:
+- **Sub-commands Executeed**:
   1. `/workflow:ui-design:import-from-code` (Phase 0.5, conditional - if code files detected)
   2. `/workflow:ui-design:style-extract` (Phase 2 - complete design systems)
   3. `/workflow:ui-design:animation-extract` (Phase 2.3 - animation tokens)

.claude/skills/_shared/SKILL-DESIGN-SPEC.md

@@ -0,0 +1,693 @@
+# Skill 设计规范 v1.0
+
+> 基于 `software-manual` 和 `copyright-docs` 两个成熟 Skill 的设计模式提炼
+
+---
+
+## 目录
+
+1. [设计理念](#1-设计理念)
+2. [目录结构规范](#2-目录结构规范)
+3. [核心组件定义](#3-核心组件定义)
+4. [SKILL.md 入口规范](#4-skillmd-入口规范)
+5. [Phase 阶段设计规范](#5-phase-阶段设计规范)
+6. [Specs 规范文件设计](#6-specs-规范文件设计)
+7. [Templates 模板设计](#7-templates-模板设计)
+8. [Scripts 脚本规范](#8-scripts-脚本规范)
+9. [Prompt 工程规范](#9-prompt-工程规范)
+10. [质量控制规范](#10-质量控制规范)
+11. [最佳实践清单](#11-最佳实践清单)
+12. [示例模板](#12-示例模板)
+
+---
+
+## 1. 设计理念
+
+### 1.1 核心原则
+
+| 原则 | 说明 | 实践 |
+|------|------|------|
+| **阶段化执行** | 复杂任务分解为有序阶段 | 使用 `phases/` 目录，数字前缀控制顺序 |
+| **关注点分离** | 逻辑、配置、视图分离 | `phases/`(逻辑) + `specs/`(配置) + `templates/`(视图) |
+| **简要返回** | Agent 返回路径+摘要，避免上下文溢出 | 返回 JSON 简要信息，文件存储完整内容 |
+| **配置驱动** | 规范作为"配置文件"，易于调整行为 | 修改 `specs/` 无需触及 `phases/` |
+| **模板复用** | 提取通用片段，确保一致性 | `templates/` 存放可复用内容 |
+
+### 1.2 架构模式
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│  Context-Optimized Architecture                                  │
+├─────────────────────────────────────────────────────────────────┤
+│                                                                  │
+│  SKILL.md (入口)  →  描述目标、定义阶段、链接资源                 │
+│       ↓                                                          │
+│  Phase 1: 收集    →  用户输入 + 自动检测 → config.json            │
+│       ↓                                                          │
+│  Phase 2: 分析    →  并行 Agent → sections/*.md                  │
+│       ↓                                                          │
+│  Phase N: 汇总    →  交叉检查 → summary.md                       │
+│       ↓                                                          │
+│  Phase N+1: 组装  →  合并文件 → 最终产物                          │
+│       ↓                                                          │
+│  Phase N+2: 迭代  →  用户反馈 → 优化                              │
+│                                                                  │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+---
+
+## 2. 目录结构规范
+
+### 2.1 标准目录结构
+
+```
+[skill-name]/
+├── SKILL.md                     # 【必需】技能入口：元数据 + 架构 + 执行流程
+├── phases/                      # 【必需】执行阶段 Prompt
+│   ├── 01-{first-step}.md       #   数字前缀定义顺序
+│   ├── 02-{second-step}.md
+│   ├── 02.5-{sub-step}.md       #   小数点用于插入子步骤
+│   └── ...
+├── specs/                       # 【必需】规范与约束
+│   ├── {domain}-requirements.md #   领域特定要求
+│   ├── quality-standards.md     #   质量标准
+│   └── writing-style.md         #   写作风格（如适用）
+├── templates/                   # 【推荐】可复用模板
+│   ├── agent-base.md            #   Agent 基础 Prompt 模板
+│   ├── output-shell.{ext}       #   输出外壳模板（html/md）
+│   └── css/                     #   样式文件（如适用）
+├── scripts/                     # 【可选】辅助脚本
+│   ├── {tool}.py                #   Python 脚本
+│   └── {tool}-runner.md         #   脚本使用说明
+└── outputs/                     # 【运行时】执行产物（不纳入版本控制）
+```
+
+### 2.2 命名约定
+
+| 类型 | 规则 | 示例 |
+|------|------|------|
+| Skill 目录 | 小写-连字符 | `software-manual`, `copyright-docs` |
+| Phase 文件 | `NN-{动作}.md` | `01-metadata-collection.md` |
+| Spec 文件 | `{领域}-{类型}.md` | `cpcc-requirements.md` |
+| Template 文件 | `{用途}-{类型}.{ext}` | `agent-base.md`, `tiddlywiki-shell.html` |
+| 输出文件 | `section-{N}-{名称}.md` | `section-2-architecture.md` |
+
+---
+
+## 3. 核心组件定义
+
+### 3.1 组件职责矩阵
+
+| 组件 | 职责 | 内容类型 | 修改频率 |
+|------|------|----------|----------|
+| `SKILL.md` | 入口 + 编排 | 元数据、架构图、执行流程 | 低（结构稳定） |
+| `phases/*.md` | 执行逻辑 | 步骤说明、Prompt、代码示例 | 中（优化迭代） |
+| `specs/*.md` | 约束配置 | 规则、标准、检查清单 | 中（需求变更） |
+| `templates/*` | 可复用片段 | Prompt 模板、输出格式 | 低（通用稳定） |
+| `scripts/*` | 自动化 | Python/JS 脚本 | 高（功能增强） |
+
+### 3.2 组件依赖关系
+
+```mermaid
+graph TD
+    SKILL[SKILL.md] --> P1[phases/01-*]
+    P1 --> P2[phases/02-*]
+    P2 --> PN[phases/N-*]
+    
+    P1 -.->|引用| SPEC[specs/*]
+    P2 -.->|引用| SPEC
+    PN -.->|引用| SPEC
+    
+    P1 -.->|使用| TPL[templates/*]
+    PN -.->|使用| TPL
+    
+    P2 -->|调用| SCR[scripts/*]
+    
+    style SKILL fill:#e1f5fe
+    style SPEC fill:#fff3e0
+    style TPL fill:#e8f5e9
+    style SCR fill:#fce4ec
+```
+
+---
+
+## 4. SKILL.md 入口规范
+
+### 4.1 必需结构
+
+```markdown
+---
+name: {skill-name}
+description: {一句话描述}. {触发关键词}. Triggers on "{关键词1}", "{关键词2}".
+allowed-tools: Task, AskUserQuestion, Read, Bash, Glob, Grep, Write, {其他MCP工具}
+---
+
+# {Skill 标题}
+
+{一段话描述 Skill 的用途和产出}
+
+## Architecture Overview
+
+{ASCII 或 Mermaid 架构图}
+
+## Key Design Principles
+
+1. **原则1**: 说明
+2. **原则2**: 说明
+...
+
+## Execution Flow
+
+{阶段执行流程图}
+
+## Agent Configuration (如适用)
+
+| Agent | Role | Output File | Focus Areas |
+|-------|------|-------------|-------------|
+| ... | ... | ... | ... |
+
+## Directory Setup
+
+{工作目录创建代码}
+
+## Output Structure
+
+{输出目录结构}
+
+## Reference Documents
+
+| Document | Purpose |
+|----------|---------|
+| [phases/01-xxx.md](phases/01-xxx.md) | ... |
+| ... | ... |
+```
+
+### 4.2 Front Matter 规范
+
+```yaml
+---
+name: skill-name              # 必需：Skill 唯一标识
+description: |                # 必需：描述 + 触发词
+  Generate XXX documents. 
+  Triggers on "keyword1", "keyword2".
+allowed-tools: |              # 必需：允许使用的工具
+  Task, AskUserQuestion, Read, Bash, 
+  Glob, Grep, Write, mcp__chrome__*
+---
+```
+
+---
+
+## 5. Phase 阶段设计规范
+
+### 5.1 Phase 文件结构
+
+```markdown
+# Phase N: {阶段名称}
+
+{一句话描述此阶段目标}
+
+## Objective
+
+{详细目标说明}
+- 目标1
+- 目标2
+
+## Execution Steps
+
+### Step 1: {步骤名称}
+
+{代码或说明}
+
+### Step 2: {步骤名称}
+
+{代码或说明}
+
+## Output
+
+- **File**: `{输出文件名}`
+- **Location**: `{输出路径}`
+- **Format**: {JSON/Markdown/HTML}
+
+## Next Phase
+
+Proceed to [Phase N+1: xxx](0N+1-xxx.md) with the generated {产出}.
+```
+
+### 5.2 Phase 类型
+
+| 类型 | 特点 | 示例 |
+|------|------|------|
+| **收集型** | 用户交互 + 自动检测 | `01-requirements-discovery.md` |
+| **探索型** | 代码分析 + 结构识别 | `02-project-exploration.md` |
+| **并行型** | 多 Agent 并行执行 | `03-parallel-analysis.md` |
+| **汇总型** | 交叉检查 + 质量验证 | `03.5-consolidation.md` |
+| **组装型** | 合并产出 + 格式化 | `04-document-assembly.md` |
+| **迭代型** | 用户反馈 + 优化 | `05-iterative-refinement.md` |
+
+### 5.3 Phase 编号规则
+
+```
+01-xxx.md      # 主阶段
+02-xxx.md      # 主阶段
+02.5-xxx.md    # 子阶段（插入 02 和 03 之间）
+03-xxx.md      # 主阶段
+```
+
+---
+
+## 6. Specs 规范文件设计
+
+### 6.1 Specs 类型
+
+| 类型 | 用途 | 示例 |
+|------|------|------|
+| **领域要求** | 领域特定合规性 | `cpcc-requirements.md` |
+| **质量标准** | 输出质量评估 | `quality-standards.md` |
+| **写作风格** | 内容风格指南 | `writing-style.md` |
+| **模板规范** | 输出格式定义 | `html-template.md` |
+
+### 6.2 Specs 结构模板
+
+```markdown
+# {规范名称}
+
+{规范用途说明}
+
+## When to Use
+
+| Phase | Usage | Section |
+|-------|-------|---------|
+| Phase N | {使用场景} | {引用章节} |
+| ... | ... | ... |
+
+---
+
+## Requirements
+
+### Category 1
+
+- [ ] 检查项1
+- [ ] 检查项2
+
+### Category 2
+
+| 项目 | 要求 | 检查方式 |
+|------|------|----------|
+| ... | ... | ... |
+
+## Validation Function
+
+{验证函数代码}
+
+## Error Handling
+
+| Error | Recovery |
+|-------|----------|
+| ... | ... |
+```
+
+### 6.3 质量标准示例结构
+
+```markdown
+# Quality Standards
+
+## Quality Dimensions
+
+### 1. Completeness (25%)
+{评分标准}
+
+### 2. Consistency (25%)
+{评分标准}
+
+### 3. Depth (25%)
+{评分标准}
+
+### 4. Readability (25%)
+{评分标准}
+
+## Quality Gates
+
+| Gate | Threshold | Action |
+|------|-----------|--------|
+| Pass | ≥ 80% | 继续执行 |
+| Review | 60-79% | 处理警告后继续 |
+| Fail | < 60% | 必须修复 |
+
+## Issue Classification
+
+### Errors (Must Fix)
+- ...
+
+### Warnings (Should Fix)
+- ...
+
+### Info (Nice to Have)
+- ...
+```
+
+---
+
+## 7. Templates 模板设计
+
+### 7.1 Agent 基础模板
+
+```markdown
+# Agent Base Template
+
+## 通用提示词结构
+
+[ROLE] 你是{角色}，专注于{职责}。
+
+[TASK]
+{任务描述}
+- 输出: {output_path}
+- 格式: {format}
+- 范围: {scope}
+
+[CONSTRAINTS]
+- 约束1
+- 约束2
+
+[OUTPUT_FORMAT]
+1. 直接写入文件
+2. 返回 JSON 简要信息
+
+[QUALITY_CHECKLIST]
+- [ ] 检查项1
+- [ ] 检查项2
+
+## 变量说明
+
+| 变量 | 来源 | 示例 |
+|------|------|------|
+| {output_dir} | Phase 1 | .workflow/.scratchpad/xxx |
+| ... | ... | ... |
+
+## Agent 配置映射
+
+{AGENT_ROLES, AGENT_SECTIONS, AGENT_FILES, AGENT_FOCUS}
+```
+
+### 7.2 输出模板规范
+
+```html
+<!-- output-shell.html 示例 -->
+<!DOCTYPE html>
+<html>
+<head>
+    <meta charset="UTF-8">
+    <title>{{title}}</title>
+    <style>
+        /* 内嵌 CSS */
+        {{styles}}
+    </style>
+</head>
+<body>
+    <div id="app">
+        {{content}}
+    </div>
+    <script>
+        /* 内嵌 JS */
+        {{scripts}}
+    </script>
+</body>
+</html>
+```
+
+### 7.3 占位符规范
+
+| 占位符格式 | 用途 | 示例 |
+|------------|------|------|
+| `{{variable}}` | 简单变量替换 | `{{title}}` |
+| `${variable}` | JavaScript 模板字符串 | `${workDir}` |
+| `{placeholder}` | Prompt 占位 | `{intro}`, `{diagram}` |
+
+---
+
+## 8. Scripts 脚本规范
+
+### 8.1 脚本类型
+
+| 类型 | 用途 | 命名 |
+|------|------|------|
+| **提取器** | 从代码提取信息 | `extract_*.py` |
+| **组装器** | 合并/转换文件 | `assemble_*.py` |
+| **验证器** | 检查合规性 | `validate_*.py` |
+| **辅助器** | 工具函数 | `*_helper.py` |
+
+### 8.2 脚本使用说明文件
+
+每个脚本应有对应的 `.md` 说明文件：
+
+```markdown
+# {Script Name} Runner
+
+## Purpose
+
+{脚本用途}
+
+## Usage
+
+{命令行使用方式}
+
+## Parameters
+
+| 参数 | 说明 | 默认值 |
+|------|------|--------|
+| ... | ... | ... |
+
+## Output
+
+{输出说明}
+
+## Example
+
+{使用示例}
+```
+
+---
+
+## 9. Prompt 工程规范
+
+### 9.1 Prompt 结构标准
+
+```
+[ROLE] {角色定义}
+
+[PROJECT CONTEXT]
+项目类型: {type}
+语言: {language}
+名称: {name}
+
+[TASK]
+{任务描述}
+输出: {output_path}
+
+[INPUT]
+- 配置: {config_path}
+- 扫描路径: {scan_paths}
+
+[CONTENT REQUIREMENTS]
+- 标题层级: # ## ### (最多3级)
+- 代码块: ```language ... ``` (必须标注语言)
+- 表格: | col1 | col2 | 格式
+- 列表: 有序 1. 2. 3. / 无序 - - -
+
+[FOCUS]
+{重点关注项}
+
+[OUTPUT FORMAT]
+{输出格式说明}
+
+[RETURN JSON]
+{返回结构}
+```
+
+### 9.2 效率优化原则
+
+| 原则 | Before (冗余) | After (精简) |
+|------|---------------|--------------|
+| **角色简化** | "你是一个专业的系统架构师，具有丰富的软件设计经验..." | `[ROLE] 系统架构师，专注于分层设计和模块依赖` |
+| **模板驱动** | "请按照以下格式输出: 首先写一个二级标题..." | `[TEMPLATE] ## 2. 标题 {content}` |
+| **焦点明确** | "分析项目的各个方面，包括架构、模块、依赖等" | `[FOCUS] 1. 分层 2. 模块 3. 依赖 4. 数据流` |
+| **返回简洁** | "请返回详细的分析结果，包括所有发现的问题..." | `[RETURN] {"status":"completed","output_file":"xxx.md","summary":"<50字"}` |
+
+### 9.3 Agent 返回格式标准
+
+```typescript
+interface AgentReturn {
+  status: "completed" | "partial" | "failed";
+  output_file: string;           // 输出文件路径
+  summary: string;               // 最多 50 字摘要
+  cross_module_notes?: string[]; // 跨模块备注
+  stats?: {                      // 统计信息
+    diagrams?: number;
+    words?: number;
+  };
+  screenshots_needed?: Array<{   // 截图需求（如适用）
+    id: string;
+    url: string;
+    description: string;
+  }>;
+}
+```
+
+---
+
+## 10. 质量控制规范
+
+### 10.1 质量维度
+
+| 维度 | 权重 | 检查项 |
+|------|------|--------|
+| **完整性** | 25% | 所有必需章节存在且有实质内容 |
+| **一致性** | 25% | 术语、格式、风格统一 |
+| **深度** | 25% | 内容详尽、示例充分 |
+| **可读性** | 25% | 结构清晰、语言简洁 |
+
+### 10.2 质量门控
+
+```javascript
+const QUALITY_GATES = {
+  pass: { threshold: 80, action: "继续执行" },
+  review: { threshold: 60, action: "处理警告后继续" },
+  fail: { threshold: 0, action: "必须修复后重试" }
+};
+```
+
+### 10.3 问题分类
+
+| 级别 | 前缀 | 含义 | 处理方式 |
+|------|------|------|----------|
+| **Error** | E | 阻塞性问题 | 必须修复 |
+| **Warning** | W | 影响质量 | 建议修复 |
+| **Info** | I | 可改进项 | 可选修复 |
+
+### 10.4 自动化检查函数模板
+
+```javascript
+function runQualityChecks(workDir) {
+  const results = {
+    completeness: checkCompleteness(workDir),
+    consistency: checkConsistency(workDir),
+    depth: checkDepth(workDir),
+    readability: checkReadability(workDir)
+  };
+
+  results.overall = Object.values(results).reduce((a, b) => a + b) / 4;
+  
+  return {
+    score: results.overall,
+    gate: results.overall >= 80 ? 'pass' : 
+          results.overall >= 60 ? 'review' : 'fail',
+    details: results
+  };
+}
+```
+
+---
+
+## 11. 最佳实践清单
+
+### 11.1 Skill 设计
+
+- [ ] **单一职责**: 每个 Skill 专注一个领域
+- [ ] **清晰入口**: SKILL.md 完整描述目标和流程
+- [ ] **阶段分解**: 复杂任务拆分为 3-7 个阶段
+- [ ] **顺序命名**: 使用数字前缀控制执行顺序
+
+### 11.2 Phase 设计
+
+- [ ] **明确目标**: 每个 Phase 有清晰的输入输出
+- [ ] **独立可测**: 每个 Phase 可单独调试
+- [ ] **链接下一步**: 明确说明后续阶段
+
+### 11.3 Prompt 设计
+
+- [ ] **角色明确**: 使用 `[ROLE]` 定义 Agent 身份
+- [ ] **任务具体**: 使用 `[TASK]` 明确执行目标
+- [ ] **约束清晰**: 使用 `[CONSTRAINTS]` 定义边界
+- [ ] **返回简洁**: Agent 返回路径+摘要，非完整内容
+
+### 11.4 质量控制
+
+- [ ] **规范驱动**: 使用 `specs/` 定义可验证的标准
+- [ ] **汇总检查**: 设置 Consolidation 阶段交叉验证
+- [ ] **问题分级**: 区分 Error/Warning/Info
+- [ ] **迭代优化**: 支持用户反馈循环
+
+---
+
+## 12. 示例模板
+
+### 12.1 新 Skill 快速启动模板
+
+```bash
+# 创建 Skill 目录结构
+mkdir -p my-skill/{phases,specs,templates,scripts}
+
+# 创建核心文件
+touch my-skill/SKILL.md
+touch my-skill/phases/{01-collection,02-analysis,03-assembly}.md
+touch my-skill/specs/{requirements,quality-standards}.md
+touch my-skill/templates/agent-base.md
+```
+
+### 12.2 SKILL.md 最小模板
+
+```markdown
+---
+name: my-skill
+description: Generate XXX. Triggers on "keyword1", "keyword2".
+allowed-tools: Task, AskUserQuestion, Read, Bash, Glob, Grep, Write
+---
+
+# My Skill
+
+Generate XXX through multi-phase analysis.
+
+## Execution Flow
+
+1. Phase 1: Collection → config.json
+2. Phase 2: Analysis → sections/*.md
+3. Phase 3: Assembly → output.md
+
+## Reference Documents
+
+| Document | Purpose |
+|----------|---------|
+| [phases/01-collection.md](phases/01-collection.md) | 信息收集 |
+| [phases/02-analysis.md](phases/02-analysis.md) | 代码分析 |
+| [phases/03-assembly.md](phases/03-assembly.md) | 文档组装 |
+```
+
+---
+
+## 附录 A: 设计对比
+
+| 设计点 | software-manual | copyright-docs |
+|--------|-----------------|----------------|
+| 阶段数 | 6 | 5 |
+| 并行 Agent | 6 | 6 |
+| 输出格式 | HTML | Markdown |
+| 质量检查 | 4 维度评分 | CPCC 合规检查 |
+| 截图支持 | Chrome MCP | 无 |
+| 迭代优化 | 用户反馈循环 | 合规验证循环 |
+
+## 附录 B: 工具依赖
+
+| 工具 | 用途 | 适用 Skill |
+|------|------|------------|
+| `Task` | 启动子 Agent | 所有 |
+| `AskUserQuestion` | 用户交互 | 所有 |
+| `Read/Write/Glob/Grep` | 文件操作 | 所有 |
+| `Bash` | 脚本执行 | 需要自动化 |
+| `mcp__chrome__*` | 浏览器截图 | UI 相关 |
+
+---
+
+*规范版本: 1.0*  
+*基于: software-manual, copyright-docs*  
+*最后更新: 2026-01-03*

.claude/skills/ccw-help/SKILL.md

@@ -0,0 +1,116 @@
+---
+name: ccw-help
+description: CCW command help system. Search, browse, recommend commands. Triggers "ccw-help", "ccw-issue".
+allowed-tools: Read, Grep, Glob, AskUserQuestion
+version: 7.0.0
+---
+
+# CCW-Help Skill
+
+CCW 命令帮助系统，提供命令搜索、推荐、文档查看功能。
+
+## Trigger Conditions
+
+- 关键词: "ccw-help", "ccw-issue", "帮助", "命令", "怎么用"
+- 场景: 询问命令用法、搜索命令、请求下一步建议
+
+## Operation Modes
+
+### Mode 1: Command Search
+
+**Triggers**: "搜索命令", "find command", "search"
+
+**Process**:
+1. Query `command.json` commands array
+2. Filter by name, description, category
+3. Present top 3-5 relevant commands
+
+### Mode 2: Smart Recommendations
+
+**Triggers**: "下一步", "what's next", "推荐"
+
+**Process**:
+1. Query command's `flow.next_steps` in `command.json`
+2. Explain WHY each recommendation fits
+
+### Mode 3: Documentation
+
+**Triggers**: "怎么用", "how to use", "详情"
+
+**Process**:
+1. Locate command in `command.json`
+2. Read source file via `source` path
+3. Provide context-specific examples
+
+### Mode 4: Beginner Onboarding
+
+**Triggers**: "新手", "getting started", "常用命令"
+
+**Process**:
+1. Query `essential_commands` array
+2. Guide appropriate workflow entry point
+
+### Mode 5: Issue Reporting
+
+**Triggers**: "ccw-issue", "报告 bug"
+
+**Process**:
+1. Use AskUserQuestion to gather context
+2. Generate structured issue template
+
+## Data Source
+
+Single source of truth: **[command.json](command.json)**
+
+| Field | Purpose |
+|-------|---------|
+| `commands[]` | Flat command list with metadata |
+| `commands[].flow` | Relationships (next_steps, prerequisites) |
+| `commands[].essential` | Essential flag for onboarding |
+| `agents[]` | Agent directory |
+| `essential_commands[]` | Core commands list |
+
+### Source Path Format
+
+`source` 字段是相对路径（从 `skills/ccw-help/` 目录）：
+
+```json
+{
+  "name": "lite-plan",
+  "source": "../../../commands/workflow/lite-plan.md"
+}
+```
+
+## Slash Commands
+
+```bash
+/ccw-help                    # 通用帮助入口
+/ccw-help search <keyword>   # 搜索命令
+/ccw-help next <command>     # 获取下一步建议
+/ccw-issue                   # 问题报告
+```
+
+## Maintenance
+
+### Update Index
+
+```bash
+cd D:/Claude_dms3/.claude/skills/ccw-help
+python scripts/analyze_commands.py
+```
+
+脚本功能：扫描 commands/ 和 agents/ 目录，生成统一的 command.json
+
+## Statistics
+
+- **Commands**: 88+
+- **Agents**: 16
+- **Essential**: 10 核心命令
+
+## Core Principle
+
+**智能整合，非模板复制**
+
+- 理解用户具体情况
+- 整合多个来源信息
+- 定制示例和说明

.claude/skills/ccw-help/command.json

@@ -0,0 +1,520 @@
+{
+  "_metadata": {
+    "version": "2.0.0",
+    "total_commands": 45,
+    "total_agents": 16,
+    "description": "Unified CCW-Help command index"
+  },
+
+  "essential_commands": [
+    "/workflow:lite-plan",
+    "/workflow:lite-fix",
+    "/workflow:plan",
+    "/workflow:execute",
+    "/workflow:session:start",
+    "/workflow:review-session-cycle",
+    "/memory:docs",
+    "/workflow:brainstorm:artifacts",
+    "/workflow:action-plan-verify",
+    "/version"
+  ],
+
+  "commands": [
+    {
+      "name": "lite-plan",
+      "command": "/workflow:lite-plan",
+      "description": "Lightweight interactive planning with in-memory plan, dispatches to lite-execute",
+      "arguments": "[-e|--explore] \"task\"|file.md",
+      "category": "workflow",
+      "difficulty": "Intermediate",
+      "essential": true,
+      "flow": {
+        "next_steps": ["/workflow:lite-execute"],
+        "alternatives": ["/workflow:plan"]
+      },
+      "source": "../../../commands/workflow/lite-plan.md"
+    },
+    {
+      "name": "lite-execute",
+      "command": "/workflow:lite-execute",
+      "description": "Execute based on in-memory plan or prompt",
+      "arguments": "[--in-memory] \"task\"|file-path",
+      "category": "workflow",
+      "difficulty": "Intermediate",
+      "flow": {
+        "prerequisites": ["/workflow:lite-plan", "/workflow:lite-fix"]
+      },
+      "source": "../../../commands/workflow/lite-execute.md"
+    },
+    {
+      "name": "lite-fix",
+      "command": "/workflow:lite-fix",
+      "description": "Lightweight bug diagnosis and fix with optional hotfix mode",
+      "arguments": "[--hotfix] \"bug description\"",
+      "category": "workflow",
+      "difficulty": "Intermediate",
+      "essential": true,
+      "flow": {
+        "next_steps": ["/workflow:lite-execute"],
+        "alternatives": ["/workflow:lite-plan"]
+      },
+      "source": "../../../commands/workflow/lite-fix.md"
+    },
+    {
+      "name": "plan",
+      "command": "/workflow:plan",
+      "description": "5-phase planning with task JSON generation",
+      "arguments": "\"description\"|file.md",
+      "category": "workflow",
+      "difficulty": "Intermediate",
+      "essential": true,
+      "flow": {
+        "next_steps": ["/workflow:action-plan-verify", "/workflow:execute"],
+        "alternatives": ["/workflow:tdd-plan"]
+      },
+      "source": "../../../commands/workflow/plan.md"
+    },
+    {
+      "name": "execute",
+      "command": "/workflow:execute",
+      "description": "Coordinate agent execution with DAG parallel processing",
+      "arguments": "[--resume-session=\"session-id\"]",
+      "category": "workflow",
+      "difficulty": "Intermediate",
+      "essential": true,
+      "flow": {
+        "prerequisites": ["/workflow:plan", "/workflow:tdd-plan"],
+        "next_steps": ["/workflow:review"]
+      },
+      "source": "../../../commands/workflow/execute.md"
+    },
+    {
+      "name": "action-plan-verify",
+      "command": "/workflow:action-plan-verify",
+      "description": "Cross-artifact consistency analysis",
+      "arguments": "[--session session-id]",
+      "category": "workflow",
+      "difficulty": "Intermediate",
+      "essential": true,
+      "flow": {
+        "prerequisites": ["/workflow:plan"],
+        "next_steps": ["/workflow:execute"]
+      },
+      "source": "../../../commands/workflow/action-plan-verify.md"
+    },
+    {
+      "name": "init",
+      "command": "/workflow:init",
+      "description": "Initialize project-level state",
+      "arguments": "[--regenerate]",
+      "category": "workflow",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/workflow/init.md"
+    },
+    {
+      "name": "clean",
+      "command": "/workflow:clean",
+      "description": "Intelligent code cleanup with stale artifact discovery",
+      "arguments": "[--dry-run] [\"focus\"]",
+      "category": "workflow",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/workflow/clean.md"
+    },
+    {
+      "name": "debug",
+      "command": "/workflow:debug",
+      "description": "Hypothesis-driven debugging with NDJSON logging",
+      "arguments": "\"bug description\"",
+      "category": "workflow",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/workflow/debug.md"
+    },
+    {
+      "name": "replan",
+      "command": "/workflow:replan",
+      "description": "Interactive workflow replanning",
+      "arguments": "[--session id] [task-id] \"requirements\"",
+      "category": "workflow",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/workflow/replan.md"
+    },
+    {
+      "name": "session:start",
+      "command": "/workflow:session:start",
+      "description": "Start or discover workflow sessions",
+      "arguments": "[--type <workflow|review|tdd>] [--auto|--new]",
+      "category": "workflow",
+      "subcategory": "session",
+      "difficulty": "Intermediate",
+      "essential": true,
+      "flow": {
+        "next_steps": ["/workflow:plan", "/workflow:execute"]
+      },
+      "source": "../../../commands/workflow/session/start.md"
+    },
+    {
+      "name": "session:list",
+      "command": "/workflow:session:list",
+      "description": "List all workflow sessions",
+      "arguments": "",
+      "category": "workflow",
+      "subcategory": "session",
+      "difficulty": "Beginner",
+      "source": "../../../commands/workflow/session/list.md"
+    },
+    {
+      "name": "session:resume",
+      "command": "/workflow:session:resume",
+      "description": "Resume paused workflow session",
+      "arguments": "",
+      "category": "workflow",
+      "subcategory": "session",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/workflow/session/resume.md"
+    },
+    {
+      "name": "session:complete",
+      "command": "/workflow:session:complete",
+      "description": "Mark session complete and archive",
+      "arguments": "",
+      "category": "workflow",
+      "subcategory": "session",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/workflow/session/complete.md"
+    },
+    {
+      "name": "brainstorm:auto-parallel",
+      "command": "/workflow:brainstorm:auto-parallel",
+      "description": "Parallel brainstorming with multi-role analysis",
+      "arguments": "\"topic\" [--count N]",
+      "category": "workflow",
+      "subcategory": "brainstorm",
+      "difficulty": "Advanced",
+      "source": "../../../commands/workflow/brainstorm/auto-parallel.md"
+    },
+    {
+      "name": "brainstorm:artifacts",
+      "command": "/workflow:brainstorm:artifacts",
+      "description": "Interactive clarification with guidance specification",
+      "arguments": "\"topic\" [--count N]",
+      "category": "workflow",
+      "subcategory": "brainstorm",
+      "difficulty": "Intermediate",
+      "essential": true,
+      "source": "../../../commands/workflow/brainstorm/artifacts.md"
+    },
+    {
+      "name": "brainstorm:synthesis",
+      "command": "/workflow:brainstorm:synthesis",
+      "description": "Refine role analyses through Q&A",
+      "arguments": "[--session session-id]",
+      "category": "workflow",
+      "subcategory": "brainstorm",
+      "difficulty": "Advanced",
+      "source": "../../../commands/workflow/brainstorm/synthesis.md"
+    },
+    {
+      "name": "tdd-plan",
+      "command": "/workflow:tdd-plan",
+      "description": "TDD planning with Red-Green-Refactor cycles",
+      "arguments": "\"feature\"|file.md",
+      "category": "workflow",
+      "difficulty": "Advanced",
+      "flow": {
+        "next_steps": ["/workflow:execute", "/workflow:tdd-verify"],
+        "alternatives": ["/workflow:plan"]
+      },
+      "source": "../../../commands/workflow/tdd-plan.md"
+    },
+    {
+      "name": "tdd-verify",
+      "command": "/workflow:tdd-verify",
+      "description": "Verify TDD compliance with coverage analysis",
+      "arguments": "[session-id]",
+      "category": "workflow",
+      "difficulty": "Advanced",
+      "flow": {
+        "prerequisites": ["/workflow:execute"]
+      },
+      "source": "../../../commands/workflow/tdd-verify.md"
+    },
+    {
+      "name": "review",
+      "command": "/workflow:review",
+      "description": "Post-implementation review (security/architecture/quality)",
+      "arguments": "[--type=<type>] [session-id]",
+      "category": "workflow",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/workflow/review.md"
+    },
+    {
+      "name": "review-session-cycle",
+      "command": "/workflow:review-session-cycle",
+      "description": "Multi-dimensional code review across 7 dimensions",
+      "arguments": "[session-id] [--dimensions=...]",
+      "category": "workflow",
+      "difficulty": "Intermediate",
+      "essential": true,
+      "flow": {
+        "prerequisites": ["/workflow:execute"],
+        "next_steps": ["/workflow:review-fix"]
+      },
+      "source": "../../../commands/workflow/review-session-cycle.md"
+    },
+    {
+      "name": "review-module-cycle",
+      "command": "/workflow:review-module-cycle",
+      "description": "Module-based multi-dimensional review",
+      "arguments": "<path-pattern> [--dimensions=...]",
+      "category": "workflow",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/workflow/review-module-cycle.md"
+    },
+    {
+      "name": "review-fix",
+      "command": "/workflow:review-fix",
+      "description": "Automated fixing of review findings",
+      "arguments": "<export-file|review-dir>",
+      "category": "workflow",
+      "difficulty": "Intermediate",
+      "flow": {
+        "prerequisites": ["/workflow:review-session-cycle", "/workflow:review-module-cycle"]
+      },
+      "source": "../../../commands/workflow/review-fix.md"
+    },
+    {
+      "name": "test-gen",
+      "command": "/workflow:test-gen",
+      "description": "Generate test session from implementation",
+      "arguments": "source-session-id",
+      "category": "workflow",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/workflow/test-gen.md"
+    },
+    {
+      "name": "test-fix-gen",
+      "command": "/workflow:test-fix-gen",
+      "description": "Create test-fix session with strategy",
+      "arguments": "session-id|\"description\"|file",
+      "category": "workflow",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/workflow/test-fix-gen.md"
+    },
+    {
+      "name": "test-cycle-execute",
+      "command": "/workflow:test-cycle-execute",
+      "description": "Execute test-fix with iterative cycles",
+      "arguments": "[--resume-session=id] [--max-iterations=N]",
+      "category": "workflow",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/workflow/test-cycle-execute.md"
+    },
+    {
+      "name": "issue:new",
+      "command": "/issue:new",
+      "description": "Create issue from GitHub URL or text",
+      "arguments": "<url|text> [--priority 1-5]",
+      "category": "issue",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/issue/new.md"
+    },
+    {
+      "name": "issue:discover",
+      "command": "/issue:discover",
+      "description": "Discover issues from multiple perspectives",
+      "arguments": "<path> [--perspectives=...]",
+      "category": "issue",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/issue/discover.md"
+    },
+    {
+      "name": "issue:plan",
+      "command": "/issue:plan",
+      "description": "Batch plan issue resolution",
+      "arguments": "--all-pending|<ids>",
+      "category": "issue",
+      "difficulty": "Intermediate",
+      "flow": {
+        "next_steps": ["/issue:queue"]
+      },
+      "source": "../../../commands/issue/plan.md"
+    },
+    {
+      "name": "issue:queue",
+      "command": "/issue:queue",
+      "description": "Form execution queue from solutions",
+      "arguments": "[--rebuild]",
+      "category": "issue",
+      "difficulty": "Intermediate",
+      "flow": {
+        "prerequisites": ["/issue:plan"],
+        "next_steps": ["/issue:execute"]
+      },
+      "source": "../../../commands/issue/queue.md"
+    },
+    {
+      "name": "issue:execute",
+      "command": "/issue:execute",
+      "description": "Execute queue with DAG parallel",
+      "arguments": "[--worktree]",
+      "category": "issue",
+      "difficulty": "Intermediate",
+      "flow": {
+        "prerequisites": ["/issue:queue"]
+      },
+      "source": "../../../commands/issue/execute.md"
+    },
+    {
+      "name": "docs",
+      "command": "/memory:docs",
+      "description": "Plan documentation workflow",
+      "arguments": "[path] [--tool <tool>]",
+      "category": "memory",
+      "difficulty": "Intermediate",
+      "essential": true,
+      "flow": {
+        "next_steps": ["/workflow:execute"]
+      },
+      "source": "../../../commands/memory/docs.md"
+    },
+    {
+      "name": "update-related",
+      "command": "/memory:update-related",
+      "description": "Update docs for git-changed modules",
+      "arguments": "[--tool <tool>]",
+      "category": "memory",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/memory/update-related.md"
+    },
+    {
+      "name": "update-full",
+      "command": "/memory:update-full",
+      "description": "Update all CLAUDE.md files",
+      "arguments": "[--tool <tool>]",
+      "category": "memory",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/memory/update-full.md"
+    },
+    {
+      "name": "skill-memory",
+      "command": "/memory:skill-memory",
+      "description": "Generate SKILL.md with loading index",
+      "arguments": "[path] [--regenerate]",
+      "category": "memory",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/memory/skill-memory.md"
+    },
+    {
+      "name": "load-skill-memory",
+      "command": "/memory:load-skill-memory",
+      "description": "Activate SKILL package for task",
+      "arguments": "[skill_name] \"task intent\"",
+      "category": "memory",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/memory/load-skill-memory.md"
+    },
+    {
+      "name": "load",
+      "command": "/memory:load",
+      "description": "Load project context via CLI",
+      "arguments": "[--tool <tool>] \"context\"",
+      "category": "memory",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/memory/load.md"
+    },
+    {
+      "name": "compact",
+      "command": "/memory:compact",
+      "description": "Compact session memory for recovery",
+      "arguments": "[description]",
+      "category": "memory",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/memory/compact.md"
+    },
+    {
+      "name": "task:create",
+      "command": "/task:create",
+      "description": "Generate task JSON from description",
+      "arguments": "\"task title\"",
+      "category": "task",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/task/create.md"
+    },
+    {
+      "name": "task:execute",
+      "command": "/task:execute",
+      "description": "Execute task JSON with agent",
+      "arguments": "task-id",
+      "category": "task",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/task/execute.md"
+    },
+    {
+      "name": "task:breakdown",
+      "command": "/task:breakdown",
+      "description": "Decompose task into subtasks",
+      "arguments": "task-id",
+      "category": "task",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/task/breakdown.md"
+    },
+    {
+      "name": "task:replan",
+      "command": "/task:replan",
+      "description": "Update task with new requirements",
+      "arguments": "task-id [\"text\"|file]",
+      "category": "task",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/task/replan.md"
+    },
+    {
+      "name": "version",
+      "command": "/version",
+      "description": "Display version and check updates",
+      "arguments": "",
+      "category": "general",
+      "difficulty": "Beginner",
+      "essential": true,
+      "source": "../../../commands/version.md"
+    },
+    {
+      "name": "enhance-prompt",
+      "command": "/enhance-prompt",
+      "description": "Transform prompts with session memory",
+      "arguments": "user input",
+      "category": "general",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/enhance-prompt.md"
+    },
+    {
+      "name": "cli-init",
+      "command": "/cli:cli-init",
+      "description": "Initialize CLI tool configurations (.gemini/, .qwen/) with technology-aware ignore rules",
+      "arguments": "[--tool gemini|qwen|all] [--preview] [--output path]",
+      "category": "cli",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/cli/cli-init.md"
+    }
+  ],
+
+  "agents": [
+    { "name": "action-planning-agent", "description": "Task planning and generation", "source": "../../../agents/action-planning-agent.md" },
+    { "name": "cli-execution-agent", "description": "CLI tool execution", "source": "../../../agents/cli-execution-agent.md" },
+    { "name": "cli-explore-agent", "description": "Codebase exploration", "source": "../../../agents/cli-explore-agent.md" },
+    { "name": "cli-lite-planning-agent", "description": "Lightweight planning", "source": "../../../agents/cli-lite-planning-agent.md" },
+    { "name": "cli-planning-agent", "description": "CLI-based planning", "source": "../../../agents/cli-planning-agent.md" },
+    { "name": "code-developer", "description": "Code implementation", "source": "../../../agents/code-developer.md" },
+    { "name": "conceptual-planning-agent", "description": "Conceptual analysis", "source": "../../../agents/conceptual-planning-agent.md" },
+    { "name": "context-search-agent", "description": "Context discovery", "source": "../../../agents/context-search-agent.md" },
+    { "name": "doc-generator", "description": "Documentation generation", "source": "../../../agents/doc-generator.md" },
+    { "name": "issue-plan-agent", "description": "Issue planning", "source": "../../../agents/issue-plan-agent.md" },
+    { "name": "issue-queue-agent", "description": "Issue queue formation", "source": "../../../agents/issue-queue-agent.md" },
+    { "name": "memory-bridge", "description": "Documentation coordination", "source": "../../../agents/memory-bridge.md" },
+    { "name": "test-context-search-agent", "description": "Test context collection", "source": "../../../agents/test-context-search-agent.md" },
+    { "name": "test-fix-agent", "description": "Test execution and fixing", "source": "../../../agents/test-fix-agent.md" },
+    { "name": "ui-design-agent", "description": "UI design and prototyping", "source": "../../../agents/ui-design-agent.md" },
+    { "name": "universal-executor", "description": "Universal task execution", "source": "../../../agents/universal-executor.md" }
+  ],
+
+  "categories": ["workflow", "issue", "memory", "task", "general", "cli"]
+}

.claude/skills/ccw-help/scripts/analyze_commands.py

@@ -1,12 +1,12 @@
 #!/usr/bin/env python3
 """
-Analyze all command files and generate index files for command-guide skill.
+Analyze all command/agent files and generate index files for ccw-help skill.
+Outputs relative paths pointing to source files (no reference folder duplication).
 """
 
 import os
 import re
 import json
-import shutil
 from pathlib import Path
 from collections import defaultdict
 from typing import Dict, List, Any
@@ -15,8 +15,7 @@ from typing import Dict, List, Any
 BASE_DIR = Path("D:/Claude_dms3/.claude")
 COMMANDS_DIR = BASE_DIR / "commands"
 AGENTS_DIR = BASE_DIR / "agents"
-SKILL_DIR = BASE_DIR / "skills" / "command-guide"
-REFERENCE_DIR = SKILL_DIR / "reference"
+SKILL_DIR = BASE_DIR / "skills" / "ccw-help"
 INDEX_DIR = SKILL_DIR / "index"
 
 def parse_frontmatter(content: str) -> Dict[str, Any]:
@@ -24,7 +23,6 @@ def parse_frontmatter(content: str) -> Dict[str, Any]:
     frontmatter = {}
     if content.startswith('---'):
         lines = content.split('\n')
-        in_frontmatter = False
         for i, line in enumerate(lines[1:], 1):
             if line.strip() == '---':
                 break
@@ -48,49 +46,33 @@ def categorize_command(file_path: Path) -> tuple:
 def determine_usage_scenario(name: str, description: str, category: str) -> str:
     """Determine primary usage scenario for command."""
     name_lower = name.lower()
-    desc_lower = description.lower()
 
-    # Planning indicators
     if any(word in name_lower for word in ['plan', 'design', 'breakdown', 'brainstorm']):
         return "planning"
-
-    # Implementation indicators
     if any(word in name_lower for word in ['implement', 'execute', 'generate', 'create', 'write']):
         return "implementation"
-
-    # Testing indicators
     if any(word in name_lower for word in ['test', 'tdd', 'verify', 'coverage']):
         return "testing"
-
-    # Documentation indicators
     if any(word in name_lower for word in ['docs', 'documentation', 'memory']):
         return "documentation"
-
-    # Session management indicators
     if any(word in name_lower for word in ['session', 'resume', 'status', 'complete']):
         return "session-management"
-
-    # Analysis indicators
     if any(word in name_lower for word in ['analyze', 'review', 'diagnosis']):
         return "analysis"
-
     return "general"
 
 def determine_difficulty(name: str, description: str, category: str) -> str:
     """Determine difficulty level."""
     name_lower = name.lower()
 
-    # Beginner commands
     beginner_keywords = ['status', 'list', 'chat', 'analyze', 'version']
     if any(word in name_lower for word in beginner_keywords):
         return "Beginner"
 
-    # Advanced commands
     advanced_keywords = ['tdd', 'conflict', 'agent', 'auto-parallel', 'coverage', 'synthesis']
     if any(word in name_lower for word in advanced_keywords):
         return "Advanced"
 
-    # Intermediate by default
     return "Intermediate"
 
 def analyze_command_file(file_path: Path) -> Dict[str, Any]:
@@ -98,30 +80,27 @@ def analyze_command_file(file_path: Path) -> Dict[str, Any]:
     with open(file_path, 'r', encoding='utf-8') as f:
         content = f.read()
 
-    # Parse frontmatter
     frontmatter = parse_frontmatter(content)
 
-    # Extract data
     name = frontmatter.get('name', file_path.stem)
     description = frontmatter.get('description', '')
     argument_hint = frontmatter.get('argument-hint', '')
 
-    # Determine categorization
     category, subcategory = categorize_command(file_path)
     usage_scenario = determine_usage_scenario(name, description, category)
     difficulty = determine_difficulty(name, description, category)
 
-    # Build relative path
-    rel_path = str(file_path.relative_to(COMMANDS_DIR)).replace('\\', '/')
+    # Build relative path from INDEX_DIR (need to go up 3 levels: index -> ccw-help -> skills -> .claude)
+    # e.g., "../../../commands/workflow/lite-plan.md"
+    rel_from_base = file_path.relative_to(BASE_DIR)
+    rel_path = "../../../" + str(rel_from_base).replace('\\', '/')
 
-    # Build full command name from frontmatter name or construct it
-    # If name already contains colons (e.g., "workflow:status"), use it directly
+    # Build full command name
     if ':' in name:
         command_name = f"/{name}"
     elif category == "general":
         command_name = f"/{name}"
     else:
-        # For subcategorized commands, build the full path
         if subcategory:
             command_name = f"/{category}:{subcategory}:{name}"
         else:
@@ -136,43 +115,50 @@ def analyze_command_file(file_path: Path) -> Dict[str, Any]:
         "subcategory": subcategory,
         "usage_scenario": usage_scenario,
         "difficulty": difficulty,
-        "file_path": rel_path
+        "source": rel_path  # Relative from index/ dir (e.g., "../../../commands/workflow/...")
+    }
+
+def analyze_agent_file(file_path: Path) -> Dict[str, Any]:
+    """Analyze a single agent file and extract metadata."""
+    with open(file_path, 'r', encoding='utf-8') as f:
+        content = f.read()
+
+    frontmatter = parse_frontmatter(content)
+
+    name = frontmatter.get('name', file_path.stem)
+    description = frontmatter.get('description', '')
+
+    # Build relative path from INDEX_DIR (need to go up 3 levels)
+    # e.g., "../../../agents/code-developer.md"
+    rel_from_base = file_path.relative_to(BASE_DIR)
+    rel_path = "../../../" + str(rel_from_base).replace('\\', '/')
+
+    return {
+        "name": name,
+        "description": description,
+        "source": rel_path  # Relative from index/ dir (e.g., "../../../agents/...")
     }
 
 def build_command_relationships() -> Dict[str, Any]:
     """Build command relationship mappings."""
-    relationships = {
-        # Workflow planning commands
+    return {
         "workflow:plan": {
-            "calls_internally": [
-                "workflow:session:start",
-                "workflow:tools:context-gather",
-                "workflow:tools:conflict-resolution",
-                "workflow:tools:task-generate-agent"
-            ],
+            "calls_internally": ["workflow:session:start", "workflow:tools:context-gather", "workflow:tools:conflict-resolution", "workflow:tools:task-generate-agent"],
             "next_steps": ["workflow:action-plan-verify", "workflow:status", "workflow:execute"],
             "alternatives": ["workflow:tdd-plan"],
             "prerequisites": []
         },
         "workflow:tdd-plan": {
-            "calls_internally": [
-                "workflow:session:start",
-                "workflow:tools:context-gather",
-                "workflow:tools:task-generate-tdd"
-            ],
+            "calls_internally": ["workflow:session:start", "workflow:tools:context-gather", "workflow:tools:task-generate-tdd"],
             "next_steps": ["workflow:tdd-verify", "workflow:status", "workflow:execute"],
             "alternatives": ["workflow:plan"],
             "prerequisites": []
         },
-
-        # Execution commands
         "workflow:execute": {
             "prerequisites": ["workflow:plan", "workflow:tdd-plan"],
             "related": ["workflow:status", "workflow:resume"],
             "next_steps": ["workflow:review", "workflow:tdd-verify"]
         },
-
-        # Verification commands
         "workflow:action-plan-verify": {
             "prerequisites": ["workflow:plan"],
             "next_steps": ["workflow:execute"],
@@ -182,8 +168,6 @@ def build_command_relationships() -> Dict[str, Any]:
             "prerequisites": ["workflow:execute"],
             "related": ["workflow:tools:tdd-coverage-analysis"]
         },
-
-        # Session management
         "workflow:session:start": {
             "next_steps": ["workflow:plan", "workflow:execute"],
             "related": ["workflow:session:list", "workflow:session:resume"]
@@ -192,95 +176,6 @@ def build_command_relationships() -> Dict[str, Any]:
             "alternatives": ["workflow:resume"],
             "related": ["workflow:session:list", "workflow:status"]
         },
-        "workflow:resume": {
-            "alternatives": ["workflow:session:resume"],
-            "related": ["workflow:status"]
-        },
-
-        # Task management
-        "task:create": {
-            "next_steps": ["task:execute"],
-            "related": ["task:breakdown"]
-        },
-        "task:breakdown": {
-            "next_steps": ["task:execute"],
-            "related": ["task:create"]
-        },
-        "task:replan": {
-            "prerequisites": ["workflow:plan"],
-            "related": ["workflow:action-plan-verify"]
-        },
-        "task:execute": {
-            "prerequisites": ["task:create", "task:breakdown", "workflow:plan"],
-            "related": ["workflow:status"]
-        },
-
-        # Memory/Documentation
-        "memory:docs": {
-            "calls_internally": [
-                "workflow:session:start",
-                "workflow:tools:context-gather"
-            ],
-            "next_steps": ["workflow:execute"]
-        },
-        "memory:skill-memory": {
-            "next_steps": ["workflow:plan", "cli:analyze"],
-            "related": ["memory:load-skill-memory"]
-        },
-        "memory:workflow-skill-memory": {
-            "related": ["memory:skill-memory"],
-            "next_steps": ["workflow:plan"]
-        },
-
-        # CLI modes
-        "cli:execute": {
-            "alternatives": ["cli:codex-execute"],
-            "related": ["cli:analyze", "cli:chat"]
-        },
-        "cli:analyze": {
-            "related": ["cli:chat", "cli:mode:code-analysis"],
-            "next_steps": ["cli:execute"]
-        },
-
-        # Brainstorming
-        "workflow:brainstorm:artifacts": {
-            "next_steps": ["workflow:brainstorm:synthesis", "workflow:plan"],
-            "related": ["workflow:brainstorm:auto-parallel"]
-        },
-        "workflow:brainstorm:synthesis": {
-            "prerequisites": ["workflow:brainstorm:artifacts"],
-            "next_steps": ["workflow:plan"]
-        },
-        "workflow:brainstorm:auto-parallel": {
-            "next_steps": ["workflow:brainstorm:synthesis", "workflow:plan"],
-            "related": ["workflow:brainstorm:artifacts"]
-        },
-
-        # Test workflows
-        "workflow:test-gen": {
-            "prerequisites": ["workflow:execute"],
-            "next_steps": ["workflow:test-cycle-execute"]
-        },
-        "workflow:test-fix-gen": {
-            "alternatives": ["workflow:test-gen"],
-            "next_steps": ["workflow:test-cycle-execute"]
-        },
-        "workflow:test-cycle-execute": {
-            "prerequisites": ["workflow:test-gen", "workflow:test-fix-gen"],
-            "related": ["workflow:tdd-verify"]
-        },
-
-        # UI Design workflows
-        "workflow:ui-design:explore-auto": {
-            "calls_internally": ["workflow:ui-design:capture", "workflow:ui-design:style-extract", "workflow:ui-design:layout-extract"],
-            "next_steps": ["workflow:ui-design:generate"]
-        },
-        "workflow:ui-design:imitate-auto": {
-            "calls_internally": ["workflow:ui-design:capture"],
-            "next_steps": ["workflow:ui-design:generate"]
-        },
-
-        # Lite workflows
         "workflow:lite-plan": {
             "calls_internally": ["workflow:lite-execute"],
             "next_steps": ["workflow:lite-execute", "workflow:status"],
@@ -296,114 +191,59 @@ def build_command_relationships() -> Dict[str, Any]:
             "prerequisites": ["workflow:lite-plan", "workflow:lite-fix"],
             "related": ["workflow:execute", "workflow:status"]
         },
-
-        # Review cycle workflows
-        "workflow:review-module-cycle": {
-            "next_steps": ["workflow:review-fix"],
-            "related": ["workflow:review-session-cycle", "workflow:review"]
-        },
         "workflow:review-session-cycle": {
             "prerequisites": ["workflow:execute"],
             "next_steps": ["workflow:review-fix"],
-            "related": ["workflow:review-module-cycle", "workflow:review"]
+            "related": ["workflow:review-module-cycle"]
         },
         "workflow:review-fix": {
             "prerequisites": ["workflow:review-module-cycle", "workflow:review-session-cycle"],
             "related": ["workflow:test-cycle-execute"]
+        },
+        "memory:docs": {
+            "calls_internally": ["workflow:session:start", "workflow:tools:context-gather"],
+            "next_steps": ["workflow:execute"]
+        },
+        "memory:skill-memory": {
+            "next_steps": ["workflow:plan", "cli:analyze"],
+            "related": ["memory:load-skill-memory"]
         }
     }
 
-    return relationships
-
-def sync_reference_directory():
-    """Sync reference directory with source directories."""
-    print("\n=== Syncing Reference Directory ===")
-
-    # Step 1: Delete all files in reference directory
-    if REFERENCE_DIR.exists():
-        print(f"Deleting existing reference directory: {REFERENCE_DIR}")
-        shutil.rmtree(REFERENCE_DIR)
-
-    # Step 2: Create reference directory structure
-    REFERENCE_DIR.mkdir(parents=True, exist_ok=True)
-    print(f"Created reference directory: {REFERENCE_DIR}")
-
-    # Step 3: Copy agents directory
-    agents_target = REFERENCE_DIR / "agents"
-    if AGENTS_DIR.exists():
-        print(f"Copying {AGENTS_DIR} -> {agents_target}")
-        shutil.copytree(AGENTS_DIR, agents_target)
-        agent_files = list(agents_target.rglob("*.md"))
-        print(f"  Copied {len(agent_files)} agent files")
-    else:
-        print(f"  WARNING: Source directory not found: {AGENTS_DIR}")
-
-    # Step 4: Copy commands directory
-    commands_target = REFERENCE_DIR / "commands"
-    if COMMANDS_DIR.exists():
-        print(f"Copying {COMMANDS_DIR} -> {commands_target}")
-        shutil.copytree(COMMANDS_DIR, commands_target)
-        command_files = list(commands_target.rglob("*.md"))
-        print(f"  Copied {len(command_files)} command files")
-    else:
-        print(f"  WARNING: Source directory not found: {COMMANDS_DIR}")
-
-    print("Reference directory sync completed\n")
-
 def identify_essential_commands(all_commands: List[Dict]) -> List[Dict]:
     """Identify the most essential commands for beginners."""
-    # Essential command names (14 most important) - use full command paths
     essential_names = [
-        "workflow:lite-plan",
-        "workflow:lite-fix",
-        "workflow:plan",
-        "workflow:execute",
-        "workflow:status",
-        "workflow:session:start",
-        "workflow:review-session-cycle",
-        "cli:analyze",
-        "cli:chat",
-        "memory:docs",
-        "workflow:brainstorm:artifacts",
-        "workflow:action-plan-verify",
-        "workflow:resume",
-        "version"
+        "workflow:lite-plan", "workflow:lite-fix", "workflow:plan",
+        "workflow:execute", "workflow:status", "workflow:session:start",
+        "workflow:review-session-cycle", "cli:analyze", "cli:chat",
+        "memory:docs", "workflow:brainstorm:artifacts",
+        "workflow:action-plan-verify", "workflow:resume", "version"
     ]
 
     essential = []
     for cmd in all_commands:
-        # Check command name without leading slash
         cmd_name = cmd['command'].lstrip('/')
         if cmd_name in essential_names:
             essential.append(cmd)
 
-    # Sort by order in essential_names
-    essential.sort(key=lambda x: essential_names.index(x['command'].lstrip('/')))
-
-    return essential[:14]  # Limit to 14
+    essential.sort(key=lambda x: essential_names.index(x['command'].lstrip('/')) if x['command'].lstrip('/') in essential_names else 999)
+    return essential[:14]
 
 def main():
     """Main analysis function."""
     import sys
     import io
 
-    # Fix Windows console encoding
     if sys.platform == 'win32':
         sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8')
 
-    print("=== Command Guide Index Rebuild ===\n")
+    print("=== CCW-Help Index Rebuild ===\n")
 
-    # Step 1: Sync reference directory
-    sync_reference_directory()
-
-    # Step 2: Analyze command files
+    # Analyze command files
     print("=== Analyzing Command Files ===")
-
-    # Find all command files
     command_files = list(COMMANDS_DIR.rglob("*.md"))
     print(f"Found {len(command_files)} command files")
 
-    # Analyze each command
     all_commands = []
     for cmd_file in sorted(command_files):
         try:
@@ -413,7 +253,21 @@ def main():
         except Exception as e:
             print(f"  ERROR analyzing {cmd_file}: {e}")
 
-    print(f"\nAnalyzed {len(all_commands)} commands")
+    # Analyze agent files
+    print("\n=== Analyzing Agent Files ===")
+    agent_files = list(AGENTS_DIR.rglob("*.md"))
+    print(f"Found {len(agent_files)} agent files")
+
+    all_agents = []
+    for agent_file in sorted(agent_files):
+        try:
+            metadata = analyze_agent_file(agent_file)
+            all_agents.append(metadata)
+            print(f"  OK {metadata['name']}")
+        except Exception as e:
+            print(f"  ERROR analyzing {agent_file}: {e}")
+
+    print(f"\nAnalyzed {len(all_commands)} commands, {len(all_agents)} agents")
 
     # Generate index files
     INDEX_DIR.mkdir(parents=True, exist_ok=True)
@@ -422,9 +276,15 @@ def main():
     all_commands_path = INDEX_DIR / "all-commands.json"
     with open(all_commands_path, 'w', encoding='utf-8') as f:
         json.dump(all_commands, f, indent=2, ensure_ascii=False)
-    print(f"\nOK Generated {all_commands_path} ({os.path.getsize(all_commands_path)} bytes)")
+    print(f"\nOK Generated {all_commands_path.name} ({os.path.getsize(all_commands_path)} bytes)")
 
-    # 2. by-category.json
+    # 2. all-agents.json
+    all_agents_path = INDEX_DIR / "all-agents.json"
+    with open(all_agents_path, 'w', encoding='utf-8') as f:
+        json.dump(all_agents, f, indent=2, ensure_ascii=False)
+    print(f"OK Generated {all_agents_path.name} ({os.path.getsize(all_agents_path)} bytes)")
+
+    # 3. by-category.json
     by_category = defaultdict(lambda: defaultdict(list))
     for cmd in all_commands:
         cat = cmd['category']
@@ -434,9 +294,9 @@ def main():
     by_category_path = INDEX_DIR / "by-category.json"
     with open(by_category_path, 'w', encoding='utf-8') as f:
         json.dump(dict(by_category), f, indent=2, ensure_ascii=False)
-    print(f"OK Generated {by_category_path} ({os.path.getsize(by_category_path)} bytes)")
+    print(f"OK Generated {by_category_path.name} ({os.path.getsize(by_category_path)} bytes)")
 
-    # 3. by-use-case.json
+    # 4. by-use-case.json
     by_use_case = defaultdict(list)
     for cmd in all_commands:
         by_use_case[cmd['usage_scenario']].append(cmd)
@@ -444,59 +304,34 @@ def main():
     by_use_case_path = INDEX_DIR / "by-use-case.json"
     with open(by_use_case_path, 'w', encoding='utf-8') as f:
         json.dump(dict(by_use_case), f, indent=2, ensure_ascii=False)
-    print(f"OK Generated {by_use_case_path} ({os.path.getsize(by_use_case_path)} bytes)")
+    print(f"OK Generated {by_use_case_path.name} ({os.path.getsize(by_use_case_path)} bytes)")
 
-    # 4. essential-commands.json
+    # 5. essential-commands.json
     essential = identify_essential_commands(all_commands)
     essential_path = INDEX_DIR / "essential-commands.json"
     with open(essential_path, 'w', encoding='utf-8') as f:
         json.dump(essential, f, indent=2, ensure_ascii=False)
-    print(f"OK Generated {essential_path} ({os.path.getsize(essential_path)} bytes)")
+    print(f"OK Generated {essential_path.name} ({os.path.getsize(essential_path)} bytes)")
 
-    # 5. command-relationships.json
+    # 6. command-relationships.json
     relationships = build_command_relationships()
     relationships_path = INDEX_DIR / "command-relationships.json"
     with open(relationships_path, 'w', encoding='utf-8') as f:
         json.dump(relationships, f, indent=2, ensure_ascii=False)
-    print(f"OK Generated {relationships_path} ({os.path.getsize(relationships_path)} bytes)")
+    print(f"OK Generated {relationships_path.name} ({os.path.getsize(relationships_path)} bytes)")
 
-    # Print summary statistics
-    print("\n=== Summary Statistics ===")
-
-    # Reference directory statistics
-    if REFERENCE_DIR.exists():
-        ref_agents = list((REFERENCE_DIR / "agents").rglob("*.md")) if (REFERENCE_DIR / "agents").exists() else []
-        ref_commands = list((REFERENCE_DIR / "commands").rglob("*.md")) if (REFERENCE_DIR / "commands").exists() else []
-        print(f"\nReference directory:")
-        print(f"  Agents: {len(ref_agents)} files")
-        print(f"  Commands: {len(ref_commands)} files")
-        print(f"  Total: {len(ref_agents) + len(ref_commands)} files")
-
-    print(f"\nTotal commands indexed: {len(all_commands)}")
+    # Print summary
+    print("\n=== Summary ===")
+    print(f"Commands: {len(all_commands)}")
+    print(f"Agents: {len(all_agents)}")
+    print(f"Essential: {len(essential)}")
     print(f"\nBy category:")
     for cat in sorted(by_category.keys()):
         total = sum(len(cmds) for cmds in by_category[cat].values())
         print(f"  {cat}: {total}")
-        for subcat in sorted(by_category[cat].keys()):
-            if subcat != '_root':
-                print(f"    - {subcat}: {len(by_category[cat][subcat])}")
 
-    print(f"\nBy usage scenario:")
-    for scenario in sorted(by_use_case.keys()):
-        print(f"  {scenario}: {len(by_use_case[scenario])}")
-
-    print(f"\nBy difficulty:")
-    difficulty_counts = defaultdict(int)
-    for cmd in all_commands:
-        difficulty_counts[cmd['difficulty']] += 1
-    for difficulty in ['Beginner', 'Intermediate', 'Advanced']:
-        print(f"  {difficulty}: {difficulty_counts[difficulty]}")
-
-    print(f"\nEssential commands: {len(essential)}")
-
-    print("\n=== Index Rebuild Complete ===")
-    print(f"Reference: {REFERENCE_DIR}")
-    print(f"Index: {INDEX_DIR}")
+    print(f"\nIndex: {INDEX_DIR}")
+    print("=== Complete ===")
 
 if __name__ == '__main__':
     main()

.claude/skills/ccw-loop/README.md

@@ -0,0 +1,303 @@
+# CCW Loop Skill
+
+无状态迭代开发循环工作流，支持开发 (Develop)、调试 (Debug)、验证 (Validate) 三个阶段，每个阶段都有独立的文件记录进展。
+
+## Overview
+
+CCW Loop 是一个自主模式 (Autonomous) 的 Skill，通过文件驱动的无状态循环，帮助开发者系统化地完成开发任务。
+
+### 核心特性
+
+1. **无状态循环**: 每次执行从文件读取状态，不依赖内存
+2. **文件驱动**: 所有进度记录在 Markdown 文件中，可审计、可回顾
+3. **Gemini 辅助**: 关键决策点使用 CLI 工具进行深度分析
+4. **可恢复**: 任何时候中断后可继续
+5. **双模式**: 支持交互式和自动循环
+
+### 三大阶段
+
+- **Develop**: 任务分解 → 代码实现 → 进度记录
+- **Debug**: 假设生成 → 证据收集 → 根因分析 → 修复验证
+- **Validate**: 测试执行 → 覆盖率检查 → 质量评估
+
+## Installation
+
+已包含在 `.claude/skills/ccw-loop/`，无需额外安装。
+
+## Usage
+
+### 基本用法
+
+```bash
+# 启动新循环
+/ccw-loop "实现用户认证功能"
+
+# 继续现有循环
+/ccw-loop --resume LOOP-auth-2026-01-22
+
+# 自动循环模式
+/ccw-loop --auto "修复登录bug并添加测试"
+```
+
+### 交互式流程
+
+```
+1. 启动: /ccw-loop "任务描述"
+2. 初始化: 自动分析任务并生成子任务列表
+3. 显示菜单:
+   - 📝 继续开发 (Develop)
+   - 🔍 开始调试 (Debug)
+   - ✅ 运行验证 (Validate)
+   - 📊 查看详情 (Status)
+   - 🏁 完成循环 (Complete)
+   - 🚪 退出 (Exit)
+4. 执行选择的动作
+5. 重复步骤 3-4 直到完成
+```
+
+### 自动循环流程
+
+```
+Develop (所有任务) → Debug (如有需要) → Validate → 完成
+```
+
+## Directory Structure
+
+```
+.workflow/.loop/{session-id}/
+├── meta.json              # 会话元数据 (不可修改)
+├── state.json             # 当前状态 (每次更新)
+├── summary.md             # 完成报告 (结束时生成)
+├── develop/
+│   ├── progress.md        # 开发进度时间线
+│   ├── tasks.json         # 任务列表
+│   └── changes.log        # 代码变更日志 (NDJSON)
+├── debug/
+│   ├── understanding.md   # 理解演变文档
+│   ├── hypotheses.json    # 假设历史
+│   └── debug.log          # 调试日志 (NDJSON)
+└── validate/
+    ├── validation.md      # 验证报告
+    ├── test-results.json  # 测试结果
+    └── coverage.json      # 覆盖率数据
+```
+
+## Action Reference
+
+| Action | 描述 | 触发条件 |
+|--------|------|----------|
+| action-init | 初始化会话 | 首次启动 |
+| action-menu | 显示操作菜单 | 交互模式下每次循环 |
+| action-develop-with-file | 执行开发任务 | 有待处理任务 |
+| action-debug-with-file | 假设驱动调试 | 需要调试 |
+| action-validate-with-file | 运行测试验证 | 需要验证 |
+| action-complete | 完成并生成报告 | 所有任务完成 |
+
+详细说明见 [specs/action-catalog.md](specs/action-catalog.md)
+
+## CLI Integration
+
+CCW Loop 在关键决策点集成 CLI 工具:
+
+### 任务分解 (action-init)
+```bash
+ccw cli -p "PURPOSE: 分解开发任务..."
+  --tool gemini
+  --mode analysis
+  --rule planning-breakdown-task-steps
+```
+
+### 代码实现 (action-develop)
+```bash
+ccw cli -p "PURPOSE: 实现功能代码..."
+  --tool gemini
+  --mode write
+  --rule development-implement-feature
+```
+
+### 假设生成 (action-debug - 探索)
+```bash
+ccw cli -p "PURPOSE: Generate debugging hypotheses..."
+  --tool gemini
+  --mode analysis
+  --rule analysis-diagnose-bug-root-cause
+```
+
+### 证据分析 (action-debug - 分析)
+```bash
+ccw cli -p "PURPOSE: Analyze debug log evidence..."
+  --tool gemini
+  --mode analysis
+  --rule analysis-diagnose-bug-root-cause
+```
+
+### 质量评估 (action-validate)
+```bash
+ccw cli -p "PURPOSE: Analyze test results and coverage..."
+  --tool gemini
+  --mode analysis
+  --rule analysis-review-code-quality
+```
+
+## State Management
+
+### State Schema
+
+参见 [phases/state-schema.md](phases/state-schema.md)
+
+### State Transitions
+
+```
+pending → running → completed
+              ↓
+         user_exit
+              ↓
+            failed
+```
+
+### State Recovery
+
+如果 `state.json` 损坏，可从其他文件重建:
+- develop/tasks.json → develop.*
+- debug/hypotheses.json → debug.*
+- validate/test-results.json → validate.*
+
+## Examples
+
+### Example 1: 功能开发
+
+```bash
+# 1. 启动循环
+/ccw-loop "Add user profile page"
+
+# 2. 系统初始化，生成任务:
+#    - task-001: Create profile component
+#    - task-002: Add API endpoints
+#    - task-003: Implement tests
+
+# 3. 选择 "继续开发"
+#    → 执行 task-001 (Gemini 辅助实现)
+#    → 更新 progress.md
+
+# 4. 重复开发直到所有任务完成
+
+# 5. 选择 "运行验证"
+#    → 运行测试
+#    → 检查覆盖率
+#    → 生成 validation.md
+
+# 6. 选择 "完成循环"
+#    → 生成 summary.md
+#    → 询问是否扩展为 Issue
+```
+
+### Example 2: Bug 修复
+
+```bash
+# 1. 启动循环
+/ccw-loop "Fix login timeout issue"
+
+# 2. 选择 "开始调试"
+#    → 输入 bug 描述: "Login times out after 30s"
+#    → Gemini 生成假设 (H1, H2, H3)
+#    → 添加 NDJSON 日志
+#    → 提示复现 bug
+
+# 3. 复现 bug (在应用中操作)
+
+# 4. 再次选择 "开始调试"
+#    → 解析 debug.log
+#    → Gemini 分析证据
+#    → H2 确认为根因
+#    → 生成修复代码
+#    → 更新 understanding.md
+
+# 5. 选择 "运行验证"
+#    → 测试通过
+
+# 6. 完成
+```
+
+## Templates
+
+- [progress-template.md](templates/progress-template.md): 开发进度文档模板
+- [understanding-template.md](templates/understanding-template.md): 调试理解文档模板
+- [validation-template.md](templates/validation-template.md): 验证报告模板
+
+## Specifications
+
+- [loop-requirements.md](specs/loop-requirements.md): 循环需求规范
+- [action-catalog.md](specs/action-catalog.md): 动作目录
+
+## Integration
+
+### Dashboard Integration
+
+CCW Loop 与 Dashboard Loop Monitor 集成:
+- Dashboard 创建 Loop → 触发此 Skill
+- state.json → Dashboard 实时显示
+- 任务列表双向同步
+- 控制按钮映射到 actions
+
+### Issue System Integration
+
+完成后可扩展为 Issue:
+- 维度: test, enhance, refactor, doc
+- 自动调用 `/issue:new`
+- 上下文自动填充
+
+## Error Handling
+
+| 情况 | 处理 |
+|------|------|
+| Session 不存在 | 创建新会话 |
+| state.json 损坏 | 从文件重建 |
+| CLI 工具失败 | 回退到手动模式 |
+| 测试失败 | 循环回到 develop/debug |
+| >10 迭代 | 警告用户，建议拆分 |
+
+## Limitations
+
+1. **单会话限制**: 同一时间只能有一个活跃会话
+2. **迭代限制**: 建议不超过 10 次迭代
+3. **CLI 依赖**: 部分功能依赖 Gemini CLI 可用性
+4. **测试框架**: 需要 package.json 中定义测试脚本
+
+## Troubleshooting
+
+### Q: 如何查看当前会话状态？
+
+A: 在菜单中选择 "查看详情 (Status)"
+
+### Q: 如何恢复中断的会话？
+
+A: 使用 `--resume` 参数:
+```bash
+/ccw-loop --resume LOOP-xxx-2026-01-22
+```
+
+### Q: 如果 CLI 工具失败怎么办？
+
+A: Skill 会自动降级到手动模式，提示用户手动输入
+
+### Q: 如何添加自定义 action？
+
+A: 参见 [specs/action-catalog.md](specs/action-catalog.md) 的 "Action Extensions" 部分
+
+## Contributing
+
+添加新功能:
+1. 创建 action 文件在 `phases/actions/`
+2. 更新 orchestrator 决策逻辑
+3. 添加到 action-catalog.md
+4. 更新 action-menu.md
+
+## License
+
+MIT
+
+---
+
+**Version**: 1.0.0
+**Last Updated**: 2026-01-22
+**Author**: CCW Team

.claude/skills/ccw-loop/SKILL.md

@@ -0,0 +1,259 @@
+---
+name: ccw-loop
+description: Stateless iterative development loop workflow with documented progress. Supports develop, debug, and validate phases with file-based state tracking. Triggers on "ccw-loop", "dev loop", "development loop", "开发循环", "迭代开发".
+allowed-tools: Task(*), AskUserQuestion(*), Read(*), Grep(*), Glob(*), Bash(*), Edit(*), Write(*), TodoWrite(*)
+---
+
+# CCW Loop - Stateless Iterative Development Workflow
+
+无状态迭代开发循环工作流，支持开发 (develop)、调试 (debug)、验证 (validate) 三个阶段，每个阶段都有独立的文件记录进展。
+
+## Arguments
+
+| Arg | Required | Description |
+|-----|----------|-------------|
+| task | No | Task description (for new loop, mutually exclusive with --loop-id) |
+| --loop-id | No | Existing loop ID to continue (from API or previous session) |
+| --auto | No | Auto-cycle mode (develop → debug → validate → complete) |
+
+## Unified Architecture (API + Skill Integration)
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│                     Dashboard (UI)                              │
+│  [Create] [Start] [Pause] [Resume] [Stop] [View Progress]       │
+└─────────────────────────────────────────────────────────────────┘
+                              │
+                              ▼
+┌─────────────────────────────────────────────────────────────────┐
+│              loop-v2-routes.ts (Control Plane)                  │
+│                                                                 │
+│  State: .loop/{loopId}.json (MASTER)                            │
+│  Tasks: .loop/{loopId}.tasks.jsonl                              │
+│                                                                 │
+│  /start → Trigger ccw-loop skill with --loop-id                 │
+│  /pause → Set status='paused' (skill checks before action)      │
+│  /stop  → Set status='failed' (skill terminates)                │
+│  /resume → Set status='running' (skill continues)               │
+└─────────────────────────────────────────────────────────────────┘
+                              │
+                              ▼
+┌─────────────────────────────────────────────────────────────────┐
+│               ccw-loop Skill (Execution Plane)                  │
+│                                                                 │
+│  Reads/Writes: .loop/{loopId}.json (unified state)              │
+│  Writes: .loop/{loopId}.progress/* (progress files)             │
+│                                                                 │
+│  BEFORE each action:                                            │
+│    → Check status: paused/stopped → exit gracefully             │
+│    → running → continue with action                             │
+│                                                                 │
+│  Actions: init → develop → debug → validate → complete          │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+## Key Design Principles
+
+1. **统一状态**: API 和 Skill 共享 `.loop/{loopId}.json` 状态文件
+2. **控制信号**: Skill 每个 Action 前检查 status 字段 (paused/stopped)
+3. **文件驱动**: 所有进度、理解、结果都记录在 `.loop/{loopId}.progress/`
+4. **可恢复**: 任何时候可以继续之前的循环 (`--loop-id`)
+5. **双触发**: 支持 API 触发 (`--loop-id`) 和直接调用 (task description)
+6. **Gemini 辅助**: 使用 CLI 工具进行深度分析和假设验证
+
+## Execution Modes
+
+### Mode 1: Interactive (交互式)
+
+用户手动选择每个动作，适合复杂任务。
+
+```
+用户 → 选择动作 → 执行 → 查看结果 → 选择下一动作
+```
+
+### Mode 2: Auto-Loop (自动循环)
+
+按预设顺序自动执行，适合标准开发流程。
+
+```
+Develop → Debug → Validate → (如有问题) → Develop → ...
+```
+
+## Session Structure (Unified Location)
+
+```
+.loop/
+├── {loopId}.json              # 主状态文件 (API + Skill 共享)
+├── {loopId}.tasks.jsonl       # 任务列表 (API 管理)
+└── {loopId}.progress/         # Skill 进度文件
+    ├── develop.md             # 开发进度记录
+    ├── debug.md               # 理解演变文档
+    ├── validate.md            # 验证报告
+    ├── changes.log            # 代码变更日志 (NDJSON)
+    └── debug.log              # 调试日志 (NDJSON)
+```
+
+## Directory Setup
+
+```javascript
+// loopId 来源:
+// 1. API 触发时: 从 --loop-id 参数获取
+// 2. 直接调用时: 生成新的 loop-v2-{timestamp}-{random}
+
+const loopId = args['--loop-id'] || generateLoopId()
+const loopFile = `.loop/${loopId}.json`
+const progressDir = `.loop/${loopId}.progress`
+
+// 创建进度目录
+Bash(`mkdir -p "${progressDir}"`)
+```
+
+## Action Catalog
+
+| Action | Purpose | Output Files | CLI Integration |
+|--------|---------|--------------|-----------------|
+| [action-init](phases/actions/action-init.md) | 初始化循环会话 | meta.json, state.json | - |
+| [action-develop-with-file](phases/actions/action-develop-with-file.md) | 开发任务执行 | progress.md, tasks.json | gemini --mode write |
+| [action-debug-with-file](phases/actions/action-debug-with-file.md) | 假设驱动调试 | understanding.md, hypotheses.json | gemini --mode analysis |
+| [action-validate-with-file](phases/actions/action-validate-with-file.md) | 测试与验证 | validation.md, test-results.json | gemini --mode analysis |
+| [action-complete](phases/actions/action-complete.md) | 完成循环 | summary.md | - |
+| [action-menu](phases/actions/action-menu.md) | 显示操作菜单 | - | - |
+
+## Usage
+
+```bash
+# 启动新循环 (直接调用)
+/ccw-loop "实现用户认证功能"
+
+# 继续现有循环 (API 触发或手动恢复)
+/ccw-loop --loop-id loop-v2-20260122-abc123
+
+# 自动循环模式
+/ccw-loop --auto "修复登录bug并添加测试"
+
+# API 触发自动循环
+/ccw-loop --loop-id loop-v2-20260122-abc123 --auto
+```
+
+## Execution Flow
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│  /ccw-loop [<task> | --loop-id <id>] [--auto]                    │
+├─────────────────────────────────────────────────────────────────┤
+│                                                                  │
+│  1. Parameter Detection:                                         │
+│     ├─ IF --loop-id provided:                                    │
+│     │   ├─ Read .loop/{loopId}.json                              │
+│     │   ├─ Validate status === 'running'                         │
+│     │   └─ Continue from skill_state.current_action              │
+│     └─ ELSE (task description):                                  │
+│         ├─ Generate new loopId                                   │
+│         ├─ Create .loop/{loopId}.json                            │
+│         └─ Initialize with action-init                           │
+│                                                                  │
+│  2. Orchestrator Loop:                                           │
+│     ├─ Read state from .loop/{loopId}.json                       │
+│     ├─ Check control signals:                                    │
+│     │   ├─ status === 'paused' → Exit (wait for resume)          │
+│     │   ├─ status === 'failed' → Exit with error                 │
+│     │   └─ status === 'running' → Continue                       │
+│     ├─ Show menu / auto-select next action                       │
+│     ├─ Execute action                                            │
+│     ├─ Update .loop/{loopId}.progress/{action}.md                │
+│     ├─ Update .loop/{loopId}.json (skill_state)                  │
+│     └─ Loop or exit based on user choice / completion            │
+│                                                                  │
+│  3. Action Execution:                                            │
+│     ├─ BEFORE: checkControlSignals() → exit if paused/stopped    │
+│     ├─ Develop: Plan → Implement → Document progress             │
+│     ├─ Debug: Hypothesize → Instrument → Analyze → Fix           │
+│     ├─ Validate: Test → Check → Report                           │
+│     └─ AFTER: Update skill_state in .loop/{loopId}.json          │
+│                                                                  │
+│  4. Termination:                                                 │
+│     ├─ Control signal: paused (graceful exit, wait resume)       │
+│     ├─ Control signal: stopped (failed state)                    │
+│     ├─ User exits (interactive mode)                             │
+│     ├─ All tasks completed (status → completed)                  │
+│     └─ Max iterations reached                                    │
+│                                                                  │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+## Reference Documents
+
+| Document | Purpose |
+|----------|---------|
+| [phases/orchestrator.md](phases/orchestrator.md) | 编排器：状态读取 + 动作选择 |
+| [phases/state-schema.md](phases/state-schema.md) | 状态结构定义 |
+| [specs/loop-requirements.md](specs/loop-requirements.md) | 循环需求规范 |
+| [specs/action-catalog.md](specs/action-catalog.md) | 动作目录 |
+| [templates/progress-template.md](templates/progress-template.md) | 进度文档模板 |
+| [templates/understanding-template.md](templates/understanding-template.md) | 理解文档模板 |
+
+## Integration with Loop Monitor (Dashboard)
+
+此 Skill 与 CCW Dashboard 的 Loop Monitor 实现 **控制平面 + 执行平面** 分离架构：
+
+### Control Plane (Dashboard/API → loop-v2-routes.ts)
+
+1. **创建循环**: `POST /api/loops/v2` → 创建 `.loop/{loopId}.json`
+2. **启动执行**: `POST /api/loops/v2/:loopId/start` → 触发 `/ccw-loop --loop-id {loopId} --auto`
+3. **暂停执行**: `POST /api/loops/v2/:loopId/pause` → 设置 `status='paused'` (Skill 下次检查时退出)
+4. **恢复执行**: `POST /api/loops/v2/:loopId/resume` → 设置 `status='running'` → 重新触发 Skill
+5. **停止执行**: `POST /api/loops/v2/:loopId/stop` → 设置 `status='failed'`
+
+### Execution Plane (ccw-loop Skill)
+
+1. **读取状态**: 从 `.loop/{loopId}.json` 读取 API 设置的状态
+2. **检查控制**: 每个 Action 前检查 `status` 字段
+3. **执行动作**: develop → debug → validate → complete
+4. **更新进度**: 写入 `.loop/{loopId}.progress/*.md` 和更新 `skill_state`
+5. **状态同步**: Dashboard 通过读取 `.loop/{loopId}.json` 获取进度
+
+## CLI Integration Points
+
+### Develop Phase
+```bash
+ccw cli -p "PURPOSE: Implement {task}...
+TASK: • Analyze requirements • Write code • Update progress
+MODE: write
+CONTEXT: @progress.md @tasks.json
+EXPECTED: Implementation + updated progress.md
+" --tool gemini --mode write --rule development-implement-feature
+```
+
+### Debug Phase
+```bash
+ccw cli -p "PURPOSE: Generate debugging hypotheses...
+TASK: • Analyze error • Generate hypotheses • Add instrumentation
+MODE: analysis
+CONTEXT: @understanding.md @debug.log
+EXPECTED: Hypotheses + instrumentation plan
+" --tool gemini --mode analysis --rule analysis-diagnose-bug-root-cause
+```
+
+### Validate Phase
+```bash
+ccw cli -p "PURPOSE: Validate implementation...
+TASK: • Run tests • Check coverage • Verify requirements
+MODE: analysis
+CONTEXT: @validation.md @test-results.json
+EXPECTED: Validation report
+" --tool gemini --mode analysis --rule analysis-review-code-quality
+```
+
+## Error Handling
+
+| Situation | Action |
+|-----------|--------|
+| Session not found | Create new session |
+| State file corrupted | Rebuild from file contents |
+| CLI tool fails | Fallback to manual analysis |
+| Tests fail | Loop back to develop/debug |
+| >10 iterations | Warn user, suggest break |
+
+## Post-Completion Expansion
+
+完成后询问用户是否扩展为 issue (test/enhance/refactor/doc)，选中项调用 `/issue:new "{summary} - {dimension}"`

.claude/skills/ccw-loop/phases/actions/action-complete.md

@@ -0,0 +1,320 @@
+# Action: Complete
+
+完成 CCW Loop 会话，生成总结报告。
+
+## Purpose
+
+- 生成完成报告
+- 汇总所有阶段成果
+- 提供后续建议
+- 询问是否扩展为 Issue
+
+## Preconditions
+
+- [ ] state.initialized === true
+- [ ] state.status === 'running'
+
+## Execution
+
+### Step 1: 汇总统计
+
+```javascript
+const getUtc8ISOString = () => new Date(Date.now() + 8 * 60 * 60 * 1000).toISOString()
+
+const sessionFolder = `.workflow/.loop/${state.session_id}`
+
+const stats = {
+  // 时间统计
+  duration: Date.now() - new Date(state.created_at).getTime(),
+  iterations: state.iteration_count,
+
+  // 开发统计
+  develop: {
+    total_tasks: state.develop.total_count,
+    completed_tasks: state.develop.completed_count,
+    completion_rate: state.develop.total_count > 0
+      ? (state.develop.completed_count / state.develop.total_count * 100).toFixed(1)
+      : 0
+  },
+
+  // 调试统计
+  debug: {
+    iterations: state.debug.iteration,
+    hypotheses_tested: state.debug.hypotheses.length,
+    root_cause_found: state.debug.confirmed_hypothesis !== null
+  },
+
+  // 验证统计
+  validate: {
+    runs: state.validate.test_results.length,
+    passed: state.validate.passed,
+    coverage: state.validate.coverage,
+    failed_tests: state.validate.failed_tests.length
+  }
+}
+
+console.log('\n生成完成报告...')
+```
+
+### Step 2: 生成总结报告
+
+```javascript
+const summaryReport = `# CCW Loop Session Summary
+
+**Session ID**: ${state.session_id}
+**Task**: ${state.task_description}
+**Started**: ${state.created_at}
+**Completed**: ${getUtc8ISOString()}
+**Duration**: ${formatDuration(stats.duration)}
+
+---
+
+## Executive Summary
+
+${state.validate.passed
+  ? '✅ **任务成功完成** - 所有测试通过，验证成功'
+  : state.develop.completed_count === state.develop.total_count
+    ? '⚠️ **开发完成，验证未通过** - 需要进一步调试'
+    : '⏸️ **任务部分完成** - 仍有待处理项'}
+
+---
+
+## Development Phase
+
+| Metric | Value |
+|--------|-------|
+| Total Tasks | ${stats.develop.total_tasks} |
+| Completed | ${stats.develop.completed_tasks} |
+| Completion Rate | ${stats.develop.completion_rate}% |
+
+### Completed Tasks
+
+${state.develop.tasks.filter(t => t.status === 'completed').map(t => `
+- ✅ ${t.description}
+  - Files: ${t.files_changed?.join(', ') || 'N/A'}
+  - Completed: ${t.completed_at}
+`).join('\n')}
+
+### Pending Tasks
+
+${state.develop.tasks.filter(t => t.status !== 'completed').map(t => `
+- ⏳ ${t.description}
+`).join('\n') || '_None_'}
+
+---
+
+## Debug Phase
+
+| Metric | Value |
+|--------|-------|
+| Iterations | ${stats.debug.iterations} |
+| Hypotheses Tested | ${stats.debug.hypotheses_tested} |
+| Root Cause Found | ${stats.debug.root_cause_found ? 'Yes' : 'No'} |
+
+${stats.debug.root_cause_found ? `
+### Confirmed Root Cause
+
+**${state.debug.confirmed_hypothesis}**: ${state.debug.hypotheses.find(h => h.id === state.debug.confirmed_hypothesis)?.description || 'N/A'}
+` : ''}
+
+### Hypothesis Summary
+
+${state.debug.hypotheses.map(h => `
+- **${h.id}**: ${h.status.toUpperCase()}
+  - ${h.description}
+`).join('\n') || '_No hypotheses tested_'}
+
+---
+
+## Validation Phase
+
+| Metric | Value |
+|--------|-------|
+| Test Runs | ${stats.validate.runs} |
+| Status | ${stats.validate.passed ? 'PASSED' : 'FAILED'} |
+| Coverage | ${stats.validate.coverage || 'N/A'}% |
+| Failed Tests | ${stats.validate.failed_tests} |
+
+${stats.validate.failed_tests > 0 ? `
+### Failed Tests
+
+${state.validate.failed_tests.map(t => `- ❌ ${t}`).join('\n')}
+` : ''}
+
+---
+
+## Files Modified
+
+${listModifiedFiles(sessionFolder)}
+
+---
+
+## Key Learnings
+
+${state.debug.iteration > 0 ? `
+### From Debugging
+
+${extractLearnings(state.debug.hypotheses)}
+` : ''}
+
+---
+
+## Recommendations
+
+${generateRecommendations(stats, state)}
+
+---
+
+## Session Artifacts
+
+| File | Description |
+|------|-------------|
+| \`develop/progress.md\` | Development progress timeline |
+| \`develop/tasks.json\` | Task list with status |
+| \`debug/understanding.md\` | Debug exploration and learnings |
+| \`debug/hypotheses.json\` | Hypothesis history |
+| \`validate/validation.md\` | Validation report |
+| \`validate/test-results.json\` | Test execution results |
+
+---
+
+*Generated by CCW Loop at ${getUtc8ISOString()}*
+`
+
+Write(`${sessionFolder}/summary.md`, summaryReport)
+console.log(`\n报告已保存: ${sessionFolder}/summary.md`)
+```
+
+### Step 3: 询问后续扩展
+
+```javascript
+console.log('\n' + '═'.repeat(60))
+console.log('  任务已完成')
+console.log('═'.repeat(60))
+
+const expansionResponse = await AskUserQuestion({
+  questions: [{
+    question: "是否将发现扩展为 Issue？",
+    header: "扩展选项",
+    multiSelect: true,
+    options: [
+      { label: "测试 (Test)", description: "添加更多测试用例" },
+      { label: "增强 (Enhance)", description: "功能增强建议" },
+      { label: "重构 (Refactor)", description: "代码重构建议" },
+      { label: "文档 (Doc)", description: "文档更新需求" },
+      { label: "否，直接完成", description: "不创建 Issue" }
+    ]
+  }]
+})
+
+const selectedExpansions = expansionResponse["扩展选项"]
+
+if (selectedExpansions && !selectedExpansions.includes("否，直接完成")) {
+  for (const expansion of selectedExpansions) {
+    const dimension = expansion.split(' ')[0].toLowerCase()
+    const issueSummary = `${state.task_description} - ${dimension}`
+
+    console.log(`\n创建 Issue: ${issueSummary}`)
+
+    // 调用 /issue:new 创建 issue
+    await Bash({
+      command: `/issue:new "${issueSummary}"`,
+      run_in_background: false
+    })
+  }
+}
+```
+
+### Step 4: 最终输出
+
+```javascript
+console.log(`
+═══════════════════════════════════════════════════════════
+  ✅ CCW Loop 会话完成
+═══════════════════════════════════════════════════════════
+
+  会话 ID: ${state.session_id}
+  用时: ${formatDuration(stats.duration)}
+  迭代: ${stats.iterations}
+
+  开发: ${stats.develop.completed_tasks}/${stats.develop.total_tasks} 任务完成
+  调试: ${stats.debug.iterations} 次迭代
+  验证: ${stats.validate.passed ? '通过 ✅' : '未通过 ❌'}
+
+  报告: ${sessionFolder}/summary.md
+
+═══════════════════════════════════════════════════════════
+`)
+```
+
+## State Updates
+
+```javascript
+return {
+  stateUpdates: {
+    status: 'completed',
+    completed_at: getUtc8ISOString(),
+    summary: stats
+  },
+  continue: false,
+  message: `会话 ${state.session_id} 已完成`
+}
+```
+
+## Helper Functions
+
+```javascript
+function formatDuration(ms) {
+  const seconds = Math.floor(ms / 1000)
+  const minutes = Math.floor(seconds / 60)
+  const hours = Math.floor(minutes / 60)
+
+  if (hours > 0) {
+    return `${hours}h ${minutes % 60}m`
+  } else if (minutes > 0) {
+    return `${minutes}m ${seconds % 60}s`
+  } else {
+    return `${seconds}s`
+  }
+}
+
+function generateRecommendations(stats, state) {
+  const recommendations = []
+
+  if (stats.develop.completion_rate < 100) {
+    recommendations.push('- 完成剩余开发任务')
+  }
+
+  if (!stats.validate.passed) {
+    recommendations.push('- 修复失败的测试')
+  }
+
+  if (stats.validate.coverage && stats.validate.coverage < 80) {
+    recommendations.push(`- 提高测试覆盖率 (当前: ${stats.validate.coverage}%)`)
+  }
+
+  if (stats.debug.iterations > 3 && !stats.debug.root_cause_found) {
+    recommendations.push('- 考虑代码重构以简化调试')
+  }
+
+  if (recommendations.length === 0) {
+    recommendations.push('- 考虑代码审查')
+    recommendations.push('- 更新相关文档')
+    recommendations.push('- 准备部署')
+  }
+
+  return recommendations.join('\n')
+}
+```
+
+## Error Handling
+
+| Error Type | Recovery |
+|------------|----------|
+| 报告生成失败 | 显示基本统计，跳过文件写入 |
+| Issue 创建失败 | 记录错误，继续完成 |
+
+## Next Actions
+
+- 无 (终止状态)
+- 如需继续: 使用 `ccw-loop --resume {session-id}` 重新打开会话

.claude/skills/ccw-loop/phases/actions/action-debug-with-file.md

@@ -0,0 +1,485 @@
+# Action: Debug With File
+
+假设驱动调试，记录理解演变到 understanding.md，支持 Gemini 辅助分析和假设生成。
+
+## Purpose
+
+执行假设驱动的调试流程，包括：
+- 定位错误源
+- 生成可测试假设
+- 添加 NDJSON 日志
+- 分析日志证据
+- 纠正错误理解
+- 应用修复
+
+## Preconditions
+
+- [ ] state.initialized === true
+- [ ] state.status === 'running'
+
+## Session Setup
+
+```javascript
+const getUtc8ISOString = () => new Date(Date.now() + 8 * 60 * 60 * 1000).toISOString()
+
+const sessionFolder = `.workflow/.loop/${state.session_id}`
+const debugFolder = `${sessionFolder}/debug`
+const understandingPath = `${debugFolder}/understanding.md`
+const hypothesesPath = `${debugFolder}/hypotheses.json`
+const debugLogPath = `${debugFolder}/debug.log`
+```
+
+---
+
+## Mode Detection
+
+```javascript
+// 自动检测模式
+const understandingExists = fs.existsSync(understandingPath)
+const logHasContent = fs.existsSync(debugLogPath) && fs.statSync(debugLogPath).size > 0
+
+const debugMode = logHasContent ? 'analyze' : (understandingExists ? 'continue' : 'explore')
+
+console.log(`Debug mode: ${debugMode}`)
+```
+
+---
+
+## Explore Mode (首次调试)
+
+### Step 1.1: 定位错误源
+
+```javascript
+if (debugMode === 'explore') {
+  // 询问用户 bug 描述
+  const bugInput = await AskUserQuestion({
+    questions: [{
+      question: "请描述遇到的 bug 或错误信息：",
+      header: "Bug 描述",
+      multiSelect: false,
+      options: [
+        { label: "手动输入", description: "输入错误描述或堆栈" },
+        { label: "从测试失败", description: "从验证阶段的失败测试中获取" }
+      ]
+    }]
+  })
+
+  const bugDescription = bugInput["Bug 描述"]
+
+  // 提取关键词并搜索
+  const searchResults = await Task({
+    subagent_type: 'Explore',
+    run_in_background: false,
+    prompt: `Search codebase for error patterns related to: ${bugDescription}`
+  })
+
+  // 分析搜索结果，识别受影响的位置
+  const affectedLocations = analyzeSearchResults(searchResults)
+}
+```
+
+### Step 1.2: 记录初始理解
+
+```javascript
+// 创建 understanding.md
+const initialUnderstanding = `# Understanding Document
+
+**Session ID**: ${state.session_id}
+**Bug Description**: ${bugDescription}
+**Started**: ${getUtc8ISOString()}
+
+---
+
+## Exploration Timeline
+
+### Iteration 1 - Initial Exploration (${getUtc8ISOString()})
+
+#### Current Understanding
+
+Based on bug description and initial code search:
+
+- Error pattern: ${errorPattern}
+- Affected areas: ${affectedLocations.map(l => l.file).join(', ')}
+- Initial hypothesis: ${initialThoughts}
+
+#### Evidence from Code Search
+
+${searchResults.map(r => `
+**Keyword: "${r.keyword}"**
+- Found in: ${r.files.join(', ')}
+- Key findings: ${r.insights}
+`).join('\n')}
+
+#### Next Steps
+
+- Generate testable hypotheses
+- Add instrumentation
+- Await reproduction
+
+---
+
+## Current Consolidated Understanding
+
+${initialConsolidatedUnderstanding}
+`
+
+Write(understandingPath, initialUnderstanding)
+```
+
+### Step 1.3: Gemini 辅助假设生成
+
+```bash
+ccw cli -p "
+PURPOSE: Generate debugging hypotheses for: ${bugDescription}
+Success criteria: Testable hypotheses with clear evidence criteria
+
+TASK:
+• Analyze error pattern and code search results
+• Identify 3-5 most likely root causes
+• For each hypothesis, specify:
+  - What might be wrong
+  - What evidence would confirm/reject it
+  - Where to add instrumentation
+• Rank by likelihood
+
+MODE: analysis
+
+CONTEXT: @${understandingPath} | Search results in understanding.md
+
+EXPECTED:
+- Structured hypothesis list (JSON format)
+- Each hypothesis with: id, description, testable_condition, logging_point, evidence_criteria
+- Likelihood ranking (1=most likely)
+
+CONSTRAINTS: Focus on testable conditions
+" --tool gemini --mode analysis --rule analysis-diagnose-bug-root-cause
+```
+
+### Step 1.4: 保存假设
+
+```javascript
+const hypotheses = {
+  iteration: 1,
+  timestamp: getUtc8ISOString(),
+  bug_description: bugDescription,
+  hypotheses: [
+    {
+      id: "H1",
+      description: "...",
+      testable_condition: "...",
+      logging_point: "file.ts:func:42",
+      evidence_criteria: {
+        confirm: "...",
+        reject: "..."
+      },
+      likelihood: 1,
+      status: "pending"
+    }
+    // ...
+  ],
+  gemini_insights: "...",
+  corrected_assumptions: []
+}
+
+Write(hypothesesPath, JSON.stringify(hypotheses, null, 2))
+```
+
+### Step 1.5: 添加 NDJSON 日志
+
+```javascript
+// 为每个假设添加日志点
+for (const hypothesis of hypotheses.hypotheses) {
+  const [file, func, line] = hypothesis.logging_point.split(':')
+
+  const logStatement = `console.log(JSON.stringify({
+    hid: "${hypothesis.id}",
+    ts: Date.now(),
+    func: "${func}",
+    data: { /* 相关数据 */ }
+  }))`
+
+  // 使用 Edit 工具添加日志
+  // ...
+}
+```
+
+---
+
+## Analyze Mode (有日志后)
+
+### Step 2.1: 解析调试日志
+
+```javascript
+if (debugMode === 'analyze') {
+  // 读取 NDJSON 日志
+  const logContent = Read(debugLogPath)
+  const entries = logContent.split('\n')
+    .filter(l => l.trim())
+    .map(l => JSON.parse(l))
+
+  // 按假设分组
+  const byHypothesis = groupBy(entries, 'hid')
+}
+```
+
+### Step 2.2: Gemini 辅助证据分析
+
+```bash
+ccw cli -p "
+PURPOSE: Analyze debug log evidence to validate/correct hypotheses for: ${bugDescription}
+Success criteria: Clear verdict per hypothesis + corrected understanding
+
+TASK:
+• Parse log entries by hypothesis
+• Evaluate evidence against expected criteria
+• Determine verdict: confirmed | rejected | inconclusive
+• Identify incorrect assumptions from previous understanding
+• Suggest corrections to understanding
+
+MODE: analysis
+
+CONTEXT:
+@${debugLogPath}
+@${understandingPath}
+@${hypothesesPath}
+
+EXPECTED:
+- Per-hypothesis verdict with reasoning
+- Evidence summary
+- List of incorrect assumptions with corrections
+- Updated consolidated understanding
+- Root cause if confirmed, or next investigation steps
+
+CONSTRAINTS: Evidence-based reasoning only, no speculation
+" --tool gemini --mode analysis --rule analysis-diagnose-bug-root-cause
+```
+
+### Step 2.3: 更新理解文档
+
+```javascript
+// 追加新迭代到 understanding.md
+const iteration = state.debug.iteration + 1
+
+const analysisEntry = `
+### Iteration ${iteration} - Evidence Analysis (${getUtc8ISOString()})
+
+#### Log Analysis Results
+
+${results.map(r => `
+**${r.id}**: ${r.verdict.toUpperCase()}
+- Evidence: ${JSON.stringify(r.evidence)}
+- Reasoning: ${r.reason}
+`).join('\n')}
+
+#### Corrected Understanding
+
+Previous misunderstandings identified and corrected:
+
+${corrections.map(c => `
+- ~~${c.wrong}~~ → ${c.corrected}
+  - Why wrong: ${c.reason}
+  - Evidence: ${c.evidence}
+`).join('\n')}
+
+#### New Insights
+
+${newInsights.join('\n- ')}
+
+#### Gemini Analysis
+
+${geminiAnalysis}
+
+${confirmedHypothesis ? `
+#### Root Cause Identified
+
+**${confirmedHypothesis.id}**: ${confirmedHypothesis.description}
+
+Evidence supporting this conclusion:
+${confirmedHypothesis.supportingEvidence}
+` : `
+#### Next Steps
+
+${nextSteps}
+`}
+
+---
+
+## Current Consolidated Understanding (Updated)
+
+### What We Know
+
+- ${validUnderstanding1}
+- ${validUnderstanding2}
+
+### What Was Disproven
+
+- ~~${wrongAssumption}~~ (Evidence: ${disproofEvidence})
+
+### Current Investigation Focus
+
+${currentFocus}
+
+### Remaining Questions
+
+- ${openQuestion1}
+- ${openQuestion2}
+`
+
+const existingContent = Read(understandingPath)
+Write(understandingPath, existingContent + analysisEntry)
+```
+
+### Step 2.4: 更新假设状态
+
+```javascript
+const hypothesesData = JSON.parse(Read(hypothesesPath))
+
+// 更新假设状态
+hypothesesData.hypotheses = hypothesesData.hypotheses.map(h => ({
+  ...h,
+  status: results.find(r => r.id === h.id)?.verdict || h.status,
+  evidence: results.find(r => r.id === h.id)?.evidence || h.evidence,
+  verdict_reason: results.find(r => r.id === h.id)?.reason || h.verdict_reason
+}))
+
+hypothesesData.iteration++
+hypothesesData.timestamp = getUtc8ISOString()
+
+Write(hypothesesPath, JSON.stringify(hypothesesData, null, 2))
+```
+
+---
+
+## Fix & Verification
+
+### Step 3.1: 应用修复
+
+```javascript
+if (confirmedHypothesis) {
+  console.log(`\n根因确认: ${confirmedHypothesis.description}`)
+  console.log('准备应用修复...')
+
+  // 使用 Gemini 生成修复代码
+  const fixPrompt = `
+PURPOSE: Fix the identified root cause
+Root Cause: ${confirmedHypothesis.description}
+Evidence: ${confirmedHypothesis.supportingEvidence}
+
+TASK:
+• Generate fix code
+• Ensure backward compatibility
+• Add tests if needed
+
+MODE: write
+
+CONTEXT: @${confirmedHypothesis.logging_point.split(':')[0]}
+
+EXPECTED: Fixed code + verification steps
+`
+
+  await Bash({
+    command: `ccw cli -p "${fixPrompt}" --tool gemini --mode write --rule development-debug-runtime-issues`,
+    run_in_background: false
+  })
+}
+```
+
+### Step 3.2: 记录解决方案
+
+```javascript
+const resolutionEntry = `
+### Resolution (${getUtc8ISOString()})
+
+#### Fix Applied
+
+- Modified files: ${modifiedFiles.join(', ')}
+- Fix description: ${fixDescription}
+- Root cause addressed: ${rootCause}
+
+#### Verification Results
+
+${verificationResults}
+
+#### Lessons Learned
+
+1. ${lesson1}
+2. ${lesson2}
+
+#### Key Insights for Future
+
+- ${insight1}
+- ${insight2}
+`
+
+const existingContent = Read(understandingPath)
+Write(understandingPath, existingContent + resolutionEntry)
+```
+
+### Step 3.3: 清理日志
+
+```javascript
+// 移除调试日志
+// (可选，根据用户选择)
+```
+
+---
+
+## State Updates
+
+```javascript
+return {
+  stateUpdates: {
+    debug: {
+      current_bug: bugDescription,
+      hypotheses: hypothesesData.hypotheses,
+      confirmed_hypothesis: confirmedHypothesis?.id || null,
+      iteration: hypothesesData.iteration,
+      last_analysis_at: getUtc8ISOString(),
+      understanding_updated: true
+    },
+    last_action: 'action-debug-with-file'
+  },
+  continue: true,
+  message: confirmedHypothesis
+    ? `根因确认: ${confirmedHypothesis.description}\n修复已应用，请验证`
+    : `分析完成，需要更多证据\n请复现 bug 后再次执行`
+}
+```
+
+## Error Handling
+
+| Error Type | Recovery |
+|------------|----------|
+| 空 debug.log | 提示用户复现 bug |
+| 所有假设被否定 | 使用 Gemini 生成新假设 |
+| 修复无效 | 记录失败尝试，迭代 |
+| >5 迭代 | 建议升级到 /workflow:lite-fix |
+| Gemini 不可用 | 回退到手动分析 |
+
+## Understanding Document Template
+
+参考 [templates/understanding-template.md](../../templates/understanding-template.md)
+
+## CLI Integration
+
+### 假设生成
+```bash
+ccw cli -p "PURPOSE: Generate debugging hypotheses..." --tool gemini --mode analysis --rule analysis-diagnose-bug-root-cause
+```
+
+### 证据分析
+```bash
+ccw cli -p "PURPOSE: Analyze debug log evidence..." --tool gemini --mode analysis --rule analysis-diagnose-bug-root-cause
+```
+
+### 生成修复
+```bash
+ccw cli -p "PURPOSE: Fix the identified root cause..." --tool gemini --mode write --rule development-debug-runtime-issues
+```
+
+## Next Actions (Hints)
+
+- 根因确认: `action-validate-with-file` (验证修复)
+- 需要更多证据: 等待用户复现，再次执行此动作
+- 所有假设否定: 重新执行此动作生成新假设
+- 用户选择: `action-menu` (返回菜单)

.claude/skills/ccw-loop/phases/actions/action-develop-with-file.md

@@ -0,0 +1,365 @@
+# Action: Develop With File
+
+增量开发任务执行，记录进度到 progress.md，支持 Gemini 辅助实现。
+
+## Purpose
+
+执行开发任务并记录进度，包括：
+- 分析任务需求
+- 使用 Gemini/CLI 实现代码
+- 记录代码变更
+- 更新进度文档
+
+## Preconditions
+
+- [ ] state.status === 'running'
+- [ ] state.skill_state !== null
+- [ ] state.skill_state.develop.tasks.some(t => t.status === 'pending')
+
+## Session Setup (Unified Location)
+
+```javascript
+const getUtc8ISOString = () => new Date(Date.now() + 8 * 60 * 60 * 1000).toISOString()
+
+// 统一位置: .loop/{loopId}
+const loopId = state.loop_id
+const loopFile = `.loop/${loopId}.json`
+const progressDir = `.loop/${loopId}.progress`
+const progressPath = `${progressDir}/develop.md`
+const changesLogPath = `${progressDir}/changes.log`
+```
+
+---
+
+## Execution
+
+### Step 0: Check Control Signals (CRITICAL)
+
+```javascript
+/**
+ * CRITICAL: 每个 Action 必须在开始时检查控制信号
+ * 如果 API 设置了 paused/stopped，Skill 应立即退出
+ */
+function checkControlSignals(loopId) {
+  const state = JSON.parse(Read(`.loop/${loopId}.json`))
+
+  switch (state.status) {
+    case 'paused':
+      console.log('⏸️ Loop paused by API. Exiting action.')
+      return { continue: false, reason: 'paused' }
+
+    case 'failed':
+      console.log('⏹️ Loop stopped by API. Exiting action.')
+      return { continue: false, reason: 'stopped' }
+
+    case 'running':
+      return { continue: true, reason: 'running' }
+
+    default:
+      return { continue: false, reason: 'unknown_status' }
+  }
+}
+
+// Execute check
+const control = checkControlSignals(loopId)
+if (!control.continue) {
+  return {
+    skillStateUpdates: { current_action: null },
+    continue: false,
+    message: `Action terminated: ${control.reason}`
+  }
+}
+```
+
+### Step 1: 加载任务列表
+
+```javascript
+// 读取任务列表 (从 skill_state)
+let tasks = state.skill_state?.develop?.tasks || []
+
+// 如果任务列表为空，询问用户创建
+if (tasks.length === 0) {
+  // 使用 Gemini 分析任务描述，生成任务列表
+  const analysisPrompt = `
+PURPOSE: 分析开发任务并分解为可执行步骤
+Success: 生成 3-7 个具体、可验证的子任务
+
+TASK:
+• 分析任务描述: ${state.task_description}
+• 识别关键功能点
+• 分解为独立子任务
+• 为每个子任务指定工具和模式
+
+MODE: analysis
+
+CONTEXT: @package.json @src/**/*.ts | Memory: 项目结构
+
+EXPECTED:
+JSON 格式:
+{
+  "tasks": [
+    {
+      "id": "task-001",
+      "description": "任务描述",
+      "tool": "gemini",
+      "mode": "write",
+      "files": ["src/xxx.ts"]
+    }
+  ]
+}
+`
+
+  const result = await Task({
+    subagent_type: 'cli-execution-agent',
+    run_in_background: false,
+    prompt: `Execute Gemini CLI with prompt: ${analysisPrompt}`
+  })
+
+  tasks = JSON.parse(result).tasks
+}
+
+// 找到第一个待处理任务
+const currentTask = tasks.find(t => t.status === 'pending')
+
+if (!currentTask) {
+  return {
+    skillStateUpdates: {
+      develop: { ...state.skill_state.develop, current_task: null }
+    },
+    continue: true,
+    message: '所有开发任务已完成'
+  }
+}
+```
+
+### Step 2: 执行开发任务
+
+```javascript
+console.log(`\n执行任务: ${currentTask.description}`)
+
+// 更新任务状态
+currentTask.status = 'in_progress'
+
+// 使用 Gemini 实现
+const implementPrompt = `
+PURPOSE: 实现开发任务
+Task: ${currentTask.description}
+Success criteria: 代码实现完成，测试通过
+
+TASK:
+• 分析现有代码结构
+• 实现功能代码
+• 添加必要的类型定义
+• 确保代码风格一致
+
+MODE: write
+
+CONTEXT: @${currentTask.files?.join(' @') || 'src/**/*.ts'}
+
+EXPECTED:
+- 完整的代码实现
+- 代码变更列表
+- 简要实现说明
+
+CONSTRAINTS: 遵循现有代码风格 | 不破坏现有功能
+`
+
+const implementResult = await Bash({
+  command: `ccw cli -p "${implementPrompt}" --tool gemini --mode write --rule development-implement-feature`,
+  run_in_background: false
+})
+
+// 记录代码变更
+const timestamp = getUtc8ISOString()
+const changeEntry = {
+  timestamp,
+  task_id: currentTask.id,
+  description: currentTask.description,
+  files_changed: currentTask.files || [],
+  result: 'success'
+}
+
+// 追加到 changes.log (NDJSON 格式)
+const changesContent = Read(changesLogPath) || ''
+Write(changesLogPath, changesContent + JSON.stringify(changeEntry) + '\n')
+```
+
+### Step 3: 更新进度文档
+
+```javascript
+const timestamp = getUtc8ISOString()
+const iteration = state.develop.completed_count + 1
+
+// 读取现有进度文档
+let progressContent = Read(progressPath) || ''
+
+// 如果是新文档，添加头部
+if (!progressContent) {
+  progressContent = `# Development Progress
+
+**Session ID**: ${state.session_id}
+**Task**: ${state.task_description}
+**Started**: ${timestamp}
+
+---
+
+## Progress Timeline
+
+`
+}
+
+// 追加本次进度
+const progressEntry = `
+### Iteration ${iteration} - ${currentTask.description} (${timestamp})
+
+#### Task Details
+
+- **ID**: ${currentTask.id}
+- **Tool**: ${currentTask.tool}
+- **Mode**: ${currentTask.mode}
+
+#### Implementation Summary
+
+${implementResult.summary || '实现完成'}
+
+#### Files Changed
+
+${currentTask.files?.map(f => `- \`${f}\``).join('\n') || '- No files specified'}
+
+#### Status: COMPLETED
+
+---
+
+`
+
+Write(progressPath, progressContent + progressEntry)
+
+// 更新任务状态
+currentTask.status = 'completed'
+currentTask.completed_at = timestamp
+```
+
+### Step 4: 更新任务列表文件
+
+```javascript
+// 更新 tasks.json
+const updatedTasks = tasks.map(t =>
+  t.id === currentTask.id ? currentTask : t
+)
+
+Write(tasksPath, JSON.stringify(updatedTasks, null, 2))
+```
+
+## State Updates
+
+```javascript
+return {
+  stateUpdates: {
+    develop: {
+      tasks: updatedTasks,
+      current_task_id: null,
+      completed_count: state.develop.completed_count + 1,
+      total_count: updatedTasks.length,
+      last_progress_at: getUtc8ISOString()
+    },
+    last_action: 'action-develop-with-file'
+  },
+  continue: true,
+  message: `任务完成: ${currentTask.description}\n进度: ${state.develop.completed_count + 1}/${updatedTasks.length}`
+}
+```
+
+## Error Handling
+
+| Error Type | Recovery |
+|------------|----------|
+| Gemini CLI 失败 | 提示用户手动实现，记录到 progress.md |
+| 文件写入失败 | 重试一次，失败则记录错误 |
+| 任务解析失败 | 询问用户手动输入任务 |
+
+## Progress Document Template
+
+```markdown
+# Development Progress
+
+**Session ID**: LOOP-xxx-2026-01-22
+**Task**: 实现用户认证功能
+**Started**: 2026-01-22T10:00:00+08:00
+
+---
+
+## Progress Timeline
+
+### Iteration 1 - 分析登录组件 (2026-01-22T10:05:00+08:00)
+
+#### Task Details
+
+- **ID**: task-001
+- **Tool**: gemini
+- **Mode**: analysis
+
+#### Implementation Summary
+
+分析了现有登录组件结构，识别了需要修改的文件和依赖关系。
+
+#### Files Changed
+
+- `src/components/Login.tsx`
+- `src/hooks/useAuth.ts`
+
+#### Status: COMPLETED
+
+---
+
+### Iteration 2 - 实现登录 API (2026-01-22T10:15:00+08:00)
+
+...
+
+---
+
+## Current Statistics
+
+| Metric | Value |
+|--------|-------|
+| Total Tasks | 5 |
+| Completed | 2 |
+| In Progress | 1 |
+| Pending | 2 |
+| Progress | 40% |
+
+---
+
+## Next Steps
+
+- [ ] 完成剩余任务
+- [ ] 运行测试
+- [ ] 代码审查
+```
+
+## CLI Integration
+
+### 任务分析
+```bash
+ccw cli -p "PURPOSE: 分解开发任务为子任务
+TASK: • 分析任务描述 • 识别功能点 • 生成任务列表
+MODE: analysis
+CONTEXT: @package.json @src/**/*
+EXPECTED: JSON 任务列表
+" --tool gemini --mode analysis --rule planning-breakdown-task-steps
+```
+
+### 代码实现
+```bash
+ccw cli -p "PURPOSE: 实现功能代码
+TASK: • 分析需求 • 编写代码 • 添加类型
+MODE: write
+CONTEXT: @src/xxx.ts
+EXPECTED: 完整实现
+" --tool gemini --mode write --rule development-implement-feature
+```
+
+## Next Actions (Hints)
+
+- 所有任务完成: `action-debug-with-file` (开始调试)
+- 任务失败: `action-develop-with-file` (重试或下一个任务)
+- 用户选择: `action-menu` (返回菜单)

.claude/skills/ccw-loop/phases/actions/action-init.md

@@ -0,0 +1,200 @@
+# Action: Initialize
+
+初始化 CCW Loop 会话，创建目录结构和初始状态。
+
+## Purpose
+
+- 创建会话目录结构
+- 初始化状态文件
+- 分析任务描述生成初始任务列表
+- 准备执行环境
+
+## Preconditions
+
+- [ ] state.status === 'pending'
+- [ ] state.initialized === false
+
+## Execution
+
+### Step 1: 创建目录结构
+
+```javascript
+const getUtc8ISOString = () => new Date(Date.now() + 8 * 60 * 60 * 1000).toISOString()
+
+const taskSlug = state.task_description.toLowerCase().replace(/[^a-z0-9]+/g, '-').substring(0, 30)
+const dateStr = getUtc8ISOString().substring(0, 10)
+const sessionId = `LOOP-${taskSlug}-${dateStr}`
+const sessionFolder = `.workflow/.loop/${sessionId}`
+
+Bash(`mkdir -p "${sessionFolder}/develop"`)
+Bash(`mkdir -p "${sessionFolder}/debug"`)
+Bash(`mkdir -p "${sessionFolder}/validate"`)
+
+console.log(`Session created: ${sessionId}`)
+console.log(`Location: ${sessionFolder}`)
+```
+
+### Step 2: 创建元数据文件
+
+```javascript
+const meta = {
+  session_id: sessionId,
+  task_description: state.task_description,
+  created_at: getUtc8ISOString(),
+  mode: state.mode || 'interactive'
+}
+
+Write(`${sessionFolder}/meta.json`, JSON.stringify(meta, null, 2))
+```
+
+### Step 3: 分析任务生成开发任务列表
+
+```javascript
+// 使用 Gemini 分析任务描述
+console.log('\n分析任务描述...')
+
+const analysisPrompt = `
+PURPOSE: 分析开发任务并分解为可执行步骤
+Success: 生成 3-7 个具体、可验证的子任务
+
+TASK:
+• 分析任务描述: ${state.task_description}
+• 识别关键功能点
+• 分解为独立子任务
+• 为每个子任务指定工具和模式
+
+MODE: analysis
+
+CONTEXT: @package.json @src/**/*.ts (如存在)
+
+EXPECTED:
+JSON 格式:
+{
+  "tasks": [
+    {
+      "id": "task-001",
+      "description": "任务描述",
+      "tool": "gemini",
+      "mode": "write",
+      "priority": 1
+    }
+  ],
+  "estimated_complexity": "low|medium|high",
+  "key_files": ["file1.ts", "file2.ts"]
+}
+
+CONSTRAINTS: 生成实际可执行的任务
+`
+
+const result = await Bash({
+  command: `ccw cli -p "${analysisPrompt}" --tool gemini --mode analysis --rule planning-breakdown-task-steps`,
+  run_in_background: false
+})
+
+const analysis = JSON.parse(result.stdout)
+const tasks = analysis.tasks.map((t, i) => ({
+  ...t,
+  id: t.id || `task-${String(i + 1).padStart(3, '0')}`,
+  status: 'pending',
+  created_at: getUtc8ISOString(),
+  completed_at: null,
+  files_changed: []
+}))
+
+// 保存任务列表
+Write(`${sessionFolder}/develop/tasks.json`, JSON.stringify(tasks, null, 2))
+```
+
+### Step 4: 初始化进度文档
+
+```javascript
+const progressInitial = `# Development Progress
+
+**Session ID**: ${sessionId}
+**Task**: ${state.task_description}
+**Started**: ${getUtc8ISOString()}
+**Estimated Complexity**: ${analysis.estimated_complexity}
+
+---
+
+## Task List
+
+${tasks.map((t, i) => `${i + 1}. [ ] ${t.description}`).join('\n')}
+
+## Key Files
+
+${analysis.key_files?.map(f => `- \`${f}\``).join('\n') || '- To be determined'}
+
+---
+
+## Progress Timeline
+
+`
+
+Write(`${sessionFolder}/develop/progress.md`, progressInitial)
+```
+
+### Step 5: 显示初始化结果
+
+```javascript
+console.log(`\n✅ 会话初始化完成`)
+console.log(`\n任务列表 (${tasks.length} 项):`)
+tasks.forEach((t, i) => {
+  console.log(`  ${i + 1}. ${t.description} [${t.tool}/${t.mode}]`)
+})
+console.log(`\n预估复杂度: ${analysis.estimated_complexity}`)
+console.log(`\n执行 'develop' 开始开发，或 'menu' 查看更多选项`)
+```
+
+## State Updates
+
+```javascript
+return {
+  stateUpdates: {
+    session_id: sessionId,
+    status: 'running',
+    initialized: true,
+    develop: {
+      tasks: tasks,
+      current_task_id: null,
+      completed_count: 0,
+      total_count: tasks.length,
+      last_progress_at: null
+    },
+    debug: {
+      current_bug: null,
+      hypotheses: [],
+      confirmed_hypothesis: null,
+      iteration: 0,
+      last_analysis_at: null,
+      understanding_updated: false
+    },
+    validate: {
+      test_results: [],
+      coverage: null,
+      passed: false,
+      failed_tests: [],
+      last_run_at: null
+    },
+    context: {
+      estimated_complexity: analysis.estimated_complexity,
+      key_files: analysis.key_files
+    }
+  },
+  continue: true,
+  message: `会话 ${sessionId} 已初始化\n${tasks.length} 个开发任务待执行`
+}
+```
+
+## Error Handling
+
+| Error Type | Recovery |
+|------------|----------|
+| 目录创建失败 | 检查权限，重试 |
+| Gemini 分析失败 | 提示用户手动输入任务 |
+| 任务解析失败 | 使用默认任务列表 |
+
+## Next Actions
+
+- 成功: `action-menu` (显示操作菜单) 或 `action-develop-with-file` (直接开始开发)
+- 失败: 报错退出

.claude/skills/ccw-loop/phases/actions/action-menu.md

@@ -0,0 +1,192 @@
+# Action: Menu
+
+显示交互式操作菜单，让用户选择下一步操作。
+
+## Purpose
+
+- 显示当前状态摘要
+- 提供操作选项
+- 接收用户选择
+- 返回下一个动作
+
+## Preconditions
+
+- [ ] state.initialized === true
+- [ ] state.status === 'running'
+
+## Execution
+
+### Step 1: 生成状态摘要
+
+```javascript
+const getUtc8ISOString = () => new Date(Date.now() + 8 * 60 * 60 * 1000).toISOString()
+
+// 开发进度
+const developProgress = state.develop.total_count > 0
+  ? `${state.develop.completed_count}/${state.develop.total_count} (${(state.develop.completed_count / state.develop.total_count * 100).toFixed(0)}%)`
+  : '未开始'
+
+// 调试状态
+const debugStatus = state.debug.confirmed_hypothesis
+  ? `✅ 已确认根因`
+  : state.debug.iteration > 0
+    ? `🔍 迭代 ${state.debug.iteration}`
+    : '未开始'
+
+// 验证状态
+const validateStatus = state.validate.passed
+  ? `✅ 通过`
+  : state.validate.test_results.length > 0
+    ? `❌ ${state.validate.failed_tests.length} 个失败`
+    : '未运行'
+
+const statusSummary = `
+═══════════════════════════════════════════════════════════
+  CCW Loop - ${state.session_id}
+═══════════════════════════════════════════════════════════
+
+  任务: ${state.task_description}
+  迭代: ${state.iteration_count}
+
+  ┌─────────────────────────────────────────────────────┐
+  │  开发 (Develop)  │  ${developProgress.padEnd(20)}      │
+  │  调试 (Debug)    │  ${debugStatus.padEnd(20)}      │
+  │  验证 (Validate) │  ${validateStatus.padEnd(20)}      │
+  └─────────────────────────────────────────────────────┘
+
+═══════════════════════════════════════════════════════════
+`
+
+console.log(statusSummary)
+```
+
+### Step 2: 显示操作选项
+
+```javascript
+const options = [
+  {
+    label: "📝 继续开发 (Develop)",
+    description: state.develop.completed_count < state.develop.total_count
+      ? `执行下一个开发任务`
+      : "所有任务已完成，可添加新任务",
+    action: "action-develop-with-file"
+  },
+  {
+    label: "🔍 开始调试 (Debug)",
+    description: state.debug.iteration > 0
+      ? "继续假设驱动调试"
+      : "开始新的调试会话",
+    action: "action-debug-with-file"
+  },
+  {
+    label: "✅ 运行验证 (Validate)",
+    description: "运行测试并检查覆盖率",
+    action: "action-validate-with-file"
+  },
+  {
+    label: "📊 查看详情 (Status)",
+    description: "查看详细进度和文件",
+    action: "action-status"
+  },
+  {
+    label: "🏁 完成循环 (Complete)",
+    description: "结束当前循环",
+    action: "action-complete"
+  },
+  {
+    label: "🚪 退出 (Exit)",
+    description: "保存状态并退出",
+    action: "exit"
+  }
+]
+
+const response = await AskUserQuestion({
+  questions: [{
+    question: "选择下一步操作：",
+    header: "操作",
+    multiSelect: false,
+    options: options.map(o => ({
+      label: o.label,
+      description: o.description
+    }))
+  }]
+})
+
+const selectedLabel = response["操作"]
+const selectedOption = options.find(o => o.label === selectedLabel)
+const nextAction = selectedOption?.action || 'action-menu'
+```
+
+### Step 3: 处理特殊选项
+
+```javascript
+if (nextAction === 'exit') {
+  console.log('\n保存状态并退出...')
+  return {
+    stateUpdates: {
+      status: 'user_exit'
+    },
+    continue: false,
+    message: '会话已保存，使用 --resume 可继续'
+  }
+}
+
+if (nextAction === 'action-status') {
+  // 显示详细状态
+  const sessionFolder = `.workflow/.loop/${state.session_id}`
+
+  console.log('\n=== 开发进度 ===')
+  const progress = Read(`${sessionFolder}/develop/progress.md`)
+  console.log(progress?.substring(0, 500) + '...')
+
+  console.log('\n=== 调试状态 ===')
+  if (state.debug.hypotheses.length > 0) {
+    state.debug.hypotheses.forEach(h => {
+      console.log(`  ${h.id}: ${h.status} - ${h.description.substring(0, 50)}...`)
+    })
+  } else {
+    console.log('  尚未开始调试')
+  }
+
+  console.log('\n=== 验证结果 ===')
+  if (state.validate.test_results.length > 0) {
+    const latest = state.validate.test_results[state.validate.test_results.length - 1]
+    console.log(`  最近运行: ${latest.timestamp}`)
+    console.log(`  通过率: ${latest.summary.pass_rate}%`)
+  } else {
+    console.log('  尚未运行验证')
+  }
+
+  // 返回菜单
+  return {
+    stateUpdates: {},
+    continue: true,
+    nextAction: 'action-menu',
+    message: ''
+  }
+}
+```
+
+## State Updates
+
+```javascript
+return {
+  stateUpdates: {
+    // 不更新状态，仅返回下一个动作
+  },
+  continue: true,
+  nextAction: nextAction,
+  message: `执行: ${selectedOption?.label || nextAction}`
+}
+```
+
+## Error Handling
+
+| Error Type | Recovery |
+|------------|----------|
+| 用户取消 | 返回菜单 |
+| 无效选择 | 重新显示菜单 |
+
+## Next Actions
+
+根据用户选择动态决定下一个动作。

.claude/skills/ccw-loop/phases/actions/action-validate-with-file.md

@@ -0,0 +1,307 @@
+# Action: Validate With File
+
+运行测试并验证实现，记录结果到 validation.md，支持 Gemini 辅助分析测试覆盖率和质量。
+
+## Purpose
+
+执行测试验证流程，包括:
+- 运行单元测试
+- 运行集成测试
+- 检查代码覆盖率
+- 生成验证报告
+- 分析失败原因
+
+## Preconditions
+
+- [ ] state.initialized === true
+- [ ] state.status === 'running'
+- [ ] state.develop.completed_count > 0 || state.debug.confirmed_hypothesis !== null
+
+## Session Setup
+
+```javascript
+const getUtc8ISOString = () => new Date(Date.now() + 8 * 60 * 60 * 1000).toISOString()
+
+const sessionFolder = `.workflow/.loop/${state.session_id}`
+const validateFolder = `${sessionFolder}/validate`
+const validationPath = `${validateFolder}/validation.md`
+const testResultsPath = `${validateFolder}/test-results.json`
+const coveragePath = `${validateFolder}/coverage.json`
+```
+
+---
+
+## Execution
+
+### Step 1: 运行测试
+
+```javascript
+console.log('\n运行测试...')
+
+// 检测测试框架
+const packageJson = JSON.parse(Read('package.json'))
+const testScript = packageJson.scripts?.test || 'npm test'
+
+// 运行测试并捕获输出
+const testResult = await Bash({
+  command: testScript,
+  timeout: 300000  // 5分钟
+})
+
+// 解析测试输出
+const testResults = parseTestOutput(testResult.stdout)
+```
+
+### Step 2: 检查覆盖率
+
+```javascript
+// 运行覆盖率检查
+let coverageData = null
+
+if (packageJson.scripts?.['test:coverage']) {
+  const coverageResult = await Bash({
+    command: 'npm run test:coverage',
+    timeout: 300000
+  })
+
+  // 解析覆盖率报告
+  coverageData = parseCoverageReport(coverageResult.stdout)
+
+  Write(coveragePath, JSON.stringify(coverageData, null, 2))
+}
+```
+
+### Step 3: Gemini 辅助分析
+
+```bash
+ccw cli -p "
+PURPOSE: Analyze test results and coverage
+Success criteria: Identify quality issues and suggest improvements
+
+TASK:
+• Analyze test execution results
+• Review code coverage metrics
+• Identify missing test cases
+• Suggest quality improvements
+• Verify requirements coverage
+
+MODE: analysis
+
+CONTEXT:
+@${testResultsPath}
+@${coveragePath}
+@${sessionFolder}/develop/progress.md
+
+EXPECTED:
+- Quality assessment report
+- Failed tests analysis
+- Coverage gaps identification
+- Improvement recommendations
+- Pass/Fail decision with rationale
+
+CONSTRAINTS: Evidence-based quality assessment
+" --tool gemini --mode analysis --rule analysis-review-code-quality
+```
+
+### Step 4: 生成验证报告
+
+```javascript
+const timestamp = getUtc8ISOString()
+const iteration = (state.validate.test_results?.length || 0) + 1
+
+const validationReport = `# Validation Report
+
+**Session ID**: ${state.session_id}
+**Task**: ${state.task_description}
+**Validated**: ${timestamp}
+
+---
+
+## Iteration ${iteration} - Validation Run
+
+### Test Execution Summary
+
+| Metric | Value |
+|--------|-------|
+| Total Tests | ${testResults.total} |
+| Passed | ${testResults.passed} |
+| Failed | ${testResults.failed} |
+| Skipped | ${testResults.skipped} |
+| Duration | ${testResults.duration_ms}ms |
+| **Pass Rate** | **${(testResults.passed / testResults.total * 100).toFixed(1)}%** |
+
+### Coverage Report
+
+${coverageData ? `
+| File | Statements | Branches | Functions | Lines |
+|------|------------|----------|-----------|-------|
+${coverageData.files.map(f => `| ${f.path} | ${f.statements}% | ${f.branches}% | ${f.functions}% | ${f.lines}% |`).join('\n')}
+
+**Overall Coverage**: ${coverageData.overall.statements}%
+` : '_No coverage data available_'}
+
+### Failed Tests
+
+${testResults.failed > 0 ? `
+${testResults.failures.map(f => `
+#### ${f.test_name}
+
+- **Suite**: ${f.suite}
+- **Error**: ${f.error_message}
+- **Stack**:
+\`\`\`
+${f.stack_trace}
+\`\`\`
+`).join('\n')}
+` : '_All tests passed_'}
+
+### Gemini Quality Analysis
+
+${geminiAnalysis}
+
+### Recommendations
+
+${recommendations.map(r => `- ${r}`).join('\n')}
+
+---
+
+## Validation Decision
+
+**Result**: ${testResults.passed === testResults.total ? '✅ PASS' : '❌ FAIL'}
+
+**Rationale**: ${validationDecision}
+
+${testResults.passed !== testResults.total ? `
+### Next Actions
+
+1. Review failed tests
+2. Debug failures using action-debug-with-file
+3. Fix issues and re-run validation
+` : `
+### Next Actions
+
+1. Consider code review
+2. Prepare for deployment
+3. Update documentation
+`}
+`
+
+// 写入验证报告
+Write(validationPath, validationReport)
+```
+
+### Step 5: 保存测试结果
+
+```javascript
+const testResultsData = {
+  iteration,
+  timestamp,
+  summary: {
+    total: testResults.total,
+    passed: testResults.passed,
+    failed: testResults.failed,
+    skipped: testResults.skipped,
+    pass_rate: (testResults.passed / testResults.total * 100).toFixed(1),
+    duration_ms: testResults.duration_ms
+  },
+  tests: testResults.tests,
+  failures: testResults.failures,
+  coverage: coverageData?.overall || null
+}
+
+Write(testResultsPath, JSON.stringify(testResultsData, null, 2))
+```
+
+---
+
+## State Updates
+
+```javascript
+const validationPassed = testResults.failed === 0 && testResults.passed > 0
+
+return {
+  stateUpdates: {
+    validate: {
+      test_results: [...(state.validate.test_results || []), testResultsData],
+      coverage: coverageData?.overall.statements || null,
+      passed: validationPassed,
+      failed_tests: testResults.failures.map(f => f.test_name),
+      last_run_at: getUtc8ISOString()
+    },
+    last_action: 'action-validate-with-file'
+  },
+  continue: true,
+  message: validationPassed
+    ? `验证通过 ✅\n测试: ${testResults.passed}/${testResults.total}\n覆盖率: ${coverageData?.overall.statements || 'N/A'}%`
+    : `验证失败 ❌\n失败: ${testResults.failed}/${testResults.total}\n建议进入调试模式`
+}
+```
+
+## Test Output Parsers
+
+### Jest/Vitest Parser
+
+```javascript
+function parseJestOutput(stdout) {
+  const testPattern = /Tests:\s+(\d+) passed.*?(\d+) failed.*?(\d+) total/
+  const match = stdout.match(testPattern)
+
+  return {
+    total: parseInt(match[3]),
+    passed: parseInt(match[1]),
+    failed: parseInt(match[2]),
+    // ... parse individual test results
+  }
+}
+```
+
+### Pytest Parser
+
+```javascript
+function parsePytestOutput(stdout) {
+  const summaryPattern = /(\d+) passed.*?(\d+) failed.*?(\d+) error/
+  // ... implementation
+}
+```
+
+## Error Handling
+
+| Error Type | Recovery |
+|------------|----------|
+| Tests don't run | 检查测试脚本配置，提示用户 |
+| All tests fail | 建议进入 debug 模式 |
+| Coverage tool missing | 跳过覆盖率检查，仅运行测试 |
+| Timeout | 增加超时时间或拆分测试 |
+
+## Validation Report Template
+
+参考 [templates/validation-template.md](../../templates/validation-template.md)
+
+## CLI Integration
+
+### 质量分析
+```bash
+ccw cli -p "PURPOSE: Analyze test results and coverage...
+TASK: • Review results • Identify gaps • Suggest improvements
+MODE: analysis
+CONTEXT: @test-results.json @coverage.json
+EXPECTED: Quality assessment
+" --tool gemini --mode analysis --rule analysis-review-code-quality
+```
+
+### 测试生成 (如覆盖率低)
+```bash
+ccw cli -p "PURPOSE: Generate missing test cases...
+TASK: • Analyze uncovered code • Write tests
+MODE: write
+CONTEXT: @coverage.json @src/**/*
+EXPECTED: Test code
+" --tool gemini --mode write --rule development-generate-tests
+```
+
+## Next Actions (Hints)
+
+- 验证通过: `action-complete` (完成循环)
+- 验证失败: `action-debug-with-file` (调试失败测试)
+- 覆盖率低: `action-develop-with-file` (添加测试)
+- 用户选择: `action-menu` (返回菜单)

.claude/skills/ccw-loop/phases/orchestrator.md

@@ -0,0 +1,486 @@
+# Orchestrator
+
+根据当前状态选择并执行下一个动作，实现无状态循环工作流。与 API (loop-v2-routes.ts) 协作实现控制平面/执行平面分离。
+
+## Role
+
+检查控制信号 → 读取文件状态 → 选择动作 → 执行 → 更新文件 → 循环，直到完成或被外部暂停/停止。
+
+## State Management (Unified Location)
+
+### 读取状态
+
+```javascript
+const getUtc8ISOString = () => new Date(Date.now() + 8 * 60 * 60 * 1000).toISOString()
+
+/**
+ * 读取循环状态 (统一位置)
+ * @param loopId - Loop ID (e.g., "loop-v2-20260122-abc123")
+ */
+function readLoopState(loopId) {
+  const stateFile = `.loop/${loopId}.json`
+
+  if (!fs.existsSync(stateFile)) {
+    return null
+  }
+
+  const state = JSON.parse(Read(stateFile))
+  return state
+}
+```
+
+### 更新状态
+
+```javascript
+/**
+ * 更新循环状态 (只更新 skill_state 部分，不修改 API 字段)
+ * @param loopId - Loop ID
+ * @param updates - 更新内容 (skill_state 字段)
+ */
+function updateLoopState(loopId, updates) {
+  const stateFile = `.loop/${loopId}.json`
+  const currentState = readLoopState(loopId)
+
+  if (!currentState) {
+    throw new Error(`Loop state not found: ${loopId}`)
+  }
+
+  // 只更新 skill_state 和 updated_at
+  const newState = {
+    ...currentState,
+    updated_at: getUtc8ISOString(),
+    skill_state: {
+      ...currentState.skill_state,
+      ...updates
+    }
+  }
+
+  Write(stateFile, JSON.stringify(newState, null, 2))
+  return newState
+}
+```
+
+### 创建新循环状态 (直接调用时)
+
+```javascript
+/**
+ * 创建新的循环状态 (仅在直接调用时使用，API 触发时状态已存在)
+ */
+function createLoopState(loopId, taskDescription) {
+  const stateFile = `.loop/${loopId}.json`
+  const now = getUtc8ISOString()
+
+  const state = {
+    // API 兼容字段
+    loop_id: loopId,
+    title: taskDescription.substring(0, 100),
+    description: taskDescription,
+    max_iterations: 10,
+    status: 'running',  // 直接调用时设为 running
+    current_iteration: 0,
+    created_at: now,
+    updated_at: now,
+
+    // Skill 扩展字段
+    skill_state: null  // 由 action-init 初始化
+  }
+
+  // 确保目录存在
+  Bash(`mkdir -p ".loop"`)
+  Bash(`mkdir -p ".loop/${loopId}.progress"`)
+
+  Write(stateFile, JSON.stringify(state, null, 2))
+  return state
+}
+```
+
+## Control Signal Checking
+
+```javascript
+/**
+ * 检查 API 控制信号
+ * 必须在每个 Action 开始前调用
+ * @returns { continue: boolean, reason: string }
+ */
+function checkControlSignals(loopId) {
+  const state = readLoopState(loopId)
+
+  if (!state) {
+    return { continue: false, reason: 'state_not_found' }
+  }
+
+  switch (state.status) {
+    case 'paused':
+      // API 暂停了循环，Skill 应退出等待 resume
+      console.log(`⏸️ Loop paused by API. Waiting for resume...`)
+      return { continue: false, reason: 'paused' }
+
+    case 'failed':
+      // API 停止了循环 (用户手动停止)
+      console.log(`⏹️ Loop stopped by API.`)
+      return { continue: false, reason: 'stopped' }
+
+    case 'completed':
+      // 已完成
+      console.log(`✅ Loop already completed.`)
+      return { continue: false, reason: 'completed' }
+
+    case 'created':
+      // API 创建但未启动 (不应该走到这里)
+      console.log(`⚠️ Loop not started by API.`)
+      return { continue: false, reason: 'not_started' }
+
+    case 'running':
+      // 正常继续
+      return { continue: true, reason: 'running' }
+
+    default:
+      console.log(`⚠️ Unknown status: ${state.status}`)
+      return { continue: false, reason: 'unknown_status' }
+  }
+}
+```
+
+## Decision Logic
+
+```javascript
+/**
+ * 选择下一个 Action (基于 skill_state)
+ */
+function selectNextAction(state, mode = 'interactive') {
+  const skillState = state.skill_state
+
+  // 1. 终止条件检查 (API status)
+  if (state.status === 'completed') return null
+  if (state.status === 'failed') return null
+  if (state.current_iteration >= state.max_iterations) {
+    console.warn(`已达到最大迭代次数 (${state.max_iterations})`)
+    return 'action-complete'
+  }
+
+  // 2. 初始化检查
+  if (!skillState || !skillState.current_action) {
+    return 'action-init'
+  }
+
+  // 3. 模式判断
+  if (mode === 'interactive') {
+    return 'action-menu'  // 显示菜单让用户选择
+  }
+
+  // 4. 自动模式：基于状态自动选择
+  if (mode === 'auto') {
+    // 按优先级：develop → debug → validate
+
+    // 如果有待开发任务
+    const hasPendingDevelop = skillState.develop?.tasks?.some(t => t.status === 'pending')
+    if (hasPendingDevelop) {
+      return 'action-develop-with-file'
+    }
+
+    // 如果开发完成但未调试
+    if (skillState.last_action === 'action-develop-with-file') {
+      const needsDebug = skillState.develop?.completed < skillState.develop?.total
+      if (needsDebug) {
+        return 'action-debug-with-file'
+      }
+    }
+
+    // 如果调试完成但未验证
+    if (skillState.last_action === 'action-debug-with-file' ||
+        skillState.debug?.confirmed_hypothesis) {
+      return 'action-validate-with-file'
+    }
+
+    // 如果验证失败，回到开发
+    if (skillState.last_action === 'action-validate-with-file') {
+      if (!skillState.validate?.passed) {
+        return 'action-develop-with-file'
+      }
+    }
+
+    // 全部通过，完成
+    if (skillState.validate?.passed && !hasPendingDevelop) {
+      return 'action-complete'
+    }
+
+    // 默认：开发
+    return 'action-develop-with-file'
+  }
+
+  // 5. 默认完成
+  return 'action-complete'
+}
+```
+
+## Execution Loop
+
+```javascript
+/**
+ * 运行编排器
+ * @param options.loopId - 现有 Loop ID (API 触发时)
+ * @param options.task - 任务描述 (直接调用时)
+ * @param options.mode - 'interactive' | 'auto'
+ */
+async function runOrchestrator(options = {}) {
+  const { loopId: existingLoopId, task, mode = 'interactive' } = options
+
+  console.log('=== CCW Loop Orchestrator Started ===')
+
+  // 1. 确定 loopId
+  let loopId
+  let state
+
+  if (existingLoopId) {
+    // API 触发：使用现有 loopId
+    loopId = existingLoopId
+    state = readLoopState(loopId)
+
+    if (!state) {
+      console.error(`Loop not found: ${loopId}`)
+      return { status: 'error', message: 'Loop not found' }
+    }
+
+    console.log(`Resuming loop: ${loopId}`)
+    console.log(`Status: ${state.status}`)
+
+  } else if (task) {
+    // 直接调用：创建新 loopId
+    const timestamp = getUtc8ISOString().replace(/[-:]/g, '').split('.')[0]
+    const random = Math.random().toString(36).substring(2, 10)
+    loopId = `loop-v2-${timestamp}-${random}`
+
+    console.log(`Creating new loop: ${loopId}`)
+    console.log(`Task: ${task}`)
+
+    state = createLoopState(loopId, task)
+
+  } else {
+    console.error('Either --loop-id or task description is required')
+    return { status: 'error', message: 'Missing loopId or task' }
+  }
+
+  const progressDir = `.loop/${loopId}.progress`
+
+  // 2. 主循环
+  let iteration = state.current_iteration || 0
+
+  while (iteration < state.max_iterations) {
+    iteration++
+
+    // ========================================
+    // CRITICAL: Check control signals first
+    // ========================================
+    const control = checkControlSignals(loopId)
+    if (!control.continue) {
+      console.log(`\n🛑 Loop terminated: ${control.reason}`)
+      break
+    }
+
+    // 重新读取状态 (可能被 API 更新)
+    state = readLoopState(loopId)
+
+    console.log(`\n[Iteration ${iteration}] Status: ${state.status}`)
+
+    // 选择下一个动作
+    const actionId = selectNextAction(state, mode)
+
+    if (!actionId) {
+      console.log('No action selected, terminating.')
+      break
+    }
+
+    console.log(`[Iteration ${iteration}] Executing: ${actionId}`)
+
+    // 更新 current_iteration
+    state = {
+      ...state,
+      current_iteration: iteration,
+      updated_at: getUtc8ISOString()
+    }
+    Write(`.loop/${loopId}.json`, JSON.stringify(state, null, 2))
+
+    // 执行动作
+    try {
+      const actionPromptFile = `.claude/skills/ccw-loop/phases/actions/${actionId}.md`
+
+      if (!fs.existsSync(actionPromptFile)) {
+        console.error(`Action file not found: ${actionPromptFile}`)
+        continue
+      }
+
+      const actionPrompt = Read(actionPromptFile)
+
+      // 构建 Agent 提示
+      const agentPrompt = `
+[LOOP CONTEXT]
+Loop ID: ${loopId}
+State File: .loop/${loopId}.json
+Progress Dir: ${progressDir}
+
+[CURRENT STATE]
+${JSON.stringify(state, null, 2)}
+
+[ACTION INSTRUCTIONS]
+${actionPrompt}
+
+[TASK]
+You are executing ${actionId} for loop: ${state.title || state.description}
+
+[CONTROL SIGNALS]
+Before executing, check if status is still 'running'.
+If status is 'paused' or 'failed', exit gracefully.
+
+[RETURN]
+Return JSON with:
+- skillStateUpdates: Object with skill_state fields to update
+- continue: Boolean indicating if loop should continue
+- message: String with user message
+`
+
+      const result = await Task({
+        subagent_type: 'universal-executor',
+        run_in_background: false,
+        description: `Execute ${actionId}`,
+        prompt: agentPrompt
+      })
+
+      // 解析结果
+      const actionResult = JSON.parse(result)
+
+      // 更新状态 (只更新 skill_state)
+      updateLoopState(loopId, {
+        current_action: null,
+        last_action: actionId,
+        completed_actions: [
+          ...(state.skill_state?.completed_actions || []),
+          actionId
+        ],
+        ...actionResult.skillStateUpdates
+      })
+
+      // 显示消息
+      if (actionResult.message) {
+        console.log(`\n${actionResult.message}`)
+      }
+
+      // 检查是否继续
+      if (actionResult.continue === false) {
+        console.log('Action requested termination.')
+        break
+      }
+
+    } catch (error) {
+      console.error(`Error executing ${actionId}: ${error.message}`)
+
+      // 错误处理
+      updateLoopState(loopId, {
+        current_action: null,
+        errors: [
+          ...(state.skill_state?.errors || []),
+          {
+            action: actionId,
+            message: error.message,
+            timestamp: getUtc8ISOString()
+          }
+        ]
+      })
+    }
+  }
+
+  if (iteration >= state.max_iterations) {
+    console.log(`\n⚠️ Reached maximum iterations (${state.max_iterations})`)
+    console.log('Consider breaking down the task or taking a break.')
+  }
+
+  console.log('\n=== CCW Loop Orchestrator Finished ===')
+
+  // 返回最终状态
+  const finalState = readLoopState(loopId)
+  return {
+    status: finalState.status,
+    loop_id: loopId,
+    iterations: iteration,
+    final_state: finalState
+  }
+}
+```
+
+## Action Catalog
+
+| Action | Purpose | Preconditions | Effects |
+|--------|---------|---------------|---------|
+| [action-init](actions/action-init.md) | 初始化会话 | status=pending | initialized=true |
+| [action-menu](actions/action-menu.md) | 显示操作菜单 | initialized=true | 用户选择下一动作 |
+| [action-develop-with-file](actions/action-develop-with-file.md) | 开发任务 | initialized=true | 更新 progress.md |
+| [action-debug-with-file](actions/action-debug-with-file.md) | 假设调试 | initialized=true | 更新 understanding.md |
+| [action-validate-with-file](actions/action-validate-with-file.md) | 测试验证 | initialized=true | 更新 validation.md |
+| [action-complete](actions/action-complete.md) | 完成循环 | validation_passed=true | status=completed |
+
+## Termination Conditions
+
+1. **API 暂停**: `state.status === 'paused'` (Skill 退出，等待 resume)
+2. **API 停止**: `state.status === 'failed'` (Skill 终止)
+3. **任务完成**: `state.status === 'completed'`
+4. **迭代限制**: `state.current_iteration >= state.max_iterations`
+5. **Action 请求终止**: `actionResult.continue === false`
+
+## Error Recovery
+
+| Error Type | Recovery Strategy |
+|------------|-------------------|
+| 动作执行失败 | 记录错误，增加 error_count，继续下一动作 |
+| 状态文件损坏 | 从其他文件重建状态 (progress.md, understanding.md 等) |
+| 用户中止 | 保存当前状态，允许 --resume 恢复 |
+| CLI 工具失败 | 回退到手动分析模式 |
+
+## Mode Strategies
+
+### Interactive Mode (默认)
+
+每次显示菜单，让用户选择动作：
+
+```
+当前状态: 开发中
+可用操作:
+  1. 继续开发 (develop)
+  2. 开始调试 (debug)
+  3. 运行验证 (validate)
+  4. 查看进度 (status)
+  5. 退出 (exit)
+
+请选择:
+```
+
+### Auto Mode (自动循环)
+
+按预设流程自动执行：
+
+```
+Develop → Debug → Validate →
+  ↓ (如验证失败)
+Develop (修复) → Debug → Validate → 完成
+```
+
+## State Machine (API Status)
+
+```mermaid
+stateDiagram-v2
+    [*] --> created: API creates loop
+    created --> running: API /start → Trigger Skill
+    running --> paused: API /pause → Set status
+    running --> completed: action-complete
+    running --> failed: API /stop OR error
+    paused --> running: API /resume → Re-trigger Skill
+    completed --> [*]
+    failed --> [*]
+
+    note right of paused
+      Skill checks status before each action
+      If paused, Skill exits gracefully
+    end note
+
+    note right of running
+      Skill executes: init → develop → debug → validate
+    end note
+```

.claude/skills/ccw-loop/phases/state-schema.md

@@ -0,0 +1,474 @@
+# State Schema
+
+CCW Loop 的状态结构定义（统一版本）。
+
+## 状态文件
+
+**位置**: `.loop/{loopId}.json` (统一位置，API + Skill 共享)
+
+**旧版本位置** (仅向后兼容): `.workflow/.loop/{session-id}/state.json`
+
+## 结构定义
+
+### 统一状态接口 (Unified Loop State)
+
+```typescript
+/**
+ * Unified Loop State - API 和 Skill 共享的状态结构
+ * API (loop-v2-routes.ts) 拥有状态的主控权
+ * Skill (ccw-loop) 读取和更新此状态
+ */
+interface LoopState {
+  // =====================================================
+  // API FIELDS (from loop-v2-routes.ts)
+  // 这些字段由 API 管理，Skill 只读
+  // =====================================================
+
+  loop_id: string                // Loop ID, e.g., "loop-v2-20260122-abc123"
+  title: string                  // Loop 标题
+  description: string            // Loop 描述
+  max_iterations: number         // 最大迭代次数
+  status: 'created' | 'running' | 'paused' | 'completed' | 'failed'
+  current_iteration: number      // 当前迭代次数
+  created_at: string             // 创建时间 (ISO8601)
+  updated_at: string             // 最后更新时间 (ISO8601)
+  completed_at?: string          // 完成时间 (ISO8601)
+  failure_reason?: string        // 失败原因
+
+  // =====================================================
+  // SKILL EXTENSION FIELDS
+  // 这些字段由 Skill 管理，API 只读
+  // =====================================================
+
+  skill_state?: {
+    // 当前执行动作
+    current_action: 'init' | 'develop' | 'debug' | 'validate' | 'complete' | null
+    last_action: string | null
+    completed_actions: string[]
+    mode: 'interactive' | 'auto'
+
+    // === 开发阶段 ===
+    develop: {
+      total: number
+      completed: number
+      current_task?: string
+      tasks: DevelopTask[]
+      last_progress_at: string | null
+    }
+
+    // === 调试阶段 ===
+    debug: {
+      active_bug?: string
+      hypotheses_count: number
+      hypotheses: Hypothesis[]
+      confirmed_hypothesis: string | null
+      iteration: number
+      last_analysis_at: string | null
+    }
+
+    // === 验证阶段 ===
+    validate: {
+      pass_rate: number           // 测试通过率 (0-100)
+      coverage: number            // 覆盖率 (0-100)
+      test_results: TestResult[]
+      passed: boolean
+      failed_tests: string[]
+      last_run_at: string | null
+    }
+
+    // === 错误追踪 ===
+    errors: Array<{
+      action: string
+      message: string
+      timestamp: string
+    }>
+  }
+}
+
+interface DevelopTask {
+  id: string
+  description: string
+  tool: 'gemini' | 'qwen' | 'codex' | 'bash'
+  mode: 'analysis' | 'write'
+  status: 'pending' | 'in_progress' | 'completed' | 'failed'
+  files_changed: string[]
+  created_at: string
+  completed_at: string | null
+}
+
+interface Hypothesis {
+  id: string                    // H1, H2, ...
+  description: string
+  testable_condition: string
+  logging_point: string
+  evidence_criteria: {
+    confirm: string
+    reject: string
+  }
+  likelihood: number            // 1 = 最可能
+  status: 'pending' | 'confirmed' | 'rejected' | 'inconclusive'
+  evidence: Record<string, any> | null
+  verdict_reason: string | null
+}
+
+interface TestResult {
+  test_name: string
+  suite: string
+  status: 'passed' | 'failed' | 'skipped'
+  duration_ms: number
+  error_message: string | null
+  stack_trace: string | null
+}
+```
+
+## 初始状态
+
+### 由 API 创建时 (Dashboard 触发)
+
+```json
+{
+  "loop_id": "loop-v2-20260122-abc123",
+  "title": "Implement user authentication",
+  "description": "Add login/logout functionality",
+  "max_iterations": 10,
+  "status": "created",
+  "current_iteration": 0,
+  "created_at": "2026-01-22T10:00:00+08:00",
+  "updated_at": "2026-01-22T10:00:00+08:00"
+}
+```
+
+### 由 Skill 初始化后 (action-init)
+
+```json
+{
+  "loop_id": "loop-v2-20260122-abc123",
+  "title": "Implement user authentication",
+  "description": "Add login/logout functionality",
+  "max_iterations": 10,
+  "status": "running",
+  "current_iteration": 0,
+  "created_at": "2026-01-22T10:00:00+08:00",
+  "updated_at": "2026-01-22T10:00:05+08:00",
+
+  "skill_state": {
+    "current_action": "init",
+    "last_action": null,
+    "completed_actions": [],
+    "mode": "auto",
+
+    "develop": {
+      "total": 3,
+      "completed": 0,
+      "current_task": null,
+      "tasks": [
+        { "id": "task-001", "description": "Create auth component", "status": "pending" }
+      ],
+      "last_progress_at": null
+    },
+
+    "debug": {
+      "active_bug": null,
+      "hypotheses_count": 0,
+      "hypotheses": [],
+      "confirmed_hypothesis": null,
+      "iteration": 0,
+      "last_analysis_at": null
+    },
+
+    "validate": {
+      "pass_rate": 0,
+      "coverage": 0,
+      "test_results": [],
+      "passed": false,
+      "failed_tests": [],
+      "last_run_at": null
+    },
+
+    "errors": []
+  }
+}
+```
+
+## 控制信号检查 (Control Signals)
+
+Skill 在每个 Action 开始前必须检查控制信号：
+
+```javascript
+/**
+ * 检查 API 控制信号
+ * @returns { continue: boolean, action: 'pause_exit' | 'stop_exit' | 'continue' }
+ */
+function checkControlSignals(loopId) {
+  const state = JSON.parse(Read(`.loop/${loopId}.json`))
+
+  switch (state.status) {
+    case 'paused':
+      // API 暂停了循环，Skill 应退出等待 resume
+      return { continue: false, action: 'pause_exit' }
+
+    case 'failed':
+      // API 停止了循环 (用户手动停止)
+      return { continue: false, action: 'stop_exit' }
+
+    case 'running':
+      // 正常继续
+      return { continue: true, action: 'continue' }
+
+    default:
+      // 异常状态
+      return { continue: false, action: 'stop_exit' }
+  }
+}
+```
+
+### 在 Action 中使用
+
+```markdown
+## Execution
+
+### Step 1: Check Control Signals
+
+\`\`\`javascript
+const control = checkControlSignals(loopId)
+if (!control.continue) {
+  // 输出退出原因
+  console.log(`Loop ${control.action}: status = ${state.status}`)
+
+  // 如果是 pause_exit，保存当前进度
+  if (control.action === 'pause_exit') {
+    updateSkillState(loopId, { current_action: 'paused' })
+  }
+
+  return  // 退出 Action
+}
+\`\`\`
+
+### Step 2: Execute Action Logic
+...
+```
+
+## 状态转换规则
+
+### 1. 初始化 (action-init)
+
+```javascript
+// Skill 初始化后
+{
+  // API 字段更新
+  status: 'created' → 'running',  // 或保持 'running' 如果 API 已设置
+  updated_at: timestamp,
+
+  // Skill 字段初始化
+  skill_state: {
+    current_action: 'init',
+    mode: 'auto',
+    develop: {
+      tasks: [...parsed_tasks],
+      total: N,
+      completed: 0
+    }
+  }
+}
+```
+
+### 2. 开发进行中 (action-develop-with-file)
+
+```javascript
+// 开发任务执行后
+{
+  updated_at: timestamp,
+  current_iteration: state.current_iteration + 1,
+
+  skill_state: {
+    current_action: 'develop',
+    last_action: 'action-develop-with-file',
+    completed_actions: [...state.skill_state.completed_actions, 'action-develop-with-file'],
+    develop: {
+      current_task: 'task-xxx',
+      completed: N+1,
+      last_progress_at: timestamp
+    }
+  }
+}
+```
+
+### 3. 调试进行中 (action-debug-with-file)
+
+```javascript
+// 调试执行后
+{
+  updated_at: timestamp,
+  current_iteration: state.current_iteration + 1,
+
+  skill_state: {
+    current_action: 'debug',
+    last_action: 'action-debug-with-file',
+    debug: {
+      active_bug: '...',
+      hypotheses_count: N,
+      hypotheses: [...new_hypotheses],
+      iteration: N+1,
+      last_analysis_at: timestamp
+    }
+  }
+}
+```
+
+### 4. 验证完成 (action-validate-with-file)
+
+```javascript
+// 验证执行后
+{
+  updated_at: timestamp,
+  current_iteration: state.current_iteration + 1,
+
+  skill_state: {
+    current_action: 'validate',
+    last_action: 'action-validate-with-file',
+    validate: {
+      test_results: [...results],
+      pass_rate: 95.5,
+      coverage: 85.0,
+      passed: true | false,
+      failed_tests: ['test1', 'test2'],
+      last_run_at: timestamp
+    }
+  }
+}
+```
+
+### 5. 完成 (action-complete)
+
+```javascript
+// 循环完成后
+{
+  status: 'running' → 'completed',
+  completed_at: timestamp,
+  updated_at: timestamp,
+
+  skill_state: {
+    current_action: 'complete',
+    last_action: 'action-complete'
+  }
+}
+```
+
+## 状态派生字段
+
+以下字段可从状态计算得出，不需要存储：
+
+```javascript
+// 开发完成度
+const developProgress = state.develop.total_count > 0
+  ? (state.develop.completed_count / state.develop.total_count) * 100
+  : 0
+
+// 是否有待开发任务
+const hasPendingDevelop = state.develop.tasks.some(t => t.status === 'pending')
+
+// 调试是否完成
+const debugCompleted = state.debug.confirmed_hypothesis !== null
+
+// 验证是否通过
+const validationPassed = state.validate.passed && state.validate.test_results.length > 0
+
+// 整体进度
+const overallProgress = (
+  (developProgress * 0.5) +
+  (debugCompleted ? 25 : 0) +
+  (validationPassed ? 25 : 0)
+)
+```
+
+## 文件同步
+
+### 统一位置 (Unified Location)
+
+状态与文件的对应关系：
+
+| 状态字段 | 同步文件 | 同步时机 |
+|----------|----------|----------|
+| 整个 LoopState | `.loop/{loopId}.json` | 每次状态变更 (主文件) |
+| `skill_state.develop` | `.loop/{loopId}.progress/develop.md` | 每次开发操作后 |
+| `skill_state.debug` | `.loop/{loopId}.progress/debug.md` | 每次调试操作后 |
+| `skill_state.validate` | `.loop/{loopId}.progress/validate.md` | 每次验证操作后 |
+| 代码变更日志 | `.loop/{loopId}.progress/changes.log` | 每次文件修改 (NDJSON) |
+| 调试日志 | `.loop/{loopId}.progress/debug.log` | 每次调试日志 (NDJSON) |
+
+### 文件结构示例
+
+```
+.loop/
+├── loop-v2-20260122-abc123.json         # 主状态文件 (API + Skill)
+├── loop-v2-20260122-abc123.tasks.jsonl  # 任务列表 (API 管理)
+└── loop-v2-20260122-abc123.progress/    # Skill 进度文件
+    ├── develop.md                       # 开发进度
+    ├── debug.md                         # 调试理解
+    ├── validate.md                      # 验证报告
+    ├── changes.log                      # 代码变更 (NDJSON)
+    └── debug.log                        # 调试日志 (NDJSON)
+```
+
+## 状态恢复
+
+如果主状态文件 `.loop/{loopId}.json` 损坏，可以从进度文件重建 skill_state:
+
+```javascript
+function rebuildSkillStateFromProgress(loopId) {
+  const progressDir = `.loop/${loopId}.progress`
+
+  // 尝试从进度文件解析状态
+  const skill_state = {
+    develop: parseProgressFile(`${progressDir}/develop.md`),
+    debug: parseProgressFile(`${progressDir}/debug.md`),
+    validate: parseProgressFile(`${progressDir}/validate.md`)
+  }
+
+  return skill_state
+}
+
+// 解析进度 Markdown 文件
+function parseProgressFile(filePath) {
+  const content = Read(filePath)
+  if (!content) return null
+
+  // 从 Markdown 表格和结构中提取数据
+  // ... implementation
+}
+```
+
+### 恢复策略
+
+1. **API 字段**: 无法恢复 - 需要从 API 重新获取或用户手动输入
+2. **skill_state 字段**: 可以从 `.progress/` 目录的 Markdown 文件解析
+3. **任务列表**: 从 `.loop/{loopId}.tasks.jsonl` 恢复
+
+## 状态验证
+
+```javascript
+function validateState(state) {
+  const errors = []
+
+  // 必需字段
+  if (!state.session_id) errors.push('Missing session_id')
+  if (!state.task_description) errors.push('Missing task_description')
+
+  // 状态一致性
+  if (state.initialized && state.status === 'pending') {
+    errors.push('Inconsistent: initialized but status is pending')
+  }
+
+  if (state.status === 'completed' && !state.validate.passed) {
+    errors.push('Inconsistent: completed but validation not passed')
+  }
+
+  // 开发任务一致性
+  const completedTasks = state.develop.tasks.filter(t => t.status === 'completed').length
+  if (completedTasks !== state.develop.completed_count) {
+    errors.push('Inconsistent: completed_count mismatch')
+  }
+
+  return { valid: errors.length === 0, errors }
+}
+```

.claude/skills/ccw-loop/specs/action-catalog.md

@@ -0,0 +1,300 @@
+# Action Catalog
+
+CCW Loop 所有可用动作的目录和说明。
+
+## Available Actions
+
+| Action | Purpose | Preconditions | Effects | CLI Integration |
+|--------|---------|---------------|---------|-----------------|
+| [action-init](../phases/actions/action-init.md) | 初始化会话 | status=pending, initialized=false | status→running, initialized→true, 创建目录和任务列表 | Gemini 任务分解 |
+| [action-menu](../phases/actions/action-menu.md) | 显示操作菜单 | initialized=true, status=running | 返回用户选择的动作 | - |
+| [action-develop-with-file](../phases/actions/action-develop-with-file.md) | 执行开发任务 | initialized=true, pending tasks > 0 | 更新 progress.md, 完成一个任务 | Gemini 代码实现 |
+| [action-debug-with-file](../phases/actions/action-debug-with-file.md) | 假设驱动调试 | initialized=true | 更新 understanding.md, hypotheses.json | Gemini 假设生成和证据分析 |
+| [action-validate-with-file](../phases/actions/action-validate-with-file.md) | 运行测试验证 | initialized=true, develop > 0 or debug confirmed | 更新 validation.md, test-results.json | Gemini 质量分析 |
+| [action-complete](../phases/actions/action-complete.md) | 完成循环 | initialized=true | status→completed, 生成 summary.md | - |
+
+## Action Dependencies Graph
+
+```mermaid
+graph TD
+    START([用户启动 /ccw-loop]) --> INIT[action-init]
+    INIT --> MENU[action-menu]
+
+    MENU --> DEVELOP[action-develop-with-file]
+    MENU --> DEBUG[action-debug-with-file]
+    MENU --> VALIDATE[action-validate-with-file]
+    MENU --> STATUS[action-status]
+    MENU --> COMPLETE[action-complete]
+    MENU --> EXIT([退出])
+
+    DEVELOP --> MENU
+    DEBUG --> MENU
+    VALIDATE --> MENU
+    STATUS --> MENU
+    COMPLETE --> END([结束])
+    EXIT --> END
+
+    style INIT fill:#e1f5fe
+    style MENU fill:#fff3e0
+    style DEVELOP fill:#e8f5e9
+    style DEBUG fill:#fce4ec
+    style VALIDATE fill:#f3e5f5
+    style COMPLETE fill:#c8e6c9
+```
+
+## Action Execution Matrix
+
+### Interactive Mode
+
+| State | Auto-Selected Action | User Options |
+|-------|---------------------|--------------|
+| pending | action-init | - |
+| running, !initialized | action-init | - |
+| running, initialized | action-menu | All actions |
+
+### Auto Mode
+
+| Condition | Selected Action |
+|-----------|----------------|
+| pending_develop_tasks > 0 | action-develop-with-file |
+| last_action=develop, !debug_completed | action-debug-with-file |
+| last_action=debug, !validation_completed | action-validate-with-file |
+| validation_failed | action-develop-with-file (fix) |
+| validation_passed, no pending | action-complete |
+
+## Action Inputs/Outputs
+
+### action-init
+
+**Inputs**:
+- state.task_description
+- User input (optional)
+
+**Outputs**:
+- meta.json
+- state.json (初始化)
+- develop/tasks.json
+- develop/progress.md
+
+**State Changes**:
+```javascript
+{
+  status: 'pending' → 'running',
+  initialized: false → true,
+  develop.tasks: [] → [task1, task2, ...]
+}
+```
+
+### action-develop-with-file
+
+**Inputs**:
+- state.develop.tasks
+- User selection (如有多个待处理任务)
+
+**Outputs**:
+- develop/progress.md (追加)
+- develop/tasks.json (更新)
+- develop/changes.log (追加)
+
+**State Changes**:
+```javascript
+{
+  develop.current_task_id: null → 'task-xxx' → null,
+  develop.completed_count: N → N+1,
+  last_action: X → 'action-develop-with-file'
+}
+```
+
+### action-debug-with-file
+
+**Inputs**:
+- Bug description (用户输入或从测试失败获取)
+- debug.log (如已有)
+
+**Outputs**:
+- debug/understanding.md (追加)
+- debug/hypotheses.json (更新)
+- Code changes (添加日志或修复)
+
+**State Changes**:
+```javascript
+{
+  debug.current_bug: null → 'bug description',
+  debug.hypotheses: [...updated],
+  debug.iteration: N → N+1,
+  debug.confirmed_hypothesis: null → 'H1' (如确认)
+}
+```
+
+### action-validate-with-file
+
+**Inputs**:
+- 测试脚本 (从 package.json)
+- 覆盖率工具 (可选)
+
+**Outputs**:
+- validate/validation.md (追加)
+- validate/test-results.json (更新)
+- validate/coverage.json (更新)
+
+**State Changes**:
+```javascript
+{
+  validate.test_results: [...new results],
+  validate.coverage: null → 85.5,
+  validate.passed: false → true,
+  validate.failed_tests: ['test1', 'test2'] → []
+}
+```
+
+### action-complete
+
+**Inputs**:
+- state (完整状态)
+- User choices (扩展选项)
+
+**Outputs**:
+- summary.md
+- Issues (如选择扩展)
+
+**State Changes**:
+```javascript
+{
+  status: 'running' → 'completed',
+  completed_at: null → timestamp
+}
+```
+
+## Action Sequences
+
+### Typical Happy Path
+
+```
+action-init
+  → action-develop-with-file (task 1)
+  → action-develop-with-file (task 2)
+  → action-develop-with-file (task 3)
+  → action-validate-with-file
+    → PASS
+  → action-complete
+```
+
+### Debug Iteration Path
+
+```
+action-init
+  → action-develop-with-file (task 1)
+  → action-validate-with-file
+    → FAIL
+  → action-debug-with-file (探索)
+  → action-debug-with-file (分析)
+    → Root cause found
+  → action-validate-with-file
+    → PASS
+  → action-complete
+```
+
+### Multi-Iteration Path
+
+```
+action-init
+  → action-develop-with-file (task 1)
+  → action-debug-with-file
+  → action-develop-with-file (task 2)
+  → action-validate-with-file
+    → FAIL
+  → action-debug-with-file
+  → action-validate-with-file
+    → PASS
+  → action-complete
+```
+
+## Error Scenarios
+
+### CLI Tool Failure
+
+```
+action-develop-with-file
+  → Gemini CLI fails
+  → Fallback to manual implementation
+  → Prompt user for code
+  → Continue
+```
+
+### Test Failure
+
+```
+action-validate-with-file
+  → Tests fail
+  → Record failed tests
+  → Suggest action-debug-with-file
+  → User chooses debug or manual fix
+```
+
+### Max Iterations Reached
+
+```
+state.iteration_count >= 10
+  → Warning message
+  → Suggest break or task split
+  → Allow continue or exit
+```
+
+## Action Extensions
+
+### Adding New Actions
+
+To add a new action:
+
+1. Create `phases/actions/action-{name}.md`
+2. Define preconditions, execution, state updates
+3. Add to this catalog
+4. Update orchestrator.md decision logic
+5. Add to action-menu.md options
+
+### Action Template
+
+```markdown
+# Action: {Name}
+
+{Brief description}
+
+## Purpose
+
+{Detailed purpose}
+
+## Preconditions
+
+- [ ] condition1
+- [ ] condition2
+
+## Execution
+
+### Step 1: {Step Name}
+
+\`\`\`javascript
+// code
+\`\`\`
+
+## State Updates
+
+\`\`\`javascript
+return {
+  stateUpdates: {
+    // updates
+  },
+  continue: true,
+  message: "..."
+}
+\`\`\`
+
+## Error Handling
+
+| Error Type | Recovery |
+|------------|----------|
+| ... | ... |
+
+## Next Actions (Hints)
+
+- condition: next_action
+```

.claude/skills/ccw-loop/specs/loop-requirements.md

@@ -0,0 +1,192 @@
+# Loop Requirements Specification
+
+CCW Loop 的核心需求和约束定义。
+
+## Core Requirements
+
+### 1. 无状态循环
+
+**Requirement**: 每次执行从文件读取状态，执行后写回文件，不依赖内存状态。
+
+**Rationale**: 支持随时中断和恢复，状态持久化。
+
+**Validation**:
+- [ ] 每个 action 开始时从文件读取状态
+- [ ] 每个 action 结束时将状态写回文件
+- [ ] 无全局变量或内存状态依赖
+
+### 2. 文件驱动进度
+
+**Requirement**: 所有进度、理解、验证结果都记录在专用 Markdown 文件中。
+
+**Rationale**: 可审计、可回顾、团队可见。
+
+**Validation**:
+- [ ] develop/progress.md 记录开发进度
+- [ ] debug/understanding.md 记录理解演变
+- [ ] validate/validation.md 记录验证结果
+- [ ] 所有文件使用 Markdown 格式，易读
+
+### 3. CLI 工具集成
+
+**Requirement**: 关键决策点使用 Gemini/CLI 进行深度分析。
+
+**Rationale**: 利用 LLM 能力提高质量。
+
+**Validation**:
+- [ ] 任务分解使用 Gemini
+- [ ] 假设生成使用 Gemini
+- [ ] 证据分析使用 Gemini
+- [ ] 质量评估使用 Gemini
+
+### 4. 用户控制循环
+
+**Requirement**: 支持交互式和自动循环两种模式，用户可随时介入。
+
+**Rationale**: 灵活性，适应不同场景。
+
+**Validation**:
+- [ ] 交互模式：每步显示菜单
+- [ ] 自动模式：按预设流程执行
+- [ ] 用户可随时退出
+- [ ] 状态可恢复
+
+### 5. 可恢复性
+
+**Requirement**: 任何时候中断后，可以从上次位置继续。
+
+**Rationale**: 长时间任务支持，意外中断恢复。
+
+**Validation**:
+- [ ] 状态保存在 state.json
+- [ ] 使用 --resume 可继续
+- [ ] 历史记录完整保留
+
+## Quality Standards
+
+### Completeness
+
+| Dimension | Threshold |
+|-----------|-----------|
+| 进度文档完整性 | 每个任务都有记录 |
+| 理解文档演变 | 每次迭代都有更新 |
+| 验证报告详尽 | 包含所有测试结果 |
+
+### Consistency
+
+| Dimension | Threshold |
+|-----------|-----------|
+| 文件格式一致 | 所有 Markdown 文件使用相同模板 |
+| 状态同步一致 | state.json 与文件内容匹配 |
+| 时间戳格式 | 统一使用 ISO8601 格式 |
+
+### Usability
+
+| Dimension | Threshold |
+|-----------|-----------|
+| 菜单易用性 | 选项清晰，描述准确 |
+| 进度可见性 | 随时可查看当前状态 |
+| 错误提示 | 错误消息清晰，提供恢复建议 |
+
+## Constraints
+
+### 1. 文件结构约束
+
+```
+.workflow/.loop/{session-id}/
+├── meta.json           # 只写一次，不再修改
+├── state.json          # 每次 action 后更新
+├── develop/
+│   ├── progress.md     # 只追加，不删除
+│   ├── tasks.json      # 任务状态更新
+│   └── changes.log     # NDJSON 格式，只追加
+├── debug/
+│   ├── understanding.md   # 只追加，记录时间线
+│   ├── hypotheses.json    # 更新假设状态
+│   └── debug.log          # NDJSON 格式
+└── validate/
+    ├── validation.md      # 每次验证追加
+    ├── test-results.json  # 累积测试结果
+    └── coverage.json      # 最新覆盖率
+```
+
+### 2. 命名约束
+
+- Session ID: `LOOP-{slug}-{YYYY-MM-DD}`
+- Task ID: `task-{NNN}` (三位数字)
+- Hypothesis ID: `H{N}` (单字母+数字)
+
+### 3. 状态转换约束
+
+```
+pending → running → completed
+              ↓
+         user_exit
+              ↓
+            failed
+```
+
+Only allow: `pending→running`, `running→completed/user_exit/failed`
+
+### 4. 错误限制约束
+
+- 最大错误次数: 3
+- 超过 3 次错误 → 自动终止
+- 每次错误 → 记录到 state.errors[]
+
+### 5. 迭代限制约束
+
+- 最大迭代次数: 10 (警告)
+- 超过 10 次 → 警告用户，但不强制停止
+- 建议拆分任务或休息
+
+## Integration Requirements
+
+### 1. Dashboard 集成
+
+**Requirement**: 与 CCW Dashboard Loop Monitor 无缝集成。
+
+**Specification**:
+- Dashboard 创建 Loop → 调用此 Skill
+- state.json → Dashboard 实时显示
+- 任务列表双向同步
+- 状态控制按钮映射到 actions
+
+### 2. Issue 系统集成
+
+**Requirement**: 完成后可扩展为 Issue。
+
+**Specification**:
+- 支持维度: test, enhance, refactor, doc
+- 调用 `/issue:new "{summary} - {dimension}"`
+- 自动填充上下文
+
+### 3. CLI 工具集成
+
+**Requirement**: 使用 CCW CLI 工具进行分析和实现。
+
+**Specification**:
+- 任务分解: `--rule planning-breakdown-task-steps`
+- 代码实现: `--rule development-implement-feature`
+- 根因分析: `--rule analysis-diagnose-bug-root-cause`
+- 质量评估: `--rule analysis-review-code-quality`
+
+## Non-Functional Requirements
+
+### Performance
+
+- Session 初始化: < 5s
+- Action 执行: < 30s (不含 CLI 调用)
+- 状态读写: < 1s
+
+### Reliability
+
+- 状态文件损坏恢复: 支持从其他文件重建
+- CLI 工具失败降级: 回退到手动模式
+- 错误重试: 支持一次自动重试
+
+### Maintainability
+
+- 文档化: 所有 action 都有清晰说明
+- 模块化: 每个 action 独立可测
+- 可扩展: 易于添加新 action

.claude/skills/ccw-loop/templates/progress-template.md

@@ -0,0 +1,175 @@
+# Progress Document Template
+
+开发进度文档的标准模板。
+
+## Template Structure
+
+```markdown
+# Development Progress
+
+**Session ID**: {{session_id}}
+**Task**: {{task_description}}
+**Started**: {{started_at}}
+**Estimated Complexity**: {{complexity}}
+
+---
+
+## Task List
+
+{{#each tasks}}
+{{@index}}. [{{#if completed}}x{{else}} {{/if}}] {{description}}
+{{/each}}
+
+## Key Files
+
+{{#each key_files}}
+- `{{this}}`
+{{/each}}
+
+---
+
+## Progress Timeline
+
+{{#each iterations}}
+### Iteration {{@index}} - {{task_name}} ({{timestamp}})
+
+#### Task Details
+
+- **ID**: {{task_id}}
+- **Tool**: {{tool}}
+- **Mode**: {{mode}}
+
+#### Implementation Summary
+
+{{summary}}
+
+#### Files Changed
+
+{{#each files_changed}}
+- `{{this}}`
+{{/each}}
+
+#### Status: {{status}}
+
+---
+{{/each}}
+
+## Current Statistics
+
+| Metric | Value |
+|--------|-------|
+| Total Tasks | {{total_tasks}} |
+| Completed | {{completed_tasks}} |
+| In Progress | {{in_progress_tasks}} |
+| Pending | {{pending_tasks}} |
+| Progress | {{progress_percentage}}% |
+
+---
+
+## Next Steps
+
+{{#each next_steps}}
+- [ ] {{this}}
+{{/each}}
+```
+
+## Template Variables
+
+| Variable | Type | Source | Description |
+|----------|------|--------|-------------|
+| `session_id` | string | state.session_id | 会话 ID |
+| `task_description` | string | state.task_description | 任务描述 |
+| `started_at` | string | state.created_at | 开始时间 |
+| `complexity` | string | state.context.estimated_complexity | 预估复杂度 |
+| `tasks` | array | state.develop.tasks | 任务列表 |
+| `key_files` | array | state.context.key_files | 关键文件 |
+| `iterations` | array | 从文件解析 | 迭代历史 |
+| `total_tasks` | number | state.develop.total_count | 总任务数 |
+| `completed_tasks` | number | state.develop.completed_count | 已完成数 |
+
+## Usage Example
+
+```javascript
+const progressTemplate = Read('.claude/skills/ccw-loop/templates/progress-template.md')
+
+function renderProgress(state) {
+  let content = progressTemplate
+
+  // 替换简单变量
+  content = content.replace('{{session_id}}', state.session_id)
+  content = content.replace('{{task_description}}', state.task_description)
+  content = content.replace('{{started_at}}', state.created_at)
+  content = content.replace('{{complexity}}', state.context?.estimated_complexity || 'unknown')
+
+  // 替换任务列表
+  const taskList = state.develop.tasks.map((t, i) => {
+    const checkbox = t.status === 'completed' ? 'x' : ' '
+    return `${i + 1}. [${checkbox}] ${t.description}`
+  }).join('\n')
+  content = content.replace('{{#each tasks}}...{{/each}}', taskList)
+
+  // 替换统计
+  content = content.replace('{{total_tasks}}', state.develop.total_count)
+  content = content.replace('{{completed_tasks}}', state.develop.completed_count)
+  // ...
+
+  return content
+}
+```
+
+## Section Templates
+
+### Task Entry
+
+```markdown
+### Iteration {{N}} - {{task_name}} ({{timestamp}})
+
+#### Task Details
+
+- **ID**: {{task_id}}
+- **Tool**: {{tool}}
+- **Mode**: {{mode}}
+
+#### Implementation Summary
+
+{{summary}}
+
+#### Files Changed
+
+{{#each files}}
+- `{{this}}`
+{{/each}}
+
+#### Status: COMPLETED
+
+---
+```
+
+### Statistics Table
+
+```markdown
+## Current Statistics
+
+| Metric | Value |
+|--------|-------|
+| Total Tasks | {{total}} |
+| Completed | {{completed}} |
+| In Progress | {{in_progress}} |
+| Pending | {{pending}} |
+| Progress | {{percentage}}% |
+```
+
+### Next Steps
+
+```markdown
+## Next Steps
+
+{{#if all_completed}}
+- [ ] Run validation tests
+- [ ] Code review
+- [ ] Update documentation
+{{else}}
+- [ ] Complete remaining {{pending}} tasks
+- [ ] Review completed work
+{{/if}}
+```

.claude/skills/ccw-loop/templates/understanding-template.md

@@ -0,0 +1,303 @@
+# Understanding Document Template
+
+调试理解演变文档的标准模板。
+
+## Template Structure
+
+```markdown
+# Understanding Document
+
+**Session ID**: {{session_id}}
+**Bug Description**: {{bug_description}}
+**Started**: {{started_at}}
+
+---
+
+## Exploration Timeline
+
+{{#each iterations}}
+### Iteration {{number}} - {{title}} ({{timestamp}})
+
+{{#if is_exploration}}
+#### Current Understanding
+
+Based on bug description and initial code search:
+
+- Error pattern: {{error_pattern}}
+- Affected areas: {{affected_areas}}
+- Initial hypothesis: {{initial_thoughts}}
+
+#### Evidence from Code Search
+
+{{#each search_results}}
+**Keyword: "{{keyword}}"**
+- Found in: {{files}}
+- Key findings: {{insights}}
+{{/each}}
+{{/if}}
+
+{{#if has_hypotheses}}
+#### Hypotheses Generated (Gemini-Assisted)
+
+{{#each hypotheses}}
+**{{id}}** (Likelihood: {{likelihood}}): {{description}}
+- Logging at: {{logging_point}}
+- Testing: {{testable_condition}}
+- Evidence to confirm: {{confirm_criteria}}
+- Evidence to reject: {{reject_criteria}}
+{{/each}}
+
+**Gemini Insights**: {{gemini_insights}}
+{{/if}}
+
+{{#if is_analysis}}
+#### Log Analysis Results
+
+{{#each results}}
+**{{id}}**: {{verdict}}
+- Evidence: {{evidence}}
+- Reasoning: {{reason}}
+{{/each}}
+
+#### Corrected Understanding
+
+Previous misunderstandings identified and corrected:
+
+{{#each corrections}}
+- ~~{{wrong}}~~ → {{corrected}}
+  - Why wrong: {{reason}}
+  - Evidence: {{evidence}}
+{{/each}}
+
+#### New Insights
+
+{{#each insights}}
+- {{this}}
+{{/each}}
+
+#### Gemini Analysis
+
+{{gemini_analysis}}
+{{/if}}
+
+{{#if root_cause_found}}
+#### Root Cause Identified
+
+**{{hypothesis_id}}**: {{description}}
+
+Evidence supporting this conclusion:
+{{supporting_evidence}}
+{{else}}
+#### Next Steps
+
+{{next_steps}}
+{{/if}}
+
+---
+{{/each}}
+
+## Current Consolidated Understanding
+
+### What We Know
+
+{{#each valid_understandings}}
+- {{this}}
+{{/each}}
+
+### What Was Disproven
+
+{{#each disproven}}
+- ~~{{assumption}}~~ (Evidence: {{evidence}})
+{{/each}}
+
+### Current Investigation Focus
+
+{{current_focus}}
+
+### Remaining Questions
+
+{{#each questions}}
+- {{this}}
+{{/each}}
+```
+
+## Template Variables
+
+| Variable | Type | Source | Description |
+|----------|------|--------|-------------|
+| `session_id` | string | state.session_id | 会话 ID |
+| `bug_description` | string | state.debug.current_bug | Bug 描述 |
+| `iterations` | array | 从文件解析 | 迭代历史 |
+| `hypotheses` | array | state.debug.hypotheses | 假设列表 |
+| `valid_understandings` | array | 从 Gemini 分析 | 有效理解 |
+| `disproven` | array | 从假设状态 | 被否定的假设 |
+
+## Section Templates
+
+### Exploration Section
+
+```markdown
+### Iteration {{N}} - Initial Exploration ({{timestamp}})
+
+#### Current Understanding
+
+Based on bug description and initial code search:
+
+- Error pattern: {{pattern}}
+- Affected areas: {{areas}}
+- Initial hypothesis: {{thoughts}}
+
+#### Evidence from Code Search
+
+{{#each search_results}}
+**Keyword: "{{keyword}}"**
+- Found in: {{files}}
+- Key findings: {{insights}}
+{{/each}}
+
+#### Next Steps
+
+- Generate testable hypotheses
+- Add instrumentation
+- Await reproduction
+```
+
+### Hypothesis Section
+
+```markdown
+#### Hypotheses Generated (Gemini-Assisted)
+
+| ID | Description | Likelihood | Status |
+|----|-------------|------------|--------|
+{{#each hypotheses}}
+| {{id}} | {{description}} | {{likelihood}} | {{status}} |
+{{/each}}
+
+**Details:**
+
+{{#each hypotheses}}
+**{{id}}**: {{description}}
+- Logging at: `{{logging_point}}`
+- Testing: {{testable_condition}}
+- Confirm: {{evidence_criteria.confirm}}
+- Reject: {{evidence_criteria.reject}}
+{{/each}}
+```
+
+### Analysis Section
+
+```markdown
+### Iteration {{N}} - Evidence Analysis ({{timestamp}})
+
+#### Log Analysis Results
+
+{{#each results}}
+**{{id}}**: **{{verdict}}**
+- Evidence: \`{{evidence}}\`
+- Reasoning: {{reason}}
+{{/each}}
+
+#### Corrected Understanding
+
+| Previous Assumption | Corrected To | Reason |
+|---------------------|--------------|--------|
+{{#each corrections}}
+| ~~{{wrong}}~~ | {{corrected}} | {{reason}} |
+{{/each}}
+
+#### Gemini Analysis
+
+{{gemini_analysis}}
+```
+
+### Consolidated Understanding Section
+
+```markdown
+## Current Consolidated Understanding
+
+### What We Know
+
+{{#each valid}}
+- {{this}}
+{{/each}}
+
+### What Was Disproven
+
+{{#each disproven}}
+- ~~{{this.assumption}}~~ (Evidence: {{this.evidence}})
+{{/each}}
+
+### Current Investigation Focus
+
+{{focus}}
+
+### Remaining Questions
+
+{{#each questions}}
+- {{this}}
+{{/each}}
+```
+
+### Resolution Section
+
+```markdown
+### Resolution ({{timestamp}})
+
+#### Fix Applied
+
+- Modified files: {{files}}
+- Fix description: {{description}}
+- Root cause addressed: {{root_cause}}
+
+#### Verification Results
+
+{{verification}}
+
+#### Lessons Learned
+
+{{#each lessons}}
+{{@index}}. {{this}}
+{{/each}}
+
+#### Key Insights for Future
+
+{{#each insights}}
+- {{this}}
+{{/each}}
+```
+
+## Consolidation Rules
+
+更新 "Current Consolidated Understanding" 时遵循以下规则:
+
+1. **简化被否定项**: 移到 "What Was Disproven"，只保留单行摘要
+2. **保留有效见解**: 将确认的发现提升到 "What We Know"
+3. **避免重复**: 不在合并部分重复时间线细节
+4. **关注当前状态**: 描述现在知道什么，而不是过程
+5. **保留关键纠正**: 保留重要的 wrong→right 转换供学习
+
+## Anti-Patterns
+
+**错误示例 (冗余)**:
+```markdown
+## Current Consolidated Understanding
+
+In iteration 1 we thought X, but in iteration 2 we found Y, then in iteration 3...
+Also we checked A and found B, and then we checked C...
+```
+
+**正确示例 (精简)**:
+```markdown
+## Current Consolidated Understanding
+
+### What We Know
+- Error occurs during runtime update, not initialization
+- Config value is None (not missing key)
+
+### What Was Disproven
+- ~~Initialization error~~ (Timing evidence)
+- ~~Missing key hypothesis~~ (Key exists)
+
+### Current Investigation Focus
+Why is config value None during update?
+```

.claude/skills/ccw-loop/templates/validation-template.md

@@ -0,0 +1,258 @@
+# Validation Report Template
+
+验证报告的标准模板。
+
+## Template Structure
+
+```markdown
+# Validation Report
+
+**Session ID**: {{session_id}}
+**Task**: {{task_description}}
+**Validated**: {{timestamp}}
+
+---
+
+## Iteration {{iteration}} - Validation Run
+
+### Test Execution Summary
+
+| Metric | Value |
+|--------|-------|
+| Total Tests | {{total_tests}} |
+| Passed | {{passed_tests}} |
+| Failed | {{failed_tests}} |
+| Skipped | {{skipped_tests}} |
+| Duration | {{duration}}ms |
+| **Pass Rate** | **{{pass_rate}}%** |
+
+### Coverage Report
+
+{{#if has_coverage}}
+| File | Statements | Branches | Functions | Lines |
+|------|------------|----------|-----------|-------|
+{{#each coverage_files}}
+| {{path}} | {{statements}}% | {{branches}}% | {{functions}}% | {{lines}}% |
+{{/each}}
+
+**Overall Coverage**: {{overall_coverage}}%
+{{else}}
+_No coverage data available_
+{{/if}}
+
+### Failed Tests
+
+{{#if has_failures}}
+{{#each failures}}
+#### {{test_name}}
+
+- **Suite**: {{suite}}
+- **Error**: {{error_message}}
+- **Stack**:
+\`\`\`
+{{stack_trace}}
+\`\`\`
+{{/each}}
+{{else}}
+_All tests passed_
+{{/if}}
+
+### Gemini Quality Analysis
+
+{{gemini_analysis}}
+
+### Recommendations
+
+{{#each recommendations}}
+- {{this}}
+{{/each}}
+
+---
+
+## Validation Decision
+
+**Result**: {{#if passed}}✅ PASS{{else}}❌ FAIL{{/if}}
+
+**Rationale**: {{rationale}}
+
+{{#if not_passed}}
+### Next Actions
+
+1. Review failed tests
+2. Debug failures using action-debug-with-file
+3. Fix issues and re-run validation
+{{else}}
+### Next Actions
+
+1. Consider code review
+2. Prepare for deployment
+3. Update documentation
+{{/if}}
+```
+
+## Template Variables
+
+| Variable | Type | Source | Description |
+|----------|------|--------|-------------|
+| `session_id` | string | state.session_id | 会话 ID |
+| `task_description` | string | state.task_description | 任务描述 |
+| `timestamp` | string | 当前时间 | 验证时间 |
+| `iteration` | number | 从文件计算 | 验证迭代次数 |
+| `total_tests` | number | 测试输出 | 总测试数 |
+| `passed_tests` | number | 测试输出 | 通过数 |
+| `failed_tests` | number | 测试输出 | 失败数 |
+| `pass_rate` | number | 计算得出 | 通过率 |
+| `coverage_files` | array | 覆盖率报告 | 文件覆盖率 |
+| `failures` | array | 测试输出 | 失败测试详情 |
+| `gemini_analysis` | string | Gemini CLI | 质量分析 |
+| `recommendations` | array | Gemini CLI | 建议列表 |
+
+## Section Templates
+
+### Test Summary
+
+```markdown
+### Test Execution Summary
+
+| Metric | Value |
+|--------|-------|
+| Total Tests | {{total}} |
+| Passed | {{passed}} |
+| Failed | {{failed}} |
+| Skipped | {{skipped}} |
+| Duration | {{duration}}ms |
+| **Pass Rate** | **{{rate}}%** |
+```
+
+### Coverage Table
+
+```markdown
+### Coverage Report
+
+| File | Statements | Branches | Functions | Lines |
+|------|------------|----------|-----------|-------|
+{{#each files}}
+| `{{path}}` | {{statements}}% | {{branches}}% | {{functions}}% | {{lines}}% |
+{{/each}}
+
+**Overall Coverage**: {{overall}}%
+
+**Coverage Thresholds**:
+- ✅ Good: ≥ 80%
+- ⚠️ Warning: 60-79%
+- ❌ Poor: < 60%
+```
+
+### Failed Test Details
+
+```markdown
+### Failed Tests
+
+{{#each failures}}
+#### ❌ {{test_name}}
+
+| Field | Value |
+|-------|-------|
+| Suite | {{suite}} |
+| Error | {{error_message}} |
+| Duration | {{duration}}ms |
+
+**Stack Trace**:
+\`\`\`
+{{stack_trace}}
+\`\`\`
+
+**Possible Causes**:
+{{#each possible_causes}}
+- {{this}}
+{{/each}}
+
+---
+{{/each}}
+```
+
+### Quality Analysis
+
+```markdown
+### Gemini Quality Analysis
+
+#### Code Quality Assessment
+
+| Dimension | Score | Status |
+|-----------|-------|--------|
+| Correctness | {{correctness}}/10 | {{correctness_status}} |
+| Completeness | {{completeness}}/10 | {{completeness_status}} |
+| Reliability | {{reliability}}/10 | {{reliability_status}} |
+| Maintainability | {{maintainability}}/10 | {{maintainability_status}} |
+
+#### Key Findings
+
+{{#each findings}}
+- **{{severity}}**: {{description}}
+{{/each}}
+
+#### Recommendations
+
+{{#each recommendations}}
+{{@index}}. {{this}}
+{{/each}}
+```
+
+### Decision Section
+
+```markdown
+## Validation Decision
+
+**Result**: {{#if passed}}✅ PASS{{else}}❌ FAIL{{/if}}
+
+**Rationale**:
+{{rationale}}
+
+**Confidence Level**: {{confidence}}
+
+### Decision Matrix
+
+| Criteria | Status | Weight | Score |
+|----------|--------|--------|-------|
+| All tests pass | {{tests_pass}} | 40% | {{tests_score}} |
+| Coverage ≥ 80% | {{coverage_pass}} | 30% | {{coverage_score}} |
+| No critical issues | {{no_critical}} | 20% | {{critical_score}} |
+| Quality analysis pass | {{quality_pass}} | 10% | {{quality_score}} |
+| **Total** | | 100% | **{{total_score}}** |
+
+**Threshold**: 70% to pass
+
+### Next Actions
+
+{{#if passed}}
+1. ✅ Code review (recommended)
+2. ✅ Update documentation
+3. ✅ Prepare for deployment
+{{else}}
+1. ❌ Review failed tests
+2. ❌ Debug failures
+3. ❌ Fix issues and re-run
+{{/if}}
+```
+
+## Historical Comparison
+
+```markdown
+## Validation History
+
+| Iteration | Date | Pass Rate | Coverage | Status |
+|-----------|------|-----------|----------|--------|
+{{#each history}}
+| {{iteration}} | {{date}} | {{pass_rate}}% | {{coverage}}% | {{status}} |
+{{/each}}
+
+### Trend Analysis
+
+{{#if improving}}
+📈 **Improving**: Pass rate increased from {{previous_rate}}% to {{current_rate}}%
+{{else if declining}}
+📉 **Declining**: Pass rate decreased from {{previous_rate}}% to {{current_rate}}%
+{{else}}
+➡️ **Stable**: Pass rate remains at {{current_rate}}%
+{{/if}}
+```

.claude/skills/ccw/SKILL.md

@@ -0,0 +1,522 @@
+---
+name: ccw
+description: Stateless workflow orchestrator. Auto-selects optimal workflow based on task intent. Triggers "ccw", "workflow".
+allowed-tools: Task(*), SlashCommand(*), AskUserQuestion(*), Read(*), Bash(*), Grep(*), TodoWrite(*)
+---
+
+# CCW - Claude Code Workflow Orchestrator
+
+无状态工作流协调器，根据任务意图自动选择最优工作流。
+
+## Workflow System Overview
+
+CCW 提供两个工作流系统：**Main Workflow** 和 **Issue Workflow**，协同覆盖完整的软件开发生命周期。
+
+```
+┌─────────────────────────────────────────────────────────────────────────────┐
+│                              Main Workflow                                  │
+│                                                                             │
+│  ┌─────────────┐   ┌─────────────┐   ┌─────────────┐   ┌─────────────┐     │
+│  │   Level 1   │ → │   Level 2   │ → │   Level 3   │ → │   Level 4   │     │
+│  │   Rapid     │   │ Lightweight │   │  Standard   │   │ Brainstorm  │     │
+│  │             │   │             │   │             │   │             │     │
+│  │ lite-lite-  │   │ lite-plan   │   │    plan     │   │ brainstorm  │     │
+│  │    lite     │   │ lite-fix    │   │  tdd-plan   │   │  :auto-     │     │
+│  │             │   │ multi-cli-  │   │ test-fix-   │   │  parallel   │     │
+│  │             │   │    plan     │   │    gen      │   │     ↓       │     │
+│  │             │   │             │   │             │   │   plan      │     │
+│  └─────────────┘   └─────────────┘   └─────────────┘   └─────────────┘     │
+│                                                                             │
+│  Complexity: ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━▶  │
+│              Low                                                    High    │
+└─────────────────────────────────────────────────────────────────────────────┘
+                                    │
+                                    │ After development
+                                    ▼
+┌─────────────────────────────────────────────────────────────────────────────┐
+│                              Issue Workflow                                 │
+│                                                                             │
+│     ┌──────────────┐         ┌──────────────┐         ┌──────────────┐     │
+│     │  Accumulate  │    →    │    Plan      │    →    │   Execute    │     │
+│     │  Discover &  │         │    Batch     │         │   Parallel   │     │
+│     │   Collect    │         │   Planning   │         │  Execution   │     │
+│     └──────────────┘         └──────────────┘         └──────────────┘     │
+│                                                                             │
+│     Supplementary role: Maintain main branch stability, worktree isolation  │
+└─────────────────────────────────────────────────────────────────────────────┘
+```
+
+## Architecture
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│  CCW Orchestrator (CLI-Enhanced + Requirement Analysis)         │
+├─────────────────────────────────────────────────────────────────┤
+│  Phase 1    │ Input Analysis (rule-based, fast path)            │
+│  Phase 1.5  │ CLI Classification (semantic, smart path)         │
+│  Phase 1.75 │ Requirement Clarification (clarity < 2)           │
+│  Phase 2    │ Level Selection (intent → level → workflow)       │
+│  Phase 2.5  │ CLI Action Planning (high complexity)             │
+│  Phase 3    │ User Confirmation (optional)                      │
+│  Phase 4    │ TODO Tracking Setup                               │
+│  Phase 5    │ Execution Loop                                    │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+## Level Quick Reference
+
+| Level | Name | Workflows | Artifacts | Execution |
+|-------|------|-----------|-----------|-----------|
+| **1** | Rapid | `lite-lite-lite` | None | Direct execute |
+| **2** | Lightweight | `lite-plan`, `lite-fix`, `multi-cli-plan` | Memory/Lightweight files | → `lite-execute` |
+| **3** | Standard | `plan`, `tdd-plan`, `test-fix-gen` | Session persistence | → `execute` / `test-cycle-execute` |
+| **4** | Brainstorm | `brainstorm:auto-parallel` → `plan` | Multi-role analysis + Session | → `execute` |
+| **-** | Issue | `discover` → `plan` → `queue` → `execute` | Issue records | Worktree isolation (optional) |
+
+## Workflow Selection Decision Tree
+
+```
+Start
+  │
+  ├─ Is it post-development maintenance?
+  │     ├─ Yes → Issue Workflow
+  │     └─ No ↓
+  │
+  ├─ Are requirements clear?
+  │     ├─ Uncertain → Level 4 (brainstorm:auto-parallel)
+  │     └─ Clear ↓
+  │
+  ├─ Need persistent Session?
+  │     ├─ Yes → Level 3 (plan / tdd-plan / test-fix-gen)
+  │     └─ No ↓
+  │
+  ├─ Need multi-perspective / solution comparison?
+  │     ├─ Yes → Level 2 (multi-cli-plan)
+  │     └─ No ↓
+  │
+  ├─ Is it a bug fix?
+  │     ├─ Yes → Level 2 (lite-fix)
+  │     └─ No ↓
+  │
+  ├─ Need planning?
+  │     ├─ Yes → Level 2 (lite-plan)
+  │     └─ No → Level 1 (lite-lite-lite)
+```
+
+## Intent Classification
+
+### Priority Order (with Level Mapping)
+
+| Priority | Intent | Patterns | Level | Flow |
+|----------|--------|----------|-------|------|
+| 1 | bugfix/hotfix | `urgent,production,critical` + bug | L2 | `bugfix.hotfix` |
+| 1 | bugfix | `fix,bug,error,crash,fail` | L2 | `bugfix.standard` |
+| 2 | issue batch | `issues,batch` + `fix,resolve` | Issue | `issue` |
+| 3 | exploration | `不确定,explore,研究,what if` | L4 | `full` |
+| 3 | multi-perspective | `多视角,权衡,比较方案,cross-verify` | L2 | `multi-cli-plan` |
+| 4 | quick-task | `快速,简单,small,quick` + feature | L1 | `lite-lite-lite` |
+| 5 | ui design | `ui,design,component,style` | L3/L4 | `ui` |
+| 6 | tdd | `tdd,test-driven,先写测试` | L3 | `tdd` |
+| 7 | test-fix | `测试失败,test fail,fix test` | L3 | `test-fix-gen` |
+| 8 | review | `review,审查,code review` | L3 | `review-fix` |
+| 9 | documentation | `文档,docs,readme` | L2 | `docs` |
+| 99 | feature | complexity-based | L2/L3 | `rapid`/`coupled` |
+
+### Quick Selection Guide
+
+| Scenario | Recommended Workflow | Level |
+|----------|---------------------|-------|
+| Quick fixes, config adjustments | `lite-lite-lite` | 1 |
+| Clear single-module features | `lite-plan → lite-execute` | 2 |
+| Bug diagnosis and fix | `lite-fix` | 2 |
+| Production emergencies | `lite-fix --hotfix` | 2 |
+| Technology selection, solution comparison | `multi-cli-plan → lite-execute` | 2 |
+| Multi-module changes, refactoring | `plan → verify → execute` | 3 |
+| Test-driven development | `tdd-plan → execute → tdd-verify` | 3 |
+| Test failure fixes | `test-fix-gen → test-cycle-execute` | 3 |
+| New features, architecture design | `brainstorm:auto-parallel → plan → execute` | 4 |
+| Post-development issue fixes | Issue Workflow | - |
+
+### Complexity Assessment
+
+```javascript
+function assessComplexity(text) {
+  let score = 0
+  if (/refactor|重构|migrate|迁移|architect|架构|system|系统/.test(text)) score += 2
+  if (/multiple|多个|across|跨|all|所有|entire|整个/.test(text)) score += 2
+  if (/integrate|集成|api|database|数据库/.test(text)) score += 1
+  if (/security|安全|performance|性能|scale|扩展/.test(text)) score += 1
+  return score >= 4 ? 'high' : score >= 2 ? 'medium' : 'low'
+}
+```
+
+| Complexity | Flow |
+|------------|------|
+| high | `coupled` (plan → verify → execute) |
+| medium/low | `rapid` (lite-plan → lite-execute) |
+
+### Dimension Extraction (WHAT/WHERE/WHY/HOW)
+
+从用户输入提取四个维度，用于需求澄清和工作流选择：
+
+| 维度 | 提取内容 | 示例模式 |
+|------|----------|----------|
+| **WHAT** | action + target | `创建/修复/重构/优化/分析` + 目标对象 |
+| **WHERE** | scope + paths | `file/module/system` + 文件路径 |
+| **WHY** | goal + motivation | `为了.../因为.../目的是...` |
+| **HOW** | constraints + preferences | `必须.../不要.../应该...` |
+
+**Clarity Score** (0-3):
+- +0.5: 有明确 action
+- +0.5: 有具体 target
+- +0.5: 有文件路径
+- +0.5: scope 不是 unknown
+- +0.5: 有明确 goal
+- +0.5: 有约束条件
+- -0.5: 包含不确定词 (`不知道/maybe/怎么`)
+
+### Requirement Clarification
+
+当 `clarity_score < 2` 时触发需求澄清：
+
+```javascript
+if (dimensions.clarity_score < 2) {
+  const questions = generateClarificationQuestions(dimensions)
+  // 生成问题：目标是什么? 范围是什么? 有什么约束?
+  AskUserQuestion({ questions })
+}
+```
+
+**澄清问题类型**:
+- 目标不明确 → "你想要对什么进行操作?"
+- 范围不明确 → "操作的范围是什么?"
+- 目的不明确 → "这个操作的主要目标是什么?"
+- 复杂操作 → "有什么特殊要求或限制?"
+
+## TODO Tracking Protocol
+
+### CRITICAL: Append-Only Rule
+
+CCW 创建的 Todo **必须附加到现有列表**，不能覆盖用户的其他 Todo。
+
+### Implementation
+
+```javascript
+// 1. 使用 CCW 前缀隔离工作流 todo
+const prefix = `CCW:${flowName}`
+
+// 2. 创建新 todo 时使用前缀格式
+TodoWrite({
+  todos: [
+    ...existingNonCCWTodos,  // 保留用户的 todo
+    { content: `${prefix}: [1/N] /command:step1`, status: "in_progress", activeForm: "..." },
+    { content: `${prefix}: [2/N] /command:step2`, status: "pending", activeForm: "..." }
+  ]
+})
+
+// 3. 更新状态时只修改匹配前缀的 todo
+```
+
+### Todo Format
+
+```
+CCW:{flow}: [{N}/{Total}] /command:name
+```
+
+### Visual Example
+
+```
+✓ CCW:rapid: [1/2] /workflow:lite-plan
+→ CCW:rapid: [2/2] /workflow:lite-execute
+  用户自己的 todo（保留不动）
+```
+
+### Status Management
+
+- 开始工作流：创建所有步骤 todo，第一步 `in_progress`
+- 完成步骤：当前步骤 `completed`，下一步 `in_progress`
+- 工作流结束：所有 CCW todo 标记 `completed`
+
+## Execution Flow
+
+```javascript
+// 1. Check explicit command
+if (input.startsWith('/workflow:') || input.startsWith('/issue:')) {
+  SlashCommand(input)
+  return
+}
+
+// 2. Classify intent
+const intent = classifyIntent(input)  // See command.json intent_rules
+
+// 3. Select flow
+const flow = selectFlow(intent)  // See command.json flows
+
+// 4. Create todos with CCW prefix
+createWorkflowTodos(flow)
+
+// 5. Dispatch first command
+SlashCommand(flow.steps[0].command, args: input)
+```
+
+## CLI Tool Integration
+
+CCW 在特定条件下自动注入 CLI 调用：
+
+| Condition | CLI Inject |
+|-----------|------------|
+| 大量代码上下文 (≥50k chars) | `gemini --mode analysis` |
+| 高复杂度任务 | `gemini --mode analysis` |
+| Bug 诊断 | `gemini --mode analysis` |
+| 多任务执行 (≥3 tasks) | `codex --mode write` |
+
+### CLI Enhancement Phases
+
+**Phase 1.5: CLI-Assisted Classification**
+
+当规则匹配不明确时，使用 CLI 辅助分类：
+
+| 触发条件 | 说明 |
+|----------|------|
+| matchCount < 2 | 多个意图模式匹配 |
+| complexity = high | 高复杂度任务 |
+| input > 100 chars | 长输入需要语义理解 |
+
+**Phase 2.5: CLI-Assisted Action Planning**
+
+高复杂度任务的工作流优化：
+
+| 触发条件 | 说明 |
+|----------|------|
+| complexity = high | 高复杂度任务 |
+| steps >= 3 | 多步骤工作流 |
+| input > 200 chars | 复杂需求描述 |
+
+CLI 可返回建议：`use_default` | `modify` (调整步骤) | `upgrade` (升级工作流)
+
+## Continuation Commands
+
+工作流执行中的用户控制命令：
+
+| 命令 | 作用 |
+|------|------|
+| `continue` | 继续执行下一步 |
+| `skip` | 跳过当前步骤 |
+| `abort` | 终止工作流 |
+| `/workflow:*` | 切换到指定命令 |
+| 自然语言 | 重新分析意图 |
+
+## Workflow Flow Details
+
+### Issue Workflow (Main Workflow 补充机制)
+
+Issue Workflow 是 Main Workflow 的**补充机制**，专注于开发后的持续维护。
+
+#### 设计理念
+
+| 方面 | Main Workflow | Issue Workflow |
+|------|---------------|----------------|
+| **用途** | 主要开发周期 | 开发后维护 |
+| **时机** | 功能开发阶段 | 主工作流完成后 |
+| **范围** | 完整功能实现 | 针对性修复/增强 |
+| **并行性** | 依赖分析 → Agent 并行 | Worktree 隔离 (可选) |
+| **分支模型** | 当前分支工作 | 可使用隔离的 worktree |
+
+#### 为什么 Main Workflow 不自动使用 Worktree？
+
+**依赖分析已解决并行性问题**：
+1. 规划阶段 (`/workflow:plan`) 执行依赖分析
+2. 自动识别任务依赖和关键路径
+3. 划分为**并行组**（独立任务）和**串行链**（依赖任务）
+4. Agent 并行执行独立任务，无需文件系统隔离
+
+#### 两阶段生命周期
+
+```
+┌─────────────────────────────────────────────────────────────────────┐
+│                    Phase 1: Accumulation (积累阶段)                  │
+│                                                                     │
+│   Triggers: 任务完成后的 review、代码审查发现、测试失败              │
+│                                                                     │
+│   ┌────────────┐     ┌────────────┐     ┌────────────┐             │
+│   │ discover   │     │ discover-  │     │    new     │             │
+│   │ Auto-find  │     │ by-prompt  │     │  Manual    │             │
+│   └────────────┘     └────────────┘     └────────────┘             │
+│                                                                     │
+│   持续积累 issues 到待处理队列                                       │
+└─────────────────────────────────────────────────────────────────────┘
+                               │
+                               │ 积累足够后
+                               ▼
+┌─────────────────────────────────────────────────────────────────────┐
+│                  Phase 2: Batch Resolution (批量解决阶段)            │
+│                                                                     │
+│   ┌────────────┐     ┌────────────┐     ┌────────────┐             │
+│   │   plan     │ ──→ │   queue    │ ──→ │  execute   │             │
+│   │ --all-     │     │ Optimize   │     │  Parallel  │             │
+│   │  pending   │     │  order     │     │ execution  │             │
+│   └────────────┘     └────────────┘     └────────────┘             │
+│                                                                     │
+│   支持 worktree 隔离，保持主分支稳定                                 │
+└─────────────────────────────────────────────────────────────────────┘
+```
+
+#### 与 Main Workflow 的协作
+
+```
+开发迭代循环
+┌─────────────────────────────────────────────────────────────────────┐
+│                                                                     │
+│   ┌─────────┐                              ┌─────────┐             │
+│   │ Feature │ ──→ Main Workflow ──→ Done ──→│ Review  │             │
+│   │ Request │     (Level 1-4)              └────┬────┘             │
+│   └─────────┘                                   │                  │
+│        ▲                                        │ 发现 Issues       │
+│        │                                        ▼                  │
+│        │                                  ┌─────────┐              │
+│   继续 │                                  │  Issue  │              │
+│   新功能│                                  │ Workflow│              │
+│        │                                  └────┬────┘              │
+│        │         ┌──────────────────────────────┘                   │
+│        │         │ 修复完成                                          │
+│        │         ▼                                                 │
+│   ┌────┴────┐◀──────                                               │
+│   │  Main   │    Merge                                             │
+│   │ Branch  │    back                                              │
+│   └─────────┘                                                      │
+│                                                                     │
+└─────────────────────────────────────────────────────────────────────┘
+```
+
+#### 命令列表
+
+**积累阶段：**
+```bash
+/issue:discover            # 多视角自动发现
+/issue:discover-by-prompt  # 基于提示发现
+/issue:new                 # 手动创建
+```
+
+**批量解决阶段：**
+```bash
+/issue:plan --all-pending  # 批量规划所有待处理
+/issue:queue               # 生成优化执行队列
+/issue:execute             # 并行执行
+```
+
+### lite-lite-lite vs multi-cli-plan
+
+| 维度 | lite-lite-lite | multi-cli-plan |
+|------|---------------|----------------|
+| **产物** | 无文件 | IMPL_PLAN.md + plan.json + synthesis.json |
+| **状态** | 无状态 | 持久化 session |
+| **CLI选择** | 自动分析任务类型选择 | 配置驱动 |
+| **迭代** | 通过 AskUser | 多轮收敛 |
+| **执行** | 直接执行 | 通过 lite-execute |
+| **适用** | 快速修复、简单功能 | 复杂多步骤实现 |
+
+**选择指南**：
+- 任务清晰、改动范围小 → `lite-lite-lite`
+- 需要多视角分析、复杂架构 → `multi-cli-plan`
+
+### multi-cli-plan vs lite-plan
+
+| 维度 | multi-cli-plan | lite-plan |
+|------|---------------|-----------|
+| **上下文** | ACE 语义搜索 | 手动文件模式 |
+| **分析** | 多 CLI 交叉验证 | 单次规划 |
+| **迭代** | 多轮直到收敛 | 单轮 |
+| **置信度** | 高 (共识驱动) | 中 (单一视角) |
+| **适用** | 需要多视角的复杂任务 | 直接明确的实现 |
+
+**选择指南**：
+- 需求明确、路径清晰 → `lite-plan`
+- 需要权衡、多方案比较 → `multi-cli-plan`
+
+## Artifact Flow Protocol
+
+工作流产出的自动流转机制，支持不同格式产出间的意图提取和完成度判断。
+
+### 产出格式
+
+| 命令 | 产出位置 | 格式 | 关键字段 |
+|------|----------|------|----------|
+| `/workflow:lite-plan` | memory://plan | structured_plan | tasks, files, dependencies |
+| `/workflow:plan` | .workflow/{session}/IMPL_PLAN.md | markdown_plan | phases, tasks, risks |
+| `/workflow:execute` | execution_log.json | execution_report | completed_tasks, errors |
+| `/workflow:test-cycle-execute` | test_results.json | test_report | pass_rate, failures, coverage |
+| `/workflow:review-session-cycle` | review_report.md | review_report | findings, severity_counts |
+
+### 意图提取 (Intent Extraction)
+
+流转到下一步时，自动提取关键信息：
+
+```
+plan → execute:
+  提取: tasks (未完成), priority_order, files_to_modify, context_summary
+
+execute → test:
+  提取: modified_files, test_scope (推断), pending_verification
+
+test → fix:
+  条件: pass_rate < 0.95
+  提取: failures, error_messages, affected_files, suggested_fixes
+
+review → fix:
+  条件: critical > 0 OR high > 3
+  提取: findings (critical/high), fix_priority, affected_files
+```
+
+### 完成度判断
+
+**Test 完成度路由**:
+```
+pass_rate >= 0.95 AND coverage >= 0.80  → complete
+pass_rate >= 0.95 AND coverage < 0.80   → add_more_tests
+pass_rate >= 0.80                        → fix_failures_then_continue
+pass_rate < 0.80                         → major_fix_required
+```
+
+**Review 完成度路由**:
+```
+critical == 0 AND high <= 3  → complete_or_optional_fix
+critical > 0                  → mandatory_fix
+high > 3                      → recommended_fix
+```
+
+### 流转决策模式
+
+**plan_execute_test**:
+```
+plan → execute → test
+         ↓ (if test fail)
+    extract_failures → fix → test (max 3 iterations)
+         ↓ (if still fail)
+    manual_intervention
+```
+
+**iterative_improvement**:
+```
+execute → test → fix → test → ...
+    loop until: pass_rate >= 0.95 OR iterations >= 3
+```
+
+### 使用示例
+
+```javascript
+// 执行完成后，根据产出决定下一步
+const result = await execute(plan)
+
+// 提取意图流转到测试
+const testContext = extractIntent('execute_to_test', result)
+// testContext = { modified_files, test_scope, pending_verification }
+
+// 测试完成后，根据完成度决定路由
+const testResult = await test(testContext)
+const nextStep = evaluateCompletion('test', testResult)
+// nextStep = 'fix_failures_then_continue' if pass_rate = 0.85
+```
+
+## Reference
+
+- [command.json](command.json) - 命令元数据、Flow 定义、意图规则、Artifact Flow

.claude/skills/ccw/command.json

@@ -0,0 +1,641 @@
+{
+  "_metadata": {
+    "version": "2.0.0",
+    "description": "Unified CCW command index with capabilities, flows, and intent rules"
+  },
+
+  "capabilities": {
+    "explore": {
+      "description": "Codebase exploration and context gathering",
+      "commands": ["/workflow:init", "/workflow:tools:gather", "/memory:load"],
+      "agents": ["cli-explore-agent", "context-search-agent"]
+    },
+    "brainstorm": {
+      "description": "Multi-perspective analysis and ideation",
+      "commands": ["/workflow:brainstorm:auto-parallel", "/workflow:brainstorm:artifacts", "/workflow:brainstorm:synthesis"],
+      "roles": ["product-manager", "system-architect", "ux-expert", "data-architect", "api-designer"]
+    },
+    "plan": {
+      "description": "Task planning and decomposition",
+      "commands": ["/workflow:lite-plan", "/workflow:plan", "/workflow:tdd-plan", "/task:create", "/task:breakdown"],
+      "agents": ["cli-lite-planning-agent", "action-planning-agent"]
+    },
+    "verify": {
+      "description": "Plan and quality verification",
+      "commands": ["/workflow:action-plan-verify", "/workflow:tdd-verify"]
+    },
+    "execute": {
+      "description": "Task execution and implementation",
+      "commands": ["/workflow:lite-execute", "/workflow:execute", "/task:execute"],
+      "agents": ["code-developer", "cli-execution-agent", "universal-executor"]
+    },
+    "bugfix": {
+      "description": "Bug diagnosis and fixing",
+      "commands": ["/workflow:lite-fix"],
+      "agents": ["code-developer"]
+    },
+    "test": {
+      "description": "Test generation and execution",
+      "commands": ["/workflow:test-gen", "/workflow:test-fix-gen", "/workflow:test-cycle-execute"],
+      "agents": ["test-fix-agent"]
+    },
+    "review": {
+      "description": "Code review and quality analysis",
+      "commands": ["/workflow:review-session-cycle", "/workflow:review-module-cycle", "/workflow:review", "/workflow:review-fix"]
+    },
+    "issue": {
+      "description": "Issue lifecycle management - discover, accumulate, batch resolve",
+      "commands": ["/issue:new", "/issue:discover", "/issue:discover-by-prompt", "/issue:plan", "/issue:queue", "/issue:execute", "/issue:manage"],
+      "agents": ["issue-plan-agent", "issue-queue-agent", "cli-explore-agent"],
+      "lifecycle": {
+        "accumulation": {
+          "description": "任务完成后进行需求扩展、bug分析、测试发现",
+          "triggers": ["post-task review", "code review findings", "test failures"],
+          "commands": ["/issue:discover", "/issue:discover-by-prompt", "/issue:new"]
+        },
+        "batch_resolution": {
+          "description": "积累的issue集中规划和并行执行",
+          "flow": ["plan", "queue", "execute"],
+          "commands": ["/issue:plan --all-pending", "/issue:queue", "/issue:execute"]
+        }
+      }
+    },
+    "ui-design": {
+      "description": "UI design and prototyping",
+      "commands": ["/workflow:ui-design:explore-auto", "/workflow:ui-design:imitate-auto", "/workflow:ui-design:design-sync"],
+      "agents": ["ui-design-agent"]
+    },
+    "memory": {
+      "description": "Documentation and knowledge management",
+      "commands": ["/memory:docs", "/memory:update-related", "/memory:update-full", "/memory:skill-memory"],
+      "agents": ["doc-generator", "memory-bridge"]
+    }
+  },
+
+  "flows": {
+    "_level_guide": {
+      "L1": "Rapid - No artifacts, direct execution",
+      "L2": "Lightweight - Memory/lightweight files, → lite-execute",
+      "L3": "Standard - Session persistence, → execute/test-cycle-execute",
+      "L4": "Brainstorm - Multi-role analysis + Session, → execute"
+    },
+    "lite-lite-lite": {
+      "name": "Ultra-Rapid Execution",
+      "level": "L1",
+      "description": "零文件 + 自动CLI选择 + 语义描述 + 直接执行",
+      "complexity": ["low"],
+      "artifacts": "none",
+      "steps": [
+        { "phase": "clarify", "description": "需求澄清 (AskUser if needed)" },
+        { "phase": "auto-select", "description": "任务分析 → 自动选择CLI组合" },
+        { "phase": "multi-cli", "description": "并行多CLI分析" },
+        { "phase": "decision", "description": "展示结果 → AskUser决策" },
+        { "phase": "execute", "description": "直接执行 (无中间文件)" }
+      ],
+      "cli_hints": {
+        "analysis": { "tool": "auto", "mode": "analysis", "parallel": true },
+        "execution": { "tool": "auto", "mode": "write" }
+      },
+      "estimated_time": "10-30 min"
+    },
+    "rapid": {
+      "name": "Rapid Iteration",
+      "level": "L2",
+      "description": "内存规划 + 直接执行",
+      "complexity": ["low", "medium"],
+      "artifacts": "memory://plan",
+      "steps": [
+        { "command": "/workflow:lite-plan", "optional": false, "auto_continue": true },
+        { "command": "/workflow:lite-execute", "optional": false }
+      ],
+      "cli_hints": {
+        "explore_phase": { "tool": "gemini", "mode": "analysis", "trigger": "needs_exploration" },
+        "execution": { "tool": "codex", "mode": "write", "trigger": "complexity >= medium" }
+      },
+      "estimated_time": "15-45 min"
+    },
+    "multi-cli-plan": {
+      "name": "Multi-CLI Collaborative Planning",
+      "level": "L2",
+      "description": "ACE上下文 + 多CLI协作分析 + 迭代收敛 + 计划生成",
+      "complexity": ["medium", "high"],
+      "artifacts": ".workflow/.multi-cli-plan/{session}/",
+      "steps": [
+        { "command": "/workflow:multi-cli-plan", "optional": false, "phases": [
+          "context_gathering: ACE语义搜索",
+          "multi_cli_discussion: cli-discuss-agent多轮分析",
+          "present_options: 展示解决方案",
+          "user_decision: 用户选择",
+          "plan_generation: cli-lite-planning-agent生成计划"
+        ]},
+        { "command": "/workflow:lite-execute", "optional": false }
+      ],
+      "vs_lite_plan": {
+        "context": "ACE semantic search vs Manual file patterns",
+        "analysis": "Multi-CLI cross-verification vs Single-pass planning",
+        "iteration": "Multiple rounds until convergence vs Single round",
+        "confidence": "High (consensus-based) vs Medium (single perspective)",
+        "best_for": "Complex tasks needing multiple perspectives vs Straightforward implementations"
+      },
+      "agents": ["cli-discuss-agent", "cli-lite-planning-agent"],
+      "cli_hints": {
+        "discussion": { "tools": ["gemini", "codex", "claude"], "mode": "analysis", "parallel": true },
+        "planning": { "tool": "gemini", "mode": "analysis" }
+      },
+      "estimated_time": "30-90 min"
+    },
+    "coupled": {
+      "name": "Standard Planning",
+      "level": "L3",
+      "description": "完整规划 + 验证 + 执行",
+      "complexity": ["medium", "high"],
+      "artifacts": ".workflow/active/{session}/",
+      "steps": [
+        { "command": "/workflow:plan", "optional": false },
+        { "command": "/workflow:action-plan-verify", "optional": false, "auto_continue": true },
+        { "command": "/workflow:execute", "optional": false },
+        { "command": "/workflow:review", "optional": true }
+      ],
+      "cli_hints": {
+        "pre_analysis": { "tool": "gemini", "mode": "analysis", "trigger": "always" },
+        "execution": { "tool": "codex", "mode": "write", "trigger": "always" }
+      },
+      "estimated_time": "2-4 hours"
+    },
+    "full": {
+      "name": "Full Exploration (Brainstorm)",
+      "level": "L4",
+      "description": "头脑风暴 + 规划 + 执行",
+      "complexity": ["high"],
+      "artifacts": ".workflow/active/{session}/.brainstorming/",
+      "steps": [
+        { "command": "/workflow:brainstorm:auto-parallel", "optional": false, "confirm_before": true },
+        { "command": "/workflow:plan", "optional": false },
+        { "command": "/workflow:action-plan-verify", "optional": true, "auto_continue": true },
+        { "command": "/workflow:execute", "optional": false }
+      ],
+      "cli_hints": {
+        "role_analysis": { "tool": "gemini", "mode": "analysis", "trigger": "always", "parallel": true },
+        "execution": { "tool": "codex", "mode": "write", "trigger": "task_count >= 3" }
+      },
+      "estimated_time": "1-3 hours"
+    },
+    "bugfix": {
+      "name": "Bug Fix",
+      "level": "L2",
+      "description": "智能诊断 + 修复 (5 phases)",
+      "complexity": ["low", "medium"],
+      "artifacts": ".workflow/.lite-fix/{bug-slug}-{date}/",
+      "variants": {
+        "standard": [{ "command": "/workflow:lite-fix", "optional": false }],
+        "hotfix": [{ "command": "/workflow:lite-fix --hotfix", "optional": false }]
+      },
+      "phases": [
+        "Phase 1: Bug Analysis & Diagnosis (severity pre-assessment)",
+        "Phase 2: Clarification (optional, AskUserQuestion)",
+        "Phase 3: Fix Planning (Low/Medium → Claude, High/Critical → cli-lite-planning-agent)",
+        "Phase 4: Confirmation & Selection",
+        "Phase 5: Execute (→ lite-execute --mode bugfix)"
+      ],
+      "cli_hints": {
+        "diagnosis": { "tool": "gemini", "mode": "analysis", "trigger": "always" },
+        "fix": { "tool": "codex", "mode": "write", "trigger": "severity >= medium" }
+      },
+      "estimated_time": "10-30 min"
+    },
+    "issue": {
+      "name": "Issue Lifecycle",
+      "level": "Supplementary",
+      "description": "发现积累 → 批量规划 → 队列优化 → 并行执行 (Main Workflow 补充机制)",
+      "complexity": ["medium", "high"],
+      "artifacts": ".workflow/.issues/",
+      "purpose": "Post-development continuous maintenance, maintain main branch stability",
+      "phases": {
+        "accumulation": {
+          "description": "项目迭代中持续发现和积累issue",
+          "commands": ["/issue:discover", "/issue:discover-by-prompt", "/issue:new"],
+          "trigger": "post-task, code-review, test-failure"
+        },
+        "resolution": {
+          "description": "集中规划和执行积累的issue",
+          "steps": [
+            { "command": "/issue:plan --all-pending", "optional": false },
+            { "command": "/issue:queue", "optional": false },
+            { "command": "/issue:execute", "optional": false }
+          ]
+        }
+      },
+      "worktree_support": {
+        "description": "可选的 worktree 隔离，保持主分支稳定",
+        "use_case": "主开发完成后的 issue 修复"
+      },
+      "cli_hints": {
+        "discovery": { "tool": "gemini", "mode": "analysis", "trigger": "perspective_analysis", "parallel": true },
+        "solution_generation": { "tool": "gemini", "mode": "analysis", "trigger": "always", "parallel": true },
+        "batch_execution": { "tool": "codex", "mode": "write", "trigger": "always" }
+      },
+      "estimated_time": "1-4 hours"
+    },
+    "tdd": {
+      "name": "Test-Driven Development",
+      "level": "L3",
+      "description": "TDD规划 + 执行 + 验证 (6 phases)",
+      "complexity": ["medium", "high"],
+      "artifacts": ".workflow/active/{session}/",
+      "steps": [
+        { "command": "/workflow:tdd-plan", "optional": false },
+        { "command": "/workflow:action-plan-verify", "optional": true, "auto_continue": true },
+        { "command": "/workflow:execute", "optional": false },
+        { "command": "/workflow:tdd-verify", "optional": false }
+      ],
+      "tdd_structure": {
+        "description": "Each IMPL task contains complete internal Red-Green-Refactor cycle",
+        "meta": "tdd_workflow: true",
+        "flow_control": "implementation_approach contains 3 steps (red/green/refactor)"
+      },
+      "cli_hints": {
+        "test_strategy": { "tool": "gemini", "mode": "analysis", "trigger": "always" },
+        "red_green_refactor": { "tool": "codex", "mode": "write", "trigger": "always" }
+      },
+      "estimated_time": "1-3 hours"
+    },
+    "test-fix": {
+      "name": "Test Fix Generation",
+      "level": "L3",
+      "description": "测试修复生成 + 执行循环 (5 phases)",
+      "complexity": ["medium", "high"],
+      "artifacts": ".workflow/active/WFS-test-{session}/",
+      "dual_mode": {
+        "session_mode": { "input": "WFS-xxx", "context_source": "Source session summaries" },
+        "prompt_mode": { "input": "Text/file path", "context_source": "Direct codebase analysis" }
+      },
+      "steps": [
+        { "command": "/workflow:test-fix-gen", "optional": false },
+        { "command": "/workflow:test-cycle-execute", "optional": false }
+      ],
+      "task_structure": [
+        "IMPL-001.json (test understanding & generation)",
+        "IMPL-001.5-review.json (quality gate)",
+        "IMPL-002.json (test execution & fix cycle)"
+      ],
+      "cli_hints": {
+        "analysis": { "tool": "gemini", "mode": "analysis", "trigger": "always" },
+        "fix_cycle": { "tool": "codex", "mode": "write", "trigger": "pass_rate < 0.95" }
+      },
+      "estimated_time": "1-2 hours"
+    },
+    "ui": {
+      "name": "UI-First Development",
+      "level": "L3/L4",
+      "description": "UI设计 + 规划 + 执行",
+      "complexity": ["medium", "high"],
+      "artifacts": ".workflow/active/{session}/",
+      "variants": {
+        "explore": [
+          { "command": "/workflow:ui-design:explore-auto", "optional": false },
+          { "command": "/workflow:ui-design:design-sync", "optional": false, "auto_continue": true },
+          { "command": "/workflow:plan", "optional": false },
+          { "command": "/workflow:execute", "optional": false }
+        ],
+        "imitate": [
+          { "command": "/workflow:ui-design:imitate-auto", "optional": false },
+          { "command": "/workflow:ui-design:design-sync", "optional": false, "auto_continue": true },
+          { "command": "/workflow:plan", "optional": false },
+          { "command": "/workflow:execute", "optional": false }
+        ]
+      },
+      "estimated_time": "2-4 hours"
+    },
+    "review-fix": {
+      "name": "Review and Fix",
+      "level": "L3",
+      "description": "多维审查 + 自动修复",
+      "complexity": ["medium"],
+      "artifacts": ".workflow/active/{session}/review_report.md",
+      "steps": [
+        { "command": "/workflow:review-session-cycle", "optional": false },
+        { "command": "/workflow:review-fix", "optional": true }
+      ],
+      "cli_hints": {
+        "multi_dimension_review": { "tool": "gemini", "mode": "analysis", "trigger": "always", "parallel": true },
+        "auto_fix": { "tool": "codex", "mode": "write", "trigger": "findings_count >= 3" }
+      },
+      "estimated_time": "30-90 min"
+    },
+    "docs": {
+      "name": "Documentation",
+      "level": "L2",
+      "description": "批量文档生成",
+      "complexity": ["low", "medium"],
+      "variants": {
+        "incremental": [{ "command": "/memory:update-related", "optional": false }],
+        "full": [
+          { "command": "/memory:docs", "optional": false },
+          { "command": "/workflow:execute", "optional": false }
+        ]
+      },
+      "estimated_time": "15-60 min"
+    }
+  },
+
+  "intent_rules": {
+    "_level_mapping": {
+      "description": "Intent → Level → Flow mapping guide",
+      "L1": ["lite-lite-lite"],
+      "L2": ["rapid", "bugfix", "multi-cli-plan", "docs"],
+      "L3": ["coupled", "tdd", "test-fix", "review-fix", "ui"],
+      "L4": ["full"],
+      "Supplementary": ["issue"]
+    },
+    "bugfix": {
+      "priority": 1,
+      "level": "L2",
+      "variants": {
+        "hotfix": {
+          "patterns": ["hotfix", "urgent", "production", "critical", "emergency", "紧急", "生产环境", "线上"],
+          "flow": "bugfix.hotfix"
+        },
+        "standard": {
+          "patterns": ["fix", "bug", "error", "issue", "crash", "broken", "fail", "wrong", "修复", "错误", "崩溃"],
+          "flow": "bugfix.standard"
+        }
+      }
+    },
+    "issue_batch": {
+      "priority": 2,
+      "level": "Supplementary",
+      "patterns": {
+        "batch": ["issues", "batch", "queue", "多个", "批量"],
+        "action": ["fix", "resolve", "处理", "解决"]
+      },
+      "require_both": true,
+      "flow": "issue"
+    },
+    "exploration": {
+      "priority": 3,
+      "level": "L4",
+      "patterns": ["不确定", "不知道", "explore", "研究", "分析一下", "怎么做", "what if", "探索"],
+      "flow": "full"
+    },
+    "multi_perspective": {
+      "priority": 3,
+      "level": "L2",
+      "patterns": ["多视角", "权衡", "比较方案", "cross-verify", "多CLI", "协作分析"],
+      "flow": "multi-cli-plan"
+    },
+    "quick_task": {
+      "priority": 4,
+      "level": "L1",
+      "patterns": ["快速", "简单", "small", "quick", "simple", "trivial", "小改动"],
+      "flow": "lite-lite-lite"
+    },
+    "ui_design": {
+      "priority": 5,
+      "level": "L3/L4",
+      "patterns": ["ui", "界面", "design", "设计", "component", "组件", "style", "样式", "layout", "布局"],
+      "variants": {
+        "imitate": { "triggers": ["参考", "模仿", "像", "类似"], "flow": "ui.imitate" },
+        "explore": { "triggers": [], "flow": "ui.explore" }
+      }
+    },
+    "tdd": {
+      "priority": 6,
+      "level": "L3",
+      "patterns": ["tdd", "test-driven", "测试驱动", "先写测试", "test first"],
+      "flow": "tdd"
+    },
+    "test_fix": {
+      "priority": 7,
+      "level": "L3",
+      "patterns": ["测试失败", "test fail", "fix test", "test error", "pass rate", "coverage gap"],
+      "flow": "test-fix"
+    },
+    "review": {
+      "priority": 8,
+      "level": "L3",
+      "patterns": ["review", "审查", "检查代码", "code review", "质量检查"],
+      "flow": "review-fix"
+    },
+    "documentation": {
+      "priority": 9,
+      "level": "L2",
+      "patterns": ["文档", "documentation", "docs", "readme"],
+      "variants": {
+        "incremental": { "triggers": ["更新", "增量"], "flow": "docs.incremental" },
+        "full": { "triggers": ["全部", "完整"], "flow": "docs.full" }
+      }
+    },
+    "feature": {
+      "priority": 99,
+      "complexity_map": {
+        "high": { "level": "L3", "flow": "coupled" },
+        "medium": { "level": "L2", "flow": "rapid" },
+        "low": { "level": "L1", "flow": "lite-lite-lite" }
+      }
+    }
+  },
+
+  "complexity_indicators": {
+    "high": {
+      "threshold": 4,
+      "patterns": {
+        "architecture": { "keywords": ["refactor", "重构", "migrate", "迁移", "architect", "架构", "system", "系统"], "weight": 2 },
+        "multi_module": { "keywords": ["multiple", "多个", "across", "跨", "all", "所有", "entire", "整个"], "weight": 2 },
+        "integration": { "keywords": ["integrate", "集成", "api", "database", "数据库"], "weight": 1 },
+        "quality": { "keywords": ["security", "安全", "performance", "性能", "scale", "扩展"], "weight": 1 }
+      }
+    },
+    "medium": { "threshold": 2 },
+    "low": { "threshold": 0 }
+  },
+
+  "cli_tools": {
+    "gemini": {
+      "strengths": ["超长上下文", "深度分析", "架构理解", "执行流追踪"],
+      "triggers": ["分析", "理解", "设计", "架构", "诊断"],
+      "mode": "analysis"
+    },
+    "qwen": {
+      "strengths": ["代码模式识别", "多维度分析"],
+      "triggers": ["评估", "对比", "验证"],
+      "mode": "analysis"
+    },
+    "codex": {
+      "strengths": ["精确代码生成", "自主执行"],
+      "triggers": ["实现", "重构", "修复", "生成"],
+      "mode": "write"
+    }
+  },
+
+  "cli_injection_rules": {
+    "context_gathering": { "trigger": "file_read >= 50k OR module_count >= 5", "inject": "gemini --mode analysis" },
+    "pre_planning_analysis": { "trigger": "complexity === high", "inject": "gemini --mode analysis" },
+    "debug_diagnosis": { "trigger": "intent === bugfix AND root_cause_unclear", "inject": "gemini --mode analysis" },
+    "code_review": { "trigger": "step === review", "inject": "gemini --mode analysis" },
+    "implementation": { "trigger": "step === execute AND task_count >= 3", "inject": "codex --mode write" }
+  },
+
+  "artifact_flow": {
+    "_description": "定义工作流产出的格式、意图提取和流转规则",
+
+    "outputs": {
+      "/workflow:lite-plan": {
+        "artifact": "memory://plan",
+        "format": "structured_plan",
+        "fields": ["tasks", "files", "dependencies", "approach"]
+      },
+      "/workflow:plan": {
+        "artifact": ".workflow/{session}/IMPL_PLAN.md",
+        "format": "markdown_plan",
+        "fields": ["phases", "tasks", "dependencies", "risks", "test_strategy"]
+      },
+      "/workflow:multi-cli-plan": {
+        "artifact": ".workflow/.multi-cli-plan/{session}/",
+        "format": "multi_file",
+        "files": ["IMPL_PLAN.md", "plan.json", "synthesis.json"],
+        "fields": ["consensus", "divergences", "recommended_approach", "tasks"]
+      },
+      "/workflow:lite-execute": {
+        "artifact": "git_changes",
+        "format": "code_diff",
+        "fields": ["modified_files", "added_files", "deleted_files", "build_status"]
+      },
+      "/workflow:execute": {
+        "artifact": ".workflow/{session}/execution_log.json",
+        "format": "execution_report",
+        "fields": ["completed_tasks", "pending_tasks", "errors", "warnings"]
+      },
+      "/workflow:test-cycle-execute": {
+        "artifact": ".workflow/{session}/test_results.json",
+        "format": "test_report",
+        "fields": ["pass_rate", "failures", "coverage", "duration"]
+      },
+      "/workflow:review-session-cycle": {
+        "artifact": ".workflow/{session}/review_report.md",
+        "format": "review_report",
+        "fields": ["findings", "severity_counts", "recommendations"]
+      },
+      "/workflow:lite-fix": {
+        "artifact": "git_changes",
+        "format": "fix_report",
+        "fields": ["root_cause", "fix_applied", "files_modified", "verification_status"]
+      }
+    },
+
+    "intent_extraction": {
+      "plan_to_execute": {
+        "from": ["lite-plan", "plan", "multi-cli-plan"],
+        "to": ["lite-execute", "execute"],
+        "extract": {
+          "tasks": "$.tasks[] | filter(status != 'completed')",
+          "priority_order": "$.tasks | sort_by(priority)",
+          "files_to_modify": "$.tasks[].files | flatten | unique",
+          "dependencies": "$.dependencies",
+          "context_summary": "$.approach OR $.recommended_approach"
+        }
+      },
+      "execute_to_test": {
+        "from": ["lite-execute", "execute"],
+        "to": ["test-cycle-execute", "test-fix-gen"],
+        "extract": {
+          "modified_files": "$.modified_files",
+          "test_scope": "infer_from($.modified_files)",
+          "build_status": "$.build_status",
+          "pending_verification": "$.completed_tasks | needs_test"
+        }
+      },
+      "test_to_fix": {
+        "from": ["test-cycle-execute"],
+        "to": ["lite-fix", "review-fix"],
+        "condition": "$.pass_rate < 0.95",
+        "extract": {
+          "failures": "$.failures",
+          "error_messages": "$.failures[].message",
+          "affected_files": "$.failures[].file",
+          "suggested_fixes": "$.failures[].suggested_fix"
+        }
+      },
+      "review_to_fix": {
+        "from": ["review-session-cycle", "review-module-cycle"],
+        "to": ["review-fix"],
+        "condition": "$.severity_counts.critical > 0 OR $.severity_counts.high > 3",
+        "extract": {
+          "findings": "$.findings | filter(severity in ['critical', 'high'])",
+          "fix_priority": "$.findings | group_by(category) | sort_by(severity)",
+          "affected_files": "$.findings[].file | unique"
+        }
+      }
+    },
+
+    "completion_criteria": {
+      "plan": {
+        "required": ["has_tasks", "has_files"],
+        "optional": ["has_tests", "no_blocking_risks"],
+        "threshold": 0.8,
+        "routing": {
+          "complete": "proceed_to_execute",
+          "incomplete": "clarify_requirements"
+        }
+      },
+      "execute": {
+        "required": ["all_tasks_attempted", "no_critical_errors"],
+        "optional": ["build_passes", "lint_passes"],
+        "threshold": 1.0,
+        "routing": {
+          "complete": "proceed_to_test_or_review",
+          "partial": "continue_execution",
+          "failed": "diagnose_and_retry"
+        }
+      },
+      "test": {
+        "metrics": {
+          "pass_rate": { "target": 0.95, "minimum": 0.80 },
+          "coverage": { "target": 0.80, "minimum": 0.60 }
+        },
+        "routing": {
+          "pass_rate >= 0.95 AND coverage >= 0.80": "complete",
+          "pass_rate >= 0.95 AND coverage < 0.80": "add_more_tests",
+          "pass_rate >= 0.80": "fix_failures_then_continue",
+          "pass_rate < 0.80": "major_fix_required"
+        }
+      },
+      "review": {
+        "metrics": {
+          "critical_findings": { "target": 0, "maximum": 0 },
+          "high_findings": { "target": 0, "maximum": 3 }
+        },
+        "routing": {
+          "critical == 0 AND high <= 3": "complete_or_optional_fix",
+          "critical > 0": "mandatory_fix",
+          "high > 3": "recommended_fix"
+        }
+      }
+    },
+
+    "flow_decisions": {
+      "_description": "根据产出完成度决定下一步",
+      "patterns": {
+        "plan_execute_test": {
+          "sequence": ["plan", "execute", "test"],
+          "on_test_fail": {
+            "action": "extract_failures_and_fix",
+            "max_iterations": 3,
+            "fallback": "manual_intervention"
+          }
+        },
+        "plan_execute_review": {
+          "sequence": ["plan", "execute", "review"],
+          "on_review_issues": {
+            "action": "prioritize_and_fix",
+            "auto_fix_threshold": "severity < high"
+          }
+        },
+        "iterative_improvement": {
+          "sequence": ["execute", "test", "fix"],
+          "loop_until": "pass_rate >= 0.95 OR iterations >= 3",
+          "on_loop_exit": "report_status"
+        }
+      }
+    }
+  }
+}

.claude/skills/command-guide/SKILL.md

@@ -1,388 +0,0 @@
----
-name: command-guide
-description: Workflow command guide for Claude Code Workflow (78 commands). Search/browse commands, get next-step recommendations, view documentation, report issues. Triggers "CCW-help", "CCW-issue", "ccw-help", "ccw-issue", "ccw"
-allowed-tools: Read, Grep, Glob, AskUserQuestion
-version: 5.8.0
----
-
-# Command Guide Skill
-
-Comprehensive command guide for Claude Code Workflow (CCW) system covering 78 commands across 5 categories (workflow, cli, memory, task, general).
-
-## 🆕 What's New in v5.8.0
-
-### Major Features
-
-**🎨 UI Design Style Memory Workflow** (Primary Focus)
-- **`/memory:style-skill-memory`** - Generate reusable SKILL packages from design systems
-- **`/workflow:ui-design:codify-style`** - Extract design tokens from code with automatic file discovery
-- **`/workflow:ui-design:reference-page-generator`** - Generate multi-component reference pages
-- **Workflow**: Design extraction → Token documentation → SKILL package → Easy loading
-
-**⚡ `/workflow:lite-plan`** - Intelligent Planning & Execution (Testing Phase)
-- Dynamic workflow adaptation (smart exploration, adaptive planning, progressive clarification)
-- Two-dimensional confirmation (task approval + execution method selection)
-- Direct execution with live TodoWrite progress tracking
-- Faster than `/workflow:plan` (1-3 min vs 5-10 min) for simple to medium tasks
-
-**🗺️ `/memory:code-map-memory`** - Code Flow Mapping Generator (Testing Phase)
-- Uses cli-explore-agent for deep code flow analysis with dual-source strategy
-- Generates Mermaid diagrams for architecture, functions, data flow, conditional paths
-- Creates feature-specific SKILL packages for code understanding
-- Progressive loading (2K → 30K tokens) for efficient context management
-
-### Agent 
-
-- **cli-explore-agent**  - Specialized code exploration with Deep Scan mode (Bash + Gemini)
-- **cli-planning-agent** - Enhanced task generation with improved context handling
-- **ui-design-agent** - Major refactoring for better design system extraction
-
-### Additional Improvements
-- Enhanced brainstorming workflows with parallel execution
-- Improved test workflow documentation and task attachment models
-- Updated CLI tool default models (Gemini 2.5-pro)
-
-## 🧠 Core Principle: Intelligent Integration
-
-**⚠️ IMPORTANT**: This SKILL provides **reference materials** for intelligent integration, NOT templates for direct copying.
-
-**Response Strategy**:
-1. **Analyze user's specific context** - Understand their exact need, workflow stage, and technical level
-2. **Extract relevant information** - Select only the pertinent parts from reference guides
-3. **Synthesize and customize** - Combine multiple sources, add context-specific examples
-4. **Deliver targeted response** - Provide concise, actionable guidance tailored to the user's situation
-
-**Never**:
-- ❌ Copy-paste entire template sections verbatim
-- ❌ Return raw reference documentation without processing
-- ❌ Provide generic responses that ignore user context
-
-**Always**:
-- ✅ Understand the user's specific situation first
-- ✅ Integrate information from multiple sources (indexes, guides, reference docs)
-- ✅ Customize examples and explanations to match user's use case
-- ✅ Provide progressive depth - brief answers with "more detail available" prompts
-
----
-
-## 🎯 Operation Modes
-
-### Mode 1: Command Search 🔍
-
-**When**: User searches by keyword, category, or use-case
-
-**Triggers**: "搜索命令", "find command", "planning 相关", "search"
-
-**Process**:
-1. Identify search type (keyword/category/use-case)
-2. Query appropriate index (all-commands/by-category/by-use-case)
-3. **Intelligently filter and rank** results based on user's implied context
-4. **Synthesize concise response** with command names, brief descriptions, and use-case fit
-5. **Suggest next steps** - related commands or workflow patterns
-
-**Example**: "搜索 planning 命令" → Analyze user's likely goal → Present top 3-5 most relevant planning commands with context-specific usage hints, NOT raw JSON dump
-
----
-
-### Mode 2: Smart Recommendations 🤖
-
-**When**: User asks for next steps after a command
-
-**Triggers**: "下一步", "what's next", "after /workflow:plan", "推荐"
-
-**Process**:
-1. **Analyze workflow context** - Understand where user is in their development cycle
-2. Query `index/command-relationships.json` for possible next commands
-3. **Evaluate and prioritize** recommendations based on:
-   - User's stated goals
-   - Common workflow patterns
-   - Project complexity indicators
-4. **Craft contextual guidance** - Explain WHY each recommendation fits, not just WHAT to run
-5. **Provide workflow examples** - Show complete flow, not isolated commands
-
-**Example**: "执行完 /workflow:plan 后做什么？" → Analyze plan output quality → Recommend `/workflow:action-plan-verify` (if complex) OR `/workflow:execute` (if straightforward) with reasoning for each choice
-
----
-
-### Mode 3: Full Documentation 📖
-
-**When**: User requests command details
-
-**Triggers**: "参数说明", "怎么用", "how to use", "详情"
-
-**Process**:
-1. Locate command in `index/all-commands.json`
-2. Read original command file for full details
-3. **Extract user-relevant sections** - Focus on what they asked about (parameters OR examples OR workflow)
-4. **Enhance with context** - Add use-case specific examples if user's scenario is clear
-5. **Progressive disclosure** - Provide core info first, offer "need more details?" prompts
-
-**Example**: "/workflow:plan 的参数是什么？" → Identify user's experience level → Present parameters with context-appropriate explanations (beginner: verbose + examples; advanced: concise + edge cases), NOT raw documentation dump
-
----
-
-### Mode 4: Beginner Onboarding 🎓
-
-**When**: New user needs guidance
-
-**Triggers**: "新手", "getting started", "如何开始", "常用命令", **"从0到1"**, **"全新项目"**
-
-**Process**:
-1. **Assess user background** - Ask clarifying questions if needed (coding experience? project type?)
-2. **⚠️ Identify project stage** - FROM-ZERO-TO-ONE vs FEATURE-ADDITION:
-   - **从0到1场景** (全新项目/产品/架构决策) → **MUST START with brainstorming workflow**
-   - **功能新增场景** (已有项目中添加功能) → Start with planning workflow
-3. **Design personalized learning path** based on their goals and stage
-4. **Curate essential commands** from `index/essential-commands.json` - Select 3-5 most relevant for their use case
-5. **Provide guided first example** - Walk through ONE complete workflow with explanation, **emphasizing brainstorming for 0-to-1 scenarios**
-6. **Set clear next steps** - What to try next, where to get help
-
-**Example 1 (从0到1)**: "我是新手，如何开始全新项目？" → Identify as FROM-ZERO-TO-ONE → Emphasize brainstorming workflow (`/workflow:brainstorm:artifacts`) as mandatory first step → Explain brainstorm → plan → execute flow
-
-**Example 2 (功能新增)**: "我是新手，如何在已有项目中添加功能？" → Identify as FEATURE-ADDITION → Guide to planning workflow (`/workflow:plan`) → Explain plan → execute → test flow
-
-**Example 3 (探索)**: "我是新手，如何开始？" → Ask clarifying question: "是全新项目启动（从0到1）还是在已有项目中添加功能？" → Based on answer, route to appropriate workflow
-
----
-
-### Mode 5: Issue Reporting 📝
-
-**When**: User wants to report issue or request feature
-
-**Triggers**: **"CCW-issue"**, **"CCW-help"**, **"ccw-issue"**, **"ccw-help"**, **"ccw"**, "报告 bug", "功能建议", "问题咨询", "交互式诊断"
-
-**Process**:
-1. **Understand issue context** - Use AskUserQuestion to confirm type AND gather initial context
-2. **Intelligently guide information collection**:
-   - Adapt questions based on previous answers
-   - Skip irrelevant sections
-   - Probe for missing critical details
-3. **Select and customize template**:
-   - `issue-diagnosis.md`, `issue-bug.md`, `issue-feature.md`, or `issue-question.md`
-   - **Adapt template sections** to match user's specific scenario
-4. **Synthesize coherent issue report**:
-   - Integrate collected information with appropriate template sections
-   - **Highlight key details** - Don't bury critical info in boilerplate
-   - Add privacy-protected command history
-5. **Provide actionable next steps** - Immediate troubleshooting OR submission guidance
-
-**Example**: "CCW-issue" → Detect user frustration level → For urgent: fast-track to critical info collection; For exploratory: comprehensive diagnostic flow, NOT one-size-fits-all questionnaire
-
-**🆕 Enhanced Features**:
-- Complete command history with privacy protection
-- Interactive diagnostic checklists
-- Decision tree navigation (diagnosis template)
-- Execution environment capture
-
----
-
-### Mode 6: Deep Command Analysis 🔬
-
-**When**: User asks detailed questions about specific commands or agents
-
-**Triggers**: "详细说明", "命令原理", "agent 如何工作", "实现细节", specific command/agent name mentioned
-
-**Data Sources**:
-- `reference/agents/*.md` - All agent documentation (11 agents)
-- `reference/commands/**/*.md` - All command documentation (69 commands)
-
-**Process**:
-
-**Simple Query** (direct documentation lookup):
-1. Identify target command/agent from user query
-2. Locate corresponding markdown file in `reference/`
-3. **Extract contextually relevant sections** - Not entire document
-4. **Synthesize focused explanation**:
-   - Address user's specific question
-   - Add context-appropriate examples
-   - Link related concepts
-5. **Offer progressive depth** - "Want to know more about X?"
-
-**Complex Query** (CLI-assisted analysis):
-1. **Detect complexity indicators** (多个命令对比、工作流程分析、最佳实践)
-2. **Design targeted analysis prompt** for gemini/qwen via CCW:
-   - Frame user's question precisely
-   - Specify required analysis depth
-   - Request structured comparison/synthesis
-   ```bash
-   ccw cli -p "
-   PURPOSE: Analyze command documentation to answer user query
-   TASK: • [extracted user question with context]
-   MODE: analysis
-   CONTEXT: @**/*
-   EXPECTED: Comprehensive answer with examples and recommendations
-   RULES: $(cat ~/.claude/workflows/cli-templates/prompts/analysis/02-analyze-code-patterns.txt) | Focus on practical usage | analysis=READ-ONLY
-   " --tool gemini --cd ~/.claude/skills/command-guide/reference
-   ```
-   Note: Use `--cd` with absolute path `~/.claude/skills/command-guide/reference` for reference documentation access
-3. **Process and integrate CLI analysis**:
-   - Extract key insights from CLI output
-   - Add context-specific examples
-   - Synthesize actionable recommendations
-4. **Deliver tailored response** - Not raw CLI output
-
-**Query Classification**:
-- **Simple**: Single command explanation, parameter list, basic usage
-- **Complex**: Cross-command workflows, performance comparison, architectural analysis, best practices across multiple commands
-
-**Examples**:
-
-*Simple Query*:
-```
-User: "action-planning-agent 如何工作？"
-→ Read reference/agents/action-planning-agent.md
-→ **Identify user's knowledge gap** (mechanism? inputs/outputs? when to use?)
-→ **Extract relevant sections** addressing their need
-→ **Synthesize focused explanation** with examples
-→ NOT: Dump entire agent documentation
-```
-
-*Complex Query*:
-```
-User: "对比 workflow:plan 和 workflow:tdd-plan 的使用场景和最佳实践"
-→ Detect: 多命令对比 + 最佳实践
-→ **Design comparison framework** (when to use, trade-offs, workflow integration)
-→ Use gemini to analyze both commands with structured comparison prompt
-→ **Synthesize insights** into decision matrix and usage guidelines
-→ NOT: Raw command documentation side-by-side
-```
-
----
-
-## 📚 Index Files
-
-All command metadata is stored in JSON indexes for fast querying:
-
-- **all-commands.json** - Complete catalog (69 commands) with full metadata
-- **by-category.json** - Hierarchical organization (workflow/cli/memory/task)
-- **by-use-case.json** - Grouped by scenario (planning/implementation/testing/docs/session)
-- **essential-commands.json** - Top 14 most-used commands
-- **command-relationships.json** - Next-step recommendations and dependencies
-
-📖 Detailed structure: [Index Structure Reference](guides/index-structure.md)
-
----
-
-## 🗂️ Supporting Guides
-
-- **[Getting Started](guides/getting-started.md)** - 5-minute quickstart for beginners
-- **[Workflow Patterns](guides/workflow-patterns.md)** - Common workflow examples (Plan→Execute, TDD, UI design)
-- **[CLI Tools Guide](guides/cli-tools-guide.md)** - Gemini/Qwen/Codex usage
-- **[Troubleshooting](guides/troubleshooting.md)** - Common issues and solutions
-- **[Implementation Details](guides/implementation-details.md)** - Detailed logic for each mode
-- **[Usage Examples](guides/examples.md)** - Example dialogues and edge cases
-
-## 📦 Reference Documentation
-
-Complete backup of all command and agent documentation for deep analysis:
-
-- **[reference/agents/](reference/agents/)** - 14 agent markdown files with implementation details
-  - **New in v5.8**: cli-explore-agent (code exploration), cli-planning-agent (enhanced)
-- **[reference/commands/](reference/commands/)** - 78 command markdown files organized by category
-  - `cli/` - CLI tool commands (10 files) - **New**: document-analysis mode
-  - `memory/` - Memory management commands (12 files) - **New**: docs-full-cli, docs-related-cli, code-map-memory, style-skill-memory
-  - `task/` - Task management commands (4 files)
-  - `workflow/` - Workflow commands (50 files) - **New**: lite-plan, lite-fix, ui-design enhancements
-
-**Installation Path**: `~/.claude/skills/command-guide/` (skill designed for global installation)
-
-**Absolute Reference Path**: `~/.claude/skills/command-guide/reference/`
-
-**Usage**: Mode 6 queries these files directly for detailed command/agent analysis, or uses CLI tools (gemini/qwen) with absolute paths for complex cross-command analysis.
-
----
-
-## 🛠️ Issue Templates
-
-Generate standardized GitHub issue templates with **execution flow emphasis**:
-
-- **[Interactive Diagnosis](templates/issue-diagnosis.md)** - 🆕 Comprehensive diagnostic workflow with decision tree, checklists, and full command history
-- **[Bug Report](templates/issue-bug.md)** - Report command errors with complete execution flow and environment details
-- **[Feature Request](templates/issue-feature.md)** - Suggest improvements with current workflow analysis and pain points
-- **[Question](templates/issue-question.md)** - Ask usage questions with detailed attempt history and context
-
-**All templates now include**:
-- ✅ Complete command history sections (with privacy protection)
-- ✅ Execution environment details
-- ✅ Interactive problem-locating checklists
-- ✅ Structured troubleshooting guidance
-
-Templates are auto-populated during Mode 5 (Issue Reporting) interaction.
-
----
-
-## 📊 System Statistics
-
-- **Total Commands**: 78
-- **Total Agents**: 14
-- **Categories**: 5 (workflow: 50, cli: 10, memory: 12, task: 4, general: 2)
-- **Use Cases**: 7 (planning, implementation, testing, documentation, session-management, analysis, general)
-- **Difficulty Levels**: 3 (Beginner, Intermediate, Advanced)
-- **Essential Commands**: 13
-- **Reference Docs**: 92 markdown files (14 agents + 78 commands)
-
----
-
-## 🔧 Maintenance
-
-### Updating Indexes
-
-When commands are added/modified/removed:
-
-```bash
-cd /d/Claude_dms3/.claude/skills/command-guide
-python scripts/analyze_commands.py
-```
-
-This script:
-1. Scans all command files in `../../commands/`
-2. Extracts metadata from YAML frontmatter
-3. Analyzes command relationships
-4. Regenerates all 5 index files
-
-### Committing Updates
-
-```bash
-git add .claude/skills/command-guide/
-git commit -m "docs: update command indexes"
-git push
-```
-
-Team members get latest indexes via `git pull`.
-
----
-
-## 📖 Related Documentation
-
-- [Workflow Architecture](../../workflows/workflow-architecture.md) - System design overview
-- [Intelligent Tools Strategy](../../workflows/intelligent-tools-strategy.md) - CLI tool selection
-- [Context Search Strategy](../../workflows/context-search-strategy.md) - Search patterns
-- [Task Core](../../workflows/task-core.md) - Task system fundamentals
-
----
-
-## 🔄 Maintenance
-
-### Documentation Updates
-
-This SKILL documentation is kept in sync with command implementations through a standardized update process.
-
-**Update Guideline**: See [UPDATE-GUIDELINE.md](UPDATE-GUIDELINE.md) for the complete documentation maintenance process.
-
-**Update Process**:
-1. **Analyze**: Identify changed commands/agents from git commits
-2. **Extract**: Gather change information and impact assessment
-3. **Update**: Sync reference docs, guides, and examples
-4. **Regenerate**: Run `scripts/analyze_commands.py` to rebuild indexes
-5. **Validate**: Test examples and verify consistency
-6. **Commit**: Follow standardized commit message format
-
-**Key Capabilities**:
-- 6 operation modes (Search, Recommendations, Full Docs, Onboarding, Issue Reporting, Deep Analysis)
-- 80 reference documentation files (11 agents + 69 commands)
-- 5 JSON indexes for fast command lookup
-- 8 comprehensive guides covering all workflow patterns
-- 4 issue templates for standardized problem reporting
-- CLI-assisted complex query analysis with gemini/qwen integration
-
-**Maintainer**: CCW Team

.claude/skills/command-guide/UPDATE-GUIDELINE.md

@@ -1,592 +0,0 @@
-# Command Guide Update Guideline
-
-## 📋 Purpose
-
-This document defines a **standardized, repeatable process** for updating command-guide documentation when command changes are detected. Use this guideline every time you need to update command-guide SKILL documentation to ensure consistency and completeness.
-
----
-
-## 🎯 Update Trigger Conditions
-
-Execute this update process when ANY of the following conditions are met:
-
-1. **New commands added** to `.claude/commands/`
-2. **Command parameters changed** (new flags, modified behavior)
-3. **Command architecture refactored** (workflow reorganization)
-4. **Agent implementations updated** in `.claude/agents/`
-5. **User explicitly requests** command-guide update
-
----
-
-## 📊 Phase 1: Analysis & Discovery
-
-### Step 1.1: Identify Changed Files
-
-**Objective**: Discover what has changed since last update
-
-**Actions**:
-```bash
-# Find recent commits affecting commands/agents
-git log --oneline --since="<last-update-date>" --grep="command\|agent\|workflow" -20
-
-# Show detailed changes
-git diff <last-commit>..<current-commit> --stat .claude/commands/ .claude/agents/
-
-# Identify modified command files
-git diff <last-commit>..<current-commit> --name-only .claude/commands/
-```
-
-**Output**: List of changed files and commit messages
-
-**Document**:
-- Changed command files
-- Changed agent files
-- Key commit messages
-- Change patterns (new features, refactoring, fixes)
-
----
-
-### Step 1.2: Analyze Change Scope
-
-**Objective**: Understand the nature and impact of changes
-
-**Questions to Answer**:
-1. **What changed?** (parameters, workflow, architecture, behavior)
-2. **Why changed?** (new feature, optimization, bug fix, refactoring)
-3. **Impact scope?** (single command, workflow pattern, system-wide)
-4. **User-facing?** (affects user commands, internal only)
-
-**Analysis Matrix**:
-
-| Change Type | Detection Method | Impact Level |
-|-------------|--------------------|--------------|
-| **New Parameter** | Diff `argument-hint` field | Medium |
-| **Workflow Reorganization** | Multiple command changes | High |
-| **Architecture Change** | Agent file changes + command changes | High |
-| **Bug Fix** | Single file, small change | Low |
-| **New Command** | New file in `.claude/commands/` | Medium-High |
-
-**Output**: Change classification and impact assessment
-
----
-
-### Step 1.3: Map Affected Documentation
-
-**Objective**: Identify which documentation files need updates
-
-**Mapping Rules**:
-
-**Command Changes** → Affects:
-- `reference/commands/<category>/<command-name>.md` (copy from source)
-- `index/all-commands.json` (regenerate)
-- `index/by-category.json` (if new category)
-- `guides/ui-design-workflow-guide.md` (if UI workflow affected)
-- `guides/workflow-patterns.md` (if workflow pattern changed)
-
-**Agent Changes** → Affects:
-- `reference/agents/<agent-name>.md` (copy from source)
-- `guides/implementation-details.md` (if agent behavior changed)
-
-**Workflow Reorganization** → Affects:
-- All related command references
-- Workflow guides
-- Examples in guides
-
-**Output**: Checklist of files to update
-
----
-
-## 🔧 Phase 2: Content Preparation
-
-### Step 2.1: Extract Key Information
-
-**Objective**: Gather information needed for documentation updates
-
-**Extract from Git Commits**:
-```bash
-# Get commit details
-git show <commit-hash> --stat
-
-# Extract commit message
-git log --format=%B -n 1 <commit-hash>
-```
-
-**Information to Extract**:
-1. **Feature Name** (from commit message)
-2. **Change Description** (what was added/modified/removed)
-3. **Rationale** (why the change was made)
-4. **New Parameters** (from diff)
-5. **Breaking Changes** (backward compatibility impact)
-6. **Usage Examples** (from commit or command file)
-
-**Output**: Structured data for documentation
-
----
-
-### Step 2.2: Categorize Changes
-
-**Objective**: Organize changes into logical categories
-
-**Categories**:
-
-1. **Major Features**
-   - New commands
-   - New workflows
-   - Architecture changes
-   - User-facing feature additions
-
-2. **Enhancements**
-   - New parameters
-   - Improved behavior
-   - Performance optimizations
-   - Better error handling
-
-3. **Refactoring**
-   - Code reorganization (no user impact)
-   - Internal structure changes
-   - Consistency improvements
-
-4. **Bug Fixes**
-   - Corrected behavior
-   - Fixed edge cases
-   - Parameter validation fixes
-
-5. **Documentation**
-   - Updated descriptions
-   - New examples
-   - Clarified usage
-
-**Output**: Changes grouped by category with priority
-
----
-
-### Step 2.3: Analyze User Impact
-
-**Objective**: Determine what users need to know
-
-**User Impact Questions**:
-1. **Do existing workflows break?** → Migration guide needed
-2. **Are new features optional?** → Enhancement documentation
-3. **Is behavior significantly different?** → Usage pattern updates
-4. **Do examples need updates?** → Example refresh required
-
-**Impact Levels**:
-- **Critical** (Breaking changes, migration required)
-- **Important** (New features users should adopt)
-- **Nice-to-have** (Enhancements, optional)
-- **Internal** (No user action needed)
-
-**Output**: User-facing change summary with impact levels
-
----
-
-## 📝 Phase 3: Documentation Updates
-
-### Step 3.1: Update Reference Documentation
-
-**Objective**: Sync reference docs with source command files
-
-**Actions**:
-
-1. **Run Python Script to Sync & Rebuild**:
-   ```bash
-   cd /d/Claude_dms3/.claude/skills/command-guide
-   python scripts/analyze_commands.py
-   ```
-
-   This script automatically:
-   - Deletes existing `reference/` directory
-   - Copies all agent files from `.claude/agents/` to `reference/agents/`
-   - Copies all command files from `.claude/commands/` to `reference/commands/`
-   - Regenerates all 5 index files with updated metadata
-
-2. **Verify Completeness**:
-   - Check sync output for file counts (11 agents + 70 commands)
-   - Verify all 5 index files regenerated successfully
-   - Ensure YAML frontmatter integrity in copied files
-
-**Output**: Updated reference documentation matching source + regenerated indexes
-
----
-
-### Step 3.2: Update Workflow Guides
-
-**Objective**: Reflect changes in user-facing workflow guides
-
-**Workflow Guide Update Pattern**:
-
-**IF** (UI workflow commands changed):
-1. Open `guides/ui-design-workflow-guide.md`
-2. Locate affected workflow pattern sections
-3. Update examples to use new parameters/behavior
-4. Add "New!" badges for new features
-5. Update performance metrics if applicable
-6. Add troubleshooting entries for new issues
-
-**IF** (General workflow patterns changed):
-1. Open `guides/workflow-patterns.md`
-2. Update affected workflow examples
-3. Add new pattern sections if applicable
-
-**Update Template for New Features**:
-```markdown
-### [Feature Name] (New!)
-
-**Purpose**: [What this feature enables]
-
-**Usage**:
-```bash
-[Example command with new feature]
-```
-
-**Benefits**:
-- [Benefit 1]
-- [Benefit 2]
-
-**When to Use**:
-- [Use case 1]
-- [Use case 2]
-```
-
-**Output**: Updated workflow guides with new features documented
-
----
-
-### Step 3.3: Update Examples and Best Practices
-
-**Objective**: Ensure examples reflect current best practices
-
-**Example Update Checklist**:
-- [ ] Remove deprecated parameter usage
-- [ ] Add examples for new parameters
-- [ ] Update command syntax if changed
-- [ ] Verify all examples are runnable
-- [ ] Add "Note" sections for common pitfalls
-
-**Best Practices Update**:
-- [ ] Add recommendations for new features
-- [ ] Update "When to Use" guidelines
-- [ ] Revise performance optimization tips
-- [ ] Update troubleshooting entries
-
-**Output**: Current, runnable examples
-
----
-
-### Step 3.4: Update SKILL.md Metadata
-
-**Objective**: Keep SKILL.md current without version-specific details
-
-**Update Sections**:
-
-1. **Supporting Guides** (if new guide added):
-   ```markdown
-   - **[New Guide Name](guides/new-guide.md)** - Description
-   ```
-
-2. **System Statistics** (if counts changed):
-   ```markdown
-   - **Total Commands**: <new-count>
-   - **Total Agents**: <new-count>
-   ```
-
-3. **Remove Old Changelog Entries**:
-   - Keep only last 3 changelog entries
-   - Archive older entries to separate file if needed
-
-**DO NOT**:
-- Add version numbers
-- Add specific dates
-- Create time-based changelog entries
-
-**Output**: Updated SKILL.md metadata
-
----
-
-## 🧪 Phase 4: Validation
-
-### Step 4.1: Consistency Check
-
-**Objective**: Ensure documentation is internally consistent
-
-**Checklist**:
-- [ ] All command references use correct names
-- [ ] Parameter descriptions match command files
-- [ ] Examples use valid parameter combinations
-- [ ] Links between documents are not broken
-- [ ] Index files reflect current command count
-
-**Validation Commands**:
-```bash
-# Check for broken internal links
-grep -r "\[.*\](.*\.md)" guides/ reference/ | grep -v "http"
-
-# Verify command count consistency
-actual=$(find ../../commands -name "*.md" | wc -l)
-indexed=$(jq '.commands | length' index/all-commands.json)
-echo "Actual: $actual, Indexed: $indexed"
-```
-
-**Output**: Validation report
-
----
-
-### Step 4.2: Example Testing
-
-**Objective**: Verify all examples are runnable
-
-**Test Cases**:
-- [ ] Copy example commands from guides
-- [ ] Run in test environment
-- [ ] Verify expected output
-- [ ] Document any prerequisites
-
-**Note**: Some examples may be illustrative only; mark these clearly
-
-**Output**: Tested examples
-
----
-
-### Step 4.3: Peer Review Checklist
-
-**Objective**: Prepare documentation for review
-
-**Review Points**:
-- [ ] Is the change clearly explained?
-- [ ] Are examples helpful and clear?
-- [ ] Is migration guidance complete (if breaking)?
-- [ ] Are troubleshooting tips adequate?
-- [ ] Is the documentation easy to scan?
-
-**Output**: Review-ready documentation
-
----
-
-## 📤 Phase 5: Commit & Distribution
-
-### Step 5.1: Git Commit Structure
-
-**Objective**: Create clear, traceable commits
-
-**Commit Pattern**:
-```bash
-git add .claude/skills/command-guide/
-
-# Commit message format
-git commit -m "docs(command-guide): update for <feature-name> changes
-
-- Update reference docs for <changed-commands>
-- Enhance <guide-name> with <feature> documentation
-- Regenerate indexes (new count: <count>)
-- Add troubleshooting for <new-issues>
-
-Refs: <commit-hashes-of-source-changes>
-"
-```
-
-**Commit Message Rules**:
-- **Type**: `docs(command-guide)`
-- **Scope**: Always `command-guide`
-- **Summary**: Concise, imperative mood
-- **Body**: Bullet points for each change type
-- **Refs**: Link to source change commits
-
-**Output**: Clean commit history
-
----
-
-### Step 5.2: Update Distribution
-
-**Objective**: Make updates available to users
-
-**Actions**:
-```bash
-# Push to remote
-git push origin main
-
-# Verify GitHub reflects changes
-# Check: https://github.com/<org>/<repo>/tree/main/.claude/skills/command-guide
-```
-
-**User Notification** (if breaking changes):
-- Update project README
-- Add note to main documentation
-- Consider announcement in team channels
-
-**Output**: Published updates
-
----
-
-## 🔄 Phase 6: Iteration & Improvement
-
-### Step 6.1: Gather Feedback
-
-**Objective**: Improve documentation based on usage
-
-**Feedback Sources**:
-- User questions about changed commands
-- Confusion points in examples
-- Missing information requests
-- Error reports
-
-**Track**:
-- Common questions → Add to troubleshooting
-- Confusing examples → Simplify or expand
-- Missing use cases → Add to guides
-
-**Output**: Improvement backlog
-
----
-
-### Step 6.2: Continuous Refinement
-
-**Objective**: Keep documentation evolving
-
-**Regular Tasks**:
-- [ ] Review index statistics monthly
-- [ ] Update examples with real-world usage
-- [ ] Consolidate redundant sections
-- [ ] Expand troubleshooting based on issues
-- [ ] Refresh screenshots/outputs if UI changed
-
-**Output**: Living documentation
-
----
-
-## 📐 Update Decision Matrix
-
-Use this matrix to determine update depth:
-
-| Change Scope | Reference Docs | Workflow Guides | Examples | Indexes | Migration Guide |
-|--------------|----------------|-----------------|----------|---------|-----------------|
-| **New Parameter** | Update command file | Add parameter note | Add usage example | Regenerate | No |
-| **Workflow Refactor** | Update all affected | Major revision | Update all examples | Regenerate | If breaking |
-| **New Command** | Copy new file | Add workflow pattern | Add examples | Regenerate | No |
-| **Architecture Change** | Update all affected | Major revision | Comprehensive update | Regenerate | Yes |
-| **Bug Fix** | Update description | Add note if user-visible | Fix incorrect examples | No change | No |
-| **New Feature** | Update affected files | Add feature section | Add feature examples | Regenerate | No |
-
----
-
-## 🎯 Quality Gates
-
-Before considering documentation update complete, verify:
-
-### Gate 1: Completeness
-- [ ] All changed commands have updated reference docs
-- [ ] All new features are documented in guides
-- [ ] All examples are current and correct
-- [ ] Indexes reflect current state
-
-### Gate 2: Clarity
-- [ ] Non-expert can understand changes
-- [ ] Examples demonstrate key use cases
-- [ ] Migration path is clear (if breaking)
-- [ ] Troubleshooting covers common issues
-
-### Gate 3: Consistency
-- [ ] Terminology is consistent across docs
-- [ ] Parameter descriptions match everywhere
-- [ ] Cross-references are accurate
-- [ ] Formatting follows established patterns
-
-### Gate 4: Accessibility
-- [ ] Table of contents is current
-- [ ] Search/navigation works
-- [ ] Related docs are linked
-- [ ] Issue templates reference new content
-
----
-
-## 🚀 Quick Start Template
-
-When updates are needed, follow this abbreviated workflow:
-
-```bash
-# 1. ANALYZE (5 min)
-git log --oneline --since="<last-update>" --grep="command\|agent" -20
-# → Identify what changed
-
-# 2. EXTRACT (10 min)
-git show <commit-hash> --stat
-git diff <commit>..HEAD --stat .claude/commands/
-# → Understand changes
-
-# 3. UPDATE (30 min)
-# - Update affected guide sections (ui-design-workflow-guide.md, etc.)
-# - Add examples for new features
-# - Document parameter changes
-
-# 4. SYNC & REGENERATE (2 min)
-cd /d/Claude_dms3/.claude/skills/command-guide
-python scripts/analyze_commands.py
-# → Syncs reference docs + regenerates all 5 indexes
-
-# 5. VALIDATE (10 min)
-# - Test examples
-# - Check consistency
-# - Verify links
-
-# 6. COMMIT (5 min)
-git add .claude/skills/command-guide/
-git commit -m "docs(command-guide): update for <feature> changes"
-git push origin main
-```
-
-**Total Time**: ~1 hour for typical update
-
----
-
-## 🔗 Related Resources
-
-- **Python Index Script**: `.claude/skills/command-guide/scripts/analyze_commands.py`
-- **Issue Templates**: `.claude/skills/command-guide/templates/`
-- **SKILL Entry Point**: `.claude/skills/command-guide/SKILL.md`
-- **Reference Source**: `.claude/commands/` and `.claude/agents/`
-
----
-
-## 📌 Appendix: Common Patterns
-
-### Pattern 1: New Parameter Addition
-
-**Example**: `--interactive` flag added to `explore-auto`
-
-**Update Sequence**:
-1. Update `guides/ui-design-workflow-guide.md` with interactive examples
-2. Add "When to Use" guidance
-3. Run Python script to sync reference docs and regenerate indexes
-4. Update argument-hint in examples
-
----
-
-### Pattern 2: Workflow Reorganization
-
-**Example**: Layout extraction split into concept generation + selection
-
-**Update Sequence**:
-1. Major revision of workflow guide section
-2. Update all workflow examples
-3. Add migration notes for existing users
-4. Update troubleshooting
-5. Run Python script to sync and regenerate indexes
-
----
-
-### Pattern 3: Architecture Change
-
-**Example**: Agent execution model changed
-
-**Update Sequence**:
-1. Update `guides/implementation-details.md`
-2. Revise all workflow patterns using affected agents
-3. Create migration guide
-4. Update examples comprehensively
-5. Run Python script to sync and regenerate indexes
-6. Add extensive troubleshooting
-
----
-
-**End of Update Guideline**
-
-This guideline is a living document. Improve it based on update experience.

.claude/skills/command-guide/guides/cli-tools-guide.md

@@ -1,410 +0,0 @@
-# CLI 工具使用指南
-
-> **SKILL 参考文档**：用于回答用户关于 CLI 工具（Gemini、Qwen、Codex）的使用问题
->
-> **用途**：当用户询问 CLI 工具的能力、使用方法、调用方式时，从本文档中提取相关信息，根据用户具体需求加工后返回
-
-## 🎯 快速理解：CLI 工具是什么？
-
-CLI 工具是集成在 Claude DMS3 中的**智能分析和执行助手**。
-
-**工作流程**：
-1. **用户** → 用自然语言向 Claude Code 描述需求（如"分析认证模块的安全性"）
-2. **Claude Code** → 识别用户意图，决定使用哪种方式：
-   - **CLI 工具语义调用**：生成并执行 `gemini`/`qwen`/`codex` 命令
-   - **Slash 命令调用**：执行预定义的工作流命令（如 `/workflow:plan`）
-3. **工具** → 自动完成任务并返回结果
-
-**核心理念**：用户用自然语言描述需求 → Claude Code 选择最佳方式 → 工具执行 → 返回结果
-
----
-
-## 📋 三大工具能力对比
-
-| 工具 | 擅长领域 | 典型场景 | 何时使用 |
-|------|----------|----------|----------|
-| **Gemini** | 分析、理解、规划 | 代码分析、架构设计、问题诊断 | 需要深入理解代码或系统 |
-| **Qwen** | 分析、备选方案 | 代码审查、模式识别 | Gemini 不可用时的备选 |
-| **Codex** | 实现、测试、执行 | 功能开发、测试生成、自动化任务 | 需要生成代码或自动执行 |
-
-**简单记忆**：
-- 想**理解**什么 → Gemini / Qwen
-- 想**实现**什么 → Codex
-
----
-
-## 🚀 Claude Code 的两种响应方式
-
-当用户用自然语言描述需求时，Claude Code 会根据任务特性选择最佳方式：
-
-### 方式 1：CLI 工具语义调用（灵活、强大）
-
-**用户明确指示使用 CLI 工具**，Claude Code 生成并执行相应命令。
-
-#### 示例 1：Gemini 语义分析
-
-**用户输入**（必须明确提到工具）：
-```
-使用 gemini 分析认证模块的安全性，识别潜在的安全漏洞，
-关注 JWT 令牌处理、密码存储、会话管理等方面，
-提供具体的修复建议
-```
-
-**Claude Code 生成并执行**（CLI 命令）：
-```bash
-cd src/auth && gemini -p "
-分析认证模块的安全性，识别潜在的安全漏洞，
-关注 JWT 令牌处理、密码存储、会话管理等方面，
-提供具体的修复建议
-" -m gemini-3-pro-preview-11-2025
-```
-
-**工具输出**：Gemini 自动理解任务，组合多个分析步骤，返回结构化报告
-
----
-
-#### 示例 2：Qwen 语义分析（Gemini 的备选）
-
-**用户输入**：
-```
-用 qwen 追踪用户登录的完整执行流程，
-从 API 入口到数据库查询，
-列出所有调用的函数和依赖关系
-```
-
-**Claude Code 生成并执行**：
-```bash
-cd src/auth && qwen -p "
-追踪用户登录的完整执行流程，
-从 API 入口到数据库查询，
-列出所有调用的函数和依赖关系
-"
-```
-
-**工具输出**：Qwen 理解需求，自动追踪执行路径
-
----
-
-#### 示例 3：Codex 语义实现
-
-**用户输入**：
-```
-让 codex 实现 JWT 令牌刷新机制：
-1. 添加 refreshToken 端点
-2. 验证旧令牌的有效性
-3. 生成新的访问令牌
-4. 确保安全性（防重放攻击）
-```
-
-**Claude Code 生成并执行**：
-```bash
-codex -C src/auth --full-auto exec "
-实现 JWT 令牌刷新机制：
-1. 添加 refreshToken 端点
-2. 验证旧令牌的有效性
-3. 生成新的访问令牌
-4. 确保安全性（防重放攻击）
-" -m gpt-5 --skip-git-repo-check -s danger-full-access
-```
-
-**工具输出**：Codex 理解需求，自动生成代码并集成到现有系统
-
----
-
-**核心特点**：
-- ✅ **用户明确指定工具**：必须说"使用 gemini"、"用 qwen"、"让 codex"等触发工具调用
-- ✅ **Claude 生成命令**：识别工具名称后，自动构造最优的 CLI 工具调用
-- ✅ **工具自动理解**：CLI 工具解析需求，组合分析/实现步骤
-- ✅ **灵活强大**：不受预定义工作流限制
-- ✅ **精确控制**：Claude 可指定工作目录、文件范围、模型参数
-
-**触发方式**：
-- "使用 gemini ..."
-- "用 qwen ..."
-- "让 codex ..."
-- "通过 gemini 工具..."
-
-**Claude Code 何时选择此方式**：
-- 用户明确指定使用某个 CLI 工具
-- 复杂分析任务（跨模块、多维度）
-- 自定义工作流需求
-- 需要精确控制上下文范围
-
----
-
-### 方式 2：Slash 命令调用（标准工作流）
-
-**用户直接输入 Slash 命令**，或 **Claude Code 建议使用 Slash 命令**，系统执行预定义工作流（内部调用 CLI 工具）。
-
-#### Workflow 类命令（系统自动选择工具）
-
-**示例 1：规划任务**
-
-**用户输入**：
-```
-/workflow:plan --agent "实现用户认证功能"
-```
-
-**系统执行**：内部调用 gemini/qwen 分析 + action-planning-agent 生成任务
-
----
-
-**示例 2：执行任务**
-
-**用户输入**：
-```
-/workflow:execute
-```
-
-**系统执行**：内部调用 codex 实现代码
-
----
-
-**示例 3：生成测试**
-
-**用户输入**：
-```
-/workflow:test-gen WFS-xxx
-```
-
-**系统执行**：内部调用 gemini 分析 + codex 生成测试
-
----
-
-#### CLI 类命令（指定工具）
-
-**示例 1：封装的分析命令**
-
-**用户输入**：
-```
-/cli:analyze --tool gemini "分析认证模块"
-```
-
-**系统执行**：使用 gemini 工具进行分析
-
----
-
-**示例 2：封装的执行命令**
-
-**用户输入**：
-```
-/cli:execute --tool codex "实现 JWT 刷新"
-```
-
-**系统执行**：使用 codex 工具实现功能
-
----
-
-**示例 3：快速执行（YOLO 模式）**
-
-**用户输入**：
-```
-/cli:codex-execute "添加用户头像上传"
-```
-
-**系统执行**：使用 codex 快速实现
-
----
-
-**核心特点**：
-- ✅ **用户可直接输入**：Slash 命令格式固定，用户可以直接输入（如 `/workflow:plan`）
-- ✅ **Claude 可建议**：Claude Code 也可以识别需求后建议或执行 Slash 命令
-- ✅ **预定义流程**：标准化的工作流模板
-- ✅ **自动工具选择**：workflow 命令内部自动选择合适的 CLI 工具
-- ✅ **集成完整**：包含规划、执行、测试、文档等环节
-- ✅ **简单易用**：无需了解底层 CLI 工具细节
-
-**Claude Code 何时选择此方式**：
-- 标准开发任务（功能开发、测试、重构）
-- 团队协作（统一工作流）
-- 适合新手（降低学习曲线）
-- 快速开发（减少配置时间）
-
----
-
-## 🔄 两种方式对比
-
-| 维度 | CLI 工具语义调用 | Slash 命令调用 |
-|------|------------------|----------------|
-| **用户输入** | 纯自然语言描述需求 | `/` 开头的固定命令格式 |
-| **Claude Code 行为** | 生成并执行 `gemini`/`qwen`/`codex` 命令 | 执行预定义工作流（内部调用 CLI 工具） |
-| **灵活性** | 完全自定义任务和执行方式 | 固定工作流模板 |
-| **学习曲线** | 用户无需学习（纯自然语言） | 需要知道 Slash 命令名称 |
-| **适用复杂度** | 复杂、探索性、定制化任务 | 标准、重复性、工作流化任务 |
-| **工具选择** | Claude 自动选择最佳 CLI 工具 | 系统自动选择（workflow 类）<br>或用户指定（cli 类） |
-| **典型场景** | 深度分析、自定义流程、探索研究 | 日常开发、团队协作、标准流程 |
-
-**使用建议**：
-- **日常开发** → 优先使用 Slash 命令（标准化、快速）
-- **复杂分析** → Claude 自动选择 CLI 工具语义调用（灵活、强大）
-- **用户角度** → 只需用自然语言描述需求，Claude Code 会选择最佳方式
-
----
-
-## 💡 工具能力速查
-
-### Gemini - 分析与规划
-- 执行流程追踪、依赖分析、代码模式识别
-- 架构设计、技术方案评估、任务分解
-- 文档生成（API 文档、模块说明）
-
-**触发示例**：`使用 gemini 追踪用户登录的完整流程`
-
----
-
-### Qwen - Gemini 的备选
-- 代码分析、模式识别、架构评审
-- 作为 Gemini 不可用时的备选方案
-
-**触发示例**：`用 qwen 分析数据处理模块`
-
----
-
-### Codex - 实现与执行
-- 功能开发、组件实现、API 创建
-- 单元测试、集成测试、TDD 支持
-- 代码重构、性能改进、Bug 修复
-
-**触发示例**：`让 codex 实现用户注册功能，包含邮箱验证`
-
----
-
-## 🔄 典型使用场景
-
-### 场景 1：理解陌生代码库
-
-**需求**：接手新项目，需要快速理解代码结构
-
-**方式 1：CLI 工具语义调用**（推荐，灵活）
-
-- **用户输入**：`使用 gemini 分析这个项目的架构设计，识别主要模块、依赖关系和架构模式`
-- **Claude Code 生成并执行**：`cd project-root && gemini -p "..."`
-
-**方式 2：Slash 命令**
-- **用户输入**：`/cli:analyze --tool gemini "分析项目架构"`
-
----
-
-### 场景 2：实现新功能
-
-**需求**：实现用户认证功能
-
-**方式 1：CLI 工具语义调用**
-- **用户输入**：`让 codex 实现用户认证功能：注册（邮箱+密码+验证）、登录（JWT token）、刷新令牌，技术栈 Node.js + Express`
-- **Claude Code 生成并执行**：`codex -C src/auth --full-auto exec "..." --skip-git-repo-check -s danger-full-access`
-
-**方式 2：Slash 命令**（工作流化）
-- **用户输入**：`/workflow:plan --agent "实现用户认证功能"` → `/workflow:execute`
-
----
-
-### 场景 3：诊断 Bug
-
-**需求**：登录功能偶尔超时
-
-**方式 1：CLI 工具语义调用**
-- **用户输入**：`使用 gemini 诊断登录超时问题，分析处理流程、性能瓶颈、数据库查询效率`
-- **Claude Code 生成并执行**：`cd src/auth && gemini -p "..."`
-- **用户输入**：`让 codex 根据上述分析修复登录超时，优化查询、添加缓存`
-- **Claude Code 生成并执行**：`codex -C src/auth --full-auto exec "..." --skip-git-repo-check -s danger-full-access`
-
-**方式 2：Slash 命令**
-- **用户输入**：`/cli:mode:bug-diagnosis --tool gemini "诊断登录超时"` → `/cli:execute --tool codex "修复登录超时"`
-
----
-
-### 场景 4：生成文档
-
-**需求**：为 API 模块生成完整文档
-
-**方式 1：CLI 工具语义调用**
-- **用户输入**：`使用 gemini 为 API 模块生成技术文档，包含端点说明、数据模型、使用示例`
-- **Claude Code 生成并执行**：`cd src/api && gemini -p "..." --approval-mode yolo`
-
-**方式 2：Slash 命令**
-- **用户输入**：`/memory:docs src/api --tool gemini --mode full`
-
----
-
-## 🎯 常用工作流程
-
-### 简单 Bug 修复
-```
-使用 gemini 诊断问题（可选其他 cli 工具）
-→ Claude 分析
-→ Claude 直接执行修复
-```
-
-### 复杂 Bug 修复
-```
-/cli:mode:plan 或 /cli:mode:bug-diagnosis
-→ Claude 分析
-→ Claude 执行修复
-```
-
-### 简单功能增加
-```
-/cli:mode:plan
-→ Claude 执行
-```
-
-### 复杂功能增加
-```
-/cli:mode:plan --agent
-→ Claude 执行 或 /cli:codex-execute
-
-或
-
-/cli:mode:plan
-→ 进入工作流模式（/workflow:execute）
-```
-
-### 项目内存管理
-
-**建立技术栈文档**（为项目提供技术参考）
-```
-/memory:tech-research [session-id | tech-stack-name]
-```
-
-**为项目重建多级结构的 CLAUDE.md 内存**
-```
-/memory:docs [path] [--tool gemini|qwen|codex] [--mode full|partial]
-```
-
----
-
-## 📚 常用命令速查
-
-| 需求 | 推荐命令 |
-|------|----------|
-| **代码分析** | `使用 gemini 分析...` 或 `/cli:analyze --tool gemini` |
-| **Bug 诊断** | `/cli:mode:bug-diagnosis` |
-| **功能实现** | `/cli:codex-execute` 或 `让 codex 实现...` |
-| **架构规划** | `/cli:mode:plan` |
-| **生成测试** | `/workflow:test-gen WFS-xxx` |
-| **完整工作流** | `/workflow:plan` → `/workflow:execute` |
-| **技术文档** | `/memory:tech-research [tech-name]` |
-| **项目文档** | `/memory:docs [path]` |
-
----
-
-## 🆘 快速提示
-
-**触发 CLI 工具语义调用**：
-- "使用 gemini ..."
-- "用 qwen ..."
-- "让 codex ..."
-
-**选择工具**：
-- **理解/分析/规划** → Gemini
-- **实现/测试/执行** → Codex
-- **不确定** → 使用 Slash 命令让系统选择
-
-**提升质量**：
-- 清晰描述需求和期望
-- 提供上下文信息
-- 使用 `--agent` 处理复杂任务
-
----
-
-**最后更新**: 2025-11-06

.claude/skills/command-guide/guides/examples.md

@@ -1,537 +0,0 @@
-# Usage Examples
-
-Comprehensive examples of command-guide skill in action across all 5 operation modes.
-
----
-
-## Mode 1: Command Search 🔍
-
-### Example 1: Keyword Search
-
-**User**: "搜索包含 'execute' 的命令"
-
-**Skill Response**:
-```
-找到 4 个相关命令：
-
-1. **cli:execute** (高级)
-   描述: Auto-execution of implementation tasks with YOLO permissions
-   参数: [--agent] [--tool codex|gemini|qwen] [--enhance] description or task-id
-   场景: implementation
-
-2. **task:execute** (中级)
-   描述: Execute tasks with appropriate agents and context-aware orchestration
-   参数: task-id
-   场景: implementation
-
-3. **workflow:execute** (中级)
-   描述: Coordinate agents for existing workflow tasks with automatic discovery
-   参数: [--resume-session="session-id"]
-   场景: implementation
-
-4. **codex-execute** (高级)
-   描述: Automated task decomposition and execution with Codex
-   参数: task description or task-id
-   场景: implementation
-
-💡 相关命令: workflow:plan, task:create
-📖 详细文档: [Implementation Commands](workflow-patterns.md#implementation)
-```
-
----
-
-### Example 2: Category Search
-
-**User**: "cli 类别下有哪些命令？"
-
-**Skill Response**:
-```
-CLI 类别包含 9 个命令：
-
-**核心命令** (6个):
-- cli:analyze - Quick codebase analysis
-- cli:chat - Direct codebase interaction
-- cli:execute - Auto-execution with YOLO
-- cli:cli-init - Initialize CLI tool configs
-- cli:codex-execute - Codex-powered execution
-- cli:discuss-plan - Multi-model planning discussion
-
-**模式命令** (3个):
-- cli:mode:plan - Project planning mode
-- cli:mode:code-analysis - Deep code analysis mode
-- cli:mode:bug-diagnosis - Bug diagnosis mode
-
-📚 使用指南: [CLI Tools Guide](cli-tools-guide.md)
-```
-
----
-
-### Example 3: Use-Case Search
-
-**User**: "planning 相关的命令有哪些？"
-
-**Skill Response**:
-```
-Planning 场景包含 8 个命令：
-
-**核心规划**:
-1. workflow:plan (高级) - 5阶段规划工作流
-2. cli:mode:plan (高级) - 项目规划和架构分析
-3. workflow:tdd-plan (高级) - TDD 规划工作流
-
-**任务分解**:
-4. task:breakdown (中级) - 智能任务分解
-5. workflow:tools:task-generate (中级) - 生成任务 JSON
-
-**架构设计**:
-6. workflow:brainstorm:system-architect (中级) - 系统架构师头脑风暴
-7. workflow:brainstorm:api-designer (中级) - API 设计师头脑风暴
-
-**评估验证**:
-8. workflow:action-plan-verify (中级) - 规划质量验证
-
-💡 常见工作流: Plan → Verify → Execute
-📖 模式参考: [Workflow Patterns](workflow-patterns.md#planning-workflow)
-```
-
----
-
-## Mode 2: Smart Recommendations 🤖
-
-### Example 1: After Planning
-
-**User**: "执行完 /workflow:plan 后下一步做什么？"
-
-**Skill Response**:
-```
-推荐的后续步骤：
-
-**🎯 主要选择**:
-1. **/workflow:execute** - 开始执行规划的任务
-   ✅ 这是最常见的下一步
-   作用: 实际执行 workflow:plan 生成的任务
-
-**📋 可选步骤**:
-2. **/workflow:action-plan-verify** - 验证规划质量
-   作用: 在执行前检查规划的一致性和完整性
-   建议: 重要项目建议先验证
-
-3. **/workflow:status** - 查看规划状态
-   作用: 查看生成的任务和当前进度
-
-**📚 完整工作流模式**:
-Plan → Verify (可选) → Execute → Review
-
-详见: [Planning Workflow Pattern](workflow-patterns.md#planning-execution)
-```
-
----
-
-### Example 2: After Execution
-
-**User**: "workflow:execute 执行完成后，推荐做什么？"
-
-**Skill Response**:
-```
-推荐的后续步骤：
-
-**🎯 主要选择**:
-1. **/workflow:review** - 审查实现结果
-   ✅ 检查代码质量、安全性、架构
-   参数: [--type=quality|security|architecture]
-
-**📊 可选步骤**:
-2. **/workflow:status** - 查看执行状态
-   作用: 确认所有任务都已完成
-
-3. **/workflow:test-gen** - 生成测试
-   作用: 为实现的功能创建测试用例
-
-4. **/workflow:session:complete** - 完成会话
-   作用: 标记工作流已完成，归档经验
-
-**🔄 如果需要修改**:
-- /task:replan - 重新规划某个任务
-- /workflow:resume - 恢复工作流
-
-详见: [Execution Review Pattern](workflow-patterns.md#execution-review)
-```
-
----
-
-## Mode 3: Full Documentation 📖
-
-### Example 1: Command Parameters
-
-**User**: "/workflow:plan 的参数是什么？"
-
-**Skill Response**:
-```
-# workflow:plan
-
-**描述**: Orchestrate 5-phase planning workflow with quality gate, executing commands and passing context between phases
-
-**参数**:
-```bash
-/workflow:plan [--agent] [--cli-execute] "text description"|file.md
-```
-
-**参数说明**:
-- `--agent` (可选): 使用 agent 模式执行规划
-- `--cli-execute` (可选): 允许在规划阶段执行 CLI 命令
-- `"text description"`: 任务描述文本
-- `file.md`: 或者提供任务描述文件路径
-
-**使用场景**: planning
-**难度级别**: 高级
-
-**使用示例**:
-```bash
-# 基本用法
-/workflow:plan "实现用户认证功能"
-
-# 使用 agent 模式
-/workflow:plan --agent "重构支付模块"
-
-# 从文件读取
-/workflow:plan --agent feature-spec.md
-
-# 允许 CLI 执行
-/workflow:plan --cli-execute "添加搜索功能"
-```
-
-**执行流程**:
-1. 上下文收集
-2. 概念规划
-3. 实现规划
-4. 任务生成
-5. 质量验证
-
-**相关命令**:
-- workflow:execute - 执行规划的任务
-- workflow:action-plan-verify - 验证规划质量
-- workflow:status - 查看规划状态
-
-**详细文档**: ../../commands/workflow/plan.md
-```
-
----
-
-## Mode 4: Beginner Onboarding 🎓
-
-### Example 1: Complete Beginner
-
-**User**: "我是新手，如何开始使用工作流系统？"
-
-**Skill Response**:
-```
-欢迎使用 Claude DMS3 工作流系统！🎉
-
-## 🚀 快速开始（3 步）
-
-### Step 1: 了解核心命令（Top 5）
-
-1. **/workflow:plan** - 规划一个功能或任务
-   用法: /workflow:plan "你想做的事情"
-
-2. **/workflow:execute** - 执行规划的任务
-   用法: /workflow:execute
-
-3. **/cli:execute** - 快速自动执行
-   用法: /cli:execute "实现XXX功能"
-
-4. **/task:create** - 创建单个任务
-   用法: /task:create "任务标题"
-
-5. **/enhance-prompt** - 优化你的提示词
-   用法: /enhance-prompt "你的想法"
-
-### Step 2: 尝试第一个工作流
-
-```bash
-# 1. 规划一个简单功能
-/workflow:plan "添加用户登录功能"
-
-# 2. 执行规划
-/workflow:execute
-
-# 3. 审查结果
-/workflow:review
-```
-
-### Step 3: 学习资源
-
-📖 **必读指南**:
-- [5分钟快速开始](getting-started.md)
-- [常见工作流模式](workflow-patterns.md)
-
-🛠️ **工具指南**:
-- [CLI 工具使用](cli-tools-guide.md)
-- [问题排查](troubleshooting.md)
-
-💡 **下一步建议**:
-1. 阅读 getting-started.md（5分钟）
-2. 尝试上面的第一个工作流
-3. 探索更多命令: 询问 "常用命令有哪些"
-
-有问题随时问 "CCW-help"！
-```
-
----
-
-### Example 2: Intermediate User
-
-**User**: "常用命令有哪些？"
-
-**Skill Response**:
-```
-## 核心命令列表（Top 14）
-
-### 🎯 工作流管理 (5个)
-1. workflow:plan - 5阶段规划
-2. workflow:execute - 执行任务
-3. workflow:review - 审查实现
-4. workflow:tdd-plan - TDD 规划
-5. workflow:test-gen - 生成测试
-
-### 🛠️ CLI 工具 (3个)
-6. cli:execute - 自动执行
-7. cli:mode:plan - 规划模式
-8. cli:analyze - 代码分析
-
-### 📋 任务管理 (3个)
-9. task:create - 创建任务
-10. task:execute - 执行任务
-11. task:breakdown - 分解任务
-
-### 🔧 实用工具 (2个)
-12. enhance-prompt - 提示词增强
-13. version - 版本信息
-
-### 💡 使用频率
-- **每天**: workflow:plan, workflow:execute, cli:execute
-- **经常**: task:create, enhance-prompt
-- **按需**: workflow:review, test-gen, tdd-plan
-
-📚 详细文档: [Index Structure](index-structure.md#essential-commands)
-```
-
----
-
-## Mode 5: Issue Reporting 📝
-
-### Example 1: Bug Report
-
-**User**: "CCW-issue"
-
-**Skill (Interactive)**:
-```
-请选择问题类型：
-1. 🐛 Bug 报告
-2. ✨ 功能请求
-3. ❓ 问题咨询
-```
-
-**User**: "1"
-
-**Skill**:
-```
-好的，我将帮您创建 Bug 报告。请回答以下问题：
-
-1. 简要描述问题：
-```
-
-**User**: "/workflow:plan 执行后没有生成任务文件"
-
-**Skill**:
-```
-2. 您执行的完整命令是什么？
-```
-
-**User**: "/workflow:plan '添加登录功能'"
-
-**Skill**:
-```
-3. 期望的结果是什么？
-```
-
-**User**: "应该在 .workflow/ 目录生成 task.json"
-
-**Skill**:
-```
-4. 实际发生了什么？
-```
-
-**User**: "命令执行了但没有生成文件"
-
-**Skill**:
-```
-✅ Bug 报告已生成！
-
-文件路径: templates/.generated/bug-2025-01-06-123456.md
-
---- 报告内容 ---
-# Bug 报告
-
-## 问题描述
-/workflow:plan 执行后没有生成任务文件
-
-## 执行的命令
-```bash
-/workflow:plan '添加登录功能'
-```
-
-## 期望行为
-应该在 .workflow/ 目录生成 task.json
-
-## 实际行为
-命令执行了但没有生成文件
-
-## 环境信息
-- 操作系统: Windows
-- 报告日期: 2025-01-06
-- 相关命令: /workflow:plan
-
----
-
-**下一步操作**:
-1. 复制以上内容到 GitHub Issues
-2. 或使用: gh issue create -F templates/.generated/bug-2025-01-06-123456.md
-
-需要更多帮助？使用 "CCW-help"
-```
-
----
-
-### Example 2: Feature Request
-
-**User**: "我想提个功能建议"
-
-**Skill (Interactive)**:
-```
-请选择问题类型：
-1. 🐛 Bug 报告
-2. ✨ 功能请求
-3. ❓ 问题咨询
-```
-
-**User**: "2"
-
-**Skill**:
-```
-好的，功能请求。请描述：
-
-1. 您希望添加什么功能？
-```
-
-**User**: "希望 /workflow:plan 能自动估算任务时间"
-
-**Skill**:
-```
-2. 这个功能解决什么问题？
-```
-
-**User**: "帮助更好地规划项目进度和资源分配"
-
-**Skill**:
-```
-3. 具体的使用场景是什么？（可选）
-```
-
-**User**: "规划大型项目时，能看到预计完成时间"
-
-**Skill**:
-```
-✅ 功能请求已生成！
-
-文件路径: templates/.generated/feature-2025-01-06-123457.md
-
---- 内容预览 ---
-# 功能请求
-
-## 功能概述
-希望 /workflow:plan 能自动估算任务时间
-
-## 问题背景
-帮助更好地规划项目进度和资源分配
-
-## 使用场景
-规划大型项目时，能看到预计完成时间
-
-## 优先级
-- [ ] 高 - 严重影响工作效率
-- [x] 中 - 有明显改善但有变通方案
-- [ ] 低 - 锦上添花
-
----
-
-可以复制到 GitHub 提交，或使用:
-gh issue create -F templates/.generated/feature-2025-01-06-123457.md
-```
-
----
-
-## Edge Cases & Error Handling
-
-### Case 1: No Results Found
-
-**User**: "搜索 xyz 命令"
-
-**Skill**:
-```
-❌ 未找到包含 "xyz" 的命令
-
-💡 建议：
-1. 尝试更广泛的关键词（如 "plan", "execute", "test"）
-2. 按类别浏览：workflow, cli, memory, task
-3. 查看所有常用命令：询问 "常用命令"
-4. 需要帮助：使用 "CCW-help"
-
-📚 快速参考：[All Commands Index](index-structure.md#all-commands)
-```
-
----
-
-### Case 2: Ambiguous Query
-
-**User**: "命令"
-
-**Skill**:
-```
-您想了解什么？请选择：
-
-1. 🔍 搜索特定命令
-2. 🤖 获取命令推荐
-3. 📖 查看命令文档
-4. 🎓 新手入门指导
-5. 📝 报告问题或建议
-
-或者直接说出具体需求，例如：
-- "搜索 planning 命令"
-- "执行完 /workflow:plan 下一步做什么"
-- "/task:create 怎么用"
-```
-
----
-
-### Case 3: Multiple Matches
-
-**User**: "execute 命令"
-
-**Skill**:
-```
-找到多个相关命令，请选择您需要的：
-
-1. **cli:execute** - CLI 自动执行（推荐新手）
-2. **task:execute** - 执行单个任务
-3. **workflow:execute** - 执行整个工作流
-
-或者询问：
-- "cli:execute 的详细文档"
-- "三者有什么区别"
-- "我该用哪个"
-```
-
----
-
-**Last Updated**: 2025-01-06

.claude/skills/command-guide/guides/getting-started.md

@@ -1,242 +0,0 @@
-# 5分钟快速上手指南
-
-> 欢迎使用 Claude DMS3！本指南将帮助您快速上手，5分钟内开始第一个工作流。
-
-## 🎯 Claude DMS3 是什么？
-
-Claude DMS3 是一个**智能开发管理系统**，集成了 69 个命令，帮助您：
-- 📋 规划和分解复杂任务
-- ⚡ 自动化代码实现
-- 🧪 生成和执行测试
-- 📚 生成项目文档
-- 🤖 使用 AI 工具（Gemini、Qwen、Codex）加速开发
-
-**核心理念**：用自然语言描述需求 → 系统自动规划和执行 → 获得结果
-
----
-
-## 🚀 最常用的14个命令
-
-### 工作流类（必会）
-
-| 命令 | 用途 | 何时使用 |
-|------|------|----------|
-| `/workflow:plan` | 规划任务 | 开始新功能、新项目 |
-| `/workflow:execute` | 执行任务 | plan 之后，实现功能 |
-| `/workflow:test-gen` | 生成测试 | 实现完成后，生成测试 |
-| `/workflow:status` | 查看进度 | 查看工作流状态 |
-| `/workflow:resume` | 恢复任务 | 继续之前的工作流 |
-
-### CLI 工具类（常用）
-
-| 命令 | 用途 | 何时使用 |
-|------|------|----------|
-| `/cli:analyze` | 代码分析 | 理解代码、分析架构 |
-| `/cli:execute` | 执行实现 | 精确控制实现过程 |
-| `/cli:codex-execute` | 自动化实现 | 快速实现功能 |
-| `/cli:chat` | 问答交互 | 询问代码库问题 |
-
-### Memory 类（知识管理）
-
-| 命令 | 用途 | 何时使用 |
-|------|------|----------|
-| `/memory:docs` | 生成文档 | 生成模块文档 |
-| `/memory:load` | 加载上下文 | 获取任务相关上下文 |
-
-### Task 类（任务管理）
-
-| 命令 | 用途 | 何时使用 |
-|------|------|----------|
-| `/task:create` | 创建任务 | 手动创建单个任务 |
-| `/task:execute` | 执行任务 | 执行特定任务 |
-
----
-
-## 📝 第一个工作流：实现一个新功能
-
-让我们通过一个实际例子来体验完整的工作流：**实现用户登录功能**
-
-### 步骤 1：规划任务
-
-```bash
-/workflow:plan --agent "实现用户登录功能，包括邮箱密码验证和JWT令牌"
-```
-
-**发生什么**：
-- 系统分析需求
-- 自动生成任务计划（IMPL_PLAN.md）
-- 创建多个子任务（task JSON 文件）
-- 返回 workflow session ID（如 WFS-20251106-xxx）
-
-**你会看到**：
-- ✅ 规划完成
-- 📋 任务列表（如：task-001-user-model, task-002-login-api 等）
-- 📁 Session 目录创建
-
----
-
-### 步骤 2：执行实现
-
-```bash
-/workflow:execute
-```
-
-**发生什么**：
-- 系统自动发现最新的 workflow session
-- 按顺序执行所有任务
-- 使用 Codex 自动生成代码
-- 实时显示进度
-
-**你会看到**：
-- ⏳ Task 1 执行中...
-- ✅ Task 1 完成
-- ⏳ Task 2 执行中...
-- （依次执行所有任务）
-
----
-
-### 步骤 3：生成测试
-
-```bash
-/workflow:test-gen WFS-20251106-xxx
-```
-
-**发生什么**：
-- 分析实现的代码
-- 生成测试策略
-- 创建测试任务
-
----
-
-### 步骤 4：查看状态
-
-```bash
-/workflow:status
-```
-
-**发生什么**：
-- 显示当前工作流状态
-- 列出所有任务及其状态
-- 显示已完成/进行中/待执行任务
-
----
-
-## 🎓 其他常用场景
-
-### 场景 1：快速代码分析
-
-**需求**：理解陌生代码
-
-```bash
-# 分析整体架构
-/cli:analyze --tool gemini "分析项目架构和模块关系"
-
-# 追踪执行流程
-/cli:mode:code-analysis --tool gemini "追踪用户注册的执行流程"
-```
-
----
-
-### 场景 2：快速实现功能
-
-**需求**：实现一个简单功能
-
-```bash
-# 方式 1：完整工作流（推荐）
-/workflow:plan "添加用户头像上传功能"
-/workflow:execute
-
-# 方式 2：直接实现（快速）
-/cli:codex-execute "添加用户头像上传功能，支持图片裁剪和压缩"
-```
-
----
-
-### 场景 3：恢复之前的工作
-
-**需求**：继续上次的任务
-
-```bash
-# 查看可恢复的 session
-/workflow:status
-
-# 恢复特定 session
-/workflow:resume WFS-20251106-xxx
-```
-
----
-
-### 场景 4：生成文档
-
-**需求**：为模块生成文档
-
-```bash
-/memory:docs src/auth --tool gemini --mode full
-```
-
----
-
-## 💡 快速记忆法
-
-记住这个流程，就能完成大部分任务：
-
-```
-规划 → 执行 → 测试 → 完成
-  ↓      ↓      ↓
-plan → execute → test-gen
-```
-
-**扩展场景**：
-- 需要分析理解 → 使用 `/cli:analyze`
-- 需要精确控制 → 使用 `/cli:execute`
-- 需要快速实现 → 使用 `/cli:codex-execute`
-
----
-
-## 🆘 遇到问题？
-
-### 命令记不住？
-
-使用 Command Guide SKILL：
-```bash
-ccw  # 或 ccw-help
-```
-
-然后说：
-- "搜索 planning 命令"
-- "执行完 /workflow:plan 后做什么"
-- "我是新手，如何开始"
-
----
-
-### 执行失败？
-
-1. **查看错误信息**：仔细阅读错误提示
-2. **使用诊断模板**：`ccw-issue` → 选择 "诊断模板"
-3. **查看排查指南**：[Troubleshooting Guide](troubleshooting.md)
-
----
-
-### 想深入学习？
-
-- **工作流模式**：[Workflow Patterns](workflow-patterns.md) - 学习更多工作流组合
-- **CLI 工具使用**：[CLI Tools Guide](cli-tools-guide.md) - 了解 Gemini/Qwen/Codex 的高级用法
-- **完整命令列表**：查看 `index/essential-commands.json`
-
----
-
-## 🎯 下一步
-
-现在你已经掌握了基础！尝试：
-
-1. **实践基础工作流**：选择一个小功能，走一遍 plan → execute → test-gen 流程
-2. **探索 CLI 工具**：尝试用 `/cli:analyze` 分析你的代码库
-3. **学习工作流模式**：阅读 [Workflow Patterns](workflow-patterns.md) 了解更多高级用法
-
-**记住**：Claude DMS3 的设计理念是让你用自然语言描述需求，系统自动完成繁琐的工作。不要担心命令记不住，随时可以使用 `ccw` 获取帮助！
-
----
-
-**祝你使用愉快！** 🎉
-
-有任何问题，使用 `ccw-issue` 提交问题或查询帮助。

.claude/skills/command-guide/guides/index-structure.md

@@ -1,326 +0,0 @@
-# Index Structure Reference
-
-Complete documentation for command index files and their data structures.
-
-## Overview
-
-The command-guide skill uses 5 JSON index files to organize and query 69 commands across the Claude DMS3 workflow system.
-
-## Index Files
-
-### 1. `all-commands.json`
-
-**Purpose**: Complete catalog of all commands with full metadata
-
-**Use Cases**:
-- Full-text search across all commands
-- Detailed command queries
-- Batch operations
-- Reference lookup
-
-**Structure**:
-```json
-[
-  {
-    "name": "workflow:plan",
-    "description": "Orchestrate 5-phase planning workflow with quality gate",
-    "arguments": "[--agent] [--cli-execute] \"text description\"|file.md",
-    "category": "workflow",
-    "subcategory": "core",
-    "usage_scenario": "planning",
-    "difficulty": "Advanced",
-    "file_path": "workflow/plan.md"
-  },
-  ...
-]
-```
-
-**Fields**:
-- `name` (string): Command name (e.g., "workflow:plan")
-- `description` (string): Brief functional description
-- `arguments` (string): Parameter specification
-- `category` (string): Primary category (workflow/cli/memory/task)
-- `subcategory` (string|null): Secondary grouping if applicable
-- `usage_scenario` (string): Primary use case (planning/implementation/testing/etc.)
-- `difficulty` (string): Skill level (Beginner/Intermediate/Advanced)
-- `file_path` (string): Relative path to command file
-
-**Total Records**: 69 commands
-
----
-
-### 2. `by-category.json`
-
-**Purpose**: Hierarchical organization by category and subcategory
-
-**Use Cases**:
-- Browse commands by category
-- Category-specific listings
-- Hierarchical navigation
-- Understanding command organization
-
-**Structure**:
-```json
-{
-  "workflow": {
-    "core": [
-      {
-        "name": "workflow:plan",
-        "description": "...",
-        ...
-      }
-    ],
-    "brainstorm": [...],
-    "session": [...],
-    "tools": [...],
-    "ui-design": [...]
-  },
-  "cli": {
-    "mode": [...],
-    "core": [...]
-  },
-  "memory": [...],
-  "task": [...]
-}
-```
-
-**Category Breakdown**:
-- **workflow** (46 commands):
-  - core: 11 commands
-  - brainstorm: 12 commands
-  - session: 4 commands
-  - tools: 9 commands
-  - ui-design: 10 commands
-- **cli** (9 commands):
-  - mode: 3 commands
-  - core: 6 commands
-- **memory** (8 commands)
-- **task** (4 commands)
-- **general** (2 commands)
-
----
-
-### 3. `by-use-case.json`
-
-**Purpose**: Commands organized by practical usage scenarios
-
-**Use Cases**:
-- Task-oriented command discovery
-- "I want to do X" queries
-- Workflow planning
-- Learning paths
-
-**Structure**:
-```json
-{
-  "planning": [
-    {
-      "name": "workflow:plan",
-      "description": "...",
-      ...
-    },
-    ...
-  ],
-  "implementation": [...],
-  "testing": [...],
-  "documentation": [...],
-  "session-management": [...],
-  "general": [...]
-}
-```
-
-**Use Case Categories**:
-- **planning**: Architecture, task breakdown, design
-- **implementation**: Coding, development, execution
-- **testing**: Test generation, TDD, quality assurance
-- **documentation**: Docs generation, memory management
-- **session-management**: Workflow control, resumption
-- **general**: Utilities, versioning, prompt enhancement
-
----
-
-### 4. `essential-commands.json`
-
-**Purpose**: Curated list of 10-15 most frequently used commands
-
-**Use Cases**:
-- Quick reference for beginners
-- Onboarding new users
-- Common workflow starters
-- Cheat sheet
-
-**Structure**:
-```json
-[
-  {
-    "name": "enhance-prompt",
-    "description": "Context-aware prompt enhancement",
-    "arguments": "\"user input to enhance\"",
-    "category": "general",
-    "subcategory": null,
-    "usage_scenario": "general",
-    "difficulty": "Intermediate",
-    "file_path": "enhance-prompt.md"
-  },
-  ...
-]
-```
-
-**Selection Criteria**:
-- Frequency of use in common workflows
-- Value for beginners
-- Core functionality coverage
-- Minimal overlap in capabilities
-
-**Current Count**: 14 commands
-
-**List**:
-1. `enhance-prompt` - Prompt enhancement
-2. `version` - Version info
-3. `cli:analyze` - Quick codebase analysis
-4. `cli:chat` - Direct CLI interaction
-5. `cli:execute` - Auto-execution
-6. `cli:mode:plan` - Planning mode
-7. `task:breakdown` - Task decomposition
-8. `task:create` - Create tasks
-9. `task:execute` - Execute tasks
-10. `workflow:execute` - Run workflows
-11. `workflow:plan` - Plan workflows
-12. `workflow:review` - Review implementation
-13. `workflow:tdd-plan` - TDD planning
-14. `workflow:test-gen` - Test generation
-
----
-
-### 5. `command-relationships.json`
-
-**Purpose**: Mapping of command dependencies and common sequences
-
-**Use Cases**:
-- Next-step recommendations
-- Workflow pattern suggestions
-- Related command discovery
-- Smart navigation
-
-**Structure**:
-```json
-{
-  "workflow:plan": {
-    "related_commands": [
-      "workflow:execute",
-      "workflow:action-plan-verify"
-    ],
-    "next_steps": ["workflow:execute"],
-    "prerequisites": []
-  },
-  "workflow:execute": {
-    "related_commands": [
-      "workflow:status",
-      "workflow:resume",
-      "workflow:review"
-    ],
-    "next_steps": ["workflow:review", "workflow:status"],
-    "prerequisites": ["workflow:plan"]
-  },
-  ...
-}
-```
-
-**Fields**:
-- `related_commands` (array): Commonly used together
-- `next_steps` (array): Typical next commands
-- `prerequisites` (array): Usually run before this command
-
-**Relationship Types**:
-1. **Sequential**: A → B (plan → execute)
-2. **Alternatives**: A | B (execute OR codex-execute)
-3. **Built-in**: A includes B (plan auto-includes context-gather)
-
----
-
-## Query Patterns
-
-### Pattern 1: Keyword Search
-```javascript
-// Search by keyword in name or description
-const results = allCommands.filter(cmd =>
-  cmd.name.includes(keyword) ||
-  cmd.description.toLowerCase().includes(keyword.toLowerCase())
-);
-```
-
-### Pattern 2: Category Browse
-```javascript
-// Get all commands in a category
-const workflowCommands = byCategory.workflow;
-const coreWorkflow = byCategory.workflow.core;
-```
-
-### Pattern 3: Use-Case Lookup
-```javascript
-// Find commands for specific use case
-const planningCommands = byUseCase.planning;
-```
-
-### Pattern 4: Related Commands
-```javascript
-// Get next steps after a command
-const nextSteps = commandRelationships["workflow:plan"].next_steps;
-```
-
-### Pattern 5: Essential Commands
-```javascript
-// Get beginner-friendly quick reference
-const quickStart = essentialCommands;
-```
-
----
-
-## Maintenance
-
-### Regenerating Indexes
-
-When commands are added/modified/removed:
-
-```bash
-bash scripts/update-index.sh
-```
-
-The script will:
-1. Scan all .md files in commands/
-2. Extract metadata from YAML frontmatter
-3. Analyze command relationships
-4. Identify essential commands
-5. Generate all 5 index files
-
-### Validation Checklist
-
-After regeneration, verify:
-- [ ] All 5 JSON files are valid (no syntax errors)
-- [ ] Total command count matches (currently 69)
-- [ ] No missing fields in records
-- [ ] Category breakdown correct
-- [ ] Essential commands reasonable (10-15)
-- [ ] Relationships make logical sense
-
----
-
-## Performance Considerations
-
-**Index Sizes**:
-- `all-commands.json`: ~28KB
-- `by-category.json`: ~31KB
-- `by-use-case.json`: ~29KB
-- `command-relationships.json`: ~7KB
-- `essential-commands.json`: ~5KB
-
-**Total**: ~100KB (fast to load)
-
-**Query Speed**:
-- In-memory search: < 1ms
-- File read + parse: < 50ms
-- Recommended: Load indexes once, cache in memory
-
----
-
-**Last Updated**: 2025-01-06

.claude/skills/command-guide/guides/troubleshooting.md

@@ -1,92 +0,0 @@
-# 常见问题与解决方案
-
-在使用 Gemini CLI 的过程中，您可能会遇到一些问题。本指南旨在帮助您诊断和解决这些常见问题，确保您能顺利使用 CLI。
-
-## 1. 命令执行失败或未找到
-
-**问题描述**:
-- 您输入的命令没有响应，或者系统提示“命令未找到”。
-- 命令执行后出现错误信息，但您不理解其含义。
-
-**可能原因**:
-- 命令拼写错误。
-- CLI 未正确安装或环境变量配置不正确。
-- 命令所需的依赖项缺失。
-- 命令参数不正确或缺失。
-
-**解决方案**:
-1.  **检查拼写**: 仔细核对您输入的命令是否正确，包括命令名称和任何参数。
-2.  **查看帮助**: 使用 `gemini help` 或 `gemini [command-name] --help` 来查看命令的正确用法、可用参数和示例。
-3.  **验证安装**: 确保 Gemini CLI 已正确安装，并且其可执行文件路径已添加到系统的环境变量中。您可以尝试重新安装 CLI。
-4.  **检查日志**: CLI 通常会生成日志文件。查看这些日志可以提供更详细的错误信息，帮助您定位问题。
-5.  **更新 CLI**: 确保您使用的是最新版本的 Gemini CLI。旧版本可能存在已知错误，通过 `gemini version` 检查并更新。
-
-## 2. 权限问题
-
-**问题描述**:
-- CLI 尝试读取、写入或创建文件/目录时，提示“权限被拒绝”或类似错误。
-- 某些操作（如安装依赖、修改系统配置）失败。
-
-**可能原因**:
-- 当前用户没有足够的权限执行该操作。
-- 文件或目录被其他程序占用。
-
-**解决方案**:
-1.  **以管理员身份运行**: 尝试以管理员权限（Windows）或使用 `sudo`（Linux/macOS）运行您的终端或命令提示符。
-    ```bash
-    # Windows (在命令提示符或 PowerShell 中右键选择“以管理员身份运行”)
-    # Linux/macOS
-    sudo gemini [command]
-    ```
-2.  **检查文件/目录权限**: 确保您对目标文件或目录拥有读/写/执行权限。您可能需要使用 `chmod` (Linux/macOS) 或修改文件属性 (Windows) 来更改权限。
-3.  **关闭占用程序**: 确保没有其他程序正在使用您尝试访问的文件或目录。
-
-## 3. 配置问题
-
-**问题描述**:
-- CLI 行为异常，例如无法连接到 LLM 服务，或者某些功能无法正常工作。
-- 提示缺少 API 密钥或配置项。
-
-**可能原因**:
-- 配置文件（如 `.gemini.json` 或相关环境变量）设置不正确。
-- API 密钥过期或无效。
-- 网络连接问题导致无法访问外部服务。
-
-**解决方案**:
-1.  **检查配置文件**: 仔细检查 Gemini CLI 的配置文件（通常位于用户主目录或项目根目录）中的设置。确保所有路径、API 密钥和选项都正确无误。
-2.  **验证环境变量**: 确认所有必要的环境变量（如 `GEMINI_API_KEY`）都已正确设置。
-3.  **网络连接**: 检查您的网络连接是否正常，并确保没有防火墙或代理设置阻止 CLI 访问外部服务。
-4.  **重新初始化配置**: 对于某些配置问题，您可能需要使用 `gemini cli-init` 命令重新初始化 CLI 配置。
-    ```bash
-    gemini cli-init
-    ```
-
-## 4. 智能代理 (LLM) 相关问题
-
-**问题描述**:
-- 智能代理的响应质量不佳，不相关或不准确。
-- 代理响应速度慢，或提示达到速率限制。
-
-**可能原因**:
-- 提示不够清晰或缺乏上下文。
-- 选择了不适合当前任务的 LLM 模型。
-- LLM 服务提供商的速率限制或服务中断。
-
-**解决方案**:
-1.  **优化提示**: 尝试使用 `enhance-prompt` 命令来优化您的输入，提供更清晰、更具体的上下文信息。
-2.  **选择合适的工具**: 根据任务类型，使用 `--tool` 标志选择最合适的 LLM 模型（如 `codex` 适用于代码生成，`gemini` 适用于复杂推理）。
-    ```bash
-    gemini analyze --tool gemini "分析这个复杂算法"
-    ```
-3.  **检查 API 密钥和配额**: 确保您的 LLM 服务 API 密钥有效，并且没有超出使用配额。
-4.  **重试或等待**: 如果是速率限制或服务中断，请稍后重试或联系服务提供商。
-
-## 5. 寻求帮助
-
-如果以上解决方案都无法解决您的问题，您可以：
-
--   **查阅官方文档**: 访问 Gemini CLI 的官方文档获取更全面的信息。
--   **社区支持**: 在相关的开发者社区或论坛中提问。
--   **提交问题**: 如果您认为是 CLI 的 bug，请在项目的问题跟踪器中提交详细的问题报告。
-
-希望本指南能帮助您解决遇到的问题，让您更好地利用 Gemini CLI！

.claude/skills/command-guide/guides/ui-design-workflow-guide.md

@@ -1,316 +0,0 @@
-# UI Design Workflow Guide
-
-## Overview
-
-The UI Design Workflow System is a comprehensive suite of 11 autonomous commands designed to transform intent (prompts), references (images/URLs), or existing code into functional, production-ready UI prototypes. It employs a **Separation of Concerns** architecture, treating Style (visual tokens), Structure (layout templates), and Motion (animation tokens) as independent, mix-and-match components.
-
-## Command Taxonomy
-
-### 1. Orchestrators (High-Level Workflows)
-
-These commands automate end-to-end processes by chaining specialized sub-commands.
-
-- **`/workflow:ui-design:explore-auto`**: For creating *new* designs. Generates multiple style and layout variants from a prompt to explore design directions.
-- **`/workflow:ui-design:imitate-auto`**: For *replicating* existing designs. Creates design systems from local reference files (images, code) or text prompts.
-
-### 2. Core Extractors (Specialized Analysis)
-
-Agents dedicated to analyzing specific aspects of design.
-
-- **`/workflow:ui-design:style-extract`**: Extracts visual tokens (colors, typography, spacing, shadows) into `design-tokens.json`.
-- **`/workflow:ui-design:layout-extract`**: Extracts DOM structure and CSS layout rules into `layout-templates.json`.
-- **`/workflow:ui-design:animation-extract`**: Extracts motion patterns into `animation-tokens.json`.
-
-### 3. Input & Capture Utilities
-
-Tools for gathering raw data for analysis.
-
-- **`/workflow:ui-design:capture`**: High-speed batch screenshot capture for multiple URLs.
-- **`/workflow:ui-design:explore-layers`**: Interactive, depth-controlled capture (e.g., capturing modals, dropdowns, shadow DOM).
-- **`/workflow:ui-design:import-from-code`**: Bootstraps a design system by analyzing existing CSS/JS/HTML files.
-
-### 4. Assemblers & Integrators
-
-Tools for combining components and integrating results.
-
-- **`/workflow:ui-design:generate`**: Pure assembler that combines Layout Templates + Design Tokens into HTML/CSS prototypes.
-- **`/workflow:ui-design:update`**: Synchronizes generated design artifacts with the main project session for implementation planning.
-
----
-
-## Common Workflow Patterns
-
-### Workflow A: Exploratory Design (New Concepts)
-
-**Goal:** Create multiple design options for a new project from a text description.
-
-**Primary Command:** `explore-auto`
-
-**Steps:**
-
-1. **Initiate**: User runs `/workflow:ui-design:explore-auto --prompt "Modern fintech dashboard" --style-variants 3`
-2. **Style Extraction**: System generates 3 distinct visual design systems based on the prompt.
-3. **Layout Extraction**: System researches and generates responsive layout templates for a dashboard.
-4. **Assembly**: System generates a matrix of prototypes (3 styles × 1 layout = 3 prototypes).
-5. **Review**: User views `compare.html` to select the best direction.
-
-**Example (Non-Interactive - Default):**
-
-```bash
-/workflow:ui-design:explore-auto \
-  --prompt "Modern SaaS landing page with hero, features, pricing sections" \
-  --style-variants 3 \
-  --layout-variants 2 \
-  --session WFS-001
-```
-
-**Output:**
-- `design-tokens-v1.json`, `design-tokens-v2.json`, `design-tokens-v3.json` (3 style variants)
-- `layout-templates-v1.json`, `layout-templates-v2.json` (2 layout variants)
-- 6 HTML prototypes (3 × 2 combinations)
-- `compare.html` for side-by-side comparison
-
-**Example (Interactive Mode):**
-
-```bash
-/workflow:ui-design:explore-auto \
-  --prompt "Modern SaaS landing page with hero, features, pricing sections" \
-  --style-variants 5 \
-  --layout-variants 4 \
-  --interactive \
-  --session WFS-001
-```
-
-**Interactive Flow:**
-1. System generates 5 style concepts
-2. **User selects** 2-3 preferred styles (multi-select)
-3. System generates 4 layout concepts
-4. **User selects** 2 preferred layouts (multi-select)
-5. System generates only 4-6 final prototypes (selected combinations)
-
-
-
----
-
-### Workflow B: Design Replication (Imitation)
-
-**Goal:** Create a design system and prototypes based on existing local references.
-
-**Primary Command:** `imitate-auto`
-
-**Steps:**
-
-1. **Initiate**: User runs `/workflow:ui-design:imitate-auto --input "design-refs/*.png"` with local reference files
-2. **Input Detection**: System detects input type (images, code files, or text)
-3. **Extraction**: System extracts a unified design system (style, layout, animation) from the references.
-4. **Assembly**: System creates prototypes using the extracted system.
-
-**Example:**
-
-```bash
-# Using reference images
-/workflow:ui-design:imitate-auto \
-  --input "design-refs/*.png" \
-  --session WFS-002
-
-# Or importing from existing code
-/workflow:ui-design:imitate-auto \
-  --input "./src/components" \
-  --session WFS-002
-```
-
-**Output:**
-- `design-tokens.json` (unified style system)
-- `layout-templates.json` (page structures)
-- HTML prototypes based on the input references
-
----
-
-### Workflow C: Code-First Bootstrap
-
-**Goal:** Create a design system from an existing codebase.
-
-**Primary Command:** `import-from-code`
-
-**Steps:**
-
-1. **Initiate**: User runs `/workflow:ui-design:import-from-code --base-path ./src`
-2. **Analysis**: Parallel agents analyze CSS, JS, and HTML to find tokens, layouts, and animations.
-3. **Reporting**: Generates completeness reports and initial token files.
-4. **Supplement (Optional)**: Run `style-extract` or `layout-extract` to fill gaps identified in the reports.
-
-**Example:**
-
-```bash
-/workflow:ui-design:import-from-code \
-  --base-path ./src/components \
-  --session WFS-003
-```
-
-**Output:**
-- `design-tokens.json` (extracted from CSS variables, theme files)
-- `layout-templates.json` (extracted from component structures)
-- `completeness-report.md` (gaps and recommendations)
-- `import-summary.json` (statistics and findings)
-
----
-
-## Architecture & Best Practices
-
-### Separation of Concerns
-
-**Always keep design tokens separate from layout templates:**
-
-- `design-tokens.json` (Style) - Colors, typography, spacing, shadows
-- `layout-templates.json` (Structure) - DOM hierarchy, CSS layout rules
-- `animation-tokens.json` (Motion) - Transitions, keyframes, timing functions
-
-
-
-### Token-First CSS
-
-Generated CSS should primarily use CSS custom properties:
-
-```css
-/* Good - Token-based */
-.button {
-  background: var(--color-primary);
-  padding: var(--spacing-md);
-  border-radius: var(--radius-md);
-}
-
-/* Avoid - Hardcoded */
-.button {
-  background: #3b82f6;
-  padding: 16px;
-  border-radius: 8px;
-}
-```
-
-### Style-Centric Batching
-
-For high-volume generation:
-- Group tasks by style to minimize context switching
-- Use parallel generation with multiple targets
-- Reuse existing layout inspirations
-
-### Input Quality Guidelines
-
-**For Prompts:**
-- Specify the desired *vibe* (e.g., "minimalist, high-contrast")
-- Specify the *targets* (e.g., "dashboard, settings page")
-- Include functional requirements (e.g., "responsive, mobile-first")
-
-**For Local References:**
-- Use high-quality reference images (PNG, JPG)
-- Organize files in accessible directories
-- For code imports, ensure files are properly structured (CSS, JS, HTML)
-
----
-
-## Advanced Usage
-
-### Multi-Session Workflows
-
-You can run UI design workflows within an existing workflow session:
-
-```bash
-# 1. Start a workflow session
-/workflow:session:start --new
-
-# 2. Run exploratory design
-/workflow:ui-design:explore-auto --prompt "E-commerce checkout flow" --session <session-id>
-
-# 3. Update main session with design artifacts
-/workflow:ui-design:update --session <session-id> --selected-prototypes "v1,v2"
-```
-
-### Combining Workflows
-
-**Example: Imitation + Custom Extraction**
-
-```bash
-# 1. Import design from local references
-/workflow:ui-design:imitate-auto --input "design-refs/*.png"
-
-# 2. Extract additional layouts and generate prototypes
-/workflow:ui-design:layout-extract --targets "new-page-1,new-page-2"
-/workflow:ui-design:generate
-```
-
-### Deep Interactive Capture
-
-For complex UIs with overlays, modals, or dynamic content:
-
-```bash
-/workflow:ui-design:explore-layers \
-  --url https://complex-app.com \
-  --depth 3 \
-  --session WFS-005
-```
-
----
-
-## Troubleshooting
-
-| Issue | Likely Cause | Resolution |
-|-------|--------------|------------|
-| **Missing Design Tokens** | `style-extract` failed or wasn't run | Run `/workflow:ui-design:style-extract` manually or check logs |
-| **Inaccurate Layouts** | Complex DOM structure not captured | Use `--urls` in `layout-extract` for Chrome DevTools analysis |
-| **Empty Screenshots** | Anti-bot measures or timeout | Use `explore-layers` interactive mode or increase timeout |
-| **Generation Stalls** | Too many concurrent tasks | System defaults to max 6 parallel tasks; check resources |
-| **Integration Failures** | Session ID mismatch or missing markers | Ensure `--session <id>` matches active workflow session |
-| **Low Quality Tokens** | Insufficient reference material | Provide multiple reference images/URLs for better token extraction |
-| **Inconsistent Styles** | Multiple token files without merge | Use single unified `design-tokens.json` or explicit variants |
-
----
-
-## Command Reference Quick Links
-
-### Orchestrators
-- `/workflow:ui-design:explore-auto` - Create new designs from prompts
-- `/workflow:ui-design:imitate-auto` - Replicate existing designs
-
-### Extractors
-- `/workflow:ui-design:style-extract` - Extract visual design tokens
-- `/workflow:ui-design:layout-extract` - Extract layout structures
-- `/workflow:ui-design:animation-extract` - Extract motion patterns
-
-### Utilities
-- `/workflow:ui-design:capture` - Batch screenshot capture
-- `/workflow:ui-design:explore-layers` - Interactive deep capture
-- `/workflow:ui-design:import-from-code` - Bootstrap from existing code
-- `/workflow:ui-design:generate` - Assemble prototypes from tokens
-- `/workflow:ui-design:update` - Integrate with workflow sessions
-
----
-
-## Performance Optimization
-
-### Parallel Execution
-
-The system is designed to run extraction phases in parallel:
-- Animation and layout extraction can run concurrently
-- Multiple target generation runs in parallel (default: max 6)
-- Style variant generation is parallelized
-
-### Reuse Intermediates
-
-- Generation commands reuse existing layout inspirations
-- Cached screenshots avoid redundant captures
-- Token files can be versioned and reused
-
-### Resource Management
-
-- Each agent task consumes memory and CPU
-- Monitor system resources with large batch operations
-- Consider splitting large batches into smaller chunks
-
----
-
-## Related Guides
-
-- **Getting Started** - Basic workflow concepts
-- **Workflow Patterns** - General workflow guidance
-- **CLI Tools Guide** - CLI integration strategies
-- **Troubleshooting** - Common issues and solutions

.claude/skills/command-guide/guides/workflow-patterns.md

@@ -1,662 +0,0 @@
-# 常见工作流模式
-
-> 学习如何组合命令完成复杂任务，提升开发效率
-
-## 🎯 什么是工作流？
-
-工作流是**一系列命令的组合**，用于完成特定的开发目标。Claude DMS3 提供了多种工作流模式，覆盖从规划到测试的完整开发周期。
-
-**核心概念**：
-- **工作流（Workflow）**：一组相关任务的集合
-- **任务（Task）**：独立的工作单元，有明确的输入和输出
-- **Session**：工作流的执行实例，记录所有任务状态
-- **上下文（Context）**：任务执行所需的代码、文档、配置等信息
-
----
-
-## 💡 Pattern 0: 头脑风暴（从0到1的第一步）
-
-**⚠️ 重要**：这是**从0到1开发的起点**！在开始编码之前，通过多角色头脑风暴明确需求、技术选型和架构决策。
-
-**适用场景**：
-- 全新项目启动，需求和技术方案不明确
-- 重大功能开发，涉及多个技术领域和权衡
-- 架构决策，需要多角色视角分析
-
-**流程**：话题分析 → 角色选择 → 角色问答 → 冲突解决 → 生成指导文档
-
-### 模式 A：交互式头脑风暴（推荐）
-
-**特点**：通过问答交互，逐步明确需求和决策
-
-```bash
-# 步骤 1：启动头脑风暴
-/workflow:brainstorm:artifacts "
-GOAL: 实现实时协作编辑平台
-SCOPE: 支持100+用户同时在线，低延迟(<100ms)，冲突自动解决
-CONTEXT: MVP阶段，3个月上线，团队5人（2前端+2后端+1全栈）
-" --count 3
-
-# 系统输出 Phase 0：自动收集项目上下文
-# ✅ 分析现有代码库结构
-# ✅ 加载相关文档
-# ✅ 识别技术栈和依赖
-
-# 系统输出 Phase 1：意图分析（2-4个问题）
-# 【问题1 - 核心挑战】实时协作的主要技术挑战？
-# a) 实时数据同步
-# b) 可扩展性架构
-# c) 冲突解决机制
-# 【问题2 - 优先级】MVP阶段最关注？
-# a) 功能完整性
-# b) 用户体验
-# c) 系统稳定性
-# 请回答 (格式: 1a 2c)：
-
-# 用户输入：1c 2b
-
-# 系统输出 Phase 2：角色选择（推荐 count+2 个角色）
-# 【角色选择】请选择 3 个角色参与头脑风暴
-# a) system-architect (系统架构师) - 实时同步架构设计
-# b) ui-designer (UI设计师) - 协作界面用户体验
-# c) product-manager (产品经理) - 功能优先级决策
-# d) data-architect (数据架构师) - 数据同步模型设计
-# e) ux-expert (UX专家) - 多用户协作交互流程
-# 请输入选择 (格式: 2acd 或 2a 2c 2d)：
-
-# 用户输入：2acd
-
-# 系统输出 Phase 3：角色问题（每个角色 3-4 个问题）
-# ===== system-architect 问题 =====
-# 【问题1】100+ 用户实时状态同步方案？
-# a) Event Sourcing - 完整事件历史，易于回溯
-# b) 集中式状态管理 - 简单直接，适合MVP
-# c) CRDT - 自动冲突解决，分布式友好
-# 【问题2】低延迟通信协议选择？
-# ...
-# 请回答：
-
-# 用户输入：1c 2a 3b 4c
-
-# 系统输出 Phase 4：冲突检测和解决
-# 【冲突1】CRDT 与 UI 回滚期望冲突
-# Background: system-architect 选择 CRDT，但 ui-designer 期望回滚UI
-# a) 采用 CRDT，显示合并状态
-# b) 切换到 OT 算法支持回滚
-# c) 混合方案：CRDT + 本地撤销栈
-# ...
-
-# 系统输出 Phase 5：生成指导文档
-# ✅ 生成 guidance-specification.md
-# ✅ 记录所有决策和理由
-# ✅ 标注冲突解决方案
-# 📁 文件位置：.workflow/WFS-realtime-collab/.brainstorming/guidance-specification.md
-
-# 步骤 2：查看生成的指导文档
-cat .workflow/WFS-*//.brainstorming/guidance-specification.md
-```
-
-### 模式 B：自动并行头脑风暴（快速）
-
-**特点**：自动选择角色，并行执行，快速生成多角色分析
-
-```bash
-# 步骤 1：一键启动并行头脑风暴
-/workflow:brainstorm:auto-parallel "
-GOAL: 实现支付处理模块
-SCOPE: 支持微信/支付宝/银行卡，日交易10万笔，99.99%可用性
-CONTEXT: 金融合规要求，PCI DSS认证，风控系统集成
-" --count 4
-
-# 系统输出：
-# ✅ Phase 0: 收集项目上下文
-# ✅ Phase 1-2: artifacts 交互式框架生成
-# ⏳ Phase 3: 4个角色并行分析
-#   - system-architect → 分析中...
-#   - data-architect → 分析中...
-#   - product-manager → 分析中...
-#   - subject-matter-expert → 分析中...
-# ✅ Phase 4: synthesis 综合分析
-# 📁 输出文件：
-#   - .brainstorming/guidance-specification.md (框架)
-#   - system-architect/analysis.md
-#   - data-architect/analysis.md
-#   - product-manager/analysis.md
-#   - subject-matter-expert/analysis.md
-#   - synthesis/final-recommendations.md
-
-# 步骤 2：查看综合建议
-cat .workflow/WFS-*//.brainstorming/synthesis/final-recommendations.md
-```
-
-### 模式 C：单角色深度分析（特定领域）
-
-**特点**：针对特定领域问题，调用单个角色深度分析
-
-```bash
-# 系统架构分析
-/workflow:brainstorm:system-architect "API 网关架构设计，支持10万QPS，微服务集成"
-
-# UI 设计分析
-/workflow:brainstorm:ui-designer "管理后台界面设计，复杂数据展示，操作效率优先"
-
-# 数据架构分析
-/workflow:brainstorm:data-architect "分布式数据存储方案，MySQL+Redis+ES 组合"
-```
-
-### 关键点
-
-1. **Phase 0 自动上下文收集**：
-   - 自动分析现有代码库、文档、技术栈
-   - 识别潜在冲突和集成点
-   - 为后续问题生成提供上下文
-
-2. **动态问题生成**：
-   - 基于话题关键词和项目上下文生成问题
-   - 不使用预定义模板
-   - 问题直接针对你的具体场景
-
-3. **智能角色推荐**：
-   - 基于话题分析推荐最相关的角色
-   - 推荐 count+2 个角色供选择
-   - 每个角色都有基于话题的推荐理由
-
-4. **输出物**：
-   - `guidance-specification.md` - 确认的指导规范（决策、理由、集成点）
-   - `{role}/analysis.md` - 各角色详细分析（仅 auto-parallel 模式）
-   - `synthesis/final-recommendations.md` - 综合建议（仅 auto-parallel 模式）
-
-5. **下一步**：
-   - 头脑风暴完成后，使用 `/workflow:plan` 基于指导文档生成实施计划
-   - 指导文档作为规划和实现的权威参考
-
-### 使用场景对比
-
-| 场景 | 推荐模式 | 原因 |
-|------|---------|------|
-| 全新项目启动 | 交互式 (artifacts) | 需要充分澄清需求和约束 |
-| 重大架构决策 | 交互式 (artifacts) | 需要深入讨论权衡 |
-| 快速原型验证 | 自动并行 (auto-parallel) | 快速获得多角色建议 |
-| 特定技术问题 | 单角色 (specific role) | 专注某个领域深度分析 |
-
----
-
-## 📋 Pattern 1: 规划→执行（最常用）
-
-**适用场景**：实现新功能、新模块
-
-**流程**：规划 → 执行 → 查看状态
-
-### 完整示例
-
-```bash
-# 步骤 1：规划任务
-/workflow:plan --agent "实现用户认证模块"
-
-# 系统输出：
-# ✅ 规划完成
-# 📁 Session: WFS-20251106-123456
-# 📋 生成 5 个任务
-
-# 步骤 2：执行任务
-/workflow:execute
-
-# 系统输出：
-# ⏳ 执行 task-001-user-model...
-# ✅ task-001 完成
-# ⏳ 执行 task-002-login-api...
-# ...
-
-# 步骤 3：查看状态
-/workflow:status
-
-# 系统输出：
-# Session: WFS-20251106-123456
-# Total: 5 | Completed: 5 | Pending: 0
-```
-
-**关键点**：
-- `--agent` 参数使用 AI 生成更详细的计划
-- 系统自动发现最新 session，无需手动指定
-- 所有任务按依赖顺序自动执行
-
----
-
-## 🧪 Pattern 2: TDD测试驱动开发
-
-**适用场景**：需要高质量代码和测试覆盖
-
-**流程**：TDD规划 → 执行（红→绿→重构）→ 验证
-
-### 完整示例
-
-```bash
-# 步骤 1：TDD 规划
-/workflow:tdd-plan --agent "实现购物车功能"
-
-# 系统输出：
-# ✅ TDD 任务链生成
-# 📋 Red-Green-Refactor 周期：
-#   - task-001-cart-tests (RED)
-#   - task-002-cart-implement (GREEN)
-#   - task-003-cart-refactor (REFACTOR)
-
-# 步骤 2：执行 TDD 周期
-/workflow:execute
-
-# 系统会自动：
-# 1. 生成失败的测试（RED）
-# 2. 实现代码让测试通过（GREEN）
-# 3. 重构代码（REFACTOR）
-
-# 步骤 3：验证 TDD 合规性
-/workflow:tdd-verify
-
-# 系统输出：
-# ✅ TDD 周期完整
-# ✅ 测试覆盖率: 95%
-# ✅ Red-Green-Refactor 合规
-```
-
-**关键点**：
-- TDD 模式自动生成测试优先的任务链
-- 每个任务有依赖关系，确保正确的顺序
-- 验证命令检查 TDD 合规性
-
----
-
-## 🔄 Pattern 3: 测试生成
-
-**适用场景**：已有代码，需要生成测试
-
-**流程**：分析代码 → 生成测试策略 → 执行测试生成
-
-### 完整示例
-
-```bash
-# 步骤 1：实现功能（已完成）
-# 假设已经完成实现，session 为 WFS-20251106-123456
-
-# 步骤 2：生成测试
-/workflow:test-gen WFS-20251106-123456
-
-# 系统输出：
-# ✅ 分析实现代码
-# ✅ 生成测试策略
-# 📋 创建测试任务：WFS-test-20251106-789
-
-# 步骤 3：执行测试生成
-/workflow:test-cycle-execute --resume-session WFS-test-20251106-789
-
-# 系统输出：
-# ⏳ 生成测试用例...
-# ⏳ 执行测试...
-# ❌ 3 tests failed
-# ⏳ 修复失败测试...
-# ✅ All tests passed
-```
-
-**关键点**：
-- `test-gen` 分析现有代码生成测试
-- `test-cycle-execute` 自动生成→测试→修复循环
-- 最多迭代 N 次直到所有测试通过
-
----
-
-## 🎨 Pattern 4: UI 设计工作流
-
-**适用场景**：基于设计稿或现有网站实现 UI
-
-**流程**：提取样式 → 提取布局 → 生成原型 → 更新
-
-### 完整示例
-
-```bash
-# 步骤 1：提取设计样式
-/workflow:ui-design:style-extract \
-  --images "design/*.png" \
-  --mode imitate \
-  --variants 3
-
-# 系统输出：
-# ✅ 提取颜色系统
-# ✅ 提取字体系统
-# ✅ 生成 3 个样式变体
-
-# 步骤 2：提取页面布局
-/workflow:ui-design:layout-extract \
-  --urls "https://example.com/dashboard" \
-  --device-type responsive
-
-# 系统输出：
-# ✅ 提取布局结构
-# ✅ 识别组件层次
-# ✅ 生成响应式布局
-
-# 步骤 3：生成 UI 原型
-/workflow:ui-design:generate \
-  --style-variants 2 \
-  --layout-variants 2
-
-# 系统输出：
-# ✅ 生成 4 个原型组合
-# 📁 输出：.workflow/ui-design/prototypes/
-
-# 步骤 4：更新最终版本
-/workflow:ui-design:update \
-  --session ui-session-id \
-  --selected-prototypes "proto-1,proto-3"
-
-# 系统输出：
-# ✅ 应用最终设计系统
-# ✅ 更新所有原型
-```
-
-**关键点**：
-- 支持从图片或 URL 提取设计
-- 可生成多个变体供选择
-- 最终更新使用确定的设计系统
-
----
-
-## 🔍 Pattern 5: 代码分析→重构
-
-**适用场景**：优化现有代码，提高可维护性
-
-**流程**：分析现状 → 制定计划 → 执行重构 → 生成测试
-
-### 完整示例
-
-```bash
-# 步骤 1：分析代码质量
-/cli:analyze --tool gemini --cd src/auth \
-  "评估认证模块的代码质量、可维护性和潜在问题"
-
-# 系统输出：
-# ✅ 识别 3 个设计问题
-# ✅ 发现 5 个性能瓶颈
-# ✅ 建议 7 项改进
-
-# 步骤 2：制定重构计划
-/cli:mode:plan --tool gemini --cd src/auth \
-  "基于上述分析，制定认证模块重构方案"
-
-# 系统输出：
-# ✅ 重构计划生成
-# 📋 包含 8 个重构任务
-
-# 步骤 3：执行重构
-/cli:execute --tool codex \
-  "按照重构计划执行认证模块重构"
-
-# 步骤 4：生成测试确保正确性
-/workflow:test-gen WFS-refactor-session-id
-```
-
-**关键点**：
-- Gemini 用于分析和规划（理解）
-- Codex 用于执行实现（重构）
-- 重构后必须生成测试验证
-
----
-
-## 📚 Pattern 6: 文档生成
-
-**适用场景**：为项目或模块生成文档
-
-**流程**：分析代码 → 生成文档 → 更新索引
-
-### 完整示例
-
-```bash
-# 方式 1：为单个模块生成文档
-/memory:docs src/auth --tool gemini --mode full
-
-# 系统输出：
-# ✅ 分析模块结构
-# ✅ 生成 CLAUDE.md
-# ✅ 生成 API 文档
-# ✅ 生成使用指南
-
-# 方式 2：更新所有模块文档
-/memory:update-full --tool gemini
-
-# 系统输出：
-# ⏳ 按层级更新文档...
-# ✅ Layer 3: 12 modules updated
-# ✅ Layer 2: 5 modules updated
-# ✅ Layer 1: 2 modules updated
-
-# 方式 3：只更新修改过的模块
-/memory:update-related --tool gemini
-
-# 系统输出：
-# ✅ 检测 git 变更
-# ✅ 更新 3 个相关模块
-```
-
-**关键点**：
-- `--mode full` 生成完整文档
-- `update-full` 适用于初始化或大规模更新
-- `update-related` 适用于日常增量更新
-
----
-
-## 🔄 Pattern 7: 恢复和继续
-
-**适用场景**：中断后继续工作，或修复失败的任务
-
-**流程**：查看状态 → 恢复 session → 继续执行
-
-### 完整示例
-
-```bash
-# 步骤 1：查看所有 session
-/workflow:status
-
-# 系统输出：
-# Session: WFS-20251106-123456 (5/10 completed)
-# Session: WFS-20251105-234567 (10/10 completed)
-
-# 步骤 2：恢复特定 session
-/workflow:resume WFS-20251106-123456
-
-# 系统输出：
-# ✅ Session 恢复
-# 📋 5/10 tasks completed
-# ⏳ 待执行: task-006, task-007, ...
-
-# 步骤 3：继续执行
-/workflow:execute --resume-session WFS-20251106-123456
-
-# 系统输出：
-# ⏳ 继续执行 task-006...
-# ✅ task-006 完成
-# ...
-```
-
-**关键点**：
-- 所有 session 状态都被保存
-- 可以随时恢复中断的工作流
-- 恢复时自动分析进度和待办任务
-
----
-
-## 🎯 Pattern 8: 快速实现（Codex YOLO）
-
-**适用场景**：快速实现简单功能，跳过规划
-
-**流程**：直接执行 → 完成
-
-### 完整示例
-
-```bash
-# 一键实现功能
-/cli:codex-execute --verify-git \
-  "实现用户头像上传功能：
-  - 支持 jpg/png 格式
-  - 自动裁剪为 200x200
-  - 压缩到 100KB 以下
-  - 上传到 OSS
-  "
-
-# 系统输出：
-# ⏳ 分析需求...
-# ⏳ 生成代码...
-# ⏳ 集成现有代码...
-# ✅ 功能实现完成
-# 📁 修改文件:
-#   - src/api/upload.ts
-#   - src/utils/image.ts
-```
-
-**关键点**：
-- 适合简单、独立的功能
-- `--verify-git` 确保 git 状态干净
-- 自动分析需求并完整实现
-
----
-
-## 🤝 Pattern 9: 多工具协作
-
-**适用场景**：复杂任务需要多个 AI 工具配合
-
-**流程**：Gemini 分析 → Gemini/Qwen 规划 → Codex 实现
-
-### 完整示例
-
-```bash
-# 步骤 1：Gemini 深度分析
-/cli:analyze --tool gemini \
-  "分析支付模块的安全性和性能问题"
-
-# 步骤 2：多工具讨论方案
-/cli:discuss-plan --topic "支付模块重构方案" --rounds 3
-
-# 系统输出：
-# Round 1:
-#   Gemini: 建议方案 A（关注安全）
-#   Codex: 建议方案 B（关注性能）
-# Round 2:
-#   Gemini: 综合分析...
-#   Codex: 技术实现评估...
-# Round 3:
-#   最终方案: 方案 C（安全+性能）
-
-# 步骤 3：Codex 执行实现
-/cli:execute --tool codex "按照方案 C 重构支付模块"
-```
-
-**关键点**：
-- `discuss-plan` 让多个 AI 讨论方案
-- 每个工具贡献自己的专长
-- 最终选择综合最优方案
-
----
-
-## 📊 工作流选择指南
-
-**核心区分**：从0到1 vs 功能新增
-- **从0到1**：全新项目、新产品、重大架构决策 → **必须头脑风暴**
-- **功能新增**：已有项目中添加功能 → **可直接规划**
-
-```mermaid
-graph TD
-    A[我要做什么?] --> B{项目阶段?}
-
-    B -->|从0到1<br/>全新项目/产品| Z[💡头脑风暴<br/>必经阶段]
-    B -->|功能新增<br/>已有项目| C{任务类型?}
-
-    Z --> Z1[/workflow:brainstorm:artifacts<br/>或<br/>/workflow:brainstorm:auto-parallel]
-    Z1 --> Z2[⬇️ 生成指导文档]
-    Z2 --> C
-
-    C -->|新功能| D[规划→执行]
-    C -->|需要测试| E{代码是否存在?}
-    C -->|UI开发| F[UI设计工作流]
-    C -->|代码优化| G[分析→重构]
-    C -->|生成文档| H[文档生成]
-    C -->|快速实现| I[Codex YOLO]
-
-    E -->|不存在| J[TDD工作流]
-    E -->|已存在| K[测试生成]
-
-    D --> L[/workflow:plan<br/>↓<br/>/workflow:execute]
-    J --> M[/workflow:tdd-plan<br/>↓<br/>/workflow:execute]
-    K --> N[/workflow:test-gen<br/>↓<br/>/workflow:test-cycle-execute]
-    F --> O[/workflow:ui-design:*]
-    G --> P[/cli:analyze<br/>↓<br/>/cli:mode:plan<br/>↓<br/>/cli:execute]
-    H --> Q[/memory:docs]
-    I --> R[/cli:codex-execute]
-```
-
-**说明**：
-- **从0到1场景**：创业项目、新产品线、系统重构 → 头脑风暴明确方向后再规划
-- **功能新增场景**：现有系统添加模块、优化现有功能 → 直接进入规划或分析
-
----
-
-## 💡 最佳实践
-
-### ✅ 推荐做法
-
-1. **复杂任务使用完整工作流**
-   ```bash
-   /workflow:plan → /workflow:execute → /workflow:test-gen
-   ```
-
-2. **简单任务使用 Codex YOLO**
-   ```bash
-   /cli:codex-execute "快速实现xxx"
-   ```
-
-3. **重要代码使用 TDD**
-   ```bash
-   /workflow:tdd-plan → /workflow:execute → /workflow:tdd-verify
-   ```
-
-4. **定期更新文档**
-   ```bash
-   /memory:update-related  # 每次提交前
-   ```
-
-5. **善用恢复功能**
-   ```bash
-   /workflow:status → /workflow:resume
-   ```
-
----
-
-### ❌ 避免做法
-
-1. **⚠️ 不要在从0到1场景跳过头脑风暴**
-   - ❌ 全新项目直接 `/workflow:plan`
-   - ✅ 先 `/workflow:brainstorm:artifacts` 明确方向再规划
-
-2. **不要跳过规划直接执行复杂任务**
-   - ❌ 直接 `/cli:execute` 实现复杂功能
-   - ✅ 先 `/workflow:plan` 再 `/workflow:execute`
-
-3. **不要忽略测试**
-   - ❌ 实现完成后不生成测试
-   - ✅ 使用 `/workflow:test-gen` 生成测试
-
-4. **不要遗忘文档**
-   - ❌ 代码实现后忘记更新文档
-   - ✅ 使用 `/memory:update-related` 自动更新
-
----
-
-## 🔗 相关资源
-
-- **快速入门**：[Getting Started](getting-started.md) - 5分钟上手
-- **CLI 工具**：[CLI Tools Guide](cli-tools-guide.md) - Gemini/Qwen/Codex 详解
-- **UI设计工作流**：[UI Design Workflow Guide](ui-design-workflow-guide.md) - UI设计完整指南
-- **问题排查**：[Troubleshooting](troubleshooting.md) - 常见问题解决
-- **完整命令列表**：查看 `index/all-commands.json`
-
----
-
-**最后更新**: 2025-11-06
-
-记住：选择合适的工作流模式，事半功倍！不确定用哪个？使用 `ccw` 询问 Command Guide！

.claude/skills/command-guide/index/all-commands.json

@@ -1,772 +0,0 @@
-[
-  {
-    "name": "cli-init",
-    "command": "/cli:cli-init",
-    "description": "Generate .gemini/ and .qwen/ config directories with settings.json and ignore files based on workspace technology detection",
-    "arguments": "[--tool gemini|qwen|all] [--output path] [--preview]",
-    "category": "cli",
-    "subcategory": null,
-    "usage_scenario": "general",
-    "difficulty": "Intermediate",
-    "file_path": "cli/cli-init.md"
-  },
-  {
-    "name": "enhance-prompt",
-    "command": "/enhance-prompt",
-    "description": "Enhanced prompt transformation using session memory and intent analysis with --enhance flag detection",
-    "arguments": "user input to enhance",
-    "category": "general",
-    "subcategory": null,
-    "usage_scenario": "general",
-    "difficulty": "Intermediate",
-    "file_path": "enhance-prompt.md"
-  },
-  {
-    "name": "code-map-memory",
-    "command": "/memory:code-map-memory",
-    "description": "3-phase orchestrator: parse feature keyword → cli-explore-agent analyzes (Deep Scan dual-source) → orchestrator generates Mermaid docs + SKILL package (skips phase 2 if exists)",
-    "arguments": "\\\"feature-keyword\\\" [--regenerate] [--tool <gemini|qwen>]",
-    "category": "memory",
-    "subcategory": null,
-    "usage_scenario": "documentation",
-    "difficulty": "Intermediate",
-    "file_path": "memory/code-map-memory.md"
-  },
-  {
-    "name": "docs-full-cli",
-    "command": "/memory:docs-full-cli",
-    "description": "Generate full project documentation using CLI execution (Layer 3→1) with batched agents (4 modules/agent) and gemini→qwen→codex fallback, <20 modules uses direct parallel",
-    "arguments": "[path] [--tool <gemini|qwen|codex>]",
-    "category": "memory",
-    "subcategory": null,
-    "usage_scenario": "documentation",
-    "difficulty": "Intermediate",
-    "file_path": "memory/docs-full-cli.md"
-  },
-  {
-    "name": "docs-related-cli",
-    "command": "/memory:docs-related-cli",
-    "description": "Generate/update documentation for git-changed modules using CLI execution with batched agents (4 modules/agent) and gemini→qwen→codex fallback, <15 modules uses direct parallel",
-    "arguments": "[--tool <gemini|qwen|codex>]",
-    "category": "memory",
-    "subcategory": null,
-    "usage_scenario": "documentation",
-    "difficulty": "Intermediate",
-    "file_path": "memory/docs-related-cli.md"
-  },
-  {
-    "name": "docs",
-    "command": "/memory:docs",
-    "description": "Plan documentation workflow with dynamic grouping (≤10 docs/task), generates IMPL tasks for parallel module trees, README, ARCHITECTURE, and HTTP API docs",
-    "arguments": "[path] [--tool <gemini|qwen|codex>] [--mode <full|partial>] [--cli-execute]",
-    "category": "memory",
-    "subcategory": null,
-    "usage_scenario": "documentation",
-    "difficulty": "Intermediate",
-    "file_path": "memory/docs.md"
-  },
-  {
-    "name": "load-skill-memory",
-    "command": "/memory:load-skill-memory",
-    "description": "Activate SKILL package (auto-detect from paths/keywords or manual) and intelligently load documentation based on task intent keywords",
-    "arguments": "[skill_name] \\\"task intent description\\",
-    "category": "memory",
-    "subcategory": null,
-    "usage_scenario": "documentation",
-    "difficulty": "Intermediate",
-    "file_path": "memory/load-skill-memory.md"
-  },
-  {
-    "name": "load",
-    "command": "/memory:load",
-    "description": "Delegate to universal-executor agent to analyze project via Gemini/Qwen CLI and return JSON core content package for task context",
-    "arguments": "[--tool gemini|qwen] \\\"task context description\\",
-    "category": "memory",
-    "subcategory": null,
-    "usage_scenario": "general",
-    "difficulty": "Intermediate",
-    "file_path": "memory/load.md"
-  },
-  {
-    "name": "skill-memory",
-    "command": "/memory:skill-memory",
-    "description": "4-phase autonomous orchestrator: check docs → /memory:docs planning → /workflow:execute → generate SKILL.md with progressive loading index (skips phases 2-3 if docs exist)",
-    "arguments": "[path] [--tool <gemini|qwen|codex>] [--regenerate] [--mode <full|partial>] [--cli-execute]",
-    "category": "memory",
-    "subcategory": null,
-    "usage_scenario": "documentation",
-    "difficulty": "Intermediate",
-    "file_path": "memory/skill-memory.md"
-  },
-  {
-    "name": "style-skill-memory",
-    "command": "/memory:style-skill-memory",
-    "description": "Generate SKILL memory package from style reference for easy loading and consistent design system usage",
-    "arguments": "[package-name] [--regenerate]",
-    "category": "memory",
-    "subcategory": null,
-    "usage_scenario": "documentation",
-    "difficulty": "Intermediate",
-    "file_path": "memory/style-skill-memory.md"
-  },
-  {
-    "name": "tech-research",
-    "command": "/memory:tech-research",
-    "description": "3-phase orchestrator: extract tech stack → Exa research → generate path-conditional rules (auto-loaded by Claude Code)",
-    "arguments": "[session-id | tech-stack-name] [--regenerate] [--tool <gemini|qwen>]",
-    "category": "memory",
-    "subcategory": null,
-    "usage_scenario": "general",
-    "difficulty": "Intermediate",
-    "file_path": "memory/tech-research.md"
-  },
-  {
-    "name": "update-full",
-    "command": "/memory:update-full",
-    "description": "Update all CLAUDE.md files using layer-based execution (Layer 3→1) with batched agents (4 modules/agent) and gemini→qwen→codex fallback, <20 modules uses direct parallel",
-    "arguments": "[--tool gemini|qwen|codex] [--path <directory>]",
-    "category": "memory",
-    "subcategory": null,
-    "usage_scenario": "general",
-    "difficulty": "Intermediate",
-    "file_path": "memory/update-full.md"
-  },
-  {
-    "name": "update-related",
-    "command": "/memory:update-related",
-    "description": "Update CLAUDE.md for git-changed modules using batched agent execution (4 modules/agent) with gemini→qwen→codex fallback, <15 modules uses direct execution",
-    "arguments": "[--tool gemini|qwen|codex]",
-    "category": "memory",
-    "subcategory": null,
-    "usage_scenario": "general",
-    "difficulty": "Intermediate",
-    "file_path": "memory/update-related.md"
-  },
-  {
-    "name": "workflow-skill-memory",
-    "command": "/memory:workflow-skill-memory",
-    "description": "Process WFS-* archived sessions using universal-executor agents with Gemini analysis to generate workflow-progress SKILL package (sessions-timeline, lessons, conflicts)",
-    "arguments": "session <session-id> | all",
-    "category": "memory",
-    "subcategory": null,
-    "usage_scenario": "documentation",
-    "difficulty": "Intermediate",
-    "file_path": "memory/workflow-skill-memory.md"
-  },
-  {
-    "name": "breakdown",
-    "command": "/task:breakdown",
-    "description": "Decompose complex task into subtasks with dependency mapping, creates child task JSONs with parent references and execution order",
-    "arguments": "task-id",
-    "category": "task",
-    "subcategory": null,
-    "usage_scenario": "planning",
-    "difficulty": "Intermediate",
-    "file_path": "task/breakdown.md"
-  },
-  {
-    "name": "create",
-    "command": "/task:create",
-    "description": "Generate task JSON from natural language description with automatic file pattern detection, scope inference, and dependency analysis",
-    "arguments": "\\\"task title\\",
-    "category": "task",
-    "subcategory": null,
-    "usage_scenario": "implementation",
-    "difficulty": "Intermediate",
-    "file_path": "task/create.md"
-  },
-  {
-    "name": "execute",
-    "command": "/task:execute",
-    "description": "Execute task JSON using appropriate agent (@doc-generator/@implementation-agent/@test-agent) with pre-analysis context loading and status tracking",
-    "arguments": "task-id",
-    "category": "task",
-    "subcategory": null,
-    "usage_scenario": "implementation",
-    "difficulty": "Intermediate",
-    "file_path": "task/execute.md"
-  },
-  {
-    "name": "replan",
-    "command": "/task:replan",
-    "description": "Update task JSON with new requirements or batch-update multiple tasks from verification report, tracks changes in task-changes.json",
-    "arguments": "task-id [\\\"text\\\"|file.md] | --batch [verification-report.md]",
-    "category": "task",
-    "subcategory": null,
-    "usage_scenario": "planning",
-    "difficulty": "Intermediate",
-    "file_path": "task/replan.md"
-  },
-  {
-    "name": "version",
-    "command": "/version",
-    "description": "Display Claude Code version information and check for updates",
-    "arguments": "",
-    "category": "general",
-    "subcategory": null,
-    "usage_scenario": "general",
-    "difficulty": "Beginner",
-    "file_path": "version.md"
-  },
-  {
-    "name": "action-plan-verify",
-    "command": "/workflow:action-plan-verify",
-    "description": "Perform non-destructive cross-artifact consistency analysis between IMPL_PLAN.md and task JSONs with quality gate validation",
-    "arguments": "[optional: --session session-id]",
-    "category": "workflow",
-    "subcategory": null,
-    "usage_scenario": "planning",
-    "difficulty": "Intermediate",
-    "file_path": "workflow/action-plan-verify.md"
-  },
-  {
-    "name": "api-designer",
-    "command": "/workflow:brainstorm:api-designer",
-    "description": "Generate or update api-designer/analysis.md addressing guidance-specification discussion points for API design perspective",
-    "arguments": "optional topic - uses existing framework if available",
-    "category": "workflow",
-    "subcategory": "brainstorm",
-    "usage_scenario": "planning",
-    "difficulty": "Intermediate",
-    "file_path": "workflow/brainstorm/api-designer.md"
-  },
-  {
-    "name": "artifacts",
-    "command": "/workflow:brainstorm:artifacts",
-    "description": "Interactive clarification generating confirmed guidance specification through role-based analysis and synthesis",
-    "arguments": "topic or challenge description [--count N]",
-    "category": "workflow",
-    "subcategory": "brainstorm",
-    "usage_scenario": "general",
-    "difficulty": "Intermediate",
-    "file_path": "workflow/brainstorm/artifacts.md"
-  },
-  {
-    "name": "auto-parallel",
-    "command": "/workflow:brainstorm:auto-parallel",
-    "description": "Parallel brainstorming automation with dynamic role selection and concurrent execution across multiple perspectives",
-    "arguments": "topic or challenge description\" [--count N]",
-    "category": "workflow",
-    "subcategory": "brainstorm",
-    "usage_scenario": "general",
-    "difficulty": "Advanced",
-    "file_path": "workflow/brainstorm/auto-parallel.md"
-  },
-  {
-    "name": "data-architect",
-    "command": "/workflow:brainstorm:data-architect",
-    "description": "Generate or update data-architect/analysis.md addressing guidance-specification discussion points for data architecture perspective",
-    "arguments": "optional topic - uses existing framework if available",
-    "category": "workflow",
-    "subcategory": "brainstorm",
-    "usage_scenario": "general",
-    "difficulty": "Intermediate",
-    "file_path": "workflow/brainstorm/data-architect.md"
-  },
-  {
-    "name": "product-manager",
-    "command": "/workflow:brainstorm:product-manager",
-    "description": "Generate or update product-manager/analysis.md addressing guidance-specification discussion points for product management perspective",
-    "arguments": "optional topic - uses existing framework if available",
-    "category": "workflow",
-    "subcategory": "brainstorm",
-    "usage_scenario": "general",
-    "difficulty": "Intermediate",
-    "file_path": "workflow/brainstorm/product-manager.md"
-  },
-  {
-    "name": "product-owner",
-    "command": "/workflow:brainstorm:product-owner",
-    "description": "Generate or update product-owner/analysis.md addressing guidance-specification discussion points for product ownership perspective",
-    "arguments": "optional topic - uses existing framework if available",
-    "category": "workflow",
-    "subcategory": "brainstorm",
-    "usage_scenario": "general",
-    "difficulty": "Intermediate",
-    "file_path": "workflow/brainstorm/product-owner.md"
-  },
-  {
-    "name": "scrum-master",
-    "command": "/workflow:brainstorm:scrum-master",
-    "description": "Generate or update scrum-master/analysis.md addressing guidance-specification discussion points for Agile process perspective",
-    "arguments": "optional topic - uses existing framework if available",
-    "category": "workflow",
-    "subcategory": "brainstorm",
-    "usage_scenario": "general",
-    "difficulty": "Intermediate",
-    "file_path": "workflow/brainstorm/scrum-master.md"
-  },
-  {
-    "name": "subject-matter-expert",
-    "command": "/workflow:brainstorm:subject-matter-expert",
-    "description": "Generate or update subject-matter-expert/analysis.md addressing guidance-specification discussion points for domain expertise perspective",
-    "arguments": "optional topic - uses existing framework if available",
-    "category": "workflow",
-    "subcategory": "brainstorm",
-    "usage_scenario": "general",
-    "difficulty": "Intermediate",
-    "file_path": "workflow/brainstorm/subject-matter-expert.md"
-  },
-  {
-    "name": "synthesis",
-    "command": "/workflow:brainstorm:synthesis",
-    "description": "Clarify and refine role analyses through intelligent Q&A and targeted updates with synthesis agent",
-    "arguments": "[optional: --session session-id]",
-    "category": "workflow",
-    "subcategory": "brainstorm",
-    "usage_scenario": "general",
-    "difficulty": "Advanced",
-    "file_path": "workflow/brainstorm/synthesis.md"
-  },
-  {
-    "name": "system-architect",
-    "command": "/workflow:brainstorm:system-architect",
-    "description": "Generate or update system-architect/analysis.md addressing guidance-specification discussion points for system architecture perspective",
-    "arguments": "optional topic - uses existing framework if available",
-    "category": "workflow",
-    "subcategory": "brainstorm",
-    "usage_scenario": "general",
-    "difficulty": "Intermediate",
-    "file_path": "workflow/brainstorm/system-architect.md"
-  },
-  {
-    "name": "ui-designer",
-    "command": "/workflow:brainstorm:ui-designer",
-    "description": "Generate or update ui-designer/analysis.md addressing guidance-specification discussion points for UI design perspective",
-    "arguments": "optional topic - uses existing framework if available",
-    "category": "workflow",
-    "subcategory": "brainstorm",
-    "usage_scenario": "planning",
-    "difficulty": "Intermediate",
-    "file_path": "workflow/brainstorm/ui-designer.md"
-  },
-  {
-    "name": "ux-expert",
-    "command": "/workflow:brainstorm:ux-expert",
-    "description": "Generate or update ux-expert/analysis.md addressing guidance-specification discussion points for UX perspective",
-    "arguments": "optional topic - uses existing framework if available",
-    "category": "workflow",
-    "subcategory": "brainstorm",
-    "usage_scenario": "general",
-    "difficulty": "Intermediate",
-    "file_path": "workflow/brainstorm/ux-expert.md"
-  },
-  {
-    "name": "execute",
-    "command": "/workflow:execute",
-    "description": "Coordinate agent execution for workflow tasks with automatic session discovery, parallel task processing, and status tracking",
-    "arguments": "[--resume-session=\\\"session-id\\\"]",
-    "category": "workflow",
-    "subcategory": null,
-    "usage_scenario": "implementation",
-    "difficulty": "Intermediate",
-    "file_path": "workflow/execute.md"
-  },
-  {
-    "name": "init",
-    "command": "/workflow:init",
-    "description": "Initialize project-level state with intelligent project analysis using cli-explore-agent",
-    "arguments": "[--regenerate]",
-    "category": "workflow",
-    "subcategory": null,
-    "usage_scenario": "general",
-    "difficulty": "Intermediate",
-    "file_path": "workflow/init.md"
-  },
-  {
-    "name": "lite-execute",
-    "command": "/workflow:lite-execute",
-    "description": "Execute tasks based on in-memory plan, prompt description, or file content",
-    "arguments": "[--in-memory] [\\\"task description\\\"|file-path]",
-    "category": "workflow",
-    "subcategory": null,
-    "usage_scenario": "implementation",
-    "difficulty": "Intermediate",
-    "file_path": "workflow/lite-execute.md"
-  },
-  {
-    "name": "lite-fix",
-    "command": "/workflow:lite-fix",
-    "description": "Lightweight bug diagnosis and fix workflow with intelligent severity assessment and optional hotfix mode for production incidents",
-    "arguments": "[--hotfix] \\\"bug description or issue reference\\",
-    "category": "workflow",
-    "subcategory": null,
-    "usage_scenario": "general",
-    "difficulty": "Intermediate",
-    "file_path": "workflow/lite-fix.md"
-  },
-  {
-    "name": "lite-plan",
-    "command": "/workflow:lite-plan",
-    "description": "Lightweight interactive planning workflow with in-memory planning, code exploration, and execution dispatch to lite-execute after user confirmation",
-    "arguments": "[-e|--explore] \\\"task description\\\"|file.md",
-    "category": "workflow",
-    "subcategory": null,
-    "usage_scenario": "planning",
-    "difficulty": "Intermediate",
-    "file_path": "workflow/lite-plan.md"
-  },
-  {
-    "name": "plan",
-    "command": "/workflow:plan",
-    "description": "5-phase planning workflow with action-planning-agent task generation, outputs IMPL_PLAN.md and task JSONs",
-    "arguments": "\\\"text description\\\"|file.md",
-    "category": "workflow",
-    "subcategory": null,
-    "usage_scenario": "planning",
-    "difficulty": "Intermediate",
-    "file_path": "workflow/plan.md"
-  },
-  {
-    "name": "replan",
-    "command": "/workflow:replan",
-    "description": "Interactive workflow replanning with session-level artifact updates and boundary clarification through guided questioning",
-    "arguments": "[--session session-id] [task-id] \\\"requirements\\\"|file.md [--interactive]",
-    "category": "workflow",
-    "subcategory": null,
-    "usage_scenario": "planning",
-    "difficulty": "Intermediate",
-    "file_path": "workflow/replan.md"
-  },
-  {
-    "name": "review-fix",
-    "command": "/workflow:review-fix",
-    "description": "Automated fixing of code review findings with AI-powered planning and coordinated execution. Uses intelligent grouping, multi-stage timeline coordination, and test-driven verification.",
-    "arguments": "<export-file|review-dir> [--resume] [--max-iterations=N]",
-    "category": "workflow",
-    "subcategory": null,
-    "usage_scenario": "analysis",
-    "difficulty": "Intermediate",
-    "file_path": "workflow/review-fix.md"
-  },
-  {
-    "name": "review-module-cycle",
-    "command": "/workflow:review-module-cycle",
-    "description": "Independent multi-dimensional code review for specified modules/files. Analyzes specific code paths across 7 dimensions with hybrid parallel-iterative execution, independent of workflow sessions.",
-    "arguments": "<path-pattern> [--dimensions=security,architecture,...] [--max-iterations=N]",
-    "category": "workflow",
-    "subcategory": null,
-    "usage_scenario": "analysis",
-    "difficulty": "Intermediate",
-    "file_path": "workflow/review-module-cycle.md"
-  },
-  {
-    "name": "review-session-cycle",
-    "command": "/workflow:review-session-cycle",
-    "description": "Session-based comprehensive multi-dimensional code review. Analyzes git changes from workflow session across 7 dimensions with hybrid parallel-iterative execution, aggregates findings, and performs focused deep-dives on critical issues until quality gates met.",
-    "arguments": "[session-id] [--dimensions=security,architecture,...] [--max-iterations=N]",
-    "category": "workflow",
-    "subcategory": null,
-    "usage_scenario": "session-management",
-    "difficulty": "Intermediate",
-    "file_path": "workflow/review-session-cycle.md"
-  },
-  {
-    "name": "review",
-    "command": "/workflow:review",
-    "description": "Post-implementation review with specialized types (security/architecture/action-items/quality) using analysis agents and Gemini",
-    "arguments": "[--type=security|architecture|action-items|quality] [optional: session-id]",
-    "category": "workflow",
-    "subcategory": null,
-    "usage_scenario": "analysis",
-    "difficulty": "Intermediate",
-    "file_path": "workflow/review.md"
-  },
-  {
-    "name": "complete",
-    "command": "/workflow:session:complete",
-    "description": "Mark active workflow session as complete, archive with lessons learned, update manifest, remove active flag",
-    "arguments": "",
-    "category": "workflow",
-    "subcategory": "session",
-    "usage_scenario": "session-management",
-    "difficulty": "Intermediate",
-    "file_path": "workflow/session/complete.md"
-  },
-  {
-    "name": "list",
-    "command": "/workflow:session:list",
-    "description": "List all workflow sessions with status filtering, shows session metadata and progress information",
-    "arguments": "",
-    "category": "workflow",
-    "subcategory": "session",
-    "usage_scenario": "general",
-    "difficulty": "Beginner",
-    "file_path": "workflow/session/list.md"
-  },
-  {
-    "name": "resume",
-    "command": "/workflow:session:resume",
-    "description": "Resume the most recently paused workflow session with automatic session discovery and status update",
-    "arguments": "",
-    "category": "workflow",
-    "subcategory": "session",
-    "usage_scenario": "session-management",
-    "difficulty": "Intermediate",
-    "file_path": "workflow/session/resume.md"
-  },
-  {
-    "name": "start",
-    "command": "/workflow:session:start",
-    "description": "Discover existing sessions or start new workflow session with intelligent session management and conflict detection",
-    "arguments": "[--type <workflow|review|tdd|test|docs>] [--auto|--new] [optional: task description for new session]",
-    "category": "workflow",
-    "subcategory": "session",
-    "usage_scenario": "general",
-    "difficulty": "Intermediate",
-    "file_path": "workflow/session/start.md"
-  },
-  {
-    "name": "tdd-plan",
-    "command": "/workflow:tdd-plan",
-    "description": "TDD workflow planning with Red-Green-Refactor task chain generation, test-first development structure, and cycle tracking",
-    "arguments": "\\\"feature description\\\"|file.md",
-    "category": "workflow",
-    "subcategory": null,
-    "usage_scenario": "planning",
-    "difficulty": "Advanced",
-    "file_path": "workflow/tdd-plan.md"
-  },
-  {
-    "name": "tdd-verify",
-    "command": "/workflow:tdd-verify",
-    "description": "Verify TDD workflow compliance against Red-Green-Refactor cycles, generate quality report with coverage analysis",
-    "arguments": "[optional: WFS-session-id]",
-    "category": "workflow",
-    "subcategory": null,
-    "usage_scenario": "testing",
-    "difficulty": "Advanced",
-    "file_path": "workflow/tdd-verify.md"
-  },
-  {
-    "name": "test-cycle-execute",
-    "command": "/workflow:test-cycle-execute",
-    "description": "Execute test-fix workflow with dynamic task generation and iterative fix cycles until test pass rate >= 95% or max iterations reached. Uses @cli-planning-agent for failure analysis and task generation.",
-    "arguments": "[--resume-session=\\\"session-id\\\"] [--max-iterations=N]",
-    "category": "workflow",
-    "subcategory": null,
-    "usage_scenario": "implementation",
-    "difficulty": "Intermediate",
-    "file_path": "workflow/test-cycle-execute.md"
-  },
-  {
-    "name": "test-fix-gen",
-    "command": "/workflow:test-fix-gen",
-    "description": "Create test-fix workflow session from session ID, description, or file path with test strategy generation and task planning",
-    "arguments": "(source-session-id | \\\"feature description\\\" | /path/to/file.md)",
-    "category": "workflow",
-    "subcategory": null,
-    "usage_scenario": "testing",
-    "difficulty": "Intermediate",
-    "file_path": "workflow/test-fix-gen.md"
-  },
-  {
-    "name": "test-gen",
-    "command": "/workflow:test-gen",
-    "description": "Create independent test-fix workflow session from completed implementation session, analyzes code to generate test tasks",
-    "arguments": "source-session-id",
-    "category": "workflow",
-    "subcategory": null,
-    "usage_scenario": "testing",
-    "difficulty": "Intermediate",
-    "file_path": "workflow/test-gen.md"
-  },
-  {
-    "name": "conflict-resolution",
-    "command": "/workflow:tools:conflict-resolution",
-    "description": "Detect and resolve conflicts between plan and existing codebase using CLI-powered analysis with Gemini/Qwen",
-    "arguments": "--session WFS-session-id --context path/to/context-package.json",
-    "category": "workflow",
-    "subcategory": "tools",
-    "usage_scenario": "general",
-    "difficulty": "Advanced",
-    "file_path": "workflow/tools/conflict-resolution.md"
-  },
-  {
-    "name": "gather",
-    "command": "/workflow:tools:gather",
-    "description": "Intelligently collect project context using context-search-agent based on task description, packages into standardized JSON",
-    "arguments": "--session WFS-session-id \\\"task description\\",
-    "category": "workflow",
-    "subcategory": "tools",
-    "usage_scenario": "general",
-    "difficulty": "Intermediate",
-    "file_path": "workflow/tools/context-gather.md"
-  },
-  {
-    "name": "task-generate-agent",
-    "command": "/workflow:tools:task-generate-agent",
-    "description": "Generate implementation plan documents (IMPL_PLAN.md, task JSONs, TODO_LIST.md) using action-planning-agent - produces planning artifacts, does NOT execute code implementation",
-    "arguments": "--session WFS-session-id",
-    "category": "workflow",
-    "subcategory": "tools",
-    "usage_scenario": "implementation",
-    "difficulty": "Advanced",
-    "file_path": "workflow/tools/task-generate-agent.md"
-  },
-  {
-    "name": "task-generate-tdd",
-    "command": "/workflow:tools:task-generate-tdd",
-    "description": "Autonomous TDD task generation using action-planning-agent with Red-Green-Refactor cycles, test-first structure, and cycle validation",
-    "arguments": "--session WFS-session-id",
-    "category": "workflow",
-    "subcategory": "tools",
-    "usage_scenario": "implementation",
-    "difficulty": "Advanced",
-    "file_path": "workflow/tools/task-generate-tdd.md"
-  },
-  {
-    "name": "tdd-coverage-analysis",
-    "command": "/workflow:tools:tdd-coverage-analysis",
-    "description": "Analyze test coverage and TDD cycle execution with Red-Green-Refactor compliance verification",
-    "arguments": "--session WFS-session-id",
-    "category": "workflow",
-    "subcategory": "tools",
-    "usage_scenario": "testing",
-    "difficulty": "Advanced",
-    "file_path": "workflow/tools/tdd-coverage-analysis.md"
-  },
-  {
-    "name": "test-concept-enhanced",
-    "command": "/workflow:tools:test-concept-enhanced",
-    "description": "Coordinate test analysis workflow using cli-execution-agent to generate test strategy via Gemini",
-    "arguments": "--session WFS-test-session-id --context path/to/test-context-package.json",
-    "category": "workflow",
-    "subcategory": "tools",
-    "usage_scenario": "testing",
-    "difficulty": "Intermediate",
-    "file_path": "workflow/tools/test-concept-enhanced.md"
-  },
-  {
-    "name": "test-context-gather",
-    "command": "/workflow:tools:test-context-gather",
-    "description": "Collect test coverage context using test-context-search-agent and package into standardized test-context JSON",
-    "arguments": "--session WFS-test-session-id",
-    "category": "workflow",
-    "subcategory": "tools",
-    "usage_scenario": "testing",
-    "difficulty": "Intermediate",
-    "file_path": "workflow/tools/test-context-gather.md"
-  },
-  {
-    "name": "test-task-generate",
-    "command": "/workflow:tools:test-task-generate",
-    "description": "Generate test planning documents (IMPL_PLAN.md, test task JSONs, TODO_LIST.md) using action-planning-agent - produces test planning artifacts, does NOT execute tests",
-    "arguments": "--session WFS-test-session-id",
-    "category": "workflow",
-    "subcategory": "tools",
-    "usage_scenario": "implementation",
-    "difficulty": "Intermediate",
-    "file_path": "workflow/tools/test-task-generate.md"
-  },
-  {
-    "name": "animation-extract",
-    "command": "/workflow:ui-design:animation-extract",
-    "description": "Extract animation and transition patterns from prompt inference and image references for design system documentation",
-    "arguments": "[--design-id <id>] [--session <id>] [--images \"<glob>\"] [--focus \"<types>\"] [--interactive] [--refine]",
-    "category": "workflow",
-    "subcategory": "ui-design",
-    "usage_scenario": "general",
-    "difficulty": "Intermediate",
-    "file_path": "workflow/ui-design/animation-extract.md"
-  },
-  {
-    "name": "workflow:ui-design:codify-style",
-    "command": "/workflow:ui-design:codify-style",
-    "description": "Orchestrator to extract styles from code and generate shareable reference package with preview (automatic file discovery)",
-    "arguments": "<path> [--package-name <name>] [--output-dir <path>] [--overwrite]",
-    "category": "workflow",
-    "subcategory": "ui-design",
-    "usage_scenario": "planning",
-    "difficulty": "Intermediate",
-    "file_path": "workflow/ui-design/codify-style.md"
-  },
-  {
-    "name": "design-sync",
-    "command": "/workflow:ui-design:design-sync",
-    "description": "Synchronize finalized design system references to brainstorming artifacts, preparing them for /workflow:plan consumption",
-    "arguments": "--session <session_id> [--selected-prototypes \"<list>\"]",
-    "category": "workflow",
-    "subcategory": "ui-design",
-    "usage_scenario": "planning",
-    "difficulty": "Intermediate",
-    "file_path": "workflow/ui-design/design-sync.md"
-  },
-  {
-    "name": "explore-auto",
-    "command": "/workflow:ui-design:explore-auto",
-    "description": "Interactive exploratory UI design workflow with style-centric batch generation, creates design variants from prompts/images with parallel execution and user selection",
-    "arguments": "[--input \"<value>\"] [--targets \"<list>\"] [--target-type \"page|component\"] [--session <id>] [--style-variants <count>] [--layout-variants <count>]",
-    "category": "workflow",
-    "subcategory": "ui-design",
-    "usage_scenario": "general",
-    "difficulty": "Intermediate",
-    "file_path": "workflow/ui-design/explore-auto.md"
-  },
-  {
-    "name": "generate",
-    "command": "/workflow:ui-design:generate",
-    "description": "Assemble UI prototypes by combining layout templates with design tokens (default animation support), pure assembler without new content generation",
-    "arguments": "[--design-id <id>] [--session <id>]",
-    "category": "workflow",
-    "subcategory": "ui-design",
-    "usage_scenario": "implementation",
-    "difficulty": "Intermediate",
-    "file_path": "workflow/ui-design/generate.md"
-  },
-  {
-    "name": "imitate-auto",
-    "command": "/workflow:ui-design:imitate-auto",
-    "description": "UI design workflow with direct code/image input for design token extraction and prototype generation",
-    "arguments": "[--input \"<value>\"] [--session <id>]",
-    "category": "workflow",
-    "subcategory": "ui-design",
-    "usage_scenario": "general",
-    "difficulty": "Intermediate",
-    "file_path": "workflow/ui-design/imitate-auto.md"
-  },
-  {
-    "name": "workflow:ui-design:import-from-code",
-    "command": "/workflow:ui-design:import-from-code",
-    "description": "Import design system from code files (CSS/JS/HTML/SCSS) with automatic file discovery and parallel agent analysis",
-    "arguments": "[--design-id <id>] [--session <id>] [--source <path>]",
-    "category": "workflow",
-    "subcategory": "ui-design",
-    "usage_scenario": "planning",
-    "difficulty": "Intermediate",
-    "file_path": "workflow/ui-design/import-from-code.md"
-  },
-  {
-    "name": "layout-extract",
-    "command": "/workflow:ui-design:layout-extract",
-    "description": "Extract structural layout information from reference images or text prompts using Claude analysis with variant generation or refinement mode",
-    "arguments": "[--design-id <id>] [--session <id>] [--images \"<glob>\"] [--prompt \"<desc>\"] [--targets \"<list>\"] [--variants <count>] [--device-type <desktop|mobile|tablet|responsive>] [--interactive] [--refine]",
-    "category": "workflow",
-    "subcategory": "ui-design",
-    "usage_scenario": "general",
-    "difficulty": "Intermediate",
-    "file_path": "workflow/ui-design/layout-extract.md"
-  },
-  {
-    "name": "workflow:ui-design:reference-page-generator",
-    "command": "/workflow:ui-design:reference-page-generator",
-    "description": "Generate multi-component reference pages and documentation from design run extraction",
-    "arguments": "[--design-run <path>] [--package-name <name>] [--output-dir <path>]",
-    "category": "workflow",
-    "subcategory": "ui-design",
-    "usage_scenario": "planning",
-    "difficulty": "Intermediate",
-    "file_path": "workflow/ui-design/reference-page-generator.md"
-  },
-  {
-    "name": "style-extract",
-    "command": "/workflow:ui-design:style-extract",
-    "description": "Extract design style from reference images or text prompts using Claude analysis with variant generation or refinement mode",
-    "arguments": "[--design-id <id>] [--session <id>] [--images \"<glob>\"] [--prompt \"<desc>\"] [--variants <count>] [--interactive] [--refine]",
-    "category": "workflow",
-    "subcategory": "ui-design",
-    "usage_scenario": "general",
-    "difficulty": "Intermediate",
-    "file_path": "workflow/ui-design/style-extract.md"
-  }
-]

.claude/skills/command-guide/index/by-category.json

@@ -1,800 +0,0 @@
-{
-  "cli": {
-    "_root": [
-      {
-        "name": "cli-init",
-        "command": "/cli:cli-init",
-        "description": "Generate .gemini/ and .qwen/ config directories with settings.json and ignore files based on workspace technology detection",
-        "arguments": "[--tool gemini|qwen|all] [--output path] [--preview]",
-        "category": "cli",
-        "subcategory": null,
-        "usage_scenario": "general",
-        "difficulty": "Intermediate",
-        "file_path": "cli/cli-init.md"
-      }
-    ]
-  },
-  "general": {
-    "_root": [
-      {
-        "name": "enhance-prompt",
-        "command": "/enhance-prompt",
-        "description": "Enhanced prompt transformation using session memory and intent analysis with --enhance flag detection",
-        "arguments": "user input to enhance",
-        "category": "general",
-        "subcategory": null,
-        "usage_scenario": "general",
-        "difficulty": "Intermediate",
-        "file_path": "enhance-prompt.md"
-      },
-      {
-        "name": "version",
-        "command": "/version",
-        "description": "Display Claude Code version information and check for updates",
-        "arguments": "",
-        "category": "general",
-        "subcategory": null,
-        "usage_scenario": "general",
-        "difficulty": "Beginner",
-        "file_path": "version.md"
-      }
-    ]
-  },
-  "memory": {
-    "_root": [
-      {
-        "name": "code-map-memory",
-        "command": "/memory:code-map-memory",
-        "description": "3-phase orchestrator: parse feature keyword → cli-explore-agent analyzes (Deep Scan dual-source) → orchestrator generates Mermaid docs + SKILL package (skips phase 2 if exists)",
-        "arguments": "\\\"feature-keyword\\\" [--regenerate] [--tool <gemini|qwen>]",
-        "category": "memory",
-        "subcategory": null,
-        "usage_scenario": "documentation",
-        "difficulty": "Intermediate",
-        "file_path": "memory/code-map-memory.md"
-      },
-      {
-        "name": "docs-full-cli",
-        "command": "/memory:docs-full-cli",
-        "description": "Generate full project documentation using CLI execution (Layer 3→1) with batched agents (4 modules/agent) and gemini→qwen→codex fallback, <20 modules uses direct parallel",
-        "arguments": "[path] [--tool <gemini|qwen|codex>]",
-        "category": "memory",
-        "subcategory": null,
-        "usage_scenario": "documentation",
-        "difficulty": "Intermediate",
-        "file_path": "memory/docs-full-cli.md"
-      },
-      {
-        "name": "docs-related-cli",
-        "command": "/memory:docs-related-cli",
-        "description": "Generate/update documentation for git-changed modules using CLI execution with batched agents (4 modules/agent) and gemini→qwen→codex fallback, <15 modules uses direct parallel",
-        "arguments": "[--tool <gemini|qwen|codex>]",
-        "category": "memory",
-        "subcategory": null,
-        "usage_scenario": "documentation",
-        "difficulty": "Intermediate",
-        "file_path": "memory/docs-related-cli.md"
-      },
-      {
-        "name": "docs",
-        "command": "/memory:docs",
-        "description": "Plan documentation workflow with dynamic grouping (≤10 docs/task), generates IMPL tasks for parallel module trees, README, ARCHITECTURE, and HTTP API docs",
-        "arguments": "[path] [--tool <gemini|qwen|codex>] [--mode <full|partial>] [--cli-execute]",
-        "category": "memory",
-        "subcategory": null,
-        "usage_scenario": "documentation",
-        "difficulty": "Intermediate",
-        "file_path": "memory/docs.md"
-      },
-      {
-        "name": "load-skill-memory",
-        "command": "/memory:load-skill-memory",
-        "description": "Activate SKILL package (auto-detect from paths/keywords or manual) and intelligently load documentation based on task intent keywords",
-        "arguments": "[skill_name] \\\"task intent description\\",
-        "category": "memory",
-        "subcategory": null,
-        "usage_scenario": "documentation",
-        "difficulty": "Intermediate",
-        "file_path": "memory/load-skill-memory.md"
-      },
-      {
-        "name": "load",
-        "command": "/memory:load",
-        "description": "Delegate to universal-executor agent to analyze project via Gemini/Qwen CLI and return JSON core content package for task context",
-        "arguments": "[--tool gemini|qwen] \\\"task context description\\",
-        "category": "memory",
-        "subcategory": null,
-        "usage_scenario": "general",
-        "difficulty": "Intermediate",
-        "file_path": "memory/load.md"
-      },
-      {
-        "name": "skill-memory",
-        "command": "/memory:skill-memory",
-        "description": "4-phase autonomous orchestrator: check docs → /memory:docs planning → /workflow:execute → generate SKILL.md with progressive loading index (skips phases 2-3 if docs exist)",
-        "arguments": "[path] [--tool <gemini|qwen|codex>] [--regenerate] [--mode <full|partial>] [--cli-execute]",
-        "category": "memory",
-        "subcategory": null,
-        "usage_scenario": "documentation",
-        "difficulty": "Intermediate",
-        "file_path": "memory/skill-memory.md"
-      },
-      {
-        "name": "style-skill-memory",
-        "command": "/memory:style-skill-memory",
-        "description": "Generate SKILL memory package from style reference for easy loading and consistent design system usage",
-        "arguments": "[package-name] [--regenerate]",
-        "category": "memory",
-        "subcategory": null,
-        "usage_scenario": "documentation",
-        "difficulty": "Intermediate",
-        "file_path": "memory/style-skill-memory.md"
-      },
-      {
-        "name": "tech-research",
-        "command": "/memory:tech-research",
-        "description": "3-phase orchestrator: extract tech stack → Exa research → generate path-conditional rules (auto-loaded by Claude Code)",
-        "arguments": "[session-id | tech-stack-name] [--regenerate] [--tool <gemini|qwen>]",
-        "category": "memory",
-        "subcategory": null,
-        "usage_scenario": "general",
-        "difficulty": "Intermediate",
-        "file_path": "memory/tech-research.md"
-      },
-      {
-        "name": "update-full",
-        "command": "/memory:update-full",
-        "description": "Update all CLAUDE.md files using layer-based execution (Layer 3→1) with batched agents (4 modules/agent) and gemini→qwen→codex fallback, <20 modules uses direct parallel",
-        "arguments": "[--tool gemini|qwen|codex] [--path <directory>]",
-        "category": "memory",
-        "subcategory": null,
-        "usage_scenario": "general",
-        "difficulty": "Intermediate",
-        "file_path": "memory/update-full.md"
-      },
-      {
-        "name": "update-related",
-        "command": "/memory:update-related",
-        "description": "Update CLAUDE.md for git-changed modules using batched agent execution (4 modules/agent) with gemini→qwen→codex fallback, <15 modules uses direct execution",
-        "arguments": "[--tool gemini|qwen|codex]",
-        "category": "memory",
-        "subcategory": null,
-        "usage_scenario": "general",
-        "difficulty": "Intermediate",
-        "file_path": "memory/update-related.md"
-      },
-      {
-        "name": "workflow-skill-memory",
-        "command": "/memory:workflow-skill-memory",
-        "description": "Process WFS-* archived sessions using universal-executor agents with Gemini analysis to generate workflow-progress SKILL package (sessions-timeline, lessons, conflicts)",
-        "arguments": "session <session-id> | all",
-        "category": "memory",
-        "subcategory": null,
-        "usage_scenario": "documentation",
-        "difficulty": "Intermediate",
-        "file_path": "memory/workflow-skill-memory.md"
-      }
-    ]
-  },
-  "task": {
-    "_root": [
-      {
-        "name": "breakdown",
-        "command": "/task:breakdown",
-        "description": "Decompose complex task into subtasks with dependency mapping, creates child task JSONs with parent references and execution order",
-        "arguments": "task-id",
-        "category": "task",
-        "subcategory": null,
-        "usage_scenario": "planning",
-        "difficulty": "Intermediate",
-        "file_path": "task/breakdown.md"
-      },
-      {
-        "name": "create",
-        "command": "/task:create",
-        "description": "Generate task JSON from natural language description with automatic file pattern detection, scope inference, and dependency analysis",
-        "arguments": "\\\"task title\\",
-        "category": "task",
-        "subcategory": null,
-        "usage_scenario": "implementation",
-        "difficulty": "Intermediate",
-        "file_path": "task/create.md"
-      },
-      {
-        "name": "execute",
-        "command": "/task:execute",
-        "description": "Execute task JSON using appropriate agent (@doc-generator/@implementation-agent/@test-agent) with pre-analysis context loading and status tracking",
-        "arguments": "task-id",
-        "category": "task",
-        "subcategory": null,
-        "usage_scenario": "implementation",
-        "difficulty": "Intermediate",
-        "file_path": "task/execute.md"
-      },
-      {
-        "name": "replan",
-        "command": "/task:replan",
-        "description": "Update task JSON with new requirements or batch-update multiple tasks from verification report, tracks changes in task-changes.json",
-        "arguments": "task-id [\\\"text\\\"|file.md] | --batch [verification-report.md]",
-        "category": "task",
-        "subcategory": null,
-        "usage_scenario": "planning",
-        "difficulty": "Intermediate",
-        "file_path": "task/replan.md"
-      }
-    ]
-  },
-  "workflow": {
-    "_root": [
-      {
-        "name": "action-plan-verify",
-        "command": "/workflow:action-plan-verify",
-        "description": "Perform non-destructive cross-artifact consistency analysis between IMPL_PLAN.md and task JSONs with quality gate validation",
-        "arguments": "[optional: --session session-id]",
-        "category": "workflow",
-        "subcategory": null,
-        "usage_scenario": "planning",
-        "difficulty": "Intermediate",
-        "file_path": "workflow/action-plan-verify.md"
-      },
-      {
-        "name": "execute",
-        "command": "/workflow:execute",
-        "description": "Coordinate agent execution for workflow tasks with automatic session discovery, parallel task processing, and status tracking",
-        "arguments": "[--resume-session=\\\"session-id\\\"]",
-        "category": "workflow",
-        "subcategory": null,
-        "usage_scenario": "implementation",
-        "difficulty": "Intermediate",
-        "file_path": "workflow/execute.md"
-      },
-      {
-        "name": "init",
-        "command": "/workflow:init",
-        "description": "Initialize project-level state with intelligent project analysis using cli-explore-agent",
-        "arguments": "[--regenerate]",
-        "category": "workflow",
-        "subcategory": null,
-        "usage_scenario": "general",
-        "difficulty": "Intermediate",
-        "file_path": "workflow/init.md"
-      },
-      {
-        "name": "lite-execute",
-        "command": "/workflow:lite-execute",
-        "description": "Execute tasks based on in-memory plan, prompt description, or file content",
-        "arguments": "[--in-memory] [\\\"task description\\\"|file-path]",
-        "category": "workflow",
-        "subcategory": null,
-        "usage_scenario": "implementation",
-        "difficulty": "Intermediate",
-        "file_path": "workflow/lite-execute.md"
-      },
-      {
-        "name": "lite-fix",
-        "command": "/workflow:lite-fix",
-        "description": "Lightweight bug diagnosis and fix workflow with intelligent severity assessment and optional hotfix mode for production incidents",
-        "arguments": "[--hotfix] \\\"bug description or issue reference\\",
-        "category": "workflow",
-        "subcategory": null,
-        "usage_scenario": "general",
-        "difficulty": "Intermediate",
-        "file_path": "workflow/lite-fix.md"
-      },
-      {
-        "name": "lite-plan",
-        "command": "/workflow:lite-plan",
-        "description": "Lightweight interactive planning workflow with in-memory planning, code exploration, and execution dispatch to lite-execute after user confirmation",
-        "arguments": "[-e|--explore] \\\"task description\\\"|file.md",
-        "category": "workflow",
-        "subcategory": null,
-        "usage_scenario": "planning",
-        "difficulty": "Intermediate",
-        "file_path": "workflow/lite-plan.md"
-      },
-      {
-        "name": "plan",
-        "command": "/workflow:plan",
-        "description": "5-phase planning workflow with action-planning-agent task generation, outputs IMPL_PLAN.md and task JSONs",
-        "arguments": "\\\"text description\\\"|file.md",
-        "category": "workflow",
-        "subcategory": null,
-        "usage_scenario": "planning",
-        "difficulty": "Intermediate",
-        "file_path": "workflow/plan.md"
-      },
-      {
-        "name": "replan",
-        "command": "/workflow:replan",
-        "description": "Interactive workflow replanning with session-level artifact updates and boundary clarification through guided questioning",
-        "arguments": "[--session session-id] [task-id] \\\"requirements\\\"|file.md [--interactive]",
-        "category": "workflow",
-        "subcategory": null,
-        "usage_scenario": "planning",
-        "difficulty": "Intermediate",
-        "file_path": "workflow/replan.md"
-      },
-      {
-        "name": "review-fix",
-        "command": "/workflow:review-fix",
-        "description": "Automated fixing of code review findings with AI-powered planning and coordinated execution. Uses intelligent grouping, multi-stage timeline coordination, and test-driven verification.",
-        "arguments": "<export-file|review-dir> [--resume] [--max-iterations=N]",
-        "category": "workflow",
-        "subcategory": null,
-        "usage_scenario": "analysis",
-        "difficulty": "Intermediate",
-        "file_path": "workflow/review-fix.md"
-      },
-      {
-        "name": "review-module-cycle",
-        "command": "/workflow:review-module-cycle",
-        "description": "Independent multi-dimensional code review for specified modules/files. Analyzes specific code paths across 7 dimensions with hybrid parallel-iterative execution, independent of workflow sessions.",
-        "arguments": "<path-pattern> [--dimensions=security,architecture,...] [--max-iterations=N]",
-        "category": "workflow",
-        "subcategory": null,
-        "usage_scenario": "analysis",
-        "difficulty": "Intermediate",
-        "file_path": "workflow/review-module-cycle.md"
-      },
-      {
-        "name": "review-session-cycle",
-        "command": "/workflow:review-session-cycle",
-        "description": "Session-based comprehensive multi-dimensional code review. Analyzes git changes from workflow session across 7 dimensions with hybrid parallel-iterative execution, aggregates findings, and performs focused deep-dives on critical issues until quality gates met.",
-        "arguments": "[session-id] [--dimensions=security,architecture,...] [--max-iterations=N]",
-        "category": "workflow",
-        "subcategory": null,
-        "usage_scenario": "session-management",
-        "difficulty": "Intermediate",
-        "file_path": "workflow/review-session-cycle.md"
-      },
-      {
-        "name": "review",
-        "command": "/workflow:review",
-        "description": "Post-implementation review with specialized types (security/architecture/action-items/quality) using analysis agents and Gemini",
-        "arguments": "[--type=security|architecture|action-items|quality] [optional: session-id]",
-        "category": "workflow",
-        "subcategory": null,
-        "usage_scenario": "analysis",
-        "difficulty": "Intermediate",
-        "file_path": "workflow/review.md"
-      },
-      {
-        "name": "tdd-plan",
-        "command": "/workflow:tdd-plan",
-        "description": "TDD workflow planning with Red-Green-Refactor task chain generation, test-first development structure, and cycle tracking",
-        "arguments": "\\\"feature description\\\"|file.md",
-        "category": "workflow",
-        "subcategory": null,
-        "usage_scenario": "planning",
-        "difficulty": "Advanced",
-        "file_path": "workflow/tdd-plan.md"
-      },
-      {
-        "name": "tdd-verify",
-        "command": "/workflow:tdd-verify",
-        "description": "Verify TDD workflow compliance against Red-Green-Refactor cycles, generate quality report with coverage analysis",
-        "arguments": "[optional: WFS-session-id]",
-        "category": "workflow",
-        "subcategory": null,
-        "usage_scenario": "testing",
-        "difficulty": "Advanced",
-        "file_path": "workflow/tdd-verify.md"
-      },
-      {
-        "name": "test-cycle-execute",
-        "command": "/workflow:test-cycle-execute",
-        "description": "Execute test-fix workflow with dynamic task generation and iterative fix cycles until test pass rate >= 95% or max iterations reached. Uses @cli-planning-agent for failure analysis and task generation.",
-        "arguments": "[--resume-session=\\\"session-id\\\"] [--max-iterations=N]",
-        "category": "workflow",
-        "subcategory": null,
-        "usage_scenario": "implementation",
-        "difficulty": "Intermediate",
-        "file_path": "workflow/test-cycle-execute.md"
-      },
-      {
-        "name": "test-fix-gen",
-        "command": "/workflow:test-fix-gen",
-        "description": "Create test-fix workflow session from session ID, description, or file path with test strategy generation and task planning",
-        "arguments": "(source-session-id | \\\"feature description\\\" | /path/to/file.md)",
-        "category": "workflow",
-        "subcategory": null,
-        "usage_scenario": "testing",
-        "difficulty": "Intermediate",
-        "file_path": "workflow/test-fix-gen.md"
-      },
-      {
-        "name": "test-gen",
-        "command": "/workflow:test-gen",
-        "description": "Create independent test-fix workflow session from completed implementation session, analyzes code to generate test tasks",
-        "arguments": "source-session-id",
-        "category": "workflow",
-        "subcategory": null,
-        "usage_scenario": "testing",
-        "difficulty": "Intermediate",
-        "file_path": "workflow/test-gen.md"
-      }
-    ],
-    "brainstorm": [
-      {
-        "name": "api-designer",
-        "command": "/workflow:brainstorm:api-designer",
-        "description": "Generate or update api-designer/analysis.md addressing guidance-specification discussion points for API design perspective",
-        "arguments": "optional topic - uses existing framework if available",
-        "category": "workflow",
-        "subcategory": "brainstorm",
-        "usage_scenario": "planning",
-        "difficulty": "Intermediate",
-        "file_path": "workflow/brainstorm/api-designer.md"
-      },
-      {
-        "name": "artifacts",
-        "command": "/workflow:brainstorm:artifacts",
-        "description": "Interactive clarification generating confirmed guidance specification through role-based analysis and synthesis",
-        "arguments": "topic or challenge description [--count N]",
-        "category": "workflow",
-        "subcategory": "brainstorm",
-        "usage_scenario": "general",
-        "difficulty": "Intermediate",
-        "file_path": "workflow/brainstorm/artifacts.md"
-      },
-      {
-        "name": "auto-parallel",
-        "command": "/workflow:brainstorm:auto-parallel",
-        "description": "Parallel brainstorming automation with dynamic role selection and concurrent execution across multiple perspectives",
-        "arguments": "topic or challenge description\" [--count N]",
-        "category": "workflow",
-        "subcategory": "brainstorm",
-        "usage_scenario": "general",
-        "difficulty": "Advanced",
-        "file_path": "workflow/brainstorm/auto-parallel.md"
-      },
-      {
-        "name": "data-architect",
-        "command": "/workflow:brainstorm:data-architect",
-        "description": "Generate or update data-architect/analysis.md addressing guidance-specification discussion points for data architecture perspective",
-        "arguments": "optional topic - uses existing framework if available",
-        "category": "workflow",
-        "subcategory": "brainstorm",
-        "usage_scenario": "general",
-        "difficulty": "Intermediate",
-        "file_path": "workflow/brainstorm/data-architect.md"
-      },
-      {
-        "name": "product-manager",
-        "command": "/workflow:brainstorm:product-manager",
-        "description": "Generate or update product-manager/analysis.md addressing guidance-specification discussion points for product management perspective",
-        "arguments": "optional topic - uses existing framework if available",
-        "category": "workflow",
-        "subcategory": "brainstorm",
-        "usage_scenario": "general",
-        "difficulty": "Intermediate",
-        "file_path": "workflow/brainstorm/product-manager.md"
-      },
-      {
-        "name": "product-owner",
-        "command": "/workflow:brainstorm:product-owner",
-        "description": "Generate or update product-owner/analysis.md addressing guidance-specification discussion points for product ownership perspective",
-        "arguments": "optional topic - uses existing framework if available",
-        "category": "workflow",
-        "subcategory": "brainstorm",
-        "usage_scenario": "general",
-        "difficulty": "Intermediate",
-        "file_path": "workflow/brainstorm/product-owner.md"
-      },
-      {
-        "name": "scrum-master",
-        "command": "/workflow:brainstorm:scrum-master",
-        "description": "Generate or update scrum-master/analysis.md addressing guidance-specification discussion points for Agile process perspective",
-        "arguments": "optional topic - uses existing framework if available",
-        "category": "workflow",
-        "subcategory": "brainstorm",
-        "usage_scenario": "general",
-        "difficulty": "Intermediate",
-        "file_path": "workflow/brainstorm/scrum-master.md"
-      },
-      {
-        "name": "subject-matter-expert",
-        "command": "/workflow:brainstorm:subject-matter-expert",
-        "description": "Generate or update subject-matter-expert/analysis.md addressing guidance-specification discussion points for domain expertise perspective",
-        "arguments": "optional topic - uses existing framework if available",
-        "category": "workflow",
-        "subcategory": "brainstorm",
-        "usage_scenario": "general",
-        "difficulty": "Intermediate",
-        "file_path": "workflow/brainstorm/subject-matter-expert.md"
-      },
-      {
-        "name": "synthesis",
-        "command": "/workflow:brainstorm:synthesis",
-        "description": "Clarify and refine role analyses through intelligent Q&A and targeted updates with synthesis agent",
-        "arguments": "[optional: --session session-id]",
-        "category": "workflow",
-        "subcategory": "brainstorm",
-        "usage_scenario": "general",
-        "difficulty": "Advanced",
-        "file_path": "workflow/brainstorm/synthesis.md"
-      },
-      {
-        "name": "system-architect",
-        "command": "/workflow:brainstorm:system-architect",
-        "description": "Generate or update system-architect/analysis.md addressing guidance-specification discussion points for system architecture perspective",
-        "arguments": "optional topic - uses existing framework if available",
-        "category": "workflow",
-        "subcategory": "brainstorm",
-        "usage_scenario": "general",
-        "difficulty": "Intermediate",
-        "file_path": "workflow/brainstorm/system-architect.md"
-      },
-      {
-        "name": "ui-designer",
-        "command": "/workflow:brainstorm:ui-designer",
-        "description": "Generate or update ui-designer/analysis.md addressing guidance-specification discussion points for UI design perspective",
-        "arguments": "optional topic - uses existing framework if available",
-        "category": "workflow",
-        "subcategory": "brainstorm",
-        "usage_scenario": "planning",
-        "difficulty": "Intermediate",
-        "file_path": "workflow/brainstorm/ui-designer.md"
-      },
-      {
-        "name": "ux-expert",
-        "command": "/workflow:brainstorm:ux-expert",
-        "description": "Generate or update ux-expert/analysis.md addressing guidance-specification discussion points for UX perspective",
-        "arguments": "optional topic - uses existing framework if available",
-        "category": "workflow",
-        "subcategory": "brainstorm",
-        "usage_scenario": "general",
-        "difficulty": "Intermediate",
-        "file_path": "workflow/brainstorm/ux-expert.md"
-      }
-    ],
-    "session": [
-      {
-        "name": "complete",
-        "command": "/workflow:session:complete",
-        "description": "Mark active workflow session as complete, archive with lessons learned, update manifest, remove active flag",
-        "arguments": "",
-        "category": "workflow",
-        "subcategory": "session",
-        "usage_scenario": "session-management",
-        "difficulty": "Intermediate",
-        "file_path": "workflow/session/complete.md"
-      },
-      {
-        "name": "list",
-        "command": "/workflow:session:list",
-        "description": "List all workflow sessions with status filtering, shows session metadata and progress information",
-        "arguments": "",
-        "category": "workflow",
-        "subcategory": "session",
-        "usage_scenario": "general",
-        "difficulty": "Beginner",
-        "file_path": "workflow/session/list.md"
-      },
-      {
-        "name": "resume",
-        "command": "/workflow:session:resume",
-        "description": "Resume the most recently paused workflow session with automatic session discovery and status update",
-        "arguments": "",
-        "category": "workflow",
-        "subcategory": "session",
-        "usage_scenario": "session-management",
-        "difficulty": "Intermediate",
-        "file_path": "workflow/session/resume.md"
-      },
-      {
-        "name": "start",
-        "command": "/workflow:session:start",
-        "description": "Discover existing sessions or start new workflow session with intelligent session management and conflict detection",
-        "arguments": "[--type <workflow|review|tdd|test|docs>] [--auto|--new] [optional: task description for new session]",
-        "category": "workflow",
-        "subcategory": "session",
-        "usage_scenario": "general",
-        "difficulty": "Intermediate",
-        "file_path": "workflow/session/start.md"
-      }
-    ],
-    "tools": [
-      {
-        "name": "conflict-resolution",
-        "command": "/workflow:tools:conflict-resolution",
-        "description": "Detect and resolve conflicts between plan and existing codebase using CLI-powered analysis with Gemini/Qwen",
-        "arguments": "--session WFS-session-id --context path/to/context-package.json",
-        "category": "workflow",
-        "subcategory": "tools",
-        "usage_scenario": "general",
-        "difficulty": "Advanced",
-        "file_path": "workflow/tools/conflict-resolution.md"
-      },
-      {
-        "name": "gather",
-        "command": "/workflow:tools:gather",
-        "description": "Intelligently collect project context using context-search-agent based on task description, packages into standardized JSON",
-        "arguments": "--session WFS-session-id \\\"task description\\",
-        "category": "workflow",
-        "subcategory": "tools",
-        "usage_scenario": "general",
-        "difficulty": "Intermediate",
-        "file_path": "workflow/tools/context-gather.md"
-      },
-      {
-        "name": "task-generate-agent",
-        "command": "/workflow:tools:task-generate-agent",
-        "description": "Generate implementation plan documents (IMPL_PLAN.md, task JSONs, TODO_LIST.md) using action-planning-agent - produces planning artifacts, does NOT execute code implementation",
-        "arguments": "--session WFS-session-id",
-        "category": "workflow",
-        "subcategory": "tools",
-        "usage_scenario": "implementation",
-        "difficulty": "Advanced",
-        "file_path": "workflow/tools/task-generate-agent.md"
-      },
-      {
-        "name": "task-generate-tdd",
-        "command": "/workflow:tools:task-generate-tdd",
-        "description": "Autonomous TDD task generation using action-planning-agent with Red-Green-Refactor cycles, test-first structure, and cycle validation",
-        "arguments": "--session WFS-session-id",
-        "category": "workflow",
-        "subcategory": "tools",
-        "usage_scenario": "implementation",
-        "difficulty": "Advanced",
-        "file_path": "workflow/tools/task-generate-tdd.md"
-      },
-      {
-        "name": "tdd-coverage-analysis",
-        "command": "/workflow:tools:tdd-coverage-analysis",
-        "description": "Analyze test coverage and TDD cycle execution with Red-Green-Refactor compliance verification",
-        "arguments": "--session WFS-session-id",
-        "category": "workflow",
-        "subcategory": "tools",
-        "usage_scenario": "testing",
-        "difficulty": "Advanced",
-        "file_path": "workflow/tools/tdd-coverage-analysis.md"
-      },
-      {
-        "name": "test-concept-enhanced",
-        "command": "/workflow:tools:test-concept-enhanced",
-        "description": "Coordinate test analysis workflow using cli-execution-agent to generate test strategy via Gemini",
-        "arguments": "--session WFS-test-session-id --context path/to/test-context-package.json",
-        "category": "workflow",
-        "subcategory": "tools",
-        "usage_scenario": "testing",
-        "difficulty": "Intermediate",
-        "file_path": "workflow/tools/test-concept-enhanced.md"
-      },
-      {
-        "name": "test-context-gather",
-        "command": "/workflow:tools:test-context-gather",
-        "description": "Collect test coverage context using test-context-search-agent and package into standardized test-context JSON",
-        "arguments": "--session WFS-test-session-id",
-        "category": "workflow",
-        "subcategory": "tools",
-        "usage_scenario": "testing",
-        "difficulty": "Intermediate",
-        "file_path": "workflow/tools/test-context-gather.md"
-      },
-      {
-        "name": "test-task-generate",
-        "command": "/workflow:tools:test-task-generate",
-        "description": "Generate test planning documents (IMPL_PLAN.md, test task JSONs, TODO_LIST.md) using action-planning-agent - produces test planning artifacts, does NOT execute tests",
-        "arguments": "--session WFS-test-session-id",
-        "category": "workflow",
-        "subcategory": "tools",
-        "usage_scenario": "implementation",
-        "difficulty": "Intermediate",
-        "file_path": "workflow/tools/test-task-generate.md"
-      }
-    ],
-    "ui-design": [
-      {
-        "name": "animation-extract",
-        "command": "/workflow:ui-design:animation-extract",
-        "description": "Extract animation and transition patterns from prompt inference and image references for design system documentation",
-        "arguments": "[--design-id <id>] [--session <id>] [--images \"<glob>\"] [--focus \"<types>\"] [--interactive] [--refine]",
-        "category": "workflow",
-        "subcategory": "ui-design",
-        "usage_scenario": "general",
-        "difficulty": "Intermediate",
-        "file_path": "workflow/ui-design/animation-extract.md"
-      },
-      {
-        "name": "workflow:ui-design:codify-style",
-        "command": "/workflow:ui-design:codify-style",
-        "description": "Orchestrator to extract styles from code and generate shareable reference package with preview (automatic file discovery)",
-        "arguments": "<path> [--package-name <name>] [--output-dir <path>] [--overwrite]",
-        "category": "workflow",
-        "subcategory": "ui-design",
-        "usage_scenario": "planning",
-        "difficulty": "Intermediate",
-        "file_path": "workflow/ui-design/codify-style.md"
-      },
-      {
-        "name": "design-sync",
-        "command": "/workflow:ui-design:design-sync",
-        "description": "Synchronize finalized design system references to brainstorming artifacts, preparing them for /workflow:plan consumption",
-        "arguments": "--session <session_id> [--selected-prototypes \"<list>\"]",
-        "category": "workflow",
-        "subcategory": "ui-design",
-        "usage_scenario": "planning",
-        "difficulty": "Intermediate",
-        "file_path": "workflow/ui-design/design-sync.md"
-      },
-      {
-        "name": "explore-auto",
-        "command": "/workflow:ui-design:explore-auto",
-        "description": "Interactive exploratory UI design workflow with style-centric batch generation, creates design variants from prompts/images with parallel execution and user selection",
-        "arguments": "[--input \"<value>\"] [--targets \"<list>\"] [--target-type \"page|component\"] [--session <id>] [--style-variants <count>] [--layout-variants <count>]",
-        "category": "workflow",
-        "subcategory": "ui-design",
-        "usage_scenario": "general",
-        "difficulty": "Intermediate",
-        "file_path": "workflow/ui-design/explore-auto.md"
-      },
-      {
-        "name": "generate",
-        "command": "/workflow:ui-design:generate",
-        "description": "Assemble UI prototypes by combining layout templates with design tokens (default animation support), pure assembler without new content generation",
-        "arguments": "[--design-id <id>] [--session <id>]",
-        "category": "workflow",
-        "subcategory": "ui-design",
-        "usage_scenario": "implementation",
-        "difficulty": "Intermediate",
-        "file_path": "workflow/ui-design/generate.md"
-      },
-      {
-        "name": "imitate-auto",
-        "command": "/workflow:ui-design:imitate-auto",
-        "description": "UI design workflow with direct code/image input for design token extraction and prototype generation",
-        "arguments": "[--input \"<value>\"] [--session <id>]",
-        "category": "workflow",
-        "subcategory": "ui-design",
-        "usage_scenario": "general",
-        "difficulty": "Intermediate",
-        "file_path": "workflow/ui-design/imitate-auto.md"
-      },
-      {
-        "name": "workflow:ui-design:import-from-code",
-        "command": "/workflow:ui-design:import-from-code",
-        "description": "Import design system from code files (CSS/JS/HTML/SCSS) with automatic file discovery and parallel agent analysis",
-        "arguments": "[--design-id <id>] [--session <id>] [--source <path>]",
-        "category": "workflow",
-        "subcategory": "ui-design",
-        "usage_scenario": "planning",
-        "difficulty": "Intermediate",
-        "file_path": "workflow/ui-design/import-from-code.md"
-      },
-      {
-        "name": "layout-extract",
-        "command": "/workflow:ui-design:layout-extract",
-        "description": "Extract structural layout information from reference images or text prompts using Claude analysis with variant generation or refinement mode",
-        "arguments": "[--design-id <id>] [--session <id>] [--images \"<glob>\"] [--prompt \"<desc>\"] [--targets \"<list>\"] [--variants <count>] [--device-type <desktop|mobile|tablet|responsive>] [--interactive] [--refine]",
-        "category": "workflow",
-        "subcategory": "ui-design",
-        "usage_scenario": "general",
-        "difficulty": "Intermediate",
-        "file_path": "workflow/ui-design/layout-extract.md"
-      },
-      {
-        "name": "workflow:ui-design:reference-page-generator",
-        "command": "/workflow:ui-design:reference-page-generator",
-        "description": "Generate multi-component reference pages and documentation from design run extraction",
-        "arguments": "[--design-run <path>] [--package-name <name>] [--output-dir <path>]",
-        "category": "workflow",
-        "subcategory": "ui-design",
-        "usage_scenario": "planning",
-        "difficulty": "Intermediate",
-        "file_path": "workflow/ui-design/reference-page-generator.md"
-      },
-      {
-        "name": "style-extract",
-        "command": "/workflow:ui-design:style-extract",
-        "description": "Extract design style from reference images or text prompts using Claude analysis with variant generation or refinement mode",
-        "arguments": "[--design-id <id>] [--session <id>] [--images \"<glob>\"] [--prompt \"<desc>\"] [--variants <count>] [--interactive] [--refine]",
-        "category": "workflow",
-        "subcategory": "ui-design",
-        "usage_scenario": "general",
-        "difficulty": "Intermediate",
-        "file_path": "workflow/ui-design/style-extract.md"
-      }
-    ]
-  }
-}

.claude/skills/command-guide/index/by-use-case.json

@@ -1,786 +0,0 @@
-{
-  "general": [
-    {
-      "name": "cli-init",
-      "command": "/cli:cli-init",
-      "description": "Generate .gemini/ and .qwen/ config directories with settings.json and ignore files based on workspace technology detection",
-      "arguments": "[--tool gemini|qwen|all] [--output path] [--preview]",
-      "category": "cli",
-      "subcategory": null,
-      "usage_scenario": "general",
-      "difficulty": "Intermediate",
-      "file_path": "cli/cli-init.md"
-    },
-    {
-      "name": "enhance-prompt",
-      "command": "/enhance-prompt",
-      "description": "Enhanced prompt transformation using session memory and intent analysis with --enhance flag detection",
-      "arguments": "user input to enhance",
-      "category": "general",
-      "subcategory": null,
-      "usage_scenario": "general",
-      "difficulty": "Intermediate",
-      "file_path": "enhance-prompt.md"
-    },
-    {
-      "name": "load",
-      "command": "/memory:load",
-      "description": "Delegate to universal-executor agent to analyze project via Gemini/Qwen CLI and return JSON core content package for task context",
-      "arguments": "[--tool gemini|qwen] \\\"task context description\\",
-      "category": "memory",
-      "subcategory": null,
-      "usage_scenario": "general",
-      "difficulty": "Intermediate",
-      "file_path": "memory/load.md"
-    },
-    {
-      "name": "tech-research",
-      "command": "/memory:tech-research",
-      "description": "3-phase orchestrator: extract tech stack → Exa research → generate path-conditional rules (auto-loaded by Claude Code)",
-      "arguments": "[session-id | tech-stack-name] [--regenerate] [--tool <gemini|qwen>]",
-      "category": "memory",
-      "subcategory": null,
-      "usage_scenario": "general",
-      "difficulty": "Intermediate",
-      "file_path": "memory/tech-research.md"
-    },
-    {
-      "name": "update-full",
-      "command": "/memory:update-full",
-      "description": "Update all CLAUDE.md files using layer-based execution (Layer 3→1) with batched agents (4 modules/agent) and gemini→qwen→codex fallback, <20 modules uses direct parallel",
-      "arguments": "[--tool gemini|qwen|codex] [--path <directory>]",
-      "category": "memory",
-      "subcategory": null,
-      "usage_scenario": "general",
-      "difficulty": "Intermediate",
-      "file_path": "memory/update-full.md"
-    },
-    {
-      "name": "update-related",
-      "command": "/memory:update-related",
-      "description": "Update CLAUDE.md for git-changed modules using batched agent execution (4 modules/agent) with gemini→qwen→codex fallback, <15 modules uses direct execution",
-      "arguments": "[--tool gemini|qwen|codex]",
-      "category": "memory",
-      "subcategory": null,
-      "usage_scenario": "general",
-      "difficulty": "Intermediate",
-      "file_path": "memory/update-related.md"
-    },
-    {
-      "name": "version",
-      "command": "/version",
-      "description": "Display Claude Code version information and check for updates",
-      "arguments": "",
-      "category": "general",
-      "subcategory": null,
-      "usage_scenario": "general",
-      "difficulty": "Beginner",
-      "file_path": "version.md"
-    },
-    {
-      "name": "artifacts",
-      "command": "/workflow:brainstorm:artifacts",
-      "description": "Interactive clarification generating confirmed guidance specification through role-based analysis and synthesis",
-      "arguments": "topic or challenge description [--count N]",
-      "category": "workflow",
-      "subcategory": "brainstorm",
-      "usage_scenario": "general",
-      "difficulty": "Intermediate",
-      "file_path": "workflow/brainstorm/artifacts.md"
-    },
-    {
-      "name": "auto-parallel",
-      "command": "/workflow:brainstorm:auto-parallel",
-      "description": "Parallel brainstorming automation with dynamic role selection and concurrent execution across multiple perspectives",
-      "arguments": "topic or challenge description\" [--count N]",
-      "category": "workflow",
-      "subcategory": "brainstorm",
-      "usage_scenario": "general",
-      "difficulty": "Advanced",
-      "file_path": "workflow/brainstorm/auto-parallel.md"
-    },
-    {
-      "name": "data-architect",
-      "command": "/workflow:brainstorm:data-architect",
-      "description": "Generate or update data-architect/analysis.md addressing guidance-specification discussion points for data architecture perspective",
-      "arguments": "optional topic - uses existing framework if available",
-      "category": "workflow",
-      "subcategory": "brainstorm",
-      "usage_scenario": "general",
-      "difficulty": "Intermediate",
-      "file_path": "workflow/brainstorm/data-architect.md"
-    },
-    {
-      "name": "product-manager",
-      "command": "/workflow:brainstorm:product-manager",
-      "description": "Generate or update product-manager/analysis.md addressing guidance-specification discussion points for product management perspective",
-      "arguments": "optional topic - uses existing framework if available",
-      "category": "workflow",
-      "subcategory": "brainstorm",
-      "usage_scenario": "general",
-      "difficulty": "Intermediate",
-      "file_path": "workflow/brainstorm/product-manager.md"
-    },
-    {
-      "name": "product-owner",
-      "command": "/workflow:brainstorm:product-owner",
-      "description": "Generate or update product-owner/analysis.md addressing guidance-specification discussion points for product ownership perspective",
-      "arguments": "optional topic - uses existing framework if available",
-      "category": "workflow",
-      "subcategory": "brainstorm",
-      "usage_scenario": "general",
-      "difficulty": "Intermediate",
-      "file_path": "workflow/brainstorm/product-owner.md"
-    },
-    {
-      "name": "scrum-master",
-      "command": "/workflow:brainstorm:scrum-master",
-      "description": "Generate or update scrum-master/analysis.md addressing guidance-specification discussion points for Agile process perspective",
-      "arguments": "optional topic - uses existing framework if available",
-      "category": "workflow",
-      "subcategory": "brainstorm",
-      "usage_scenario": "general",
-      "difficulty": "Intermediate",
-      "file_path": "workflow/brainstorm/scrum-master.md"
-    },
-    {
-      "name": "subject-matter-expert",
-      "command": "/workflow:brainstorm:subject-matter-expert",
-      "description": "Generate or update subject-matter-expert/analysis.md addressing guidance-specification discussion points for domain expertise perspective",
-      "arguments": "optional topic - uses existing framework if available",
-      "category": "workflow",
-      "subcategory": "brainstorm",
-      "usage_scenario": "general",
-      "difficulty": "Intermediate",
-      "file_path": "workflow/brainstorm/subject-matter-expert.md"
-    },
-    {
-      "name": "synthesis",
-      "command": "/workflow:brainstorm:synthesis",
-      "description": "Clarify and refine role analyses through intelligent Q&A and targeted updates with synthesis agent",
-      "arguments": "[optional: --session session-id]",
-      "category": "workflow",
-      "subcategory": "brainstorm",
-      "usage_scenario": "general",
-      "difficulty": "Advanced",
-      "file_path": "workflow/brainstorm/synthesis.md"
-    },
-    {
-      "name": "system-architect",
-      "command": "/workflow:brainstorm:system-architect",
-      "description": "Generate or update system-architect/analysis.md addressing guidance-specification discussion points for system architecture perspective",
-      "arguments": "optional topic - uses existing framework if available",
-      "category": "workflow",
-      "subcategory": "brainstorm",
-      "usage_scenario": "general",
-      "difficulty": "Intermediate",
-      "file_path": "workflow/brainstorm/system-architect.md"
-    },
-    {
-      "name": "ux-expert",
-      "command": "/workflow:brainstorm:ux-expert",
-      "description": "Generate or update ux-expert/analysis.md addressing guidance-specification discussion points for UX perspective",
-      "arguments": "optional topic - uses existing framework if available",
-      "category": "workflow",
-      "subcategory": "brainstorm",
-      "usage_scenario": "general",
-      "difficulty": "Intermediate",
-      "file_path": "workflow/brainstorm/ux-expert.md"
-    },
-    {
-      "name": "init",
-      "command": "/workflow:init",
-      "description": "Initialize project-level state with intelligent project analysis using cli-explore-agent",
-      "arguments": "[--regenerate]",
-      "category": "workflow",
-      "subcategory": null,
-      "usage_scenario": "general",
-      "difficulty": "Intermediate",
-      "file_path": "workflow/init.md"
-    },
-    {
-      "name": "lite-fix",
-      "command": "/workflow:lite-fix",
-      "description": "Lightweight bug diagnosis and fix workflow with intelligent severity assessment and optional hotfix mode for production incidents",
-      "arguments": "[--hotfix] \\\"bug description or issue reference\\",
-      "category": "workflow",
-      "subcategory": null,
-      "usage_scenario": "general",
-      "difficulty": "Intermediate",
-      "file_path": "workflow/lite-fix.md"
-    },
-    {
-      "name": "list",
-      "command": "/workflow:session:list",
-      "description": "List all workflow sessions with status filtering, shows session metadata and progress information",
-      "arguments": "",
-      "category": "workflow",
-      "subcategory": "session",
-      "usage_scenario": "general",
-      "difficulty": "Beginner",
-      "file_path": "workflow/session/list.md"
-    },
-    {
-      "name": "start",
-      "command": "/workflow:session:start",
-      "description": "Discover existing sessions or start new workflow session with intelligent session management and conflict detection",
-      "arguments": "[--type <workflow|review|tdd|test|docs>] [--auto|--new] [optional: task description for new session]",
-      "category": "workflow",
-      "subcategory": "session",
-      "usage_scenario": "general",
-      "difficulty": "Intermediate",
-      "file_path": "workflow/session/start.md"
-    },
-    {
-      "name": "conflict-resolution",
-      "command": "/workflow:tools:conflict-resolution",
-      "description": "Detect and resolve conflicts between plan and existing codebase using CLI-powered analysis with Gemini/Qwen",
-      "arguments": "--session WFS-session-id --context path/to/context-package.json",
-      "category": "workflow",
-      "subcategory": "tools",
-      "usage_scenario": "general",
-      "difficulty": "Advanced",
-      "file_path": "workflow/tools/conflict-resolution.md"
-    },
-    {
-      "name": "gather",
-      "command": "/workflow:tools:gather",
-      "description": "Intelligently collect project context using context-search-agent based on task description, packages into standardized JSON",
-      "arguments": "--session WFS-session-id \\\"task description\\",
-      "category": "workflow",
-      "subcategory": "tools",
-      "usage_scenario": "general",
-      "difficulty": "Intermediate",
-      "file_path": "workflow/tools/context-gather.md"
-    },
-    {
-      "name": "animation-extract",
-      "command": "/workflow:ui-design:animation-extract",
-      "description": "Extract animation and transition patterns from prompt inference and image references for design system documentation",
-      "arguments": "[--design-id <id>] [--session <id>] [--images \"<glob>\"] [--focus \"<types>\"] [--interactive] [--refine]",
-      "category": "workflow",
-      "subcategory": "ui-design",
-      "usage_scenario": "general",
-      "difficulty": "Intermediate",
-      "file_path": "workflow/ui-design/animation-extract.md"
-    },
-    {
-      "name": "explore-auto",
-      "command": "/workflow:ui-design:explore-auto",
-      "description": "Interactive exploratory UI design workflow with style-centric batch generation, creates design variants from prompts/images with parallel execution and user selection",
-      "arguments": "[--input \"<value>\"] [--targets \"<list>\"] [--target-type \"page|component\"] [--session <id>] [--style-variants <count>] [--layout-variants <count>]",
-      "category": "workflow",
-      "subcategory": "ui-design",
-      "usage_scenario": "general",
-      "difficulty": "Intermediate",
-      "file_path": "workflow/ui-design/explore-auto.md"
-    },
-    {
-      "name": "imitate-auto",
-      "command": "/workflow:ui-design:imitate-auto",
-      "description": "UI design workflow with direct code/image input for design token extraction and prototype generation",
-      "arguments": "[--input \"<value>\"] [--session <id>]",
-      "category": "workflow",
-      "subcategory": "ui-design",
-      "usage_scenario": "general",
-      "difficulty": "Intermediate",
-      "file_path": "workflow/ui-design/imitate-auto.md"
-    },
-    {
-      "name": "layout-extract",
-      "command": "/workflow:ui-design:layout-extract",
-      "description": "Extract structural layout information from reference images or text prompts using Claude analysis with variant generation or refinement mode",
-      "arguments": "[--design-id <id>] [--session <id>] [--images \"<glob>\"] [--prompt \"<desc>\"] [--targets \"<list>\"] [--variants <count>] [--device-type <desktop|mobile|tablet|responsive>] [--interactive] [--refine]",
-      "category": "workflow",
-      "subcategory": "ui-design",
-      "usage_scenario": "general",
-      "difficulty": "Intermediate",
-      "file_path": "workflow/ui-design/layout-extract.md"
-    },
-    {
-      "name": "style-extract",
-      "command": "/workflow:ui-design:style-extract",
-      "description": "Extract design style from reference images or text prompts using Claude analysis with variant generation or refinement mode",
-      "arguments": "[--design-id <id>] [--session <id>] [--images \"<glob>\"] [--prompt \"<desc>\"] [--variants <count>] [--interactive] [--refine]",
-      "category": "workflow",
-      "subcategory": "ui-design",
-      "usage_scenario": "general",
-      "difficulty": "Intermediate",
-      "file_path": "workflow/ui-design/style-extract.md"
-    }
-  ],
-  "documentation": [
-    {
-      "name": "code-map-memory",
-      "command": "/memory:code-map-memory",
-      "description": "3-phase orchestrator: parse feature keyword → cli-explore-agent analyzes (Deep Scan dual-source) → orchestrator generates Mermaid docs + SKILL package (skips phase 2 if exists)",
-      "arguments": "\\\"feature-keyword\\\" [--regenerate] [--tool <gemini|qwen>]",
-      "category": "memory",
-      "subcategory": null,
-      "usage_scenario": "documentation",
-      "difficulty": "Intermediate",
-      "file_path": "memory/code-map-memory.md"
-    },
-    {
-      "name": "docs-full-cli",
-      "command": "/memory:docs-full-cli",
-      "description": "Generate full project documentation using CLI execution (Layer 3→1) with batched agents (4 modules/agent) and gemini→qwen→codex fallback, <20 modules uses direct parallel",
-      "arguments": "[path] [--tool <gemini|qwen|codex>]",
-      "category": "memory",
-      "subcategory": null,
-      "usage_scenario": "documentation",
-      "difficulty": "Intermediate",
-      "file_path": "memory/docs-full-cli.md"
-    },
-    {
-      "name": "docs-related-cli",
-      "command": "/memory:docs-related-cli",
-      "description": "Generate/update documentation for git-changed modules using CLI execution with batched agents (4 modules/agent) and gemini→qwen→codex fallback, <15 modules uses direct parallel",
-      "arguments": "[--tool <gemini|qwen|codex>]",
-      "category": "memory",
-      "subcategory": null,
-      "usage_scenario": "documentation",
-      "difficulty": "Intermediate",
-      "file_path": "memory/docs-related-cli.md"
-    },
-    {
-      "name": "docs",
-      "command": "/memory:docs",
-      "description": "Plan documentation workflow with dynamic grouping (≤10 docs/task), generates IMPL tasks for parallel module trees, README, ARCHITECTURE, and HTTP API docs",
-      "arguments": "[path] [--tool <gemini|qwen|codex>] [--mode <full|partial>] [--cli-execute]",
-      "category": "memory",
-      "subcategory": null,
-      "usage_scenario": "documentation",
-      "difficulty": "Intermediate",
-      "file_path": "memory/docs.md"
-    },
-    {
-      "name": "load-skill-memory",
-      "command": "/memory:load-skill-memory",
-      "description": "Activate SKILL package (auto-detect from paths/keywords or manual) and intelligently load documentation based on task intent keywords",
-      "arguments": "[skill_name] \\\"task intent description\\",
-      "category": "memory",
-      "subcategory": null,
-      "usage_scenario": "documentation",
-      "difficulty": "Intermediate",
-      "file_path": "memory/load-skill-memory.md"
-    },
-    {
-      "name": "skill-memory",
-      "command": "/memory:skill-memory",
-      "description": "4-phase autonomous orchestrator: check docs → /memory:docs planning → /workflow:execute → generate SKILL.md with progressive loading index (skips phases 2-3 if docs exist)",
-      "arguments": "[path] [--tool <gemini|qwen|codex>] [--regenerate] [--mode <full|partial>] [--cli-execute]",
-      "category": "memory",
-      "subcategory": null,
-      "usage_scenario": "documentation",
-      "difficulty": "Intermediate",
-      "file_path": "memory/skill-memory.md"
-    },
-    {
-      "name": "style-skill-memory",
-      "command": "/memory:style-skill-memory",
-      "description": "Generate SKILL memory package from style reference for easy loading and consistent design system usage",
-      "arguments": "[package-name] [--regenerate]",
-      "category": "memory",
-      "subcategory": null,
-      "usage_scenario": "documentation",
-      "difficulty": "Intermediate",
-      "file_path": "memory/style-skill-memory.md"
-    },
-    {
-      "name": "workflow-skill-memory",
-      "command": "/memory:workflow-skill-memory",
-      "description": "Process WFS-* archived sessions using universal-executor agents with Gemini analysis to generate workflow-progress SKILL package (sessions-timeline, lessons, conflicts)",
-      "arguments": "session <session-id> | all",
-      "category": "memory",
-      "subcategory": null,
-      "usage_scenario": "documentation",
-      "difficulty": "Intermediate",
-      "file_path": "memory/workflow-skill-memory.md"
-    }
-  ],
-  "planning": [
-    {
-      "name": "breakdown",
-      "command": "/task:breakdown",
-      "description": "Decompose complex task into subtasks with dependency mapping, creates child task JSONs with parent references and execution order",
-      "arguments": "task-id",
-      "category": "task",
-      "subcategory": null,
-      "usage_scenario": "planning",
-      "difficulty": "Intermediate",
-      "file_path": "task/breakdown.md"
-    },
-    {
-      "name": "replan",
-      "command": "/task:replan",
-      "description": "Update task JSON with new requirements or batch-update multiple tasks from verification report, tracks changes in task-changes.json",
-      "arguments": "task-id [\\\"text\\\"|file.md] | --batch [verification-report.md]",
-      "category": "task",
-      "subcategory": null,
-      "usage_scenario": "planning",
-      "difficulty": "Intermediate",
-      "file_path": "task/replan.md"
-    },
-    {
-      "name": "action-plan-verify",
-      "command": "/workflow:action-plan-verify",
-      "description": "Perform non-destructive cross-artifact consistency analysis between IMPL_PLAN.md and task JSONs with quality gate validation",
-      "arguments": "[optional: --session session-id]",
-      "category": "workflow",
-      "subcategory": null,
-      "usage_scenario": "planning",
-      "difficulty": "Intermediate",
-      "file_path": "workflow/action-plan-verify.md"
-    },
-    {
-      "name": "api-designer",
-      "command": "/workflow:brainstorm:api-designer",
-      "description": "Generate or update api-designer/analysis.md addressing guidance-specification discussion points for API design perspective",
-      "arguments": "optional topic - uses existing framework if available",
-      "category": "workflow",
-      "subcategory": "brainstorm",
-      "usage_scenario": "planning",
-      "difficulty": "Intermediate",
-      "file_path": "workflow/brainstorm/api-designer.md"
-    },
-    {
-      "name": "ui-designer",
-      "command": "/workflow:brainstorm:ui-designer",
-      "description": "Generate or update ui-designer/analysis.md addressing guidance-specification discussion points for UI design perspective",
-      "arguments": "optional topic - uses existing framework if available",
-      "category": "workflow",
-      "subcategory": "brainstorm",
-      "usage_scenario": "planning",
-      "difficulty": "Intermediate",
-      "file_path": "workflow/brainstorm/ui-designer.md"
-    },
-    {
-      "name": "lite-plan",
-      "command": "/workflow:lite-plan",
-      "description": "Lightweight interactive planning workflow with in-memory planning, code exploration, and execution dispatch to lite-execute after user confirmation",
-      "arguments": "[-e|--explore] \\\"task description\\\"|file.md",
-      "category": "workflow",
-      "subcategory": null,
-      "usage_scenario": "planning",
-      "difficulty": "Intermediate",
-      "file_path": "workflow/lite-plan.md"
-    },
-    {
-      "name": "plan",
-      "command": "/workflow:plan",
-      "description": "5-phase planning workflow with action-planning-agent task generation, outputs IMPL_PLAN.md and task JSONs",
-      "arguments": "\\\"text description\\\"|file.md",
-      "category": "workflow",
-      "subcategory": null,
-      "usage_scenario": "planning",
-      "difficulty": "Intermediate",
-      "file_path": "workflow/plan.md"
-    },
-    {
-      "name": "replan",
-      "command": "/workflow:replan",
-      "description": "Interactive workflow replanning with session-level artifact updates and boundary clarification through guided questioning",
-      "arguments": "[--session session-id] [task-id] \\\"requirements\\\"|file.md [--interactive]",
-      "category": "workflow",
-      "subcategory": null,
-      "usage_scenario": "planning",
-      "difficulty": "Intermediate",
-      "file_path": "workflow/replan.md"
-    },
-    {
-      "name": "tdd-plan",
-      "command": "/workflow:tdd-plan",
-      "description": "TDD workflow planning with Red-Green-Refactor task chain generation, test-first development structure, and cycle tracking",
-      "arguments": "\\\"feature description\\\"|file.md",
-      "category": "workflow",
-      "subcategory": null,
-      "usage_scenario": "planning",
-      "difficulty": "Advanced",
-      "file_path": "workflow/tdd-plan.md"
-    },
-    {
-      "name": "workflow:ui-design:codify-style",
-      "command": "/workflow:ui-design:codify-style",
-      "description": "Orchestrator to extract styles from code and generate shareable reference package with preview (automatic file discovery)",
-      "arguments": "<path> [--package-name <name>] [--output-dir <path>] [--overwrite]",
-      "category": "workflow",
-      "subcategory": "ui-design",
-      "usage_scenario": "planning",
-      "difficulty": "Intermediate",
-      "file_path": "workflow/ui-design/codify-style.md"
-    },
-    {
-      "name": "design-sync",
-      "command": "/workflow:ui-design:design-sync",
-      "description": "Synchronize finalized design system references to brainstorming artifacts, preparing them for /workflow:plan consumption",
-      "arguments": "--session <session_id> [--selected-prototypes \"<list>\"]",
-      "category": "workflow",
-      "subcategory": "ui-design",
-      "usage_scenario": "planning",
-      "difficulty": "Intermediate",
-      "file_path": "workflow/ui-design/design-sync.md"
-    },
-    {
-      "name": "workflow:ui-design:import-from-code",
-      "command": "/workflow:ui-design:import-from-code",
-      "description": "Import design system from code files (CSS/JS/HTML/SCSS) with automatic file discovery and parallel agent analysis",
-      "arguments": "[--design-id <id>] [--session <id>] [--source <path>]",
-      "category": "workflow",
-      "subcategory": "ui-design",
-      "usage_scenario": "planning",
-      "difficulty": "Intermediate",
-      "file_path": "workflow/ui-design/import-from-code.md"
-    },
-    {
-      "name": "workflow:ui-design:reference-page-generator",
-      "command": "/workflow:ui-design:reference-page-generator",
-      "description": "Generate multi-component reference pages and documentation from design run extraction",
-      "arguments": "[--design-run <path>] [--package-name <name>] [--output-dir <path>]",
-      "category": "workflow",
-      "subcategory": "ui-design",
-      "usage_scenario": "planning",
-      "difficulty": "Intermediate",
-      "file_path": "workflow/ui-design/reference-page-generator.md"
-    }
-  ],
-  "implementation": [
-    {
-      "name": "create",
-      "command": "/task:create",
-      "description": "Generate task JSON from natural language description with automatic file pattern detection, scope inference, and dependency analysis",
-      "arguments": "\\\"task title\\",
-      "category": "task",
-      "subcategory": null,
-      "usage_scenario": "implementation",
-      "difficulty": "Intermediate",
-      "file_path": "task/create.md"
-    },
-    {
-      "name": "execute",
-      "command": "/task:execute",
-      "description": "Execute task JSON using appropriate agent (@doc-generator/@implementation-agent/@test-agent) with pre-analysis context loading and status tracking",
-      "arguments": "task-id",
-      "category": "task",
-      "subcategory": null,
-      "usage_scenario": "implementation",
-      "difficulty": "Intermediate",
-      "file_path": "task/execute.md"
-    },
-    {
-      "name": "execute",
-      "command": "/workflow:execute",
-      "description": "Coordinate agent execution for workflow tasks with automatic session discovery, parallel task processing, and status tracking",
-      "arguments": "[--resume-session=\\\"session-id\\\"]",
-      "category": "workflow",
-      "subcategory": null,
-      "usage_scenario": "implementation",
-      "difficulty": "Intermediate",
-      "file_path": "workflow/execute.md"
-    },
-    {
-      "name": "lite-execute",
-      "command": "/workflow:lite-execute",
-      "description": "Execute tasks based on in-memory plan, prompt description, or file content",
-      "arguments": "[--in-memory] [\\\"task description\\\"|file-path]",
-      "category": "workflow",
-      "subcategory": null,
-      "usage_scenario": "implementation",
-      "difficulty": "Intermediate",
-      "file_path": "workflow/lite-execute.md"
-    },
-    {
-      "name": "test-cycle-execute",
-      "command": "/workflow:test-cycle-execute",
-      "description": "Execute test-fix workflow with dynamic task generation and iterative fix cycles until test pass rate >= 95% or max iterations reached. Uses @cli-planning-agent for failure analysis and task generation.",
-      "arguments": "[--resume-session=\\\"session-id\\\"] [--max-iterations=N]",
-      "category": "workflow",
-      "subcategory": null,
-      "usage_scenario": "implementation",
-      "difficulty": "Intermediate",
-      "file_path": "workflow/test-cycle-execute.md"
-    },
-    {
-      "name": "task-generate-agent",
-      "command": "/workflow:tools:task-generate-agent",
-      "description": "Generate implementation plan documents (IMPL_PLAN.md, task JSONs, TODO_LIST.md) using action-planning-agent - produces planning artifacts, does NOT execute code implementation",
-      "arguments": "--session WFS-session-id",
-      "category": "workflow",
-      "subcategory": "tools",
-      "usage_scenario": "implementation",
-      "difficulty": "Advanced",
-      "file_path": "workflow/tools/task-generate-agent.md"
-    },
-    {
-      "name": "task-generate-tdd",
-      "command": "/workflow:tools:task-generate-tdd",
-      "description": "Autonomous TDD task generation using action-planning-agent with Red-Green-Refactor cycles, test-first structure, and cycle validation",
-      "arguments": "--session WFS-session-id",
-      "category": "workflow",
-      "subcategory": "tools",
-      "usage_scenario": "implementation",
-      "difficulty": "Advanced",
-      "file_path": "workflow/tools/task-generate-tdd.md"
-    },
-    {
-      "name": "test-task-generate",
-      "command": "/workflow:tools:test-task-generate",
-      "description": "Generate test planning documents (IMPL_PLAN.md, test task JSONs, TODO_LIST.md) using action-planning-agent - produces test planning artifacts, does NOT execute tests",
-      "arguments": "--session WFS-test-session-id",
-      "category": "workflow",
-      "subcategory": "tools",
-      "usage_scenario": "implementation",
-      "difficulty": "Intermediate",
-      "file_path": "workflow/tools/test-task-generate.md"
-    },
-    {
-      "name": "generate",
-      "command": "/workflow:ui-design:generate",
-      "description": "Assemble UI prototypes by combining layout templates with design tokens (default animation support), pure assembler without new content generation",
-      "arguments": "[--design-id <id>] [--session <id>]",
-      "category": "workflow",
-      "subcategory": "ui-design",
-      "usage_scenario": "implementation",
-      "difficulty": "Intermediate",
-      "file_path": "workflow/ui-design/generate.md"
-    }
-  ],
-  "analysis": [
-    {
-      "name": "review-fix",
-      "command": "/workflow:review-fix",
-      "description": "Automated fixing of code review findings with AI-powered planning and coordinated execution. Uses intelligent grouping, multi-stage timeline coordination, and test-driven verification.",
-      "arguments": "<export-file|review-dir> [--resume] [--max-iterations=N]",
-      "category": "workflow",
-      "subcategory": null,
-      "usage_scenario": "analysis",
-      "difficulty": "Intermediate",
-      "file_path": "workflow/review-fix.md"
-    },
-    {
-      "name": "review-module-cycle",
-      "command": "/workflow:review-module-cycle",
-      "description": "Independent multi-dimensional code review for specified modules/files. Analyzes specific code paths across 7 dimensions with hybrid parallel-iterative execution, independent of workflow sessions.",
-      "arguments": "<path-pattern> [--dimensions=security,architecture,...] [--max-iterations=N]",
-      "category": "workflow",
-      "subcategory": null,
-      "usage_scenario": "analysis",
-      "difficulty": "Intermediate",
-      "file_path": "workflow/review-module-cycle.md"
-    },
-    {
-      "name": "review",
-      "command": "/workflow:review",
-      "description": "Post-implementation review with specialized types (security/architecture/action-items/quality) using analysis agents and Gemini",
-      "arguments": "[--type=security|architecture|action-items|quality] [optional: session-id]",
-      "category": "workflow",
-      "subcategory": null,
-      "usage_scenario": "analysis",
-      "difficulty": "Intermediate",
-      "file_path": "workflow/review.md"
-    }
-  ],
-  "session-management": [
-    {
-      "name": "review-session-cycle",
-      "command": "/workflow:review-session-cycle",
-      "description": "Session-based comprehensive multi-dimensional code review. Analyzes git changes from workflow session across 7 dimensions with hybrid parallel-iterative execution, aggregates findings, and performs focused deep-dives on critical issues until quality gates met.",
-      "arguments": "[session-id] [--dimensions=security,architecture,...] [--max-iterations=N]",
-      "category": "workflow",
-      "subcategory": null,
-      "usage_scenario": "session-management",
-      "difficulty": "Intermediate",
-      "file_path": "workflow/review-session-cycle.md"
-    },
-    {
-      "name": "complete",
-      "command": "/workflow:session:complete",
-      "description": "Mark active workflow session as complete, archive with lessons learned, update manifest, remove active flag",
-      "arguments": "",
-      "category": "workflow",
-      "subcategory": "session",
-      "usage_scenario": "session-management",
-      "difficulty": "Intermediate",
-      "file_path": "workflow/session/complete.md"
-    },
-    {
-      "name": "resume",
-      "command": "/workflow:session:resume",
-      "description": "Resume the most recently paused workflow session with automatic session discovery and status update",
-      "arguments": "",
-      "category": "workflow",
-      "subcategory": "session",
-      "usage_scenario": "session-management",
-      "difficulty": "Intermediate",
-      "file_path": "workflow/session/resume.md"
-    }
-  ],
-  "testing": [
-    {
-      "name": "tdd-verify",
-      "command": "/workflow:tdd-verify",
-      "description": "Verify TDD workflow compliance against Red-Green-Refactor cycles, generate quality report with coverage analysis",
-      "arguments": "[optional: WFS-session-id]",
-      "category": "workflow",
-      "subcategory": null,
-      "usage_scenario": "testing",
-      "difficulty": "Advanced",
-      "file_path": "workflow/tdd-verify.md"
-    },
-    {
-      "name": "test-fix-gen",
-      "command": "/workflow:test-fix-gen",
-      "description": "Create test-fix workflow session from session ID, description, or file path with test strategy generation and task planning",
-      "arguments": "(source-session-id | \\\"feature description\\\" | /path/to/file.md)",
-      "category": "workflow",
-      "subcategory": null,
-      "usage_scenario": "testing",
-      "difficulty": "Intermediate",
-      "file_path": "workflow/test-fix-gen.md"
-    },
-    {
-      "name": "test-gen",
-      "command": "/workflow:test-gen",
-      "description": "Create independent test-fix workflow session from completed implementation session, analyzes code to generate test tasks",
-      "arguments": "source-session-id",
-      "category": "workflow",
-      "subcategory": null,
-      "usage_scenario": "testing",
-      "difficulty": "Intermediate",
-      "file_path": "workflow/test-gen.md"
-    },
-    {
-      "name": "tdd-coverage-analysis",
-      "command": "/workflow:tools:tdd-coverage-analysis",
-      "description": "Analyze test coverage and TDD cycle execution with Red-Green-Refactor compliance verification",
-      "arguments": "--session WFS-session-id",
-      "category": "workflow",
-      "subcategory": "tools",
-      "usage_scenario": "testing",
-      "difficulty": "Advanced",
-      "file_path": "workflow/tools/tdd-coverage-analysis.md"
-    },
-    {
-      "name": "test-concept-enhanced",
-      "command": "/workflow:tools:test-concept-enhanced",
-      "description": "Coordinate test analysis workflow using cli-execution-agent to generate test strategy via Gemini",
-      "arguments": "--session WFS-test-session-id --context path/to/test-context-package.json",
-      "category": "workflow",
-      "subcategory": "tools",
-      "usage_scenario": "testing",
-      "difficulty": "Intermediate",
-      "file_path": "workflow/tools/test-concept-enhanced.md"
-    },
-    {
-      "name": "test-context-gather",
-      "command": "/workflow:tools:test-context-gather",
-      "description": "Collect test coverage context using test-context-search-agent and package into standardized test-context JSON",
-      "arguments": "--session WFS-test-session-id",
-      "category": "workflow",
-      "subcategory": "tools",
-      "usage_scenario": "testing",
-      "difficulty": "Intermediate",
-      "file_path": "workflow/tools/test-context-gather.md"
-    }
-  ]
-}

.claude/skills/command-guide/index/command-relationships.json

@@ -1,307 +0,0 @@
-{
-  "workflow:plan": {
-    "calls_internally": [
-      "workflow:session:start",
-      "workflow:tools:context-gather",
-      "workflow:tools:conflict-resolution",
-      "workflow:tools:task-generate-agent"
-    ],
-    "next_steps": [
-      "workflow:action-plan-verify",
-      "workflow:status",
-      "workflow:execute"
-    ],
-    "alternatives": [
-      "workflow:tdd-plan"
-    ],
-    "prerequisites": []
-  },
-  "workflow:tdd-plan": {
-    "calls_internally": [
-      "workflow:session:start",
-      "workflow:tools:context-gather",
-      "workflow:tools:task-generate-tdd"
-    ],
-    "next_steps": [
-      "workflow:tdd-verify",
-      "workflow:status",
-      "workflow:execute"
-    ],
-    "alternatives": [
-      "workflow:plan"
-    ],
-    "prerequisites": []
-  },
-  "workflow:execute": {
-    "prerequisites": [
-      "workflow:plan",
-      "workflow:tdd-plan"
-    ],
-    "related": [
-      "workflow:status",
-      "workflow:resume"
-    ],
-    "next_steps": [
-      "workflow:review",
-      "workflow:tdd-verify"
-    ]
-  },
-  "workflow:action-plan-verify": {
-    "prerequisites": [
-      "workflow:plan"
-    ],
-    "next_steps": [
-      "workflow:execute"
-    ],
-    "related": [
-      "workflow:status"
-    ]
-  },
-  "workflow:tdd-verify": {
-    "prerequisites": [
-      "workflow:execute"
-    ],
-    "related": [
-      "workflow:tools:tdd-coverage-analysis"
-    ]
-  },
-  "workflow:session:start": {
-    "next_steps": [
-      "workflow:plan",
-      "workflow:execute"
-    ],
-    "related": [
-      "workflow:session:list",
-      "workflow:session:resume"
-    ]
-  },
-  "workflow:session:resume": {
-    "alternatives": [
-      "workflow:resume"
-    ],
-    "related": [
-      "workflow:session:list",
-      "workflow:status"
-    ]
-  },
-  "workflow:resume": {
-    "alternatives": [
-      "workflow:session:resume"
-    ],
-    "related": [
-      "workflow:status"
-    ]
-  },
-  "task:create": {
-    "next_steps": [
-      "task:execute"
-    ],
-    "related": [
-      "task:breakdown"
-    ]
-  },
-  "task:breakdown": {
-    "next_steps": [
-      "task:execute"
-    ],
-    "related": [
-      "task:create"
-    ]
-  },
-  "task:replan": {
-    "prerequisites": [
-      "workflow:plan"
-    ],
-    "related": [
-      "workflow:action-plan-verify"
-    ]
-  },
-  "task:execute": {
-    "prerequisites": [
-      "task:create",
-      "task:breakdown",
-      "workflow:plan"
-    ],
-    "related": [
-      "workflow:status"
-    ]
-  },
-  "memory:docs": {
-    "calls_internally": [
-      "workflow:session:start",
-      "workflow:tools:context-gather"
-    ],
-    "next_steps": [
-      "workflow:execute"
-    ]
-  },
-  "memory:skill-memory": {
-    "next_steps": [
-      "workflow:plan",
-      "cli:analyze"
-    ],
-    "related": [
-      "memory:load-skill-memory"
-    ]
-  },
-  "memory:workflow-skill-memory": {
-    "related": [
-      "memory:skill-memory"
-    ],
-    "next_steps": [
-      "workflow:plan"
-    ]
-  },
-  "cli:execute": {
-    "alternatives": [
-      "cli:codex-execute"
-    ],
-    "related": [
-      "cli:analyze",
-      "cli:chat"
-    ]
-  },
-  "cli:analyze": {
-    "related": [
-      "cli:chat",
-      "cli:mode:code-analysis"
-    ],
-    "next_steps": [
-      "cli:execute"
-    ]
-  },
-  "workflow:brainstorm:artifacts": {
-    "next_steps": [
-      "workflow:brainstorm:synthesis",
-      "workflow:plan"
-    ],
-    "related": [
-      "workflow:brainstorm:auto-parallel"
-    ]
-  },
-  "workflow:brainstorm:synthesis": {
-    "prerequisites": [
-      "workflow:brainstorm:artifacts"
-    ],
-    "next_steps": [
-      "workflow:plan"
-    ]
-  },
-  "workflow:brainstorm:auto-parallel": {
-    "next_steps": [
-      "workflow:brainstorm:synthesis",
-      "workflow:plan"
-    ],
-    "related": [
-      "workflow:brainstorm:artifacts"
-    ]
-  },
-  "workflow:test-gen": {
-    "prerequisites": [
-      "workflow:execute"
-    ],
-    "next_steps": [
-      "workflow:test-cycle-execute"
-    ]
-  },
-  "workflow:test-fix-gen": {
-    "alternatives": [
-      "workflow:test-gen"
-    ],
-    "next_steps": [
-      "workflow:test-cycle-execute"
-    ]
-  },
-  "workflow:test-cycle-execute": {
-    "prerequisites": [
-      "workflow:test-gen",
-      "workflow:test-fix-gen"
-    ],
-    "related": [
-      "workflow:tdd-verify"
-    ]
-  },
-  "workflow:ui-design:explore-auto": {
-    "calls_internally": [
-      "workflow:ui-design:capture",
-      "workflow:ui-design:style-extract",
-      "workflow:ui-design:layout-extract"
-    ],
-    "next_steps": [
-      "workflow:ui-design:generate"
-    ]
-  },
-  "workflow:ui-design:imitate-auto": {
-    "calls_internally": [
-      "workflow:ui-design:capture"
-    ],
-    "next_steps": [
-      "workflow:ui-design:generate"
-    ]
-  },
-  "workflow:lite-plan": {
-    "calls_internally": [
-      "workflow:lite-execute"
-    ],
-    "next_steps": [
-      "workflow:lite-execute",
-      "workflow:status"
-    ],
-    "alternatives": [
-      "workflow:plan"
-    ],
-    "prerequisites": []
-  },
-  "workflow:lite-fix": {
-    "next_steps": [
-      "workflow:lite-execute",
-      "workflow:status"
-    ],
-    "alternatives": [
-      "workflow:lite-plan"
-    ],
-    "related": [
-      "workflow:test-cycle-execute"
-    ]
-  },
-  "workflow:lite-execute": {
-    "prerequisites": [
-      "workflow:lite-plan",
-      "workflow:lite-fix"
-    ],
-    "related": [
-      "workflow:execute",
-      "workflow:status"
-    ]
-  },
-  "workflow:review-module-cycle": {
-    "next_steps": [
-      "workflow:review-fix"
-    ],
-    "related": [
-      "workflow:review-session-cycle",
-      "workflow:review"
-    ]
-  },
-  "workflow:review-session-cycle": {
-    "prerequisites": [
-      "workflow:execute"
-    ],
-    "next_steps": [
-      "workflow:review-fix"
-    ],
-    "related": [
-      "workflow:review-module-cycle",
-      "workflow:review"
-    ]
-  },
-  "workflow:review-fix": {
-    "prerequisites": [
-      "workflow:review-module-cycle",
-      "workflow:review-session-cycle"
-    ],
-    "related": [
-      "workflow:test-cycle-execute"
-    ]
-  }
-}

.claude/skills/command-guide/index/essential-commands.json

@@ -1,112 +0,0 @@
-[
-  {
-    "name": "lite-plan",
-    "command": "/workflow:lite-plan",
-    "description": "Lightweight interactive planning workflow with in-memory planning, code exploration, and execution dispatch to lite-execute after user confirmation",
-    "arguments": "[-e|--explore] \\\"task description\\\"|file.md",
-    "category": "workflow",
-    "subcategory": null,
-    "usage_scenario": "planning",
-    "difficulty": "Intermediate",
-    "file_path": "workflow/lite-plan.md"
-  },
-  {
-    "name": "lite-fix",
-    "command": "/workflow:lite-fix",
-    "description": "Lightweight bug diagnosis and fix workflow with intelligent severity assessment and optional hotfix mode for production incidents",
-    "arguments": "[--hotfix] \\\"bug description or issue reference\\",
-    "category": "workflow",
-    "subcategory": null,
-    "usage_scenario": "general",
-    "difficulty": "Intermediate",
-    "file_path": "workflow/lite-fix.md"
-  },
-  {
-    "name": "plan",
-    "command": "/workflow:plan",
-    "description": "5-phase planning workflow with action-planning-agent task generation, outputs IMPL_PLAN.md and task JSONs",
-    "arguments": "\\\"text description\\\"|file.md",
-    "category": "workflow",
-    "subcategory": null,
-    "usage_scenario": "planning",
-    "difficulty": "Intermediate",
-    "file_path": "workflow/plan.md"
-  },
-  {
-    "name": "execute",
-    "command": "/workflow:execute",
-    "description": "Coordinate agent execution for workflow tasks with automatic session discovery, parallel task processing, and status tracking",
-    "arguments": "[--resume-session=\\\"session-id\\\"]",
-    "category": "workflow",
-    "subcategory": null,
-    "usage_scenario": "implementation",
-    "difficulty": "Intermediate",
-    "file_path": "workflow/execute.md"
-  },
-  {
-    "name": "start",
-    "command": "/workflow:session:start",
-    "description": "Discover existing sessions or start new workflow session with intelligent session management and conflict detection",
-    "arguments": "[--type <workflow|review|tdd|test|docs>] [--auto|--new] [optional: task description for new session]",
-    "category": "workflow",
-    "subcategory": "session",
-    "usage_scenario": "general",
-    "difficulty": "Intermediate",
-    "file_path": "workflow/session/start.md"
-  },
-  {
-    "name": "review-session-cycle",
-    "command": "/workflow:review-session-cycle",
-    "description": "Session-based comprehensive multi-dimensional code review. Analyzes git changes from workflow session across 7 dimensions with hybrid parallel-iterative execution, aggregates findings, and performs focused deep-dives on critical issues until quality gates met.",
-    "arguments": "[session-id] [--dimensions=security,architecture,...] [--max-iterations=N]",
-    "category": "workflow",
-    "subcategory": null,
-    "usage_scenario": "session-management",
-    "difficulty": "Intermediate",
-    "file_path": "workflow/review-session-cycle.md"
-  },
-  {
-    "name": "docs",
-    "command": "/memory:docs",
-    "description": "Plan documentation workflow with dynamic grouping (≤10 docs/task), generates IMPL tasks for parallel module trees, README, ARCHITECTURE, and HTTP API docs",
-    "arguments": "[path] [--tool <gemini|qwen|codex>] [--mode <full|partial>] [--cli-execute]",
-    "category": "memory",
-    "subcategory": null,
-    "usage_scenario": "documentation",
-    "difficulty": "Intermediate",
-    "file_path": "memory/docs.md"
-  },
-  {
-    "name": "artifacts",
-    "command": "/workflow:brainstorm:artifacts",
-    "description": "Interactive clarification generating confirmed guidance specification through role-based analysis and synthesis",
-    "arguments": "topic or challenge description [--count N]",
-    "category": "workflow",
-    "subcategory": "brainstorm",
-    "usage_scenario": "general",
-    "difficulty": "Intermediate",
-    "file_path": "workflow/brainstorm/artifacts.md"
-  },
-  {
-    "name": "action-plan-verify",
-    "command": "/workflow:action-plan-verify",
-    "description": "Perform non-destructive cross-artifact consistency analysis between IMPL_PLAN.md and task JSONs with quality gate validation",
-    "arguments": "[optional: --session session-id]",
-    "category": "workflow",
-    "subcategory": null,
-    "usage_scenario": "planning",
-    "difficulty": "Intermediate",
-    "file_path": "workflow/action-plan-verify.md"
-  },
-  {
-    "name": "version",
-    "command": "/version",
-    "description": "Display Claude Code version information and check for updates",
-    "arguments": "",
-    "category": "general",
-    "subcategory": null,
-    "usage_scenario": "general",
-    "difficulty": "Beginner",
-    "file_path": "version.md"
-  }
-]

.claude/skills/command-guide/reference/commands/cli/cli-init.md

@@ -1,440 +0,0 @@
----
-name: cli-init
-description: Generate .gemini/ and .qwen/ config directories with settings.json and ignore files based on workspace technology detection
-argument-hint: "[--tool gemini|qwen|all] [--output path] [--preview]"
-allowed-tools: Bash(*), Read(*), Write(*), Glob(*)
----
-
-# CLI Initialization Command (/cli:cli-init)
-
-## Overview
-Initializes CLI tool configurations for the workspace by:
-1. Analyzing current workspace using `get_modules_by_depth.sh` to identify technology stacks
-2. Generating ignore files (`.geminiignore` and `.qwenignore`) with filtering rules optimized for detected technologies
-3. Creating configuration directories (`.gemini/` and `.qwen/`) with settings.json files
-
-**Supported Tools**: gemini, qwen, all (default: all)
-
-## Core Functionality
-
-### Configuration Generation
-1. **Workspace Analysis**: Runs `get_modules_by_depth.sh` to analyze project structure
-2. **Technology Stack Detection**: Identifies tech stacks based on file extensions, directories, and configuration files
-3. **Config Creation**: Generates tool-specific configuration directories and settings files
-4. **Ignore Rules Generation**: Creates ignore files with filtering patterns for detected technologies
-
-### Generated Files
-
-#### Configuration Directories
-Creates tool-specific configuration directories:
-
-**For Gemini** (`.gemini/`):
-- `.gemini/settings.json`:
-```json
-{
-  "contextfilename": ["CLAUDE.md","GEMINI.md"]
-}
-```
-
-**For Qwen** (`.qwen/`):
-- `.qwen/settings.json`:
-```json
-{
-  "contextfilename": ["CLAUDE.md","QWEN.md"]
-}
-```
-
-#### Ignore Files
-Uses gitignore syntax to filter files from CLI tool analysis:
-- `.geminiignore` - For Gemini CLI
-- `.qwenignore` - For Qwen CLI
-
-Both files have identical content based on detected technologies.
-
-### Supported Technology Stacks
-
-#### Frontend Technologies
-- **React/Next.js**: Ignores build artifacts, .next/, node_modules
-- **Vue/Nuxt**: Ignores .nuxt/, dist/, .cache/
-- **Angular**: Ignores dist/, .angular/, node_modules
-- **Webpack/Vite**: Ignores build outputs, cache directories
-
-#### Backend Technologies
-- **Node.js**: Ignores node_modules, package-lock.json, npm-debug.log
-- **Python**: Ignores __pycache__, .venv, *.pyc, .pytest_cache
-- **Java**: Ignores target/, .gradle/, *.class, .mvn/
-- **Go**: Ignores vendor/, *.exe, go.sum (when appropriate)
-- **C#/.NET**: Ignores bin/, obj/, *.dll, *.pdb
-
-#### Database & Infrastructure
-- **Docker**: Ignores .dockerignore, docker-compose.override.yml
-- **Kubernetes**: Ignores *.secret.yaml, helm charts temp files
-- **Database**: Ignores *.db, *.sqlite, database dumps
-
-### Generated Rules Structure
-
-#### Base Rules (Always Included)
-```
-# Version Control
-.git/
-.svn/
-.hg/
-
-# OS Files
-.DS_Store
-Thumbs.db
-*.tmp
-*.swp
-
-# IDE Files
-.vscode/
-.idea/
-.vs/
-
-# Logs
-*.log
-logs/
-```
-
-#### Technology-Specific Rules
-Rules are added based on detected technologies:
-
-**Node.js Projects** (package.json detected):
-```
-# Node.js
-node_modules/
-npm-debug.log*
-.npm/
-.yarn/
-package-lock.json
-yarn.lock
-.pnpm-store/
-```
-
-**Python Projects** (requirements.txt, setup.py, pyproject.toml detected):
-```
-# Python
-__pycache__/
-*.py[cod]
-.venv/
-venv/
-.pytest_cache/
-.coverage
-htmlcov/
-```
-
-**Java Projects** (pom.xml, build.gradle detected):
-```
-# Java
-target/
-.gradle/
-*.class
-*.jar
-*.war
-.mvn/
-```
-
-## Command Options
-
-### Tool Selection
-
-**Initialize All Tools (default)**:
-```bash
-/cli:cli-init
-```
-- Creates `.gemini/`, `.qwen/` directories with settings.json
-- Creates `.geminiignore` and `.qwenignore` files
-- Sets contextfilename to "CLAUDE.md" for both
-
-**Initialize Gemini Only**:
-```bash
-/cli:cli-init --tool gemini
-```
-- Creates only `.gemini/` directory and `.geminiignore` file
-
-**Initialize Qwen Only**:
-```bash
-/cli:cli-init --tool qwen
-```
-- Creates only `.qwen/` directory and `.qwenignore` file
-
-### Preview Mode
-```bash
-/cli:cli-init --preview
-```
-- Shows what would be generated without creating files
-- Displays detected technologies, configuration, and ignore rules
-
-### Custom Output Path
-```bash
-/cli:cli-init --output=.config/
-```
-- Generates files in specified directory
-- Creates directories if they don't exist
-
-### Combined Options
-```bash
-/cli:cli-init --tool qwen --preview
-/cli:cli-init --tool all --output=.config/
-```
-
-## EXECUTION INSTRUCTIONS - START HERE
-
-**When this command is triggered, follow these exact steps:**
-
-### Step 1: Parse Tool Selection
-```bash
-# Extract --tool flag (default: all)
-# Options: gemini, qwen, all
-```
-
-### Step 2: Workspace Analysis (MANDATORY FIRST)
-```bash
-# Analyze workspace structure
-bash(ccw tool exec get_modules_by_depth '{"format":"json"}')
-```
-
-### Step 3: Technology Detection
-```bash
-# Check for common tech stack indicators
-bash(find . -name "package.json" -not -path "*/node_modules/*" | head -1)
-bash(find . -name "requirements.txt" -o -name "setup.py" -o -name "pyproject.toml" | head -1)
-bash(find . -name "pom.xml" -o -name "build.gradle" | head -1)
-bash(find . -name "Dockerfile" | head -1)
-```
-
-### Step 4: Generate Configuration Files
-
-**For Gemini** (if --tool is gemini or all):
-```bash
-# Create .gemini/ directory and settings.json
-mkdir -p .gemini
-Write({file_path: '.gemini/settings.json', content: '{"contextfilename": "CLAUDE.md"}'})
-
-# Create .geminiignore file with detected technology rules
-# Backup existing files if present
-```
-
-**For Qwen** (if --tool is qwen or all):
-```bash
-# Create .qwen/ directory and settings.json
-mkdir -p .qwen
-Write({file_path: '.qwen/settings.json', content: '{"contextfilename": "CLAUDE.md"}'})
-
-# Create .qwenignore file with detected technology rules
-# Backup existing files if present
-```
-
-### Step 5: Validation
-```bash
-# Verify generated files are valid
-bash(ls -la .gemini* .qwen* 2>/dev/null || echo "Configuration files created")
-```
-
-## Implementation Process (Technical Details)
-
-### Phase 1: Tool Selection
-1. Parse `--tool` flag from command arguments
-2. Determine which configurations to generate:
-   - `gemini`: Generate .gemini/ and .geminiignore only
-   - `qwen`: Generate .qwen/ and .qwenignore only
-   - `all` (default): Generate both sets of files
-
-### Phase 2: Workspace Analysis
-1. Execute `get_modules_by_depth.sh json` to get structured project data
-2. Parse JSON output to identify directories and files
-3. Scan for technology indicators:
-   - Configuration files (package.json, requirements.txt, etc.)
-   - Directory patterns (src/, tests/, etc.)
-   - File extensions (.js, .py, .java, etc.)
-4. Detect project name from directory name or package.json
-
-### Phase 3: Technology Detection
-```bash
-# Technology detection logic
-detect_nodejs() {
-    [ -f "package.json" ] || find . -name "package.json" -not -path "*/node_modules/*" | head -1
-}
-
-detect_python() {
-    [ -f "requirements.txt" ] || [ -f "setup.py" ] || [ -f "pyproject.toml" ] || \
-    find . -name "*.py" -not -path "*/__pycache__/*" | head -1
-}
-
-detect_java() {
-    [ -f "pom.xml" ] || [ -f "build.gradle" ] || \
-    find . -name "*.java" | head -1
-}
-```
-
-### Phase 4: Configuration Generation
-**For each selected tool**, create:
-
-1. **Config Directory**:
-   - Create `.gemini/` or `.qwen/` directory if it doesn't exist
-   - Generate `settings.json` with contextfilename setting
-   - Set contextfilename to "CLAUDE.md" by default
-
-2. **Settings.json Format** (identical for both tools):
-```json
-{
-  "contextfilename": "CLAUDE.md"
-}
-```
-
-### Phase 5: Ignore Rules Generation
-1. Start with base rules (always included)
-2. Add technology-specific rules based on detection
-3. Add workspace-specific patterns if found
-4. Sort and deduplicate rules
-5. Generate identical content for both `.geminiignore` and `.qwenignore`
-
-### Phase 6: File Creation
-1. **Generate config directories**: Create `.gemini/` and/or `.qwen/` directories with settings.json
-2. **Generate ignore files**: Create organized ignore files with sections
-3. **Create backups**: Backup existing files if present
-4. **Validate**: Check generated files are valid
-
-## Generated File Format
-
-### Configuration Files
-```json
-// .gemini/settings.json or .qwen/settings.json
-{
-  "contextfilename": "CLAUDE.md"
-}
-```
-
-### Ignore Files
-```
-# .geminiignore / .qwenignore
-# Generated by Claude Code /cli:cli-init command
-# Creation date: 2024-01-15 10:30:00
-# Detected technologies: Node.js, Python, Docker
-#
-# This file uses gitignore syntax to filter files for CLI tool analysis
-# Edit this file to customize filtering rules for your project
-
-# ============================================================================
-# Base Rules (Always Applied)
-# ============================================================================
-
-# Version Control
-.git/
-.svn/
-.hg/
-
-# ============================================================================
-# Node.js (Detected: package.json found)
-# ============================================================================
-
-node_modules/
-npm-debug.log*
-.npm/
-yarn-error.log
-package-lock.json
-
-# ============================================================================
-# Python (Detected: requirements.txt, *.py files found)
-# ============================================================================
-
-__pycache__/
-*.py[cod]
-.venv/
-.pytest_cache/
-.coverage
-
-# ============================================================================
-# Docker (Detected: Dockerfile found)
-# ============================================================================
-
-.dockerignore
-docker-compose.override.yml
-
-# ============================================================================
-# Custom Rules (Add your project-specific rules below)
-# ============================================================================
-
-```
-
-## Error Handling
-
-### Missing Dependencies
-- If `get_modules_by_depth.sh` not found, show error with path to script
-- Gracefully handle cases where script fails
-
-### Write Permissions
-- Check write permissions before attempting file creation
-- Show clear error message if cannot write to target location
-
-### Backup Existing Files
-- If `.gemini/` directory exists, create backup as `.gemini.backup/`
-- If `.qwen/` directory exists, create backup as `.qwen.backup/`
-- If `.geminiignore` exists, create backup as `.geminiignore.backup`
-- If `.qwenignore` exists, create backup as `.qwenignore.backup`
-- Include timestamp in backup filename
-
-## Integration Points
-
-### Workflow Commands
-- **After `/cli:plan`**: Suggest running cli-init for better analysis
-- **Before analysis**: Recommend updating ignore patterns for cleaner results
-
-### CLI Tool Integration
-- Automatically update when new technologies detected
-- Integrate with `intelligent-tools-strategy.md` recommendations
-
-## Usage Examples
-
-### Basic Project Setup
-```bash
-# Initialize all CLI tools (Gemini + Qwen)
-/cli:cli-init
-
-# Initialize only Gemini
-/cli:cli-init --tool gemini
-
-# Initialize only Qwen
-/cli:cli-init --tool qwen
-
-# Preview what would be generated
-/cli:cli-init --preview
-
-# Generate in subdirectory
-/cli:cli-init --output=.config/
-```
-
-### Technology Migration
-```bash
-# After adding new tech stack (e.g., Docker)
-/cli:cli-init  # Regenerates all config and ignore files with new rules
-
-# Check what changed
-/cli:cli-init --preview  # Compare with existing configuration
-
-# Update only Qwen configuration
-/cli:cli-init --tool qwen
-```
-
-### Tool-Specific Initialization
-```bash
-# Setup for Gemini-only workflow
-/cli:cli-init --tool gemini
-
-# Setup for Qwen-only workflow
-/cli:cli-init --tool qwen
-
-# Setup both with preview
-/cli:cli-init --tool all --preview
-```
-
-
-## Tool Selection Guide
-
-| Scenario | Command | Result |
-|----------|---------|--------|
-| **New project, using both tools** | `/cli:cli-init` | Creates .gemini/, .qwen/, .geminiignore, .qwenignore |
-| **Gemini-only workflow** | `/cli:cli-init --tool gemini` | Creates .gemini/ and .geminiignore only |
-| **Qwen-only workflow** | `/cli:cli-init --tool qwen` | Creates .qwen/ and .qwenignore only |
-| **Preview before commit** | `/cli:cli-init --preview` | Shows what would be generated |
-| **Update configurations** | `/cli:cli-init` | Regenerates all files with backups |

.claude/skills/command-guide/reference/commands/enhance-prompt.md

@@ -1,93 +0,0 @@
----
-name: enhance-prompt
-description: Enhanced prompt transformation using session memory and intent analysis with --enhance flag detection
-argument-hint: "user input to enhance"
----
-
-## Overview
-
-Systematically enhances user prompts by leveraging session memory context and intent analysis, translating ambiguous requests into actionable specifications.
-
-## Core Protocol
-
-**Enhancement Pipeline:**
-`Intent Translation` → `Context Integration` → `Structured Output`
-
-**Context Sources:**
-- Session memory (conversation history, previous analysis)
-- Implicit technical requirements
-- User intent patterns
-
-## Enhancement Rules
-
-### Intent Translation
-
-| User Says | Translate To | Focus |
-|-----------|--------------|-------|
-| "fix" | Debug and resolve | Root cause → preserve behavior |
-| "improve" | Enhance/optimize | Performance/readability |
-| "add" | Implement feature | Integration + edge cases |
-| "refactor" | Restructure quality | Maintain behavior |
-| "update" | Modernize | Version compatibility |
-
-### Context Integration Strategy
-
-**Session Memory:**
-- Reference recent conversation context
-- Reuse previously identified patterns
-- Build on established understanding
-- Infer technical requirements from discussion
-
-**Example:**
-```bash
-# User: "add login"
-# Session Memory: Previous auth discussion, JWT mentioned
-# Inferred: JWT-based auth, integrate with existing session management
-# Action: Implement JWT authentication with session persistence
-```
-
-## Output Structure
-
-```bash
-INTENT: [Clear technical goal]
-CONTEXT: [Session memory + codebase patterns]
-ACTION: [Specific implementation steps]
-ATTENTION: [Critical constraints]
-```
-
-### Output Examples
-
-**Example 1:**
-```bash
-# Input: "fix login button"
-INTENT: Debug non-functional login button
-CONTEXT: From session - OAuth flow discussed, known state issue
-ACTION: Check event binding → verify state updates → test auth flow
-ATTENTION: Preserve existing OAuth integration
-```
-
-**Example 2:**
-```bash
-# Input: "refactor payment code"
-INTENT: Restructure payment module for maintainability
-CONTEXT: Session memory - PCI compliance requirements, Stripe integration patterns
-ACTION: Extract reusable validators → isolate payment gateway logic → maintain adapter pattern
-ATTENTION: Zero behavior change, maintain PCI compliance, full test coverage
-```
-
-## Enhancement Triggers
-
-- Ambiguous language: "fix", "improve", "clean up"
-- Vague requests requiring clarification
-- Complex technical requirements
-- Architecture changes
-- Critical systems: auth, payment, security
-- Multi-step refactoring
-
-## Key Principles
-
-1. **Session Memory First**: Leverage conversation context and established understanding
-2. **Context Reuse**: Build on previous discussions and decisions
-3. **Clear Output**: Structured, actionable specifications
-4. **Intent Clarification**: Transform vague requests into specific technical goals
-5. **Avoid Duplication**: Reference existing context, don't repeat

.claude/skills/command-guide/reference/commands/memory/code-map-memory.md

@@ -1,687 +0,0 @@
----
-name: code-map-memory
-description: 3-phase orchestrator: parse feature keyword → cli-explore-agent analyzes (Deep Scan dual-source) → orchestrator generates Mermaid docs + SKILL package (skips phase 2 if exists)
-argument-hint: "\"feature-keyword\" [--regenerate] [--tool <gemini|qwen>]"
-allowed-tools: SlashCommand(*), TodoWrite(*), Bash(*), Read(*), Write(*), Task(*)
----
-
-# Code Flow Mapping Generator
-
-## Overview
-
-**Pure Orchestrator with Agent Delegation**: Prepares context paths and delegates code flow analysis to specialized cli-explore-agent. Orchestrator transforms agent's JSON analysis into Mermaid documentation.
-
-**Auto-Continue Workflow**: Runs fully autonomously once triggered. Each phase completes and automatically triggers the next phase.
-
-**Execution Paths**:
-- **Full Path**: All 3 phases (no existing codemap OR `--regenerate` specified)
-- **Skip Path**: Phase 1 → Phase 3 (existing codemap found AND no `--regenerate` flag)
-- **Phase 3 Always Executes**: SKILL index is always generated or updated
-
-**Agent Responsibility** (cli-explore-agent):
-- Deep code flow analysis using dual-source strategy (Bash + Gemini CLI)
-- Returns structured JSON with architecture, functions, data flow, conditionals, patterns
-- NO file writing - analysis only
-
-**Orchestrator Responsibility**:
-- Provides feature keyword and analysis scope to agent
-- Transforms agent's JSON into Mermaid-enriched markdown documentation
-- Writes all files (5 docs + metadata.json + SKILL.md)
-
-## Core Rules
-
-1. **Start Immediately**: First action is TodoWrite initialization, second action is Phase 1 execution
-2. **Feature-Specific SKILL**: Each feature creates independent `.claude/skills/codemap-{feature}/` package
-3. **Specialized Agent**: Phase 2a uses cli-explore-agent for professional code analysis (Deep Scan mode)
-4. **Orchestrator Documentation**: Phase 2b transforms agent JSON into Mermaid markdown files
-5. **Auto-Continue**: After completing each phase, update TodoWrite and immediately execute next phase
-6. **No User Prompts**: Never ask user questions or wait for input between phases
-7. **Track Progress**: Update TodoWrite after EVERY phase completion before starting next phase
-8. **Multi-Level Detail**: Generate 4 levels: architecture → function → data → conditional
-
----
-
-## 3-Phase Execution
-
-### Phase 1: Parse Feature Keyword & Check Existing
-
-**Goal**: Normalize feature keyword, check existing codemap, prepare for analysis
-
-**Step 1: Parse Feature Keyword**
-```bash
-# Get feature keyword from argument
-FEATURE_KEYWORD="$1"
-
-# Normalize: lowercase, spaces to hyphens
-normalized_feature=$(echo "$FEATURE_KEYWORD" | tr '[:upper:]' '[:lower:]' | tr ' ' '-' | tr '_' '-')
-
-# Example: "User Authentication" → "user-authentication"
-# Example: "支付处理" → "支付处理" (keep non-ASCII)
-```
-
-**Step 2: Set Tool Preference**
-```bash
-# Default to gemini unless --tool specified
-TOOL="${tool_flag:-gemini}"
-```
-
-**Step 3: Check Existing Codemap**
-```bash
-# Define codemap directory
-CODEMAP_DIR=".claude/skills/codemap-${normalized_feature}"
-
-# Check if codemap exists
-bash(test -d "$CODEMAP_DIR" && echo "exists" || echo "not_exists")
-
-# Count existing files
-bash(find "$CODEMAP_DIR" -name "*.md" 2>/dev/null | wc -l || echo 0)
-```
-
-**Step 4: Skip Decision**
-```javascript
-if (existing_files > 0 && !regenerate_flag) {
-  SKIP_GENERATION = true
-  message = "Codemap already exists, skipping Phase 2. Use --regenerate to force regeneration."
-} else if (regenerate_flag) {
-  bash(rm -rf "$CODEMAP_DIR")
-  SKIP_GENERATION = false
-  message = "Regenerating codemap from scratch."
-} else {
-  SKIP_GENERATION = false
-  message = "No existing codemap found, generating new code flow analysis."
-}
-```
-
-**Output Variables**:
-- `FEATURE_KEYWORD`: Original feature keyword
-- `normalized_feature`: Normalized feature name for directory
-- `CODEMAP_DIR`: `.claude/skills/codemap-{feature}`
-- `TOOL`: CLI tool to use (gemini or qwen)
-- `SKIP_GENERATION`: Boolean - whether to skip Phase 2
-
-**TodoWrite**:
-- If skipping: Mark phase 1 completed, phase 2 completed, phase 3 in_progress
-- If not skipping: Mark phase 1 completed, phase 2 in_progress
-
----
-
-### Phase 2: Code Flow Analysis & Documentation Generation
-
-**Skip Condition**: Skipped if `SKIP_GENERATION = true`
-
-**Goal**: Use cli-explore-agent for professional code analysis, then orchestrator generates Mermaid documentation
-
-**Architecture**: Phase 2a (Agent Analysis) → Phase 2b (Orchestrator Documentation)
-
----
-
-#### Phase 2a: cli-explore-agent Analysis
-
-**Purpose**: Leverage specialized cli-explore-agent for deep code flow analysis
-
-**Agent Task Specification**:
-
-```
-Task(
-  subagent_type: "cli-explore-agent",
-  description: "Analyze code flow: {FEATURE_KEYWORD}",
-  prompt: "
-Perform Deep Scan analysis for feature: {FEATURE_KEYWORD}
-
-**Analysis Mode**: deep-scan (Dual-source: Bash structural scan + Gemini semantic analysis)
-
-**Analysis Objectives**:
-1. **Module Architecture**: Identify high-level module organization, interactions, and entry points
-2. **Function Call Chains**: Trace execution paths, call sequences, and parameter flows
-3. **Data Transformations**: Map data structure changes and transformation stages
-4. **Conditional Paths**: Document decision trees, branches, and error handling strategies
-5. **Design Patterns**: Discover architectural patterns and extract design intent
-
-**Scope**:
-- Feature: {FEATURE_KEYWORD}
-- CLI Tool: {TOOL} (gemini-2.5-pro or qwen coder-model)
-- File Discovery: MCP Code Index (preferred) + rg fallback
-- Target: 5-15 most relevant files
-
-**MANDATORY FIRST STEP**:
-Read: ~/.claude/workflows/cli-templates/schemas/codemap-json-schema.json
-
-**Output**: Return JSON following schema exactly. NO FILE WRITING - return JSON analysis only.
-
-**Critical Requirements**:
-- Use Deep Scan mode: Bash (Phase 1 - precise locations) + Gemini CLI (Phase 2 - semantic understanding) + Synthesis (Phase 3 - merge with attribution)
-- Focus exclusively on {FEATURE_KEYWORD} feature flow
-- Include file:line references for ALL findings
-- Extract design intent from code structure and comments
-- NO FILE WRITING - return JSON analysis only
-- Handle tool failures gracefully (Gemini → Qwen fallback, MCP → rg fallback)
-  "
-)
-```
-
-**Agent Output**: JSON analysis result with architecture, functions, data flow, conditionals, and patterns
-
----
-
-#### Phase 2b: Orchestrator Documentation Generation
-
-**Purpose**: Transform cli-explore-agent JSON into Mermaid-enriched documentation
-
-**Input**: Agent's JSON analysis result
-
-**Process**:
-
-1. **Parse Agent Analysis**:
-   ```javascript
-   const analysis = JSON.parse(agentResult)
-   const { feature, files_analyzed, architecture, function_calls, data_flow, conditional_logic, design_patterns } = analysis
-   ```
-
-2. **Generate Mermaid Diagrams from Structured Data**:
-
-   **a) architecture-flow.md** (~3K tokens):
-   ```javascript
-   // Convert architecture.modules + architecture.interactions → Mermaid graph TD
-   const architectureMermaid = `
-   graph TD
-   ${architecture.modules.map(m => `    ${m.name}[${m.name}]`).join('\n')}
-   ${architecture.interactions.map(i => `    ${i.from} -->|${i.type}| ${i.to}`).join('\n')}
-   `
-
-   Write({
-     file_path: `${CODEMAP_DIR}/architecture-flow.md`,
-     content: `---
-feature: ${feature}
-level: architecture
-detail: high-level module interactions
----
-# Architecture Flow: ${feature}
-
-## Overview
-${architecture.overview}
-
-## Module Architecture
-${architecture.modules.map(m => `### ${m.name}\n- **File**: ${m.file}\n- **Role**: ${m.responsibility}\n- **Dependencies**: ${m.dependencies.join(', ')}`).join('\n\n')}
-
-## Flow Diagram
-\`\`\`mermaid
-${architectureMermaid}
-\`\`\`
-
-## Key Interactions
-${architecture.interactions.map(i => `- **${i.from} → ${i.to}**: ${i.description}`).join('\n')}
-
-## Entry Points
-${architecture.entry_points.map(e => `- **${e.function}** (${e.file}): ${e.description}`).join('\n')}
-`
-   })
-   ```
-
-   **b) function-calls.md** (~5K tokens):
-   ```javascript
-   // Convert function_calls.sequences → Mermaid sequenceDiagram
-   const sequenceMermaid = `
-   sequenceDiagram
-   ${function_calls.sequences.map(s => `    ${s.from}->>${s.to}: ${s.method}`).join('\n')}
-   `
-
-   Write({
-     file_path: `${CODEMAP_DIR}/function-calls.md`,
-     content: `---
-feature: ${feature}
-level: function
-detail: function-level call sequences
----
-# Function Call Chains: ${feature}
-
-## Call Sequence Diagram
-\`\`\`mermaid
-${sequenceMermaid}
-\`\`\`
-
-## Detailed Call Chains
-${function_calls.call_chains.map(chain => `
-### Chain ${chain.chain_id}: ${chain.description}
-${chain.sequence.map(fn => `- **${fn.function}** (${fn.file})\n  - Calls: ${fn.calls.join(', ')}`).join('\n')}
-`).join('\n')}
-
-## Parameters & Returns
-${function_calls.sequences.map(s => `- **${s.method}** → Returns: ${s.returns || 'void'}`).join('\n')}
-`
-   })
-   ```
-
-   **c) data-flow.md** (~4K tokens):
-   ```javascript
-   // Convert data_flow.transformations → Mermaid flowchart LR
-   const dataFlowMermaid = `
-   flowchart LR
-   ${data_flow.transformations.map((t, i) => `    Stage${i}[${t.from}] -->|${t.transformer}| Stage${i+1}[${t.to}]`).join('\n')}
-   `
-
-   Write({
-     file_path: `${CODEMAP_DIR}/data-flow.md`,
-     content: `---
-feature: ${feature}
-level: data
-detail: data structure transformations
----
-# Data Flow: ${feature}
-
-## Data Transformation Diagram
-\`\`\`mermaid
-${dataFlowMermaid}
-\`\`\`
-
-## Data Structures
-${data_flow.structures.map(s => `### ${s.name} (${s.stage})\n\`\`\`json\n${JSON.stringify(s.shape, null, 2)}\n\`\`\``).join('\n\n')}
-
-## Transformations
-${data_flow.transformations.map(t => `- **${t.from} → ${t.to}** via \`${t.transformer}\` (${t.file})`).join('\n')}
-`
-   })
-   ```
-
-   **d) conditional-paths.md** (~4K tokens):
-   ```javascript
-   // Convert conditional_logic.branches → Mermaid flowchart TD
-   const conditionalMermaid = `
-   flowchart TD
-       Start[Entry Point]
-   ${conditional_logic.branches.map((b, i) => `
-       Start --> Check${i}{${b.condition}}
-       Check${i} -->|Yes| Path${i}A[${b.true_path}]
-       Check${i} -->|No| Path${i}B[${b.false_path}]
-   `).join('\n')}
-   `
-
-   Write({
-     file_path: `${CODEMAP_DIR}/conditional-paths.md`,
-     content: `---
-feature: ${feature}
-level: conditional
-detail: decision trees and error paths
----
-# Conditional Paths: ${feature}
-
-## Decision Tree
-\`\`\`mermaid
-${conditionalMermaid}
-\`\`\`
-
-## Branch Conditions
-${conditional_logic.branches.map(b => `- **${b.condition}** (${b.file})\n  - True: ${b.true_path}\n  - False: ${b.false_path}`).join('\n')}
-
-## Error Handling
-${conditional_logic.error_handling.map(e => `- **${e.error_type}**: Handler \`${e.handler}\` (${e.file}) - Recovery: ${e.recovery}`).join('\n')}
-`
-   })
-   ```
-
-   **e) complete-flow.md** (~8K tokens):
-   ```javascript
-   // Integrate all Mermaid diagrams
-   Write({
-     file_path: `${CODEMAP_DIR}/complete-flow.md`,
-     content: `---
-feature: ${feature}
-level: complete
-detail: integrated multi-level view
----
-# Complete Flow: ${feature}
-
-## Integrated Flow Diagram
-\`\`\`mermaid
-graph TB
-    subgraph Architecture
-    ${architecture.modules.map(m => `    ${m.name}[${m.name}]`).join('\n')}
-    end
-
-    subgraph "Function Calls"
-    ${function_calls.call_chains[0]?.sequence.map(fn => `    ${fn.function}`).join('\n') || ''}
-    end
-
-    subgraph "Data Flow"
-    ${data_flow.structures.map(s => `    ${s.name}[${s.name}]`).join('\n')}
-    end
-\`\`\`
-
-## Complete Trace
-[Comprehensive end-to-end documentation combining all analysis layers]
-
-## Design Patterns Identified
-${design_patterns.map(p => `- **${p.pattern}** in ${p.location}: ${p.description}`).join('\n')}
-
-## Recommendations
-${analysis.recommendations.map(r => `- ${r}`).join('\n')}
-
-## Cross-References
-- [Architecture Flow](./architecture-flow.md) - High-level module structure
-- [Function Calls](./function-calls.md) - Detailed call chains
-- [Data Flow](./data-flow.md) - Data transformation stages
-- [Conditional Paths](./conditional-paths.md) - Decision trees and error handling
-`
-   })
-   ```
-
-3. **Write metadata.json**:
-   ```javascript
-   Write({
-     file_path: `${CODEMAP_DIR}/metadata.json`,
-     content: JSON.stringify({
-       feature: feature,
-       normalized_name: normalized_feature,
-       generated_at: new Date().toISOString(),
-       tool_used: analysis.analysis_metadata.tool_used,
-       files_analyzed: files_analyzed.map(f => f.file),
-       analysis_summary: {
-         total_files: files_analyzed.length,
-         modules_traced: architecture.modules.length,
-         functions_traced: function_calls.call_chains.reduce((sum, c) => sum + c.sequence.length, 0),
-         patterns_discovered: design_patterns.length
-       }
-     }, null, 2)
-   })
-   ```
-
-4. **Report Phase 2 Completion**:
-   ```
-   Phase 2 Complete: Code flow analysis and documentation generated
-
-   - Agent Analysis: cli-explore-agent with {TOOL}
-   - Files Analyzed: {count}
-   - Documentation Generated: 5 markdown files + metadata.json
-   - Location: {CODEMAP_DIR}
-   ```
-
-**Completion Criteria**:
-- cli-explore-agent task completed successfully with JSON result
-- 5 documentation files written with valid Mermaid diagrams
-- metadata.json written with analysis summary
-- All files properly formatted and cross-referenced
-
-**TodoWrite**: Mark phase 2 completed, phase 3 in_progress
-
----
-
-### Phase 3: Generate SKILL.md Index
-
-**Note**: This phase **ALWAYS executes** - generates or updates the SKILL index.
-
-**Goal**: Read generated flow documentation and create SKILL.md index with progressive loading
-
-**Steps**:
-
-1. **Verify Generated Files**:
-   ```bash
-   bash(find "{CODEMAP_DIR}" -name "*.md" -type f | sort)
-   ```
-
-2. **Read metadata.json**:
-   ```javascript
-   Read({CODEMAP_DIR}/metadata.json)
-   // Extract: feature, normalized_name, files_analyzed, analysis_summary
-   ```
-
-3. **Read File Headers** (optional, first 30 lines):
-   ```javascript
-   Read({CODEMAP_DIR}/architecture-flow.md, limit: 30)
-   Read({CODEMAP_DIR}/function-calls.md, limit: 30)
-   // Extract overview and diagram counts
-   ```
-
-4. **Generate SKILL.md Index**:
-
-   Template structure:
-   ```yaml
-   ---
-   name: codemap-{normalized_feature}
-   description: Code flow mapping for {FEATURE_KEYWORD} feature (located at {project_path}). Load this SKILL when analyzing, tracing, or understanding {FEATURE_KEYWORD} execution flow, especially when no relevant context exists in memory.
-   version: 1.0.0
-   generated_at: {ISO_TIMESTAMP}
-   ---
-   # Code Flow Map: {FEATURE_KEYWORD}
-
-   ## Feature: `{FEATURE_KEYWORD}`
-
-   **Analysis Date**: {DATE}
-   **Tool Used**: {TOOL}
-   **Files Analyzed**: {COUNT}
-
-   ## Progressive Loading
-
-   ### Level 0: Quick Overview (~2K tokens)
-   - [Architecture Flow](./architecture-flow.md) - High-level module interactions
-
-   ### Level 1: Core Flows (~10K tokens)
-   - [Architecture Flow](./architecture-flow.md) - Module architecture
-   - [Function Calls](./function-calls.md) - Function call chains
-
-   ### Level 2: Complete Analysis (~20K tokens)
-   - [Architecture Flow](./architecture-flow.md)
-   - [Function Calls](./function-calls.md)
-   - [Data Flow](./data-flow.md) - Data transformations
-
-   ### Level 3: Deep Dive (~30K tokens)
-   - [Architecture Flow](./architecture-flow.md)
-   - [Function Calls](./function-calls.md)
-   - [Data Flow](./data-flow.md)
-   - [Conditional Paths](./conditional-paths.md) - Branches and error handling
-   - [Complete Flow](./complete-flow.md) - Integrated comprehensive view
-
-   ## Usage
-
-   Load this SKILL package when:
-   - Analyzing {FEATURE_KEYWORD} implementation
-   - Tracing execution flow for debugging
-   - Understanding code dependencies
-   - Planning refactoring or enhancements
-
-   ## Analysis Summary
-
-   - **Modules Traced**: {modules_traced}
-   - **Functions Traced**: {functions_traced}
-   - **Files Analyzed**: {total_files}
-
-   ## Mermaid Diagrams Included
-
-   - Architecture flow diagram (graph TD)
-   - Function call sequence diagram (sequenceDiagram)
-   - Data transformation flowchart (flowchart LR)
-   - Conditional decision tree (flowchart TD)
-   - Complete integrated diagram (graph TB)
-   ```
-
-5. **Write SKILL.md**:
-   ```javascript
-   Write({
-     file_path: `{CODEMAP_DIR}/SKILL.md`,
-     content: generatedIndexMarkdown
-   })
-   ```
-
-**Completion Criteria**:
-- SKILL.md index written
-- All documentation files verified
-- Progressive loading levels (0-3) properly structured
-- Mermaid diagram references included
-
-**TodoWrite**: Mark phase 3 completed
-
-**Final Report**:
-```
-Code Flow Mapping Complete
-
-Feature: {FEATURE_KEYWORD}
-Location: .claude/skills/codemap-{normalized_feature}/
-
-Files Generated:
-- SKILL.md (index)
-- architecture-flow.md (with Mermaid diagram)
-- function-calls.md (with Mermaid sequence diagram)
-- data-flow.md (with Mermaid flowchart)
-- conditional-paths.md (with Mermaid decision tree)
-- complete-flow.md (with integrated Mermaid diagram)
-- metadata.json
-
-Analysis:
-- Files analyzed: {count}
-- Modules traced: {count}
-- Functions traced: {count}
-
-Usage: Skill(command: "codemap-{normalized_feature}")
-```
-
----
-
-## Implementation Details
-
-### TodoWrite Patterns
-
-**Initialization** (Before Phase 1):
-```javascript
-TodoWrite({todos: [
-  {"content": "Parse feature keyword and check existing", "status": "in_progress", "activeForm": "Parsing feature keyword"},
-  {"content": "Agent analyzes code flow and generates files", "status": "pending", "activeForm": "Analyzing code flow"},
-  {"content": "Generate SKILL.md index", "status": "pending", "activeForm": "Generating SKILL index"}
-]})
-```
-
-**Full Path** (SKIP_GENERATION = false):
-```javascript
-// After Phase 1
-TodoWrite({todos: [
-  {"content": "Parse feature keyword and check existing", "status": "completed", ...},
-  {"content": "Agent analyzes code flow and generates files", "status": "in_progress", ...},
-  {"content": "Generate SKILL.md index", "status": "pending", ...}
-]})
-
-// After Phase 2
-TodoWrite({todos: [
-  {"content": "Parse feature keyword and check existing", "status": "completed", ...},
-  {"content": "Agent analyzes code flow and generates files", "status": "completed", ...},
-  {"content": "Generate SKILL.md index", "status": "in_progress", ...}
-]})
-
-// After Phase 3
-TodoWrite({todos: [
-  {"content": "Parse feature keyword and check existing", "status": "completed", ...},
-  {"content": "Agent analyzes code flow and generates files", "status": "completed", ...},
-  {"content": "Generate SKILL.md index", "status": "completed", ...}
-]})
-```
-
-**Skip Path** (SKIP_GENERATION = true):
-```javascript
-// After Phase 1 (skip Phase 2)
-TodoWrite({todos: [
-  {"content": "Parse feature keyword and check existing", "status": "completed", ...},
-  {"content": "Agent analyzes code flow and generates files", "status": "completed", ...},  // Skipped
-  {"content": "Generate SKILL.md index", "status": "in_progress", ...}
-]})
-```
-
-### Execution Flow
-
-**Full Path**:
-```
-User → TodoWrite Init → Phase 1 (parse) → Phase 2 (agent analyzes) → Phase 3 (write index) → Report
-```
-
-**Skip Path**:
-```
-User → TodoWrite Init → Phase 1 (detect existing) → Phase 3 (update index) → Report
-```
-
-### Error Handling
-
-**Phase 1 Errors**:
-- Empty feature keyword: Report error, ask user to provide feature description
-- Invalid characters: Normalize and continue
-
-**Phase 2 Errors (Agent)**:
-- Agent task fails: Retry once, report if fails again
-- No files discovered: Warn user, ask for more specific feature keyword
-- CLI failures: Agent handles internally with retries
-- Invalid Mermaid syntax: Agent validates before writing
-
-**Phase 3 Errors**:
-- Write failures: Report which files failed
-- Missing files: Note in SKILL.md, suggest regeneration
-
----
-
-## Parameters
-
-```bash
-/memory:code-map-memory "feature-keyword" [--regenerate] [--tool <gemini|qwen>]
-```
-
-**Arguments**:
-- **"feature-keyword"**: Feature or flow to analyze (required)
-  - Examples: `"user authentication"`, `"payment processing"`, `"数据导入流程"`
-  - Can be English, Chinese, or mixed
-  - Spaces and underscores normalized to hyphens
-- **--regenerate**: Force regenerate existing codemap (deletes and recreates)
-- **--tool**: CLI tool for analysis (default: gemini)
-  - `gemini`: Comprehensive flow analysis with gemini-2.5-pro
-  - `qwen`: Alternative with coder-model
-
----
-
-## Examples
-
-**Generated File Structure** (for all examples):
-```
-.claude/skills/codemap-{feature}/
-├── SKILL.md                    # Index (Phase 3)
-├── architecture-flow.md        # Agent (Phase 2) - High-level flow
-├── function-calls.md           # Agent (Phase 2) - Function chains
-├── data-flow.md                # Agent (Phase 2) - Data transformations
-├── conditional-paths.md        # Agent (Phase 2) - Branches & errors
-├── complete-flow.md            # Agent (Phase 2) - Integrated view
-└── metadata.json               # Agent (Phase 2)
-```
-
-### Example 1: User Authentication Flow
-
-```bash
-/memory:code-map-memory "user authentication"
-```
-
-**Workflow**:
-1. Phase 1: Normalizes to "user-authentication", checks existing codemap
-2. Phase 2: Agent discovers auth-related files, executes CLI analysis, generates 5 flow docs with Mermaid
-3. Phase 3: Generates SKILL.md index with progressive loading
-
-**Output**: `.claude/skills/codemap-user-authentication/` with 6 files + metadata
-
-
-### Example 3: Regenerate with Qwen
-
-```bash
-/memory:code-map-memory "payment processing" --regenerate --tool qwen
-```
-
-**Workflow**:
-1. Phase 1: Deletes existing codemap due to --regenerate
-2. Phase 2: Agent uses qwen with coder-model for fresh analysis
-3. Phase 3: Generates updated SKILL.md
-
----
-
-
-## Architecture
-
-```
-code-map-memory (orchestrator)
-  ├─ Phase 1: Parse & Check (bash commands, skip decision)
-  ├─ Phase 2: Code Analysis & Documentation (skippable)
-  │   ├─ Phase 2a: cli-explore-agent Analysis
-  │   │   └─ Deep Scan: Bash structural + Gemini semantic → JSON
-  │   └─ Phase 2b: Orchestrator Documentation
-  │       └─ Transform JSON → 5 Mermaid markdown files + metadata.json
-  └─ Phase 3: Write SKILL.md (index generation, always runs)
-
-Output: .claude/skills/codemap-{feature}/
-```

.claude/skills/command-guide/reference/commands/memory/docs-full-cli.md

@@ -1,471 +0,0 @@
----
-name: docs-full-cli
-description: Generate full project documentation using CLI execution (Layer 3→1) with batched agents (4 modules/agent) and gemini→qwen→codex fallback, <20 modules uses direct parallel
-argument-hint: "[path] [--tool <gemini|qwen|codex>]"
----
-
-# Full Documentation Generation - CLI Mode (/memory:docs-full-cli)
-
-## Overview
-
-Orchestrates project-wide documentation generation using CLI-based execution with batched agents and automatic tool fallback.
-
-**Parameters**:
-- `path`: Target directory (default: current directory)
-- `--tool <gemini|qwen|codex>`: Primary tool (default: gemini)
-
-**Execution Flow**: Discovery → Plan Presentation → Execution → Verification
-
-## 3-Layer Architecture & Auto-Strategy Selection
-
-### Layer Definition & Strategy Assignment
-
-| Layer | Depth | Strategy | Purpose | Context Pattern |
-|-------|-------|----------|---------|----------------|
-| **Layer 3** (Deepest) | ≥3 | `full` | Generate docs for all subdirectories with code | `@**/*` (all files) |
-| **Layer 2** (Middle) | 1-2 | `single` | Current dir + child docs | `@*/API.md @*/README.md @*.{ts,tsx,js,...}` |
-| **Layer 1** (Top) | 0 | `single` | Current dir + child docs | `@*/API.md @*/README.md @*.{ts,tsx,js,...}` |
-
-**Generation Direction**: Layer 3 → Layer 2 → Layer 1 (bottom-up dependency flow)
-
-**Strategy Auto-Selection**: Strategies are automatically determined by directory depth - no user configuration needed.
-
-### Strategy Details
-
-#### Full Strategy (Layer 3 Only)
-- **Use Case**: Deepest directories with comprehensive file coverage
-- **Behavior**: Generates API.md + README.md for current directory AND subdirectories containing code
-- **Context**: All files in current directory tree (`@**/*`)
-- **Output**: `.workflow/docs/{project_name}/{path}/API.md` + `README.md`
-
-
-#### Single Strategy (Layers 1-2)
-- **Use Case**: Upper layers that aggregate from existing documentation
-- **Behavior**: Generates API.md + README.md only in current directory
-- **Context**: Direct children docs + current directory code files
-- **Output**: `.workflow/docs/{project_name}/{path}/API.md` + `README.md`
-
-### Example Flow
-```
-src/auth/handlers/ (depth 3) → FULL STRATEGY
-  CONTEXT: @**/* (all files in handlers/ and subdirs)
-  GENERATES: .workflow/docs/project/src/auth/handlers/{API.md,README.md} + subdirs
-  ↓
-src/auth/ (depth 2) → SINGLE STRATEGY
-  CONTEXT: @*/API.md @*/README.md @*.ts (handlers docs + current code)
-  GENERATES: .workflow/docs/project/src/auth/{API.md,README.md} only
-  ↓
-src/ (depth 1) → SINGLE STRATEGY
-  CONTEXT: @*/API.md @*/README.md (auth docs, utils docs)
-  GENERATES: .workflow/docs/project/src/{API.md,README.md} only
-  ↓
-./ (depth 0) → SINGLE STRATEGY
-  CONTEXT: @*/API.md @*/README.md (src docs, tests docs)
-  GENERATES: .workflow/docs/project/{API.md,README.md} only
-```
-
-## Core Execution Rules
-
-1. **Analyze First**: Module discovery + folder classification before generation
-2. **Wait for Approval**: Present plan, no execution without user confirmation
-3. **Execution Strategy**:
-   - **<20 modules**: Direct parallel execution (max 4 concurrent per layer)
-   - **≥20 modules**: Agent batch processing (4 modules/agent, 73% overhead reduction)
-4. **Tool Fallback**: Auto-retry with fallback tools on failure
-5. **Layer Sequential**: Process layers 3→2→1 (bottom-up), parallel batches within layer
-6. **Safety Check**: Verify only docs files modified in .workflow/docs/
-7. **Layer-based Grouping**: Group modules by LAYER (not depth) for execution
-
-## Tool Fallback Hierarchy
-
-```javascript
---tool gemini  →  [gemini, qwen, codex]  // default
---tool qwen    →  [qwen, gemini, codex]
---tool codex   →  [codex, gemini, qwen]
-```
-
-**Trigger**: Non-zero exit code from generation script
-
-| Tool   | Best For                       | Fallback To    |
-|--------|--------------------------------|----------------|
-| gemini | Documentation, patterns        | qwen → codex   |
-| qwen   | Architecture, system design    | gemini → codex |
-| codex  | Implementation, code quality   | gemini → qwen  |
-
-## Execution Phases
-
-### Phase 1: Discovery & Analysis
-
-```javascript
-// Get project metadata
-Bash({command: "pwd && basename \"$(pwd)\" && git rev-parse --show-toplevel 2>/dev/null || pwd", run_in_background: false});
-
-// Get module structure with classification
-Bash({command: "ccw tool exec get_modules_by_depth '{\"format\":\"list\"}' | ccw tool exec classify_folders '{}'", run_in_background: false});
-
-// OR with path parameter
-Bash({command: "cd <target-path> && ccw tool exec get_modules_by_depth '{\"format\":\"list\"}' | ccw tool exec classify_folders '{}'", run_in_background: false});
-```
-
-**Parse output** `depth:N|path:<PATH>|type:<code|navigation>|...` to extract module paths, types, and count.
-
-**Smart filter**: Auto-detect and skip tests/build/config/vendor based on project tech stack.
-
-### Phase 2: Plan Presentation
-
-**For <20 modules**:
-```
-Documentation Generation Plan:
-  Tool: gemini (fallback: qwen → codex)
-  Total: 7 modules
-  Execution: Direct parallel (< 20 modules threshold)
-  Project: myproject
-  Output: .workflow/docs/myproject/
-
-  Will generate docs for:
-  - ./core/interfaces (12 files, type: code) - depth 2 [Layer 2] - single strategy
-  - ./core (22 files, type: code) - depth 1 [Layer 2] - single strategy
-  - ./models (9 files, type: code) - depth 1 [Layer 2] - single strategy
-  - ./utils (12 files, type: navigation) - depth 1 [Layer 2] - single strategy
-  - . (5 files, type: code) - depth 0 [Layer 1] - single strategy
-
-  Documentation Strategy (Auto-Selected):
-  - Layer 2 (depth 1-2): API.md + README.md (current dir only, reference child docs)
-  - Layer 1 (depth 0): API.md + README.md (current dir only, reference child docs)
-
-  Output Structure:
-  - Code folders: API.md + README.md
-  - Navigation folders: README.md only
-
-  Auto-skipped: ./tests, __pycache__, node_modules (15 paths)
-  Execution order: Layer 2 → Layer 1
-  Estimated time: ~5-10 minutes
-
-  Confirm execution? (y/n)
-```
-
-**For ≥20 modules**:
-```
-Documentation Generation Plan:
-  Tool: gemini (fallback: qwen → codex)
-  Total: 31 modules
-  Execution: Agent batch processing (4 modules/agent)
-  Project: myproject
-  Output: .workflow/docs/myproject/
-
-  Will generate docs for:
-  - ./src/features/auth (12 files, type: code) - depth 3 [Layer 3] - full strategy
-  - ./.claude/commands/cli (6 files, type: code) - depth 3 [Layer 3] - full strategy
-  - ./src/utils (8 files, type: code) - depth 2 [Layer 2] - single strategy
-  ...
-
-  Documentation Strategy (Auto-Selected):
-  - Layer 3 (depth ≥3): API.md + README.md (all subdirs with code)
-  - Layer 2 (depth 1-2): API.md + README.md (current dir only)
-  - Layer 1 (depth 0): API.md + README.md (current dir only)
-
-  Output Structure:
-  - Code folders: API.md + README.md
-  - Navigation folders: README.md only
-
-  Auto-skipped: ./tests, __pycache__, node_modules (15 paths)
-  Execution order: Layer 3 → Layer 2 → Layer 1
-
-  Agent allocation (by LAYER):
-  - Layer 3 (14 modules, depth ≥3): 4 agents [4, 4, 4, 2]
-  - Layer 2 (15 modules, depth 1-2): 4 agents [4, 4, 4, 3]
-  - Layer 1 (2 modules, depth 0): 1 agent [2]
-
-  Estimated time: ~15-25 minutes
-
-  Confirm execution? (y/n)
-```
-
-### Phase 3A: Direct Execution (<20 modules)
-
-**Strategy**: Parallel execution within layer (max 4 concurrent), no agent overhead.
-
-**CRITICAL**: All Bash commands use `run_in_background: false` for synchronous execution.
-
-```javascript
-let project_name = detect_project_name();
-
-for (let layer of [3, 2, 1]) {
-  if (modules_by_layer[layer].length === 0) continue;
-  let batches = batch_modules(modules_by_layer[layer], 4);
-
-  for (let batch of batches) {
-    let parallel_tasks = batch.map(module => {
-      return async () => {
-        let strategy = module.depth >= 3 ? "full" : "single";
-        for (let tool of tool_order) {
-          Bash({
-            command: `cd ${module.path} && ccw tool exec generate_module_docs '{"strategy":"${strategy}","sourcePath":".","projectName":"${project_name}","tool":"${tool}"}'`,
-            run_in_background: false
-          });
-          if (bash_result.exit_code === 0) {
-            report(`✅ ${module.path} (Layer ${layer}) docs generated with ${tool}`);
-            return true;
-          }
-        }
-        report(`❌ FAILED: ${module.path} (Layer ${layer}) failed all tools`);
-        return false;
-      };
-    });
-    await Promise.all(parallel_tasks.map(task => task()));
-  }
-}
-```
-
-### Phase 3B: Agent Batch Execution (≥20 modules)
-
-**Strategy**: Batch modules into groups of 4, spawn memory-bridge agents per batch.
-
-```javascript
-// Group modules by LAYER and batch within each layer
-let modules_by_layer = group_by_layer(module_list);
-let tool_order = construct_tool_order(primary_tool);
-let project_name = detect_project_name();
-
-for (let layer of [3, 2, 1]) {
-  if (modules_by_layer[layer].length === 0) continue;
-
-  let batches = batch_modules(modules_by_layer[layer], 4);
-  let worker_tasks = [];
-
-  for (let batch of batches) {
-    worker_tasks.push(
-      Task(
-        subagent_type="memory-bridge",
-        description=`Generate docs for ${batch.length} modules in Layer ${layer}`,
-        prompt=generate_batch_worker_prompt(batch, tool_order, layer, project_name)
-      )
-    );
-  }
-
-  await parallel_execute(worker_tasks);
-}
-```
-
-**Batch Worker Prompt Template**:
-```
-PURPOSE: Generate documentation for assigned modules with tool fallback
-
-TASK: Generate API.md + README.md for assigned modules using specified strategies.
-
-PROJECT: {{project_name}}
-OUTPUT: .workflow/docs/{{project_name}}/
-
-MODULES:
-{{module_path_1}} (strategy: {{strategy_1}}, type: {{folder_type_1}})
-{{module_path_2}} (strategy: {{strategy_2}}, type: {{folder_type_2}})
-...
-
-TOOLS (try in order): {{tool_1}}, {{tool_2}}, {{tool_3}}
-
-EXECUTION SCRIPT: ccw tool exec generate_module_docs
-  - Accepts strategy parameter: full | single
-  - Accepts folder type detection: code | navigation
-  - Tool execution via direct CLI commands (gemini/qwen/codex)
-  - Output path: .workflow/docs/{{project_name}}/{module_path}/
-
-EXECUTION FLOW (for each module):
-  1. Tool fallback loop (exit on first success):
-     for tool in {{tool_1}} {{tool_2}} {{tool_3}}; do
-       Bash({
-         command: `cd "{{module_path}}" && ccw tool exec generate_module_docs '{"strategy":"{{strategy}}","sourcePath":".","projectName":"{{project_name}}","tool":"${tool}"}'`,
-         run_in_background: false
-       })
-       exit_code=$?
-
-       if [ $exit_code -eq 0 ]; then
-         report "✅ {{module_path}} docs generated with $tool"
-         break
-       else
-         report "⚠️  {{module_path}} failed with $tool, trying next..."
-         continue
-       fi
-     done
-
-  2. Handle complete failure (all tools failed):
-     if [ $exit_code -ne 0 ]; then
-       report "❌ FAILED: {{module_path}} - all tools exhausted"
-       # Continue to next module (do not abort batch)
-     fi
-
-FOLDER TYPE HANDLING:
-  - code: Generate API.md + README.md
-  - navigation: Generate README.md only
-
-FAILURE HANDLING:
-  - Module-level isolation: One module's failure does not affect others
-  - Exit code detection: Non-zero exit code triggers next tool
-  - Exhaustion reporting: Log modules where all tools failed
-  - Batch continuation: Always process remaining modules
-
-REPORTING FORMAT:
-  Per-module status:
-    ✅ path/to/module docs generated with {tool}
-    ⚠️  path/to/module failed with {tool}, trying next...
-    ❌ FAILED: path/to/module - all tools exhausted
-```
-
-### Phase 4: Project-Level Documentation
-
-**After all module documentation is generated, create project-level documentation files.**
-
-```javascript
-let project_name = detect_project_name();
-let project_root = get_project_root();
-
-// Step 1: Generate Project README
-report("Generating project README.md...");
-for (let tool of tool_order) {
-  Bash({
-    command: `cd ${project_root} && ccw tool exec generate_module_docs '{"strategy":"project-readme","sourcePath":".","projectName":"${project_name}","tool":"${tool}"}'`,
-    run_in_background: false
-  });
-  if (bash_result.exit_code === 0) {
-    report(`✅ Project README generated with ${tool}`);
-    break;
-  }
-}
-
-// Step 2: Generate Architecture & Examples
-report("Generating ARCHITECTURE.md and EXAMPLES.md...");
-for (let tool of tool_order) {
-  Bash({
-    command: `cd ${project_root} && ccw tool exec generate_module_docs '{"strategy":"project-architecture","sourcePath":".","projectName":"${project_name}","tool":"${tool}"}'`,
-    run_in_background: false
-  });
-  if (bash_result.exit_code === 0) {
-    report(`✅ Architecture docs generated with ${tool}`);
-    break;
-  }
-}
-
-// Step 3: Generate HTTP API documentation (if API routes detected)
-Bash({command: 'rg "router\\.|@Get|@Post" -g "*.{ts,js,py}" 2>/dev/null && echo "API_FOUND" || echo "NO_API"', run_in_background: false});
-if (bash_result.stdout.includes("API_FOUND")) {
-  report("Generating HTTP API documentation...");
-  for (let tool of tool_order) {
-    Bash({
-      command: `cd ${project_root} && ccw tool exec generate_module_docs '{"strategy":"http-api","sourcePath":".","projectName":"${project_name}","tool":"${tool}"}'`,
-      run_in_background: false
-    });
-    if (bash_result.exit_code === 0) {
-      report(`✅ HTTP API docs generated with ${tool}`);
-      break;
-    }
-  }
-}
-```
-
-**Expected Output**:
-```
-Project-Level Documentation:
-  ✅ README.md (project root overview)
-  ✅ ARCHITECTURE.md (system design)
-  ✅ EXAMPLES.md (usage examples)
-  ✅ api/README.md (HTTP API reference) [optional]
-```
-
-### Phase 5: Verification
-
-```javascript
-// Check documentation files created
-Bash({command: 'find .workflow/docs -type f -name "*.md" 2>/dev/null | wc -l', run_in_background: false});
-
-// Display structure
-Bash({command: 'tree -L 3 .workflow/docs/', run_in_background: false});
-```
-
-**Result Summary**:
-```
-Documentation Generation Summary:
-  Total: 31 | Success: 29 | Failed: 2
-  Tool usage: gemini: 25, qwen: 4, codex: 0
-  Failed: path1, path2
-
-  Generated documentation:
-    .workflow/docs/myproject/
-    ├── src/
-    │   ├── auth/
-    │   │   ├── API.md
-    │   │   └── README.md
-    │   └── utils/
-    │       └── README.md
-    └── README.md
-```
-
-## Error Handling
-
-**Batch Worker**: Tool fallback per module, batch isolation, clear status reporting
-**Coordinator**: Invalid path abort, user decline handling, verification with cleanup
-**Fallback Triggers**: Non-zero exit code, script timeout, unexpected output
-
-## Output Structure
-
-```
-.workflow/docs/{project_name}/
-├── src/                           # Mirrors source structure
-│   ├── modules/
-│   │   ├── README.md              # Navigation
-│   │   ├── auth/
-│   │   │   ├── API.md             # API signatures
-│   │   │   ├── README.md          # Module docs
-│   │   │   └── middleware/
-│   │   │       ├── API.md
-│   │   │       └── README.md
-│   │   └── api/
-│   │       ├── API.md
-│   │       └── README.md
-│   └── utils/
-│       └── README.md
-├── lib/
-│   └── core/
-│       ├── API.md
-│       └── README.md
-├── README.md                      # ✨ Project root overview (auto-generated)
-├── ARCHITECTURE.md                # ✨ System design (auto-generated)
-├── EXAMPLES.md                    # ✨ Usage examples (auto-generated)
-└── api/                           # ✨ Optional (auto-generated if HTTP API detected)
-    └── README.md                  # HTTP API reference
-```
-
-## Usage Examples
-
-```bash
-# Full project documentation generation
-/memory:docs-full-cli
-
-# Target specific directory
-/memory:docs-full-cli src/features/auth
-/memory:docs-full-cli .claude
-
-# Use specific tool
-/memory:docs-full-cli --tool qwen
-/memory:docs-full-cli src --tool qwen
-```
-
-## Key Advantages
-
-- **Efficiency**: 30 modules → 8 agents (73% reduction from sequential)
-- **Resilience**: 3-tier tool fallback per module
-- **Performance**: Parallel batches, no concurrency limits
-- **Observability**: Per-module tool usage, batch-level metrics
-- **Automation**: Zero configuration - strategy auto-selected by directory depth
-- **Path Mirroring**: Clear 1:1 mapping between source and documentation structure
-
-## Template Reference
-
-Templates used from `~/.claude/workflows/cli-templates/prompts/documentation/`:
-- `api.txt`: Code API documentation (Part A: Code API, Part B: HTTP API)
-- `module-readme.txt`: Module purpose, usage, dependencies
-- `folder-navigation.txt`: Navigation README for folders with subdirectories
-
-## Related Commands
-
-- `/memory:docs` - Agent-based documentation planning workflow
-- `/memory:docs-related-cli` - Update docs for changed modules only
-- `/workflow:execute` - Execute documentation tasks (when using agent mode)

.claude/skills/command-guide/reference/commands/memory/docs-related-cli.md

@@ -1,386 +0,0 @@
----
-name: docs-related-cli
-description: Generate/update documentation for git-changed modules using CLI execution with batched agents (4 modules/agent) and gemini→qwen→codex fallback, <15 modules uses direct parallel
-argument-hint: "[--tool <gemini|qwen|codex>]"
----
-
-# Related Documentation Generation - CLI Mode (/memory:docs-related-cli)
-
-## Overview
-
-Orchestrates context-aware documentation generation/update for changed modules using CLI-based execution with batched agents and automatic tool fallback (gemini→qwen→codex).
-
-**Parameters**:
-- `--tool <gemini|qwen|codex>`: Primary tool (default: gemini)
-
-**Execution Flow**:
-1. Change Detection → 2. Plan Presentation → 3. Batched Execution → 4. Verification
-
-## Core Rules
-
-1. **Detect Changes First**: Use git diff to identify affected modules
-2. **Wait for Approval**: Present plan, no execution without user confirmation
-3. **Execution Strategy**:
-   - **<15 modules**: Direct parallel execution (max 4 concurrent per depth, no agent overhead)
-   - **≥15 modules**: Agent batch processing (4 modules/agent, 73% overhead reduction)
-4. **Tool Fallback**: Auto-retry with fallback tools on failure
-5. **Depth Sequential**: Process depths N→0, parallel batches within depth (both modes)
-6. **Related Mode**: Generate/update only changed modules and their parent contexts
-7. **Single Strategy**: Always use `single` strategy (incremental update)
-
-## Tool Fallback Hierarchy
-
-```javascript
---tool gemini  →  [gemini, qwen, codex]  // default
---tool qwen    →  [qwen, gemini, codex]
---tool codex   →  [codex, gemini, qwen]
-```
-
-**Trigger**: Non-zero exit code from generation script
-
-| Tool   | Best For                       | Fallback To    |
-|--------|--------------------------------|----------------|
-| gemini | Documentation, patterns        | qwen → codex   |
-| qwen   | Architecture, system design    | gemini → codex |
-| codex  | Implementation, code quality   | gemini → qwen  |
-
-## Phase 1: Change Detection & Analysis
-
-```javascript
-// Get project metadata
-Bash({command: "pwd && basename \"$(pwd)\" && git rev-parse --show-toplevel 2>/dev/null || pwd", run_in_background: false});
-
-// Detect changed modules
-Bash({command: "ccw tool exec detect_changed_modules '{\"format\":\"list\"}'", run_in_background: false});
-
-// Cache git changes
-Bash({command: "git add -A 2>/dev/null || true", run_in_background: false});
-```
-
-**Parse output** `depth:N|path:<PATH>|change:<TYPE>|type:<code|navigation>` to extract affected modules.
-
-**Smart filter**: Auto-detect and skip tests/build/config/vendor based on project tech stack (Node.js/Python/Go/Rust/etc).
-
-**Fallback**: If no changes detected, use recent modules (first 10 by depth).
-
-## Phase 2: Plan Presentation
-
-**Present filtered plan**:
-```
-Related Documentation Generation Plan:
-  Tool: gemini (fallback: qwen → codex)
-  Changed: 4 modules | Batching: 4 modules/agent
-  Project: myproject
-  Output: .workflow/docs/myproject/
-
-  Will generate/update docs for:
-  - ./src/api/auth (5 files, type: code) [new module]
-  - ./src/api (12 files, type: code) [parent of changed auth/]
-  - ./src (8 files, type: code) [parent context]
-  - . (14 files, type: code) [root level]
-
-  Documentation Strategy:
-  - Strategy: single (all modules - incremental update)
-  - Output: API.md + README.md (code folders), README.md only (navigation folders)
-  - Context: Current dir code + child docs
-
-  Auto-skipped (12 paths):
-  - Tests: ./src/api/auth.test.ts (8 paths)
-  - Config: tsconfig.json (3 paths)
-  - Other: node_modules (1 path)
-
-  Agent allocation:
-  - Depth 3 (1 module): 1 agent [1]
-  - Depth 2 (1 module): 1 agent [1]
-  - Depth 1 (1 module): 1 agent [1]
-  - Depth 0 (1 module): 1 agent [1]
-
-  Estimated time: ~5-10 minutes
-
-  Confirm execution? (y/n)
-```
-
-**Decision logic**:
-- User confirms "y": Proceed with execution
-- User declines "n": Abort, no changes
-- <15 modules: Direct execution
-- ≥15 modules: Agent batch execution
-
-## Phase 3A: Direct Execution (<15 modules)
-
-**Strategy**: Parallel execution within depth (max 4 concurrent), no agent overhead.
-
-**CRITICAL**: All Bash commands use `run_in_background: false` for synchronous execution.
-
-```javascript
-let project_name = detect_project_name();
-
-for (let depth of sorted_depths.reverse()) {  // N → 0
-  let batches = batch_modules(modules_by_depth[depth], 4);
-
-  for (let batch of batches) {
-    let parallel_tasks = batch.map(module => {
-      return async () => {
-        for (let tool of tool_order) {
-          Bash({
-            command: `cd ${module.path} && ccw tool exec generate_module_docs '{"strategy":"single","sourcePath":".","projectName":"${project_name}","tool":"${tool}"}'`,
-            run_in_background: false
-          });
-          if (bash_result.exit_code === 0) {
-            report(`✅ ${module.path} docs generated with ${tool}`);
-            return true;
-          }
-        }
-        report(`❌ FAILED: ${module.path} failed all tools`);
-        return false;
-      };
-    });
-    await Promise.all(parallel_tasks.map(task => task()));
-  }
-}
-```
-
-## Phase 3B: Agent Batch Execution (≥15 modules)
-
-### Batching Strategy
-
-```javascript
-// Batch modules into groups of 4
-function batch_modules(modules, batch_size = 4) {
-  let batches = [];
-  for (let i = 0; i < modules.length; i += batch_size) {
-    batches.push(modules.slice(i, i + batch_size));
-  }
-  return batches;
-}
-// Examples: 10→[4,4,2] | 8→[4,4] | 3→[3]
-```
-
-### Coordinator Orchestration
-
-```javascript
-let modules_by_depth = group_by_depth(changed_modules);
-let tool_order = construct_tool_order(primary_tool);
-let project_name = detect_project_name();
-
-for (let depth of sorted_depths.reverse()) {  // N → 0
-  let batches = batch_modules(modules_by_depth[depth], 4);
-  let worker_tasks = [];
-
-  for (let batch of batches) {
-    worker_tasks.push(
-      Task(
-        subagent_type="memory-bridge",
-        description=`Generate docs for ${batch.length} modules at depth ${depth}`,
-        prompt=generate_batch_worker_prompt(batch, tool_order, depth, project_name, "related")
-      )
-    );
-  }
-
-  await parallel_execute(worker_tasks);  // Batches run in parallel
-}
-```
-
-### Batch Worker Prompt Template
-
-```
-PURPOSE: Generate/update documentation for assigned modules with tool fallback (related mode)
-
-TASK:
-Generate documentation for the following modules based on recent changes. For each module, try tools in order until success.
-
-PROJECT: {{project_name}}
-OUTPUT: .workflow/docs/{{project_name}}/
-
-MODULES:
-{{module_path_1}} (type: {{folder_type_1}})
-{{module_path_2}} (type: {{folder_type_2}})
-{{module_path_3}} (type: {{folder_type_3}})
-{{module_path_4}} (type: {{folder_type_4}})
-
-TOOLS (try in order):
-1. {{tool_1}}
-2. {{tool_2}}
-3. {{tool_3}}
-
-EXECUTION:
-For each module above:
-  1. Try tool 1:
-     Bash({
-       command: `cd "{{module_path}}" && ccw tool exec generate_module_docs '{"strategy":"single","sourcePath":".","projectName":"{{project_name}}","tool":"{{tool_1}}"}'`,
-       run_in_background: false
-     })
-     → Success: Report "✅ {{module_path}} docs generated with {{tool_1}}", proceed to next module
-     → Failure: Try tool 2
-  2. Try tool 2:
-     Bash({
-       command: `cd "{{module_path}}" && ccw tool exec generate_module_docs '{"strategy":"single","sourcePath":".","projectName":"{{project_name}}","tool":"{{tool_2}}"}'`,
-       run_in_background: false
-     })
-     → Success: Report "✅ {{module_path}} docs generated with {{tool_2}}", proceed to next module
-     → Failure: Try tool 3
-  3. Try tool 3:
-     Bash({
-       command: `cd "{{module_path}}" && ccw tool exec generate_module_docs '{"strategy":"single","sourcePath":".","projectName":"{{project_name}}","tool":"{{tool_3}}"}'`,
-       run_in_background: false
-     })
-     → Success: Report "✅ {{module_path}} docs generated with {{tool_3}}", proceed to next module
-     → Failure: Report "❌ FAILED: {{module_path}} failed all tools", proceed to next module
-
-FOLDER TYPE HANDLING:
-  - code: Generate API.md + README.md
-  - navigation: Generate README.md only
-
-REPORTING:
-Report final summary with:
-- Total processed: X modules
-- Successful: Y modules
-- Failed: Z modules
-- Tool usage: {{tool_1}}:X, {{tool_2}}:Y, {{tool_3}}:Z
-```
-
-## Phase 4: Verification
-
-```javascript
-// Check documentation files created/updated
-Bash({command: 'find .workflow/docs -type f -name "*.md" 2>/dev/null | wc -l', run_in_background: false});
-
-// Display recent changes
-Bash({command: 'find .workflow/docs -type f -name "*.md" -mmin -60 2>/dev/null', run_in_background: false});
-```
-
-**Aggregate results**:
-```
-Documentation Generation Summary:
-  Total: 4 | Success: 4 | Failed: 0
-
-  Tool usage:
-  - gemini: 4 modules
-  - qwen: 0 modules (fallback)
-  - codex: 0 modules
-
-  Changes:
-  .workflow/docs/myproject/src/api/auth/API.md      (new)
-  .workflow/docs/myproject/src/api/auth/README.md   (new)
-  .workflow/docs/myproject/src/api/API.md           (updated)
-  .workflow/docs/myproject/src/api/README.md        (updated)
-  .workflow/docs/myproject/src/API.md               (updated)
-  .workflow/docs/myproject/src/README.md            (updated)
-  .workflow/docs/myproject/API.md                   (updated)
-  .workflow/docs/myproject/README.md                (updated)
-```
-
-## Execution Summary
-
-**Module Count Threshold**:
-- **<15 modules**: Coordinator executes Phase 3A (Direct Execution)
-- **≥15 modules**: Coordinator executes Phase 3B (Agent Batch Execution)
-
-**Agent Hierarchy** (for ≥15 modules):
-- **Coordinator**: Handles batch division, spawns worker agents per depth
-- **Worker Agents**: Each processes 4 modules with tool fallback (related mode)
-
-## Error Handling
-
-**Batch Worker**:
-- Tool fallback per module (auto-retry)
-- Batch isolation (failures don't propagate)
-- Clear per-module status reporting
-
-**Coordinator**:
-- No changes: Use fallback (recent 10 modules)
-- User decline: No execution
-- Verification fail: Report incomplete modules
-- Partial failures: Continue execution, report failed modules
-
-**Fallback Triggers**:
-- Non-zero exit code
-- Script timeout
-- Unexpected output
-
-## Output Structure
-
-```
-.workflow/docs/{project_name}/
-├── src/                           # Mirrors source structure
-│   ├── modules/
-│   │   ├── README.md
-│   │   ├── auth/
-│   │   │   ├── API.md             # Updated based on code changes
-│   │   │   └── README.md          # Updated based on code changes
-│   │   └── api/
-│   │       ├── API.md
-│   │       └── README.md
-│   └── utils/
-│       └── README.md
-└── README.md
-```
-
-## Usage Examples
-
-```bash
-# Daily development documentation update
-/memory:docs-related-cli
-
-# After feature work with specific tool
-/memory:docs-related-cli --tool qwen
-
-# Code quality documentation review after implementation
-/memory:docs-related-cli --tool codex
-```
-
-## Key Advantages
-
-**Efficiency**: 30 modules → 8 agents (73% reduction)
-**Resilience**: 3-tier fallback per module
-**Performance**: Parallel batches, no concurrency limits
-**Context-aware**: Updates based on actual git changes
-**Fast**: Only affected modules, not entire project
-**Incremental**: Single strategy for focused updates
-
-## Coordinator Checklist
-
-- Parse `--tool` (default: gemini)
-- Get project metadata (name, root)
-- Detect changed modules via detect_changed_modules.sh
-- **Smart filter modules** (auto-detect tech stack, skip tests/build/config/vendor)
-- Cache git changes
-- Apply fallback if no changes (recent 10 modules)
-- Construct tool fallback order
-- **Present filtered plan** with skip reasons and change types
-- **Wait for y/n confirmation**
-- Determine execution mode:
-  - **<15 modules**: Direct execution (Phase 3A)
-    - For each depth (N→0): Sequential module updates with tool fallback
-  - **≥15 modules**: Agent batch execution (Phase 3B)
-    - For each depth (N→0): Batch modules (4 per batch), spawn batch workers in parallel
-- Wait for depth/batch completion
-- Aggregate results
-- Verification check (documentation files created/updated)
-- Display summary + recent changes
-
-## Comparison with Full Documentation Generation
-
-| Aspect | Related Generation | Full Generation |
-|--------|-------------------|-----------------|
-| **Scope** | Changed modules only | All project modules |
-| **Speed** | Fast (minutes) | Slower (10-30 min) |
-| **Use case** | Daily development | Initial setup, major refactoring |
-| **Strategy** | `single` (all) | `full` (L3) + `single` (L1-2) |
-| **Trigger** | After commits | After setup or major changes |
-| **Batching** | 4 modules/agent | 4 modules/agent |
-| **Fallback** | gemini→qwen→codex | gemini→qwen→codex |
-| **Complexity threshold** | ≤15 modules | ≤20 modules |
-
-## Template Reference
-
-Templates used from `~/.claude/workflows/cli-templates/prompts/documentation/`:
-- `api.txt`: Code API documentation
-- `module-readme.txt`: Module purpose, usage, dependencies
-- `folder-navigation.txt`: Navigation README for folders
-
-## Related Commands
-
-- `/memory:docs-full-cli` - Full project documentation generation
-- `/memory:docs` - Agent-based documentation planning workflow
-- `/memory:update-related` - Update CLAUDE.md for changed modules

.claude/skills/command-guide/reference/commands/memory/docs.md

@@ -1,616 +0,0 @@
----
-name: docs
-description: Plan documentation workflow with dynamic grouping (≤10 docs/task), generates IMPL tasks for parallel module trees, README, ARCHITECTURE, and HTTP API docs
-argument-hint: "[path] [--tool <gemini|qwen|codex>] [--mode <full|partial>] [--cli-execute]"
----
-
-# Documentation Workflow (/memory:docs)
-
-## Overview
-Lightweight planner that analyzes project structure, decomposes documentation work into tasks, and generates execution plans. Does NOT generate documentation content itself - delegates to doc-generator agent.
-
-**Execution Strategy**:
-- **Dynamic Task Grouping**: Level 1 tasks grouped by top-level directories with document count limit
-  - **Primary constraint**: Each task generates ≤10 documents (API.md + README.md count)
-  - **Optimization goal**: Prefer grouping 2 top-level directories per task for context sharing
-  - **Conflict resolution**: If 2 dirs exceed 10 docs, reduce to 1 dir/task; if 1 dir exceeds 10 docs, split by subdirectories
-  - **Context benefit**: Same-task directories analyzed together via single Gemini call
-- **Parallel Execution**: Multiple Level 1 tasks execute concurrently for faster completion
-- **Pre-computed Analysis**: Phase 2 performs unified analysis once, stored in `.process/` for reuse
-- **Efficient Data Loading**: All existing docs loaded once in Phase 2, shared across tasks
-
-**Path Mirroring**: Documentation structure mirrors source code under `.workflow/docs/{project_name}/`
-- Example: `my_app/src/core/` → `.workflow/docs/my_app/src/core/API.md`
-
-**Two Execution Modes**:
-- **Default (Agent Mode)**: CLI analyzes in `pre_analysis` (MODE=analysis), agent writes docs
-- **--cli-execute (CLI Mode)**: CLI generates docs in `implementation_approach` (MODE=write), agent executes CLI commands
-
-## Path Mirroring Strategy
-
-**Principle**: Documentation structure **mirrors** source code structure under project-specific directory.
-
-| Source Path | Project Name | Documentation Path |
-|------------|--------------|-------------------|
-| `my_app/src/core/` | `my_app` | `.workflow/docs/my_app/src/core/API.md` |
-| `my_app/src/modules/auth/` | `my_app` | `.workflow/docs/my_app/src/modules/auth/API.md` |
-| `another_project/lib/utils/` | `another_project` | `.workflow/docs/another_project/lib/utils/API.md` |
-
-
-## Parameters
-
-```bash
-/memory:docs [path] [--tool <gemini|qwen|codex>] [--mode <full|partial>] [--cli-execute]
-```
-
-- **path**: Source directory to analyze (default: current directory)
-  - Specifies the source code directory to be documented
-  - Documentation is generated in a separate `.workflow/docs/{project_name}/` directory at the workspace root, **not** within the source `path` itself
-  - The source path's structure is mirrored within the project-specific documentation folder
-  - Example: analyzing `src/modules` produces documentation at `.workflow/docs/{project_name}/src/modules/`
-- **--mode**: Documentation generation mode (default: full)
-  - `full`: Complete documentation (modules + README + ARCHITECTURE + EXAMPLES + HTTP API)
-  - `partial`: Module documentation only (API.md + README.md)
-- **--tool**: CLI tool selection (default: gemini)
-  - `gemini`: Comprehensive documentation, pattern recognition
-  - `qwen`: Architecture analysis, system design focus
-  - `codex`: Implementation validation, code quality
-- **--cli-execute**: Enable CLI-based documentation generation (optional)
-
-## Planning Workflow
-
-### Phase 1: Initialize Session
-
-```bash
-# Get target path, project name, and root
-bash(pwd && basename "$(pwd)" && git rev-parse --show-toplevel 2>/dev/null || pwd && date +%Y%m%d-%H%M%S)
-```
-
-```javascript
-// Create docs session (type: docs)
-SlashCommand(command="/workflow:session:start --type docs --new \"{project_name}-docs-{timestamp}\"")
-// Parse output to get sessionId
-```
-
-```bash
-# Update workflow-session.json with docs-specific fields
-ccw session {sessionId} write workflow-session.json '{"target_path":"{target_path}","project_root":"{project_root}","project_name":"{project_name}","mode":"full","tool":"gemini","cli_execute":false}'
-```
-
-### Phase 2: Analyze Structure
-
-**Smart filter**: Auto-detect and skip tests/build/config/vendor based on project tech stack.
-
-**Commands** (collect data with simple bash):
-
-```bash
-# 1. Run folder analysis
-bash(ccw tool exec get_modules_by_depth '{}' | ccw tool exec classify_folders '{}')
-
-# 2. Get top-level directories (first 2 path levels)
-bash(ccw tool exec get_modules_by_depth '{}' | ccw tool exec classify_folders '{}' | awk -F'|' '{print $1}' | sed 's|^\./||' | awk -F'/' '{if(NF>=2) print $1"/"$2; else if(NF==1) print $1}' | sort -u)
-
-# 3. Find existing docs (if directory exists)
-bash(if [ -d .workflow/docs/\${project_name} ]; then find .workflow/docs/\${project_name} -type f -name "*.md" ! -path "*/README.md" ! -path "*/ARCHITECTURE.md" ! -path "*/EXAMPLES.md" ! -path "*/api/*" 2>/dev/null; fi)
-
-# 4. Read existing docs content (if files exist)
-bash(if [ -d .workflow/docs/\${project_name} ]; then find .workflow/docs/\${project_name} -type f -name "*.md" ! -path "*/README.md" ! -path "*/ARCHITECTURE.md" ! -path "*/EXAMPLES.md" ! -path "*/api/*" 2>/dev/null | xargs cat 2>/dev/null; fi)
-```
-
-**Data Processing**: Parse bash outputs, calculate statistics, use **Write tool** to create `${session_dir}/.process/doc-planning-data.json` with structure:
-
-```json
-{
-  "metadata": {
-    "generated_at": "2025-11-03T16:57:30.469669",
-    "project_name": "project_name",
-    "project_root": "/path/to/project"
-  },
-  "folder_analysis": [
-    {"path": "./src/core", "type": "code", "code_count": 5, "dirs_count": 2}
-  ],
-  "top_level_dirs": ["src/modules", "lib/core"],
-  "existing_docs": {
-    "file_list": [".workflow/docs/project/src/core/API.md"],
-    "content": "... existing docs content ..."
-  },
-  "unified_analysis": [],
-  "statistics": {
-    "total": 15,
-    "code": 8,
-    "navigation": 7,
-    "top_level": 3
-  }
-}
-```
-
-**Then** use **Edit tool** to update `workflow-session.json` adding analysis field.
-
-**Output**: Single `doc-planning-data.json` with all analysis data (no temp files or Python scripts).
-
-**Auto-skipped**: Tests (`**/test/**`, `**/*.test.*`), Build (`**/node_modules/**`, `**/dist/**`), Config (root-level files), Vendor directories.
-
-### Phase 3: Detect Update Mode
-
-**Commands**:
-
-```bash
-# Count existing docs from doc-planning-data.json
-ccw session WFS-docs-{timestamp} read .process/doc-planning-data.json --raw | jq '.existing_docs.file_list | length'
-# Or read entire process file and parse
-```
-
-**Data Processing**: Use count result, then use **Edit tool** to update `workflow-session.json`:
-- Add `"update_mode": "update"` if count > 0, else `"create"`
-- Add `"existing_docs": <count>`
-
-### Phase 4: Decompose Tasks
-
-**Task Hierarchy** (Dynamic based on document count):
-
-```
-Small Projects (total ≤10 docs):
-  Level 1: IMPL-001 (all directories in single task, shared context)
-  Level 2: IMPL-002 (README, full mode only)
-  Level 3: IMPL-003 (ARCHITECTURE+EXAMPLES), IMPL-004 (HTTP API, optional)
-
-Medium Projects (Example: 7 top-level dirs, 18 total docs):
-  Step 1: Count docs per top-level dir
-    ├─ dir1: 3 docs, dir2: 4 docs → Group 1 (7 docs)
-    ├─ dir3: 5 docs, dir4: 3 docs → Group 2 (8 docs)
-    ├─ dir5: 2 docs → Group 3 (2 docs, can add more)
-
-  Step 2: Create tasks with ≤10 docs constraint
-  Level 1: IMPL-001 to IMPL-003 (parallel groups)
-    ├─ IMPL-001: Group 1 (dir1 + dir2, 7 docs, shared context)
-    ├─ IMPL-002: Group 2 (dir3 + dir4, 8 docs, shared context)
-    └─ IMPL-003: Group 3 (remaining dirs, ≤10 docs)
-  Level 2: IMPL-004 (README, depends on Level 1, full mode only)
-  Level 3: IMPL-005 (ARCHITECTURE+EXAMPLES), IMPL-006 (HTTP API, optional)
-
-Large Projects (single dir >10 docs):
-  Step 1: Detect oversized directory
-    └─ src/modules/: 15 subdirs → 30 docs (exceeds limit)
-
-  Step 2: Split by subdirectories
-  Level 1: IMPL-001 to IMPL-003 (split oversized dir)
-    ├─ IMPL-001: src/modules/ subdirs 1-5 (10 docs)
-    ├─ IMPL-002: src/modules/ subdirs 6-10 (10 docs)
-    └─ IMPL-003: src/modules/ subdirs 11-15 (10 docs)
-```
-
-**Grouping Algorithm**:
-1. Count total docs for each top-level directory
-2. Try grouping 2 directories (optimization for context sharing)
-3. If group exceeds 10 docs, split to 1 dir/task
-4. If single dir exceeds 10 docs, split by subdirectories
-5. Create parallel Level 1 tasks with ≤10 docs each
-
-
-**Commands**:
-
-```bash
-# 1. Get top-level directories from doc-planning-data.json
-ccw session WFS-docs-{timestamp} read .process/doc-planning-data.json --raw | jq -r '.top_level_dirs[]'
-
-# 2. Get mode from workflow-session.json
-ccw session WFS-docs-{timestamp} read workflow-session.json --raw | jq -r '.mode // "full"'
-
-# 3. Check for HTTP API
-bash(grep -r "router\.|@Get\|@Post" src/ 2>/dev/null && echo "API_FOUND" || echo "NO_API")
-```
-
-**Data Processing**:
-1. Count documents for each top-level directory (from folder_analysis):
-   - Code folders: 2 docs each (API.md + README.md)
-   - Navigation folders: 1 doc each (README.md only)
-2. Apply grouping algorithm with ≤10 docs constraint:
-   - Try grouping 2 directories, calculate total docs
-   - If total ≤10 docs: create group
-   - If total >10 docs: split to 1 dir/group or subdivide
-   - If single dir >10 docs: split by subdirectories
-3. Use **Edit tool** to update `doc-planning-data.json` adding groups field:
-   ```json
-   "groups": {
-     "count": 3,
-     "assignments": [
-       {"group_id": "001", "directories": ["src/modules", "src/utils"], "doc_count": 5},
-       {"group_id": "002", "directories": ["lib/core"], "doc_count": 6},
-       {"group_id": "003", "directories": ["lib/helpers"], "doc_count": 3}
-     ]
-   }
-   ```
-
-**Task ID Calculation**:
-```bash
-group_count=$(ccw session WFS-docs-{timestamp} read .process/doc-planning-data.json --raw | jq '.groups.count')
-readme_id=$((group_count + 1))   # Next ID after groups
-arch_id=$((group_count + 2))
-api_id=$((group_count + 3))
-```
-
-### Phase 5: Generate Task JSONs
-
-**CLI Strategy**:
-
-| Mode | cli_execute | Placement | CLI MODE | Approval Flag | Agent Role |
-|------|-------------|-----------|----------|---------------|------------|
-| **Agent** | false | pre_analysis | analysis | (none) | Generate docs in implementation_approach |
-| **CLI** | true | implementation_approach | write | --mode write | Execute CLI commands, validate output |
-
-**Command Patterns**:
-- Gemini/Qwen: `ccw cli -p "..." --tool gemini --mode analysis --cd dir`
-- CLI Mode: `ccw cli -p "..." --tool gemini --mode write --cd dir`
-- Codex: `ccw cli -p "..." --tool codex --mode write --cd dir`
-
-**Generation Process**:
-1. Read configuration values (tool, cli_execute, mode) from workflow-session.json
-2. Read group assignments from doc-planning-data.json
-3. Generate Level 1 tasks (IMPL-001 to IMPL-N, one per group)
-4. Generate Level 2+ tasks if mode=full (README, ARCHITECTURE, HTTP API)
-
-## Task Templates
-
-### Level 1: Module Trees Group Task (Unified)
-
-**Execution Model**: Each task processes assigned directory group (max 2 directories) using pre-analyzed data from Phase 2.
-
-```json
-{
-  "id": "IMPL-${group_number}",
-  "title": "Document Module Trees Group ${group_number}",
-  "status": "pending",
-  "meta": {
-    "type": "docs-tree-group",
-    "agent": "@doc-generator",
-    "tool": "gemini",
-    "cli_execute": false,
-    "group_number": "${group_number}",
-    "total_groups": "${total_groups}"
-  },
-  "context": {
-    "requirements": [
-      "Process directories from group ${group_number} in doc-planning-data.json",
-      "Generate docs to .workflow/docs/${project_name}/ (mirrored structure)",
-      "Code folders: API.md + README.md; Navigation folders: README.md only",
-      "Use pre-analyzed data from Phase 2 (no redundant analysis)"
-    ],
-    "focus_paths": ["${group_dirs_from_json}"],
-    "precomputed_data": {
-      "phase2_analysis": "${session_dir}/.process/doc-planning-data.json"
-    }
-  },
-  "flow_control": {
-    "pre_analysis": [
-      {
-        "step": "load_precomputed_data",
-        "action": "Load Phase 2 analysis and extract group directories",
-        "commands": [
-          "ccw session ${session_id} read .process/doc-planning-data.json",
-          "ccw session ${session_id} read .process/doc-planning-data.json --raw | jq '.groups.assignments[] | select(.group_id == \"${group_number}\") | .directories'"
-        ],
-        "output_to": "phase2_context",
-        "note": "Single JSON file contains all Phase 2 analysis results"
-      }
-    ],
-    "implementation_approach": [
-      {
-        "step": 1,
-        "title": "Generate documentation for assigned directory group",
-        "description": "Process directories in Group ${group_number} using pre-analyzed data",
-        "modification_points": [
-          "Read group directories from [phase2_context].groups.assignments[${group_number}].directories",
-          "For each directory: parse folder types from folder_analysis, parse structure from unified_analysis",
-          "Map source_path to .workflow/docs/${project_name}/{path}",
-          "Generate API.md for code folders, README.md for all folders",
-          "Preserve user modifications from [phase2_context].existing_docs.content"
-        ],
-        "logic_flow": [
-          "phase2 = parse([phase2_context])",
-          "dirs = phase2.groups.assignments[${group_number}].directories",
-          "for dir in dirs:",
-          "  folder_info = find(dir, phase2.folder_analysis)",
-          "  outline = find(dir, phase2.unified_analysis)",
-          "  if folder_info.type == 'code': generate API.md + README.md",
-          "  elif folder_info.type == 'navigation': generate README.md only",
-          "  write to .workflow/docs/${project_name}/{dir}/"
-        ],
-        "depends_on": [],
-        "output": "group_module_docs"
-      }
-    ],
-    "target_files": [
-      ".workflow/docs/${project_name}/*/API.md",
-      ".workflow/docs/${project_name}/*/README.md"
-    ]
-  }
-}
-```
-
-**CLI Execute Mode Note**: When `cli_execute=true`, add Step 2 in `implementation_approach`:
-```json
-{
-  "step": 2,
-  "title": "Batch generate documentation via CLI",
-  "command": "ccw cli -p 'PURPOSE: Generate module docs\\nTASK: Create documentation\\nMODE: write\\nCONTEXT: @**/* [phase2_context]\\nEXPECTED: API.md and README.md\\nRULES: Mirror structure' --tool gemini --mode write --cd ${dirs_from_group}",
-  "depends_on": [1],
-  "output": "generated_docs"
-}
-```
-
-### Level 2: Project README Task
-
-**Task ID**: `IMPL-${readme_id}` (where `readme_id = group_count + 1`)
-**Dependencies**: Depends on all Level 1 tasks completing.
-
-```json
-{
-  "id": "IMPL-${readme_id}",
-  "title": "Generate Project README",
-  "status": "pending",
-  "depends_on": ["IMPL-001", "...", "IMPL-${group_count}"],
-  "meta": {"type": "docs", "agent": "@doc-generator", "tool": "gemini", "cli_execute": false},
-  "flow_control": {
-    "pre_analysis": [
-      {
-        "step": "load_existing_readme",
-        "command": "bash(cat .workflow/docs/${project_name}/README.md 2>/dev/null || echo 'No existing README')",
-        "output_to": "existing_readme"
-      },
-      {
-        "step": "load_module_docs",
-        "command": "bash(find .workflow/docs/${project_name} -type f -name '*.md' ! -path '.workflow/docs/${project_name}/README.md' ! -path '.workflow/docs/${project_name}/ARCHITECTURE.md' ! -path '.workflow/docs/${project_name}/EXAMPLES.md' ! -path '.workflow/docs/${project_name}/api/*' | xargs cat)",
-        "output_to": "all_module_docs"
-      },
-      {
-        "step": "analyze_project",
-        "command": "bash(ccw cli -p \"PURPOSE: Analyze project structure\\nTASK: Extract overview from modules\\nMODE: analysis\\nCONTEXT: [all_module_docs]\\nEXPECTED: Project outline\" --tool gemini --mode analysis)",
-        "output_to": "project_outline"
-      }
-    ],
-    "implementation_approach": [
-      {
-        "step": 1,
-        "title": "Generate project README",
-        "description": "Generate project README with navigation links while preserving user modifications",
-        "modification_points": [
-          "Parse [project_outline] and [all_module_docs]",
-          "Generate README structure with navigation links",
-          "Preserve [existing_readme] user modifications"
-        ],
-        "logic_flow": ["Parse data", "Generate README with navigation", "Preserve modifications"],
-        "depends_on": [],
-        "output": "project_readme"
-      }
-    ],
-    "target_files": [".workflow/docs/${project_name}/README.md"]
-  }
-}
-```
-
-### Level 3: Architecture & Examples Documentation Task
-
-**Task ID**: `IMPL-${arch_id}` (where `arch_id = group_count + 2`)
-**Dependencies**: Depends on Level 2 (Project README).
-
-```json
-{
-  "id": "IMPL-${arch_id}",
-  "title": "Generate Architecture & Examples Documentation",
-  "status": "pending",
-  "depends_on": ["IMPL-${readme_id}"],
-  "meta": {"type": "docs", "agent": "@doc-generator", "tool": "gemini", "cli_execute": false},
-  "flow_control": {
-    "pre_analysis": [
-      {"step": "load_existing_docs", "command": "bash(cat .workflow/docs/${project_name}/{ARCHITECTURE,EXAMPLES}.md 2>/dev/null || echo 'No existing docs')", "output_to": "existing_arch_examples"},
-      {"step": "load_all_docs", "command": "bash(cat .workflow/docs/${project_name}/README.md && find .workflow/docs/${project_name} -type f -name '*.md' ! -path '*/README.md' ! -path '*/ARCHITECTURE.md' ! -path '*/EXAMPLES.md' ! -path '*/api/*' | xargs cat)", "output_to": "all_docs"},
-      {"step": "analyze_architecture", "command": "bash(ccw cli -p \"PURPOSE: Analyze system architecture\\nTASK: Synthesize architectural overview and examples\\nMODE: analysis\\nCONTEXT: [all_docs]\\nEXPECTED: Architecture + Examples outline\" --tool gemini --mode analysis)", "output_to": "arch_examples_outline"}
-    ],
-    "implementation_approach": [
-      {
-        "step": 1,
-        "title": "Generate architecture and examples documentation",
-        "modification_points": [
-          "Parse [arch_examples_outline] and [all_docs]",
-          "Generate ARCHITECTURE.md (system design, patterns)",
-          "Generate EXAMPLES.md (code snippets, usage)",
-          "Preserve [existing_arch_examples] modifications"
-        ],
-        "depends_on": [],
-        "output": "arch_examples_docs"
-      }
-    ],
-    "target_files": [".workflow/docs/${project_name}/ARCHITECTURE.md", ".workflow/docs/${project_name}/EXAMPLES.md"]
-  }
-}
-```
-
-### Level 4: HTTP API Documentation Task (Optional)
-
-**Task ID**: `IMPL-${api_id}` (where `api_id = group_count + 3`)
-**Dependencies**: Depends on Level 3.
-
-```json
-{
-  "id": "IMPL-${api_id}",
-  "title": "Generate HTTP API Documentation",
-  "status": "pending",
-  "depends_on": ["IMPL-${arch_id}"],
-  "meta": {"type": "docs", "agent": "@doc-generator", "tool": "gemini", "cli_execute": false},
-  "flow_control": {
-    "pre_analysis": [
-      {"step": "discover_api", "command": "bash(rg 'router\\.| @(Get|Post)' -g '*.{ts,js}')", "output_to": "endpoint_discovery"},
-      {"step": "load_existing_api", "command": "bash(cat .workflow/docs/${project_name}/api/README.md 2>/dev/null || echo 'No existing API docs')", "output_to": "existing_api_docs"},
-      {"step": "analyze_api", "command": "bash(ccw cli -p \"PURPOSE: Document HTTP API\\nTASK: Analyze endpoints\\nMODE: analysis\\nCONTEXT: @src/api/**/* [endpoint_discovery]\\nEXPECTED: API outline\" --tool gemini --mode analysis)", "output_to": "api_outline"}
-    ],
-    "implementation_approach": [
-      {
-        "step": 1,
-        "title": "Generate HTTP API documentation",
-        "modification_points": [
-          "Parse [api_outline] and [endpoint_discovery]",
-          "Document endpoints, request/response formats",
-          "Preserve [existing_api_docs] modifications"
-        ],
-        "depends_on": [],
-        "output": "api_docs"
-      }
-    ],
-    "target_files": [".workflow/docs/${project_name}/api/README.md"]
-  }
-}
-```
-
-## Session Structure
-
-**Unified Structure** (single JSON replaces multiple text files):
-
-```
-.workflow/active/
-└── WFS-docs-{timestamp}/
-    ├── workflow-session.json            # Session metadata
-    ├── IMPL_PLAN.md
-    ├── TODO_LIST.md
-    ├── .process/
-    │   └── doc-planning-data.json       # All Phase 2 analysis data (replaces 7+ files)
-    └── .task/
-        ├── IMPL-001.json                # Small: all modules | Large: group 1
-        ├── IMPL-00N.json                # (Large only: groups 2-N)
-        ├── IMPL-{N+1}.json              # README (full mode)
-        ├── IMPL-{N+2}.json              # ARCHITECTURE+EXAMPLES (full mode)
-        └── IMPL-{N+3}.json              # HTTP API (optional)
-```
-
-**doc-planning-data.json Structure**:
-```json
-{
-  "metadata": {
-    "generated_at": "2025-11-03T16:41:06+08:00",
-    "project_name": "Claude_dms3",
-    "project_root": "/d/Claude_dms3"
-  },
-  "folder_analysis": [
-    {"path": "./src/core", "type": "code", "code_count": 5, "dirs_count": 2},
-    {"path": "./src/utils", "type": "navigation", "code_count": 0, "dirs_count": 4}
-  ],
-  "top_level_dirs": ["src/modules", "src/utils", "lib/core"],
-  "existing_docs": {
-    "file_list": [".workflow/docs/project/src/core/API.md"],
-    "content": "... concatenated existing docs ..."
-  },
-  "unified_analysis": [
-    {"module_path": "./src/core", "outline_summary": "Core functionality"}
-  ],
-  "groups": {
-    "count": 4,
-    "assignments": [
-      {"group_id": "001", "directories": ["src/modules", "src/utils"], "doc_count": 6},
-      {"group_id": "002", "directories": ["lib/core", "lib/helpers"], "doc_count": 7}
-    ]
-  },
-  "statistics": {
-    "total": 15,
-    "code": 8,
-    "navigation": 7,
-    "top_level": 3
-  }
-}
-```
-
-**Workflow Session Structure** (workflow-session.json):
-```json
-{
-  "session_id": "WFS-docs-{timestamp}",
-  "project": "{project_name} documentation",
-  "status": "planning",
-  "timestamp": "2024-01-20T14:30:22+08:00",
-  "path": ".",
-  "target_path": "/path/to/project",
-  "project_root": "/path/to/project",
-  "project_name": "{project_name}",
-  "mode": "full",
-  "tool": "gemini",
-  "cli_execute": false,
-  "update_mode": "update",
-  "existing_docs": 5,
-  "analysis": {
-    "total": "15",
-    "code": "8",
-    "navigation": "7",
-    "top_level": "3"
-  }
-}
-```
-
-## Generated Documentation
-
-**Structure mirrors project source directories under project-specific folder**:
-
-```
-.workflow/docs/
-└── {project_name}/                    # Project-specific root
-    ├── src/                           # Mirrors src/ directory
-    │   ├── modules/
-    │   │   ├── README.md              # Navigation
-    │   │   ├── auth/
-    │   │   │   ├── API.md             # API signatures
-    │   │   │   ├── README.md          # Module docs
-    │   │   │   └── middleware/
-    │   │   │       ├── API.md
-    │   │   │       └── README.md
-    │   │   └── api/
-    │   │       ├── API.md
-    │   │       └── README.md
-    │   └── utils/
-    │       └── README.md
-    ├── lib/                           # Mirrors lib/ directory
-    │   └── core/
-    │       ├── API.md
-    │       └── README.md
-    ├── README.md                      # Project root
-    ├── ARCHITECTURE.md                # System design
-    ├── EXAMPLES.md                    # Usage examples
-    └── api/                           # Optional
-        └── README.md                  # HTTP API reference
-```
-
-## Execution Commands
-
-```bash
-# Execute entire workflow (auto-discovers active session)
-/workflow:execute
-
-# Or specify session
-/workflow:execute --resume-session="WFS-docs-yyyymmdd-hhmmss"
-
-# Individual task execution
-/task:execute IMPL-001
-```
-
-## Template Reference
-
-**Available Templates** (`~/.claude/workflows/cli-templates/prompts/documentation/`):
-- `api.txt`: Code API (Part A) + HTTP API (Part B)
-- `module-readme.txt`: Module purpose, usage, dependencies
-- `folder-navigation.txt`: Navigation README for folders with subdirectories
-- `project-readme.txt`: Project overview, getting started, navigation
-- `project-architecture.txt`: System structure, module map, design patterns
-- `project-examples.txt`: End-to-end usage examples
-
-## Execution Mode Summary
-
-| Mode | CLI Placement | CLI MODE | Approval Flag | Agent Role |
-|------|---------------|----------|---------------|------------|
-| **Agent (default)** | pre_analysis | analysis | (none) | Generates documentation content |
-| **CLI (--cli-execute)** | implementation_approach | write | --mode write | Executes CLI commands, validates output |
-
-**Execution Flow**:
-- **Phase 2**: Unified analysis once, results in `.process/`
-- **Phase 4**: Dynamic grouping (max 2 dirs per group)
-- **Level 1**: Parallel processing for module tree groups
-- **Level 2+**: Sequential execution for project-level docs
-
-## Related Commands
-- `/workflow:execute` - Execute documentation tasks
-- `/workflow:status` - View task progress
-- `/workflow:session:complete` - Mark session complete