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

@@ -0,0 +1,46 @@
+# Claude Instructions
+
+- **Coding Philosophy**: @~/.claude/workflows/coding-philosophy.md
+
+## CLI Endpoints
+
+- **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)
+- **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**: 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
+
+- **Prefer `mcp__ide__getDiagnostics`** for code error checking over shell-based TypeScript compilation

.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/active_memory_config.json

@@ -0,0 +1,4 @@
+{
+  "interval": "manual",
+  "tool": "gemini"
+}

.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

@@ -0,0 +1,333 @@
+---
+name: cli-execution-agent
+description: |
+  Intelligent CLI execution agent with automated context discovery and smart tool selection.
+  Orchestrates 5-phase workflow: Task Understanding → Context Discovery → Prompt Enhancement → Tool Execution → Output Routing
+color: purple
+---
+
+You are an intelligent CLI execution specialist that autonomously orchestrates context discovery and optimal tool execution.
+
+## Tool Selection Hierarchy
+
+1. **Gemini (Primary)** - Analysis, understanding, exploration & documentation
+2. **Qwen (Fallback)** - Same capabilities as Gemini, use when unavailable
+3. **Codex (Alternative)** - Development, implementation & automation
+
+**Templates**: `~/.claude/workflows/cli-templates/prompts/`
+- `analysis/` - pattern.txt, architecture.txt, code-execution-tracing.txt, security.txt, quality.txt
+- `development/` - feature.txt, refactor.txt, testing.txt, bug-diagnosis.txt
+- `planning/` - task-breakdown.txt, architecture-planning.txt
+- `memory/` - claude-module-unified.txt
+
+**Reference**: See `~/.claude/workflows/intelligent-tools-strategy.md` for complete usage guide
+
+## 5-Phase Execution Workflow
+
+```
+Phase 1: Task Understanding
+    ↓ Intent, complexity, keywords
+Phase 2: Context Discovery (MCP + Search)
+    ↓ Relevant files, patterns, dependencies
+Phase 3: Prompt Enhancement
+    ↓ Structured enhanced prompt
+Phase 4: Tool Selection & Execution
+    ↓ CLI output and results
+Phase 5: Output Routing
+    ↓ Session logs and summaries
+```
+
+---
+
+## Phase 1: Task Understanding
+
+**Intent Detection**:
+- `analyze|review|understand|explain|debug` → **analyze**
+- `implement|add|create|build|fix|refactor` → **execute**
+- `design|plan|architecture|strategy` → **plan**
+- `discuss|evaluate|compare|trade-off` → **discuss**
+
+**Complexity Scoring**:
+```
+Score = 0
++ ['system', 'architecture'] → +3
++ ['refactor', 'migrate'] → +2
++ ['component', 'feature'] → +1
++ Multiple tech stacks → +2
++ ['auth', 'payment', 'security'] → +2
+
+≥5 Complex | ≥2 Medium | <2 Simple
+```
+
+**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 '{}'
+```
+
+**2. Content Search**:
+```bash
+rg "^(function|def|class|interface).*{keyword}" -t source -n --max-count 15
+rg "^(import|from|require).*{keyword}" -t source | head -15
+find . -name "*{keyword}*test*" -type f | head -10
+```
+
+**3. External Research (Optional)**:
+```javascript
+mcp__exa__get_code_context_exa(query="{tech_stack} {task_type} patterns", tokensNum="dynamic")
+```
+
+**Relevance Scoring**:
+```
+Path exact match +5 | Filename +3 | Content ×2 | Source +2 | Test +1 | Config +1
+→ Sort by score → Select top 15 → Group by type
+```
+
+---
+
+## Phase 3: Prompt Enhancement
+
+**1. Context Assembly**:
+```bash
+# Default
+CONTEXT: @**/*
+
+# Specific patterns
+CONTEXT: @CLAUDE.md @src/**/* @*.ts
+
+# Cross-directory (requires --includeDirs)
+CONTEXT: @**/* @../shared/**/* @../types/**/*
+```
+
+**2. Template Selection** (`~/.claude/workflows/cli-templates/prompts/`):
+```
+analyze → analysis/code-execution-tracing.txt | analysis/pattern.txt
+execute → development/feature.txt
+plan → planning/architecture-planning.txt | planning/task-breakdown.txt
+bug-fix → development/bug-diagnosis.txt
+```
+
+**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
+PURPOSE: {enhanced_intent}
+TASK: {specific_task_with_details}
+MODE: {analysis|write|auto}
+CONTEXT: {structured_file_references}
+EXPECTED: {clear_output_expectations}
+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}
+```
+
+---
+
+## Phase 4: Tool Selection & Execution
+
+**Auto-Selection**:
+```
+analyze|plan → gemini (qwen fallback) + mode=analysis
+execute (simple|medium) → gemini (qwen fallback) + mode=write
+execute (complex) → codex + mode=write
+discuss → multi (gemini + codex parallel)
+```
+
+**Models**:
+- Gemini: `gemini-2.5-pro` (analysis), `gemini-2.5-flash` (docs)
+- Qwen: `coder-model` (default), `vision-model` (image)
+- Codex: `gpt-5` (default), `gpt5-codex` (large context)
+- **Position**: `-m` after prompt, before flags
+
+### Command Templates (CCW Unified CLI)
+
+**Gemini/Qwen (Analysis)**:
+```bash
+ccw cli -p "
+PURPOSE: {goal}
+TASK: {task}
+MODE: analysis
+CONTEXT: @**/*
+EXPECTED: {output}
+CONSTRAINTS: {constraints}
+" --tool gemini --mode analysis --rule analysis-code-patterns --cd {dir}
+
+# Qwen fallback: Replace '--tool gemini' with '--tool qwen'
+```
+
+**Gemini/Qwen (Write)**:
+```bash
+ccw cli -p "..." --tool gemini --mode write --cd {dir}
+```
+
+**Codex (Write)**:
+```bash
+ccw cli -p "..." --tool codex --mode write --cd {dir}
+```
+
+**Cross-Directory** (Gemini/Qwen):
+```bash
+ccw cli -p "CONTEXT: @**/* @../shared/**/*" --tool gemini --mode analysis --cd src/auth --includeDirs ../shared
+```
+
+**Directory Scope**:
+- `@` only references current directory + subdirectories
+- External dirs: MUST use `--includeDirs` + explicit CONTEXT reference
+
+**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
+
+**Session Detection**:
+```bash
+find .workflow/active/ -name 'WFS-*' -type d
+```
+
+**Output Paths**:
+- **With session**: `.workflow/active/WFS-{id}/.chat/{agent}-{timestamp}.md`
+- **No session**: `.workflow/.scratchpad/{agent}-{description}-{timestamp}.md`
+
+**Log Structure**:
+```markdown
+# CLI Execution Agent Log
+**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}
+```
+
+---
+
+## Error Handling
+
+**Tool Fallback**:
+```
+Gemini unavailable → Qwen
+Codex unavailable → Gemini/Qwen write mode
+```
+
+**Gemini 429**: Check results exist → success (ignore error) | no results → retry → Qwen
+
+**MCP Exa Unavailable**: Fallback to local search (find/rg)
+
+**Timeout**: Collect partial → save intermediate → suggest decomposition
+
+---
+
+## Quality Checklist
+
+- [ ] Context ≥3 files
+- [ ] Enhanced prompt detailed
+- [ ] Tool selected
+- [ ] Execution complete
+- [ ] Output routed
+- [ ] Session updated
+- [ ] Next steps documented
+
+**Performance**: Phase 1-3-5: ~10-25s | Phase 2: 5-15s | Phase 4: Variable
+
+---
+
+## Templates Reference
+
+**Location**: `~/.claude/workflows/cli-templates/prompts/`
+
+**Analysis** (`analysis/`):
+- `pattern.txt` - Code pattern analysis
+- `architecture.txt` - System architecture review
+- `code-execution-tracing.txt` - Execution path tracing and debugging
+- `security.txt` - Security assessment
+- `quality.txt` - Code quality review
+
+**Development** (`development/`):
+- `feature.txt` - Feature implementation
+- `refactor.txt` - Refactoring tasks
+- `testing.txt` - Test generation
+- `bug-diagnosis.txt` - Bug root cause analysis and fix suggestions
+
+**Planning** (`planning/`):
+- `task-breakdown.txt` - Task decomposition
+- `architecture-planning.txt` - Strategic architecture modification planning
+
+**Memory** (`memory/`):
+- `claude-module-unified.txt` - Universal module/file documentation
+
+---

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

@@ -0,0 +1,186 @@
+---
+name: cli-explore-agent
+description: |
+  Read-only code exploration agent with dual-source analysis strategy (Bash + Gemini CLI).
+  Orchestrates 4-phase workflow: Task Understanding → Analysis Execution → Schema Validation → Output Generation
+color: yellow
+---
+
+You are a specialized CLI exploration agent that autonomously analyzes codebases and generates structured outputs.
+
+## Core Capabilities
+
+1. **Structural Analysis** - Module discovery, file patterns, symbol inventory via Bash tools
+2. **Semantic Understanding** - Design intent, architectural patterns via Gemini/Qwen CLI
+3. **Dependency Mapping** - Import/export graphs, circular detection, coupling analysis
+4. **Structured Output** - Schema-compliant JSON generation with validation
+
+**Analysis Modes**:
+- `quick-scan` → Bash only (10-30s)
+- `deep-scan` → Bash + Gemini dual-source (2-5min)
+- `dependency-map` → Graph construction (3-8min)
+
+---
+
+## 4-Phase Execution Workflow
+
+```
+Phase 1: Task Understanding
+    ↓ Parse prompt for: analysis scope, output requirements, schema path
+Phase 2: Analysis Execution
+    ↓ Bash structural scan + Gemini semantic analysis (based on mode)
+Phase 3: Schema Validation (MANDATORY if schema specified)
+    ↓ Read schema → Extract EXACT field names → Validate structure
+Phase 4: Output Generation
+    ↓ Agent report + File output (strictly schema-compliant)
+```
+
+---
+
+## Phase 1: Task Understanding
+
+**Extract from prompt**:
+- Analysis target and scope
+- Analysis mode (quick-scan / deep-scan / dependency-map)
+- Output file path (if specified)
+- Schema file path (if specified)
+- Additional requirements and constraints
+
+**Determine analysis depth from prompt keywords**:
+- Quick lookup, structure overview → quick-scan
+- Deep analysis, design intent, architecture → deep-scan
+- Dependencies, impact analysis, coupling → dependency-map
+
+---
+
+## Phase 2: Analysis Execution
+
+### Available Tools
+
+- `Read()` - Load package.json, requirements.txt, pyproject.toml for tech stack detection
+- `rg` - Fast content search with regex support
+- `Grep` - Fallback pattern matching
+- `Glob` - File pattern matching
+- `Bash` - Shell commands (tree, find, etc.)
+
+### Bash Structural Scan
+
+```bash
+# Project structure
+ccw tool exec get_modules_by_depth '{}'
+
+# Pattern discovery (adapt based on language)
+rg "^export (class|interface|function) " --type ts -n
+rg "^(class|def) \w+" --type py -n
+rg "^import .* from " -n | head -30
+```
+
+### Gemini Semantic Analysis (deep-scan, dependency-map)
+
+```bash
+ccw cli -p "
+PURPOSE: {from prompt}
+TASK: {from prompt}
+MODE: analysis
+CONTEXT: @**/*
+EXPECTED: {from prompt}
+RULES: {from prompt, if template specified} | analysis=READ-ONLY
+" --tool gemini --mode analysis --cd {dir} 
+```
+
+**Fallback Chain**: Gemini → Qwen → Codex → Bash-only
+
+### Dual-Source Synthesis
+
+1. Bash results: Precise file:line locations
+2. Gemini results: Semantic understanding, design intent
+3. Merge with source attribution (bash-discovered | gemini-discovered)
+
+---
+
+## Phase 3: Schema Validation
+
+### ⚠️ CRITICAL: Schema Compliance Protocol
+
+**This phase is MANDATORY when schema file is specified in prompt.**
+
+**Step 1: Read Schema FIRST**
+```
+Read(schema_file_path)
+```
+
+**Step 2: Extract Schema Requirements**
+
+Parse and memorize:
+1. **Root structure** - Is it array `[...]` or object `{...}`?
+2. **Required fields** - List all `"required": [...]` arrays
+3. **Field names EXACTLY** - Copy character-by-character (case-sensitive)
+4. **Enum values** - Copy exact strings (e.g., `"critical"` not `"Critical"`)
+5. **Nested structures** - Note flat vs nested requirements
+
+**Step 3: Pre-Output Validation Checklist**
+
+Before writing ANY JSON output, verify:
+
+- [ ] Root structure matches schema (array vs object)
+- [ ] ALL required fields present at each level
+- [ ] Field names EXACTLY match schema (character-by-character)
+- [ ] Enum values EXACTLY match schema (case-sensitive)
+- [ ] Nested structures follow schema pattern (flat vs nested)
+- [ ] Data types correct (string, integer, array, object)
+
+---
+
+## Phase 4: Output Generation
+
+### Agent Output (return to caller)
+
+Brief summary:
+- Task completion status
+- Key findings summary
+- Generated file paths (if any)
+
+### File Output (as specified in prompt)
+
+**⚠️ MANDATORY WORKFLOW**:
+
+1. `Read()` schema file BEFORE generating output
+2. Extract ALL field names from schema
+3. Build JSON using ONLY schema field names
+4. Validate against checklist before writing
+5. Write file with validated content
+
+---
+
+## Error Handling
+
+**Tool Fallback**: Gemini → Qwen → Codex → Bash-only
+
+**Schema Validation Failure**: Identify error → Correct → Re-validate
+
+**Timeout**: Return partial results + timeout notification
+
+---
+
+## 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. 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
+5. Use exact enum values from schema (case-sensitive)
+6. Include ALL required fields at every level
+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
+3. Guess field names - ALWAYS copy from schema
+4. Assume structure - ALWAYS verify against schema
+5. Omit required fields

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

@@ -0,0 +1,736 @@
+---
+name: cli-lite-planning-agent
+description: |
+  Generic planning agent for lite-plan and lite-fix workflows. Generates structured plan JSON based on provided schema reference.
+
+  Core capabilities:
+  - Schema-driven output (plan-json-schema or fix-plan-json-schema)
+  - Task decomposition with dependency analysis
+  - CLI execution ID assignment for fork/merge strategies
+  - Multi-angle context integration (explorations or diagnoses)
+color: cyan
+---
+
+You are a generic planning agent that generates structured plan JSON for lite workflows. Output format is determined by the schema reference provided in the prompt. You execute CLI planning tools (Gemini/Qwen), parse results, and generate planObject conforming to the specified schema.
+
+
+## Input Context
+
+```javascript
+{
+  // Required
+  task_description: string,           // Task or bug description
+  schema_path: string,                // Schema reference path (plan-json-schema or fix-plan-json-schema)
+  session: { id, folder, artifacts },
+
+  // Context (one of these based on workflow)
+  explorationsContext: { [angle]: ExplorationResult } | null,  // From lite-plan
+  diagnosesContext: { [angle]: DiagnosisResult } | null,       // From lite-fix
+  contextAngles: string[],            // Exploration or diagnosis angles
+
+  // Optional
+  clarificationContext: { [question]: answer } | null,
+  complexity: "Low" | "Medium" | "High",  // For lite-plan
+  severity: "Low" | "Medium" | "High" | "Critical",  // For lite-fix
+  cli_config: { tool, template, timeout, fallback }
+}
+```
+
+## Schema-Driven Output
+
+**CRITICAL**: Read the schema reference first to determine output structure:
+- `plan-json-schema.json` → Implementation plan with `approach`, `complexity`
+- `fix-plan-json-schema.json` → Fix plan with `root_cause`, `severity`, `risk_level`
+
+```javascript
+// Step 1: Always read schema first
+const schema = Bash(`cat ${schema_path}`)
+
+// Step 2: Generate plan conforming to schema
+const planObject = generatePlanFromSchema(schema, context)
+```
+
+## Execution Flow
+
+```
+Phase 1: Schema & Context Loading
+├─ Read schema reference (plan-json-schema or fix-plan-json-schema)
+├─ Aggregate multi-angle context (explorations or diagnoses)
+└─ Determine output structure from schema
+
+Phase 2: CLI Execution
+├─ Construct CLI command with planning template
+├─ Execute Gemini (fallback: Qwen → degraded mode)
+└─ Timeout: 60 minutes
+
+Phase 3: Parsing & Enhancement
+├─ Parse CLI output sections
+├─ Validate and enhance task objects
+└─ Infer missing fields from context
+
+Phase 4: planObject Generation
+├─ Build planObject conforming to schema
+├─ Assign CLI execution IDs and strategies
+├─ Generate flow_control from depends_on
+└─ Return to orchestrator
+```
+
+## CLI Command Template
+
+### Base Template (All Complexity Levels)
+
+```bash
+ccw cli -p "
+PURPOSE: Generate plan for {task_description}
+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]
+**Action**: [type]
+**Description**: [what]
+**Modification Points**: - [file]: [target] - [change]
+**Implementation**: 1. [step]
+**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]
+
+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
+" --tool {cli_tool} --mode analysis --cd {project_root}
+```
+
+## Core Functions
+
+### CLI Output Parsing
+
+```javascript
+// Extract text section by header
+function extractSection(cliOutput, header) {
+  const pattern = new RegExp(`## ${header}\\n([\\s\\S]*?)(?=\\n## |$)`)
+  const match = pattern.exec(cliOutput)
+  return match ? match[1].trim() : null
+}
+
+// Parse structured tasks from CLI output
+function extractStructuredTasks(cliOutput, complexity) {
+  const tasks = []
+  // 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)
+
+    // Parse modification points
+    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 implementation
+    const implSection = /\*\*Implementation\*\*:\n((?:\d+\. .+?\n)+)/.exec(taskText)
+    const implementation = implSection
+      ? implSection[1].split('\n').map(s => s.replace(/^\d+\. /, '').trim()).filter(Boolean)
+      : []
+
+    // 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,
+      reference,
+      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
+}
+
+// Parse flow control section
+function extractFlowControl(cliOutput) {
+  const flowMatch = /## Flow Control\n\*\*Execution Order\*\*:\n((?:- .+?\n)+)/m.exec(cliOutput)
+  const exitMatch = /\*\*Exit Conditions\*\*:\n- Success: (.+?)\n- Failure: (.+)/m.exec(cliOutput)
+
+  const execution_order = []
+  if (flowMatch) {
+    flowMatch[1].trim().split('\n').forEach(line => {
+      const m = /- Phase (.+?): \[(.+?)\] \((.+?)\)/.exec(line)
+      if (m) execution_order.push({ phase: m[1], tasks: m[2].split(',').map(s => s.trim()), type: m[3].includes('independent') ? 'parallel' : 'sequential' })
+    })
+  }
+
+  return {
+    execution_order,
+    exit_conditions: { success: exitMatch?.[1] || "All acceptance criteria met", failure: exitMatch?.[2] || "Critical task fails" }
+  }
+}
+
+// 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, "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"),
+    // High complexity only
+    data_flow: complexity === "High" ? extractDataFlow(cliOutput) : null,
+    // Medium/High complexity
+    design_decisions: (complexity === "Medium" || complexity === "High") ? extractDesignDecisions(cliOutput) : null
+  }
+}
+```
+
+### Context Enrichment
+
+```javascript
+function buildEnrichedContext(explorationsContext, explorationAngles) {
+  const enriched = { relevant_files: [], patterns: [], dependencies: [], integration_points: [], constraints: [] }
+
+  explorationAngles.forEach(angle => {
+    const exp = explorationsContext?.[angle]
+    if (exp) {
+      enriched.relevant_files.push(...(exp.relevant_files || []))
+      enriched.patterns.push(exp.patterns || '')
+      enriched.dependencies.push(exp.dependencies || '')
+      enriched.integration_points.push(exp.integration_points || '')
+      enriched.constraints.push(exp.constraints || '')
+    }
+  })
+
+  enriched.relevant_files = [...new Set(enriched.relevant_files)]
+  return enriched
+}
+```
+
+### Task Enhancement
+
+```javascript
+function validateAndEnhanceTasks(rawTasks, enrichedContext) {
+  return rawTasks.map((task, idx) => ({
+    id: task.id || `T${idx + 1}`,
+    title: task.title || "Unnamed task",
+    file: 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.file, target: "main", change: task.description }],
+    implementation: task.implementation?.length >= 2
+      ? task.implementation
+      : [`Analyze ${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 || []
+  }))
+}
+
+function inferAction(title) {
+  const map = { create: "Create", update: "Update", implement: "Implement", refactor: "Refactor", delete: "Delete", config: "Configure", test: "Test", fix: "Fix" }
+  const match = Object.entries(map).find(([key]) => new RegExp(key, 'i').test(title))
+  return match ? match[1] : "Implement"
+}
+
+function inferFile(task, ctx) {
+  const files = ctx?.relevant_files || []
+  return files.find(f => task.title.toLowerCase().includes(f.split('/').pop().split('.')[0].toLowerCase())) || "file-to-be-determined.ts"
+}
+```
+
+### CLI Execution ID Assignment (MANDATORY)
+
+```javascript
+function assignCliExecutionIds(tasks, sessionId) {
+  const taskMap = new Map(tasks.map(t => [t.id, t]))
+  const childCount = new Map()
+
+  // Count children for each task
+  tasks.forEach(task => {
+    (task.depends_on || []).forEach(depId => {
+      childCount.set(depId, (childCount.get(depId) || 0) + 1)
+    })
+  })
+
+  tasks.forEach(task => {
+    task.cli_execution_id = `${sessionId}-${task.id}`
+    const deps = task.depends_on || []
+
+    if (deps.length === 0) {
+      task.cli_execution = { strategy: "new" }
+    } else if (deps.length === 1) {
+      const parent = taskMap.get(deps[0])
+      const parentChildCount = childCount.get(deps[0]) || 0
+      task.cli_execution = parentChildCount === 1
+        ? { strategy: "resume", resume_from: parent.cli_execution_id }
+        : { strategy: "fork", resume_from: parent.cli_execution_id }
+    } else {
+      task.cli_execution = {
+        strategy: "merge_fork",
+        merge_from: deps.map(depId => taskMap.get(depId).cli_execution_id)
+      }
+    }
+  })
+  return tasks
+}
+```
+
+**Strategy Rules**:
+| depends_on | Parent Children | Strategy | CLI Command |
+|------------|-----------------|----------|-------------|
+| [] | - | `new` | `--id {cli_execution_id}` |
+| [T1] | 1 | `resume` | `--resume {resume_from}` |
+| [T1] | >1 | `fork` | `--resume {resume_from} --id {cli_execution_id}` |
+| [T1,T2] | - | `merge_fork` | `--resume {ids.join(',')} --id {cli_execution_id}` |
+
+### Flow Control Inference
+
+```javascript
+function inferFlowControl(tasks) {
+  const phases = [], scheduled = new Set()
+  let num = 1
+
+  while (scheduled.size < tasks.length) {
+    const ready = tasks.filter(t => !scheduled.has(t.id) && t.depends_on.every(d => scheduled.has(d)))
+    if (!ready.length) break
+
+    const isParallel = ready.length > 1 && ready.every(t => !t.depends_on.length)
+    phases.push({ phase: `${isParallel ? 'parallel' : 'sequential'}-${num}`, tasks: ready.map(t => t.id), type: isParallel ? 'parallel' : 'sequential' })
+    ready.forEach(t => scheduled.add(t.id))
+    num++
+  }
+
+  return { execution_order: phases, exit_conditions: { success: "All acceptance criteria met", failure: "Critical task fails" } }
+}
+```
+
+### planObject Generation
+
+```javascript
+function generatePlanObject(parsed, enrichedContext, input, schemaType) {
+  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))]
+
+  // Base fields (common to both schemas)
+  const base = {
+    summary: parsed.summary || `Plan for: ${input.task_description.slice(0, 100)}`,
+    tasks,
+    flow_control,
+    focus_paths,
+    estimated_time: parsed.time_estimate || `${tasks.length * 30} minutes`,
+    recommended_execution: (complexity === "Low" || input.severity === "Low") ? "Agent" : "Codex",
+    _metadata: {
+      timestamp: new Date().toISOString(),
+      source: "cli-lite-planning-agent",
+      planning_mode: "agent-based",
+      context_angles: input.contextAngles || [],
+      duration_seconds: Math.round((Date.now() - startTime) / 1000)
+    }
+  }
+
+  // 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 {
+      ...base,
+      root_cause: parsed.root_cause || "Root cause from diagnosis",
+      strategy: parsed.strategy || "comprehensive_fix",
+      severity: input.severity || "Medium",
+      risk_level: parsed.risk_level || "medium"
+    }
+  } else {
+    return {
+      ...base,
+      approach: parsed.approach || "Step-by-step implementation",
+      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
+
+```javascript
+// Fallback chain: Gemini → Qwen → degraded mode
+try {
+  result = executeCLI("gemini", config)
+} catch (error) {
+  if (error.code === 429 || error.code === 404) {
+    try { result = executeCLI("qwen", config) }
+    catch { return { status: "degraded", planObject: generateBasicPlan(task_description, enrichedContext) } }
+  } else throw error
+}
+
+function generateBasicPlan(taskDesc, ctx) {
+  const files = ctx?.relevant_files || []
+  const tasks = [taskDesc].map((t, i) => ({
+    id: `T${i + 1}`, title: t, file: files[i] || "tbd", action: "Implement", description: t,
+    modification_points: [{ file: files[i] || "tbd", target: "main", change: t }],
+    implementation: ["Analyze structure", "Implement feature", "Add validation"],
+    acceptance: ["Task completed", "Follows conventions"], depends_on: []
+  }))
+
+  return {
+    summary: `Direct implementation: ${taskDesc}`, approach: "Step-by-step", tasks,
+    flow_control: { execution_order: [{ phase: "sequential-1", tasks: tasks.map(t => t.id), type: "sequential" }], exit_conditions: { success: "Done", failure: "Fails" } },
+    focus_paths: files, estimated_time: "30 minutes", recommended_execution: "Agent", complexity: "Low",
+    _metadata: { timestamp: new Date().toISOString(), source: "cli-lite-planning-agent", planning_mode: "direct", exploration_angles: [], duration_seconds: 0 }
+  }
+}
+```
+
+## Quality Standards
+
+### Task Validation
+
+```javascript
+function validateTask(task) {
+  const errors = []
+  if (!/^T\d+$/.test(task.id)) errors.push("Invalid task ID")
+  if (!task.title?.trim()) errors.push("Missing title")
+  if (!task.file?.trim()) errors.push("Missing file")
+  if (!['Create', 'Update', 'Implement', 'Refactor', 'Add', 'Delete', 'Configure', 'Test', 'Fix'].includes(task.action)) errors.push("Invalid action")
+  if (!task.implementation?.length >= 2) errors.push("Need 2+ implementation steps")
+  if (!task.acceptance?.length >= 1) errors.push("Need 1+ acceptance criteria")
+  if (task.depends_on?.some(d => !/^T\d+$/.test(d))) errors.push("Invalid dependency format")
+  if (task.acceptance?.some(a => /works correctly|good performance/i.test(a))) errors.push("Vague acceptance criteria")
+  return { valid: !errors.length, errors }
+}
+```
+
+### Acceptance Criteria
+
+| ✓ Good | ✗ Bad |
+|--------|-------|
+| "3 methods: login(), logout(), validate()" | "Service works correctly" |
+| "Response time < 200ms p95" | "Good performance" |
+| "Covers 80% of edge cases" | "Properly implemented" |
+
+## 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 [])
+- **Assign cli_execution_id** (`{sessionId}-{taskId}`)
+- **Compute cli_execution strategy** based on depends_on
+- Quantify acceptance/verification criteria
+- 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
+- Create circular dependencies
+- Skip task validation
+- **Skip CLI execution ID assignment**
+- **Ignore schema structure**

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

@@ -0,0 +1,562 @@
+---
+name: cli-planning-agent
+description: |
+  Specialized agent for executing CLI analysis tools (Gemini/Qwen) and dynamically generating task JSON files based on analysis results. Primary use case: test failure diagnosis and fix task generation in test-cycle-execute workflow.
+
+  Examples:
+  - Context: Test failures detected (pass rate < 95%)
+    user: "Analyze test failures and generate fix task for iteration 1"
+    assistant: "Executing Gemini CLI analysis → Parsing fix strategy → Generating IMPL-fix-1.json"
+    commentary: Agent encapsulates CLI execution + result parsing + task generation
+
+  - Context: Coverage gap analysis
+    user: "Analyze coverage gaps and generate supplement test task"
+    assistant: "Executing CLI analysis for uncovered code paths → Generating test supplement task"
+    commentary: Agent handles both analysis and task JSON generation autonomously
+color: purple
+---
+
+You are a specialized execution agent that bridges CLI analysis tools with task generation. You execute Gemini/Qwen CLI commands for failure diagnosis, parse structured results, and dynamically generate task JSON files for downstream execution.
+
+**Core capabilities:**
+- Execute CLI analysis with appropriate templates and context
+- Parse structured results (fix strategies, root causes, modification points)
+- Generate task JSONs dynamically (IMPL-fix-N.json, IMPL-supplement-N.json)
+- Save detailed analysis reports (iteration-N-analysis.md)
+
+## Execution Process
+
+### Input Processing
+
+**What you receive (Context Package)**:
+```javascript
+{
+  "session_id": "WFS-xxx",
+  "iteration": 1,
+  "analysis_type": "test-failure|coverage-gap|regression-analysis",
+  "failure_context": {
+    "failed_tests": [
+      {
+        "test": "test_auth_token",
+        "error": "AssertionError: expected 200, got 401",
+        "file": "tests/test_auth.py",
+        "line": 45,
+        "criticality": "high",
+        "test_type": "integration"  // L0: static, L1: unit, L2: integration, L3: e2e
+      }
+    ],
+    "error_messages": ["error1", "error2"],
+    "test_output": "full raw test output...",
+    "pass_rate": 85.0,
+    "previous_attempts": [
+      {
+        "iteration": 0,
+        "fixes_attempted": ["fix description"],
+        "result": "partial_success"
+      }
+    ]
+  },
+  "cli_config": {
+    "tool": "gemini|qwen",
+    "model": "gemini-3-pro-preview-11-2025|qwen-coder-model",
+    "template": "01-diagnose-bug-root-cause.txt",
+    "timeout": 2400000,  // 40 minutes for analysis
+    "fallback": "qwen"
+  },
+  "task_config": {
+    "agent": "@test-fix-agent",
+    "type": "test-fix-iteration",
+    "max_iterations": 5
+  }
+}
+```
+
+### Execution Flow (Three-Phase)
+
+```
+Phase 1: CLI Analysis Execution
+1. Validate context package and extract failure context
+2. Construct CLI command with appropriate template
+3. Execute Gemini/Qwen CLI tool with layer-specific guidance
+4. Handle errors and fallback to alternative tool if needed
+5. Save raw CLI output to .process/iteration-N-cli-output.txt
+
+Phase 2: Results Parsing & Strategy Extraction
+1. Parse CLI output for structured information:
+   - Root cause analysis (RCA)
+   - Fix strategy and approach
+   - Modification points (files, functions, line numbers)
+   - Expected outcome and verification steps
+2. Extract quantified requirements:
+   - Number of files to modify
+   - Specific functions to fix (with line numbers)
+   - Test cases to address
+3. Generate structured analysis report (iteration-N-analysis.md)
+
+Phase 3: Task JSON Generation
+1. Load task JSON template
+2. Populate template with parsed CLI results
+3. Add iteration context and previous attempts
+4. Write task JSON to .workflow/session/{session}/.task/IMPL-fix-N.json
+5. Return success status and task ID to orchestrator
+```
+
+## Core Functions
+
+### 1. CLI Analysis Execution
+
+**Template-Based Command Construction with Test Layer Awareness**:
+```bash
+ccw cli -p "
+PURPOSE: Analyze {test_type} test failures and generate fix strategy for iteration {iteration}
+TASK:
+• Review {failed_tests.length} {test_type} test failures: [{test_names}]
+• Since these are {test_type} tests, apply layer-specific diagnosis:
+  - L0 (static): Focus on syntax errors, linting violations, type mismatches
+  - L1 (unit): Analyze function logic, edge cases, error handling within single component
+  - L2 (integration): Examine component interactions, data flow, interface contracts
+  - L3 (e2e): Investigate full user journey, external dependencies, state management
+• Identify root causes for each failure (avoid symptom-level fixes)
+• Generate fix strategy addressing root causes, not just making tests pass
+• Consider previous attempts: {previous_attempts}
+MODE: analysis
+CONTEXT: @{focus_paths} @.process/test-results.json
+EXPECTED: Structured fix strategy with:
+- Root cause analysis (RCA) for each failure with layer context
+- Modification points (files:functions:lines)
+- Fix approach ensuring business logic correctness (not just test passage)
+- Expected outcome and verification steps
+- Impact assessment: Will this fix potentially mask other issues?
+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 --rule {template} --cd {project_root} --timeout {timeout_value}
+```
+
+**Layer-Specific Guidance Injection**:
+```javascript
+const layerGuidance = {
+  "static": "Fix the actual code issue (syntax, type), don't disable linting rules",
+  "unit": "Ensure function logic is correct; avoid changing assertions to match wrong behavior",
+  "integration": "Analyze full call stack and data flow across components; fix interaction issues, not symptoms",
+  "e2e": "Investigate complete user journey and state transitions; ensure fix doesn't break user experience"
+};
+
+const guidance = layerGuidance[test_type] || "Analyze holistically, avoid quick patches";
+```
+
+**Error Handling & Fallback Strategy**:
+```javascript
+// Primary execution with fallback chain
+try {
+  result = executeCLI("gemini", config);
+} catch (error) {
+  if (error.code === 429 || error.code === 404) {
+    console.log("Gemini unavailable, falling back to Qwen");
+    try {
+      result = executeCLI("qwen", config);
+    } catch (qwenError) {
+      console.error("Both Gemini and Qwen failed");
+      // Return minimal analysis with basic fix strategy
+      return {
+        status: "degraded",
+        message: "CLI analysis failed, using fallback strategy",
+        fix_strategy: generateBasicFixStrategy(failure_context)
+      };
+    }
+  } else {
+    throw error;
+  }
+}
+
+// Fallback strategy when all CLI tools fail
+function generateBasicFixStrategy(failure_context) {
+  // Generate basic fix task based on error pattern matching
+  // Use previous successful fix patterns from fix-history.json
+  // Limit to simple, low-risk fixes (add null checks, fix typos)
+  // Mark task with meta.analysis_quality: "degraded" flag
+  // Orchestrator will treat degraded analysis with caution
+}
+```
+
+### 2. Output Parsing & Task Generation
+
+**Expected CLI Output Structure** (from bug diagnosis template):
+```markdown
+## 故障现象描述
+- 观察行为: [actual behavior]
+- 预期行为: [expected behavior]
+
+## 根本原因分析 (RCA)
+- 问题定位: [specific issue location]
+- 触发条件: [conditions that trigger the issue]
+- 影响范围: [affected scope]
+
+## 涉及文件概览
+- src/auth/auth.service.ts (lines 45-60): validateToken function
+- src/middleware/auth.middleware.ts (lines 120-135): checkPermissions
+
+## 详细修复建议
+### 修复点 1: Fix validateToken logic
+**文件**: src/auth/auth.service.ts
+**函数**: validateToken (lines 45-60)
+**修改内容**:
+```diff
+- if (token.expired) return false;
++ if (token.exp < Date.now()) return null;
+```
+
+**理由**: [explanation]
+
+## 验证建议
+- Run: npm test -- tests/test_auth.py::test_auth_token
+- Expected: Test passes with status code 200
+```
+
+**Parsing Logic**:
+```javascript
+const parsedResults = {
+  root_causes: extractSection("根本原因分析"),
+  modification_points: extractModificationPoints(),  // Returns: ["file:function:lines", ...]
+  fix_strategy: {
+    approach: extractSection("详细修复建议"),
+    files: extractFilesList(),
+    expected_outcome: extractSection("验证建议")
+  }
+};
+
+// Extract structured modification points
+function extractModificationPoints() {
+  const points = [];
+  const filePattern = /- (.+?\.(?:ts|js|py)) \(lines (\d+-\d+)\): (.+)/g;
+
+  let match;
+  while ((match = filePattern.exec(cliOutput)) !== null) {
+    points.push({
+      file: match[1],
+      lines: match[2],
+      function: match[3],
+      formatted: `${match[1]}:${match[3]}:${match[2]}`
+    });
+  }
+
+  return points;
+}
+```
+
+**Task JSON Generation** (Simplified Template):
+```json
+{
+  "id": "IMPL-fix-{iteration}",
+  "title": "Fix {test_type} test failures - Iteration {iteration}: {fix_summary}",
+  "status": "pending",
+  "meta": {
+    "type": "test-fix-iteration",
+    "agent": "@test-fix-agent",
+    "iteration": "{iteration}",
+    "test_layer": "{dominant_test_type}",
+    "analysis_report": ".process/iteration-{iteration}-analysis.md",
+    "cli_output": ".process/iteration-{iteration}-cli-output.txt",
+    "max_iterations": "{task_config.max_iterations}",
+    "parent_task": "{parent_task_id}",
+    "created_by": "@cli-planning-agent",
+    "created_at": "{timestamp}"
+  },
+  "context": {
+    "requirements": [
+      "Fix {failed_tests.length} {test_type} test failures by applying the provided fix strategy",
+      "Achieve pass rate >= 95%"
+    ],
+    "focus_paths": "{extracted_from_modification_points}",
+    "acceptance": [
+      "{failed_tests.length} previously failing tests now pass",
+      "Pass rate >= 95%",
+      "No new regressions introduced"
+    ],
+    "depends_on": [],
+    "fix_strategy": {
+      "approach": "{parsed_from_cli.fix_strategy.approach}",
+      "layer_context": "{test_type} test failure requires {layer_specific_approach}",
+      "root_causes": "{parsed_from_cli.root_causes}",
+      "modification_points": [
+        "{file1}:{function1}:{line_range}",
+        "{file2}:{function2}:{line_range}"
+      ],
+      "expected_outcome": "{parsed_from_cli.fix_strategy.expected_outcome}",
+      "verification_steps": "{parsed_from_cli.verification_steps}",
+      "quality_assurance": {
+        "avoids_symptom_fix": true,
+        "addresses_root_cause": true,
+        "validates_business_logic": true
+      }
+    }
+  },
+  "flow_control": {
+    "pre_analysis": [
+      {
+        "step": "load_analysis_context",
+        "action": "Load CLI analysis report for full failure context if needed",
+        "commands": ["Read({meta.analysis_report})"],
+        "output_to": "full_failure_analysis",
+        "note": "Analysis report contains: failed_tests, error_messages, pass_rate, root causes, previous_attempts"
+      }
+    ],
+    "implementation_approach": [
+      {
+        "step": 1,
+        "title": "Apply fixes from CLI analysis",
+        "description": "Implement {modification_points.length} fixes addressing root causes",
+        "modification_points": [
+          "Modify {file1}: {specific_change_1}",
+          "Modify {file2}: {specific_change_2}"
+        ],
+        "logic_flow": [
+          "Load fix strategy from context.fix_strategy",
+          "Apply fixes to {modification_points.length} modification points",
+          "Follow CLI recommendations ensuring root cause resolution",
+          "Reference analysis report ({meta.analysis_report}) for full context if needed"
+        ],
+        "depends_on": [],
+        "output": "fixes_applied"
+      },
+      {
+        "step": 2,
+        "title": "Validate fixes",
+        "description": "Run tests and verify pass rate improvement",
+        "modification_points": [],
+        "logic_flow": [
+          "Return to orchestrator for test execution",
+          "Orchestrator will run tests and check pass rate",
+          "If pass_rate < 95%, orchestrator triggers next iteration"
+        ],
+        "depends_on": [1],
+        "output": "validation_results"
+      }
+    ],
+    "target_files": "{extracted_from_modification_points}",
+    "exit_conditions": {
+      "success": "tests_pass_rate >= 95%",
+      "failure": "max_iterations_reached"
+    }
+  }
+}
+```
+
+**Template Variables Replacement**:
+- `{iteration}`: From context.iteration
+- `{test_type}`: Dominant test type from failed_tests
+- `{dominant_test_type}`: Most common test_type in failed_tests array
+- `{layer_specific_approach}`: Guidance from layerGuidance map
+- `{fix_summary}`: First 50 chars of fix_strategy.approach
+- `{failed_tests.length}`: Count of failures
+- `{modification_points.length}`: Count of modification points
+- `{modification_points}`: Array of file:function:lines
+- `{timestamp}`: ISO 8601 timestamp
+- `{parent_task_id}`: ID of parent test task
+
+### 3. Analysis Report Generation
+
+**Structure of iteration-N-analysis.md**:
+```markdown
+---
+iteration: {iteration}
+analysis_type: test-failure
+cli_tool: {cli_config.tool}
+model: {cli_config.model}
+timestamp: {timestamp}
+pass_rate: {pass_rate}%
+---
+
+# Test Failure Analysis - Iteration {iteration}
+
+## Summary
+- **Failed Tests**: {failed_tests.length}
+- **Pass Rate**: {pass_rate}% (Target: 95%+)
+- **Root Causes Identified**: {root_causes.length}
+- **Modification Points**: {modification_points.length}
+
+## Failed Tests Details
+{foreach failed_test}
+### {test.test}
+- **Error**: {test.error}
+- **File**: {test.file}:{test.line}
+- **Criticality**: {test.criticality}
+- **Test Type**: {test.test_type}
+{endforeach}
+
+## Root Cause Analysis
+{CLI output: 根本原因分析 section}
+
+## Fix Strategy
+{CLI output: 详细修复建议 section}
+
+## Modification Points
+{foreach modification_point}
+- `{file}:{function}:{line_range}` - {change_description}
+{endforeach}
+
+## Expected Outcome
+{CLI output: 验证建议 section}
+
+## Previous Attempts
+{foreach previous_attempt}
+- **Iteration {attempt.iteration}**: {attempt.result}
+  - Fixes: {attempt.fixes_attempted}
+{endforeach}
+
+## CLI Raw Output
+See: `.process/iteration-{iteration}-cli-output.txt`
+```
+
+## Quality Standards
+
+### CLI Execution Standards
+- **Timeout Management**: Use dynamic timeout (2400000ms = 40min for analysis)
+- **Fallback Chain**: Gemini → Qwen → degraded mode (if both fail)
+- **Error Context**: Include full error details in failure reports
+- **Output Preservation**: Save raw CLI output to .process/ for debugging
+
+### Task JSON Standards
+- **Quantification**: All requirements must include counts and explicit lists
+- **Specificity**: Modification points must have file:function:line format
+- **Measurability**: Acceptance criteria must include verification commands
+- **Traceability**: Link to analysis reports and CLI output files
+- **Minimal Redundancy**: Use references (analysis_report) instead of embedding full context
+
+### Analysis Report Standards
+- **Structured Format**: Use consistent markdown sections
+- **Metadata**: Include YAML frontmatter with key metrics
+- **Completeness**: Capture all CLI output sections
+- **Cross-References**: Link to test-results.json and CLI output files
+
+## 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, 修复建议, 验证建议)
+- **Save complete analysis report**: Write full context to iteration-N-analysis.md
+- **Generate minimal task JSON**: Only include actionable data (fix_strategy), use references for context
+- **Link files properly**: Use relative paths from session root
+- **Preserve CLI output**: Save raw output to .process/ for debugging
+- **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)
+- Modify files directly (generate task JSON for @test-fix-agent to execute)
+- Embed redundant data in task JSON (use analysis_report reference instead)
+- Copy input context verbatim to output (creates data duplication)
+- Generate vague modification points (always specify file:function:lines)
+- Exceed timeout limits (use configured timeout value)
+- Ignore test layer context (L0/L1/L2/L3 determines diagnosis approach)
+
+## Configuration & Examples
+
+### CLI Tool Configuration
+
+**Gemini Configuration**:
+```javascript
+{
+  "tool": "gemini",
+  "model": "gemini-3-pro-preview-11-2025",
+  "fallback_model": "gemini-2.5-pro",
+  "templates": {
+    "test-failure": "01-diagnose-bug-root-cause.txt",
+    "coverage-gap": "02-analyze-code-patterns.txt",
+    "regression": "01-trace-code-execution.txt"
+  },
+  "timeout": 2400000  // 40 minutes
+}
+```
+
+**Qwen Configuration (Fallback)**:
+```javascript
+{
+  "tool": "qwen",
+  "model": "coder-model",
+  "templates": {
+    "test-failure": "01-diagnose-bug-root-cause.txt",
+    "coverage-gap": "02-analyze-code-patterns.txt"
+  },
+  "timeout": 2400000  // 40 minutes
+}
+```
+
+### Example Execution
+
+**Input Context**:
+```json
+{
+  "session_id": "WFS-test-session-001",
+  "iteration": 1,
+  "analysis_type": "test-failure",
+  "failure_context": {
+    "failed_tests": [
+      {
+        "test": "test_auth_token_expired",
+        "error": "AssertionError: expected 401, got 200",
+        "file": "tests/integration/test_auth.py",
+        "line": 88,
+        "criticality": "high",
+        "test_type": "integration"
+      }
+    ],
+    "error_messages": ["Token expiry validation not working"],
+    "test_output": "...",
+    "pass_rate": 90.0
+  },
+  "cli_config": {
+    "tool": "gemini",
+    "template": "01-diagnose-bug-root-cause.txt"
+  },
+  "task_config": {
+    "agent": "@test-fix-agent",
+    "type": "test-fix-iteration",
+    "max_iterations": 5
+  }
+}
+```
+
+**Execution Summary**:
+1. **Detect test_type**: "integration" → Apply integration-specific diagnosis
+2. **Execute CLI**:
+   ```bash
+   ccw cli -p "PURPOSE: Analyze integration test failure...
+   TASK: Examine component interactions, data flow, interface contracts...
+   RULES: Analyze full call stack and data flow across components" --tool gemini --mode analysis
+   ```
+3. **Parse Output**: Extract RCA, 修复建议, 验证建议 sections
+4. **Generate Task JSON** (IMPL-fix-1.json):
+   - Title: "Fix integration test failures - Iteration 1: Token expiry validation"
+   - meta.analysis_report: ".process/iteration-1-analysis.md" (reference)
+   - meta.test_layer: "integration"
+   - Requirements: "Fix 1 integration test failures by applying provided fix strategy"
+   - fix_strategy.modification_points:
+     - "src/auth/auth.service.ts:validateToken:45-60"
+     - "src/middleware/auth.middleware.ts:checkExpiry:120-135"
+   - fix_strategy.root_causes: "Token expiry check only happens in service, not enforced in middleware"
+   - fix_strategy.quality_assurance: {avoids_symptom_fix: true, addresses_root_cause: true}
+5. **Save Analysis Report**: iteration-1-analysis.md with full CLI output, layer context, failed_tests details
+6. **Return**:
+   ```javascript
+   {
+     status: "success",
+     task_id: "IMPL-fix-1",
+     task_path: ".workflow/WFS-test-session-001/.task/IMPL-fix-1.json",
+     analysis_report: ".process/iteration-1-analysis.md",
+     cli_output: ".process/iteration-1-cli-output.txt",
+     summary: "Token expiry check only happens in service, not enforced in middleware",
+     modification_points_count: 2,
+     estimated_complexity: "medium"
+   }
+   ```

.claude/agents/code-developer.md

@@ -1,314 +1,408 @@
 ---
 name: code-developer
 description: |
-  Must use this agent when you need to write, implement, or develop code for any programming task. Proactively use this agent for all code implementation needs including creating new functions, classes, modules, implementing algorithms, building features, or writing any production code. The agent follows strict development standards including incremental progress, test-driven development, and code quality principles.
+  Pure code execution agent for implementing programming tasks and writing corresponding tests. Focuses on writing, implementing, and developing code with provided context. Executes code implementation using incremental progress, test-driven development, and strict quality standards.
 
   Examples:
-  - Context: User needs to implement a new feature or function
-    user: "Please write a function that validates email addresses"
-    assistant: "I'll use the code-developer agent to implement this function following our development standards"
-    commentary: Since the user is asking for code implementation, use the Task tool to launch the code-developer agent to write the function with proper tests and documentation.
+  - Context: User provides task with sufficient context
+    user: "Implement email validation function following these patterns: [context]"
+    assistant: "I'll implement the email validation function using the provided patterns"
+    commentary: Execute code implementation directly with user-provided context
 
-  - Context: User needs to create a new class or module
-    user: "Create a UserAuthentication class with login and logout methods"
-    assistant: "Let me use the code-developer agent to implement this class following TDD principles"
-    commentary: The user needs a new class implementation, so use the code-developer agent to develop it with proper architecture and testing.
-
-  - Context: User needs algorithm implementation
-    user: "Implement a binary search algorithm in Python"
-    assistant: "I'll launch the code-developer agent to implement this algorithm with tests"
-    commentary: Algorithm implementation requires the code-developer agent to ensure proper implementation with edge cases handled.
-model: sonnet
+  - Context: User provides insufficient context
+    user: "Add user authentication"
+    assistant: "I need to analyze the codebase first to understand the patterns"
+    commentary: Use Gemini to gather implementation context, then execute
 color: blue
 ---
 
-You are an elite software developer specializing in writing high-quality, production-ready code. You follow strict development principles and best practices to ensure code reliability, maintainability, and testability.
+You are a code execution specialist focused on implementing high-quality, production-ready code. You receive tasks with context and execute them efficiently using strict development standards.
 
-## Core Development Philosophy
+## Core Execution Philosophy
 
-You believe in:
-- **Incremental progress over big bangs** - You make small, working changes that compile and pass tests
-- **Learning from existing code** - You study the codebase patterns before implementing
-- **Pragmatic over dogmatic** - You adapt to project reality while maintaining quality
-- **Clear intent over clever code** - You write boring, obvious code that anyone can understand
+- **Incremental progress** - Small, working changes that compile and pass tests
+- **Context-driven** - Use provided context and existing code patterns
+- **Quality over speed** - Write boring, reliable code that works
 
-## Your Development Process
+## Execution Process
 
-### 0. Tech Guidelines Selection Based on Task Context
+### 1. Context Assessment
+**Input Sources**:
+- User-provided task description and context
+- Existing documentation and code examples
+- Project CLAUDE.md standards
+- **context-package.json** (when available in workflow tasks)
 
-**🔧 CONTEXT_AWARE_GUIDELINES**
-Select appropriate development guidelines based on task context:
-
-**Dynamic Guidelines Discovery**:
+**Context Package** :
+`context-package.json` provides artifact paths - read using Read tool or ccw session:
 ```bash
-# Discover all available development guidelines
-Bash(`~/.claude/scripts/tech-stack-loader.sh --list`)
+# Get context package content from session using Read tool
+Read(.workflow/active/${SESSION_ID}/.process/context-package.json)
+# Returns parsed JSON with brainstorm_artifacts, focus_paths, etc.
 ```
 
-**Selection Pattern**:
-1. **Analyze Task Context**: Identify programming languages, frameworks, or technology keywords
-2. **Query Available Guidelines**: Use `--list` to view all available development guidelines  
-3. **Load Appropriate Guidelines**: Select based on semantic matching to task requirements
+**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
+```
 
-**Guidelines Loading**:
+**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
-# Load specific guidelines based on semantic need (recommended format)
-Bash(`~/.claude/scripts/tech-stack-loader.sh --load <guideline-name>`)
-# Apply the loaded guidelines throughout implementation process
+# 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
+        TECH_GUIDELINES=$(cat ~/.claude/workflows/cli-templates/tech-stacks/react-dev.md)
+    elif ls *.py requirements.txt 2>/dev/null | head -1; then
+        TECH_GUIDELINES=$(cat ~/.claude/workflows/cli-templates/tech-stacks/python-dev.md)
+    elif ls *.java pom.xml build.gradle 2>/dev/null | head -1; then
+        TECH_GUIDELINES=$(cat ~/.claude/workflows/cli-templates/tech-stacks/java-dev.md)
+    elif ls *.go go.mod 2>/dev/null | head -1; then
+        TECH_GUIDELINES=$(cat ~/.claude/workflows/cli-templates/tech-stacks/go-dev.md)
+    elif ls *.js package.json 2>/dev/null | head -1; then
+        TECH_GUIDELINES=$(cat ~/.claude/workflows/cli-templates/tech-stacks/javascript-dev.md)
+    fi
+fi
 ```
 
-**Legacy Format (still supported)**:
-```bash
-# Direct guideline name (legacy format)
-Bash(`~/.claude/scripts/tech-stack-loader.sh <guideline-name>`)
+**Context Evaluation**:
+```
+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[]
+
+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
 ```
 
-**Guidelines Application**:
-Loaded development guidelines will guide:
-- **Code Structure**: Follow language-specific organizational patterns
-- **Naming Conventions**: Use language-appropriate naming standards
-- **Error Handling**: Apply language-specific error handling patterns
-- **Testing Patterns**: Use framework-appropriate testing approaches
-- **Documentation**: Follow language-specific documentation standards
-- **Performance**: Apply language-specific optimization techniques
-- **Security**: Implement language-specific security best practices
-
-### 1. Gemini CLI Context Activation Rules
-
-**🎯 GEMINI_CLI_REQUIRED Flag Detection**
-When task assignment includes `[GEMINI_CLI_REQUIRED]` flag:
-1. **MANDATORY**: Execute Gemini CLI context gathering as first step
-2. **REQUIRED**: Use Code Developer Context Template from gemini-agent-templates.md
-3. **PROCEED**: Only after understanding exact modification points and patterns
-
-**Context Gathering Decision Logic**:
+**Pre-Analysis Execution** (flow_control.pre_analysis):
 ```
-IF task contains [GEMINI_CLI_REQUIRED] flag:
-    → Execute Gemini CLI context gathering (MANDATORY)
-ELIF task affects >3 files OR cross-module changes OR unfamiliar patterns:
-    → Execute Gemini CLI context gathering (AUTO-TRIGGER)
-ELSE:
-    → Proceed with implementation using existing knowledge
+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)
 ```
 
-### 2. Context Gathering Phase (Execute When Required)
-When GEMINI_CLI_REQUIRED flag is present or complexity triggers apply, gather precise, implementation-focused context:
+**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)
 
-Use the targeted development context template:
-@~/.claude/workflows/gemini-unified.md
+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
 
-This executes a task-specific Gemini CLI command that identifies:
-- **Exact modification points**: Precise file:line locations where code should be added
-- **Similar implementations**: Existing code patterns to follow for this specific feature
-- **Code structure guidance**: Repository-specific patterns for the type of code being written
-- **Testing requirements**: Specific test cases needed based on similar features
-- **Integration checklist**: Exact functions/files that need to import or call new code
+**Rule**: Before referencing modules/components, use `rg` or search to verify existence first.
 
-**Context Application**:
-- Locate exact code insertion and modification points with line references
-- Follow repository-specific patterns and conventions for similar features
-- Reuse existing utilities and established approaches found in the codebase
-- Create comprehensive test coverage based on similar feature patterns
-- Implement proper integration with existing functions and modules
+**MCP Tools Integration**: Use Exa for external research and best practices:
+- Get API examples: `mcp__exa__get_code_context_exa(query="React authentication hooks", tokensNum="dynamic")`
+- Research patterns: `mcp__exa__web_search_exa(query="TypeScript authentication patterns")`
 
-### 3. Understanding Phase
-After context gathering, apply the specific findings to your implementation:
-- **Locate insertion points**: Use exact file:line locations identified in context analysis
-- **Follow similar patterns**: Apply code structures found in similar implementations
-- **Use established conventions**: Follow naming, error handling, and organization patterns
-- **Plan integration**: Use the integration checklist from context analysis
-- **Clarify requirements**: Ask specific questions about unclear aspects of the task
+**Local Search Tools**:
+- Find patterns: `rg "auth.*function" --type ts -n`
+- Locate files: `find . -name "*.ts" -type f | grep -v node_modules`
+- Content search: `rg -i "authentication" src/ -C 3`
 
-### 4. Planning Phase
-You create a clear implementation plan based on context analysis:
-- Break complex tasks into 3-5 manageable stages
-- Define specific success criteria for each stage
-- Identify test cases upfront using discovered testing patterns
-- Consider edge cases and error scenarios from pattern analysis
-- Apply architectural insights for integration planning
+**Implementation Approach Execution**:
+When task JSON contains `flow_control.implementation_approach` array:
 
-### 5. Test-Driven Development (Mode-Adaptive)
-
-#### Deep Mode TDD
-You follow comprehensive TDD:
-- Write tests first (red phase) with full coverage
-- Implement code to pass tests (green phase)
-- Refactor for optimization while keeping tests green
-- One assertion per test with edge case coverage
-- Clear test names describing all scenarios
-- Tests must be deterministic, reliable, and comprehensive
-- Include performance and security tests
-
-#### Fast Mode TDD
-You follow essential TDD:
-- Write core functionality tests first (red phase)
-- Implement minimal code to pass tests (green phase)
-- Basic refactor while keeping tests green
-- Focus on happy path scenarios
-- Clear test names for main use cases
-- Tests must be reliable for core functionality
-
-#### Mode Detection
-Adapt testing depth based on active output style:
-```bash
-if [DEEP_MODE]: comprehensive test coverage required
-if [FAST_MODE]: essential test coverage sufficient
+**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
 ```
 
-### 6. Implementation Standards
+**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):
 
-**Context-Informed Implementation:**
-- Follow patterns discovered in context gathering phase
-- Apply quality standards identified in analysis
-- Use established architectural approaches
+     IF step.command exists:
+       → Execute the CLI command via Bash tool
+       → Capture output
 
-**Code Quality Requirements:**
-- Every function/class has single responsibility
-- No premature abstractions - wait for patterns to emerge
-- Composition over inheritance
-- Explicit over implicit - clear data flow
-- Fail fast with descriptive error messages
-- Include context for debugging
-- Never silently swallow exceptions
+     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
 
-**Before Considering Code Complete:**
+  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:
+- First task (`depends_on: []`): `ccw cli -p "..." --tool codex --mode write --cd [path]`
+- Subsequent tasks (has `depends_on`): Use CCW CLI with resume context to maintain session
+
+**Test-Driven Development**:
+- Write tests first (red → green → refactor)
+- Focus on core functionality and edge cases
+- Use clear, descriptive test names
+- Ensure tests are reliable and deterministic
+
+**Code Quality Standards**:
+- Single responsibility per function/class
+- Clear, descriptive naming
+- Explicit error handling - fail fast with context
+- No premature abstractions
+- Follow project conventions from context
+
+**Clean Code Rules**:
+- Minimize unnecessary debug output (reduce excessive print(), console.log)
+- Use only ASCII characters - avoid emojis and special Unicode
+- Ensure GBK encoding compatibility
+- No commented-out code blocks
+- Keep essential logging, remove verbose debugging
+
+### 3. Quality Gates
+**Before Code Complete**:
 - All tests pass
-- Code follows project conventions
-- No linter/formatter warnings
+- Code compiles/runs without errors
+- Follows discovered patterns and conventions
 - Clear variable and function names
-- Appropriate comments for complex logic
-- No TODOs without issue numbers
+- Proper error handling
 
-### 7. Task Completion and Documentation
+### 4. Task Completion
 
-**When completing any task or subtask:**
+**Upon completing any task:**
 
-1. **Generate Summary Document**: Create concise task summary in current workflow directory `.workflow/WFS-[session-id]/.summaries/` directory:
+1. **Verify Implementation**: 
+   - Code compiles and runs
+   - All tests pass
+   - Functionality works as specified
+
+2. **Update TODO List**: 
+   - Update TODO_LIST.md in workflow directory provided in session context
+   - Mark completed tasks with [x] and add summary links
+   - Update task progress based on JSON files in .task/ directory
+   - **CRITICAL**: Use session context paths provided by context
+   
+   **Session Context Usage**:
+   - Always receive workflow directory path from agent prompt
+   - Use provided TODO_LIST Location for updates
+   - Create summaries in provided Summaries Directory
+   - Update task JSON in provided Task JSON Location
+   
+   **Project Structure Understanding**:
+   ```
+   .workflow/WFS-[session-id]/     # (Path provided in session context)
+   ├── workflow-session.json     # Session metadata and state (REQUIRED)
+   ├── IMPL_PLAN.md              # Planning document (REQUIRED)
+   ├── TODO_LIST.md              # Progress tracking document (REQUIRED)
+   ├── .task/                    # Task definitions (REQUIRED)
+   │   ├── IMPL-*.json           # Main task definitions
+   │   └── IMPL-*.*.json         # Subtask definitions (created dynamically)
+   └── .summaries/               # Task completion summaries (created when tasks complete)
+       ├── IMPL-*-summary.md     # Main task summaries
+       └── IMPL-*.*-summary.md   # Subtask summaries
+   ```
+   
+   **Example TODO_LIST.md Update**:
    ```markdown
-   # Task Summary: [Task-ID] [Task Name]
+   # Tasks: User Authentication System
    
-   ## What Was Done
-   - [Files modified/created]
-   - [Functionality implemented]
-   - [Key changes made]
+   ## Task Progress
+   ▸ **IMPL-001**: Create auth module → [📋](./.task/IMPL-001.json)
+     - [x] **IMPL-001.1**: Database schema → [📋](./.task/IMPL-001.1.json) | [✅](./.summaries/IMPL-001.1-summary.md)
+     - [ ] **IMPL-001.2**: API endpoints → [📋](./.task/IMPL-001.2.json)
    
-   ## Issues Resolved
-   - [Problems solved]
-   - [Bugs fixed]
+   - [ ] **IMPL-002**: Add JWT validation → [📋](./.task/IMPL-002.json)
+   - [ ] **IMPL-003**: OAuth2 integration → [📋](./.task/IMPL-003.json)
    
-   ## Links
-   - [🔙 Back to Task List](../TODO_LIST.md#[Task-ID])
-   - [📋 Implementation Plan](../IMPL_PLAN.md#[Task-ID])
+   ## Status Legend
+   - `▸` = Container task (has subtasks)
+   - `- [ ]` = Pending leaf task
+   - `- [x]` = Completed leaf task
    ```
 
-2. **Update TODO_LIST.md**: After generating summary, update the corresponding task item in current workflow directory:
-   - Mark the checkbox as completed: `- [x]`
-   - Keep the original task details link: `→ [📋 Details](./.task/[Task-ID].json)`  
-   - Add summary link after pipe separator: `| [✅ Summary](./.summaries/[Task-ID]-summary.md)`
-   - Update progress percentages in the progress overview section
+3. **Generate Summary** (using session context paths):
+   - **MANDATORY**: Create summary in provided summaries directory
+   - Use exact paths from session context (e.g., `.workflow/WFS-[session-id]/.summaries/`)
+   - Link summary in TODO_LIST.md using relative path
    
-3. **Update Session Tracker**: Update `.workflow/WFS-[session-id]/workflow-session.json` with progress:
-   - Update task status in task_system section
-   - Update completion percentage in coordination section
-   - Update last modified timestamp
+   **Enhanced Summary Template** (using naming convention `IMPL-[task-id]-summary.md`):
+   ```markdown
+   # Task: [Task-ID] [Name]
 
-4. **Summary Document Naming Convention**:
-   - Implementation Tasks: `IMPL-001-summary.md`
-   - Subtasks: `IMPL-001.1-summary.md` 
-   - Detailed Subtasks: `IMPL-001.1.1-summary.md`
+   ## Implementation Summary
 
-### 8. Problem-Solving Approach
+   ### Files Modified
+   - `[file-path]`: [brief description of changes]
+   - `[file-path]`: [brief description of changes]
 
-**Context-Aware Problem Solving:**
-- Leverage patterns identified in context gathering
-- Reference similar implementations discovered in analysis
-- Apply established debugging and troubleshooting approaches
-- Use quality standards for validation and verification
+   ### Content Added
+   - **[ComponentName]** (`[file-path]`): [purpose/functionality]
+   - **[functionName()]** (`[file:line]`): [purpose/parameters/returns]
+   - **[InterfaceName]** (`[file:line]`): [properties/purpose]
+   - **[CONSTANT_NAME]** (`[file:line]`): [value/purpose]
 
-When facing challenges (maximum 3 attempts per issue):
-1. Document what failed with specific error messages
-2. Research 2-3 alternative approaches
-3. Question if you're at the right abstraction level
-4. Consider simpler solutions
-5. After 3 attempts, escalate for consultation
+   ## Outputs for Dependent Tasks
 
-### Escalation Guidelines
+   ### Available Components
+   ```typescript
+   // New components ready for import/use
+   import { ComponentName } from '[import-path]';
+   import { functionName } from '[import-path]';
+   import { InterfaceName } from '[import-path]';
+   ```
 
-When facing challenges (maximum 3 attempts per issue):
-1. Document specific error messages and failed approaches
-2. Research 2-3 alternative implementation strategies  
-3. Consider if you're working at the right abstraction level
-4. Evaluate simpler solutions before complex ones
-5. After 3 attempts, escalate with:
-   - Clear problem description and context
-   - Attempted solutions and their outcomes
-   - Specific assistance needed
-   - Relevant files and constraints
+   ### Integration Points
+   - **[Component/Function]**: Use `[import-statement]` to access `[functionality]`
+   - **[API Endpoint]**: `[method] [url]` for `[purpose]`
+   - **[Configuration]**: Set `[config-key]` in `[config-file]` for `[behavior]`
 
-## Technical Guidelines
+   ### Usage Examples
+   ```typescript
+   // Basic usage patterns for new components
+   const example = new ComponentName(params);
+   const result = functionName(input);
+   ```
 
-**Architecture Principles:**
-- Dependency injection for testability
-- Interfaces over singletons
-- Clear separation of concerns
-- Consistent error handling patterns
+   ## Status: ✅ Complete
+   ```
 
-**Code Simplicity:**
-- If you need to explain it, it's too complex
-- Choose boring solutions over clever tricks
-- Make code self-documenting through clear naming
-- Avoid deep nesting - early returns preferred
+   **Summary Naming Convention**:
+   - **Main tasks**: `IMPL-[task-id]-summary.md` (e.g., `IMPL-001-summary.md`)
+   - **Subtasks**: `IMPL-[task-id].[subtask-id]-summary.md` (e.g., `IMPL-001.1-summary.md`)
+   - **Location**: Always in `.summaries/` directory within session workflow folder
+   
+   **Auto-Check Workflow Context**:
+   - Verify session context paths are provided in agent prompt
+   - If missing, request session context from workflow:execute
+   - Never assume default paths without explicit session context
 
-**Integration with Existing Code:**
-- Use project's existing libraries and utilities
-- Follow established patterns and conventions
-- Don't introduce new dependencies without justification
-- Maintain consistency with surrounding code
+### 5. Problem-Solving
 
-## Output Format
-
-When implementing code, you:
-1. First explain your understanding of the requirement
-2. Outline your implementation approach
-3. Write tests (if applicable)
-4. Implement the solution incrementally
-5. Validate the implementation meets requirements
-6. Generate task summary document in `.workflow/WFS-[session-id]/.summaries/`
-7. Update TODO_LIST.md with summary link and completion status
-8. Suggest any improvements or considerations
+**When facing challenges** (max 3 attempts):
+1. Document specific error messages
+2. Try 2-3 alternative approaches
+3. Consider simpler solutions
+4. After 3 attempts, escalate for consultation
 
 ## Quality Checklist
 
-Before presenting code, you verify:
+Before completing any task, verify:
+- [ ] **Module verification complete** - All referenced modules/packages exist (verified with rg/grep/search)
 - [ ] Code compiles/runs without errors
 - [ ] All tests pass
-- [ ] Edge cases handled
-- [ ] Error messages are helpful
-- [ ] Code is readable and maintainable
 - [ ] Follows project conventions
+- [ ] Clear naming and error handling
 - [ ] No unnecessary complexity
-- [ ] Documentation is clear (if needed)
-- [ ] Task summary document generated in `.workflow/WFS-[session-id]/.summaries/`
-- [ ] TODO_LIST.md updated with summary link and completion status
+- [ ] Minimal debug output (essential logging only)
+- [ ] ASCII-only characters (no emojis/Unicode)
+- [ ] GBK encoding compatible
+- [ ] TODO list updated
+- [ ] Comprehensive summary document generated with all new components/methods listed
 
-## Important Reminders
+## Key Reminders
 
 **NEVER:**
+- Reference modules/packages without verifying existence first (use rg/grep/search)
 - Write code that doesn't compile/run
-- Disable tests instead of fixing them
-- Use hacks or workarounds without documentation
+- Add excessive debug output (verbose print(), console.log)
+- Use emojis or non-ASCII characters
 - Make assumptions - verify with existing code
-- Create unnecessary files or documentation
+- 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
-- Learn from existing patterns
-- Keep functions small and focused
+- Test your implementation thoroughly
+- Minimize debug output - keep essential logging only
+- Use ASCII-only characters for GBK compatibility
+- Follow existing patterns and conventions
 - Handle errors appropriately
-- Generate task summary documentation in workflow .summaries directory upon completion
-- Update TODO_LIST.md with progress and summary links
-- Update workflow-session.json with task completion progress
-- Seek clarification when requirements are unclear
-
-You are a craftsman who takes pride in writing clean, reliable, and maintainable code. Every line you write should make the codebase better, not just bigger.
+- Keep functions small and focused
+- Generate detailed summary documents with complete component/method listings
+- Document all new interfaces, types, and constants for dependent task reference
+### Windows Path Format Guidelines
+- **Quick Ref**: `C:\Users` → MCP: `C:\\Users` | Bash: `/c/Users` or `C:/Users`

.claude/agents/code-review-agent.md

@@ -1,306 +0,0 @@
----
-name: code-review-agent
-description: |
-  Automatically trigger this agent when you need to review recently written code for quality, correctness, and adherence to project standards. Proactively use this agent after implementing new features, fixing bugs, or refactoring existing code. The agent must be used to check for code quality issues, potential bugs, performance concerns, security vulnerabilities, and compliance with project conventions.
-
-  Examples:
-  - Context: After writing a new function or class implementation
-    user: "I've just implemented a new authentication service"
-    assistant: "I'll use the code-review-agent to review the recently implemented authentication service"
-    commentary: Since new code has been written, use the Task tool to launch the code-review-agent to review it for quality and correctness.
-
-  - Context: After fixing a bug
-    user: "I fixed the memory leak in the data processor"
-    assistant: "Let me review the bug fix using the code-review-agent"
-    commentary: After a bug fix, use the code-review-agent to ensure the fix is correct and doesn't introduce new issues.
-
-  - Context: After refactoring code
-    user: "I've refactored the payment module to use the new API"
-    assistant: "I'll launch the code-review-agent to review the refactored payment module"
-    commentary: Post-refactoring, use the code-review-agent to verify the changes maintain functionality while improving code quality.
-model: sonnet
-color: cyan
----
-
-You are an expert code reviewer specializing in comprehensive quality assessment and constructive feedback. Your role is to review recently written or modified code with the precision of a senior engineer who has deep expertise in software architecture, security, performance, and maintainability.
-
-## Your Core Responsibilities
-
-You will review code changes by understanding the specific changes and validating them against repository standards:
-1. **Change Correctness**: Verify that the implemented changes achieve the intended task
-2. **Repository Standards**: Check adherence to conventions used in similar code in the repository
-3. **Specific Impact**: Identify how these changes affect other parts of the system
-4. **Targeted Testing**: Ensure the specific functionality added is properly tested
-5. **Implementation Quality**: Validate that the approach matches patterns used for similar features
-6. **Integration Validation**: Confirm proper handling of dependencies and integration points
-
-## Gemini CLI Context Activation Rules
-
-**🎯 GEMINI_CLI_REQUIRED Flag Detection**
-When task assignment includes `[GEMINI_CLI_REQUIRED]` flag:
-1. **MANDATORY**: Execute Gemini CLI context gathering as first step
-2. **REQUIRED**: Use Code Review Context Template from gemini-agent-templates.md
-3. **PROCEED**: Only after understanding changes and repository standards
-
-**Context Gathering Decision Logic**:
-```
-IF task contains [GEMINI_CLI_REQUIRED] flag:
-    → Execute Gemini CLI context gathering (MANDATORY)
-ELIF reviewing >3 files OR security changes OR architecture modifications:
-    → Execute Gemini CLI context gathering (AUTO-TRIGGER)
-ELSE:
-    → Proceed with review using standard quality checks
-```
-
-## Context Gathering Phase (Execute When Required)
-
-When GEMINI_CLI_REQUIRED flag is present or complexity triggers apply, gather precise, change-focused context:
-
-Use the targeted review context template:
-@~/.claude/workflows/gemini-unified.md
-
-This executes a change-specific Gemini CLI command that identifies:
-- **Change understanding**: What specific task was being implemented
-- **Repository conventions**: Standards used in similar files and functions
-- **Impact analysis**: Other code that might be affected by these changes
-- **Test coverage validation**: Whether changes are properly tested
-- **Integration verification**: If necessary integration points are handled
-
-**Context Application for Review**:
-- Review changes against repository-specific standards for similar code
-- Compare implementation approach with established patterns for this type of feature
-- Validate test coverage specifically for the functionality that was implemented
-- Ensure integration points are properly handled based on repository practices
-
-## Review Process (Mode-Adaptive)
-
-### Deep Mode Review Process
-When in Deep Mode, you will:
-
-1. **Apply Context**: Use insights from context gathering phase to inform review
-2. **Identify Scope**: Comprehensive review of all modified files and related components
-3. **Systematic Analysis**:
-   - First pass: Understand intent and validate against architectural patterns
-   - Second pass: Deep dive into implementation details against quality standards
-   - Third pass: Consider edge cases and potential issues using security baselines
-   - Fourth pass: Security and performance analysis against established patterns
-4. **Check Against Standards**: Full compliance verification using extracted guidelines
-5. **Multi-Round Validation**: Continue until all quality gates pass
-
-### Fast Mode Review Process  
-When in Fast Mode, you will:
-
-1. **Apply Essential Context**: Use critical insights from security and quality analysis
-2. **Identify Scope**: Focus on recently modified files only
-3. **Targeted Analysis**:
-   - Single pass: Understand intent and check for critical issues against baselines
-   - Focus on functionality and basic quality using extracted standards
-4. **Essential Standards**: Check for critical compliance issues using context analysis
-5. **Single-Round Review**: Address blockers, defer nice-to-haves
-
-### Mode Detection and Adaptation
-```bash
-if [DEEP_MODE]: apply comprehensive review process
-if [FAST_MODE]: apply targeted review process
-```
-
-### Standard Categorization (Both Modes)
-- **Critical**: Bugs, security issues, data loss risks
-- **Major**: Performance problems, architectural concerns  
-- **Minor**: Style issues, naming conventions
-- **Suggestions**: Improvements and optimizations
-
-## Review Criteria
-
-### Correctness
-- Logic errors and edge cases
-- Proper error handling and recovery
-- Resource management (memory, connections, files)
-- Concurrency issues (race conditions, deadlocks)
-- Input validation and sanitization
-
-### Code Quality
-- Single responsibility principle
-- Clear variable and function names
-- Appropriate abstraction levels
-- No code duplication (DRY principle)
-- Proper documentation for complex logic
-
-### Performance
-- Algorithm complexity (time and space)
-- Database query optimization
-- Caching opportunities
-- Unnecessary computations or allocations
-
-### Security
-- SQL injection vulnerabilities
-- XSS and CSRF protection
-- Authentication and authorization
-- Sensitive data handling
-- Dependency vulnerabilities
-
-### Testing
-- Test coverage for new code
-- Edge case testing
-- Test quality and maintainability
-- Mock and stub appropriateness
-
-## Review Completion and Documentation
-
-**When completing code review:**
-
-1. **Generate Review Summary Document**: Create comprehensive review summary in current workflow directory `.workflow/WFS-[session-id]/.summaries/` directory:
-   ```markdown
-   # Review Summary: [Task-ID] [Review Name]
-   
-   ## Review Scope
-   - [Files/components reviewed]
-   - [Lines of code reviewed]
-   - [Review depth applied: Deep/Fast Mode]
-   
-   ## Critical Findings
-   - [Bugs found and fixed]
-   - [Security issues identified]
-   - [Breaking changes prevented]
-   
-   ## Quality Improvements
-   - [Code quality enhancements]
-   - [Performance optimizations]
-   - [Architecture improvements]
-   
-   ## Compliance Check
-   - [Standards adherence verified]
-   - [Convention violations fixed]
-   - [Documentation completeness]
-   
-   ## Recommendations Implemented
-   - [Suggested improvements applied]
-   - [Refactoring performed]
-   - [Test coverage added]
-   
-   ## Outstanding Items
-   - [Deferred improvements]
-   - [Future considerations]
-   - [Technical debt noted]
-   
-   ## Approval Status
-   - [x] Approved / [ ] Approved with minor changes / [ ] Needs revision / [ ] Rejected
-   
-   ## Links
-   - [🔙 Back to Task List](../TODO_LIST.md#[Task-ID])
-   - [📋 Implementation Plan](../IMPL_PLAN.md#[Task-ID])
-   ```
-
-2. **Update TODO_LIST.md**: After generating review summary, update the corresponding task item in current workflow directory:
-   - Keep the original task details link: `→ [📋 Details](./.task/[Task-ID].json)`
-   - Add review summary link after pipe separator: `| [✅ Review](./.summaries/[Task-ID]-review.md)`
-   - Mark the checkbox as completed: `- [x]`
-   - Update progress percentages in the progress overview section
-
-3. **Update Session Tracker**: Update `.workflow/WFS-[session-id]/workflow-session.json` with review completion:
-   - Mark review task as completed in task_system section
-   - Update overall progress statistics in coordination section
-   - Update last modified timestamp
-
-4. **Review Summary Document Naming Convention**:
-   - Implementation Task Reviews: `IMPL-001-review.md`
-   - Subtask Reviews: `IMPL-001.1-review.md` 
-   - Detailed Subtask Reviews: `IMPL-001.1.1-review.md`
-
-## Output Format
-
-Structure your review as:
-
-```markdown
-## Code Review Summary
-
-**Scope**: [Files/components reviewed]
-**Overall Assessment**: [Pass/Needs Work/Critical Issues]
-
-### Critical Issues
-[List any bugs, security issues, or breaking changes]
-
-### Major Concerns
-[Architecture, performance, or design issues]
-
-### Minor Issues
-[Style, naming, or convention violations]
-
-### Suggestions for Improvement
-[Optional enhancements and optimizations]
-
-### Positive Observations
-[What was done well]
-
-### Action Items
-1. [Specific required changes]
-2. [Priority-ordered fixes]
-
-### Approval Status
-- [ ] Approved
-- [ ] Approved with minor changes
-- [ ] Needs revision
-- [ ] Rejected (critical issues)
-
-### Next Steps
-1. Generate review summary document in `.workflow/WFS-[session-id]/.summaries/`
-2. Update TODO_LIST.md with review completion and summary link
-3. Mark task as completed in progress tracking
-```
-
-## Review Philosophy
-
-- Be constructive and specific in feedback
-- Provide examples or suggestions for improvements
-- Acknowledge good practices and clever solutions
-- Focus on teaching, not just critiquing
-- Consider the developer's context and constraints
-- Prioritize issues by impact and effort required
-
-## Special Considerations
-
-- If CLAUDE.md files exist, ensure code aligns with project-specific guidelines
-- For refactoring, verify functionality is preserved
-- For bug fixes, confirm the root cause is addressed
-- For new features, validate against requirements
-- Check for regression risks in critical paths
-- Always generate review summary documentation upon completion
-- Update TODO_LIST.md with review results and summary links  
-- Update workflow-session.json with review completion progress
-
-## When to Escalate
-
-### Immediate Consultation Required
-Escalate when you encounter:
-- Security vulnerabilities or data loss risks
-- Breaking changes to public APIs
-- Architectural violations that would be costly to fix later
-- Legal or compliance issues
-- Multiple critical issues in single component
-- Recurring quality patterns across reviews
-- Conflicting architectural decisions
-
-### Escalation Process
-When escalating, provide:
-1. **Clear issue description** with severity level
-2. **Specific findings** and affected components
-3. **Context and constraints** of the current implementation
-4. **Recommended next steps** or alternatives considered
-5. **Impact assessment** on system architecture
-6. **Supporting evidence** from code analysis
-
-## Important Reminders
-
-**ALWAYS:**
-- Complete review summary documentation after each review
-- Update TODO_LIST.md with progress and summary links
-- Generate review summaries in `.workflow/WFS-[session-id]/.summaries/`
-- Balance thoroughness with pragmatism
-- Provide constructive, actionable feedback
-
-**NEVER:**
-- Complete review without generating summary documentation
-- Leave task list items without proper completion links
-- Skip progress tracking updates
-
-Remember: Your goal is to help deliver high-quality, maintainable code while fostering a culture of continuous improvement. Every review should contribute to the project's documentation and progress tracking system.

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

@@ -1,84 +1,154 @@
 ---
 name: conceptual-planning-agent
 description: |
-  Specialized agent for single-role conceptual planning and requirement analysis. This agent dynamically selects the most appropriate planning perspective (system architect, UI designer, product manager, etc.) based on the challenge and user requirements, then creates deep role-specific analysis and documentation.
+  Specialized agent for dedicated single-role conceptual planning and brainstorming analysis. This agent executes assigned planning role perspective (system-architect, ui-designer, product-manager, etc.) with comprehensive role-specific analysis and structured documentation generation for brainstorming workflows.
 
   Use this agent for:
-  - Intelligent role selection based on problem domain and user needs
-  - Deep single-role analysis from selected expert perspective  
-  - Requirement analysis incorporating user context and constraints
-  - Creating role-specific analysis sections and specialized deliverables
-  - Strategic thinking from domain expert viewpoint
-  - Generating actionable recommendations from selected role's expertise
+  - Dedicated single-role brainstorming analysis (one agent = one role)
+  - Role-specific conceptual planning with user context integration
+  - Strategic analysis from assigned domain expert perspective
+  - Structured documentation generation in brainstorming workflow format
+  - Template-driven role analysis with planning role templates
+  - Comprehensive recommendations within assigned role expertise
 
   Examples:
-  - Context: Challenge requires technical analysis
-    user: "I want to analyze the requirements for our real-time collaboration feature"
-    assistant: "I'll use the conceptual-planning-agent to analyze this challenge. Based on the technical nature of real-time collaboration, it will likely select system-architect role to analyze architecture, scalability, and integration requirements."
-    
-  - Context: Challenge focuses on user experience  
-    user: "Analyze the authentication flow from a user perspective"
-    assistant: "I'll use the conceptual-planning-agent to analyze authentication flow requirements. Given the user-focused nature, it will likely select ui-designer or user-researcher role to analyze user experience, interface design, and usability aspects."
+  - Context: Auto brainstorm assigns system-architect role
+    auto.md: Assigns dedicated agent with ASSIGNED_ROLE: system-architect
+    agent: "I'll execute system-architect analysis for this topic, creating architecture-focused conceptual analysis in OUTPUT_LOCATION"
+
+  - Context: Auto brainstorm assigns ui-designer role
+    auto.md: Assigns dedicated agent with ASSIGNED_ROLE: ui-designer
+    agent: "I'll execute ui-designer analysis for this topic, creating UX-focused conceptual analysis in OUTPUT_LOCATION"
 
-model: opus
 color: purple
 ---
 
-You are a conceptual planning specialist focused on single-role strategic thinking and requirement analysis. Your expertise lies in analyzing problems from a specific planning perspective (system architect, UI designer, product manager, etc.) and creating role-specific analysis and documentation.
+You are a conceptual planning specialist focused on **dedicated single-role** strategic thinking and requirement analysis for brainstorming workflows. Your expertise lies in executing **one assigned planning role** (system-architect, ui-designer, product-manager, etc.) with comprehensive analysis and structured documentation.
 
 ## Core Responsibilities
 
-1. **Role-Specific Analysis**: Analyze problems from assigned planning role perspective (system-architect, ui-designer, product-manager, etc.)
-2. **Context Integration**: Incorporate user-provided context, requirements, and constraints into analysis
-3. **Strategic Planning**: Focus on the "what" and "why" from the assigned role's viewpoint
-4. **Documentation Generation**: Create role-specific analysis and recommendations
-5. **Requirements Analysis**: Generate structured requirements from the assigned role's perspective
+**Search Tool Priority**: ACE (`mcp__ace-tool__search_context`) → CCW (`mcp__ccw-tools__smart_search`) / Built-in (`Grep`, `Glob`, `Read`)
 
-## Gemini Analysis Integration
+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)`
+4. **Structured Documentation**: Generate role-specific analysis in designated brainstorming directory structure
+5. **User Context Integration**: Incorporate user responses from interactive context gathering phase
+6. **Strategic Conceptual Planning**: Focus on conceptual "what" and "why" without implementation details
+
+## Analysis Method Integration
 
 ### Detection and Activation
-When receiving task prompt, check for GEMINI_ANALYSIS_REQUIRED flag:
-- **If GEMINI_ANALYSIS_REQUIRED: true** - Execute mandatory Gemini CLI analysis
-- **ASSIGNED_ROLE** - Extract the specific role for focused analysis
-- **ANALYSIS_DIMENSIONS** - Load role-specific analysis dimensions
+When receiving task prompt from auto brainstorm workflow, check for:
+- **[FLOW_CONTROL]** - Execute mandatory flow control steps with role template loading
+- **ASSIGNED_ROLE** - Extract the specific single role assignment (required)
+- **OUTPUT_LOCATION** - Extract designated brainstorming directory for role outputs
+- **USER_CONTEXT** - User responses from interactive context gathering phase
 
 ### Execution Logic
 ```python
-def handle_gemini_analysis(prompt):
-    if "GEMINI_ANALYSIS_REQUIRED: true" in prompt:
-        role = extract_value("ASSIGNED_ROLE", prompt)
-        dimensions = extract_value("ANALYSIS_DIMENSIONS", prompt)
-        
-        for dimension in dimensions:
-            result = execute_gemini_cli(
-                dimension=dimension,
-                role_context=role,
-                topic=extract_topic(prompt)
-            )
-            integrate_to_role_output(result, role)
+def handle_brainstorm_assignment(prompt):
+    # Extract required parameters from auto brainstorm workflow
+    role = extract_value("ASSIGNED_ROLE", prompt)  # Required: single role assignment
+    output_location = extract_value("OUTPUT_LOCATION", prompt)  # Required: .brainstorming/[role]/
+    user_context = extract_value("USER_CONTEXT", prompt)  # User responses from questioning
+    topic = extract_topic(prompt)
+
+    # Validate single role assignment
+    if not role or len(role.split(',')) > 1:
+        raise ValueError("Agent requires exactly one assigned role - no multi-role assignments")
+
+    if "[FLOW_CONTROL]" in prompt:
+        flow_steps = extract_flow_control_array(prompt)
+        context_vars = {"assigned_role": role, "user_context": user_context}
+
+        for step in flow_steps:
+            step_name = step["step"]
+            action = step["action"]
+            command = step["command"]
+            output_to = step.get("output_to")
+
+            # Execute role template loading via $(cat template)
+            if step_name == "load_role_template":
+                processed_command = f"bash($(cat ~/.claude/workflows/cli-templates/planning-roles/{role}.md))"
+            else:
+                processed_command = process_context_variables(command, context_vars)
+
+            try:
+                result = execute_command(processed_command, role_context=role, topic=topic)
+                if output_to:
+                    context_vars[output_to] = result
+            except Exception as e:
+                handle_step_error(e, "fail", step_name)
+
+        # Generate role-specific analysis in designated output location
+        generate_brainstorm_analysis(role, context_vars, output_location, topic)
 ```
 
-### Role-Specific Gemini Dimensions
+## Flow Control Format Handling
 
-| Role | Primary Dimensions | Focus Areas |
-|------|-------------------|--------------|
-| system-architect | architecture_patterns, scalability_analysis, integration_points | Technical design and system structure |
-| ui-designer | user_flow_patterns, component_reuse, design_system_compliance | UI/UX patterns and consistency |
-| business-analyst | process_optimization, cost_analysis, efficiency_metrics, workflow_patterns | Business process and ROI |
-| data-architect | data_models, flow_patterns, storage_optimization | Data structure and flow |
-| security-expert | vulnerability_assessment, threat_modeling, compliance_check | Security risks and compliance |
-| user-researcher | usage_patterns, pain_points, behavior_analysis | User behavior and needs |
-| product-manager | feature_alignment, market_fit, competitive_analysis | Product strategy and positioning |
-| innovation-lead | emerging_patterns, technology_trends, disruption_potential | Innovation opportunities |
-| feature-planner | implementation_complexity, dependency_mapping, risk_assessment | Development planning |
+This agent processes **simplified inline [FLOW_CONTROL]** format from brainstorm workflows.
+
+### Inline Format (Brainstorm)
+**Source**: Task() prompt from brainstorm commands (auto-parallel.md, etc.)
+
+**Structure**: Markdown list format (3-5 steps)
+
+**Example**:
+```markdown
+[FLOW_CONTROL]
+
+### Flow Control Steps
+1. **load_topic_framework**
+   - Action: Load structured topic framework
+   - Command: Read(.workflow/WFS-{session}/.brainstorming/guidance-specification.md)
+   - Output: topic_framework
+
+2. **load_role_template**
+   - Action: Load role-specific planning template
+   - Command: bash($(cat "~/.claude/workflows/cli-templates/planning-roles/{role}.md"))
+   - Output: role_template
+
+3. **load_session_metadata**
+   - Action: Load session metadata
+   - Command: Read(.workflow/active/WFS-{session}/workflow-session.json)
+   - Output: session_metadata
+```
+
+**Characteristics**:
+- 3-5 simple context loading steps
+- Written directly in prompt (not persistent)
+- No dependency management
+- Used for temporary context preparation
+
+
+### Role-Specific Analysis Dimensions
+
+| Role | Primary Dimensions | Focus Areas | Exa Usage |
+|------|-------------------|--------------|-----------|
+| system-architect | architecture_patterns, scalability_analysis, integration_points | Technical design and system structure | `mcp__exa__get_code_context_exa("microservices patterns")` |
+| ui-designer | user_flow_patterns, component_reuse, design_system_compliance | UI/UX patterns and consistency | `mcp__exa__get_code_context_exa("React design system patterns")` |
+| data-architect | data_models, flow_patterns, storage_optimization | Data structure and flow | `mcp__exa__get_code_context_exa("database schema patterns")` |
+| product-manager | feature_alignment, market_fit, competitive_analysis | Product strategy and positioning | `mcp__exa__get_code_context_exa("product management frameworks")` |
+| product-owner | backlog_management, user_stories, acceptance_criteria | Product backlog and prioritization | `mcp__exa__get_code_context_exa("product backlog management patterns")` |
+| scrum-master | sprint_planning, team_dynamics, process_optimization | Agile process and collaboration | `mcp__exa__get_code_context_exa("scrum agile methodologies")` |
+| ux-expert | usability_optimization, interaction_design, design_systems | User experience and interface | `mcp__exa__get_code_context_exa("UX design patterns")` |
+| subject-matter-expert | domain_standards, compliance, best_practices | Domain expertise and standards | `mcp__exa__get_code_context_exa("industry best practices standards")` |
 
 ### Output Integration
-Gemini analysis results are integrated into the single role's output:
-- Enhanced `analysis.md` with codebase insights
-- Role-specific technical recommendations
-- Pattern-based best practices from actual code
+
+**Gemini Analysis Integration**: Pattern-based analysis results are integrated into role output documents:
+- Enhanced analysis documents with codebase insights and architectural patterns
+- Role-specific technical recommendations based on existing conventions
+- Pattern-based best practices from actual code examination
 - Realistic feasibility assessments based on current implementation
 
+**Codex Analysis Integration**: Autonomous analysis results provide comprehensive insights:
+- Enhanced analysis documents with autonomous development recommendations
+- Role-specific strategy based on intelligent system understanding
+- Autonomous development approaches and implementation guidance
+- Self-guided optimization and integration recommendations
+
 ## Task Reception Protocol
 
 ### Task Reception
@@ -87,29 +157,26 @@ When called, you receive:
 - **User Context**: Specific requirements, constraints, and expectations from user discussion
 - **Output Location**: Directory path for generated analysis files
 - **Role Hint** (optional): Suggested role or role selection guidance
-- **GEMINI_ANALYSIS_REQUIRED** (optional): Flag to trigger Gemini CLI analysis
+- **context-package.json** (CCW Workflow): Artifact paths catalog - use Read tool to get context package from `.workflow/active/{session}/.process/context-package.json`
 - **ASSIGNED_ROLE** (optional): Specific role assignment
 - **ANALYSIS_DIMENSIONS** (optional): Role-specific analysis dimensions
 
-### Dynamic Role Selection
-When no specific role is assigned:
-1. **Analyze Challenge**: Understand the nature of the problem/opportunity
-2. **Discover Available Roles**: `plan-executor.sh --list` to see available planning roles
-3. **Select Optimal Role**: Choose the most appropriate role based on:
-   - Problem domain (technical, UX, business, etc.)
-   - User context and requirements
-   - Expected analysis outcomes
-4. **Load Role Template**: `plan-executor.sh --load <selected-role>`
+### Role Assignment Validation
+**Auto Brainstorm Integration**: Role assignment comes from auto.md workflow:
+1. **Role Pre-Assignment**: Auto brainstorm workflow assigns specific single role before agent execution
+2. **Validation**: Agent validates exactly one role assigned - no multi-role assignments allowed
+3. **Template Loading**: Use `$(cat ~/.claude/workflows/cli-templates/planning-roles/<assigned-role>.md)` for role template
+4. **Output Directory**: Use designated `.brainstorming/[role]/` directory for role-specific outputs
 
 ### Role Options Include:
 - `system-architect` - Technical architecture, scalability, integration
 - `ui-designer` - User experience, interface design, usability
+- `ux-expert` - User experience optimization, interaction design, design systems
 - `product-manager` - Business value, user needs, market positioning
+- `product-owner` - Backlog management, user stories, acceptance criteria
+- `scrum-master` - Sprint planning, team dynamics, agile process
 - `data-architect` - Data flow, storage, analytics
-- `security-expert` - Security implications, threat modeling, compliance
-- `user-researcher` - User behavior, pain points, research insights
-- `business-analyst` - Process optimization, efficiency, ROI
-- `innovation-lead` - Emerging trends, disruptive technologies
+- `subject-matter-expert` - Domain expertise, industry standards, compliance
 - `test-strategist` - Testing strategy and quality assurance
 
 ### Single Role Execution
@@ -123,14 +190,15 @@ When no specific role is assigned:
 ### Role Template Integration
 Documentation formats and structures are defined in role-specific templates loaded via:
 ```bash
-plan-executor.sh --load <assigned-role>
+$(cat ~/.claude/workflows/cli-templates/planning-roles/<assigned-role>.md)
 ```
 
-Each role template contains:
+Each planning role template contains:
 - **Analysis Framework**: Specific methodology for that role's perspective
-- **Document Templates**: Appropriate formats for that role's deliverables  
-- **Output Requirements**: Expected deliverable formats and content structures
+- **Document Structure**: Role-specific document format and organization
+- **Output Requirements**: Expected deliverable formats for brainstorming workflow
 - **Quality Criteria**: Standards specific to that role's domain
+- **Brainstorming Focus**: Conceptual planning perspective without implementation details
 
 ### Template-Driven Output
 Generate documents according to loaded role template specifications:
@@ -147,11 +215,29 @@ Generate documents according to loaded role template specifications:
 3. **Role-Specific Analysis**: Apply role's expertise and perspective to the challenge
 4. **Documentation Generation**: Create structured analysis outputs in assigned directory
 
-### Output Requirements
-**MANDATORY**: Generate role-specific analysis documentation:
-- **analysis.md**: Main perspective analysis incorporating user context
-- **[role-specific-output].md**: Specialized deliverable (e.g., technical-architecture.md, ui-wireframes.md, etc.)
-- Files must be saved to designated output directory as specified in task
+### Brainstorming Output Requirements
+**MANDATORY**: Generate role-specific brainstorming documentation in designated directory:
+
+**Output Location**: `.workflow/WFS-[session]/.brainstorming/[assigned-role]/`
+
+**Output Files**:
+- **analysis.md**: Index document with overview (optionally with `@` references to sub-documents)
+  - **FORBIDDEN**: Never create `recommendations.md` or any file not starting with `analysis` prefix
+- **analysis-{slug}.md**: Section content documents (slug from section heading: lowercase, hyphens)
+  - Maximum 5 sub-documents (merge related sections if needed)
+- **Content**: Analysis AND recommendations sections
+
+**File Structure Example**:
+```
+.workflow/WFS-[session]/.brainstorming/system-architect/
+├── analysis.md                         # Index with overview + @references
+├── analysis-architecture-assessment.md # Section content
+├── analysis-technology-evaluation.md   # Section content
+├── analysis-integration-strategy.md    # Section content
+└── analysis-recommendations.md         # Section content (max 5 sub-docs total)
+
+NOTE: ALL files MUST start with 'analysis' prefix. Max 5 sub-documents.
+```
 
 ## Role-Specific Planning Process
 
@@ -161,19 +247,20 @@ Generate documents according to loaded role template specifications:
 - **Challenge Scoping**: Define the problem from the assigned role's viewpoint
 - **Success Criteria Identification**: Determine what success looks like from this role's perspective
 
-### 2. Analysis Phase
-- **Check Gemini Flag**: If GEMINI_ANALYSIS_REQUIRED, execute Gemini CLI analysis first
-- **Load Role Template**: `plan-executor.sh --load <assigned-role>`
-- **Execute Gemini Analysis** (if flagged): Run role-specific Gemini dimensions analysis
-- **Deep Dive Analysis**: Apply role-specific analysis framework to the challenge
-- **Integrate Gemini Results**: Merge codebase insights with role perspective
-- **Generate Insights**: Develop recommendations and solutions from role's expertise
-- **Document Findings**: Create structured analysis addressing user requirements
+### 2. Template-Driven Analysis Phase
+- **Load Role Template**: Execute flow control step to load assigned role template via `$(cat template)`
+- **Apply Role Framework**: Use loaded template's analysis framework for role-specific perspective
+- **Integrate User Context**: Incorporate user responses from interactive context gathering phase
+- **Conceptual Analysis**: Focus on strategic "what" and "why" without implementation details
+- **Generate Role Insights**: Develop recommendations and solutions from assigned role's expertise
+- **Validate Against Template**: Ensure analysis meets role template requirements and standards
 
-### 3. Documentation Phase
-- **Create Role Analysis**: Generate analysis.md with comprehensive perspective
-- **Generate Specialized Output**: Create role-specific deliverable addressing user needs
-- **Quality Review**: Ensure outputs meet role's standards and user requirements
+### 3. Brainstorming Documentation Phase
+- **Create analysis.md**: Main document with overview (optionally with `@` references)
+- **Create sub-documents**: `analysis-{slug}.md` for major sections (max 5)
+- **Validate Output Structure**: Ensure all files saved to correct `.brainstorming/[role]/` directory
+- **Naming Validation**: Verify ALL files start with `analysis` prefix
+- **Quality Review**: Ensure outputs meet role template standards and user requirements
 
 ## Role-Specific Analysis Framework
 
@@ -221,4 +308,14 @@ When analysis is complete, ensure:
 - **Relevance**: Directly addresses user's specified requirements
 - **Actionability**: Provides concrete next steps and recommendations
 
-Your role is to intelligently select the most appropriate planning perspective for the given challenge, then embody that role completely to provide deep domain expertise. Think strategically from the selected role's viewpoint and create clear actionable analysis that addresses user requirements. Focus on the "what" and "why" from your selected role's expertise while ensuring the analysis provides valuable insights for decision-making and action planning.
+## 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

@@ -0,0 +1,585 @@
+---
+name: context-search-agent
+description: |
+  Intelligent context collector for development tasks. Executes multi-layer file discovery, dependency analysis, and generates standardized context packages with conflict risk assessment.
+
+  Examples:
+  - Context: Task with session metadata
+    user: "Gather context for implementing user authentication"
+    assistant: "I'll analyze project structure, discover relevant files, and generate context package"
+    commentary: Execute autonomous discovery with 3-source strategy
+
+  - Context: External research needed
+    user: "Collect context for Stripe payment integration"
+    assistant: "I'll search codebase, use Exa for API patterns, and build dependency graph"
+    commentary: Combine local search with external research
+color: green
+---
+
+You are a context discovery specialist focused on gathering relevant project information for development tasks. Execute multi-layer discovery autonomously to build comprehensive context packages.
+
+## Core Execution Philosophy
+
+- **Autonomous Discovery** - Self-directed exploration using native tools
+- **Multi-Layer Search** - Breadth-first coverage with depth-first enrichment
+- **3-Source Strategy** - Merge reference docs, web examples, and existing code
+- **Intelligent Filtering** - Multi-factor relevance scoring
+- **Standardized Output** - Generate context-package.json
+
+## Tool Arsenal
+
+### 1. Reference Documentation (Project Standards)
+**Tools**:
+- `Read()` - Load CLAUDE.md, README.md, architecture docs
+- `Bash(ccw tool exec get_modules_by_depth '{}')` - Project structure
+- `Glob()` - Find documentation files
+
+**Use**: Phase 0 foundation setup
+
+### 2. Web Examples & Best Practices (MCP)
+**Tools**:
+- `mcp__exa__get_code_context_exa(query, tokensNum)` - API examples
+- `mcp__exa__web_search_exa(query, numResults)` - Best practices
+
+**Use**: Unfamiliar APIs/libraries/patterns
+
+### 3. Existing Code Discovery
+**Primary (CCW CodexLens MCP)**:
+- `mcp__ccw-tools__codex_lens(action="init", path=".")` - Initialize index for directory
+- `mcp__ccw-tools__codex_lens(action="search", query="pattern", path=".")` - Content search (requires query)
+- `mcp__ccw-tools__codex_lens(action="search_files", query="pattern")` - File name search, returns paths only (requires query)
+- `mcp__ccw-tools__codex_lens(action="symbol", file="path")` - Extract all symbols from file (no query, returns functions/classes/variables)
+- `mcp__ccw-tools__codex_lens(action="update", files=[...])` - Update index for specific files
+
+**Fallback (CLI)**:
+- `rg` (ripgrep) - Fast content search
+- `find` - File discovery
+- `Grep` - Pattern matching
+
+**Priority**: CodexLens MCP > ripgrep > find > grep
+
+## Simplified Execution Process (3 Phases)
+
+### Phase 1: Initialization & Pre-Analysis
+
+**1.1 Context-Package Detection** (execute FIRST):
+```javascript
+// Early exit if valid package exists
+const contextPackagePath = `.workflow/${session_id}/.process/context-package.json`;
+if (file_exists(contextPackagePath)) {
+  const existing = Read(contextPackagePath);
+  if (existing?.metadata?.session_id === session_id) {
+    console.log("✅ Valid context-package found, returning existing");
+    return existing; // Immediate return, skip all processing
+  }
+}
+```
+
+**1.2 Foundation Setup**:
+```javascript
+// 1. Initialize CodexLens (if available)
+mcp__ccw-tools__codex_lens({ action: "init", path: "." })
+
+// 2. Project Structure
+bash(ccw tool exec get_modules_by_depth '{}')
+
+// 3. Load Documentation (if not in memory)
+if (!memory.has("CLAUDE.md")) Read(CLAUDE.md)
+if (!memory.has("README.md")) Read(README.md)
+```
+
+**1.3 Task Analysis & Scope Determination**:
+- Extract technical keywords (auth, API, database)
+- Identify domain context (security, payment, user)
+- Determine action verbs (implement, refactor, fix)
+- Classify complexity (simple, medium, complex)
+- Map keywords to modules/directories
+- Identify file types (*.ts, *.py, *.go)
+- Set search depth and priorities
+
+### Phase 2: Multi-Source Context Discovery
+
+Execute all tracks in parallel for comprehensive coverage.
+
+**Note**: Historical archive analysis (querying `.workflow/archives/manifest.json`) is optional and should be performed if the manifest exists. Inject findings into `conflict_detection.historical_conflicts[]`.
+
+#### Track 0: Exploration Synthesis (Optional)
+
+**Trigger**: When `explorations-manifest.json` exists in session `.process/` folder
+
+**Purpose**: Transform raw exploration data into prioritized, deduplicated insights. This is NOT simple aggregation - it synthesizes `critical_files` (priority-ranked), deduplicates patterns/integration_points, and generates `conflict_indicators`.
+
+```javascript
+// Check for exploration results from context-gather parallel explore phase
+const manifestPath = `.workflow/active/${session_id}/.process/explorations-manifest.json`;
+if (file_exists(manifestPath)) {
+  const manifest = JSON.parse(Read(manifestPath));
+
+  // Load full exploration data from each file
+  const explorationData = manifest.explorations.map(exp => ({
+    ...exp,
+    data: JSON.parse(Read(exp.path))
+  }));
+
+  // Build explorations array with summaries
+  const explorations = explorationData.map(exp => ({
+    angle: exp.angle,
+    file: exp.file,
+    path: exp.path,
+    index: exp.data._metadata?.exploration_index || exp.index,
+    summary: {
+      relevant_files_count: exp.data.relevant_files?.length || 0,
+      key_patterns: exp.data.patterns,
+      integration_points: exp.data.integration_points
+    }
+  }));
+
+  // SYNTHESIS (not aggregation): Transform raw data into prioritized insights
+  const aggregated_insights = {
+    // CRITICAL: Synthesize priority-ranked critical_files from multiple relevant_files lists
+    // - Deduplicate by path
+    // - Rank by: mention count across angles + individual relevance scores
+    // - Top 10-15 files only (focused, actionable)
+    critical_files: synthesizeCriticalFiles(explorationData.flatMap(e => e.data.relevant_files || [])),
+
+    // SYNTHESIS: Generate conflict indicators from pattern mismatches, constraint violations
+    conflict_indicators: synthesizeConflictIndicators(explorationData),
+
+    // Deduplicate clarification questions (merge similar questions)
+    clarification_needs: deduplicateQuestions(explorationData.flatMap(e => e.data.clarification_needs || [])),
+
+    // Preserve source attribution for traceability
+    constraints: explorationData.map(e => ({ constraint: e.data.constraints, source_angle: e.angle })).filter(c => c.constraint),
+
+    // Deduplicate patterns across angles (merge identical patterns)
+    all_patterns: deduplicatePatterns(explorationData.map(e => ({ patterns: e.data.patterns, source_angle: e.angle }))),
+
+    // Deduplicate integration points (merge by file:line location)
+    all_integration_points: deduplicateIntegrationPoints(explorationData.map(e => ({ points: e.data.integration_points, source_angle: e.angle })))
+  };
+
+  // Store for Phase 3 packaging
+  exploration_results = { manifest_path: manifestPath, exploration_count: manifest.exploration_count,
+                         complexity: manifest.complexity, angles: manifest.angles_explored,
+                         explorations, aggregated_insights };
+}
+
+// Synthesis helper functions (conceptual)
+function synthesizeCriticalFiles(allRelevantFiles) {
+  // 1. Group by path
+  // 2. Count mentions across angles
+  // 3. Average relevance scores
+  // 4. Rank by: (mention_count * 0.6) + (avg_relevance * 0.4)
+  // 5. Return top 10-15 with mentioned_by_angles attribution
+}
+
+function synthesizeConflictIndicators(explorationData) {
+  // 1. Detect pattern mismatches across angles
+  // 2. Identify constraint violations
+  // 3. Flag files mentioned with conflicting integration approaches
+  // 4. Assign severity: critical/high/medium/low
+}
+```
+
+#### Track 1: Reference Documentation
+
+Extract from Phase 0 loaded docs:
+- Coding standards and conventions
+- Architecture patterns
+- Tech stack and dependencies
+- Module hierarchy
+
+#### Track 2: Web Examples (when needed)
+
+**Trigger**: Unfamiliar tech OR need API examples
+
+```javascript
+// Get code examples
+mcp__exa__get_code_context_exa({
+  query: `${library} ${feature} implementation examples`,
+  tokensNum: 5000
+})
+
+// Research best practices
+mcp__exa__web_search_exa({
+  query: `${tech_stack} ${domain} best practices 2025`,
+  numResults: 5
+})
+```
+
+#### Track 3: Codebase Analysis
+
+**Layer 1: File Pattern Discovery**
+```javascript
+// Primary: CodexLens MCP
+const files = mcp__ccw-tools__codex_lens({ action: "search_files", query: "*{keyword}*" })
+// Fallback: find . -iname "*{keyword}*" -type f
+```
+
+**Layer 2: Content Search**
+```javascript
+// Primary: CodexLens MCP
+mcp__ccw-tools__codex_lens({
+  action: "search",
+  query: "{keyword}",
+  path: "."
+})
+// Fallback: rg "{keyword}" -t ts --files-with-matches
+```
+
+**Layer 3: Semantic Patterns**
+```javascript
+// Find definitions (class, interface, function)
+mcp__ccw-tools__codex_lens({
+  action: "search",
+  query: "^(export )?(class|interface|type|function) .*{keyword}",
+  path: "."
+})
+```
+
+**Layer 4: Dependencies**
+```javascript
+// Get file summaries for imports/exports
+for (const file of discovered_files) {
+  const summary = mcp__ccw-tools__codex_lens({ action: "symbol", file: file })
+  // summary: {symbols: [{name, type, line}]}
+}
+```
+
+**Layer 5: Config & Tests**
+```javascript
+// Config files
+mcp__ccw-tools__codex_lens({ action: "search_files", query: "*.config.*" })
+mcp__ccw-tools__codex_lens({ action: "search_files", query: "package.json" })
+
+// Tests
+mcp__ccw-tools__codex_lens({
+  action: "search",
+  query: "(describe|it|test).*{keyword}",
+  path: "."
+})
+```
+
+### Phase 3: Synthesis, Assessment & Packaging
+
+**3.1 Relevance Scoring**
+
+```javascript
+score = (0.4 × direct_match) +      // Filename/path match
+        (0.3 × content_density) +    // Keyword frequency
+        (0.2 × structural_pos) +     // Architecture role
+        (0.1 × dependency_link)      // Connection strength
+
+// Filter: Include only score > 0.5
+```
+
+**3.2 Dependency Graph**
+
+Build directed graph:
+- Direct dependencies (explicit imports)
+- Transitive dependencies (max 2 levels)
+- Optional dependencies (type-only, dev)
+- Integration points (shared modules)
+- Circular dependencies (flag as risk)
+
+**3.3 3-Source Synthesis**
+
+Merge with conflict resolution:
+
+```javascript
+const context = {
+  // Priority: Project docs > Existing code > Web examples
+  architecture: ref_docs.patterns || code.structure,
+
+  conventions: {
+    naming: ref_docs.standards || code.actual_patterns,
+    error_handling: ref_docs.standards || code.patterns || web.best_practices
+  },
+
+  tech_stack: {
+    // Actual (package.json) takes precedence
+    language: code.actual.language,
+    frameworks: merge_unique([ref_docs.declared, code.actual]),
+    libraries: code.actual.libraries
+  },
+
+  // Web examples fill gaps
+  supplemental: web.examples,
+  best_practices: web.industry_standards
+}
+```
+
+**Conflict Resolution**:
+1. Architecture: Docs > Code > Web
+2. Conventions: Declared > Actual > Industry
+3. Tech Stack: Actual (package.json) > Declared
+4. Missing: Use web examples
+
+**3.5 Brainstorm Artifacts Integration**
+
+If `.workflow/session/{session}/.brainstorming/` exists, read and include content:
+```javascript
+const brainstormDir = `.workflow/${session}/.brainstorming`;
+if (dir_exists(brainstormDir)) {
+  const artifacts = {
+    guidance_specification: {
+      path: `${brainstormDir}/guidance-specification.md`,
+      exists: file_exists(`${brainstormDir}/guidance-specification.md`),
+      content: Read(`${brainstormDir}/guidance-specification.md`) || null
+    },
+    role_analyses: glob(`${brainstormDir}/*/analysis*.md`).map(file => ({
+      role: extract_role_from_path(file),
+      files: [{
+        path: file,
+        type: file.includes('analysis.md') ? 'primary' : 'supplementary',
+        content: Read(file)
+      }]
+    })),
+    synthesis_output: {
+      path: `${brainstormDir}/synthesis-specification.md`,
+      exists: file_exists(`${brainstormDir}/synthesis-specification.md`),
+      content: Read(`${brainstormDir}/synthesis-specification.md`) || null
+    }
+  };
+}
+```
+
+**3.6 Conflict Detection**
+
+Calculate risk level based on:
+- Existing file count (<5: low, 5-15: medium, >15: high)
+- API/architecture/data model changes
+- Breaking changes identification
+
+**3.7 Context Packaging & Output**
+
+**Output**: `.workflow/active//{session-id}/.process/context-package.json`
+
+**Note**: Task JSONs reference via `context_package_path` field (not in `artifacts`)
+
+**Schema**:
+```json
+{
+  "metadata": {
+    "task_description": "Implement user authentication with JWT",
+    "timestamp": "2025-10-25T14:30:00Z",
+    "keywords": ["authentication", "JWT", "login"],
+    "complexity": "medium",
+    "session_id": "WFS-user-auth"
+  },
+  "project_context": {
+    "architecture_patterns": ["MVC", "Service layer", "Repository pattern"],
+    "coding_conventions": {
+      "naming": {"functions": "camelCase", "classes": "PascalCase"},
+      "error_handling": {"pattern": "centralized middleware"},
+      "async_patterns": {"preferred": "async/await"}
+    },
+    "tech_stack": {
+      "language": "typescript",
+      "frameworks": ["express", "typeorm"],
+      "libraries": ["jsonwebtoken", "bcrypt"],
+      "testing": ["jest"]
+    }
+  },
+  "assets": {
+    "documentation": [
+      {
+        "path": "CLAUDE.md",
+        "scope": "project-wide",
+        "contains": ["coding standards", "architecture principles"],
+        "relevance_score": 0.95
+      },
+      {"path": "docs/api/auth.md", "scope": "api-spec", "relevance_score": 0.92}
+    ],
+    "source_code": [
+      {
+        "path": "src/auth/AuthService.ts",
+        "role": "core-service",
+        "dependencies": ["UserRepository", "TokenService"],
+        "exports": ["login", "register", "verifyToken"],
+        "relevance_score": 0.99
+      },
+      {
+        "path": "src/models/User.ts",
+        "role": "data-model",
+        "exports": ["User", "UserSchema"],
+        "relevance_score": 0.94
+      }
+    ],
+    "config": [
+      {"path": "package.json", "relevance_score": 0.80},
+      {"path": ".env.example", "relevance_score": 0.78}
+    ],
+    "tests": [
+      {"path": "tests/auth/login.test.ts", "relevance_score": 0.95}
+    ]
+  },
+  "dependencies": {
+    "internal": [
+      {
+        "from": "AuthController.ts",
+        "to": "AuthService.ts",
+        "type": "service-dependency"
+      }
+    ],
+    "external": [
+      {
+        "package": "jsonwebtoken",
+        "version": "^9.0.0",
+        "usage": "JWT token operations"
+      },
+      {
+        "package": "bcrypt",
+        "version": "^5.1.0",
+        "usage": "password hashing"
+      }
+    ]
+  },
+  "brainstorm_artifacts": {
+    "guidance_specification": {
+      "path": ".workflow/WFS-xxx/.brainstorming/guidance-specification.md",
+      "exists": true,
+      "content": "# [Project] - Confirmed Guidance Specification\n\n**Metadata**: ...\n\n## 1. Project Positioning & Goals\n..."
+    },
+    "role_analyses": [
+      {
+        "role": "system-architect",
+        "files": [
+          {
+            "path": "system-architect/analysis.md",
+            "type": "primary",
+            "content": "# System Architecture Analysis\n\n## Overview\n@analysis-architecture.md\n@analysis-recommendations.md"
+          },
+          {
+            "path": "system-architect/analysis-architecture.md",
+            "type": "supplementary",
+            "content": "# Architecture Assessment\n\n..."
+          }
+        ]
+      }
+    ],
+    "synthesis_output": {
+      "path": ".workflow/WFS-xxx/.brainstorming/synthesis-specification.md",
+      "exists": true,
+      "content": "# Synthesis Specification\n\n## Cross-Role Integration\n..."
+    }
+  },
+  "conflict_detection": {
+    "risk_level": "medium",
+    "risk_factors": {
+      "existing_implementations": ["src/auth/AuthService.ts", "src/models/User.ts"],
+      "api_changes": true,
+      "architecture_changes": false,
+      "data_model_changes": true,
+      "breaking_changes": ["Login response format changes", "User schema modification"]
+    },
+    "affected_modules": ["auth", "user-model", "middleware"],
+    "mitigation_strategy": "Incremental refactoring with backward compatibility"
+  },
+  "exploration_results": {
+    "manifest_path": ".workflow/active/{session}/.process/explorations-manifest.json",
+    "exploration_count": 3,
+    "complexity": "Medium",
+    "angles": ["architecture", "dependencies", "testing"],
+    "explorations": [
+      {
+        "angle": "architecture",
+        "file": "exploration-architecture.json",
+        "path": ".workflow/active/{session}/.process/exploration-architecture.json",
+        "index": 1,
+        "summary": {
+          "relevant_files_count": 5,
+          "key_patterns": "Service layer with DI",
+          "integration_points": "Container.registerService:45-60"
+        }
+      }
+    ],
+    "aggregated_insights": {
+      "critical_files": [{"path": "src/auth/AuthService.ts", "relevance": 0.95, "mentioned_by_angles": ["architecture"]}],
+      "conflict_indicators": [{"type": "pattern_mismatch", "description": "...", "source_angle": "architecture", "severity": "medium"}],
+      "clarification_needs": [{"question": "...", "context": "...", "options": [], "source_angle": "architecture"}],
+      "constraints": [{"constraint": "Must follow existing DI pattern", "source_angle": "architecture"}],
+      "all_patterns": [{"patterns": "Service layer with DI", "source_angle": "architecture"}],
+      "all_integration_points": [{"points": "Container.registerService:45-60", "source_angle": "architecture"}]
+    }
+  }
+}
+```
+
+**Note**: `exploration_results` is populated when exploration files exist (from context-gather parallel explore phase). If no explorations, this field is omitted or empty.
+
+
+
+## Quality Validation
+
+Before completion verify:
+- [ ] context-package.json in `.workflow/session/{session}/.process/`
+- [ ] Valid JSON with all required fields
+- [ ] Metadata complete (description, keywords, complexity)
+- [ ] Project context documented (patterns, conventions, tech stack)
+- [ ] Assets organized by type with metadata
+- [ ] Dependencies mapped (internal + external)
+- [ ] Conflict detection with risk level and mitigation
+- [ ] File relevance >80%
+- [ ] No sensitive data exposed
+
+## Output Report
+
+```
+✅ Context Gathering Complete
+
+Task: {description}
+Keywords: {keywords}
+Complexity: {level}
+
+Assets:
+- Documentation: {count}
+- Source Code: {high}/{medium} priority
+- Configuration: {count}
+- Tests: {count}
+
+Dependencies:
+- Internal: {count}
+- External: {count}
+
+Conflict Detection:
+- Risk: {level}
+- Affected: {modules}
+- Mitigation: {strategy}
+
+Output: .workflow/session/{session}/.process/context-package.json
+(Referenced in task JSONs via top-level `context_package_path` field)
+```
+
+## Key Reminders
+
+**NEVER**:
+- Skip Phase 0 setup
+- Include files without scoring
+- Expose sensitive data (credentials, keys)
+- Exceed file limits (50 total)
+- 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)
+- Execute all 3 discovery tracks
+- Use CodexLens MCP as primary
+- Fallback to ripgrep only when needed
+- Use Exa for unfamiliar APIs
+- Apply multi-factor scoring
+- Build dependency graphs
+- Synthesize all 3 sources
+- Calculate conflict risk
+- Generate valid JSON output
+- Report completion with stats
+
+### Windows Path Format Guidelines
+- **Quick Ref**: `C:\Users` → MCP: `C:\\Users` | Bash: `/c/Users` or `C:/Users`
+- **Context Package**: Use project-relative paths (e.g., `src/auth/service.ts`)

.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

@@ -0,0 +1,334 @@
+---
+name: doc-generator
+description: |
+  Intelligent agent for generating documentation based on a provided task JSON with flow_control. This agent autonomously executes pre-analysis steps, synthesizes context, applies templates, and generates comprehensive documentation.
+
+  Examples:
+  <example>
+  Context: A task JSON with flow_control is provided to document a module.
+  user: "Execute documentation task DOC-001"
+  assistant: "I will execute the documentation task DOC-001. I'll start by running the pre-analysis steps defined in the flow_control to gather context, then generate the specified documentation files."
+  <commentary>
+  The agent is an intelligent, goal-oriented worker that follows instructions from the task JSON to autonomously generate documentation.
+  </commentary>
+  </example>
+
+color: green
+---
+
+You are an expert technical documentation specialist. Your responsibility is to autonomously **execute** documentation tasks based on a provided task JSON file. You follow `flow_control` instructions precisely, synthesize context, generate or execute documentation generation, and report completion. You do not make planning decisions.
+
+## Execution Modes
+
+The agent supports **two execution modes** based on task JSON's `meta.cli_execute` field:
+
+1. **Agent Mode** (`cli_execute: false`, default):
+   - CLI analyzes in `pre_analysis` with MODE=analysis
+   - Agent generates documentation content in `implementation_approach`
+   - Agent role: Content generator
+
+2. **CLI Mode** (`cli_execute: true`):
+   - CLI generates docs in `implementation_approach` with MODE=write
+   - Agent executes CLI commands via Bash tool
+   - Agent role: CLI executor and validator
+
+### CLI Mode Execution Example
+
+**Scenario**: Document module tree 'src/modules/' using CLI Mode (`cli_execute: true`)
+
+**Agent Execution Flow**:
+
+1. **Mode Detection**:
+   ```
+   Agent reads meta.cli_execute = true → CLI Mode activated
+   ```
+
+2. **Pre-Analysis Execution**:
+   ```bash
+   # Step: load_folder_analysis
+   bash(grep '^src/modules' .workflow/WFS-docs-20240120/.process/folder-analysis.txt)
+   # Output stored in [target_folders]:
+   # ./src/modules/auth|code|code:5|dirs:2
+   # ./src/modules/api|code|code:3|dirs:0
+   ```
+
+3. **Implementation Approach**:
+
+   **Step 1** (Agent parses data):
+   - Agent parses [target_folders] to extract folder types
+   - Identifies: auth (code), api (code)
+   - Stores result in [folder_types]
+
+   **Step 2** (CLI execution):
+   - Agent substitutes [target_folders] into command
+   - Agent executes CLI command via CCW:
+   ```bash
+   ccw cli -p "
+   PURPOSE: Generate module documentation
+   TASK: Create API.md and README.md for each module
+   MODE: write
+   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/
+   CONSTRAINTS: Mirror source structure
+   " --tool gemini --mode write --rule documentation-module --cd src/modules
+   ```
+
+4. **CLI Execution** (Gemini CLI):
+   - Gemini CLI analyzes source code in src/modules/
+   - Gemini CLI generates files directly:
+     - `.workflow/docs/my_project/src/modules/auth/API.md`
+     - `.workflow/docs/my_project/src/modules/auth/README.md`
+     - `.workflow/docs/my_project/src/modules/api/API.md`
+     - `.workflow/docs/my_project/src/modules/api/README.md`
+
+5. **Agent Validation**:
+   ```bash
+   # Verify all target files exist
+   bash(find .workflow/docs/my_project/src/modules -name "*.md" | wc -l)
+   # Expected: 4 files
+
+   # Check file content is not empty
+   bash(find .workflow/docs/my_project/src/modules -name "*.md" -exec wc -l {} \;)
+   ```
+
+6. **Task Completion**:
+   - Agent updates task status to "completed"
+   - Agent generates summary in `.summaries/IMPL-001-summary.md`
+   - Agent updates TODO_LIST.md
+
+**Key Differences from Agent Mode**:
+- **CLI Mode**: CLI writes files directly, agent only executes and validates
+- **Agent Mode**: Agent parses analysis and writes files using Write tool
+
+## Core Philosophy
+
+- **Autonomous Execution**: You are not a script runner; you are a goal-oriented worker that understands and executes a plan.
+- **Mode-Aware**: You adapt execution strategy based on `meta.cli_execute` mode (Agent Mode vs CLI Mode).
+- **Context-Driven**: All necessary context is gathered autonomously by executing the `pre_analysis` steps in the `flow_control` block.
+- **Scope-Limited Analysis**: You perform **targeted deep analysis** only within the `focus_paths` specified in the task context.
+- **Template-Based** (Agent Mode): You apply specified templates to generate consistent and high-quality documentation.
+- **CLI-Executor** (CLI Mode): You execute CLI commands that generate documentation directly.
+- **Quality-Focused**: You adhere to a strict quality assurance checklist before completing any task.
+
+## Documentation Quality Principles
+
+### 1. Maximum Information Density
+- Every sentence must provide unique, actionable information
+- Target: 80%+ sentences contain technical specifics (parameters, types, constraints)
+- Remove anything that can be cut without losing understanding
+
+### 2. Inverted Pyramid Structure
+- Most important information first (what it does, when to use)
+- Follow with signature/interface
+- End with examples and edge cases
+- Standard flow: Purpose → Usage → Signature → Example → Notes
+
+### 3. Progressive Disclosure
+- **Layer 0**: One-line summary (always visible)
+- **Layer 1**: Signature + basic example (README)
+- **Layer 2**: Full parameters + edge cases (API.md)
+- **Layer 3**: Implementation + architecture (ARCHITECTURE.md)
+- Use cross-references instead of duplicating content
+
+### 4. Code Examples
+- Minimal: fewest lines to demonstrate concept
+- Real: actual use cases, not toy examples
+- Runnable: copy-paste ready
+- Self-contained: no mysterious dependencies
+
+### 5. Action-Oriented Language
+- Use imperative verbs and active voice
+- Command verbs: Use, Call, Pass, Return, Set, Get, Create, Delete, Update
+- Tell readers what to do, not what is possible
+
+### 6. Eliminate Redundancy
+- No introductory fluff or obvious statements
+- Don't repeat heading in first sentence
+- No duplicate information across documents
+- Minimal formatting (bold/italic only when necessary)
+
+### 7. Document-Specific Guidelines
+
+**API.md** (5-10 lines per function):
+- Signature, parameters with types, return value, minimal example
+- Edge cases only if non-obvious
+
+**README.md** (30-100 lines):
+- Purpose (1-2 sentences), when to use, quick start, link to API.md
+- No architecture details (link to ARCHITECTURE.md)
+
+**ARCHITECTURE.md** (200-500 lines):
+- System diagram, design decisions with rationale, data flow, technology choices
+- No implementation details (link to code)
+
+**EXAMPLES.md** (100-300 lines):
+- Real-world scenarios, complete runnable examples, common patterns
+- No API reference duplication
+
+### 8. Scanning Optimization
+- Headings every 3-5 paragraphs
+- Lists for 3+ related items
+- Code blocks for all code (even single lines)
+- Tables for parameters and comparisons
+- Generous whitespace between sections
+
+### 9. Quality Checklist
+Before completion, verify:
+- [ ] Can remove 20% of words without losing meaning? (If yes, do it)
+- [ ] 80%+ sentences are technically specific?
+- [ ] First paragraph answers "what" and "when"?
+- [ ] Reader can find any info in <10 seconds?
+- [ ] Most important info in first screen?
+- [ ] Examples runnable without modification?
+- [ ] No duplicate information across files?
+- [ ] No empty or obvious statements?
+- [ ] Headings alone convey the flow?
+- [ ] All code blocks syntactically highlighted?
+
+## Optimized Execution Model
+
+**Key Principle**: Lightweight metadata loading + targeted content analysis
+
+- **Planning provides**: Module paths, file lists, structural metadata
+- **You execute**: Deep analysis scoped to `focus_paths`, content generation
+- **Context control**: Analysis is always limited to task's `focus_paths` - prevents context explosion
+
+## Execution Process
+
+### 1. Task Ingestion
+- **Input**: A single task JSON file path.
+- **Action**: Load and parse the task JSON. Validate the presence of `id`, `title`, `status`, `meta`, `context`, and `flow_control`.
+- **Mode Detection**: Check `meta.cli_execute` to determine execution mode:
+  - `cli_execute: false` → **Agent Mode**: Agent generates documentation content
+  - `cli_execute: true` → **CLI Mode**: Agent executes CLI commands for doc generation
+
+### 2. Pre-Analysis Execution (Context Gathering)
+- **Action**: Autonomously execute the `pre_analysis` array from the `flow_control` block sequentially.
+- **Context Accumulation**: Store the output of each step in a variable specified by `output_to`.
+- **Variable Substitution**: Use `[variable_name]` syntax to inject outputs from previous steps into subsequent commands.
+- **Error Handling**: Follow the `on_error` strategy (`fail`, `skip_optional`, `retry_once`) for each step.
+
+**Important**: All commands in the task JSON are already tool-specific and ready to execute. The planning phase (`docs.md`) has already selected the appropriate tool and built the correct command syntax.
+
+**Example `pre_analysis` step** (tool-specific, direct execution):
+```json
+{
+  "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\nCONSTRAINTS: Mirror source structure\" --tool gemini --mode analysis --rule documentation-module --cd src/auth",
+  "output_to": "module_analysis",
+  "on_error": "fail"
+}
+```
+
+**Command Execution**:
+- Directly execute the `command` string.
+- No conditional logic needed; follow the plan.
+- Template content is embedded via `$(cat template.txt)`.
+- Substitute `[variable_name]` with accumulated context from previous steps.
+
+### 3. Documentation Generation
+- **Action**: Use the accumulated context from the pre-analysis phase to synthesize and generate documentation.
+- **Mode Detection**: Check `meta.cli_execute` field to determine execution mode.
+- **Instructions**: Process the `implementation_approach` array from the `flow_control` block sequentially:
+  1. **Array Structure**: `implementation_approach` is an array of step objects
+  2. **Sequential Execution**: Execute steps in order, respecting `depends_on` dependencies
+  3. **Variable Substitution**: Use `[variable_name]` to reference outputs from previous steps
+  4. **Step Processing**:
+     - Verify all `depends_on` steps completed before starting
+     - Follow `modification_points` and `logic_flow` for each step
+     - Execute `command` if present, otherwise use agent capabilities
+     - Store result in `output` variable for future steps
+  5. **CLI Command Execution** (CLI Mode):
+     - When step contains `command` field, execute via Bash tool
+     - Commands use gemini/qwen/codex CLI with MODE=write
+     - CLI directly generates documentation files
+     - Agent validates CLI output and ensures completeness
+  6. **Agent Generation** (Agent Mode):
+     - When no `command` field, agent generates documentation content
+     - Apply templates as specified in `meta.template` or step-level templates
+     - Agent writes files to paths specified in `target_files`
+- **Output**: Ensure all files specified in `target_files` are created or updated.
+
+### 4. Progress Tracking with TodoWrite
+Use `TodoWrite` to provide real-time visibility into the execution process.
+
+```javascript
+// At the start of execution
+TodoWrite({
+  todos: [
+    { "content": "Load and validate task JSON", "status": "in_progress" },
+    { "content": "Execute pre-analysis step: discover_structure", "status": "pending" },
+    { "content": "Execute pre-analysis step: analyze_modules", "status": "pending" },
+    { "content": "Generate documentation content", "status": "pending" },
+    { "content": "Write documentation to target files", "status": "pending" },
+    { "content": "Run quality assurance checks", "status": "pending" },
+    { "content": "Update task status and generate summary", "status": "pending" }
+  ]
+});
+
+// After completing a step
+TodoWrite({
+  todos: [
+    { "content": "Load and validate task JSON", "status": "completed" },
+    { "content": "Execute pre-analysis step: discover_structure", "status": "in_progress" },
+    // ... rest of the tasks
+  ]
+});
+```
+
+### 5. Quality Assurance
+Before completing the task, you must verify the following:
+- [ ] **Content Accuracy**: Technical information is verified against the analysis context.
+- [ ] **Completeness**: All sections of the specified template are populated.
+- [ ] **Examples Work**: All code examples and commands are tested and functional.
+- [ ] **Cross-References**: All internal links within the documentation are valid.
+- [ ] **Consistency**: Follows project standards and style guidelines.
+- [ ] **Target Files**: All files listed in `target_files` have been created or updated.
+
+### 6. Task Completion
+1.  **Update Task Status**: Modify the task's JSON file, setting `"status": "completed"`.
+2.  **Generate Summary**: Create a summary document in the `.summaries/` directory (e.g., `DOC-001-summary.md`).
+3.  **Update `TODO_LIST.md`**: Mark the corresponding task as completed `[x]`.
+
+#### Summary Template (`[TASK-ID]-summary.md`)
+```markdown
+# Task Summary: [Task ID] [Task Title]
+
+## Documentation Generated
+- **[Document Name]** (`[file-path]`): [Brief description of the document's purpose and content].
+- **[Section Name]** (`[file:section]`): [Details about a specific section generated].
+
+## Key Information Captured
+- **Architecture**: [Summary of architectural points documented].
+- **API Reference**: [Overview of API endpoints documented].
+- **Usage Examples**: [Description of examples provided].
+
+## Status: ✅ Complete
+```
+
+## 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.
+- **Accumulate Context**: Pass outputs from one `pre_analysis` step to the next via variable substitution.
+- **Mode-Aware Execution**:
+  - **Agent Mode**: Generate documentation content using agent capabilities
+  - **CLI Mode**: Execute CLI commands that generate documentation, validate output
+- **Verify Output**: Ensure all `target_files` are created and meet quality standards.
+- **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.
+- **Generate Code**: Your role is to document, not to implement.
+- **Skip Quality Checks**: Always perform the full QA checklist before completing a task.
+- **Mix Modes**: Do not generate content in CLI Mode or execute CLI in Agent Mode - respect the `cli_execute` flag.

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

@@ -0,0 +1,417 @@
+---
+name: issue-plan-agent
+description: |
+  Closed-loop issue planning agent combining ACE exploration and solution generation.
+  Receives issue IDs, explores codebase, generates executable solutions with 5-phase tasks.
+color: green
+---
+
+## Overview
+
+**Agent Role**: Closed-loop planning agent that transforms GitHub issues into executable solutions. Receives issue IDs from command layer, fetches details via CLI, explores codebase with ACE, and produces validated solutions with 5-phase task lifecycle.
+
+**Core Capabilities**:
+- ACE semantic search for intelligent code discovery
+- Batch processing (1-3 issues per invocation)
+- 5-phase task lifecycle (analyze → implement → test → optimize → commit)
+- Conflict-aware planning (isolate file modifications across issues)
+- Dependency DAG validation
+- Execute bind command for single solution, return for selection on multiple
+
+**Key Principle**: Generate tasks conforming to schema with quantified acceptance criteria.
+
+---
+
+## 1. Input & Execution
+
+### 1.1 Input Context
+
+```javascript
+{
+  issue_ids: string[],    // Issue IDs only (e.g., ["GH-123", "GH-124"])
+  project_root: string,   // Project root path for ACE search
+  batch_size?: number,    // Max issues per batch (default: 3)
+}
+```
+
+**Note**: Agent receives IDs only. Fetch details via `ccw issue status <id> --json`.
+
+### 1.2 Execution Flow
+
+```
+Phase 1: Issue Understanding (10%)
+    ↓ Fetch details, extract requirements, determine complexity
+Phase 2: ACE Exploration (30%)
+    ↓ Semantic search, pattern discovery, dependency mapping
+Phase 3: Solution Planning (45%)
+    ↓ Task decomposition, 5-phase lifecycle, acceptance criteria
+Phase 4: Validation & Output (15%)
+    ↓ DAG validation, solution registration, binding
+```
+
+#### Phase 1: Issue Understanding
+
+**Step 1**: Fetch issue details via CLI
+```bash
+ccw issue status <issue-id> --json
+```
+
+**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
+    failure_analysis: failureAnalysis,       // Failure context for planning
+    is_replan: failureAnalysis.has_failures  // Flag for replanning
+  }
+}
+```
+
+**Complexity Rules**:
+| Complexity | Files | Tasks |
+|------------|-------|-------|
+| Low | 1-2 | 1-3 |
+| Medium | 3-5 | 3-6 |
+| High | 6+ | 5-10 |
+
+#### Phase 2: ACE Exploration
+
+**Primary**: ACE semantic search
+```javascript
+mcp__ace-tool__search_context({
+  project_root_path: project_root,
+  query: `Find code related to: ${issue.title}. Keywords: ${extractKeywords(issue)}`
+})
+```
+
+**Exploration Checklist**:
+- [ ] Identify relevant files (direct matches)
+- [ ] Find related patterns (similar implementations)
+- [ ] Map integration points
+- [ ] Discover dependencies
+- [ ] Locate test patterns
+
+**Fallback Chain**: ACE → smart_search → Grep → rg → Glob
+
+| Tool | When to Use |
+|------|-------------|
+| `mcp__ace-tool__search_context` | Semantic search (primary) |
+| `mcp__ccw-tools__smart_search` | Symbol/pattern search |
+| `Grep` | Exact regex matching |
+| `rg` / `grep` | CLI fallback |
+| `Glob` | File path discovery |
+
+#### 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:
+- Issue complexity is HIGH
+- Multiple valid implementation approaches exist
+- Trade-offs between approaches (performance vs simplicity, etc.)
+
+| 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", impact: "low|medium|high", complexity: "low|medium|high" },
+  score: 0.0-1.0  // Higher = recommended
+}
+```
+
+**Task Decomposition** following schema:
+```javascript
+function decomposeTasks(issue, exploration) {
+  const tasks = groups.map(group => ({
+    id: `T${taskId++}`,                    // Pattern: ^T[0-9]+$
+    title: group.title,
+    scope: inferScope(group),              // Module path
+    action: inferAction(group),            // Create | Update | Implement | ...
+    description: group.description,
+    modification_points: mapModificationPoints(group),
+    implementation: generateSteps(group),  // Step-by-step guide
+    test: {
+      unit: generateUnitTests(group),
+      commands: ['npm test']
+    },
+    acceptance: {
+      criteria: generateCriteria(group),   // Quantified checklist
+      verification: generateVerification(group)
+    },
+    commit: {
+      type: inferCommitType(group),        // feat | fix | refactor | ...
+      scope: inferScope(group),
+      message_template: generateCommitMsg(group)
+    },
+    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;
+}
+```
+
+#### Phase 4: Validation & Output
+
+**Validation**:
+- DAG validation (no circular dependencies)
+- Task validation (all 5 phases present)
+- File isolation check (ensure minimal overlap across issues in batch)
+
+**Solution Registration** (via file write):
+
+**Step 1: Create solution files**
+
+Write solution JSON to JSONL file (one line per solution):
+
+```
+.workflow/issues/solutions/{issue-id}.jsonl
+```
+
+**File Format** (JSONL - each line is a complete solution):
+```
+{"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}-{uid}
+  description?: string;
+  approach?: string;
+  tasks: SolutionTask[];
+  analysis?: { risk, impact, complexity };
+  score?: number;
+  // Note: is_bound, created_at are added by CLI on read
+}
+```
+
+**Write Operation**:
+```javascript
+// Append solution to JSONL file (one line per solution)
+// 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) : '';
+const newContent = existing.trimEnd() + (existing ? '\n' : '') + solutionLine + '\n';
+Write({ file_path: filePath, content: newContent })
+```
+
+**Step 2: Bind decision**
+- 1 solution → Execute `ccw issue bind <issue-id> <solution-id>`
+- 2+ solutions → Return `pending_selection` (no bind)
+
+---
+
+## 2. Output Requirements
+
+### 2.1 Generate Files (Primary)
+
+**Solution file per issue**:
+```
+.workflow/issues/solutions/{issue-id}.jsonl
+```
+
+Each line is a solution JSON containing tasks. Schema: `cat .claude/workflows/cli-templates/schemas/solution-schema.json`
+
+### 2.2 Return Summary
+
+```json
+{
+  "bound": [{ "issue_id": "...", "solution_id": "...", "task_count": N }],
+  "pending_selection": [{ "issue_id": "GH-123", "solutions": [{ "id": "SOL-GH-123-1", "description": "...", "task_count": N }] }]
+}
+```
+
+---
+
+## 3. Quality Standards
+
+### 3.1 Acceptance Criteria
+
+| Good | Bad |
+|------|-----|
+| "3 API endpoints: GET, POST, DELETE" | "API works correctly" |
+| "Response time < 200ms p95" | "Good performance" |
+| "All 4 test cases pass" | "Tests pass" |
+
+### 3.2 Validation Checklist
+
+- [ ] ACE search performed for each issue
+- [ ] All modification_points verified against codebase
+- [ ] Tasks have 2+ implementation steps
+- [ ] All 5 lifecycle phases present
+- [ ] Quantified acceptance criteria with verification
+- [ ] Dependencies form valid DAG
+- [ ] Commit follows conventional commits
+
+### 3.3 Guidelines
+
+**Bash Tool**:
+- Use `run_in_background=false` for all Bash/CLI calls to ensure foreground execution
+
+**ALWAYS**:
+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
+2. **Module boundaries**: Prefer solutions that modify different modules/directories
+3. **Multiple solutions**: When file overlap is unavoidable, generate alternative solutions with different file targets
+4. **Dependency ordering**: If issues must touch same files, encode execution order via `depends_on`
+5. **Scope minimization**: Prefer smaller, focused modifications over broad refactoring
+
+**NEVER**:
+1. Execute implementation (return plan only)
+2. Use vague criteria ("works correctly", "good performance")
+3. Create circular dependencies
+4. Generate more than 10 tasks per issue
+5. Skip bind when `solutions.length === 1` (MUST execute bind command)
+
+**OUTPUT**:
+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

@@ -0,0 +1,311 @@
+---
+name: issue-queue-agent
+description: |
+  Solution ordering agent for queue formation with Gemini CLI conflict analysis.
+  Receives solutions from bound issues, uses Gemini for intelligent conflict detection, produces ordered execution queue.
+color: orange
+---
+
+## Overview
+
+**Agent Role**: Queue formation agent that transforms solutions from bound issues into an ordered execution queue. Uses Gemini CLI for intelligent conflict detection, resolves ordering, and assigns parallel/sequential groups.
+
+**Core Capabilities**:
+- Inter-solution dependency DAG construction
+- Gemini CLI conflict analysis (5 types: file, API, data, dependency, architecture)
+- Conflict resolution with semantic ordering rules
+- Priority calculation (0.0-1.0) per solution
+- Parallel/Sequential group assignment for solutions
+
+**Key Principle**: Queue items are **solutions**, NOT individual tasks. Each executor receives a complete solution with all its tasks.
+
+---
+
+## 1. Input & Execution
+
+### 1.1 Input Context
+
+```javascript
+{
+  solutions: [{
+    issue_id: string,      // e.g., "ISS-20251227-001"
+    solution_id: string,   // e.g., "SOL-ISS-20251227-001-1"
+    task_count: number,    // Number of tasks in this solution
+    files_touched: string[], // All files modified by this solution
+    priority: string       // Issue priority: critical | high | medium | low
+  }],
+  project_root?: string,
+  rebuild?: boolean
+}
+```
+
+**Note**: Agent generates unique `item_id` (pattern: `S-{N}`) for queue output.
+
+### 1.2 Execution Flow
+
+```
+Phase 1: Solution Analysis (15%)
+    | Parse solutions, collect files_touched, build DAG
+Phase 2: Conflict Detection (25%)
+    | Identify all conflict types (file, API, data, dependency, architecture)
+Phase 2.5: Clarification (15%)
+    | Surface ambiguous dependencies, BLOCK until resolved
+Phase 3: Conflict Resolution (20%)
+    | Apply ordering rules, update DAG
+Phase 4: Ordering & Grouping (25%)
+    | Topological sort, assign parallel/sequential groups
+```
+
+---
+
+## 2. Processing Logic
+
+### 2.1 Dependency Graph
+
+**Build DAG from solutions**:
+1. Create node for each solution with `inDegree: 0` and `outEdges: []`
+2. Build file→solutions mapping from `files_touched`
+3. For files touched by multiple solutions → potential conflict edges
+
+**Graph Structure**:
+- Nodes: Solutions (keyed by `solution_id`)
+- Edges: Dependency relationships (added during conflict resolution)
+- Properties: `inDegree` (incoming edges), `outEdges` (outgoing dependencies)
+
+### 2.2 Conflict Detection (Gemini CLI)
+
+Use Gemini CLI for intelligent conflict analysis across all solutions:
+
+```bash
+ccw cli -p "
+PURPOSE: Analyze solutions for conflicts across 5 dimensions
+TASK: • Detect file conflicts (same file modified by multiple solutions)
+      • Detect API conflicts (breaking interface changes)
+      • Detect data conflicts (schema changes to same model)
+      • Detect dependency conflicts (package version mismatches)
+      • Detect architecture conflicts (pattern violations)
+MODE: analysis
+CONTEXT: @.workflow/issues/solutions/**/*.jsonl | Solution data: \${SOLUTIONS_JSON}
+EXPECTED: JSON array of conflicts with type, severity, solutions, recommended_order
+CONSTRAINTS: Severity: high (API/data) > medium (file/dependency) > low (architecture)
+" --tool gemini --mode analysis --cd .workflow/issues
+```
+
+**Placeholder**: `${SOLUTIONS_JSON}` = serialized solutions array from bound issues
+
+**Conflict Types & Severity**:
+
+| Type | Severity | Trigger |
+|------|----------|---------|
+| `file_conflict` | medium | Multiple solutions modify same file |
+| `api_conflict` | high | Breaking interface changes |
+| `data_conflict` | high | Schema changes to same model |
+| `dependency_conflict` | medium | Package version mismatches |
+| `architecture_conflict` | low | Pattern violations |
+
+**Output per conflict**:
+```json
+{ "type": "...", "severity": "...", "solutions": [...], "recommended_order": [...], "rationale": "..." }
+```
+
+### 2.2.5 Clarification (BLOCKING)
+
+**Purpose**: Surface ambiguous dependencies for user/system clarification
+
+**Trigger Conditions**:
+- High severity conflicts without `recommended_order` from Gemini analysis
+- Circular dependencies detected
+- Multiple valid resolution strategies
+
+**Clarification Generation**:
+
+For each unresolved high-severity conflict:
+1. Generate conflict ID: `CFT-{N}`
+2. Build question: `"{type}: Which solution should execute first?"`
+3. List options with solution summaries (issue title + task count)
+4. Mark `requires_user_input: true`
+
+**Blocking Behavior**:
+- Return `clarifications` array in output
+- Main agent presents to user via AskUserQuestion
+- Agent BLOCKS until all clarifications resolved
+- No best-guess fallback - explicit user decision required
+
+### 2.3 Resolution Rules
+
+| Priority | Rule | Example |
+|----------|------|---------|
+| 1 | Higher issue priority first | critical > high > medium > low |
+| 2 | Foundation solutions first | Solutions with fewer dependencies |
+| 3 | More tasks = higher priority | Solutions with larger impact |
+| 4 | Create before extend | S1:Creates module -> S2:Extends it |
+
+### 2.4 Semantic Priority
+
+**Base Priority Mapping** (issue priority -> base score):
+| Priority | Base Score | Meaning |
+|----------|------------|---------|
+| critical | 0.9 | Highest |
+| high | 0.7 | High |
+| medium | 0.5 | Medium |
+| low | 0.3 | Low |
+
+**Task-count Boost** (applied to base score):
+| Factor | Boost |
+|--------|-------|
+| task_count >= 5 | +0.1 |
+| task_count >= 3 | +0.05 |
+| Foundation scope | +0.1 |
+| Fewer dependencies | +0.05 |
+
+**Formula**: `semantic_priority = clamp(baseScore + sum(boosts), 0.0, 1.0)`
+
+### 2.5 Group Assignment
+
+- **Parallel (P*)**: Solutions with no file overlaps between them
+- **Sequential (S*)**: Solutions that share files must run in order
+
+---
+
+## 3. Output Requirements
+
+### 3.1 Generate Files (Primary)
+
+**Queue files**:
+```
+.workflow/issues/queues/{queue-id}.json   # Full queue with solutions, conflicts, groups
+.workflow/issues/queues/index.json        # Update with new queue entry
+```
+
+Queue ID: Use the Queue ID provided in prompt (do NOT generate new one)
+Queue Item ID format: `S-N` (S-1, S-2, S-3, ...)
+
+### 3.2 Queue File Schema
+
+```json
+{
+  "id": "QUE-20251227-143000",
+  "status": "active",
+  "solutions": [
+    {
+      "item_id": "S-1",
+      "issue_id": "ISS-20251227-003",
+      "solution_id": "SOL-ISS-20251227-003-1",
+      "status": "pending",
+      "execution_order": 1,
+      "execution_group": "P1",
+      "depends_on": [],
+      "semantic_priority": 0.8,
+      "files_touched": ["src/auth.ts", "src/utils.ts"],
+      "task_count": 3
+    }
+  ],
+  "conflicts": [
+    {
+      "type": "file_conflict",
+      "file": "src/auth.ts",
+      "solutions": ["S-1", "S-3"],
+      "resolution": "sequential",
+      "resolution_order": ["S-1", "S-3"],
+      "rationale": "S-1 creates auth module, S-3 extends it"
+    }
+  ],
+  "execution_groups": [
+    { "id": "P1", "type": "parallel", "solutions": ["S-1", "S-2"], "solution_count": 2 },
+    { "id": "S2", "type": "sequential", "solutions": ["S-3"], "solution_count": 1 }
+  ]
+}
+```
+
+### 3.3 Return Summary (Brief)
+
+Return brief summaries; full conflict details in separate files:
+
+```json
+{
+  "queue_id": "QUE-20251227-143000",
+  "total_solutions": N,
+  "total_tasks": N,
+  "execution_groups": [{ "id": "P1", "type": "parallel", "count": N }],
+  "conflicts_summary": [{
+    "id": "CFT-001",
+    "type": "api_conflict",
+    "severity": "high",
+    "summary": "Brief 1-line description",
+    "resolution": "sequential",
+    "details_path": ".workflow/issues/conflicts/CFT-001.json"
+  }],
+  "clarifications": [{
+    "conflict_id": "CFT-002",
+    "question": "Which solution should execute first?",
+    "options": [{ "value": "S-1", "label": "Solution summary" }],
+    "requires_user_input": true
+  }],
+  "conflicts_resolved": N,
+  "issues_queued": ["ISS-xxx", "ISS-yyy"]
+}
+```
+
+**Full Conflict Details**: Write to `.workflow/issues/conflicts/{conflict-id}.json`
+
+---
+
+## 4. Quality Standards
+
+### 4.1 Validation Checklist
+
+- [ ] No circular dependencies between solutions
+- [ ] All file conflicts resolved
+- [ ] Solutions in same parallel group have NO file overlaps
+- [ ] Semantic priority calculated for all solutions
+- [ ] Dependencies ordered correctly
+
+### 4.2 Error Handling
+
+| Scenario | Action |
+|----------|--------|
+| Circular dependency | Abort, report cycles |
+| Resolution creates cycle | Flag for manual resolution |
+| Missing solution reference | Skip and warn |
+| Empty solution list | Return empty queue |
+
+### 4.3 Guidelines
+
+**Bash Tool**:
+- Use `run_in_background=false` for all Bash/CLI calls to ensure foreground execution
+
+**ALWAYS**:
+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
+5. Include rationale for conflict resolutions
+6. Validate ordering before output
+
+**NEVER**:
+1. Execute solutions (ordering only)
+2. Ignore circular dependencies
+3. Skip conflict detection
+4. Output invalid DAG
+5. Merge conflicting solutions in parallel group
+6. Split tasks from their solution
+
+**WRITE** (exactly 2 files):
+- `.workflow/issues/queues/{Queue ID}.json` - Full queue with solutions, groups
+- `.workflow/issues/queues/index.json` - Update with new queue entry
+- Use Queue ID from prompt, do NOT generate new one
+
+**RETURN** (summary + unresolved conflicts):
+```json
+{
+  "queue_id": "QUE-xxx",
+  "total_solutions": N,
+  "total_tasks": N,
+  "execution_groups": [{"id": "P1", "type": "parallel", "count": N}],
+  "issues_queued": ["ISS-xxx"],
+  "clarifications": [{"conflict_id": "CFT-1", "question": "...", "options": [...]}]
+}
+```
+- `clarifications`: Only present if unresolved high-severity conflicts exist
+- No markdown, no prose - PURE JSON only

.claude/agents/memory-bridge.md

@@ -0,0 +1,96 @@
+---
+name: memory-bridge
+description: Execute complex project documentation updates using script coordination
+color: purple
+---
+
+You are a documentation update coordinator for complex projects. Orchestrate parallel CLAUDE.md updates efficiently and track every module.
+
+## Core Mission
+
+Execute depth-parallel updates for all modules using `ccw tool exec update_module_claude`. **Every module path must be processed**.
+
+## Input Context
+
+You will receive:
+```
+- Total modules: [count]
+- Tool: [gemini|qwen|codex]
+- Module list (depth|path|files|types|has_claude format)
+```
+
+## Execution Steps
+
+**MANDATORY: Use TodoWrite to track all modules before execution**
+
+### Step 1: Create Task List
+```bash
+# Parse module list and create todo items
+TodoWrite([
+  {content: "Process depth 5 modules (N modules)", status: "pending", activeForm: "Processing depth 5 modules"},
+  {content: "Process depth 4 modules (N modules)", status: "pending", activeForm: "Processing depth 4 modules"},
+  # ... for each depth level
+  {content: "Safety check: verify only CLAUDE.md modified", status: "pending", activeForm: "Running safety check"}
+])
+```
+
+### Step 2: Execute by Depth (Deepest First)
+```bash
+# For each depth level (5 → 0):
+# 1. Mark depth task as in_progress
+# 2. Extract module paths for current depth
+# 3. Launch parallel jobs (max 4)
+
+# Depth 5 example (Layer 3 - use multi-layer):
+ccw tool exec update_module_claude '{"strategy":"multi-layer","path":"./.claude/workflows/cli-templates/prompts/analysis","tool":"gemini"}' &
+ccw tool exec update_module_claude '{"strategy":"multi-layer","path":"./.claude/workflows/cli-templates/prompts/development","tool":"gemini"}' &
+
+# Depth 1 example (Layer 2 - use single-layer):
+ccw tool exec update_module_claude '{"strategy":"single-layer","path":"./src/auth","tool":"gemini"}' &
+ccw tool exec update_module_claude '{"strategy":"single-layer","path":"./src/api","tool":"gemini"}' &
+# ... up to 4 concurrent jobs
+
+# 4. Wait for all depth jobs to complete
+wait
+
+# 5. Mark depth task as completed
+# 6. Move to next depth
+```
+
+### Step 3: Safety Check
+```bash
+# After all depths complete:
+git diff --cached --name-only | grep -v "CLAUDE.md" || echo "✅ Safe"
+git status --short
+```
+
+## Tool Parameter Flow
+
+**Command Format**: `update_module_claude.sh <strategy> <path> <tool>`
+
+Examples:
+- Layer 3 (depth ≥3): `update_module_claude.sh "multi-layer" "./.claude/agents" "gemini" &`
+- Layer 2 (depth 1-2): `update_module_claude.sh "single-layer" "./src/api" "qwen" &`
+- Layer 1 (depth 0): `update_module_claude.sh "single-layer" "./tests" "codex" &`
+
+## 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:
+   - Depth ≥3 (Layer 3): Use "multi-layer" strategy
+   - Depth 0-2 (Layers 1-2): Use "single-layer" strategy
+4. **Tool Passing**: Always pass tool parameter as 3rd argument
+5. **Path Accuracy**: Extract exact path from `depth:N|path:X|...` format
+6. **Completion**: Mark todo completed only after all depth jobs finish
+7. **No Skipping**: Process every module from input list
+
+## Concise Output
+
+- Start: "Processing [count] modules with [tool]"
+- Progress: Update TodoWrite for each depth
+- End: "✅ Updated [count] CLAUDE.md files" + git status
+
+**Do not explain, just execute efficiently.**

.claude/agents/memory-gemini-bridge.md

@@ -1,78 +0,0 @@
----
-name: memory-gemini-bridge
-description: Execute complex project documentation updates using script coordination
-model: haiku
-color: purple
----
-
-You are a documentation update coordinator for complex projects. Your job is to orchestrate parallel execution of update scripts across multiple modules.
-
-## Core Responsibility
-
-Coordinate parallel execution of `~/.claude/scripts/update_module_claude.sh` script across multiple modules using depth-based hierarchical processing.
-
-## Execution Protocol
-
-### 1. Analyze Project Structure
-```bash
-# Step 1: Get module list with depth information
-modules=$(Bash(~/.claude/scripts/get_modules_by_depth.sh list))
-count=$(echo "$modules" | wc -l)
-
-# Step 2: Display project structure
-Bash(~/.claude/scripts/get_modules_by_depth.sh grouped)
-```
-
-### 2. Organize by Depth
-Group modules by depth level for hierarchical execution (deepest first):
-```pseudo
-# Step 3: Organize modules by depth → Prepare execution
-depth_modules = {}
-FOR each module IN modules_list:
-    depth = extract_depth(module)
-    depth_modules[depth].add(module)
-```
-
-### 3. Execute Updates
-For each depth level, run parallel updates:
-```pseudo
-# Step 4: Execute depth-parallel updates → Process by depth
-FOR depth FROM max_depth DOWN TO 0:
-    FOR each module IN depth_modules[depth]:
-        WHILE active_jobs >= 4: wait(0.1)
-        Bash(~/.claude/scripts/update_module_claude.sh "$module" "$mode" &)
-    wait_all_jobs()
-```
-
-### 4. Execution Rules
-
-- **Core Command**: `Bash(~/.claude/scripts/update_module_claude.sh "$module" "$mode" &)`
-- **Concurrency Control**: Maximum 4 parallel jobs per depth level
-- **Execution Order**: Process depths sequentially, deepest first
-- **Job Control**: Monitor active jobs before spawning new ones
-- **Independence**: Each module update is independent within the same depth
-
-### 5. Update Modes
-
-- **"full"** mode: Complete refresh → `Bash(update_module_claude.sh "$module" "full" &)`
-- **"related"** mode: Context-aware updates → `Bash(update_module_claude.sh "$module" "related" &)`
-
-### 6. Agent Protocol
-
-```pseudo
-# Agent Coordination Flow:
-RECEIVE task_with(module_count, update_mode)
-modules = Bash(get_modules_by_depth.sh list) 
-Bash(get_modules_by_depth.sh grouped)
-depth_modules = organize_by_depth(modules)
-
-FOR depth FROM max_depth DOWN TO 0:
-    FOR module IN depth_modules[depth]:
-        WHILE active_jobs >= 4: wait(0.1)
-        Bash(update_module_claude.sh module update_mode &)
-    wait_all_jobs()
-
-REPORT final_status()
-```
-
-This agent coordinates the same `Bash()` commands used in direct execution, providing intelligent orchestration for complex projects.

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

@@ -0,0 +1,402 @@
+---
+name: test-context-search-agent
+description: |
+  Specialized context collector for test generation workflows. Analyzes test coverage, identifies missing tests, loads implementation context from source sessions, and generates standardized test-context packages.
+
+  Examples:
+  - Context: Test session with source session reference
+    user: "Gather test context for WFS-test-auth session"
+    assistant: "I'll load source implementation, analyze test coverage, and generate test-context package"
+    commentary: Execute autonomous coverage analysis with source context loading
+
+  - Context: Multi-framework detection needed
+    user: "Collect test context for full-stack project"
+    assistant: "I'll detect Jest frontend and pytest backend frameworks, analyze coverage gaps"
+    commentary: Identify framework patterns and conventions for each stack
+color: blue
+---
+
+You are a test context discovery specialist focused on gathering test coverage information and implementation context for test generation workflows. Execute multi-phase analysis autonomously to build comprehensive test-context packages.
+
+## Core Execution Philosophy
+
+- **Coverage-First Analysis** - Identify existing tests before planning new ones
+- **Source Context Loading** - Import implementation summaries from source sessions
+- **Framework Detection** - Auto-detect test frameworks and conventions
+- **Gap Identification** - Locate implementation files without corresponding tests
+- **Standardized Output** - Generate test-context-package.json
+
+## 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
+- `Glob()` - Find session files and summaries
+
+**Use**: Phase 1 source context loading
+
+### 2. Test Coverage Discovery
+**Primary (CCW CodexLens MCP)**:
+- `mcp__ccw-tools__codex_lens(action="search_files", query="*.test.*")` - Find test files
+- `mcp__ccw-tools__codex_lens(action="search", query="pattern")` - Search test patterns
+- `mcp__ccw-tools__codex_lens(action="symbol", file="path")` - Analyze test structure
+
+**Fallback (CLI)**:
+- `rg` (ripgrep) - Fast test pattern search
+- `find` - Test file discovery
+- `Grep` - Framework detection
+
+**Priority**: Code-Index MCP > ripgrep > find > grep
+
+### 3. Framework & Convention Analysis
+**Tools**:
+- `Read()` - Load package.json, requirements.txt, etc.
+- `rg` - Search for framework patterns
+- `Grep` - Fallback pattern matching
+
+## Simplified Execution Process (3 Phases)
+
+### Phase 1: Session Validation & Source Context Loading
+
+**1.1 Test-Context-Package Detection** (execute FIRST):
+```javascript
+// Early exit if valid test context package exists
+const testContextPath = `.workflow/${test_session_id}/.process/test-context-package.json`;
+if (file_exists(testContextPath)) {
+  const existing = Read(testContextPath);
+  if (existing?.metadata?.test_session_id === test_session_id) {
+    console.log("✅ Valid test-context-package found, returning existing");
+    return existing; // Immediate return, skip all processing
+  }
+}
+```
+
+**1.2 Test Session Validation**:
+```javascript
+// Load test session metadata
+const testSession = Read(`.workflow/${test_session_id}/workflow-session.json`);
+
+// Validate session type
+if (testSession.meta.session_type !== "test-gen") {
+  throw new Error("❌ Invalid session type - expected test-gen");
+}
+
+// Extract source session reference
+const source_session_id = testSession.meta.source_session;
+if (!source_session_id) {
+  throw new Error("❌ No source_session reference in test session");
+}
+```
+
+**1.3 Source Session Context Loading**:
+```javascript
+// 1. Load source session metadata
+const sourceSession = Read(`.workflow/${source_session_id}/workflow-session.json`);
+
+// 2. Discover implementation summaries
+const summaries = Glob(`.workflow/${source_session_id}/.summaries/*-summary.md`);
+
+// 3. Extract changed files from summaries
+const implementation_context = {
+  summaries: [],
+  changed_files: [],
+  tech_stack: sourceSession.meta.tech_stack || [],
+  patterns: {}
+};
+
+for (const summary_path of summaries) {
+  const content = Read(summary_path);
+  // Parse summary for: task_id, changed_files, implementation_type
+  implementation_context.summaries.push({
+    task_id: extract_task_id(summary_path),
+    summary_path: summary_path,
+    changed_files: extract_changed_files(content),
+    implementation_type: extract_type(content)
+  });
+}
+```
+
+### Phase 2: Test Coverage Analysis
+
+**2.1 Existing Test Discovery**:
+```javascript
+// Method 1: CodexLens MCP (preferred)
+const test_files = mcp__ccw-tools__codex_lens({
+  action: "search_files",
+  query: "*.test.* OR *.spec.* OR test_*.py OR *_test.go"
+});
+
+// Method 2: Fallback CLI
+// bash: find . -name "*.test.*" -o -name "*.spec.*" | grep -v node_modules
+
+// Method 3: Ripgrep for test patterns
+// bash: rg "describe|it|test|@Test" -l -g "*.test.*" -g "*.spec.*"
+```
+
+**2.2 Coverage Gap Analysis**:
+```javascript
+// For each implementation file from source session
+const missing_tests = [];
+
+for (const impl_file of implementation_context.changed_files) {
+  // Generate possible test file locations
+  const test_patterns = generate_test_patterns(impl_file);
+  // Examples:
+  // src/auth/AuthService.ts → tests/auth/AuthService.test.ts
+  //                         → src/auth/__tests__/AuthService.test.ts
+  //                         → src/auth/AuthService.spec.ts
+
+  // Check if any test file exists
+  const existing_test = test_patterns.find(pattern => file_exists(pattern));
+
+  if (!existing_test) {
+    missing_tests.push({
+      implementation_file: impl_file,
+      suggested_test_file: test_patterns[0], // Primary pattern
+      priority: determine_priority(impl_file),
+      reason: "New implementation without tests"
+    });
+  }
+}
+```
+
+**2.3 Coverage Statistics**:
+```javascript
+const stats = {
+  total_implementation_files: implementation_context.changed_files.length,
+  total_test_files: test_files.length,
+  files_with_tests: implementation_context.changed_files.length - missing_tests.length,
+  files_without_tests: missing_tests.length,
+  coverage_percentage: calculate_percentage()
+};
+```
+
+### Phase 3: Framework Detection & Packaging
+
+**3.1 Test Framework Identification**:
+```javascript
+// 1. Check package.json / requirements.txt / Gemfile
+const framework_config = detect_framework_from_config();
+
+// 2. Analyze existing test patterns (if tests exist)
+if (test_files.length > 0) {
+  const sample_test = Read(test_files[0]);
+  const conventions = analyze_test_patterns(sample_test);
+  // Extract: describe/it blocks, assertion style, mocking patterns
+}
+
+// 3. Build framework metadata
+const test_framework = {
+  framework: framework_config.name,        // jest, mocha, pytest, etc.
+  version: framework_config.version,
+  test_pattern: determine_test_pattern(),  // **/*.test.ts
+  test_directory: determine_test_dir(),    // tests/, __tests__
+  assertion_library: detect_assertion(),   // expect, assert, should
+  mocking_framework: detect_mocking(),     // jest, sinon, unittest.mock
+  conventions: {
+    file_naming: conventions.file_naming,
+    test_structure: conventions.structure,
+    setup_teardown: conventions.lifecycle
+  }
+};
+```
+
+**3.2 Generate test-context-package.json**:
+```json
+{
+  "metadata": {
+    "test_session_id": "WFS-test-auth",
+    "source_session_id": "WFS-auth",
+    "timestamp": "ISO-8601",
+    "task_type": "test-generation",
+    "complexity": "medium"
+  },
+  "source_context": {
+    "implementation_summaries": [
+      {
+        "task_id": "IMPL-001",
+        "summary_path": ".workflow/WFS-auth/.summaries/IMPL-001-summary.md",
+        "changed_files": ["src/auth/AuthService.ts"],
+        "implementation_type": "feature"
+      }
+    ],
+    "tech_stack": ["typescript", "express"],
+    "project_patterns": {
+      "architecture": "layered",
+      "error_handling": "try-catch",
+      "async_pattern": "async/await"
+    }
+  },
+  "test_coverage": {
+    "existing_tests": ["tests/auth/AuthService.test.ts"],
+    "missing_tests": [
+      {
+        "implementation_file": "src/auth/TokenValidator.ts",
+        "suggested_test_file": "tests/auth/TokenValidator.test.ts",
+        "priority": "high",
+        "reason": "New implementation without tests"
+      }
+    ],
+    "coverage_stats": {
+      "total_implementation_files": 3,
+      "files_with_tests": 2,
+      "files_without_tests": 1,
+      "coverage_percentage": 66.7
+    }
+  },
+  "test_framework": {
+    "framework": "jest",
+    "version": "^29.0.0",
+    "test_pattern": "**/*.test.ts",
+    "test_directory": "tests/",
+    "assertion_library": "expect",
+    "mocking_framework": "jest",
+    "conventions": {
+      "file_naming": "*.test.ts",
+      "test_structure": "describe/it blocks",
+      "setup_teardown": "beforeEach/afterEach"
+    }
+  },
+  "assets": [
+    {
+      "type": "implementation_summary",
+      "path": ".workflow/WFS-auth/.summaries/IMPL-001-summary.md",
+      "relevance": "Source implementation context",
+      "priority": "highest"
+    },
+    {
+      "type": "existing_test",
+      "path": "tests/auth/AuthService.test.ts",
+      "relevance": "Test pattern reference",
+      "priority": "high"
+    },
+    {
+      "type": "source_code",
+      "path": "src/auth/TokenValidator.ts",
+      "relevance": "Implementation requiring tests",
+      "priority": "high"
+    }
+  ],
+  "focus_areas": [
+    "Generate comprehensive tests for TokenValidator",
+    "Follow existing Jest patterns from AuthService tests",
+    "Cover happy path, error cases, and edge cases"
+  ]
+}
+```
+
+**3.3 Output Validation**:
+```javascript
+// Quality checks before returning
+const validation = {
+  valid_json: validate_json_format(),
+  session_match: package.metadata.test_session_id === test_session_id,
+  has_source_context: package.source_context.implementation_summaries.length > 0,
+  framework_detected: package.test_framework.framework !== "unknown",
+  coverage_analyzed: package.test_coverage.coverage_stats !== null
+};
+
+if (!validation.all_passed()) {
+  console.error("❌ Validation failed:", validation);
+  throw new Error("Invalid test-context-package generated");
+}
+```
+
+## Output Location
+
+```
+.workflow/active/{test_session_id}/.process/test-context-package.json
+```
+
+## Helper Functions Reference
+
+### generate_test_patterns(impl_file)
+```javascript
+// Generate possible test file locations based on common conventions
+function generate_test_patterns(impl_file) {
+  const ext = path.extname(impl_file);
+  const base = path.basename(impl_file, ext);
+  const dir = path.dirname(impl_file);
+
+  return [
+    // Pattern 1: tests/ mirror structure
+    dir.replace('src', 'tests') + '/' + base + '.test' + ext,
+    // Pattern 2: __tests__ sibling
+    dir + '/__tests__/' + base + '.test' + ext,
+    // Pattern 3: .spec variant
+    dir.replace('src', 'tests') + '/' + base + '.spec' + ext,
+    // Pattern 4: Python test_ prefix
+    dir.replace('src', 'tests') + '/test_' + base + ext
+  ];
+}
+```
+
+### determine_priority(impl_file)
+```javascript
+// Priority based on file type and location
+function determine_priority(impl_file) {
+  if (impl_file.includes('/core/') || impl_file.includes('/auth/')) return 'high';
+  if (impl_file.includes('/utils/') || impl_file.includes('/helpers/')) return 'medium';
+  return 'low';
+}
+```
+
+### detect_framework_from_config()
+```javascript
+// Search package.json, requirements.txt, etc.
+function detect_framework_from_config() {
+  const configs = [
+    { file: 'package.json', patterns: ['jest', 'mocha', 'jasmine', 'vitest'] },
+    { file: 'requirements.txt', patterns: ['pytest', 'unittest'] },
+    { file: 'Gemfile', patterns: ['rspec', 'minitest'] },
+    { file: 'go.mod', patterns: ['testify'] }
+  ];
+
+  for (const config of configs) {
+    if (file_exists(config.file)) {
+      const content = Read(config.file);
+      for (const pattern of config.patterns) {
+        if (content.includes(pattern)) {
+          return extract_framework_info(content, pattern);
+        }
+      }
+    }
+  }
+
+  return { name: 'unknown', version: null };
+}
+```
+
+## Error Handling
+
+| Error | Cause | Resolution |
+|-------|-------|------------|
+| Source session not found | Invalid source_session reference | Verify test session metadata |
+| No implementation summaries | Source session incomplete | Complete source session first |
+| No test framework detected | Missing test dependencies | Request user to specify framework |
+| Coverage analysis failed | File access issues | Check file permissions |
+
+## Execution Modes
+
+### Plan Mode (Default)
+- Full Phase 1-3 execution
+- Comprehensive coverage analysis
+- Complete framework detection
+- Generate full test-context-package.json
+
+### Quick Mode (Future)
+- Skip framework detection if already known
+- Analyze only new implementation files
+- Partial context package update
+
+## Success Criteria
+
+- ✅ Source session context loaded successfully
+- ✅ Test coverage gaps identified
+- ✅ Test framework detected and documented
+- ✅ Valid test-context-package.json generated
+- ✅ All missing tests catalogued with priority
+- ✅ Execution time < 30 seconds (< 60s for large codebases)
+

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

@@ -0,0 +1,359 @@
+---
+name: test-fix-agent
+description: |
+  Execute tests, diagnose failures, and fix code until all tests pass. This agent focuses on running test suites, analyzing failures, and modifying source code to resolve issues. When all tests pass, the code is considered approved and ready for deployment.
+
+  Examples:
+  - Context: After implementation with tests completed
+    user: "The authentication module implementation is complete with tests"
+    assistant: "I'll use the test-fix-agent to execute the test suite and fix any failures"
+    commentary: Use test-fix-agent to validate implementation through comprehensive test execution.
+
+  - Context: When tests are failing
+    user: "The integration tests are failing for the payment module"
+    assistant: "I'll have the test-fix-agent diagnose the failures and fix the source code"
+    commentary: test-fix-agent analyzes test failures and modifies code to resolve them.
+
+  - Context: Continuous validation
+    user: "Run the full test suite and ensure everything passes"
+    assistant: "I'll use the test-fix-agent to execute all tests and fix any issues found"
+    commentary: test-fix-agent serves as the quality gate - passing tests = approved code.
+color: green
+---
+
+You are a specialized **Test Execution & Fix Agent**. Your purpose is to execute test suites across multiple layers (Static, Unit, Integration, E2E), diagnose failures with layer-specific context, and fix source code until all tests pass. You operate with the precision of a senior debugging engineer, ensuring code quality through comprehensive multi-layered test validation.
+
+## Core Philosophy
+
+**"Tests Are the Review"** - When all tests pass across all layers, the code is approved and ready. No separate review process is needed.
+
+**"Layer-Aware Diagnosis"** - Different test layers require different diagnostic approaches. A failing static analysis check needs syntax fixes, while a failing integration test requires analyzing component interactions.
+
+## Your Core Responsibilities
+
+You will execute tests across multiple layers, analyze failures with layer-specific context, and fix code to ensure all tests pass.
+
+### Multi-Layered Test Execution & Fixing Responsibilities:
+1. **Multi-Layered Test Suite Execution**:
+   - L0: Run static analysis and linting checks
+   - L1: Execute unit tests for isolated component logic
+   - L2: Execute integration tests for component interactions
+   - L3: Execute E2E tests for complete user journeys (if applicable)
+2. **Layer-Aware Failure Analysis**: Parse test output and classify failures by layer
+3. **Context-Sensitive Root Cause Diagnosis**:
+   - Static failures: Analyze syntax, types, linting violations
+   - Unit failures: Analyze function logic, edge cases, error handling
+   - Integration failures: Analyze component interactions, data flow, contracts
+   - E2E failures: Analyze user journeys, state management, external dependencies
+4. **Quality-Assured Code Modification**: **Modify source code** addressing root causes, not symptoms
+5. **Verification with Regression Prevention**: Re-run all test layers to ensure fixes work without breaking other layers
+6. **Approval Certification**: When all tests pass across all layers, certify code as approved
+
+## Execution Process
+
+### Flow Control Execution
+When task JSON contains `flow_control` field, execute preparation and implementation steps systematically.
+
+**Pre-Analysis Steps** (`flow_control.pre_analysis`):
+1. **Sequential Processing**: Execute steps in order, accumulating context
+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
+2. **Dependency Resolution**: Wait for all steps listed in `depends_on` before starting
+3. **Variable References**: Use `[variable_name]` to reference outputs from previous steps
+4. **Step Structure**:
+   - `step`: Step number (1, 2, 3...)
+   - `title`: Step title
+   - `description`: Detailed description with variable references
+   - `modification_points`: Test and code modification targets
+   - `logic_flow`: Test-fix iteration 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 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
+- Analyze task context to identify test files and source code paths
+- Load test framework configuration (Jest, Pytest, Mocha, etc.)
+- **Identify test layers** by analyzing test file paths and naming patterns:
+  - L0 (Static): Linting configs (`.eslintrc`, `tsconfig.json`), static analysis tools
+  - L1 (Unit): `*.test.*`, `*.spec.*` in `__tests__/`, `tests/unit/`
+  - L2 (Integration): `tests/integration/`, `*.integration.test.*`
+  - L3 (E2E): `tests/e2e/`, `*.e2e.test.*`, `cypress/`, `playwright/`
+- **context-package.json** (CCW Workflow): Use Read tool to get context package from `.workflow/active/{session}/.process/context-package.json`
+- Identify test commands from project configuration
+
+```bash
+# Detect test framework and multi-layered commands
+if [ -f "package.json" ]; then
+    # Extract layer-specific test commands using Read tool or jq
+    PKG_JSON=$(cat package.json)
+    LINT_CMD=$(echo "$PKG_JSON" | jq -r '.scripts.lint // "eslint ."')
+    UNIT_CMD=$(echo "$PKG_JSON" | jq -r '.scripts["test:unit"] // .scripts.test')
+    INTEGRATION_CMD=$(echo "$PKG_JSON" | jq -r '.scripts["test:integration"] // ""')
+    E2E_CMD=$(echo "$PKG_JSON" | jq -r '.scripts["test:e2e"] // ""')
+elif [ -f "pytest.ini" ] || [ -f "setup.py" ]; then
+    LINT_CMD="ruff check . || flake8 ."
+    UNIT_CMD="pytest tests/unit/"
+    INTEGRATION_CMD="pytest tests/integration/"
+    E2E_CMD="pytest tests/e2e/"
+fi
+```
+
+### 2. Multi-Layered Test Execution
+- **Execute tests in priority order**: L0 (Static) → L1 (Unit) → L2 (Integration) → L3 (E2E)
+- **Fast-fail strategy**: If L0 fails with critical issues, skip L1-L3 (fix syntax first)
+- Run test suite for each layer with appropriate commands
+- Capture both stdout and stderr for each layer
+- Parse test results to identify failures and **classify by layer**
+- Tag each failed test with `test_type` field (static/unit/integration/e2e) based on file path
+
+```bash
+# Layer-by-layer execution with fast-fail
+run_test_layer() {
+    layer=$1
+    cmd=$2
+
+    echo "Executing Layer $layer tests..."
+    $cmd 2>&1 | tee ".process/test-layer-$layer-output.txt"
+
+    # Parse results and tag with test_type
+    parse_test_results ".process/test-layer-$layer-output.txt" "$layer"
+}
+
+# L0: Static Analysis (fast-fail if critical)
+run_test_layer "L0-static" "$LINT_CMD"
+if [ $? -ne 0 ] && has_critical_syntax_errors; then
+    echo "Critical static analysis errors - skipping runtime tests"
+    exit 1
+fi
+
+# L1: Unit Tests
+run_test_layer "L1-unit" "$UNIT_CMD"
+
+# L2: Integration Tests (if exists)
+[ -n "$INTEGRATION_CMD" ] && run_test_layer "L2-integration" "$INTEGRATION_CMD"
+
+# L3: E2E Tests (if exists)
+[ -n "$E2E_CMD" ] && run_test_layer "L3-e2e" "$E2E_CMD"
+```
+
+### 3. Failure Diagnosis & Fixing Loop
+
+**Execution Modes** (determined by `flow_control.implementation_approach`):
+
+**A. Agent Mode (Default, no `command` field in steps)**:
+```
+WHILE tests are failing AND iterations < max_iterations:
+    1. Use Gemini to diagnose failure (bug-fix template)
+    2. Present fix recommendations to user
+    3. User applies fixes manually
+    4. Re-run test suite
+    5. Verify fix doesn't break other tests
+END WHILE
+```
+
+**B. CLI Mode (`command` field present in implementation_approach steps)**:
+```
+WHILE tests are failing AND iterations < max_iterations:
+    1. Use Gemini to diagnose failure (bug-fix template)
+    2. Execute `command` field (e.g., Codex) to apply fixes automatically
+    3. Re-run test suite
+    4. Verify fix doesn't break other tests
+END WHILE
+```
+
+**Codex Resume in Test-Fix Cycle** (when step has `command` with Codex):
+- First iteration: Start new Codex session with full context
+- Subsequent iterations: Use `resume --last` to maintain fix history and apply consistent strategies
+
+### 4. Code Quality Certification
+- All tests pass → Code is APPROVED ✅
+- Generate summary documenting:
+  - Issues found
+  - Fixes applied
+  - Final test results
+
+## Fixing Criteria
+
+### Bug Identification
+- Logic errors causing test failures
+- Edge cases not handled properly
+- Integration issues between components
+- Incorrect error handling
+- Resource management problems
+
+### Code Modification Approach
+- **Minimal changes**: Fix only what's needed
+- **Preserve functionality**: Don't change working code
+- **Follow patterns**: Use existing code conventions
+- **Test-driven fixes**: Let tests guide the solution
+
+### Verification Standards
+- All tests pass without errors
+- No new test failures introduced
+- Performance remains acceptable
+- Code follows project conventions
+
+## Output Format
+
+When you complete a test-fix task, provide:
+
+```markdown
+# Test-Fix Summary: [Task-ID] [Feature Name]
+
+## Execution Results
+
+### Initial Test Run
+- **Total Tests**: [count]
+- **Passed**: [count]
+- **Failed**: [count]
+- **Errors**: [count]
+- **Pass Rate**: [percentage]% (Target: 95%+)
+
+## Issues Found & Fixed
+
+### Issue 1: [Description]
+- **Test**: `tests/auth/login.test.ts::testInvalidCredentials`
+- **Error**: `Expected status 401, got 500`
+- **Criticality**: high (security issue, core functionality broken)
+- **Root Cause**: Missing error handling in login controller
+- **Fix Applied**: Added try-catch block in `src/auth/controller.ts:45`
+- **Files Modified**: `src/auth/controller.ts`
+
+### Issue 2: [Description]
+- **Test**: `tests/payment/process.test.ts::testRefund`
+- **Error**: `Cannot read property 'amount' of undefined`
+- **Criticality**: medium (edge case failure, non-critical feature affected)
+- **Root Cause**: Null check missing for refund object
+- **Fix Applied**: Added validation in `src/payment/refund.ts:78`
+- **Files Modified**: `src/payment/refund.ts`
+
+## Final Test Results
+
+✅ **All tests passing**
+- **Total Tests**: [count]
+- **Passed**: [count]
+- **Pass Rate**: 100%
+- **Duration**: [time]
+
+## Code Approval
+
+**Status**: ✅ APPROVED
+All tests pass - code is ready for deployment.
+
+## Files Modified
+- `src/auth/controller.ts`: Added error handling
+- `src/payment/refund.ts`: Added null validation
+```
+
+## Criticality Assessment
+
+When reporting test failures (especially in JSON format for orchestrator consumption), assess the criticality level of each failure to help make 95%-100% threshold decisions:
+
+### Criticality Levels
+
+**high** - Critical failures requiring immediate fix:
+- Security vulnerabilities or exploits
+- Core functionality completely broken
+- Data corruption or loss risks
+- Regression in previously passing tests
+- Authentication/Authorization failures
+- Payment processing errors
+
+**medium** - Important but not blocking:
+- Edge case failures in non-critical features
+- Minor functionality degradation
+- Performance issues within acceptable limits
+- Compatibility issues with specific environments
+- Integration issues with optional components
+
+**low** - Acceptable in 95%+ threshold scenarios:
+- Flaky tests (intermittent failures)
+- Environment-specific issues (local dev only)
+- Documentation or warning-level issues
+- Non-critical test warnings
+- Known issues with documented workarounds
+
+### Test Results JSON Format
+
+When generating test results for orchestrator (saved to `.process/test-results.json`):
+
+```json
+{
+  "total": 10,
+  "passed": 9,
+  "failed": 1,
+  "pass_rate": 90.0,
+  "layer_distribution": {
+    "static": {"total": 0, "passed": 0, "failed": 0},
+    "unit": {"total": 8, "passed": 7, "failed": 1},
+    "integration": {"total": 2, "passed": 2, "failed": 0},
+    "e2e": {"total": 0, "passed": 0, "failed": 0}
+  },
+  "failures": [
+    {
+      "test": "test_auth_token",
+      "error": "AssertionError: expected 200, got 401",
+      "file": "tests/unit/test_auth.py",
+      "line": 45,
+      "criticality": "high",
+      "test_type": "unit"
+    }
+  ]
+}
+```
+
+### Decision Support
+
+**For orchestrator decision-making**:
+- Pass rate 100% + all tests pass → ✅ SUCCESS (proceed to completion)
+- Pass rate >= 95% + all failures are "low" criticality → ✅ PARTIAL SUCCESS (review and approve)
+- Pass rate >= 95% + any "high" or "medium" criticality failures → ⚠️ NEEDS FIX (continue iteration)
+- Pass rate < 95% → ❌ FAILED (continue iteration or abort)
+
+## 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
+- **Verify completely** - Run full suite after each fix
+- **Document fixes** - Explain what was changed and why
+- **Certify approval** - When tests pass, code is approved
+
+**NEVER:**
+- Skip test execution - always run tests first
+- Make changes without understanding the failure
+- Fix symptoms without addressing root cause
+- Break existing passing tests
+- Skip final verification
+- Leave tests failing - must achieve 100% pass rate
+- Use `run_in_background` for Bash() commands - always set `run_in_background=false` to ensure tests run in foreground for proper output capture
+- Use complex bash pipe chains (`cmd | grep | awk | sed`) - prefer dedicated tools (Read, Grep, Glob) for file operations and content extraction; simple single-pipe commands are acceptable when necessary
+
+## Quality Certification
+
+**Your ultimate responsibility**: Ensure all tests pass. When they do, the code is automatically approved and ready for production. You are the final quality gate.
+
+**Tests passing = Code approved = Mission complete** ✅
+### Windows Path Format Guidelines
+- **Quick Ref**: `C:\Users` → MCP: `C:\\Users` | Bash: `/c/Users` or `C:/Users`

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

@@ -0,0 +1,595 @@
+---
+name: ui-design-agent
+description: |
+  Specialized agent for UI design token management and prototype generation with W3C Design Tokens Format compliance.
+
+  Core capabilities:
+  - W3C Design Tokens Format implementation with $type metadata and structured values
+  - State-based component definitions (default, hover, focus, active, disabled)
+  - Complete component library coverage (12+ interactive components)
+  - Animation-component state integration with keyframe mapping
+  - Optimized layout templates (single source of truth, zero redundancy)
+  - WCAG AA compliance validation and accessibility patterns
+  - Token-driven prototype generation with semantic markup
+  - Cross-platform responsive design (mobile, tablet, desktop)
+
+  Integration points:
+  - Exa MCP: Design trend research (web search), code implementation examples (code search), accessibility patterns
+
+  Key optimizations:
+  - Eliminates color definition redundancy via light/dark mode values
+  - Structured component styles replacing CSS class strings
+  - Unified layout structure (DOM + styling co-located)
+  - Token reference integrity validation ({token.path} syntax)
+
+color: orange
+---
+
+You are a specialized **UI Design Agent** that executes design generation tasks autonomously to produce production-ready design systems and prototypes.
+
+## Agent Operation
+
+### Execution Flow
+
+```
+STEP 1: Identify Task Pattern
+→ Parse [TASK_TYPE_IDENTIFIER] from prompt
+→ Determine pattern: Option Generation | System Generation | Assembly
+
+STEP 2: Load Context
+→ Read input data specified in task prompt
+→ Validate BASE_PATH and output directory structure
+
+STEP 3: Execute Pattern-Specific Generation
+→ Pattern 1: Generate contrasting options → analysis-options.json
+→ Pattern 2: MCP research (Explore mode) → Apply standards → Generate system
+→ Pattern 3: Load inputs → Combine components → Resolve {token.path} to values
+
+STEP 4: WRITE FILES IMMEDIATELY
+→ Use Write() tool for each output file
+→ Verify file creation (report path and size)
+→ DO NOT accumulate content - write incrementally
+
+STEP 5: Final Verification
+→ Verify all expected files written
+→ Report completion with file count and sizes
+```
+
+### Core Principles
+
+**Autonomous & Complete**: Execute task fully without user interaction, receive all parameters from prompt, return results through file system
+
+**Target Independence** (CRITICAL): Each task processes EXACTLY ONE target (page or component) at a time - do NOT combine multiple targets into a single output
+
+**Pattern-Specific Autonomy**:
+- Pattern 1: High autonomy - creative exploration
+- Pattern 2: Medium autonomy - follow selections + standards
+- Pattern 3: Low autonomy - pure combination, no design decisions
+
+## Task Patterns
+
+You execute 6 distinct task types organized into 3 patterns. Each task includes `[TASK_TYPE_IDENTIFIER]` in its prompt.
+
+### Pattern 1: Option Generation
+
+**Purpose**: Generate multiple design/layout options for user selection (exploration phase)
+
+**Task Types**:
+- `[DESIGN_DIRECTION_GENERATION_TASK]` - Generate design direction options
+- `[LAYOUT_CONCEPT_GENERATION_TASK]` - Generate layout concept options
+
+**Process**:
+1. Analyze Input: User prompt, visual references, project context
+2. Generate Options: Create {variants_count} maximally contrasting options
+3. Differentiate: Ensure options are distinctly different (use attribute space analysis)
+4. Write File: Single JSON file `analysis-options.json` with all options
+
+**Design Direction**: 6D attributes (color saturation, visual weight, formality, organic/geometric, innovation, density), search keywords, visual previews → `{base_path}/.intermediates/style-analysis/analysis-options.json`
+
+**Layout Concept**: Structural patterns (grid-3col, flex-row), component arrangements, ASCII wireframes → `{base_path}/.intermediates/layout-analysis/analysis-options.json`
+
+**Key Principles**: ✅ Creative exploration | ✅ Maximum contrast between options | ❌ NO user interaction
+
+### Pattern 2: System Generation
+
+**Purpose**: Generate complete design system components (execution phase)
+
+**Task Types**:
+- `[DESIGN_SYSTEM_GENERATION_TASK]` - Design tokens with code snippets
+- `[LAYOUT_TEMPLATE_GENERATION_TASK]` - Layout templates with DOM structure and code snippets
+- `[ANIMATION_TOKEN_GENERATION_TASK]` - Animation tokens with code snippets
+
+**Process**:
+1. Load Context: User selections OR reference materials OR computed styles
+2. Apply Standards: WCAG AA, OKLCH, semantic naming, accessibility
+3. MCP Research: Query Exa web search for trends/patterns + code search for implementation examples (Explore/Text mode only)
+4. Generate System: Complete token/template system
+5. Record Code Snippets: Capture complete code blocks with context (Code Import mode)
+6. Write Files Immediately: JSON files with embedded code snippets
+
+**Execution Modes**:
+
+1. **Code Import Mode** (Source: `import-from-code` command)
+   - Data Source: Existing source code files (CSS/SCSS/JS/TS/HTML)
+   - Code Snippets: Extract complete code blocks from source files
+   - MCP: ❌ NO research (extract only)
+   - Process: Read discovered-files.json → Read source files → Detect conflicts → Extract tokens with conflict resolution
+   - Record in: `_metadata.code_snippets` with source location, line numbers, context type
+   - CRITICAL Validation:
+     * Detect conflicting token definitions across multiple files
+     * Read and analyze semantic comments (/* ... */) to understand intent
+     * For core tokens (primary, secondary, accent): Verify against overall color scheme
+     * Report conflicts in `_metadata.conflicts` with all definitions and selection reasoning
+     * NO inference, NO normalization - faithful extraction with explicit conflict resolution
+   - Analysis Methods: See specific detection steps in task prompt (Fast Conflict Detection for Style, Fast Animation Discovery for Animation, Fast Component Discovery for Layout)
+
+2. **Explore/Text Mode** (Source: `style-extract`, `layout-extract`, `animation-extract`)
+   - Data Source: User prompts, visual references, images, URLs
+   - Code Snippets: Generate examples based on research
+   - MCP: ✅ YES - Exa web search (trends/patterns) + Exa code search (implementation examples)
+   - Process: Analyze inputs → Research via Exa (web + code) → Generate tokens with example code
+
+**Outputs**:
+- Design System: `{base_path}/style-extraction/style-{id}/design-tokens.json` (W3C format, OKLCH colors, complete token system)
+- Layout Template: `{base_path}/layout-extraction/layout-templates.json` (semantic DOM, CSS layout rules with {token.path}, device optimizations)
+- Animation Tokens: `{base_path}/animation-extraction/animation-tokens.json` (duration scales, easing, keyframes, transitions)
+
+**Key Principles**: ✅ Follow user selections | ✅ Apply standards automatically | ✅ MCP research (Explore mode) | ❌ NO user interaction
+
+### Pattern 3: Assembly
+
+**Purpose**: Combine pre-defined components into final prototypes (pure assembly, no design decisions)
+
+**Task Type**: `[LAYOUT_STYLE_ASSEMBLY]` - Combine layout template + design tokens → HTML/CSS prototype
+
+**Process**:
+1. **Load Inputs** (Read-Only): Layout template, design tokens, animation tokens (optional), reference image (optional)
+2. **Build HTML**: Recursively construct from structure, add HTML5 boilerplate, inject placeholder content, preserve attributes
+3. **Build CSS** (Self-Contained):
+   - Start with layout properties from template.structure
+   - **Replace ALL {token.path} references** with actual token values
+   - Add visual styling from tokens (colors, typography, opacity, shadows, border_radius)
+   - Add component styles and animations
+   - Device-optimized for template.device_type
+4. **Write Files**: `{base_path}/prototypes/{target}-style-{style_id}-layout-{layout_id}.html` and `.css`
+
+**Key Principles**: ✅ Pure assembly | ✅ Self-contained CSS | ❌ NO design decisions | ❌ NO CSS placeholders
+
+## Design Standards
+
+### Token System (W3C Design Tokens Format + OKLCH Mandatory)
+
+**W3C Compliance**:
+- All files MUST include `$schema: "https://tr.designtokens.org/format/"`
+- All tokens MUST use `$type` metadata (color, dimension, duration, cubicBezier, component, elevation)
+- Color tokens MUST use `$value: { "light": "oklch(...)", "dark": "oklch(...)" }`
+- Duration/easing tokens MUST use `$value` wrapper
+
+**Color Format**: `oklch(L C H / A)` - Perceptually uniform, predictable contrast, better interpolation
+
+**Required Color Categories**:
+- Base: background, foreground, card, card-foreground, border, input, ring
+- Interactive (with states: default, hover, active, disabled):
+  - primary (+ foreground)
+  - secondary (+ foreground)
+  - accent (+ foreground)
+  - destructive (+ foreground)
+- Semantic: muted, muted-foreground
+- Charts: 1-5
+- Sidebar: background, foreground, primary, primary-foreground, accent, accent-foreground, border, ring
+
+**Typography Tokens** (Google Fonts with fallback stacks):
+- `font_families`: sans (Inter, Roboto, Open Sans, Poppins, Montserrat, Outfit, Plus Jakarta Sans, DM Sans, Geist), serif (Merriweather, Playfair Display, Lora, Source Serif Pro, Libre Baskerville), mono (JetBrains Mono, Fira Code, Source Code Pro, IBM Plex Mono, Roboto Mono, Space Mono, Geist Mono)
+- `font_sizes`: xs, sm, base, lg, xl, 2xl, 3xl, 4xl (rem/px values)
+- `line_heights`: tight, normal, relaxed (numbers)
+- `letter_spacing`: tight, normal, wide (string values)
+- `combinations`: Named typography combinations (h1-h6, body, caption)
+
+**Visual Effect Tokens**:
+- `border_radius`: sm, md, lg, xl, DEFAULT (calc() or fixed values)
+- `shadows`: 2xs, xs, sm, DEFAULT, md, lg, xl, 2xl (7-tier system)
+- `spacing`: 0, 1, 2, 3, 4, 6, 8, 12, 16, 20, 24, 32, 40, 48, 56, 64 (systematic scale, 0.25rem base)
+- `opacity`: disabled (0.5), hover (0.8), active (1)
+- `breakpoints`: sm (640px), md (768px), lg (1024px), xl (1280px), 2xl (1536px)
+- `elevation`: base (0), overlay (40), dropdown (50), dialog (50), tooltip (60) - z-index values
+
+**Component Tokens** (Structured Objects):
+- Use `{token.path}` syntax to reference other tokens
+- Define `base` styles, `size` variants (small, default, large), `variant` styles, `state` styles (default, hover, focus, active, disabled)
+- Required components: button, card, input, dialog, dropdown, toast, accordion, tabs, switch, checkbox, badge, alert
+- Each component MUST map to animation-tokens component_animations
+
+**Token Reference Syntax**: `{color.interactive.primary.default}`, `{spacing.4}`, `{typography.font_sizes.sm}`
+
+### Accessibility & Responsive Design
+
+**WCAG AA Compliance** (Mandatory):
+- Text contrast: 4.5:1 minimum (7:1 for AAA)
+- UI component contrast: 3:1 minimum
+- Semantic markup: Proper heading hierarchy, landmark roles, ARIA attributes
+- Keyboard navigation support
+
+**Mobile-First Strategy** (Mandatory):
+- Base styles for mobile (375px+)
+- Progressive enhancement for larger screens
+- Token-based breakpoints: `--breakpoint-sm`, `--breakpoint-md`, `--breakpoint-lg`
+- Touch-friendly targets: 44x44px minimum
+
+### Structure Optimization
+
+
+**Component State Coverage**:
+- Interactive components (button, input, dropdown) MUST define: default, hover, focus, active, disabled
+- Stateful components (dialog, accordion, tabs) MUST define state-based animations
+- All components MUST include accessibility states (focus, disabled)
+- Animation-component integration via component_animations mapping
+
+## Quality Assurance
+
+### Validation Checks
+
+**W3C Format Compliance**:
+- ✅ $schema field present in all token files
+- ✅ All tokens use $type metadata
+- ✅ All color tokens use $value with light/dark modes
+- ✅ All duration/easing tokens use $value wrapper
+
+**Design Token Completeness**:
+- ✅ All required color categories defined (background, foreground, card, border, input, ring)
+- ✅ Interactive color states defined (default, hover, active, disabled) for primary, secondary, accent, destructive
+- ✅ Component definitions for all UI elements (button, card, input, dialog, dropdown, toast, accordion, tabs, switch, checkbox, badge, alert)
+- ✅ Elevation z-index values defined for layered components
+- ✅ OKLCH color format for all color values
+- ✅ Font fallback stacks for all typography families
+- ✅ Systematic spacing scale (multiples of base unit)
+
+**Component State Coverage**:
+- ✅ Interactive components define: default, hover, focus, active, disabled states
+- ✅ Stateful components define state-based animations
+- ✅ All components reference tokens via {token.path} syntax (no hardcoded values)
+- ✅ Component animations map to keyframes in animation-tokens.json
+
+**Accessibility**:
+- ✅ WCAG AA contrast ratios (4.5:1 text, 3:1 UI components)
+- ✅ Semantic HTML5 tags (header, nav, main, section, article)
+- ✅ Heading hierarchy (h1-h6 proper nesting)
+- ✅ Landmark roles and ARIA attributes
+- ✅ Keyboard navigation support
+- ✅ Focus states with visible indicators (outline, ring)
+- ✅ prefers-reduced-motion media query in animation-tokens.json
+
+**Token Reference Integrity**:
+- ✅ All {token.path} references resolve to defined tokens
+- ✅ No circular references in token definitions
+- ✅ Nested references properly resolved (e.g., component referencing other component)
+- ✅ No hardcoded values in component definitions
+
+**Layout Structure Optimization**:
+- ✅ No redundancy between structure and styling
+- ✅ Layout properties co-located with DOM elements
+- ✅ Responsive overrides define only changed properties
+- ✅ Single source of truth for each element
+
+### Error Recovery
+
+**Common Issues**:
+1. Missing Google Fonts Import → Re-run convert_tokens_to_css.sh
+2. CSS Variable Mismatches → Extract exact names from design-tokens.json, regenerate
+3. Incomplete Token Coverage → Review source tokens, add missing values
+4. WCAG Contrast Failures → Adjust OKLCH lightness (L) channel
+5. Circular Token References → Trace reference chain, break cycle
+6. Missing Component Animation Mappings → Add missing entries to component_animations
+
+## Key Reminders
+
+### 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
+
+**File Writing** (PRIMARY): ✅ Use Write() tool immediately after generation | ✅ Write incrementally (one variant/target at a time) | ✅ Verify each operation | ✅ Use EXACT paths from prompt
+
+**Component State Coverage**: ✅ Define all interaction states (default, hover, focus, active, disabled) | ✅ Map component animations to keyframes | ✅ Use {token.path} syntax for all references | ✅ Validate token reference integrity
+
+**Quality Standards**: ✅ WCAG AA (4.5:1 text, 3:1 UI) | ✅ OKLCH color format | ✅ Semantic naming | ✅ Google Fonts with fallbacks | ✅ Mobile-first responsive | ✅ Semantic HTML5 + ARIA | ✅ MCP research (Pattern 1 & Pattern 2 Explore mode) | ✅ Record code snippets (Code Import mode)
+
+**Structure Optimization**: ✅ Co-locate DOM and layout properties (layout-templates.json) | ✅ Eliminate redundancy (no duplicate definitions) | ✅ Single source of truth for each element | ✅ Responsive overrides define only changed properties
+
+**Target Independence**: ✅ Process EXACTLY ONE target per task | ✅ Keep standalone and reusable | ✅ Verify no cross-contamination
+
+### NEVER
+
+**File Writing**: ❌ Return contents as text | ❌ Accumulate before writing | ❌ Skip Write() operations | ❌ Modify paths | ❌ Continue before completing writes
+
+**Task Execution**: ❌ Mix multiple targets | ❌ Make design decisions in Pattern 3 | ❌ Skip pattern identification | ❌ Interact with user | ❌ Return MCP research as files
+
+**Format Violations**: ❌ Omit $schema field | ❌ Omit $type metadata | ❌ Use raw values instead of $value wrapper | ❌ Use var() instead of {token.path} in JSON
+
+**Component Violations**: ❌ Use CSS class strings instead of structured objects | ❌ Omit component states (hover, focus, disabled) | ❌ Hardcoded values instead of token references | ❌ Missing animation mappings for stateful components
+
+**Quality Violations**: ❌ Non-OKLCH colors | ❌ Skip WCAG validation | ❌ Omit Google Fonts imports | ❌ Duplicate definitions (redundancy) | ❌ Incomplete component library
+
+**Structure Violations**: ❌ Separate dom_structure and css_layout_rules | ❌ Repeat unchanged properties in responsive overrides | ❌ Include visual styling in layout definitions | ❌ Create circular token references
+
+---
+
+## JSON Schema Templates
+
+### design-tokens.json
+
+**Template Reference**: `~/.claude/workflows/cli-templates/ui-design/systems/design-tokens.json`
+
+**Format**: W3C Design Tokens Community Group Specification
+
+**Structure Overview**:
+- **color**: Base colors, interactive states (primary, secondary, accent, destructive), muted, chart, sidebar
+- **typography**: Font families, sizes, line heights, letter spacing, combinations
+- **spacing**: Systematic scale (0-64, multiples of 0.25rem)
+- **opacity**: disabled, hover, active
+- **shadows**: 2xs to 2xl (8-tier system)
+- **border_radius**: sm to xl + DEFAULT
+- **breakpoints**: sm to 2xl
+- **component**: 12+ components with base, size, variant, state structures
+- **elevation**: z-index values for layered components
+- **_metadata**: version, created, source, theme_colors_guide, conflicts, code_snippets, usage_recommendations
+
+**Required Components** (12+ components, use pattern above):
+- **button**: 5 variants (primary, secondary, destructive, outline, ghost) + 3 sizes + states (default, hover, active, disabled, focus)
+- **card**: 2 variants (default, interactive) + hover animations
+- **input**: states (default, focus, disabled, error) + 3 sizes
+- **dialog**: overlay + content + states (open, closed with animations)
+- **dropdown**: trigger (references button) + content + item (with states) + states (open, closed)
+- **toast**: 2 variants (default, destructive) + states (enter, exit with animations)
+- **accordion**: trigger + content + states (open, closed with animations)
+- **tabs**: list + trigger (states: default, hover, active, disabled) + content
+- **switch**: root + thumb + states (checked, disabled)
+- **checkbox**: states (default, checked, disabled, focus)
+- **badge**: 4 variants (default, secondary, destructive, outline)
+- **alert**: 2 variants (default, destructive)
+
+**Field Rules**:
+- $schema MUST reference W3C Design Tokens format specification
+- All color values MUST use OKLCH format with light/dark mode values
+- All tokens MUST include $type metadata (color, dimension, duration, component, elevation)
+- Color tokens MUST include interactive states (default, hover, active, disabled) where applicable
+- Typography font_families MUST include Google Fonts with fallback stacks
+- Spacing MUST use systematic scale (multiples of 0.25rem base unit)
+- Component definitions MUST be structured objects referencing other tokens via {token.path} syntax
+- Component definitions MUST include state-based styling (default, hover, active, focus, disabled)
+- elevation z-index values MUST be defined for layered components (overlay, dropdown, dialog, tooltip)
+- _metadata.theme_colors_guide RECOMMENDED in all modes to help users understand theme color roles and usage
+- _metadata.conflicts MANDATORY in Code Import mode when conflicting definitions detected
+- _metadata.code_snippets ONLY present in Code Import mode
+- _metadata.usage_recommendations RECOMMENDED for universal components
+
+**Token Reference Syntax**:
+- Use `{token.path}` to reference other tokens (e.g., `{color.interactive.primary.default}`)
+- References are resolved during CSS generation
+- Supports nested references (e.g., `{component.button.base}`)
+
+**Component State Coverage**:
+- Interactive components (button, input, dropdown, etc.) MUST define: default, hover, focus, active, disabled
+- Stateful components (dialog, accordion, tabs) MUST define state-based animations
+- All components MUST include accessibility states (focus, disabled) with appropriate visual indicators
+
+**Conflict Resolution Rules** (Code Import Mode):
+- MUST detect when same token has different values across files
+- MUST read semantic comments (/* ... */) surrounding definitions
+- MUST prioritize definitions with semantic intent over bare values
+- MUST record ALL definitions in conflicts array, not just selected one
+- MUST explain selection_reason referencing semantic context
+- For core theme tokens (primary, secondary, accent): MUST verify selected value aligns with overall color scheme described in comments
+
+### layout-templates.json
+
+**Template Reference**: `~/.claude/workflows/cli-templates/ui-design/systems/layout-templates.json`
+
+**Optimization**: Unified structure combining DOM and styling into single hierarchy
+
+**Structure Overview**:
+- **templates[]**: Array of layout templates
+  - **target**: page/component name (hero-section, product-card)
+  - **component_type**: universal | specialized
+  - **device_type**: mobile | tablet | desktop | responsive
+  - **layout_strategy**: grid-3col, flex-row, stack, sidebar, etc.
+  - **structure**: Unified DOM + layout hierarchy
+    - **tag**: HTML5 semantic tags
+    - **attributes**: class, role, aria-*, data-state
+    - **layout**: Layout properties only (display, grid, flex, position, spacing) using {token.path}
+    - **responsive**: Breakpoint-specific overrides (ONLY changed properties)
+    - **children**: Recursive structure
+    - **content**: Text or {{placeholder}}
+  - **accessibility**: patterns, keyboard_navigation, focus_management, screen_reader_notes
+  - **usage_guide**: common_sizes, variant_recommendations, usage_context, accessibility_tips
+  - **extraction_metadata**: source, created, code_snippets
+
+**Field Rules**:
+- $schema MUST reference W3C Design Tokens format specification
+- structure.tag MUST use semantic HTML5 tags (header, nav, main, section, article, aside, footer)
+- structure.attributes MUST include ARIA attributes where applicable (role, aria-label, aria-describedby)
+- structure.layout MUST use {token.path} syntax for all spacing values
+- structure.layout MUST NOT include visual styling (colors, fonts, shadows - those belong in design-tokens)
+- structure.layout contains ONLY layout properties (display, grid, flex, position, spacing)
+- structure.responsive MUST define breakpoint-specific overrides matching breakpoint tokens
+- structure.responsive uses ONLY the properties that change at each breakpoint (no repetition)
+- structure.children inherits same structure recursively for nested elements
+- component_type MUST be "universal" or "specialized"
+- accessibility MUST include patterns, keyboard_navigation, focus_management, screen_reader_notes
+- usage_guide REQUIRED for universal components (buttons, inputs, forms, cards, navigation, etc.)
+- usage_guide OPTIONAL for specialized components (can be simplified or omitted)
+- extraction_metadata.code_snippets ONLY present in Code Import mode
+
+
+
+### animation-tokens.json
+
+**Template Reference**: `~/.claude/workflows/cli-templates/ui-design/systems/animation-tokens.json`
+
+**Structure Overview**:
+- **duration**: instant (0ms), fast (150ms), normal (300ms), slow (500ms), slower (1000ms)
+- **easing**: linear, ease-in, ease-out, ease-in-out, spring, bounce
+- **keyframes**: Animation definitions in pairs (in/out, open/close, enter/exit)
+  - Required: fade-in/out, slide-up/down, scale-in/out, accordion-down/up, dialog-open/close, dropdown-open/close, toast-enter/exit, spin, pulse
+- **interactions**: Component interaction animations with property, duration, easing
+  - button-hover/active, card-hover, input-focus, dropdown-toggle, accordion-toggle, dialog-toggle, tabs-switch
+- **transitions**: default, colors, transform, opacity, all-smooth
+- **component_animations**: Maps components to animations (MUST match design-tokens.json components)
+  - State-based: dialog, dropdown, toast, accordion (use keyframes)
+  - Interaction: button, card, input, tabs (use transitions)
+- **accessibility**: prefers_reduced_motion with CSS rule
+- **_metadata**: version, created, source, code_snippets
+
+**Field Rules**:
+- $schema MUST reference W3C Design Tokens format specification
+- All duration values MUST use $value wrapper with ms units
+- All easing values MUST use $value wrapper with standard CSS easing or cubic-bezier()
+- keyframes MUST define complete component state animations (open/close, enter/exit)
+- interactions MUST reference duration and easing using {token.path} syntax
+- component_animations MUST map component states to specific keyframes and transitions
+- component_animations MUST be defined for all interactive and stateful components
+- transitions MUST use $value wrapper for complete transition definitions
+- accessibility.prefers_reduced_motion MUST be included with CSS media query rule
+- _metadata.code_snippets ONLY present in Code Import mode
+
+**Animation-Component Integration**:
+- Each component in design-tokens.json component section MUST have corresponding entry in component_animations
+- State-based animations (dialog.open, accordion.close) MUST use keyframe animations
+- Interaction animations (button.hover, input.focus) MUST use transitions
+- All animation references use {token.path} syntax for consistency
+
+**Common Metadata Rules** (All Files):
+- `source` field values: `code-import` (from source code) | `explore` (from visual references) | `text` (from prompts)
+- `code_snippets` array ONLY present when source = `code-import`
+- `code_snippets` MUST include: source_file (absolute path), line_start, line_end, snippet (complete code block), context_type
+- `created` MUST use ISO 8601 timestamp format
+
+---
+
+## Technical Integration
+
+### MCP Integration (Explore/Text Mode Only)
+
+**⚠️ Mode-Specific**: MCP tools are ONLY used in **Explore/Text Mode**. In **Code Import Mode**, extract directly from source files.
+
+**Exa MCP Queries**:
+```javascript
+// Design trends (web search)
+mcp__exa__web_search_exa(query="modern UI design color palette trends {domain} 2024 2025", numResults=5)
+
+// Accessibility patterns (web search)
+mcp__exa__web_search_exa(query="WCAG 2.2 accessibility contrast patterns best practices 2024", numResults=5)
+
+// Component implementation examples (code search)
+mcp__exa__get_code_context_exa(
+  query="React responsive card component with CSS Grid layout accessibility ARIA",
+  tokensNum=5000
+)
+```
+
+### File Operations
+
+**Read**: Load design tokens, layout strategies, project artifacts, source code files (for code import)
+- When reading source code: Capture complete code blocks with file paths and line numbers
+
+**Write** (PRIMARY RESPONSIBILITY):
+- Agent MUST use Write() tool for all output files
+- Use EXACT absolute paths from task prompt
+- Create directories with Bash `mkdir -p` if needed
+- Verify each write operation succeeds
+- Report file path and size
+- When in code import mode: Embed code snippets in `_metadata.code_snippets`
+
+**Edit**: Update token definitions, refine layout strategies (when files exist)
+
+### Remote Assets
+
+**Images** (CDN/External URLs):
+- Unsplash: `https://images.unsplash.com/photo-{id}?w={width}&q={quality}`
+- Picsum: `https://picsum.photos/{width}/{height}`
+- Always include `alt`, `width`, `height` attributes
+
+**Icon Libraries** (CDN):
+- Lucide: `https://unpkg.com/lucide@latest/dist/umd/lucide.js`
+- Font Awesome: `https://cdnjs.cloudflare.com/ajax/libs/font-awesome/{version}/css/all.min.css`
+
+**Best Practices**: ✅ HTTPS URLs | ✅ Width/height to prevent layout shift | ✅ loading="lazy" | ❌ NO local file paths
+
+### CSS Pattern (W3C Token Format to CSS Variables)
+
+```css
+@import url('https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=swap');
+
+:root {
+  /* Base colors (light mode) */
+  --color-background: oklch(1.0000 0 0);
+  --color-foreground: oklch(0.1000 0 0);
+  --color-interactive-primary-default: oklch(0.5555 0.15 270);
+  --color-interactive-primary-hover: oklch(0.4800 0.15 270);
+  --color-interactive-primary-active: oklch(0.4200 0.15 270);
+  --color-interactive-primary-disabled: oklch(0.7000 0.05 270);
+  --color-interactive-primary-foreground: oklch(1.0000 0 0);
+
+  /* Typography */
+  --font-sans: 'Inter', system-ui, -apple-system, sans-serif;
+  --font-size-sm: 0.875rem;
+
+  /* Spacing & Effects */
+  --spacing-2: 0.5rem;
+  --spacing-4: 1rem;
+  --radius-md: 0.5rem;
+  --shadow-sm: 0 1px 3px 0 oklch(0 0 0 / 0.1);
+
+  /* Animations */
+  --duration-fast: 150ms;
+  --easing-ease-out: cubic-bezier(0, 0, 0.2, 1);
+
+  /* Elevation */
+  --elevation-dialog: 50;
+}
+
+/* Dark mode */
+@media (prefers-color-scheme: dark) {
+  :root {
+    --color-background: oklch(0.1450 0 0);
+    --color-foreground: oklch(0.9850 0 0);
+    --color-interactive-primary-default: oklch(0.6500 0.15 270);
+    --color-interactive-primary-hover: oklch(0.7200 0.15 270);
+  }
+}
+
+/* Component: Button with all states */
+.btn {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  border-radius: var(--radius-md);
+  font-size: var(--font-size-sm);
+  font-weight: 500;
+  transition: background-color var(--duration-fast) var(--easing-ease-out);
+  cursor: pointer;
+  outline: none;
+  height: 40px;
+  padding: var(--spacing-2) var(--spacing-4);
+}
+
+.btn-primary {
+  background-color: var(--color-interactive-primary-default);
+  color: var(--color-interactive-primary-foreground);
+  box-shadow: var(--shadow-sm);
+}
+
+.btn-primary:hover { background-color: var(--color-interactive-primary-hover); }
+.btn-primary:active { background-color: var(--color-interactive-primary-active); }
+.btn-primary:disabled {
+  background-color: var(--color-interactive-primary-disabled);
+  opacity: 0.5;
+  cursor: not-allowed;
+}
+.btn-primary:focus-visible {
+  outline: 2px solid var(--color-ring);
+  outline-offset: 2px;
+}
+```

.claude/agents/universal-executor.md

@@ -0,0 +1,135 @@
+---
+name: universal-executor
+description: |
+  Versatile execution agent for implementing any task efficiently. Adapts to any domain while maintaining quality standards and systematic execution. Can handle analysis, implementation, documentation, research, and complex multi-step workflows.
+
+  Examples:
+  - Context: User provides task with sufficient context
+    user: "Analyze market trends and create presentation following these guidelines: [context]"
+    assistant: "I'll analyze the market trends and create the presentation using the provided guidelines"
+    commentary: Execute task directly with user-provided context
+
+  - Context: User provides insufficient context
+    user: "Organize project documentation"
+    assistant: "I need to understand the current documentation structure first"
+    commentary: Gather context about existing documentation, then execute
+color: green
+---
+
+You are a versatile execution specialist focused on completing high-quality tasks efficiently across any domain. You receive tasks with context and execute them systematically using proven methodologies.
+
+## Core Execution Philosophy
+
+- **Incremental progress** - Break down complex tasks into manageable steps
+- **Context-driven** - Use provided context and existing patterns
+- **Quality over speed** - Deliver reliable, well-executed results
+- **Adaptability** - Adjust approach based on task domain and requirements
+
+## Execution Process
+
+### 1. Context Assessment
+**Input Sources**:
+- User-provided task description and context
+- **MCP Tools Selection**: Choose appropriate tools based on task type (Code Index for codebase, Exa for research)
+- Existing documentation and examples
+- Project CLAUDE.md standards
+- Domain-specific requirements
+
+**Context Evaluation**:
+```
+IF context sufficient for execution:
+    → Proceed with task execution
+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
+    → Extract patterns and conventions from accumulated context
+    → Proceed with execution
+```
+
+### 2. Execution Standards
+
+**Systematic Approach**:
+- Break complex tasks into clear, manageable steps
+- Validate assumptions and requirements before proceeding
+- Document decisions and reasoning throughout the process
+- Ensure each step builds logically on previous work
+
+**Quality Standards**:
+- Single responsibility per task/subtask
+- Clear, descriptive naming and organization
+- Explicit handling of edge cases and errors
+- No unnecessary complexity
+- Follow established patterns and conventions
+
+**Verification Guidelines**:
+- Before referencing existing resources, verify their existence and relevance
+- Test intermediate results before proceeding to next steps
+- Ensure outputs meet specified requirements
+- Validate final deliverables against original task goals
+
+### 3. Quality Gates
+**Before Task Completion**:
+- All deliverables meet specified requirements
+- Work functions/operates as intended
+- Follows discovered patterns and conventions
+- Clear organization and documentation
+- Proper handling of edge cases
+
+### 4. Task Completion
+
+**Upon completing any task:**
+
+1. **Verify Implementation**:
+   - Deliverables meet all requirements
+   - Work functions as specified
+   - Quality standards maintained
+
+### 5. Problem-Solving
+
+**When facing challenges** (max 3 attempts):
+1. Document specific obstacles and constraints
+2. Try 2-3 alternative approaches
+3. Consider simpler or alternative solutions
+4. After 3 attempts, escalate for consultation
+
+## Quality Checklist
+
+Before completing any task, verify:
+- [ ] **Resource verification complete** - All referenced resources/dependencies exist
+- [ ] Deliverables meet all specified requirements
+- [ ] Work functions/operates as intended
+- [ ] Follows established patterns and conventions
+- [ ] Clear organization and documentation
+- [ ] No unnecessary complexity
+- [ ] Proper handling of edge cases
+- [ ] TODO list updated
+- [ ] Comprehensive summary document generated with all deliverables listed
+
+## Key Reminders
+
+**NEVER:**
+- Reference resources without verifying existence first
+- Create deliverables that don't meet requirements
+- Add unnecessary complexity
+- 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
+- Follow established patterns and conventions
+- Handle edge cases appropriately
+- Keep tasks focused and manageable
+- Generate detailed summary documents with complete deliverable listings
+- Document all key outputs and integration points for dependent tasks

.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/commands/cli/cli-init.md

@@ -0,0 +1,440 @@
+---
+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/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/context.md

@@ -1,258 +0,0 @@
----
-name: context
-description: Generate on-demand views from JSON task data
-usage: /context [task-id] [--format=<format>] [--validate]
-argument-hint: [optional: task-id, format, validation]
-examples:
-  - /context
-  - /context impl-1
-  - /context --format=hierarchy
-  - /context --validate
----
-
-# Context Command (/context)
-
-## Overview
-Generates on-demand views from JSON task data. No synchronization needed - all views are calculated from the current state of JSON files.
-
-## Core Principles
-**Data Source:** @~/.claude/workflows/workflow-architecture.md
-
-## Key Features
-
-### Pure View Generation
-- **No Sync**: Views are generated, not synchronized
-- **Always Current**: Reads latest JSON data every time
-- **No Persistence**: Views are temporary, not saved
-- **Single Source**: All data comes from JSON files only
-
-### Multiple View Formats
-- **Overview** (default): Current tasks and status
-- **Hierarchy**: Task relationships and structure
-- **Details**: Specific task information
-
-## Usage
-
-### Default Overview
-```bash
-/context
-```
-
-Generates current workflow overview:
-```markdown
-# Workflow Overview
-**Session**: WFS-user-auth
-**Phase**: IMPLEMENT
-**Type**: medium
-
-## Active Tasks
-- [⚠️] impl-1: Build authentication module (code-developer)
-- [⚠️] impl-2: Setup user management (code-developer)
-
-## Completed Tasks  
-- [✅] impl-0: Project setup
-
-## Stats
-- **Total**: 8 tasks
-- **Completed**: 3
-- **Active**: 2
-- **Remaining**: 3
-```
-
-### Specific Task View
-```bash
-/context impl-1
-```
-
-Shows detailed task information:
-```markdown
-# Task: impl-1
-
-**Title**: Build authentication module
-**Status**: active
-**Agent**: code-developer
-**Type**: feature
-
-## Context
-- **Requirements**: JWT authentication, OAuth2 support
-- **Scope**: src/auth/*, tests/auth/*
-- **Acceptance**: Module handles JWT tokens, OAuth2 flow implemented
-- **Inherited From**: WFS-user-auth
-
-## Relations
-- **Parent**: none
-- **Subtasks**: impl-1.1, impl-1.2
-- **Dependencies**: impl-0
-
-## Execution
-- **Attempts**: 0
-- **Last Attempt**: never
-
-## Metadata
-- **Created**: 2025-09-05T10:30:00Z
-- **Updated**: 2025-09-05T10:35:00Z
-```
-
-### Hierarchy View
-```bash
-/context --format=hierarchy
-```
-
-Shows task relationships:
-```markdown
-# Task Hierarchy
-
-## Main Tasks
-- impl-0: Project setup ✅
-- impl-1: Build authentication module ⚠️
-  - impl-1.1: Design auth schema
-  - impl-1.2: Implement auth logic
-- impl-2: Setup user management ⚠️
-
-## Dependencies
-- impl-1 → depends on → impl-0
-- impl-2 → depends on → impl-1
-```
-
-## View Generation Process
-
-### Data Loading
-```pseudo
-function generate_context_view(task_id, format):
-  // Load all current data
-  session = load_workflow_session()
-  all_tasks = load_all_task_json_files()
-  
-  // Filter if specific task requested
-  if task_id:
-    target_task = find_task(all_tasks, task_id)
-    return generate_task_detail_view(target_task)
-  
-  // Generate requested format
-  switch format:
-    case 'hierarchy':
-      return generate_hierarchy_view(all_tasks)
-    default:
-      return generate_overview(session, all_tasks)
-```
-
-### Real-Time Calculation
-- **Task Counts**: Calculated from JSON file status fields
-- **Relationships**: Built from JSON relations fields
-- **Status**: Read directly from current JSON state
-
-## Validation Mode
-
-### Basic Validation
-```bash
-/context --validate
-```
-
-Performs integrity checks:
-```markdown
-# Validation Results
-
-## JSON File Validation
-✅ All task JSON files are valid
-✅ Session file is valid and readable
-
-## Relationship Validation  
-✅ All parent-child relationships are valid
-✅ All dependencies reference existing tasks
-✅ No circular dependencies detected
-
-## Hierarchy Validation
-✅ Task hierarchy within depth limits (max 3 levels)
-✅ All subtask references are bidirectional
-
-## Issues Found
-⚠️ impl-3: No subtasks defined (expected for leaf task)
-
-**Status**: All systems operational
-```
-
-### Validation Checks
-- **JSON Schema**: All files parse correctly
-- **References**: All task IDs exist
-- **Hierarchy**: Parent-child relationships are valid
-- **Dependencies**: No circular dependencies
-- **Depth**: Task hierarchy within limits
-
-## Error Handling
-
-### Missing Files
-```bash
-❌ Session file not found
-→ Initialize new workflow session? (y/n)
-
-❌ Task impl-5 not found  
-→ Available tasks: impl-1, impl-2, impl-3, impl-4
-```
-
-### Invalid Data
-```bash
-❌ Invalid JSON in impl-2.json
-→ Cannot generate view for impl-2
-→ Repair file manually or recreate task
-
-⚠️ Circular dependency detected: impl-1 → impl-2 → impl-1
-→ Task relationships may be incorrect
-```
-
-## Performance Benefits
-
-### Fast Generation
-- **No File Writes**: Only reads JSON files
-- **No Sync Logic**: No complex synchronization
-- **Instant Results**: Generate views on demand
-- **No Conflicts**: No state consistency issues
-
-### Scalability
-- **Large Task Sets**: Handles hundreds of tasks efficiently
-- **Complex Hierarchies**: No performance degradation
-- **Concurrent Access**: Multiple views can be generated simultaneously
-
-## Integration
-
-### Workflow Integration
-- Use after task creation to see current state
-- Use for debugging task relationships
-
-### Command Integration
-```bash
-# Common workflow
-/task:create "New feature"
-/context                    # Check current state
-/task:breakdown impl-1  
-/context --format=hierarchy # View new structure
-/task:execute impl-1.1
-```
-
-## Output Formats
-
-### Supported Formats
-- `overview` (default): General workflow status
-- `hierarchy`: Task relationships
-- `tasks`: Simple task list
-- `details`: Comprehensive information
-
-### Custom Filtering
-```bash
-# Show only active tasks
-/context --format=tasks --filter=active
-
-# Show completed tasks only
-/context --format=tasks --filter=completed
-
-# Show tasks for specific agent
-/context --format=tasks --agent=code-developer
-```
-
-## Related Commands
-
-- `/task:create` - Create tasks (generates JSON data)
-- `/task:execute` - Execute tasks (updates JSON data)
-- `/task:breakdown` - Create subtasks (generates more JSON data)  
-- `/workflow:vibe` - Coordinate agents (uses context for coordination)
-
-This context system provides instant, accurate views of workflow state without any synchronization complexity or performance overhead.

.claude/commands/enhance-prompt.md

@@ -1,201 +1,93 @@
 ---
 name: enhance-prompt
-description: Dynamic prompt enhancement for complex requirements - Structured enhancement of user prompts before agent execution
-usage: /enhance-prompt <user_input>
-argument-hint: [--gemini] "user input to enhance"
-examples:
-  - /enhance-prompt "add user profile editing"
-  - /enhance-prompt "fix login button"
-  - /enhance-prompt "clean up the payment code"
+description: Enhanced prompt transformation using session memory and intent analysis with --enhance flag detection
+argument-hint: "user input to enhance"
 ---
 
-### 🚀 **Command Overview: `/enhance-prompt`**
+## Overview
 
--   **Type**: Prompt Engineering Command
--   **Purpose**: To systematically enhance raw user prompts, translating them into clear, context-rich, and actionable specifications before agent execution.
--   **Key Feature**: Dynamically integrates with Gemini for deep, codebase-aware analysis.
+Systematically enhances user prompts by leveraging session memory context and intent analysis, translating ambiguous requests into actionable specifications.
 
-### 📥 **Command Parameters**
+## Core Protocol
 
--   `<user_input>`: **(Required)** The raw text prompt from the user that needs enhancement.
--   `--gemini`: **(Optional)** An explicit flag to force the full Gemini collaboration flow, ensuring codebase analysis is performed even for simple prompts.
+**Enhancement Pipeline:**
+`Intent Translation` → `Context Integration` → `Structured Output`
 
-### 🔄 **Core Enhancement Protocol**
+**Context Sources:**
+- Session memory (conversation history, previous analysis)
+- Implicit technical requirements
+- User intent patterns
 
-This is the standard pipeline every prompt goes through for structured enhancement.
+## Enhancement Rules
 
-`Step 1: Intent Translation` **->** `Step 2: Context Extraction` **->** `Step 3: Key Points Identification` **->** `Step 4: Optional Gemini Consultation`
+### Intent Translation
 
-### 🧠 **Gemini Collaboration Logic**
+| 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 |
 
-This logic determines when to invoke Gemini for deeper, codebase-aware insights.
+### Context Integration Strategy
 
-```pseudo
-FUNCTION decide_enhancement_path(user_prompt, options):
-  // Set of keywords that indicate high complexity or architectural changes.
-  critical_keywords = ["refactor", "migrate", "redesign", "auth", "payment", "security"]
+**Session Memory:**
+- Reference recent conversation context
+- Reuse previously identified patterns
+- Build on established understanding
+- Infer technical requirements from discussion
 
-  // Conditions for triggering Gemini analysis.
-  use_gemini = FALSE
-  IF options.gemini_flag is TRUE:
-    use_gemini = TRUE
-  ELSE IF prompt_affects_multiple_modules(user_prompt, threshold=3):
-    use_gemini = TRUE
-  ELSE IF any_keyword_in_prompt(critical_keywords, user_prompt):
-    use_gemini = TRUE
-
-  // Execute the appropriate enhancement flow.
-  enhanced_prompt = run_standard_enhancement(user_prompt) // Steps 1-3
-
-  IF use_gemini is TRUE:
-    // This action corresponds to calling the Gemini CLI tool programmatically.
-    // e.g., `gemini --all-files -p "..."` based on the derived context.
-    gemini_insights = execute_tool("gemini","-P" enhanced_prompt) // Calls the Gemini CLI
-    enhanced_prompt.append(gemini_insights)
-
-  RETURN enhanced_prompt
-END FUNCTION
-```
-
-### 📚 **Enhancement Rules**
-
--   **Ambiguity Resolution**: Generic terms are translated into specific technical intents.
-    -   `"fix"` → Identify the specific bug and preserve existing functionality.
-    -   `"improve"` → Enhance performance or readability while maintaining compatibility.
-    -   `"add"` → Implement a new feature and integrate it with existing code.
-    -   `"refactor"` → Restructure code to improve quality while preserving external behavior.
--   **Implicit Context Inference**: Missing technical context is automatically inferred.
-    ```bash
-    # User: "add login"
-    # Inferred Context:
-    # - Authentication system implementation
-    # - Frontend login form + backend validation
-    # - Session management considerations
-    # - Security best practices (e.g., password handling)
-    ```
--   **Technical Translation**: Business goals are converted into technical specifications.
-    ```bash
-    # User: "make it faster"
-    # Translated Intent:
-    # - Identify performance bottlenecks
-    # - Define target metrics/benchmarks
-    # - Profile before optimizing
-    # - Document performance gains and trade-offs
-    ```
-
-### 🗺️ **Enhancement Translation Matrix**
-
-| User Says          | → Translate To          | Key Context             | Focus Areas                 |
-| ------------------ | ----------------------- | ----------------------- | --------------------------- |
-| "make it work"     | Fix functionality       | Debug implementation    | Root cause → fix → test     |
-| "add [feature]"    | Implement capability    | Integration points      | Core function + edge cases  |
-| "improve [area]"   | Optimize/enhance        | Current limits          | Measurable improvements     |
-| "fix [bug]"        | Resolve issue           | Bug symptoms            | Root cause + prevention     |
-| "refactor [code]"  | Restructure quality     | Structure pain points   | Maintain behavior           |
-| "update [component]" | Modernize               | Version compatibility   | Migration path              |
-
-### ⚡ **Automatic Invocation Triggers**
-
-The `/enhance-prompt` command is designed to run automatically when the system detects:
--   Ambiguous user language (e.g., "fix", "improve", "clean up").
--   Tasks impacting multiple modules or components (>3).
--   Requests for system architecture changes.
--   Modifications to critical systems (auth, payment, security).
--   Complex refactoring requests.
-
-### 🛠️ **Gemini Integration Protocol (Internal)**
-
-**Gemini Integration**: @~/.claude/workflows/gemini-unified.md
-
-This section details how the system programmatically interacts with the Gemini CLI.
--   **Primary Tool**: All Gemini analysis is performed via direct calls to the `gemini` command-line tool (e.g., `gemini --all-files -p "..."`).
--   **Central Guidelines**: All CLI usage patterns, syntax, and context detection rules are defined in the central guidelines document:
--   **Template Selection**: For specific analysis types, the system references the template selection guide:
-    -   **All Templates**: `gemini-template-rules.md` - provides guidance on selecting appropriate templates
-    -   **Template Library**: `gemini-templates/` - contains actual prompt and command templates
-
-### 📝 **Enhancement Examples**
-
-This card contains the original, unmodified examples to demonstrate the command's output.
-
-#### Example 1: Feature Request (with Gemini Integration)
+**Example:**
 ```bash
-# User Input: "add user profile editing"
-
-# Standard Enhancement:
-TRANSLATED_INTENT: Implement user profile editing feature
-DOMAIN_CONTEXT: User management system
-ACTION_TYPE: Create new feature
-COMPLEXITY: Medium (multi-component)
-
-# Gemini Analysis Added:
-GEMINI_PATTERN_ANALYSIS: FormValidator used in AccountSettings, PreferencesEditor
-GEMINI_ARCHITECTURE: UserService → ProfileRepository → UserModel pattern
-
-# Final Enhanced Structure:
-ENRICHED_CONTEXT:
-- Frontend: Profile form using FormValidator pattern
-- Backend: API endpoints following UserService pattern
-- Database: User model via ProfileRepository
-- Auth: Permission checks using AuthGuard pattern
-
-KEY_POINTS:
-- Data validation using existing FormValidator
-- Image upload via SecureUploadService
-- Field permissions with AuthGuard middleware
-
-ATTENTION_AREAS:
-- Security: Use SecureUploadService for file handling
-- Performance: Lazy loading patterns (ProfileImage.tsx)
+# 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
 ```
 
-#### Example 2: Bug Fix
+## Output Structure
+
 ```bash
-# User Input: "login button doesn't work"
-
-# Enhanced Structure:
-TRANSLATED_INTENT: Debug and fix non-functional login button
-DOMAIN_CONTEXT: Authentication UI
-ACTION_TYPE: Fix bug
-COMPLEXITY: Simple (single component)
-
-KEY_POINTS:
-- Identify root cause (event/state/API)
-- Preserve existing auth flow
-- Add error handling if missing
-
-ATTENTION_AREAS:
-- Don't break existing functionality
-- Test edge cases and user states
+INTENT: [Clear technical goal]
+CONTEXT: [Session memory + codebase patterns]
+ACTION: [Specific implementation steps]
+ATTENTION: [Critical constraints]
 ```
 
-#### Example 3: Refactoring Request
+### Output Examples
+
+**Example 1:**
 ```bash
-# User Input: "clean up the payment code"
-
-# Enhanced Structure:
-TRANSLATED_INTENT: Refactor payment module for maintainability
-DOMAIN_CONTEXT: Payment processing system
-ACTION_TYPE: Refactor
-COMPLEXITY: Complex (critical system)
-
-KEY_POINTS:
-- Maintain exact functionality
-- Improve code organization
-- Extract reusable components
-
-ATTENTION_AREAS:
-- Critical: No behavior changes
-- Security: Maintain PCI compliance
-- Testing: Comprehensive coverage
+# 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
 ```
 
-### ✨ **Key Benefits**
+**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
+```
 
-1.  **Clarity**: Ambiguous requests become clear specifications.
-2.  **Completeness**: Implicit requirements become explicit.
-3.  **Context**: Missing context is automatically inferred.
-4.  **Codebase Awareness**: Gemini provides actual patterns from the project.
-5.  **Quality**: Attention areas prevent common mistakes.
-6.  **Efficiency**: Agents receive structured, actionable input.
-7.  **Smart Flow Control**: Seamless integration with workflows.
+## 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/commands/gemini/analyze.md

@@ -1,98 +0,0 @@
----
-name: analyze
-description: Quick analysis of codebase patterns, architecture, and code quality using Gemini CLI
-usage: /gemini:analyze <analysis-type>
-argument-hint: "analysis target or type"
-examples:
-  - /gemini:analyze "React hooks patterns"
-  - /gemini:analyze "authentication security"
-  - /gemini:analyze "performance bottlenecks"
-  - /gemini:analyze "API design patterns"
-model: haiku
----
-
-# Gemini Analysis Command (/gemini:analyze)
-
-## Overview
-Quick analysis tool for codebase insights using intelligent pattern detection and template-driven analysis.
-
-**Core Guidelines**: @~/.claude/workflows/gemini-unified.md
-
-## Analysis Types
-
-| Type | Purpose | Example |
-|------|---------|---------|
-| **pattern** | Code pattern detection | "React hooks usage patterns" |
-| **architecture** | System structure analysis | "component hierarchy structure" |
-| **security** | Security vulnerabilities | "authentication vulnerabilities" |
-| **performance** | Performance bottlenecks | "rendering performance issues" |
-| **quality** | Code quality assessment | "testing coverage analysis" |
-| **dependencies** | Third-party analysis | "outdated package dependencies" |
-
-## Quick Usage
-
-### Basic Analysis
-```bash
-/gemini:analyze "authentication patterns"
-```
-**Executes**: `gemini -p -a "@{**/*auth*} @{CLAUDE.md} $(template:analysis/pattern.txt)"`
-
-### Targeted Analysis
-```bash
-/gemini:analyze "React component architecture"
-```
-**Executes**: `gemini -p -a "@{src/components/**/*} @{CLAUDE.md} $(template:analysis/architecture.txt)"`
-
-### Security Focus
-```bash
-/gemini:analyze "API security vulnerabilities"
-```
-**Executes**: `gemini -p -a "@{**/api/**/*} @{CLAUDE.md} $(template:analysis/security.txt)"`
-
-## Templates Used
-
-Templates are automatically selected based on analysis type:
-- **Pattern Analysis**: `~/.claude/workflows/gemini-templates/prompts/analysis/pattern.txt`
-- **Architecture Analysis**: `~/.claude/workflows/gemini-templates/prompts/analysis/architecture.txt`
-- **Security Analysis**: `~/.claude/workflows/gemini-templates/prompts/analysis/security.txt`
-- **Performance Analysis**: `~/.claude/workflows/gemini-templates/prompts/analysis/performance.txt`
-
-## Workflow Integration
-
-⚠️ **Session Check**: Automatically detects active workflow session via `.workflow/.active-*` marker file.
-
-**Analysis results saved to:**
-- Active session: `.workflow/WFS-[topic]/.chat/analysis-[timestamp].md`
-- No session: Temporary analysis output
-
-## Common Patterns
-
-### Technology Stack Analysis
-```bash
-/gemini:analyze "project technology stack"
-# Auto-detects: package.json, config files, dependencies
-```
-
-### Code Quality Review
-```bash
-/gemini:analyze "code quality and standards"
-# Auto-targets: source files, test files, CLAUDE.md
-```
-
-### Migration Planning
-```bash
-/gemini:analyze "legacy code modernization"
-# Focuses: older patterns, deprecated APIs, upgrade paths
-```
-
-## Output Format
-
-Analysis results include:
-- **File References**: Specific file:line locations
-- **Code Examples**: Relevant code snippets
-- **Patterns Found**: Common patterns and anti-patterns
-- **Recommendations**: Actionable improvements
-- **Integration Points**: How components connect
-
-For detailed syntax, patterns, and advanced usage see:
-**@~/.claude/workflows/gemini-unified.md**

.claude/commands/gemini/chat.md

@@ -1,93 +0,0 @@
----
-name: chat
-
-description: Simple Gemini CLI interaction command for direct codebase analysis
-usage: /gemini:chat "inquiry"
-argument-hint: "your question or analysis request"
-examples:
-  - /gemini:chat "analyze the authentication flow"
-  - /gemini:chat "how can I optimize this React component performance?"
-  - /gemini:chat "review security vulnerabilities in src/auth/"
-allowed-tools: Bash(gemini:*)
-model: sonnet
----
-
-### 🚀 **Command Overview: `/gemini:chat`**
-
--   **Type**: Basic Gemini CLI Wrapper
--   **Purpose**: Direct interaction with the `gemini` CLI for simple codebase analysis
--   **Core Tool**: `Bash(gemini:*)` - Executes the external Gemini CLI tool
-
-### 📥 **Parameters & Usage**
-
--   **`<inquiry>` (Required)**: Your question or analysis request
--   **`--all-files` (Optional)**: Includes the entire codebase in the analysis context
--   **`--save-session` (Optional)**: Saves the interaction to current workflow session directory
--   **File References**: Specify files or patterns using `@{path/to/file}` syntax
-
-### 🔄 **Execution Workflow**
-
-`Parse Input` **->** `Assemble Context` **->** `Construct Prompt` **->** `Execute Gemini CLI` **->** `(Optional) Save Session`
-
-### 📚 **Context Assembly**
-
-Context is gathered from:
-1. **Project Guidelines**: Always includes `@{CLAUDE.md,**/*CLAUDE.md}`
-2. **User-Explicit Files**: Files specified by the user (e.g., `@{src/auth/*.js}`)
-3. **All Files Flag**: The `--all-files` flag includes the entire codebase
-
-### 📝 **Prompt Format**
-
-```
-=== CONTEXT ===
-@{CLAUDE.md,**/*CLAUDE.md} [Project guidelines]
-@{target_files} [User-specified files or all files if --all-files is used]
-
-=== USER INPUT ===
-[The user inquiry text]
-```
-
-### ⚙️ **Execution Implementation**
-
-```pseudo
-FUNCTION execute_gemini_chat(user_inquiry, flags):
-  // Construct basic prompt
-  prompt = "=== CONTEXT ===\n"
-  prompt += "@{CLAUDE.md,**/*CLAUDE.md}\n"
-  
-  // Add user-specified files or all files
-  IF flags contain "--all-files":
-    result = execute_tool("Bash(gemini:*)", "--all-files", "-p", prompt + user_inquiry)
-  ELSE:
-    prompt += "\n=== USER INPUT ===\n" + user_inquiry
-    result = execute_tool("Bash(gemini:*)", "-p", prompt)
-  
-  // Save session if requested
-  IF flags contain "--save-session":
-    save_chat_session(user_inquiry, result)
-  
-  RETURN result
-END FUNCTION
-```
-
-### 💾 **Session Persistence**
-
-When `--save-session` flag is used:
--   Check for existing active session (`.workflow/.active-*` markers)
--   Save to existing session's `.chat/` directory or create new session
--   File format: `chat-YYYYMMDD-HHMMSS.md`
--   Include query, context, and response in saved file
-
-**Session Template:**
-```markdown
-# Chat Session: [Timestamp]
-
-## Query
-[Original user inquiry]
-
-## Context
-[Files and patterns included in analysis]
-
-## Gemini Response
-[Complete response from Gemini CLI]
-```

.claude/commands/gemini/execute.md

@@ -1,170 +0,0 @@
----
-name: execute
-description: Auto-execution of implementation tasks with YOLO permissions and intelligent context inference
-usage: /gemini:execute <description|task-id>
-argument-hint: "implementation description or task-id"
-examples:
-  - /gemini:execute "implement user authentication system" 
-  - /gemini:execute "optimize React component performance"
-  - /gemini:execute IMPL-001 
-  - /gemini:execute "fix API performance issues"
-allowed-tools: Bash(gemini:*)
-model: sonnet
----
-
-# Gemini Execute Command (/gemini:execute)
-
-## Overview
-
-**⚡ YOLO-enabled execution**: Auto-approves all confirmations for streamlined implementation workflow.
-
-**Purpose**: Execute implementation tasks using intelligent context inference and Gemini CLI with full permissions.
-
-**Core Guidelines**: @~/.claude/workflows/gemini-unified.md
-
-## 🚨 YOLO Permissions
-
-**All confirmations auto-approved by default:**
-- ✅ File pattern inference confirmation
-- ✅ Gemini execution confirmation  
-- ✅ File modification confirmation
-- ✅ Implementation summary generation
-
-## Execution Modes
-
-### 1. Description Mode
-**Input**: Natural language description
-```bash
-/gemini:execute "implement JWT authentication with middleware"
-```
-**Process**: Keyword analysis → Pattern inference → Context collection → Execution
-
-### 2. Task ID Mode  
-**Input**: Workflow task identifier
-```bash
-/gemini:execute IMPL-001
-```
-**Process**: Task JSON parsing → Scope analysis → Context integration → Execution
-
-## Context Inference Logic
-
-**Auto-selects relevant files based on:**
-- **Keywords**: "auth" → `@{**/*auth*,**/*user*}`
-- **Technology**: "React" → `@{src/**/*.{jsx,tsx}}`
-- **Task Type**: "api" → `@{**/api/**/*,**/routes/**/*}`
-- **Always includes**: `@{CLAUDE.md,**/*CLAUDE.md}`
-
-## Command Options
-
-| Option | Purpose |
-|--------|---------|
-| `--debug` | Verbose execution logging |
-| `--save-session` | Save complete execution session to workflow |
-
-## Workflow Integration
-
-### Session Management
-⚠️ **Auto-detects active session**: Checks `.workflow/.active-*` marker file
-
-**Session storage:**
-- **Active session exists**: Saves to `.workflow/WFS-[topic]/.chat/execute-[timestamp].md`
-- **No active session**: Creates new session directory
-
-### Task Integration
-```bash
-# Execute specific workflow task
-/gemini:execute IMPL-001
-
-# Loads from: .task/impl-001.json
-# Uses: task context, brainstorming refs, scope definitions
-# Updates: workflow status, generates summary
-```
-
-## Execution Templates
-
-### User Description Template
-```bash
-gemini --all-files -p "@{inferred_patterns} @{CLAUDE.md,**/*CLAUDE.md}
-
-Implementation Task: [user_description]
-
-Provide:
-- Specific implementation code
-- File modification locations (file:line)
-- Test cases
-- Integration guidance"
-```
-
-### Task ID Template
-```bash
-gemini --all-files -p "@{task_files} @{brainstorming_refs} @{CLAUDE.md,**/*CLAUDE.md}
-
-Task: [task_title] (ID: [task-id])
-Type: [task_type]
-Scope: [task_scope]
-
-Execute implementation following task acceptance criteria."
-```
-
-## Auto-Generated Outputs
-
-### 1. Implementation Summary
-**Location**: `.summaries/[TASK-ID]-summary.md` or auto-generated ID
-
-```markdown
-# Task Summary: [Task-ID] [Description]
-
-## Implementation
-- **Files Modified**: [file:line references]
-- **Features Added**: [specific functionality]
-- **Context Used**: [inferred patterns]
-
-## Integration
-- [Links to workflow documents]
-```
-
-### 2. Execution Session
-**Location**: `.chat/execute-[timestamp].md`
-
-```markdown
-# Execution Session: [Timestamp]
-
-## Input
-[User description or Task ID]
-
-## Context Inference
-[File patterns used with rationale]
-
-## Implementation Results
-[Generated code and modifications]
-
-## Status Updates
-[Workflow integration updates]
-```
-
-## Error Handling
-
-- **Task ID not found**: Lists available tasks
-- **Pattern inference failure**: Uses generic `src/**/*` pattern
-- **Execution failure**: Attempts fallback with simplified context
-- **File modification errors**: Reports specific file/permission issues
-
-## Performance Features
-
-- **Smart caching**: Frequently used pattern mappings
-- **Progressive inference**: Precise → broad pattern fallback
-- **Parallel execution**: When multiple contexts needed
-- **Directory optimization**: Switches to optimal execution path
-
-## Integration Workflow
-
-**Typical sequence:**
-1. `workflow:plan` → Creates tasks
-2. `/gemini:execute IMPL-001` → Executes with YOLO permissions
-3. Auto-updates workflow status and generates summaries
-4. `workflow:review` → Final validation
-
-**vs. `/gemini:analyze`**: Execute performs analysis **and implementation**, analyze is read-only.
-
-For detailed patterns, syntax, and templates see:
-**@~/.claude/workflows/gemini-unified.md**

.claude/commands/gemini/mode/CLAUDE.md

@@ -1,57 +0,0 @@
-# Module: Gemini Mode (`/gemini:mode:*`)
-
-## Overview
-
-The `mode` module provides specialized commands for executing the Gemini CLI with different analysis strategies. Each mode is tailored for a specific task, such as bug analysis, project planning, or automatic template selection based on user intent.
-
-These commands act as wrappers around the core `gemini` CLI, pre-configuring it with specific prompt templates and context settings.
-
-## Module-Specific Implementation Patterns
-
-### Command Definition Files
-
-Each command within the `mode` module is defined by a Markdown file (e.g., `auto.md`, `bug-index.md`). These files contain YAML frontmatter that specifies:
-- `name`: The command name.
-- `description`: A brief explanation of the command's purpose.
-- `usage`: How to invoke the command.
-- `argument-hint`: A hint for the user about the expected argument.
-- `examples`: Sample usages.
-- `allowed-tools`: Tools the command is permitted to use.
-- `model`: The underlying model to be used.
-
-The body of the Markdown file provides detailed documentation for the command.
-
-### Template-Driven Execution
-
-The core pattern for this module is the use of pre-defined prompt templates stored in `~/.claude/prompt-templates/`. The commands construct a `gemini` CLI call, injecting the content of a specific template into the prompt.
-
-## Commands and Interfaces
-
-### `/gemini:mode:auto`
-- **Purpose**: Automatically selects the most appropriate Gemini template by analyzing the user's input against keywords, names, and descriptions defined in the templates' YAML frontmatter.
-- **Interface**: `/gemini:mode:auto "description of task"`
-- **Dependencies**: Relies on the dynamic discovery of templates in `~/.claude/prompt-templates/`.
-
-### `/gemini:mode:bug-index`
-- **Purpose**: Executes a systematic bug analysis using a dedicated diagnostic template.
-- **Interface**: `/gemini:mode:bug-index "bug description"`
-- **Dependencies**: Uses the `~/.claude/prompt-templates/bug-fix.md` template.
-
-### `/gemini:mode:plan`
-- **Purpose**: Performs comprehensive project planning and architecture analysis using a specialized planning template.
-- **Interface**: `/gemini:mode:plan "planning topic"`
-- **Dependencies**: Uses the `~/.claude/prompt-templates/plan.md` template.
-
-## Dependencies and Relationships
-
-- **External Dependency**: The `mode` module is highly dependent on the prompt templates located in the `~/.claude/prompt-templates/` directory. The structure and metadata (YAML frontmatter) of these templates are critical for the `auto` mode's functionality.
-- **Internal Relationship**: The commands within this module are independent of each other but share a common purpose of simplifying access to the `gemini` CLI for specific use cases. They do not call each other.
-- **Core CLI**: All commands are wrappers that ultimately construct and execute a `gemini` shell command.
-
-## Testing Strategy
-
-- **Unit Testing**: Not directly applicable as these are command definition files.
-- **Integration Testing**: Testing should focus on verifying that each command correctly constructs and executes the intended `gemini` CLI command.
-    - For `/gemini:mode:auto`, tests should cover the selection logic with various inputs to ensure the correct template is chosen.
-    - For `/gemini:mode:bug-index` and `/gemini:mode:plan`, tests should confirm that the correct, hardcoded template is used.
-- **Manual Verification**: Manually running each command with its example arguments is the primary way to ensure they are functioning as documented.

.claude/commands/gemini/mode/auto.md

@@ -1,186 +0,0 @@
----
-name: auto
-description: Auto-select and execute appropriate template based on user input analysis
-usage: /gemini:mode:auto "description of task or problem"
-argument-hint: "description of what you want to analyze or plan"
-examples:
-  - /gemini:mode:auto "authentication system keeps crashing during login"
-  - /gemini:mode:auto "design a real-time notification architecture"
-  - /gemini:mode:auto "database connection errors in production"
-  - /gemini:mode:auto "plan user dashboard with analytics features"
-allowed-tools: Bash(ls:*), Bash(gemini:*)
-model: sonnet
----
-
-# Auto Template Selection (/gemini:mode:auto)
-
-## Overview
-Automatically analyzes user input to select the most appropriate template and execute Gemini CLI with optimal context.
-
-**Process**: List Templates → Analyze Input → Select Template → Execute with Context
-
-## Usage
-
-### Auto-Detection Examples
-```bash
-# Bug-related keywords → selects bug-fix.md
-/gemini:mode:auto "React component not rendering after state update"
-
-# Planning keywords → selects plan.md  
-/gemini:mode:auto "design microservices architecture for user management"
-
-# Error/crash keywords → selects bug-fix.md
-/gemini:mode:auto "API timeout errors in production environment"
-
-# Architecture/design keywords → selects plan.md
-/gemini:mode:auto "implement real-time chat system architecture"
-```
-
-## Template Selection Logic
-
-### Dynamic Template Discovery
-**Templates auto-discovered from**: `~/.claude/prompt-templates/`
-
-Templates are dynamically read from the directory, including their metadata (name, description, keywords) from the YAML frontmatter.
-
-### Template Metadata Parsing
-
-Each template contains YAML frontmatter with:
-```yaml
----
-name: template-name
-description: Template purpose description
-category: template-category
-keywords: [keyword1, keyword2, keyword3]
----
-```
-
-**Auto-selection based on:**
-- **Template keywords**: Matches user input against template-defined keywords
-- **Template name**: Direct name matching (e.g., "bug-fix" matches bug-related queries)  
-- **Template description**: Semantic matching against description text
-
-## Command Execution
-
-### Step 1: Template Discovery
-```bash
-# Dynamically discover all templates and extract YAML frontmatter
-cd ~/.claude/prompt-templates && echo "Discovering templates..." && for template_file in *.md; do echo "=== $template_file ==="; head -6 "$template_file" 2>/dev/null || echo "Error reading $template_file"; echo; done
-```
-
-### Step 2: Dynamic Template Analysis & Selection
-```pseudo
-FUNCTION select_template(user_input):
-  templates = list_directory("~/.claude/prompt-templates/")
-  template_metadata = {}
-  
-  # Parse all templates for metadata
-  FOR each template_file in templates:
-    content = read_file(template_file)
-    yaml_front = extract_yaml_frontmatter(content)
-    template_metadata[template_file] = {
-      "name": yaml_front.name,
-      "description": yaml_front.description, 
-      "keywords": yaml_front.keywords || [],
-      "category": yaml_front.category || "general"
-    }
-  
-  input_lower = user_input.toLowerCase()
-  best_match = null
-  highest_score = 0
-  
-  # Score each template against user input
-  FOR each template, metadata in template_metadata:
-    score = 0
-    
-    # Keyword matching (highest weight)
-    FOR each keyword in metadata.keywords:
-      IF input_lower.contains(keyword.toLowerCase()):
-        score += 3
-    
-    # Template name matching
-    IF input_lower.contains(metadata.name.toLowerCase()):
-      score += 2
-    
-    # Description semantic matching  
-    FOR each word in metadata.description.split():
-      IF input_lower.contains(word.toLowerCase()) AND word.length > 3:
-        score += 1
-    
-    IF score > highest_score:
-      highest_score = score
-      best_match = template
-  
-  # Default to first template if no matches
-  RETURN best_match || templates[0]
-END FUNCTION
-```
-
-### Step 3: Execute with Dynamically Selected Template
-```bash
-# Dynamic execution with selected template
-gemini --all-files -p "$(cat ~/.claude/prompt-templates/[selected_template])
-
-Context: @{CLAUDE.md,**/*CLAUDE.md}
-
-User Input: [user_input]"
-```
-
-**Template selection is completely dynamic** - any new templates added to the directory will be automatically discovered and available for selection based on their YAML frontmatter.
-
-## Options
-
-| Option | Purpose |
-|--------|---------|
-| `--list-templates` | Show available templates and exit |
-| `--template <name>` | Force specific template (overrides auto-selection) |
-| `--debug` | Show template selection reasoning |
-| `--save-session` | Save results to workflow session |
-
-### Manual Template Override
-```bash
-# Force specific template
-/gemini:mode:auto "user authentication" --template bug-fix.md
-/gemini:mode:auto "fix login issues" --template plan.md
-```
-
-### Dynamic Template Listing
-```bash
-# List all dynamically discovered templates
-/gemini:mode:auto --list-templates
-# Output:
-# Dynamically discovered templates in ~/.claude/prompt-templates/:
-# - bug-fix.md (用于定位bug并提供修改建议) [Keywords: 规划, bug, 修改方案]
-# - plan.md (软件架构规划和技术实现计划分析模板) [Keywords: 规划, 架构, 实现计划, 技术设计, 修改方案]
-# - [any-new-template].md (Auto-discovered description) [Keywords: auto-parsed]
-```
-
-**Complete template discovery** - new templates are automatically detected and their metadata parsed from YAML frontmatter.
-
-## Auto-Selection Examples
-
-### Dynamic Selection Examples
-```bash
-# Selection based on template keywords and metadata
-"login system crashes on startup" → Matches template with keywords: [bug, 修改方案]
-"design user dashboard with analytics" → Matches template with keywords: [规划, 架构, 技术设计]  
-"database timeout errors in production" → Matches template with keywords: [bug, 修改方案]
-"implement real-time notification system" → Matches template with keywords: [规划, 实现计划, 技术设计]
-
-# Any new templates added will be automatically matched
-"[user input]" → Dynamically matches against all template keywords and descriptions
-```
-
-
-## Session Integration
-
-When `--save-session` used, saves to:
-`.workflow/WFS-[topic]/.chat/auto-[template]-[timestamp].md`
-
-**Session includes:**
-- Original user input
-- Template selection reasoning
-- Template used
-- Complete analysis results
-
-This command streamlines template usage by automatically detecting user intent and selecting the optimal template for analysis.

.claude/commands/gemini/mode/bug-index.md

@@ -1,73 +0,0 @@
----
-name: bug-index
-description: Bug analysis and fix suggestions using specialized template
-usage: /gemini:mode:bug-index "bug description"
-argument-hint: "description of the bug or error you're experiencing"
-examples:
-  - /gemini:mode:bug-index "authentication null pointer error in login flow"
-  - /gemini:mode:bug-index "React component not re-rendering after state change"
-  - /gemini:mode:bug-index "database connection timeout in production"
-allowed-tools: Bash(gemini:*)
-model: sonnet
----
-
-# Bug Analysis Command (/gemini:mode:bug-index)
-
-## Overview
-Systematic bug analysis and fix suggestions using expert diagnostic template.
-
-## Usage
-
-### Basic Bug Analysis
-```bash
-/gemini:mode:bug-index "authentication error during login"
-```
-
-### With All Files Context
-```bash
-/gemini:mode:bug-index "React state not updating" --all-files
-```
-
-### Save to Workflow Session
-```bash
-/gemini:mode:bug-index "API timeout issues" --save-session
-```
-
-## Command Execution
-
-**Template Used**: `~/.claude/prompt-templates/bug-fix.md`
-
-**Executes**:
-```bash
-gemini --all-files -p "$(cat ~/.claude/prompt-templates/bug-fix.md)
-
-Context: @{CLAUDE.md,**/*CLAUDE.md}
-
-Bug Description: [user_description]"
-```
-
-## Analysis Focus
-
-The bug-fix template provides:
-- **Root Cause Analysis**: Systematic investigation
-- **Code Path Tracing**: Following execution flow  
-- **Targeted Solutions**: Specific, minimal fixes
-- **Impact Assessment**: Understanding side effects
-
-## Options
-
-| Option | Purpose |
-|--------|---------|
-| `--all-files` | Include entire codebase for analysis |
-| `--save-session` | Save analysis to workflow session |
-
-## Session Output
-
-When `--save-session` used, saves to:
-`.workflow/WFS-[topic]/.chat/bug-index-[timestamp].md`
-
-**Includes:**
-- Bug description
-- Template used  
-- Analysis results
-- Recommended actions

.claude/commands/gemini/mode/plan.md

@@ -1,75 +0,0 @@
----
-name: plan
-description: Project planning and architecture analysis using specialized template
-usage: /gemini:mode:plan "planning topic"
-argument-hint: "planning topic or architectural challenge to analyze"
-examples:
-  - /gemini:mode:plan "design user dashboard feature architecture"
-  - /gemini:mode:plan "plan microservices migration strategy"
-  - /gemini:mode:plan "implement real-time notification system"
-allowed-tools: Bash(gemini:*)
-model: sonnet
----
-
-# Planning Analysis Command (/gemini:mode:plan)
-
-## Overview
-Comprehensive project planning and architecture analysis using expert planning template.
-
-## Usage
-
-### Basic Planning Analysis
-```bash
-/gemini:mode:plan "design authentication system"
-```
-
-### With All Files Context
-```bash
-/gemini:mode:plan "microservices migration" --all-files
-```
-
-### Save to Workflow Session
-```bash
-/gemini:mode:plan "real-time notifications" --save-session
-```
-
-## Command Execution
-
-**Template Used**: `~/.claude/prompt-templates/plan.md`
-
-**Executes**:
-```bash
-gemini --all-files -p "$(cat ~/.claude/prompt-templates/plan.md)
-
-Context: @{CLAUDE.md,**/*CLAUDE.md}
-
-Planning Topic: [user_description]"
-```
-
-## Planning Focus
-
-The planning template provides:
-- **Requirements Analysis**: Functional and non-functional requirements
-- **Architecture Design**: System structure and interactions
-- **Implementation Strategy**: Step-by-step development approach  
-- **Risk Assessment**: Challenges and mitigation strategies
-- **Resource Planning**: Time, effort, and technology needs
-
-## Options
-
-| Option | Purpose |
-|--------|---------|
-| `--all-files` | Include entire codebase for context |
-| `--save-session` | Save analysis to workflow session |
-
-## Session Output
-
-When `--save-session` used, saves to:
-`.workflow/WFS-[topic]/.chat/plan-[timestamp].md`
-
-**Includes:**
-- Planning topic
-- Template used
-- Analysis results  
-- Implementation roadmap
-- Key decisions

.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

@@ -0,0 +1,468 @@
+---
+name: issue:discover
+description: Discover potential issues from multiple perspectives (bug, UX, test, quality, security, performance, maintainability, best-practices) using CLI explore. Supports Exa external research for security and best-practices perspectives.
+argument-hint: "<path-pattern> [--perspectives=bug,ux,...] [--external]"
+allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*), Task(*), AskUserQuestion(*), Glob(*), Grep(*)
+---
+
+# Issue Discovery Command
+
+## Quick Start
+
+```bash
+# Discover issues in specific module (interactive perspective selection)
+/issue:discover src/auth/**
+
+# Discover with specific perspectives
+/issue:discover src/payment/** --perspectives=bug,security,test
+
+# Discover with external research for all perspectives
+/issue:discover src/api/** --external
+
+# Discover in multiple modules
+/issue:discover src/auth/**,src/payment/**
+```
+
+**Discovery Scope**: Specified modules/files only
+**Output Directory**: `.workflow/issues/discoveries/{discovery-id}/`
+**Available Perspectives**: bug, ux, test, quality, security, performance, maintainability, best-practices
+**Exa Integration**: Auto-enabled for security and best-practices perspectives
+**CLI Tools**: Gemini → Qwen → Codex (fallback chain)
+
+## What & Why
+
+### Core Concept
+Multi-perspective issue discovery orchestrator that explores code from different angles to identify potential bugs, UX improvements, test gaps, and other actionable items. Unlike code review (which assesses existing code quality), discovery focuses on **finding opportunities for improvement and potential problems**.
+
+**vs Code Review**:
+- **Code Review** (`review-module-cycle`): Evaluates code quality against standards
+- **Issue Discovery** (`issue:discover`): Finds actionable issues, bugs, and improvement opportunities
+
+### Value Proposition
+1. **Proactive Issue Detection**: Find problems before they become bugs
+2. **Multi-Perspective Analysis**: Each perspective surfaces different types of issues
+3. **External Benchmarking**: Compare against industry best practices via Exa
+4. **Direct Issue Integration**: Discoveries can be exported to issue tracker
+5. **Dashboard Management**: View, filter, and export discoveries via CCW dashboard
+
+## How It Works
+
+### Execution Flow
+
+```
+Phase 1: Discovery & Initialization
+   └─ Parse target pattern, create session, initialize output structure
+
+Phase 2: Interactive Perspective Selection
+   └─ AskUserQuestion for perspective selection (or use --perspectives)
+
+Phase 3: Parallel Perspective Analysis
+   ├─ Launch N @cli-explore-agent instances (one per perspective)
+   ├─ Security & Best-Practices auto-trigger Exa research
+   ├─ Agent writes perspective JSON, returns summary
+   └─ Update discovery-progress.json
+
+Phase 4: Aggregation & Prioritization
+   ├─ Collect agent return summaries
+   ├─ Load perspective JSON files
+   ├─ Merge findings, deduplicate by file+line
+   └─ Calculate priority scores
+
+Phase 5: Issue Generation & Summary
+   ├─ Convert high-priority discoveries to issue format
+   ├─ 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
+
+### Available Perspectives
+
+| Perspective | Focus | Categories | Exa |
+|-------------|-------|------------|-----|
+| **bug** | Potential Bugs | edge-case, null-check, resource-leak, race-condition, boundary, exception-handling | - |
+| **ux** | User Experience | error-message, loading-state, feedback, accessibility, interaction, consistency | - |
+| **test** | Test Coverage | missing-test, edge-case-test, integration-gap, coverage-hole, assertion-quality | - |
+| **quality** | Code Quality | complexity, duplication, naming, documentation, code-smell, readability | - |
+| **security** | Security Issues | injection, auth, encryption, input-validation, data-exposure, access-control | ✓ |
+| **performance** | Performance | n-plus-one, memory-usage, caching, algorithm, blocking-operation, resource | - |
+| **maintainability** | Maintainability | coupling, cohesion, tech-debt, extensibility, module-boundary, interface-design | - |
+| **best-practices** | Best Practices | convention, pattern, framework-usage, anti-pattern, industry-standard | ✓ |
+
+### Interactive Perspective Selection
+
+When no `--perspectives` flag is provided, the command uses AskUserQuestion:
+
+```javascript
+AskUserQuestion({
+  questions: [{
+    question: "Select primary discovery focus:",
+    header: "Focus",
+    multiSelect: false,
+    options: [
+      { label: "Bug + Test + Quality", description: "Quick scan: potential bugs, test gaps, code quality (Recommended)" },
+      { label: "Security + Performance", description: "System audit: security issues, performance bottlenecks" },
+      { label: "Maintainability + Best-practices", description: "Long-term health: coupling, tech debt, conventions" },
+      { label: "Full analysis", description: "All 7 perspectives (comprehensive, takes longer)" }
+    ]
+  }]
+})
+```
+
+**Recommended Combinations**:
+- Quick scan: bug, test, quality
+- Full analysis: all perspectives
+- Security audit: security, bug, quality
+
+## Core Responsibilities
+
+### Orchestrator
+
+**Phase 1: Discovery & Initialization**
+
+```javascript
+// Step 1: Parse target pattern and resolve files
+const resolvedFiles = await expandGlobPattern(targetPattern);
+if (resolvedFiles.length === 0) {
+  throw new Error(`No files matched pattern: ${targetPattern}`);
+}
+
+// Step 2: Generate discovery ID
+const discoveryId = `DSC-${formatDate(new Date(), 'YYYYMMDD-HHmmss')}`;
+
+// Step 3: Create output directory
+const outputDir = `.workflow/issues/discoveries/${discoveryId}`;
+await mkdir(outputDir, { recursive: true });
+await mkdir(`${outputDir}/perspectives`, { recursive: true });
+
+// Step 4: Initialize unified discovery state (merged state+progress)
+await writeJson(`${outputDir}/discovery-state.json`, {
+  discovery_id: discoveryId,
+  target_pattern: targetPattern,
+  phase: "initialization",
+  created_at: new Date().toISOString(),
+  updated_at: new Date().toISOString(),
+  target: { files_count: { total: resolvedFiles.length }, project: {} },
+  perspectives: [],  // filled after selection: [{name, status, findings}]
+  external_research: { enabled: false, completed: false },
+  results: { total_findings: 0, issues_generated: 0, priority_distribution: {} }
+});
+```
+
+**Phase 2: Perspective Selection**
+
+```javascript
+// Check for --perspectives flag
+let selectedPerspectives = [];
+
+if (args.perspectives) {
+  selectedPerspectives = args.perspectives.split(',').map(p => p.trim());
+} else {
+  // Interactive selection via AskUserQuestion
+  const response = await AskUserQuestion({...});
+  selectedPerspectives = parseSelectedPerspectives(response);
+}
+
+// Validate and update state
+await updateDiscoveryState(outputDir, {
+  'metadata.perspectives': selectedPerspectives,
+  phase: 'parallel'
+});
+```
+
+**Phase 3: Parallel Perspective Analysis**
+
+Launch N agents in parallel (one per selected perspective):
+
+```javascript
+// Launch agents in parallel - agents write JSON and return summary
+const agentPromises = selectedPerspectives.map(perspective =>
+  Task({
+    subagent_type: "cli-explore-agent",
+    run_in_background: false,
+    description: `Discover ${perspective} issues`,
+    prompt: buildPerspectivePrompt(perspective, discoveryId, resolvedFiles, outputDir)
+  })
+);
+
+// Wait for all agents - collect their return summaries
+const results = await Promise.all(agentPromises);
+// results contain agent summaries for final report
+```
+
+**Phase 4: Aggregation & Prioritization**
+
+```javascript
+// Load all perspective JSON files written by agents
+const allFindings = [];
+for (const perspective of selectedPerspectives) {
+  const jsonPath = `${outputDir}/perspectives/${perspective}.json`;
+  if (await fileExists(jsonPath)) {
+    const data = await readJson(jsonPath);
+    allFindings.push(...data.findings.map(f => ({ ...f, perspective })));
+  }
+}
+
+// Deduplicate and prioritize
+const prioritizedFindings = deduplicateAndPrioritize(allFindings);
+
+// Update unified state
+await updateDiscoveryState(outputDir, {
+  phase: 'aggregation',
+  'results.total_findings': prioritizedFindings.length,
+  'results.priority_distribution': countByPriority(prioritizedFindings)
+});
+```
+
+**Phase 5: Issue Generation & Summary**
+
+```javascript
+// Convert high-priority findings to issues
+const issueWorthy = prioritizedFindings.filter(f =>
+  f.priority === 'critical' || f.priority === 'high' || f.priority_score >= 0.7
+);
+
+// Write discovery-issues.jsonl
+await writeJsonl(`${outputDir}/discovery-issues.jsonl`, issues);
+
+// Generate single summary.md from agent return summaries
+// Orchestrator briefly summarizes what agents returned (NO detailed reports)
+await writeSummaryFromAgentReturns(outputDir, results, prioritizedFindings, issues);
+
+// Update final state
+await updateDiscoveryState(outputDir, {
+  phase: 'complete',
+  updated_at: new Date().toISOString(),
+  'results.issues_generated': issues.length
+});
+```
+
+**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
+
+```
+.workflow/issues/discoveries/
+├── index.json                           # Discovery session index
+└── {discovery-id}/
+    ├── discovery-state.json             # Unified state (merged state+progress)
+    ├── perspectives/
+    │   └── {perspective}.json           # Per-perspective findings
+    ├── external-research.json           # Exa research results (if enabled)
+    ├── discovery-issues.jsonl           # Generated candidate issues
+    └── summary.md                       # Single summary (from agent returns)
+```
+
+### Schema References
+
+**External Schema Files** (agent MUST read and follow exactly):
+
+| Schema | Path | Purpose |
+|--------|------|---------|
+| **Discovery State** | `~/.claude/workflows/cli-templates/schemas/discovery-state-schema.json` | Session state machine |
+| **Discovery Finding** | `~/.claude/workflows/cli-templates/schemas/discovery-finding-schema.json` | Perspective analysis results |
+
+### Agent Invocation Template
+
+**Perspective Analysis Agent**:
+
+```javascript
+Task({
+  subagent_type: "cli-explore-agent",
+  run_in_background: false,
+  description: `Discover ${perspective} issues`,
+  prompt: `
+    ## Task Objective
+    Discover potential ${perspective} issues in specified module files.
+
+    ## Discovery Context
+    - Discovery ID: ${discoveryId}
+    - Perspective: ${perspective}
+    - Target Pattern: ${targetPattern}
+    - Resolved Files: ${resolvedFiles.length} files
+    - Output Directory: ${outputDir}
+
+    ## MANDATORY FIRST STEPS
+    1. Read discovery state: ${outputDir}/discovery-state.json
+    2. Read schema: ~/.claude/workflows/cli-templates/schemas/discovery-finding-schema.json
+    3. Analyze target files for ${perspective} concerns
+
+    ## Output Requirements
+
+    **1. Write JSON file**: ${outputDir}/perspectives/${perspective}.json
+    - Follow discovery-finding-schema.json exactly
+    - Each finding: id, title, priority, category, description, file, line, snippet, suggested_issue, confidence
+
+    **2. Return summary** (DO NOT write report file):
+    - Return a brief text summary of findings
+    - Include: total findings, priority breakdown, key issues
+    - This summary will be used by orchestrator for final report
+
+    ## Perspective-Specific Guidance
+    ${getPerspectiveGuidance(perspective)}
+
+    ## Success Criteria
+    - [ ] JSON written to ${outputDir}/perspectives/${perspective}.json
+    - [ ] Summary returned with findings count and key issues
+    - [ ] Each finding includes actionable suggested_issue
+    - [ ] Priority uses lowercase enum: critical/high/medium/low
+  `
+})
+```
+
+**Exa Research Agent** (for security and best-practices):
+
+```javascript
+Task({
+  subagent_type: "cli-explore-agent",
+  run_in_background: false,
+  description: `External research for ${perspective} via Exa`,
+  prompt: `
+    ## Task Objective
+    Research industry best practices for ${perspective} using Exa search
+
+    ## Research Steps
+    1. Read project tech stack: .workflow/project-tech.json
+    2. Use Exa to search for best practices
+    3. Synthesize findings relevant to this project
+
+    ## Output Requirements
+
+    **1. Write JSON file**: ${outputDir}/external-research.json
+    - Include sources, key_findings, gap_analysis, recommendations
+
+    **2. Return summary** (DO NOT write report file):
+    - Brief summary of external research findings
+    - Key recommendations for the project
+
+    ## Success Criteria
+    - [ ] JSON written to ${outputDir}/external-research.json
+    - [ ] Summary returned with key recommendations
+    - [ ] Findings are relevant to project's tech stack
+  `
+})
+```
+
+### Perspective Guidance Reference
+
+```javascript
+function getPerspectiveGuidance(perspective) {
+  const guidance = {
+    bug: `
+      Focus: Null checks, edge cases, resource leaks, race conditions, boundary conditions, exception handling
+      Priority: Critical=data corruption/crash, High=malfunction, Medium=edge case issues, Low=minor
+    `,
+    ux: `
+      Focus: Error messages, loading states, feedback, accessibility, interaction patterns, form validation
+      Priority: Critical=inaccessible, High=confusing, Medium=inconsistent, Low=cosmetic
+    `,
+    test: `
+      Focus: Missing unit tests, edge case coverage, integration gaps, assertion quality, test isolation
+      Priority: Critical=no security tests, High=no core logic tests, Medium=weak coverage, Low=minor gaps
+    `,
+    quality: `
+      Focus: Complexity, duplication, naming, documentation, code smells, readability
+      Priority: Critical=unmaintainable, High=significant issues, Medium=naming/docs, Low=minor refactoring
+    `,
+    security: `
+      Focus: Input validation, auth/authz, injection, XSS/CSRF, data exposure, access control
+      Priority: Critical=auth bypass/injection, High=missing authz, Medium=weak validation, Low=headers
+    `,
+    performance: `
+      Focus: N+1 queries, memory leaks, caching, algorithm efficiency, blocking operations
+      Priority: Critical=memory leaks, High=N+1/inefficient, Medium=missing cache, Low=minor optimization
+    `,
+    maintainability: `
+      Focus: Coupling, interface design, tech debt, extensibility, module boundaries, configuration
+      Priority: Critical=unrelated code changes, High=unclear boundaries, Medium=coupling, Low=refactoring
+    `,
+    'best-practices': `
+      Focus: Framework conventions, language patterns, anti-patterns, deprecated APIs, coding standards
+      Priority: Critical=anti-patterns causing bugs, High=convention violations, Medium=style, Low=cosmetic
+    `
+  };
+  return guidance[perspective] || 'General code discovery analysis';
+}
+```
+
+## Dashboard Integration
+
+### Viewing Discoveries
+
+Open CCW dashboard to manage discoveries:
+
+```bash
+ccw view
+```
+
+Navigate to **Issues > Discovery** to:
+- View all discovery sessions
+- Filter findings by perspective and priority
+- Preview finding details
+- Select and export findings as issues
+
+### Exporting to Issues
+
+From the dashboard, select findings and click "Export as Issues" to:
+1. Convert discoveries to standard issue format
+2. Append to `.workflow/issues/issues.jsonl`
+3. Set status to `registered`
+4. Continue with `/issue:plan` workflow
+
+## Related Commands
+
+```bash
+# After discovery, plan solutions for exported issues
+/issue:plan DSC-001,DSC-002,DSC-003
+
+# Or use interactive management
+/issue:manage
+```
+
+## Best Practices
+
+1. **Start Focused**: Begin with specific modules rather than entire codebase
+2. **Use Quick Scan First**: Start with bug, test, quality for fast results
+3. **Review Before Export**: Not all discoveries warrant issues - use dashboard to filter
+4. **Combine Perspectives**: Run related perspectives together (e.g., security + bug)
+5. **Enable Exa for New Tech**: When using unfamiliar frameworks, enable external research

.claude/commands/issue/execute.md

@@ -0,0 +1,581 @@
+---
+name: execute
+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(*)
+---
+
+# Issue Execute Command (/issue:execute)
+
+## Overview
+
+Minimal orchestrator that dispatches **solution IDs** to executors. Each executor receives a complete solution with all its tasks.
+
+**Design Principles:**
+- `queue dag` → returns parallel batches with solution IDs (S-1, S-2, ...)
+- `detail <id>` → READ-ONLY solution fetch (returns full solution with all tasks)
+- `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 --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 --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 + 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 (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 (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) {
+  console.log(dag.error || 'No solutions ready for execution');
+  console.log('Use /issue:queue to form a queue first');
+  return;
+}
+
+console.log(`
+## Queue DAG (Solution-Level)
+
+- Total Solutions: ${dag.total}
+- Ready: ${dag.ready_count}
+- Completed: ${dag.completed_count}
+- Parallel in batch 1: ${dag.parallel_batches[0]?.length || 0}
+`);
+
+// Interactive selection via AskUserQuestion
+const answer = AskUserQuestion({
+  questions: [
+    {
+      question: 'Select executor type:',
+      header: 'Executor',
+      multiSelect: false,
+      options: [
+        { label: 'Codex (Recommended)', description: 'Autonomous coding with full write access' },
+        { label: 'Gemini', description: 'Large context analysis and implementation' },
+        { label: 'Agent', description: 'Claude Code sub-agent for complex tasks' }
+      ]
+    },
+    {
+      question: 'Execution mode:',
+      header: 'Mode',
+      multiSelect: false,
+      options: [
+        { 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) {
+  console.log('### Parallel Batches (Dry-run):\n');
+  dag.parallel_batches.forEach((batch, i) => {
+    console.log(`Batch ${i + 1}: ${batch.join(', ')}`);
+  });
+  return;
+}
+```
+
+### Phase 0 & 2: Setup Queue Worktree & Dispatch
+
+```javascript
+// Parallelism determined by DAG - no manual limit
+// All solutions in same batch have NO file conflicts and can run in parallel
+const batch = dag.parallel_batches[0] || [];
+
+// Initialize TodoWrite
+TodoWrite({
+  todos: batch.map(id => ({
+    content: `Execute solution ${id}`,
+    status: 'pending',
+    activeForm: `Executing solution ${id}`
+  }))
+});
+
+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, worktreePath);
+});
+
+await Promise.all(executions);
+batch.forEach(id => updateTodo(id, 'completed'));
+```
+
+### Executor Dispatch
+
+```javascript
+// 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}
+\`\`\`
+
+### Step 2: Execute All Tasks Sequentially
+The detail command returns a FULL SOLUTION with all tasks.
+Execute each task in order (T1 → T2 → T3 → ...):
+
+For each task:
+1. Follow task.implementation steps
+2. Run task.test commands
+3. Verify task.acceptance criteria
+(Do NOT commit after each task)
+
+### Step 3: Commit Solution (Once)
+After ALL tasks pass, commit once with formatted summary:
+\`\`\`bash
+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_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}${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}${cdOption}`,
+      { timeout: 3600000, run_in_background: true }
+    );
+  } else {
+    return Task({
+      subagent_type: 'code-developer',
+      run_in_background: false,
+      description: `Execute solution ${solutionId}`,
+      prompt: worktreePath ? `Working directory: ${worktreePath}\n\n${prompt}` : prompt
+    });
+  }
+}
+```
+
+### Phase 3: Check Next Batch
+
+```javascript
+// 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
+
+- Solutions Completed: ${refreshedDag.completed_count}/${refreshedDag.total}
+- Next ready: ${refreshedDag.ready_count}
+`);
+
+if (refreshedDag.ready_count > 0) {
+  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                                                    │
+├─────────────────────────────────────────────────────────────────┤
+│ 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 (DAG guarantees)
+- **Main workspace stays clean** until merge/PR decision
+
+## CLI Endpoint Contract
+
+### `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-...",
+  "total": 3,
+  "ready_count": 2,
+  "completed_count": 0,
+  "nodes": [
+    { "id": "S-1", "issue_id": "ISS-xxx", "status": "pending", "ready": true, "task_count": 3 },
+    { "id": "S-2", "issue_id": "ISS-yyy", "status": "pending", "ready": true, "task_count": 2 },
+    { "id": "S-3", "issue_id": "ISS-zzz", "status": "pending", "ready": false, "depends_on": ["S-1"] }
+  ],
+  "parallel_batches": [["S-1", "S-2"], ["S-3"]]
+}
+```
+
+### `ccw issue detail <item_id>`
+Returns FULL SOLUTION with all tasks (READ-ONLY):
+```json
+{
+  "item_id": "S-1",
+  "issue_id": "ISS-xxx",
+  "solution_id": "SOL-xxx",
+  "status": "pending",
+  "solution": {
+    "id": "SOL-xxx",
+    "approach": "...",
+    "tasks": [
+      { "id": "T1", "title": "...", "implementation": [...], "test": {...} },
+      { "id": "T2", "title": "...", "implementation": [...], "test": {...} },
+      { "id": "T3", "title": "...", "implementation": [...], "test": {...} }
+    ],
+    "exploration_context": { "relevant_files": [...] }
+  },
+  "execution_hints": { "executor": "codex", "estimated_minutes": 180 }
+}
+```
+
+### `ccw issue done <item_id>`
+Marks solution completed/failed, updates queue state, checks for queue completion.
+
+## Error Handling
+
+| Error | Resolution |
+|-------|------------|
+| No queue | Run /issue:queue first |
+| No ready solutions | Dependencies blocked, check DAG |
+| Executor timeout | Solution not marked done, can retry |
+| Solution failure | Use `ccw issue retry` to reset |
+| Partial task failure | Executor reports which task failed via `done --fail` |
+
+## Related Commands
+
+- `/issue:plan` - Plan issues with solutions
+- `/issue:queue` - Form execution queue
+- `ccw issue queue dag` - View dependency graph
+- `ccw issue detail <id>` - View task details
+- `ccw issue retry` - Reset failed tasks

.claude/commands/issue/new.md

@@ -0,0 +1,413 @@
+---
+name: new
+description: Create structured issue from GitHub URL or text description
+argument-hint: "<github-url | text-description> [--priority 1-5]"
+allowed-tools: TodoWrite(*), Bash(*), Read(*), AskUserQuestion(*), mcp__ace-tool__search_context(*)
+---
+
+# Issue New Command (/issue:new)
+
+## Core Principle
+
+**Requirement Clarity Detection** → Ask only when needed
+
+```
+Clear Input (GitHub URL, structured text)  → Direct creation
+Unclear Input (vague description)          → Minimal clarifying questions
+```
+
+## Issue Structure 
+
+```typescript
+interface Issue {
+  id: string;                    // GH-123 or ISS-YYYYMMDD-HHMMSS
+  title: string;
+  status: 'registered' | 'planned' | 'queued' | 'in_progress' | 'completed' | 'failed';
+  priority: number;              // 1 (critical) to 5 (low)
+  context: string;               // Problem description (single source of truth)
+  source: 'github' | 'text' | 'discovery';
+  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;
+  affected_components?: string[];
+
+  // Feedback history (failures + human clarifications)
+  feedback?: {
+    type: 'failure' | 'clarification' | 'rejection';
+    stage: string;               // new/plan/execute
+    content: string;
+    created_at: string;
+  }[];
+
+  // Solution binding
+  bound_solution_id: string | null;
+
+  // Timestamps
+  created_at: string;
+  updated_at: string;
+}
+```
+
+## Quick Reference
+
+```bash
+# Clear inputs - direct creation
+/issue:new https://github.com/owner/repo/issues/123
+/issue:new "Login fails with special chars. Expected: success. Actual: 500 error"
+
+# Vague input - will ask clarifying questions
+/issue:new "something wrong with auth"
+```
+
+## Implementation
+
+### Phase 1: Input Analysis & Clarity Detection
+
+```javascript
+const input = userInput.trim();
+const flags = parseFlags(userInput);  // --priority
+
+// Detect input type and clarity
+const isGitHubUrl = input.match(/github\.com\/[\w-]+\/[\w-]+\/issues\/\d+/);
+const isGitHubShort = input.match(/^#(\d+)$/);
+const hasStructure = input.match(/(expected|actual|affects|steps):/i);
+
+// Clarity score: 0-3
+let clarityScore = 0;
+if (isGitHubUrl || isGitHubShort) clarityScore = 3;  // GitHub = fully clear
+else if (hasStructure) clarityScore = 2;             // Structured text = clear
+else if (input.length > 50) clarityScore = 1;        // Long text = somewhat clear
+else clarityScore = 0;                               // Vague
+
+let issueData = {};
+```
+
+### Phase 2: Data Extraction (GitHub or Text)
+
+```javascript
+if (isGitHubUrl || isGitHubShort) {
+  // GitHub - fetch via gh CLI
+  const result = Bash(`gh issue view ${extractIssueRef(input)} --json number,title,body,labels,url`);
+  const gh = JSON.parse(result);
+  issueData = {
+    id: `GH-${gh.number}`,
+    title: gh.title,
+    source: 'github',
+    source_url: gh.url,
+    labels: gh.labels.map(l => l.name),
+    context: gh.body?.substring(0, 500) || gh.title,
+    ...parseMarkdownBody(gh.body)
+  };
+} else {
+  // Text description
+  issueData = {
+    id: `ISS-${new Date().toISOString().replace(/[-:T]/g, '').slice(0, 14)}`,
+    source: 'text',
+    ...parseTextDescription(input)
+  };
+}
+```
+
+### Phase 3: Lightweight Context Hint (Conditional)
+
+```javascript
+// ACE search ONLY for medium clarity (1-2) AND missing components
+// Skip for: GitHub (has context), vague (needs clarification first)
+// Note: Deep exploration happens in /issue:plan, this is just a quick hint
+
+if (clarityScore >= 1 && clarityScore <= 2 && !issueData.affected_components?.length) {
+  const keywords = extractKeywords(issueData.context);
+
+  if (keywords.length >= 2) {
+    try {
+      const aceResult = mcp__ace-tool__search_context({
+        project_root_path: process.cwd(),
+        query: keywords.slice(0, 3).join(' ')
+      });
+      issueData.affected_components = aceResult.files?.slice(0, 3) || [];
+    } catch {
+      // ACE failure is non-blocking
+    }
+  }
+}
+```
+
+### Phase 4: Conditional Clarification (Only if Unclear)
+
+```javascript
+// ONLY ask questions if clarity is low - simple open-ended prompt
+if (clarityScore < 2 && (!issueData.context || issueData.context.length < 20)) {
+  const answer = AskUserQuestion({
+    questions: [{
+      question: 'Please describe the issue in more detail:',
+      header: 'Clarify',
+      multiSelect: false,
+      options: [
+        { label: 'Provide details', description: 'Describe what, where, and expected behavior' }
+      ]
+    }]
+  });
+
+  // Use custom text input (via "Other")
+  if (answer.customText) {
+    issueData.context = answer.customText;
+    issueData.title = answer.customText.split(/[.\n]/)[0].substring(0, 60);
+    issueData.feedback = [{
+      type: 'clarification',
+      stage: 'new',
+      content: answer.customText,
+      created_at: new Date().toISOString()
+    }];
+  }
+}
+```
+
+### 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)
+
+**Confirmation** (only for vague inputs, clarityScore < 2):
+- Use `AskUserQuestion` to confirm before creation
+
+**Issue Creation** (via CLI endpoint):
+```bash
+# 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:**
+| Feature | Description |
+|---------|-------------|
+| Auto-increment ID | `ISS-YYYYMMDD-NNN` (e.g., `ISS-20251229-001`) |
+| Trailing newline | Proper JSONL format, no corruption |
+| JSON output | Returns created issue with all fields |
+
+**Example:**
+```bash
+# 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\"",
+  "priority": 2,
+  "source": "text",
+  "expected_behavior": "Login succeeds",
+  "actual_behavior": "500 Internal Server Error"
+}
+EOF
+
+# Output (JSON)
+{
+  "id": "ISS-20251229-001",
+  "title": "Login fails with special chars",
+  "status": "registered",
+  ...
+}
+```
+
+**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
+
+```
+Phase 1: Input Analysis
+   └─ Detect clarity score (GitHub URL? Structured text? Keywords?)
+
+Phase 2: Data Extraction (branched by clarity)
+   ┌────────────┬─────────────────┬──────────────┐
+   │  Score 3   │   Score 1-2     │   Score 0    │
+   │  GitHub    │   Text + ACE    │   Vague      │
+   ├────────────┼─────────────────┼──────────────┤
+   │  gh CLI    │  Parse struct   │ AskQuestion  │
+   │  → parse   │  + quick hint   │ (1 question) │
+   │            │  (3 files max)  │  → feedback  │
+   └────────────┴─────────────────┴──────────────┘
+
+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
+```
+
+## Helper Functions
+
+```javascript
+function extractKeywords(text) {
+  const stopWords = new Set(['the', 'a', 'an', 'is', 'are', 'was', 'were', 'not', 'with']);
+  return text
+    .toLowerCase()
+    .split(/\W+/)
+    .filter(w => w.length > 3 && !stopWords.has(w))
+    .slice(0, 5);
+}
+
+function parseTextDescription(text) {
+  const result = { title: '', context: '' };
+  const sentences = text.split(/\.(?=\s|$)/);
+
+  result.title = sentences[0]?.trim().substring(0, 60) || 'Untitled';
+  result.context = text.substring(0, 500);
+
+  // Extract structured fields if present
+  const expected = text.match(/expected:?\s*([^.]+)/i);
+  const actual = text.match(/actual:?\s*([^.]+)/i);
+  const affects = text.match(/affects?:?\s*([^.]+)/i);
+
+  if (expected) result.expected_behavior = expected[1].trim();
+  if (actual) result.actual_behavior = actual[1].trim();
+  if (affects) {
+    result.affected_components = affects[1].split(/[,\s]+/).filter(c => c.includes('/') || c.includes('.'));
+  }
+
+  return result;
+}
+
+function parseMarkdownBody(body) {
+  if (!body) return {};
+  const result = {};
+
+  const problem = body.match(/##?\s*(problem|description)[:\s]*([\s\S]*?)(?=##|$)/i);
+  const expected = body.match(/##?\s*expected[:\s]*([\s\S]*?)(?=##|$)/i);
+  const actual = body.match(/##?\s*actual[:\s]*([\s\S]*?)(?=##|$)/i);
+
+  if (problem) result.context = problem[2].trim().substring(0, 500);
+  if (expected) result.expected_behavior = expected[2].trim();
+  if (actual) result.actual_behavior = actual[2].trim();
+
+  return result;
+}
+```
+
+## Examples
+
+### Clear Input (No Questions)
+
+```bash
+/issue:new https://github.com/org/repo/issues/42
+# → Fetches, parses, creates immediately
+
+/issue:new "Login fails with special chars. Expected: success. Actual: 500"
+# → Parses structure, creates immediately
+```
+
+### Vague Input (1 Question)
+
+```bash
+/issue:new "auth broken"
+# → Asks: "Input unclear. What is the issue about?"
+# → User provides details → saved to feedback[]
+# → Creates issue
+```
+
+## Related Commands
+
+- `/issue:plan` - Plan solution for issue
+

.claude/commands/issue/plan.md

@@ -0,0 +1,344 @@
+---
+name: plan
+description: Batch plan issue resolution using issue-plan-agent (explore + plan closed-loop)
+argument-hint: "--all-pending <issue-id>[,<issue-id>,...] [--batch-size 3] "
+allowed-tools: TodoWrite(*), Task(*), SlashCommand(*), AskUserQuestion(*), Bash(*), Read(*), Write(*)
+---
+
+# Issue Plan Command (/issue:plan)
+
+## Overview
+
+Unified planning command using **issue-plan-agent** that combines exploration and planning into a single closed-loop workflow.
+
+**Behavior:**
+- Single solution per issue → auto-bind
+- Multiple solutions → return for user selection
+- Agent handles file generation
+
+## Core Guidelines
+
+**⚠️ Data Access Principle**: Issues and solutions files can grow very large. To avoid context overflow:
+
+| Operation | Correct | Incorrect |
+|-----------|---------|-----------|
+| List issues (brief) | `ccw issue list --status pending --brief` | `Read('issues.jsonl')` |
+| Read issue details | `ccw issue status <id> --json` | `Read('issues.jsonl')` |
+| Update status | `ccw issue update <id> --status ...` | Direct file edit |
+| Bind solution | `ccw issue bind <id> <sol-id>` | Direct file edit |
+
+**Output Options**:
+- `--brief`: JSON with minimal fields (id, title, status, priority, tags)
+- `--json`: Full JSON (agent use only)
+
+**Orchestration vs Execution**:
+- **Command (orchestrator)**: Use `--brief` for minimal context
+- **Agent (executor)**: Fetch full details → `ccw issue status <id> --json`
+
+**ALWAYS** use CLI commands for CRUD operations. **NEVER** read entire `issues.jsonl` or `solutions/*.jsonl` directly. 
+
+## Usage
+
+```bash
+/issue:plan [<issue-id>[,<issue-id>,...]] [FLAGS]
+
+# Examples
+/issue:plan                           # Default: --all-pending
+/issue:plan GH-123                    # Single issue
+/issue:plan GH-123,GH-124,GH-125      # Batch (up to 3)
+/issue:plan --all-pending             # All pending issues (explicit)
+
+# Flags
+--batch-size <n>      Max issues per agent batch (default: 3)
+```
+
+## Execution Process
+
+```
+Phase 1: Issue Loading
+   ├─ Parse input (single, comma-separated, or --all-pending)
+   ├─ Fetch issue metadata (ID, title, tags)
+   ├─ Validate issues exist (create if needed)
+   └─ Group by similarity (shared tags or title keywords, max 3 per batch)
+
+Phase 2: Unified Explore + Plan (issue-plan-agent)
+   ├─ Launch issue-plan-agent per batch
+   ├─ Agent performs:
+   │   ├─ ACE semantic search for each issue
+   │   ├─ Codebase exploration (files, patterns, dependencies)
+   │   ├─ Solution generation with task breakdown
+   │   └─ Conflict detection across issues
+   └─ Output: solution JSON per issue
+
+Phase 3: Solution Registration & Binding
+   ├─ Append solutions to solutions/{issue-id}.jsonl
+   ├─ Single solution per issue → auto-bind
+   ├─ Multiple candidates → AskUserQuestion to select
+   └─ Update issues.jsonl with bound_solution_id
+
+Phase 4: Summary
+   ├─ Display bound solutions
+   ├─ Show task counts per issue
+   └─ Display next steps (/issue:queue)
+```
+
+## Implementation
+
+### Phase 1: Issue Loading (Brief Info Only)
+
+```javascript
+const batchSize = flags.batchSize || 3;
+let issues = [];  // {id, title, tags} - brief info for grouping only
+
+// Default to --all-pending if no input provided
+const useAllPending = flags.allPending || !userInput || userInput.trim() === '';
+
+if (useAllPending) {
+  // Get pending issues with brief metadata via CLI
+  const result = Bash(`ccw issue list --status pending,registered --json`).trim();
+  const parsed = result ? JSON.parse(result) : [];
+  issues = parsed.map(i => ({ id: i.id, title: i.title || '', tags: i.tags || [] }));
+
+  if (issues.length === 0) {
+    console.log('No pending issues found.');
+    return;
+  }
+  console.log(`Found ${issues.length} pending issues`);
+} else {
+  // Parse comma-separated issue IDs, fetch brief metadata
+  const ids = userInput.includes(',')
+    ? userInput.split(',').map(s => s.trim())
+    : [userInput.trim()];
+
+  for (const id of ids) {
+    Bash(`ccw issue init ${id} --title "Issue ${id}" 2>/dev/null || true`);
+    const info = Bash(`ccw issue status ${id} --json`).trim();
+    const parsed = info ? JSON.parse(info) : {};
+    issues.push({ id, title: parsed.title || '', tags: parsed.tags || [] });
+  }
+}
+// Note: Agent fetches full issue content via `ccw issue status <id> --json`
+
+// Semantic grouping via Gemini CLI (max 4 issues per group)
+async function groupBySimilarityGemini(issues) {
+  const issueSummaries = issues.map(i => ({
+    id: i.id, title: i.title, tags: i.tags
+  }));
+
+  const prompt = `
+PURPOSE: Group similar issues by semantic similarity for batch processing; maximize within-group coherence; max 4 issues per group
+TASK: • Analyze issue titles/tags semantically • Identify functional/architectural clusters • Assign each issue to one group
+MODE: analysis
+CONTEXT: Issue metadata only
+EXPECTED: JSON with groups array, each containing max 4 issue_ids, theme, rationale
+CONSTRAINTS: Each issue in exactly one group | Max 4 issues per group | Balance group sizes
+
+INPUT:
+${JSON.stringify(issueSummaries, null, 2)}
+
+OUTPUT FORMAT:
+{"groups":[{"group_id":1,"theme":"...","issue_ids":["..."],"rationale":"..."}],"ungrouped":[]}
+`;
+
+  const taskId = Bash({
+    command: `ccw cli -p "${prompt}" --tool gemini --mode analysis`,
+    run_in_background: true, timeout: 600000
+  });
+  const output = TaskOutput({ task_id: taskId, block: true });
+
+  // Extract JSON from potential markdown code blocks
+  function extractJsonFromMarkdown(text) {
+    const jsonMatch = text.match(/```json\s*\n([\s\S]*?)\n```/) ||
+                      text.match(/```\s*\n([\s\S]*?)\n```/);
+    return jsonMatch ? jsonMatch[1] : text;
+  }
+
+  const result = JSON.parse(extractJsonFromMarkdown(output));
+  return result.groups.map(g => g.issue_ids.map(id => issues.find(i => i.id === id)));
+}
+
+const batches = await groupBySimilarityGemini(issues);
+console.log(`Processing ${issues.length} issues in ${batches.length} batch(es) (max 4 issues/agent)`);
+
+TodoWrite({
+  todos: batches.map((_, i) => ({
+    content: `Plan batch ${i+1}`,
+    status: 'pending',
+    activeForm: `Planning batch ${i+1}`
+  }))
+});
+```
+
+### Phase 2: Unified Explore + Plan (issue-plan-agent) - PARALLEL
+
+```javascript
+Bash(`mkdir -p .workflow/issues/solutions`);
+const pendingSelections = [];  // Collect multi-solution issues for user selection
+const agentResults = [];       // Collect all agent results for conflict aggregation
+
+// Build prompts for all batches
+const agentTasks = batches.map((batch, batchIndex) => {
+  const issueList = batch.map(i => `- ${i.id}: ${i.title}${i.tags.length ? ` [${i.tags.join(', ')}]` : ''}`).join('\n');
+  const batchIds = batch.map(i => i.id);
+
+  const issuePrompt = `
+## Plan Issues
+
+**Issues** (grouped by similarity):
+${issueList}
+
+**Project Root**: ${process.cwd()}
+
+### Project Context (MANDATORY)
+1. Read: .workflow/project-tech.json (technology stack, architecture)
+2. Read: .workflow/project-guidelines.json (constraints and conventions)
+
+### Workflow
+1. Fetch issue details: ccw issue status <id> --json
+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}-{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
+
+### Return Summary
+{"bound":[{"issue_id":"...","solution_id":"...","task_count":N}],"pending_selection":[{"issue_id":"...","solutions":[{"id":"...","description":"...","task_count":N}]}]}
+`;
+
+  return { batchIndex, batchIds, issuePrompt, batch };
+});
+
+// Launch agents in parallel (max 10 concurrent)
+const MAX_PARALLEL = 10;
+for (let i = 0; i < agentTasks.length; i += MAX_PARALLEL) {
+  const chunk = agentTasks.slice(i, i + MAX_PARALLEL);
+  const taskIds = [];
+
+  // Launch chunk in parallel
+  for (const { batchIndex, batchIds, issuePrompt, batch } of chunk) {
+    updateTodo(`Plan batch ${batchIndex + 1}`, 'in_progress');
+    const taskId = Task(
+      subagent_type="issue-plan-agent",
+      run_in_background=true,
+      description=`Explore & plan ${batch.length} issues: ${batchIds.join(', ')}`,
+      prompt=issuePrompt
+    );
+    taskIds.push({ taskId, batchIndex });
+  }
+
+  console.log(`Launched ${taskIds.length} agents (batch ${i/MAX_PARALLEL + 1}/${Math.ceil(agentTasks.length/MAX_PARALLEL)})...`);
+
+  // Collect results from this chunk
+  for (const { taskId, batchIndex } of taskIds) {
+    const result = TaskOutput(task_id=taskId, block=true);
+
+    // Extract JSON from potential markdown code blocks (agent may wrap in ```json...```)
+    const jsonText = extractJsonFromMarkdown(result);
+    let summary;
+    try {
+      summary = JSON.parse(jsonText);
+    } catch (e) {
+      console.log(`⚠ Batch ${batchIndex + 1}: Failed to parse agent result, skipping`);
+      updateTodo(`Plan batch ${batchIndex + 1}`, 'completed');
+      continue;
+    }
+    agentResults.push(summary);  // Store for Phase 3 conflict aggregation
+
+    for (const item of summary.bound || []) {
+      console.log(`✓ ${item.issue_id}: ${item.solution_id} (${item.task_count} tasks)`);
+    }
+    // Collect and notify pending selections
+    for (const pending of summary.pending_selection || []) {
+      console.log(`⏳ ${pending.issue_id}: ${pending.solutions.length} solutions → awaiting selection`);
+      pendingSelections.push(pending);
+    }
+    if (summary.conflicts?.length > 0) {
+      console.log(`⚠ Conflicts: ${summary.conflicts.length} detected (will resolve in Phase 3)`);
+    }
+    updateTodo(`Plan batch ${batchIndex + 1}`, 'completed');
+  }
+}
+```
+
+### Phase 3: Conflict Resolution & Solution Selection
+
+**Conflict Handling:**
+- Collect `conflicts` from all agent results
+- Low/Medium severity → auto-resolve with `recommended_resolution`
+- High severity → use `AskUserQuestion` to let user choose resolution
+
+**Multi-Solution Selection:**
+- If `pending_selection` contains issues with multiple solutions:
+  - Use `AskUserQuestion` to present options (solution ID + task count + description)
+  - Extract selected solution ID from user response
+  - Verify solution file exists, recover from payload if missing
+  - Bind selected solution via `ccw issue bind <issue-id> <solution-id>`
+
+### Phase 4: Summary
+
+```javascript
+// Count planned issues via CLI
+const planned = JSON.parse(Bash(`ccw issue list --status planned --brief`) || '[]');
+const plannedCount = planned.length;
+
+console.log(`
+## Done: ${issues.length} issues → ${plannedCount} planned
+
+Next: \`/issue:queue\` → \`/issue:execute\`
+`);
+```
+
+## Error Handling
+
+| Error | Resolution |
+|-------|------------|
+| Issue not found | Auto-create in issues.jsonl |
+| ACE search fails | Agent falls back to ripgrep |
+| No solutions generated | Display error, suggest manual planning |
+| 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:
+
+- [ ] All input issues have solutions in `solutions/{issue-id}.jsonl`
+- [ ] Single solution issues are auto-bound (`bound_solution_id` set)
+- [ ] Multi-solution issues returned in `pending_selection` for user choice
+- [ ] Each solution has executable tasks with `modification_points`
+- [ ] Task acceptance criteria are quantified (not vague)
+- [ ] Conflicts detected and reported (if multiple issues touch same files)
+- [ ] Issue status updated to `planned` after binding
+
+## Related Commands
+
+- `/issue:queue` - Form execution queue from bound solutions
+- `ccw issue list` - List all issues
+- `ccw issue status` - View issue and solution details

.claude/commands/issue/queue.md

@@ -0,0 +1,441 @@
+---
+name: queue
+description: Form execution queue from bound solutions using issue-queue-agent (solution-level)
+argument-hint: "[--queues <n>] [--issue <id>]"
+allowed-tools: TodoWrite(*), Task(*), Bash(*), Read(*), Write(*)
+---
+
+# Issue Queue Command (/issue:queue)
+
+## Overview
+
+Queue formation command using **issue-queue-agent** that analyzes all bound solutions, resolves **inter-solution** conflicts, and creates an ordered execution queue at **solution level**.
+
+**Design Principle**: Queue items are **solutions**, not individual tasks. Each executor receives a complete solution with all its tasks.
+
+## Core Capabilities
+
+- **Agent-driven**: issue-queue-agent handles all ordering logic
+- **Solution-level granularity**: Queue items are solutions, not tasks
+- **Conflict clarification**: High-severity conflicts prompt user decision
+- Semantic priority calculation per solution (0.0-1.0)
+- Parallel/Sequential group assignment for solutions
+
+## Core Guidelines
+
+**⚠️ Data Access Principle**: Issues and queue files can grow very large. To avoid context overflow:
+
+| Operation | Correct | Incorrect |
+|-----------|---------|-----------|
+| List issues (brief) | `ccw issue list --status planned --brief` | `Read('issues.jsonl')` |
+| List queue (brief) | `ccw issue queue --brief` | `Read('queues/*.json')` |
+| Read issue details | `ccw issue status <id> --json` | `Read('issues.jsonl')` |
+| 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)
+- `--json`: Full JSON (agent use only)
+
+**Orchestration vs Execution**:
+- **Command (orchestrator)**: Use `--brief` for minimal context
+- **Agent (executor)**: Fetch full details → `ccw issue status <id> --json`
+
+**ALWAYS** use CLI commands for CRUD operations. **NEVER** read entire `issues.jsonl` or `queues/*.json` directly.
+
+
+
+## Usage
+
+```bash
+/issue:queue [FLAGS]
+
+# 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)
+/issue:queue --switch QUE-xxx     # Switch active queue
+/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
+```
+
+## Execution Process
+
+```
+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
+   └─ If --queues > 1: Partition solutions into N groups (minimize cross-group file conflicts)
+
+Phase 2-4: Agent-Driven Queue Formation (issue-queue-agent)
+   ├─ 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)
+   └─ Each agent writes: queue JSON + index update (NOT active yet)
+
+Phase 5: Conflict Clarification (if needed)
+   ├─ 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 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 & Distribution
+
+**Data Loading:**
+- 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 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
+{
+  "issue_id": "ISS-xxx",
+  "solution_id": "SOL-ISS-xxx-1",
+  "task_count": 3,
+  "files_touched": ["src/auth.ts", "src/utils.ts"],
+  "priority": "medium"
+}
+```
+
+**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 IDs** (command layer, pass to agent):
+```javascript
+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** (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 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)
+Step 5: Assign execution groups: P* (parallel, no overlaps) / S* (sequential, shared files)
+Step 6: Write queue JSON + update index
+
+### Output Requirements
+
+**Write files** (exactly 2):
+- `.workflow/issues/queues/${queueId}.json` - Full queue with solutions, conflicts, groups
+- `.workflow/issues/queues/index.json` - Update with new queue entry
+
+**Return JSON**:
+\`\`\`json
+{
+  "queue_id": "${queueId}",
+  "total_solutions": N,
+  "total_tasks": N,
+  "execution_groups": [{"id": "P1", "type": "parallel", "count": N}],
+  "issues_queued": ["ISS-xxx"],
+  "clarifications": [{"conflict_id": "CFT-1", "question": "...", "options": [...]}]
+}
+\`\`\`
+
+### Rules
+- Solution granularity (NOT individual tasks)
+- 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
+- [ ] Index updated with active_queue_id
+- [ ] No circular dependencies
+- [ ] Parallel groups have no file overlaps
+- [ ] Return JSON matches required shape
+```
+
+**Launch Agents** (parallel if multi-queue):
+```javascript
+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 (or all results if multi-queue)
+- If any `clarifications` array exists and non-empty → user decision required
+
+**Clarification Flow:**
+```javascript
+if (allClarifications.length > 0) {
+  for (const clarification of allClarifications) {
+    // Present to user via AskUserQuestion
+    const answer = AskUserQuestion({
+      questions: [{
+        question: `[${clarification.queue_id}] ${clarification.question}`,
+        header: clarification.conflict_id,
+        options: clarification.options,
+        multiSelect: false
+      }]
+    });
+
+    // Resume respective agent with user decision
+    Task(
+      subagent_type="issue-queue-agent",
+      resume=clarification.agent_id,
+      prompt=`Conflict ${clarification.conflict_id} resolved: ${answer.selected}`
+    );
+  }
+}
+```
+
+### Phase 6: Status Update & Summary
+
+**Status Update** (MUST use CLI command, NOT direct file operations):
+
+```bash
+# Option 1: Batch update from queue (recommended)
+ccw issue update --from-queue [queue-id] --json
+ccw issue update --from-queue --json              # Use active queue
+ccw issue update --from-queue QUE-xxx --json      # Use specific queue
+
+# Option 2: Individual issue update
+ccw issue update <issue-id> --status queued
+```
+
+**⚠️ IMPORTANT**: Do NOT directly modify `issues.jsonl`. Always use CLI command to ensure proper validation and history tracking.
+
+**Output** (JSON):
+```json
+{
+  "success": true,
+  "queue_id": "QUE-xxx",
+  "queued": ["ISS-001", "ISS-002"],
+  "queued_count": 2,
+  "unplanned": ["ISS-003"],
+  "unplanned_count": 1
+}
+```
+
+**Behavior:**
+- Updates issues in queue to `status: 'queued'` (skips already queued/executing/completed)
+- Identifies planned issues with `bound_solution_id` NOT in queue → `unplanned` array
+- Optional `queue-id`: defaults to active queue if omitted
+
+**Summary Output:**
+- Display queue ID, solution count, task count
+- 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)
+
+```
+.workflow/issues/
+├── issues.jsonl              # All issues (one per line)
+├── queues/                   # Queue history directory
+│   ├── index.json            # Queue index (active + history)
+│   ├── {queue-id}.json       # Individual queue files
+│   └── ...
+└── solutions/
+    ├── {issue-id}.jsonl      # Solutions for issue
+    └── ...
+```
+
+### Queue Index Schema
+
+```json
+{
+  "active_queue_id": "QUE-20251227-143000",
+  "active_queue_group": "QGR-20251227-143000",
+  "queues": [
+    {
+      "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,
+      "completed_solutions": 1,
+      "created_at": "2025-12-27T14:30:00Z"
+    }
+  ]
+}
+```
+
+**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
+
+| Error | Resolution |
+|-------|------------|
+| No bound solutions | Display message, suggest /issue:plan |
+| Circular dependency | List cycles, abort queue formation |
+| High-severity conflict | Return `clarifications`, prompt user decision |
+| 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` (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: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/code-map-memory.md

@@ -0,0 +1,687 @@
+---
+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/commands/memory/compact.md

@@ -0,0 +1,383 @@
+---
+name: compact
+description: Compact current session memory into structured text for session recovery, extracting objective/plan/files/decisions/constraints/state, and save via MCP core_memory tool
+argument-hint: "[optional: session description]"
+allowed-tools: mcp__ccw-tools__core_memory(*), Read(*)
+examples:
+  - /memory:compact
+  - /memory:compact "completed core-memory module"
+---
+
+# Memory Compact Command (/memory:compact)
+
+## 1. Overview
+
+The `memory:compact` command **compresses current session working memory** into structured text optimized for **session recovery**, extracts critical information, and saves it to persistent storage via MCP `core_memory` tool.
+
+**Core Philosophy**:
+- **Session Recovery First**: Capture everything needed to resume work seamlessly
+- **Minimize Re-exploration**: Include file paths, decisions, and state to avoid redundant analysis
+- **Preserve Train of Thought**: Keep notes and hypotheses for complex debugging
+- **Actionable State**: Record last action result and known issues
+
+## 2. Parameters
+
+- `"session description"` (Optional): Session description to supplement objective
+  - Example: "completed core-memory module"
+  - Example: "debugging JWT refresh - suspected memory leak"
+
+## 3. Structured Output Format
+
+```markdown
+## Session ID
+[WFS-ID if workflow session active, otherwise (none)]
+
+## Project Root
+[Absolute path to project root, e.g., D:\Claude_dms3]
+
+## Objective
+[High-level goal - the "North Star" of this session]
+
+## Execution Plan
+[CRITICAL: Embed the LATEST plan in its COMPLETE and DETAILED form]
+
+### Source: [workflow | todo | user-stated | inferred]
+
+<details>
+<summary>Full Execution Plan (Click to expand)</summary>
+
+[PRESERVE COMPLETE PLAN VERBATIM - DO NOT SUMMARIZE]
+- ALL phases, tasks, subtasks
+- ALL file paths (absolute)
+- ALL dependencies and prerequisites
+- ALL acceptance criteria
+- ALL status markers ([x] done, [ ] pending)
+- ALL notes and context
+
+Example:
+## Phase 1: Setup
+- [x] Initialize project structure
+  - Created D:\Claude_dms3\src\core\index.ts
+  - Added dependencies: lodash, zod
+- [ ] Configure TypeScript
+  - Update tsconfig.json for strict mode
+
+## Phase 2: Implementation
+- [ ] Implement core API
+  - Target: D:\Claude_dms3\src\api\handler.ts
+  - Dependencies: Phase 1 complete
+  - Acceptance: All tests pass
+
+</details>
+
+## Working Files (Modified)
+[Absolute paths to actively modified files]
+- D:\Claude_dms3\src\file1.ts (role: main implementation)
+- D:\Claude_dms3\tests\file1.test.ts (role: unit tests)
+
+## Reference Files (Read-Only)
+[Absolute paths to context files - NOT modified but essential for understanding]
+- D:\Claude_dms3\.claude\CLAUDE.md (role: project instructions)
+- D:\Claude_dms3\src\types\index.ts (role: type definitions)
+- D:\Claude_dms3\package.json (role: dependencies)
+
+## Last Action
+[Last significant action and its result/status]
+
+## Decisions
+- [Decision]: [Reasoning]
+- [Decision]: [Reasoning]
+
+## Constraints
+- [User-specified limitation or preference]
+
+## Dependencies
+- [Added/changed packages or environment requirements]
+
+## Known Issues
+- [Deferred bug or edge case]
+
+## Changes Made
+- [Completed modification]
+
+## Pending
+- [Next step] or (none)
+
+## Notes
+[Unstructured thoughts, hypotheses, debugging trails]
+```
+
+## 4. Field Definitions
+
+| Field | Purpose | Recovery Value |
+|-------|---------|----------------|
+| **Session ID** | Workflow session identifier (WFS-*) | Links memory to specific stateful task execution |
+| **Project Root** | Absolute path to project directory | Enables correct path resolution in new sessions |
+| **Objective** | Ultimate goal of the session | Prevents losing track of broader feature |
+| **Execution Plan** | Complete plan from any source (verbatim) | Preserves full planning context, avoids re-planning |
+| **Working Files** | Actively modified files (absolute paths) | Immediately identifies where work was happening |
+| **Reference Files** | Read-only context files (absolute paths) | Eliminates re-exploration for critical context |
+| **Last Action** | Final tool output/status | Immediate state awareness (success/failure) |
+| **Decisions** | Architectural choices + reasoning | Prevents re-litigating settled decisions |
+| **Constraints** | User-imposed limitations | Maintains personalized coding style |
+| **Dependencies** | Package/environment changes | Prevents missing dependency errors |
+| **Known Issues** | Deferred bugs/edge cases | Ensures issues aren't forgotten |
+| **Changes Made** | Completed modifications | Clear record of what was done |
+| **Pending** | Next steps | Immediate action items |
+| **Notes** | Hypotheses, debugging trails | Preserves "train of thought" |
+
+## 5. Execution Flow
+
+### Step 1: Analyze Current Session
+
+Extract the following from conversation history:
+
+```javascript
+const sessionAnalysis = {
+  sessionId: "",       // WFS-* if workflow session active, null otherwise
+  projectRoot: "",     // Absolute path: D:\Claude_dms3
+  objective: "",       // High-level goal (1-2 sentences)
+  executionPlan: {
+    source: "workflow" | "todo" | "user-stated" | "inferred",
+    content: ""        // Full plan content - ALWAYS preserve COMPLETE and DETAILED form
+  },
+  workingFiles: [],    // {absolutePath, role} - modified files
+  referenceFiles: [],  // {absolutePath, role} - read-only context files
+  lastAction: "",      // Last significant action + result
+  decisions: [],       // {decision, reasoning}
+  constraints: [],     // User-specified limitations
+  dependencies: [],    // Added/changed packages
+  knownIssues: [],     // Deferred bugs
+  changesMade: [],     // Completed modifications
+  pending: [],         // Next steps
+  notes: ""            // Unstructured thoughts
+}
+```
+
+### Step 2: Generate Structured Text
+
+```javascript
+// Helper: Generate execution plan section
+const generateExecutionPlan = (plan) => {
+  const sourceLabels = {
+    'workflow': 'workflow (IMPL_PLAN.md)',
+    'todo': 'todo (TodoWrite)',
+    'user-stated': 'user-stated',
+    'inferred': 'inferred'
+  };
+
+  // CRITICAL: Preserve complete plan content verbatim - DO NOT summarize
+  return `### Source: ${sourceLabels[plan.source] || plan.source}
+
+<details>
+<summary>Full Execution Plan (Click to expand)</summary>
+
+${plan.content}
+
+</details>`;
+};
+
+const structuredText = `## Session ID
+${sessionAnalysis.sessionId || '(none)'}
+
+## Project Root
+${sessionAnalysis.projectRoot}
+
+## Objective
+${sessionAnalysis.objective}
+
+## Execution Plan
+${generateExecutionPlan(sessionAnalysis.executionPlan)}
+
+## Working Files (Modified)
+${sessionAnalysis.workingFiles.map(f => `- ${f.absolutePath} (role: ${f.role})`).join('\n') || '(none)'}
+
+## Reference Files (Read-Only)
+${sessionAnalysis.referenceFiles.map(f => `- ${f.absolutePath} (role: ${f.role})`).join('\n') || '(none)'}
+
+## Last Action
+${sessionAnalysis.lastAction}
+
+## Decisions
+${sessionAnalysis.decisions.map(d => `- ${d.decision}: ${d.reasoning}`).join('\n') || '(none)'}
+
+## Constraints
+${sessionAnalysis.constraints.map(c => `- ${c}`).join('\n') || '(none)'}
+
+## Dependencies
+${sessionAnalysis.dependencies.map(d => `- ${d}`).join('\n') || '(none)'}
+
+## Known Issues
+${sessionAnalysis.knownIssues.map(i => `- ${i}`).join('\n') || '(none)'}
+
+## Changes Made
+${sessionAnalysis.changesMade.map(c => `- ${c}`).join('\n') || '(none)'}
+
+## Pending
+${sessionAnalysis.pending.length > 0
+  ? sessionAnalysis.pending.map(p => `- ${p}`).join('\n')
+  : '(none)'}
+
+## Notes
+${sessionAnalysis.notes || '(none)'}`
+```
+
+### Step 3: Import to Core Memory via MCP
+
+Use the MCP `core_memory` tool to save the structured text:
+
+```javascript
+mcp__ccw-tools__core_memory({
+  operation: "import",
+  text: structuredText
+})
+```
+
+Or via CLI (pipe structured text to import):
+
+```bash
+# Write structured text to temp file, then import
+echo "$structuredText" | ccw core-memory import
+
+# Or from a file
+ccw core-memory import --file /path/to/session-memory.md
+```
+
+**Response Format**:
+```json
+{
+  "operation": "import",
+  "id": "CMEM-YYYYMMDD-HHMMSS",
+  "message": "Created memory: CMEM-YYYYMMDD-HHMMSS"
+}
+```
+
+### Step 4: Report Recovery ID
+
+After successful import, **clearly display the Recovery ID** to the user:
+
+```
+╔════════════════════════════════════════════════════════════════════════════╗
+║  ✓ Session Memory Saved                                                    ║
+║                                                                            ║
+║  Recovery ID: CMEM-YYYYMMDD-HHMMSS                                         ║
+║                                                                            ║
+║  To restore: "Please import memory <ID>"                                   ║
+║  (MCP: core_memory export | CLI: ccw core-memory export --id <ID>)         ║
+╚════════════════════════════════════════════════════════════════════════════╝
+```
+
+## 6. Quality Checklist
+
+Before generating:
+- [ ] Session ID captured if workflow session active (WFS-*)
+- [ ] Project Root is absolute path (e.g., D:\Claude_dms3)
+- [ ] Objective clearly states the "North Star" goal
+- [ ] Execution Plan: COMPLETE plan preserved VERBATIM (no summarization)
+- [ ] Plan Source: Clearly identified (workflow | todo | user-stated | inferred)
+- [ ] Plan Details: ALL phases, tasks, file paths, dependencies, status markers included
+- [ ] All file paths are ABSOLUTE (not relative)
+- [ ] Working Files: 3-8 modified files with roles
+- [ ] Reference Files: Key context files (CLAUDE.md, types, configs)
+- [ ] Last Action captures final state (success/failure)
+- [ ] Decisions include reasoning, not just choices
+- [ ] Known Issues separates deferred from forgotten bugs
+- [ ] Notes preserve debugging hypotheses if any
+
+## 7. Path Resolution Rules
+
+### Project Root Detection
+1. Check current working directory from environment
+2. Look for project markers: `.git/`, `package.json`, `.claude/`
+3. Use the topmost directory containing these markers
+
+### Absolute Path Conversion
+```javascript
+// Convert relative to absolute
+const toAbsolutePath = (relativePath, projectRoot) => {
+  if (path.isAbsolute(relativePath)) return relativePath;
+  return path.join(projectRoot, relativePath);
+};
+
+// Example: "src/api/auth.ts" → "D:\Claude_dms3\src\api\auth.ts"
+```
+
+### Reference File Categories
+| Category | Examples | Priority |
+|----------|----------|----------|
+| Project Config | `.claude/CLAUDE.md`, `package.json`, `tsconfig.json` | High |
+| Type Definitions | `src/types/*.ts`, `*.d.ts` | High |
+| Related Modules | Parent/sibling modules with shared interfaces | Medium |
+| Test Files | Corresponding test files for modified code | Medium |
+| Documentation | `README.md`, `ARCHITECTURE.md` | Low |
+
+## 8. Plan Detection (Priority Order)
+
+### Priority 1: Workflow Session (IMPL_PLAN.md)
+```javascript
+// Check for active workflow session
+const manifest = await mcp__ccw-tools__session_manager({
+  operation: "list",
+  location: "active"
+});
+
+if (manifest.sessions?.length > 0) {
+  const session = manifest.sessions[0];
+  const plan = await mcp__ccw-tools__session_manager({
+    operation: "read",
+    session_id: session.id,
+    content_type: "plan"
+  });
+  sessionAnalysis.sessionId = session.id;
+  sessionAnalysis.executionPlan.source = "workflow";
+  sessionAnalysis.executionPlan.content = plan.content;
+}
+```
+
+### Priority 2: TodoWrite (Current Session Todos)
+```javascript
+// Extract from conversation - look for TodoWrite tool calls
+// Preserve COMPLETE todo list with all details
+const todos = extractTodosFromConversation();
+if (todos.length > 0) {
+  sessionAnalysis.executionPlan.source = "todo";
+  // Format todos with full context - preserve status markers
+  sessionAnalysis.executionPlan.content = todos.map(t =>
+    `- [${t.status === 'completed' ? 'x' : t.status === 'in_progress' ? '>' : ' '}] ${t.content}`
+  ).join('\n');
+}
+```
+
+### Priority 3: User-Stated Plan
+```javascript
+// Look for explicit plan statements in user messages:
+// - "Here's my plan: 1. ... 2. ... 3. ..."
+// - "I want to: first..., then..., finally..."
+// - Numbered or bulleted lists describing steps
+const userPlan = extractUserStatedPlan();
+if (userPlan) {
+  sessionAnalysis.executionPlan.source = "user-stated";
+  sessionAnalysis.executionPlan.content = userPlan;
+}
+```
+
+### Priority 4: Inferred Plan
+```javascript
+// If no explicit plan, infer from:
+// - Task description and breakdown discussion
+// - Sequence of actions taken
+// - Outstanding work mentioned
+const inferredPlan = inferPlanFromDiscussion();
+if (inferredPlan) {
+  sessionAnalysis.executionPlan.source = "inferred";
+  sessionAnalysis.executionPlan.content = inferredPlan;
+}
+```
+
+## 9. Notes
+
+- **Timing**: Execute at task completion or before context switch
+- **Frequency**: Once per independent task or milestone
+- **Recovery**: New session can immediately continue with full context
+- **Knowledge Graph**: Entity relationships auto-extracted for visualization
+- **Absolute Paths**: Critical for cross-session recovery on different machines

.claude/commands/memory/docs-full-cli.md

@@ -0,0 +1,471 @@
+---
+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/commands/memory/docs-related-cli.md

@@ -0,0 +1,386 @@
+---
+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/commands/memory/docs.md

@@ -0,0 +1,615 @@
+---
+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
+bash(jq '. + {"target_path":"{target_path}","project_root":"{project_root}","project_name":"{project_name}","mode":"full","tool":"gemini","cli_execute":false}' .workflow/active/{sessionId}/workflow-session.json > tmp.json && mv tmp.json .workflow/active/{sessionId}/workflow-session.json)
+```
+
+### 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
+bash(cat .workflow/active/WFS-docs-{timestamp}/.process/doc-planning-data.json | jq '.existing_docs.file_list | length')
+```
+
+**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
+bash(cat .workflow/active/WFS-docs-{timestamp}/.process/doc-planning-data.json | jq -r '.top_level_dirs[]')
+
+# 2. Get mode from workflow-session.json
+bash(cat .workflow/active/WFS-docs-{timestamp}/workflow-session.json | 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=$(jq '.groups.count' .workflow/active/WFS-docs-{timestamp}/.process/doc-planning-data.json)
+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": [
+          "bash(cat ${session_dir}/.process/doc-planning-data.json)",
+          "bash(jq '.groups.assignments[] | select(.group_id == \"${group_number}\") | .directories' ${session_dir}/.process/doc-planning-data.json)"
+        ],
+        "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

.claude/commands/memory/load-skill-memory.md

@@ -0,0 +1,182 @@
+---
+name: load-skill-memory
+description: Activate SKILL package (auto-detect from paths/keywords or manual) and intelligently load documentation based on task intent keywords
+argument-hint: "[skill_name] \"task intent description\""
+allowed-tools: Bash(*), Read(*), Skill(*)
+---
+
+# Memory Load SKILL Command (/memory:load-skill-memory)
+
+## 1. Overview
+
+The `memory:load-skill-memory` command **activates SKILL package** (auto-detect from task or manual specification) and intelligently loads documentation based on user's task intent. The system automatically determines which documentation files to read based on the intent description.
+
+**Core Philosophy**:
+- **Flexible Activation**: Auto-detect skill from task description/paths, or user explicitly specifies
+- **Intent-Driven Loading**: System analyzes task intent to determine documentation scope
+- **Intelligent Selection**: Automatically chooses appropriate documentation level and modules
+- **Direct Context Loading**: Loads selected documentation into conversation memory
+
+**When to Use**:
+- Manually activate a known SKILL package for a specific task
+- Load SKILL context when system hasn't auto-triggered it
+- Force reload SKILL documentation with specific intent focus
+
+**Note**: Normal SKILL activation happens automatically via description triggers or path mentions (system extracts skill name from file paths for intelligent triggering). Use this command only when manual activation is needed.
+
+## 2. Parameters
+
+- `[skill_name]` (Optional): Name of SKILL package to activate
+  - If omitted: System auto-detects from task description or file paths
+  - If specified: Direct activation of named SKILL package
+  - Example: `my_project`, `api_service`
+  - Must match directory name under `.claude/skills/`
+
+- `"task intent description"` (Required): Description of what you want to do
+  - Used for both: auto-detection (if skill_name omitted) and documentation scope selection
+  - **Analysis tasks**: "分析builder pattern实现", "理解参数系统架构"
+  - **Modification tasks**: "修改workflow逻辑", "增强thermal template功能"
+  - **Learning tasks**: "学习接口设计模式", "了解测试框架使用"
+  - **With paths**: "修改D:\projects\my_project\src\auth.py的认证逻辑" (auto-extracts `my_project`)
+
+## 3. Execution Flow
+
+### Step 1: Determine SKILL Name (if not provided)
+
+**Auto-Detection Strategy** (when skill_name parameter is omitted):
+1. **Path Extraction**: Scan task description for file paths
+   - Extract potential project names from path segments
+   - Example: `"修改D:\projects\my_project\src\auth.py"` → extracts `my_project`
+2. **Keyword Matching**: Match task keywords against SKILL descriptions
+   - Search for project-specific terms, domain keywords
+3. **Validation**: Check if extracted name matches `.claude/skills/{skill_name}/`
+
+**Result**: Either uses provided skill_name or auto-detected name for activation
+
+### Step 2: Activate SKILL and Analyze Intent
+
+**Activate SKILL Package**:
+```javascript
+Skill(command: "${skill_name}")  // Uses provided or auto-detected name
+```
+
+**What Happens After Activation**:
+1. If SKILL exists in memory: System reads `.claude/skills/${skill_name}/SKILL.md`
+2. If SKILL not found in memory: Error - SKILL package doesn't exist
+3. SKILL description triggers are loaded into memory
+4. Progressive loading mechanism becomes available
+5. Documentation structure is now accessible
+
+**Intent Analysis**:
+Based on task intent description, system determines:
+- **Action type**: analyzing, modifying, learning
+- **Scope**: specific module, architecture overview, complete system
+- **Depth**: quick reference, detailed API, full documentation
+
+### Step 3: Intelligent Documentation Loading
+
+**Loading Strategy**:
+
+The system automatically selects documentation based on intent keywords:
+
+1. **Quick Understanding** ("了解", "快速理解", "什么是"):
+   - Load: Level 0 (README.md only, ~2K tokens)
+   - Use case: Quick overview of capabilities
+
+2. **Specific Module Analysis** ("分析XXX模块", "理解XXX实现"):
+   - Load: Module-specific README.md + API.md (~5K tokens)
+   - Use case: Deep dive into specific component
+
+3. **Architecture Review** ("架构", "设计模式", "整体结构"):
+   - Load: README.md + ARCHITECTURE.md (~10K tokens)
+   - Use case: System design understanding
+
+4. **Implementation/Modification** ("修改", "增强", "实现"):
+   - Load: Relevant module docs + EXAMPLES.md (~15K tokens)
+   - Use case: Code modification with examples
+
+5. **Comprehensive Learning** ("学习", "完整了解", "深入理解"):
+   - Load: Level 3 (All documentation, ~40K tokens)
+   - Use case: Complete system mastery
+
+**Documentation Loaded into Memory**:
+After loading, the selected documentation content is available in conversation memory for subsequent operations.
+
+## 4. Usage Examples
+
+### Example 1: Manual Specification
+
+**User Command**:
+```bash
+/memory:load-skill-memory my_project "修改认证模块增加OAuth支持"
+```
+
+**Execution**:
+```javascript
+// Step 1: Use provided skill_name
+skill_name = "my_project"  // Directly from parameter
+
+// Step 2: Activate SKILL
+Skill(command: "my_project")
+
+// Step 3: Intent Analysis
+Keywords: ["修改", "认证模块", "增加", "OAuth"]
+Action: modifying (implementation)
+Scope: auth module + examples
+
+// Load documentation based on intent
+Read(.workflow/docs/my_project/auth/README.md)
+Read(.workflow/docs/my_project/auth/API.md)
+Read(.workflow/docs/my_project/EXAMPLES.md)
+```
+
+### Example 2: Auto-Detection from Path
+
+**User Command**:
+```bash
+/memory:load-skill-memory "修改D:\projects\my_project\src\services\api.py的接口逻辑"
+```
+
+**Execution**:
+```javascript
+// Step 1: Auto-detect skill_name from path
+Path detected: "D:\projects\my_project\src\services\api.py"
+Extracted: "my_project"
+Validated: .claude/skills/my_project/ exists ✓
+skill_name = "my_project"
+
+// Step 2: Activate SKILL
+Skill(command: "my_project")
+
+// Step 3: Intent Analysis
+Keywords: ["修改", "services", "接口逻辑"]
+Action: modifying (implementation)
+Scope: services module + examples
+
+// Load documentation based on intent
+Read(.workflow/docs/my_project/services/README.md)
+Read(.workflow/docs/my_project/services/API.md)
+Read(.workflow/docs/my_project/EXAMPLES.md)
+```
+
+## 5. Intent Keyword Mapping
+
+**Quick Reference**:
+- **Triggers**: "了解", "快速", "什么是", "简介"
+- **Loads**: README.md only (~2K)
+
+**Module-Specific**:
+- **Triggers**: "XXX模块", "XXX组件", "分析XXX"
+- **Loads**: Module README + API (~5K)
+
+**Architecture**:
+- **Triggers**: "架构", "设计", "整体结构", "系统设计"
+- **Loads**: README + ARCHITECTURE (~10K)
+
+**Implementation**:
+- **Triggers**: "修改", "增强", "实现", "开发", "集成"
+- **Loads**: Relevant module + EXAMPLES (~15K)
+
+**Comprehensive**:
+- **Triggers**: "完整", "深入", "全面", "学习整个"
+- **Loads**: All documentation (~40K)

.claude/commands/memory/load.md

@@ -0,0 +1,240 @@
+---
+name: load
+description: Delegate to universal-executor agent to analyze project via Gemini/Qwen CLI and return JSON core content package for task context
+argument-hint: "[--tool gemini|qwen] \"task context description\""
+allowed-tools: Task(*), Bash(*)
+examples:
+  - /memory:load "在当前前端基础上开发用户认证功能"
+  - /memory:load --tool qwen "重构支付模块API"
+---
+
+# Memory Load Command (/memory:load)
+
+## 1. Overview
+
+The `memory:load` command **delegates to a universal-executor agent** to analyze the project and return a structured "Core Content Pack". This pack is loaded into the main thread's memory, providing essential context for subsequent agent operations while minimizing token consumption.
+
+**Core Philosophy**:
+- **Agent-Driven**: Fully delegates execution to universal-executor agent
+- **Read-Only Analysis**: Does not modify code, only extracts context
+- **Structured Output**: Returns standardized JSON content package
+- **Memory Optimization**: Package loaded directly into main thread memory
+- **Token Efficiency**: CLI analysis executed within agent to save tokens
+
+## 2. Parameters
+
+- `"task context description"` (Required): Task description to guide context extraction
+  - Example: "在当前前端基础上开发用户认证功能"
+  - Example: "重构支付模块API"
+  - Example: "修复数据库查询性能问题"
+
+- `--tool <gemini|qwen>` (Optional): Specify CLI tool for agent to use (default: gemini)
+  - gemini: Large context window, suitable for complex project analysis
+  - qwen: Alternative to Gemini with similar capabilities
+
+## 3. Agent-Driven Execution Flow
+
+The command fully delegates to **universal-executor agent**, which autonomously:
+
+1. **Analyzes Project Structure**: Executes `get_modules_by_depth.sh` to understand architecture
+2. **Loads Documentation**: Reads CLAUDE.md, README.md and other key docs
+3. **Extracts Keywords**: Derives core keywords from task description
+4. **Discovers Files**: Uses CodexLens MCP or rg/find to locate relevant files
+5. **CLI Deep Analysis**: Executes Gemini/Qwen CLI for deep context analysis
+6. **Generates Content Package**: Returns structured JSON core content package
+
+## 4. Core Content Package Structure
+
+**Output Format** - Loaded into main thread memory for subsequent use:
+
+```json
+{
+  "task_context": "在当前前端基础上开发用户认证功能",
+  "keywords": ["前端", "用户", "认证", "auth", "login"],
+  "project_summary": {
+    "architecture": "TypeScript + React frontend with Vite build system",
+    "tech_stack": ["React", "TypeScript", "Vite", "TailwindCSS"],
+    "key_patterns": [
+      "State management via Context API",
+      "Functional components with Hooks pattern",
+      "API calls encapsulated in custom hooks"
+    ]
+  },
+  "relevant_files": [
+    {
+      "path": "src/components/Auth/LoginForm.tsx",
+      "relevance": "Existing login form component",
+      "priority": "high"
+    },
+    {
+      "path": "src/contexts/AuthContext.tsx",
+      "relevance": "Authentication state management context",
+      "priority": "high"
+    },
+    {
+      "path": "CLAUDE.md",
+      "relevance": "Project development standards",
+      "priority": "high"
+    }
+  ],
+  "integration_points": [
+    "Must integrate with existing AuthContext",
+    "Follow component organization pattern: src/components/[Feature]/",
+    "API calls should use src/hooks/useApi.ts wrapper"
+  ],
+  "constraints": [
+    "Maintain backward compatibility",
+    "Follow TypeScript strict mode",
+    "Use existing UI component library"
+  ]
+}
+```
+
+## 5. Agent Invocation
+
+```javascript
+Task(
+  subagent_type="universal-executor",
+  description="Load project memory: ${task_description}",
+  prompt=`
+## Mission: Load Project Memory Context
+
+**Task**: Load project memory context for: "${task_description}"
+**Mode**: analysis
+**Tool Preference**: ${tool || 'gemini'}
+
+## Execution Steps
+
+### Step 1: Foundation Analysis
+
+1. **Project Structure**
+   \`\`\`bash
+   bash(ccw tool exec get_modules_by_depth '{}')
+   \`\`\`
+
+2. **Core Documentation**
+   \`\`\`javascript
+   Read(CLAUDE.md)
+   Read(README.md)
+   \`\`\`
+
+### Step 2: Keyword Extraction & File Discovery
+
+1. Extract core keywords from task description
+2. Discover relevant files using ripgrep and find:
+   \`\`\`bash
+   # Find files by name
+   find . -name "*{keyword}*" -type f
+
+   # Search content with ripgrep
+   rg "{keyword}" --type ts --type md -C 2
+   rg -l "{keyword}" --type ts --type md  # List files only
+   \`\`\`
+
+### Step 3: Deep Analysis via CLI
+
+Execute Gemini/Qwen CLI for deep analysis (saves main thread tokens):
+
+\`\`\`bash
+ccw cli -p "
+PURPOSE: Extract project core context for task: ${task_description}
+TASK: Analyze project architecture, tech stack, key patterns, relevant files
+MODE: analysis
+CONTEXT: @CLAUDE.md,README.md @${discovered_files}
+EXPECTED: Structured project summary and integration point analysis
+RULES:
+- Focus on task-relevant core information
+- Identify key architecture patterns and technical constraints
+- Extract integration points and development standards
+- Output concise, structured format
+" --tool ${tool} --mode analysis
+\`\`\`
+
+### Step 4: Generate Core Content Package
+
+Generate structured JSON content package (format shown above)
+
+**Required Fields**:
+- task_context: Original task description
+- keywords: Extracted keyword array
+- project_summary: Architecture, tech stack, key patterns
+- relevant_files: File list with path, relevance, priority
+- integration_points: Integration guidance
+- constraints: Development constraints
+
+### Step 5: Return Content Package
+
+Return JSON content package as final output for main thread to load into memory.
+
+## Quality Checklist
+
+Before returning:
+- [ ] Valid JSON format
+- [ ] All required fields complete
+- [ ] relevant_files contains 3-10 files minimum
+- [ ] project_summary accurately reflects architecture
+- [ ] integration_points clearly specify integration paths
+- [ ] keywords accurately extracted (3-8 keywords)
+- [ ] Content concise, avoiding redundancy (< 5KB total)
+
+  `
+)
+```
+
+## 6. Usage Examples
+
+### Example 1: Load Context for New Feature
+
+```bash
+/memory:load "在当前前端基础上开发用户认证功能"
+```
+
+**Agent Execution**:
+1. Analyzes project structure (`get_modules_by_depth.sh`)
+2. Reads CLAUDE.md, README.md
+3. Extracts keywords: ["前端", "用户", "认证", "auth"]
+4. Uses MCP to search relevant files
+5. Executes Gemini CLI for deep analysis
+6. Returns core content package
+
+**Returned Package** (loaded into memory):
+```json
+{
+  "task_context": "在当前前端基础上开发用户认证功能",
+  "keywords": ["前端", "认证", "auth", "login"],
+  "project_summary": { ... },
+  "relevant_files": [ ... ],
+  "integration_points": [ ... ],
+  "constraints": [ ... ]
+}
+```
+
+### Example 2: Using Qwen Tool
+
+```bash
+/memory:load --tool qwen "重构支付模块API"
+```
+
+Agent uses Qwen CLI for analysis, returns same structured package.
+
+### Example 3: Bug Fix Context
+
+```bash
+/memory:load "修复登录验证错误"
+```
+
+Returns core context related to login validation, including test files and validation logic.
+
+### Memory Persistence
+
+- **Session-Scoped**: Content package valid for current session
+- **Subsequent Reference**: All subsequent agents/commands can access
+- **Reload Required**: New sessions need to re-execute /memory:load
+
+## 8. Notes
+
+- **Read-Only**: Does not modify any code, pure analysis
+- **Token Optimization**: CLI analysis executed within agent, saves main thread tokens
+- **Memory Loading**: Returned JSON loaded directly into main thread memory
+- **Subsequent Use**: Other commands/agents can reference this package for development
+- **Session-Level**: Content package valid for current session

.claude/commands/memory/skill-memory.md

@@ -0,0 +1,525 @@
+---
+name: 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)
+argument-hint: "[path] [--tool <gemini|qwen|codex>] [--regenerate] [--mode <full|partial>] [--cli-execute]"
+allowed-tools: SlashCommand(*), TodoWrite(*), Bash(*), Read(*), Write(*)
+---
+
+# Memory SKILL Package Generator
+
+## Orchestrator Role
+
+**Pure Orchestrator**: Execute documentation generation workflow, then generate SKILL.md index. Does NOT create task JSON files.
+
+**Auto-Continue Workflow**: This command runs **fully autonomously** once triggered. Each phase completes and automatically triggers the next phase without user interaction.
+
+**Execution Paths**:
+- **Full Path**: All 4 phases (no existing docs OR `--regenerate` specified)
+- **Skip Path**: Phase 1 → Phase 4 (existing docs found AND no `--regenerate` flag)
+- **Phase 4 Always Executes**: SKILL.md index is never skipped, always generated or updated
+
+## Core Rules
+
+1. **Start Immediately**: First action is TodoWrite initialization, second action is Phase 1 execution
+2. **No Task JSON**: This command does not create task JSON files - delegates to /memory:docs
+3. **Parse Every Output**: Extract required data from each command output (session_id, task_count, file paths)
+4. **Auto-Continue**: After completing each phase, update TodoWrite and immediately execute next phase
+5. **Track Progress**: Update TodoWrite after EVERY phase completion before starting next phase
+6. **Direct Generation**: Phase 4 directly generates SKILL.md using Write tool
+7. **No Manual Steps**: User should never be prompted for decisions between phases
+
+---
+
+## 4-Phase Execution
+
+### Phase 1: Prepare Arguments
+
+**Goal**: Parse command arguments and check existing documentation
+
+**Step 1: Get Target Path and Project Name**
+```bash
+# Get current directory (or use provided path)
+bash(pwd)
+
+# Get project name from directory
+bash(basename "$(pwd)")
+
+# Get project root
+bash(git rev-parse --show-toplevel 2>/dev/null || pwd)
+```
+
+**Output**:
+- `target_path`: `/d/my_project`
+- `project_name`: `my_project`
+- `project_root`: `/d/my_project`
+
+**Step 2: Set Default Parameters**
+```bash
+# Default values (use these unless user specifies otherwise):
+# - tool: "gemini"
+# - mode: "full"
+# - regenerate: false (no --regenerate flag)
+# - cli_execute: false (no --cli-execute flag)
+```
+
+**Step 3: Check Existing Documentation**
+```bash
+# Check if docs directory exists
+bash(test -d .workflow/docs/my_project && echo "exists" || echo "not_exists")
+
+# Count existing documentation files
+bash(find .workflow/docs/my_project -name "*.md" 2>/dev/null | wc -l || echo 0)
+```
+
+**Output**:
+- `docs_exists`: `exists` or `not_exists`
+- `existing_docs`: `5` (or `0` if no docs)
+
+**Step 4: Determine Execution Path**
+
+**Decision Logic**:
+```javascript
+if (existing_docs > 0 && !regenerate_flag) {
+  // Documentation exists and no regenerate flag
+  SKIP_DOCS_GENERATION = true
+  message = "Documentation already exists, skipping Phase 2 and Phase 3. Use --regenerate to force regeneration."
+} else if (regenerate_flag) {
+  // Force regeneration: delete existing docs
+  bash(rm -rf .workflow/docs/my_project 2>/dev/null || true)
+  SKIP_DOCS_GENERATION = false
+  message = "Regenerating documentation from scratch."
+} else {
+  // No existing docs
+  SKIP_DOCS_GENERATION = false
+  message = "No existing documentation found, generating new documentation."
+}
+```
+
+**Summary Variables**:
+- `PROJECT_NAME`: `my_project`
+- `TARGET_PATH`: `/d/my_project`
+- `DOCS_PATH`: `.workflow/docs/my_project`
+- `TOOL`: `gemini` (default) or user-specified
+- `MODE`: `full` (default) or user-specified
+- `CLI_EXECUTE`: `false` (default) or `true` if --cli-execute flag
+- `REGENERATE`: `false` (default) or `true` if --regenerate flag
+- `EXISTING_DOCS`: Count of existing documentation files
+- `SKIP_DOCS_GENERATION`: `true` if skipping Phase 2/3, `false` otherwise
+
+**Completion & TodoWrite**:
+- If `SKIP_DOCS_GENERATION = true`: Mark phase 1 completed, phase 2&3 completed (skipped), phase 4 in_progress
+- If `SKIP_DOCS_GENERATION = false`: Mark phase 1 completed, phase 2 in_progress
+
+**Next Action**:
+- If skipping: Display skip message → Jump to Phase 4 (SKILL.md generation)
+- If not skipping: Display preparation results → Continue to Phase 2 (documentation planning)
+
+---
+
+### Phase 2: Call /memory:docs
+
+**Skip Condition**: This phase is **skipped if SKIP_DOCS_GENERATION = true** (documentation already exists without --regenerate flag)
+
+**Goal**: Trigger documentation generation workflow
+
+**Command**:
+```bash
+SlashCommand(command="/memory:docs [targetPath] --tool [tool] --mode [mode] [--cli-execute]")
+```
+
+**Example**:
+```bash
+/memory:docs /d/my_app --tool gemini --mode full
+/memory:docs /d/my_app --tool gemini --mode full --cli-execute
+```
+
+**Note**: The `--regenerate` flag is handled in Phase 1 by deleting existing documentation. This command always calls `/memory:docs` without the regenerate flag, relying on docs.md's built-in update detection.
+
+**Parse Output**:
+- Extract session ID: `WFS-docs-[timestamp]` (store as `docsSessionId`)
+- Extract task count (store as `taskCount`)
+
+**Completion Criteria**:
+- `/memory:docs` command executed successfully
+- Session ID extracted and stored
+- Task count retrieved
+- Task files created in `.workflow/[docsSessionId]/.task/`
+- workflow-session.json exists
+
+**TodoWrite**: Mark phase 2 completed, phase 3 in_progress
+
+**Next Action**: Display docs planning results (session ID, task count) → Auto-continue to Phase 3
+
+---
+
+### Phase 3: Execute Documentation Generation
+
+**Skip Condition**: This phase is **skipped if SKIP_DOCS_GENERATION = true** (documentation already exists without --regenerate flag)
+
+**Goal**: Execute documentation generation tasks
+
+**Command**:
+```bash
+SlashCommand(command="/workflow:execute")
+```
+
+**Note**: `/workflow:execute` automatically discovers active session from Phase 2
+
+**Completion Criteria**:
+- `/workflow:execute` command executed successfully
+- Documentation files generated in `.workflow/docs/[projectName]/`
+- All tasks marked as completed in session
+- At minimum: module documentation files exist (API.md and/or README.md)
+- For full mode: Project README, ARCHITECTURE, EXAMPLES files generated
+
+**TodoWrite**: Mark phase 3 completed, phase 4 in_progress
+
+**Next Action**: Display execution results (file count, module count) → Auto-continue to Phase 4
+
+---
+
+### Phase 4: Generate SKILL.md Index
+
+**Note**: This phase is **NEVER skipped** - it always executes to generate or update the SKILL index.
+
+**Step 1: Read Key Files** (Use Read tool)
+- `.workflow/docs/{project_name}/README.md` (required)
+- `.workflow/docs/{project_name}/ARCHITECTURE.md` (optional)
+
+**Step 2: Discover Structure**
+```bash
+bash(find .workflow/docs/{project_name} -name "*.md" | sed 's|.workflow/docs/{project_name}/||' | awk -F'/' '{if(NF>=2) print $1"/"$2}' | sort -u)
+```
+
+**Step 3: Generate Intelligent Description**
+
+Extract from README + structure: Function (capabilities), Modules (names), Keywords (API/CLI/auth/etc.)
+
+**Format**: `{Project} {core capabilities} (located at {project_path}). Load this SKILL when analyzing, modifying, or learning about {domain_description} or files under this path, especially when no relevant context exists in memory.`
+
+**Key Elements**:
+- **Path Reference**: Use `TARGET_PATH` from Phase 1 for precise location identification
+- **Domain Description**: Extract human-readable domain/feature area from README (e.g., "workflow management", "thermal modeling")
+- **Trigger Optimization**: Include project path, emphasize "especially when no relevant context exists in memory"
+- **Action Coverage**: analyzing (分析), modifying (修改), learning (了解)
+
+**Example**: "Workflow orchestration system with CLI tools and documentation generation (located at /d/Claude_dms3). Load this SKILL when analyzing, modifying, or learning about workflow management or files under this path, especially when no relevant context exists in memory."
+
+**Step 4: Write SKILL.md** (Use Write tool)
+```bash
+bash(mkdir -p .claude/skills/{project_name})
+```
+
+`.claude/skills/{project_name}/SKILL.md`:
+```yaml
+---
+name: {project_name}
+description: {intelligent description from Step 3}
+version: 1.0.0
+---
+# {Project Name} SKILL Package
+
+## Documentation: `../../../.workflow/docs/{project_name}/`
+
+## Progressive Loading
+### Level 0: Quick Start (~2K)
+- [README](../../../.workflow/docs/{project_name}/README.md)
+### Level 1: Core Modules (~8K)
+{Module READMEs}
+### Level 2: Complete (~25K)
+All modules + [Architecture](../../../.workflow/docs/{project_name}/ARCHITECTURE.md)
+### Level 3: Deep Dive (~40K)
+Everything + [Examples](../../../.workflow/docs/{project_name}/EXAMPLES.md)
+```
+
+**Completion Criteria**:
+- SKILL.md file created at `.claude/skills/{project_name}/SKILL.md`
+- Intelligent description generated from documentation
+- Progressive loading levels (0-3) properly structured
+- Module index includes all documented modules
+- All file references use relative paths
+
+**TodoWrite**: Mark phase 4 completed
+
+**Final Action**: Report completion summary to user
+
+**Return to User**:
+```
+SKILL Package Generation Complete
+
+Project: {project_name}
+Documentation: .workflow/docs/{project_name}/ ({doc_count} files)
+SKILL Index: .claude/skills/{project_name}/SKILL.md
+
+Generated:
+- {task_count} documentation tasks completed
+- SKILL.md with progressive loading (4 levels)
+- Module index with {module_count} modules
+
+Usage:
+- Load Level 0: Quick project overview (~2K tokens)
+- Load Level 1: Core modules (~8K tokens)
+- Load Level 2: Complete docs (~25K tokens)
+- Load Level 3: Everything (~40K tokens)
+```
+
+---
+
+## Implementation Details
+
+### Critical Rules
+
+1. **No User Prompts Between Phases**: Never ask user questions or wait for input between phases
+2. **Immediate Phase Transition**: After TodoWrite update, immediately execute next phase command
+3. **Status-Driven Execution**: Check TodoList status after each phase:
+   - If next task is "pending" → Mark it "in_progress" and execute
+   - If all tasks are "completed" → Report final summary
+4. **Phase Completion Pattern**:
+   ```
+   Phase N completes → Update TodoWrite (N=completed, N+1=in_progress) → Execute Phase N+1
+   ```
+
+### TodoWrite Patterns
+
+#### Initialization (Before Phase 1)
+
+**FIRST ACTION**: Create TodoList with all 4 phases
+```javascript
+TodoWrite({todos: [
+  {"content": "Parse arguments and prepare", "status": "in_progress", "activeForm": "Parsing arguments"},
+  {"content": "Call /memory:docs to plan documentation", "status": "pending", "activeForm": "Calling /memory:docs"},
+  {"content": "Execute documentation generation", "status": "pending", "activeForm": "Executing documentation"},
+  {"content": "Generate SKILL.md index", "status": "pending", "activeForm": "Generating SKILL.md"}
+]})
+```
+
+**SECOND ACTION**: Execute Phase 1 immediately
+
+#### Full Path (SKIP_DOCS_GENERATION = false)
+
+**After Phase 1**:
+```javascript
+TodoWrite({todos: [
+  {"content": "Parse arguments and prepare", "status": "completed", "activeForm": "Parsing arguments"},
+  {"content": "Call /memory:docs to plan documentation", "status": "in_progress", "activeForm": "Calling /memory:docs"},
+  {"content": "Execute documentation generation", "status": "pending", "activeForm": "Executing documentation"},
+  {"content": "Generate SKILL.md index", "status": "pending", "activeForm": "Generating SKILL.md"}
+]})
+// Auto-continue to Phase 2
+```
+
+**After Phase 2**:
+```javascript
+TodoWrite({todos: [
+  {"content": "Parse arguments and prepare", "status": "completed", "activeForm": "Parsing arguments"},
+  {"content": "Call /memory:docs to plan documentation", "status": "completed", "activeForm": "Calling /memory:docs"},
+  {"content": "Execute documentation generation", "status": "in_progress", "activeForm": "Executing documentation"},
+  {"content": "Generate SKILL.md index", "status": "pending", "activeForm": "Generating SKILL.md"}
+]})
+// Auto-continue to Phase 3
+```
+
+**After Phase 3**:
+```javascript
+TodoWrite({todos: [
+  {"content": "Parse arguments and prepare", "status": "completed", "activeForm": "Parsing arguments"},
+  {"content": "Call /memory:docs to plan documentation", "status": "completed", "activeForm": "Calling /memory:docs"},
+  {"content": "Execute documentation generation", "status": "completed", "activeForm": "Executing documentation"},
+  {"content": "Generate SKILL.md index", "status": "in_progress", "activeForm": "Generating SKILL.md"}
+]})
+// Auto-continue to Phase 4
+```
+
+**After Phase 4**:
+```javascript
+TodoWrite({todos: [
+  {"content": "Parse arguments and prepare", "status": "completed", "activeForm": "Parsing arguments"},
+  {"content": "Call /memory:docs to plan documentation", "status": "completed", "activeForm": "Calling /memory:docs"},
+  {"content": "Execute documentation generation", "status": "completed", "activeForm": "Executing documentation"},
+  {"content": "Generate SKILL.md index", "status": "completed", "activeForm": "Generating SKILL.md"}
+]})
+// Report completion summary to user
+```
+
+#### Skip Path (SKIP_DOCS_GENERATION = true)
+
+**After Phase 1** (detects existing docs, skips Phase 2 & 3):
+```javascript
+TodoWrite({todos: [
+  {"content": "Parse arguments and prepare", "status": "completed", "activeForm": "Parsing arguments"},
+  {"content": "Call /memory:docs to plan documentation", "status": "completed", "activeForm": "Calling /memory:docs"},
+  {"content": "Execute documentation generation", "status": "completed", "activeForm": "Executing documentation"},
+  {"content": "Generate SKILL.md index", "status": "in_progress", "activeForm": "Generating SKILL.md"}
+]})
+// Display skip message: "Documentation already exists, skipping Phase 2 and Phase 3. Use --regenerate to force regeneration."
+// Jump directly to Phase 4
+```
+
+**After Phase 4**:
+```javascript
+TodoWrite({todos: [
+  {"content": "Parse arguments and prepare", "status": "completed", "activeForm": "Parsing arguments"},
+  {"content": "Call /memory:docs to plan documentation", "status": "completed", "activeForm": "Calling /memory:docs"},
+  {"content": "Execute documentation generation", "status": "completed", "activeForm": "Executing documentation"},
+  {"content": "Generate SKILL.md index", "status": "completed", "activeForm": "Generating SKILL.md"}
+]})
+// Report completion summary to user
+```
+
+### Execution Flow Diagrams
+
+#### Full Path Flow
+```
+User triggers command
+  ↓
+[TodoWrite] Initialize 4 phases (Phase 1 = in_progress)
+  ↓
+[Execute] Phase 1: Parse arguments
+  ↓
+[TodoWrite] Phase 1 = completed, Phase 2 = in_progress
+  ↓
+[Execute] Phase 2: Call /memory:docs
+  ↓
+[TodoWrite] Phase 2 = completed, Phase 3 = in_progress
+  ↓
+[Execute] Phase 3: Call /workflow:execute
+  ↓
+[TodoWrite] Phase 3 = completed, Phase 4 = in_progress
+  ↓
+[Execute] Phase 4: Generate SKILL.md
+  ↓
+[TodoWrite] Phase 4 = completed
+  ↓
+[Report] Display completion summary
+```
+
+#### Skip Path Flow
+```
+User triggers command
+  ↓
+[TodoWrite] Initialize 4 phases (Phase 1 = in_progress)
+  ↓
+[Execute] Phase 1: Parse arguments, detect existing docs
+  ↓
+[TodoWrite] Phase 1 = completed, Phase 2&3 = completed (skipped), Phase 4 = in_progress
+  ↓
+[Display] Skip message: "Documentation already exists, skipping Phase 2 and Phase 3"
+  ↓
+[Execute] Phase 4: Generate SKILL.md (always runs)
+  ↓
+[TodoWrite] Phase 4 = completed
+  ↓
+[Report] Display completion summary
+```
+
+### Error Handling
+
+- If any phase fails, mark it as "in_progress" (not completed)
+- Report error details to user
+- Do NOT auto-continue to next phase on failure
+
+---
+
+## Parameters
+
+```bash
+/memory:skill-memory [path] [--tool <gemini|qwen|codex>] [--regenerate] [--mode <full|partial>] [--cli-execute]
+```
+
+- **path**: Target directory (default: current directory)
+- **--tool**: CLI tool for documentation (default: gemini)
+  - `gemini`: Comprehensive documentation
+  - `qwen`: Architecture analysis
+  - `codex`: Implementation validation
+- **--regenerate**: Force regenerate all documentation
+  - When enabled: Deletes existing `.workflow/docs/{project_name}/` before regeneration
+  - Ensures fresh documentation from source code
+- **--mode**: Documentation mode (default: full)
+  - `full`: Complete docs (modules + README + ARCHITECTURE + EXAMPLES)
+  - `partial`: Module docs only
+- **--cli-execute**: Enable CLI-based documentation generation (optional)
+  - When enabled: CLI generates docs directly in implementation_approach
+  - When disabled (default): Agent generates documentation content
+
+---
+
+## Examples
+
+### Example 1: Generate SKILL Package (Default)
+
+```bash
+/memory:skill-memory
+```
+
+**Workflow**:
+1. Phase 1: Detects current directory, checks existing docs
+2. Phase 2: Calls `/memory:docs . --tool gemini --mode full` (Agent Mode)
+3. Phase 3: Executes documentation generation via `/workflow:execute`
+4. Phase 4: Generates SKILL.md at `.claude/skills/{project_name}/SKILL.md`
+
+### Example 2: Regenerate with Qwen
+
+```bash
+/memory:skill-memory /d/my_app --tool qwen --regenerate
+```
+
+**Workflow**:
+1. Phase 1: Parses target path, detects regenerate flag, deletes existing docs
+2. Phase 2: Calls `/memory:docs /d/my_app --tool qwen --mode full`
+3. Phase 3: Executes documentation regeneration
+4. Phase 4: Generates updated SKILL.md
+
+### Example 3: Partial Mode (Modules Only)
+
+```bash
+/memory:skill-memory --mode partial
+```
+
+**Workflow**:
+1. Phase 1: Detects partial mode
+2. Phase 2: Calls `/memory:docs . --tool gemini --mode partial` (Agent Mode)
+3. Phase 3: Executes module documentation only
+4. Phase 4: Generates SKILL.md with module-only index
+
+### Example 4: CLI Execute Mode
+
+```bash
+/memory:skill-memory --cli-execute
+```
+
+**Workflow**:
+1. Phase 1: Detects CLI execute mode
+2. Phase 2: Calls `/memory:docs . --tool gemini --mode full --cli-execute` (CLI Mode)
+3. Phase 3: Executes CLI-based documentation generation
+4. Phase 4: Generates SKILL.md at `.claude/skills/{project_name}/SKILL.md`
+
+### Example 5: Skip Path (Existing Docs)
+
+```bash
+/memory:skill-memory
+```
+
+**Scenario**: Documentation already exists in `.workflow/docs/{project_name}/`
+
+**Workflow**:
+1. Phase 1: Detects existing docs (5 files), sets SKIP_DOCS_GENERATION = true
+2. Display: "Documentation already exists, skipping Phase 2 and Phase 3. Use --regenerate to force regeneration."
+3. Phase 4: Generates or updates SKILL.md index only (~5-10x faster)
+
+---
+
+
+
+## Architecture
+
+```
+skill-memory (orchestrator)
+  ├─ Phase 1: Prepare (bash commands, skip decision)
+  ├─ Phase 2: /memory:docs (task planning, skippable)
+  ├─ Phase 3: /workflow:execute (task execution, skippable)
+  └─ Phase 4: Write SKILL.md (direct file generation, always runs)
+
+No task JSON created by this command
+All documentation tasks managed by /memory:docs
+Smart skip logic: 5-10x faster when docs exist
+```

.claude/commands/memory/style-skill-memory.md

@@ -0,0 +1,396 @@
+---
+name: style-skill-memory
+description: Generate SKILL memory package from style reference for easy loading and consistent design system usage
+argument-hint: "[package-name] [--regenerate]"
+allowed-tools: Bash,Read,Write,TodoWrite
+auto-continue: true
+---
+
+# Memory: Style SKILL Memory Generator
+
+## Overview
+
+**Purpose**: Convert style reference package into SKILL memory for easy loading and context management.
+
+**Input**: Style reference package at `.workflow/reference_style/{package-name}/`
+
+**Output**: SKILL memory index at `.claude/skills/style-{package-name}/SKILL.md`
+
+**Use Case**: Load design system context when working with UI components, analyzing design patterns, or implementing style guidelines.
+
+**Key Features**:
+- Extracts primary design references (colors, typography, spacing, etc.)
+- Provides dynamic adjustment guidelines for design tokens
+- Includes prerequisites and tooling requirements (browsers, PostCSS, dark mode)
+- Progressive loading structure for efficient token usage
+- Complete implementation examples with React components
+- Interactive preview showcase
+
+---
+
+## Quick Reference
+
+### Command Syntax
+
+```bash
+/memory:style-skill-memory [package-name] [--regenerate]
+
+# Arguments
+package-name    Style reference package name (required)
+--regenerate    Force regenerate SKILL.md even if it exists (optional)
+```
+
+### Usage Examples
+
+```bash
+# Generate SKILL memory for package
+/memory:style-skill-memory main-app-style-v1
+
+# Regenerate SKILL memory
+/memory:style-skill-memory main-app-style-v1 --regenerate
+
+# Package name from current directory or default
+/memory:style-skill-memory
+```
+
+### Key Variables
+
+**Input Variables**:
+- `PACKAGE_NAME`: Style reference package name
+- `PACKAGE_DIR`: `.workflow/reference_style/${package_name}`
+- `SKILL_DIR`: `.claude/skills/style-${package_name}`
+- `REGENERATE`: `true` if --regenerate flag, `false` otherwise
+
+**Data Sources** (Phase 2):
+- `DESIGN_TOKENS_DATA`: Complete design-tokens.json content (from Read)
+- `LAYOUT_TEMPLATES_DATA`: Complete layout-templates.json content (from Read)
+- `ANIMATION_TOKENS_DATA`: Complete animation-tokens.json content (from Read, if exists)
+
+**Metadata** (Phase 2):
+- `COMPONENT_COUNT`: Total components
+- `UNIVERSAL_COUNT`: Universal components count
+- `SPECIALIZED_COUNT`: Specialized components count
+- `UNIVERSAL_COMPONENTS`: Universal component names (first 5)
+- `HAS_ANIMATIONS`: Whether animation-tokens.json exists
+
+**Analysis Output** (`DESIGN_ANALYSIS` - Phase 2):
+- `has_colors`: Colors exist
+- `color_semantic`: Has semantic naming (primary/secondary/accent)
+- `uses_oklch`: Uses modern color spaces (oklch, lab, etc.)
+- `has_dark_mode`: Has separate light/dark mode color tokens
+- `spacing_pattern`: Pattern type ("linear", "geometric", "custom")
+- `spacing_scale`: Actual scale values (e.g., [4, 8, 16, 32, 64])
+- `has_typography`: Typography system exists
+- `typography_hierarchy`: Has size scale for hierarchy
+- `uses_calc`: Uses calc() expressions in token values
+- `has_radius`: Border radius exists
+- `radius_style`: Style characteristic ("sharp" <4px, "moderate" 4-8px, "rounded" >8px)
+- `has_shadows`: Shadow system exists
+- `shadow_pattern`: Elevation naming pattern
+- `has_animations`: Animation tokens exist
+- `animation_range`: Duration range (fast to slow)
+- `easing_variety`: Types of easing functions
+
+### Common Errors
+
+| Error | Cause | Resolution |
+|-------|-------|------------|
+| Package not found | Invalid package name or doesn't exist | Run `/workflow:ui-design:codify-style` first |
+| SKILL already exists | SKILL.md already generated | Use `--regenerate` flag |
+| Missing layout-templates.json | Incomplete package | Verify package integrity, re-run codify-style |
+| Invalid JSON format | Corrupted package files | Regenerate package with codify-style |
+
+---
+
+## Execution Process
+
+### Phase 1: Validate Package
+
+**TodoWrite** (First Action):
+```json
+[
+  {
+    "content": "Validate package exists and check SKILL status",
+    "activeForm": "Validating package and SKILL status",
+    "status": "in_progress"
+  },
+  {
+    "content": "Read package data and analyze design system",
+    "activeForm": "Reading package data and analyzing design system",
+    "status": "pending"
+  },
+  {
+    "content": "Generate SKILL.md with design principles and token values",
+    "activeForm": "Generating SKILL.md with design principles and token values",
+    "status": "pending"
+  }
+]
+```
+
+**Step 1: Parse Package Name**
+
+```bash
+# Get package name from argument or auto-detect
+bash(echo "${package_name}" || basename "$(pwd)" | sed 's/^style-//')
+```
+
+**Step 2: Validate Package Exists**
+
+```bash
+bash(test -d .workflow/reference_style/${package_name} && echo "exists" || echo "missing")
+```
+
+**Error Handling**:
+```javascript
+if (package_not_exists) {
+  error("ERROR: Style reference package not found: ${package_name}")
+  error("HINT: Run '/workflow:ui-design:codify-style' first to create package")
+  error("Available packages:")
+  bash(ls -1 .workflow/reference_style/ 2>/dev/null || echo "  (none)")
+  exit(1)
+}
+```
+
+**Step 3: Check SKILL Already Exists**
+
+```bash
+bash(test -f .claude/skills/style-${package_name}/SKILL.md && echo "exists" || echo "missing")
+```
+
+**Decision Logic**:
+```javascript
+if (skill_exists && !regenerate_flag) {
+  echo("SKILL memory already exists for: ${package_name}")
+  echo("Use --regenerate to force regeneration")
+  exit(0)
+}
+
+if (regenerate_flag && skill_exists) {
+  echo("Regenerating SKILL memory for: ${package_name}")
+}
+```
+
+**TodoWrite Update**: Mark "Validate" as completed, "Read package data" as in_progress
+
+---
+
+### Phase 2: Read Package Data & Analyze Design System
+
+**Step 1: Read All JSON Files**
+
+```bash
+# Read layout templates
+Read(file_path=".workflow/reference_style/${package_name}/layout-templates.json")
+
+# Read design tokens
+Read(file_path=".workflow/reference_style/${package_name}/design-tokens.json")
+
+# Read animation tokens (if exists)
+bash(test -f .workflow/reference_style/${package_name}/animation-tokens.json && echo "exists" || echo "missing")
+Read(file_path=".workflow/reference_style/${package_name}/animation-tokens.json")  # if exists
+```
+
+**Step 2: Extract Metadata for Description**
+
+```bash
+# Count components and classify by type
+bash(jq '.layout_templates | length' layout-templates.json)
+bash(jq '[.layout_templates[] | select(.component_type == "universal")] | length' layout-templates.json)
+bash(jq '[.layout_templates[] | select(.component_type == "specialized")] | length' layout-templates.json)
+bash(jq -r '.layout_templates | to_entries[] | select(.value.component_type == "universal") | .key' layout-templates.json | head -5)
+```
+
+Store results in metadata variables (see [Key Variables](#key-variables))
+
+**Step 3: Analyze Design System for Dynamic Principles**
+
+Analyze design-tokens.json to extract characteristics and patterns:
+
+```bash
+# Color system characteristics
+bash(jq '.colors | keys' design-tokens.json)
+bash(jq '.colors | to_entries[0:2] | map(.value)' design-tokens.json)
+# Check for modern color spaces
+bash(jq '.colors | to_entries[] | .value | test("oklch|lab|lch")' design-tokens.json)
+# Check for dark mode variants
+bash(jq '.colors | keys | map(select(contains("dark") or contains("light")))' design-tokens.json)
+# → Store: has_colors, color_semantic, uses_oklch, has_dark_mode
+
+# Spacing pattern detection
+bash(jq '.spacing | to_entries | map(.value) | map(gsub("[^0-9.]"; "") | tonumber)' design-tokens.json)
+# Analyze pattern: linear (4-8-12-16) vs geometric (4-8-16-32) vs custom
+# → Store: spacing_pattern, spacing_scale
+
+# Typography characteristics
+bash(jq '.typography | keys | map(select(contains("family") or contains("weight")))' design-tokens.json)
+bash(jq '.typography | to_entries | map(select(.key | contains("size"))) | .[].value' design-tokens.json)
+# Check for calc() usage
+bash(jq '. | tostring | test("calc\\(")' design-tokens.json)
+# → Store: has_typography, typography_hierarchy, uses_calc
+
+# Border radius style
+bash(jq '.border_radius | to_entries | map(.value)' design-tokens.json)
+# Check range: small (sharp <4px) vs moderate (4-8px) vs large (rounded >8px)
+# → Store: has_radius, radius_style
+
+# Shadow characteristics
+bash(jq '.shadows | keys' design-tokens.json)
+bash(jq '.shadows | to_entries[0].value' design-tokens.json)
+# → Store: has_shadows, shadow_pattern
+
+# Animations (if available)
+bash(jq '.duration | to_entries | map(.value)' animation-tokens.json)
+bash(jq '.easing | keys' animation-tokens.json)
+# → Store: has_animations, animation_range, easing_variety
+```
+
+Store analysis results in `DESIGN_ANALYSIS` (see [Key Variables](#key-variables))
+
+**Note**: Analysis focuses on characteristics and patterns, not counts. Include technical feature detection (oklch, calc, dark mode) for Prerequisites section.
+
+**TodoWrite Update**: Mark "Read package data" as completed, "Generate SKILL.md" as in_progress
+
+---
+
+### Phase 3: Generate SKILL.md
+
+**Step 1: Create SKILL Directory**
+
+```bash
+bash(mkdir -p .claude/skills/style-${package_name})
+```
+
+**Step 2: Generate Intelligent Description**
+
+**Format**:
+```
+{package_name} project-independent design system with {universal_count} universal layout templates and interactive preview (located at .workflow/reference_style/{package_name}). Load when working with reusable UI components, design tokens, layout patterns, or implementing visual consistency. Excludes {specialized_count} project-specific components.
+```
+
+**Step 3: Load and Process SKILL.md Template**
+
+**⚠️ CRITICAL - Execute First**:
+```bash
+bash(cat ~/.claude/workflows/cli-templates/memory/style-skill-memory/skill-md-template.md)
+```
+
+**Template Processing**:
+1. **Replace variables**: Substitute all `{variable}` placeholders with actual values from Phase 2
+2. **Generate dynamic sections**:
+   - **Prerequisites & Tooling**: Generate based on `DESIGN_ANALYSIS` technical features (oklch, calc, dark mode)
+   - **Design Principles**: Generate based on `DESIGN_ANALYSIS` characteristics
+   - **Complete Implementation Example**: Include React component example with token adaptation
+   - **Design Token Values**: Iterate `DESIGN_TOKENS_DATA`, `ANIMATION_TOKENS_DATA` and display all key-value pairs with DEFAULT annotations
+3. **Write to file**: Use Write tool to save to `.claude/skills/style-{package_name}/SKILL.md`
+
+**Variable Replacement Map**:
+- `{package_name}` → PACKAGE_NAME
+- `{intelligent_description}` → Generated description from Step 2
+- `{component_count}` → COMPONENT_COUNT
+- `{universal_count}` → UNIVERSAL_COUNT
+- `{specialized_count}` → SPECIALIZED_COUNT
+- `{universal_components_list}` → UNIVERSAL_COMPONENTS (comma-separated)
+- `{has_animations}` → HAS_ANIMATIONS
+
+**Dynamic Content Generation**:
+
+See template file for complete structure. Key dynamic sections:
+
+1. **Prerequisites & Tooling** (based on DESIGN_ANALYSIS technical features):
+   - IF uses_oklch → Include PostCSS plugin requirement (`postcss-oklab-function`)
+   - IF uses_calc → Include preprocessor requirement for calc() expressions
+   - IF has_dark_mode → Include dark mode implementation mechanism (class or media query)
+   - ALWAYS include browser support, jq installation, and local server setup
+
+2. **Design Principles** (based on DESIGN_ANALYSIS):
+   - IF has_colors → Include "Color System" principle with semantic pattern
+   - IF spacing_pattern detected → Include "Spatial Rhythm" with unified scale description (actual token values)
+   - IF has_typography_hierarchy → Include "Typographic System" with scale examples
+   - IF has_radius → Include "Shape Language" with style characteristic
+   - IF has_shadows → Include "Depth & Elevation" with elevation pattern
+   - IF has_animations → Include "Motion & Timing" with duration range
+   - ALWAYS include "Accessibility First" principle
+
+3. **Design Token Values** (iterate from read data):
+   - Colors: Iterate `DESIGN_TOKENS_DATA.colors`
+   - Typography: Iterate `DESIGN_TOKENS_DATA.typography`
+   - Spacing: Iterate `DESIGN_TOKENS_DATA.spacing`
+   - Border Radius: Iterate `DESIGN_TOKENS_DATA.border_radius` with calc() explanations
+   - Shadows: Iterate `DESIGN_TOKENS_DATA.shadows` with DEFAULT token annotations
+   - Animations (if available): Iterate `ANIMATION_TOKENS_DATA.duration` and `ANIMATION_TOKENS_DATA.easing`
+
+**Step 4: Verify SKILL.md Created**
+
+```bash
+bash(test -f .claude/skills/style-${package_name}/SKILL.md && echo "success" || echo "failed")
+```
+
+**TodoWrite Update**: Mark all todos as completed
+
+---
+
+### Completion Message
+
+Display a simple completion message with key information:
+
+```
+✅ SKILL memory generated for style package: {package_name}
+
+📁 Location: .claude/skills/style-{package_name}/SKILL.md
+
+📊 Package Summary:
+   - {component_count} components ({universal_count} universal, {specialized_count} specialized)
+   - Design tokens: colors, typography, spacing, shadows{animations_note}
+
+💡 Usage: /memory:load-skill-memory style-{package_name} "your task description"
+```
+
+Variables: `{package_name}`, `{component_count}`, `{universal_count}`, `{specialized_count}`, `{animations_note}` (", animations" if exists)
+
+---
+
+## Implementation Details
+
+### Critical Rules
+
+1. **Check Before Generate**: Verify package exists before attempting SKILL generation
+2. **Respect Existing SKILL**: Don't overwrite unless --regenerate flag provided
+3. **Load Templates via cat**: Use `cat ~/.claude/workflows/cli-templates/memory/style-skill-memory/{template}` to load templates
+4. **Variable Substitution**: Replace all `{variable}` placeholders with actual values
+5. **Technical Feature Detection**: Analyze tokens for modern features (oklch, calc, dark mode) and generate appropriate Prerequisites section
+6. **Dynamic Content Generation**: Generate sections based on DESIGN_ANALYSIS characteristics
+7. **Unified Spacing Scale**: Use actual token values as primary scale reference, avoid contradictory pattern descriptions
+8. **Direct Iteration**: Iterate data structures (DESIGN_TOKENS_DATA, etc.) for token values
+9. **Annotate Special Tokens**: Add comments for DEFAULT tokens and calc() expressions
+10. **Embed jq Commands**: Include bash/jq commands in SKILL.md for dynamic loading
+11. **Progressive Loading**: Include all 3 levels (0-2) with specific jq commands
+12. **Complete Examples**: Include end-to-end implementation examples (React components)
+13. **Intelligent Description**: Extract component count and key features from metadata
+14. **Emphasize Flexibility**: Strongly warn against rigid copying - values are references for creative adaptation
+
+### Template Files Location
+
+
+```
+Phase 1: Validate
+  ├─ Parse package_name
+  ├─ Check PACKAGE_DIR exists
+  └─ Check SKILL_DIR exists (skip if exists and no --regenerate)
+
+Phase 2: Read & Analyze
+  ├─ Read design-tokens.json → DESIGN_TOKENS_DATA
+  ├─ Read layout-templates.json → LAYOUT_TEMPLATES_DATA
+  ├─ Read animation-tokens.json → ANIMATION_TOKENS_DATA (if exists)
+  ├─ Extract Metadata → COMPONENT_COUNT, UNIVERSAL_COUNT, etc.
+  └─ Analyze Design System → DESIGN_ANALYSIS (characteristics)
+
+Phase 3: Generate
+  ├─ Create SKILL directory
+  ├─ Generate intelligent description
+  ├─ Load SKILL.md template (cat command)
+  ├─ Replace variables and generate dynamic content
+  ├─ Write SKILL.md
+  ├─ Verify creation
+  ├─ Load completion message template (cat command)
+  └─ Display completion message
+```

.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

@@ -0,0 +1,310 @@
+---
+name: tech-research-rules
+description: "3-phase orchestrator: extract tech stack → Exa research → generate path-conditional rules (auto-loaded by Claude Code)"
+argument-hint: "[session-id | tech-stack-name] [--regenerate] [--tool <gemini|qwen>]"
+allowed-tools: SlashCommand(*), TodoWrite(*), Bash(*), Read(*), Write(*), Task(*)
+---
+
+# Tech Stack Rules Generator
+
+## Overview
+
+**Purpose**: Generate multi-layered, path-conditional rules that Claude Code automatically loads based on file context.
+
+**Output Structure**:
+```
+.claude/rules/tech/{tech-stack}/
+├── core.md           # paths: **/*.{ext} - Core principles
+├── patterns.md       # paths: src/**/*.{ext} - Implementation patterns
+├── testing.md        # paths: **/*.{test,spec}.{ext} - Testing rules
+├── config.md         # paths: *.config.* - Configuration rules
+├── api.md            # paths: **/api/**/* - API rules (backend only)
+├── components.md     # paths: **/components/**/* - Component rules (frontend only)
+└── metadata.json     # Generation metadata
+```
+
+**Templates Location**: `~/.claude/workflows/cli-templates/prompts/rules/`
+
+---
+
+## Core Rules
+
+1. **Start Immediately**: First action is TodoWrite initialization
+2. **Path-Conditional Output**: Every rule file includes `paths` frontmatter
+3. **Template-Driven**: Agent reads templates before generating content
+4. **Agent Produces Files**: Agent writes all rule files directly
+5. **No Manual Loading**: Rules auto-activate when Claude works with matching files
+
+---
+
+## 3-Phase Execution
+
+### Phase 1: Prepare Context & Detect Tech Stack
+
+**Goal**: Detect input mode, extract tech stack info, determine file extensions
+
+**Input Mode Detection**:
+```bash
+input="$1"
+
+if [[ "$input" == WFS-* ]]; then
+  MODE="session"
+  SESSION_ID="$input"
+  # Read workflow-session.json to extract tech stack
+else
+  MODE="direct"
+  TECH_STACK_NAME="$input"
+fi
+```
+
+**Tech Stack Analysis**:
+```javascript
+// Decompose composite tech stacks
+// "typescript-react-nextjs" → ["typescript", "react", "nextjs"]
+
+const TECH_EXTENSIONS = {
+  "typescript": "{ts,tsx}",
+  "javascript": "{js,jsx}",
+  "python": "py",
+  "rust": "rs",
+  "go": "go",
+  "java": "java",
+  "csharp": "cs",
+  "ruby": "rb",
+  "php": "php"
+};
+
+const FRAMEWORK_TYPE = {
+  "react": "frontend",
+  "vue": "frontend",
+  "angular": "frontend",
+  "nextjs": "fullstack",
+  "nuxt": "fullstack",
+  "fastapi": "backend",
+  "express": "backend",
+  "django": "backend",
+  "rails": "backend"
+};
+```
+
+**Check Existing Rules**:
+```bash
+normalized_name=$(echo "$TECH_STACK_NAME" | tr '[:upper:]' '[:lower:]' | tr ' ' '-')
+rules_dir=".claude/rules/tech/${normalized_name}"
+existing_count=$(find "${rules_dir}" -name "*.md" 2>/dev/null | wc -l || echo 0)
+```
+
+**Skip Decision**:
+- If `existing_count > 0` AND no `--regenerate` → `SKIP_GENERATION = true`
+- If `--regenerate` → Delete existing and regenerate
+
+**Output Variables**:
+- `TECH_STACK_NAME`: Normalized name
+- `PRIMARY_LANG`: Primary language
+- `FILE_EXT`: File extension pattern
+- `FRAMEWORK_TYPE`: frontend | backend | fullstack | library
+- `COMPONENTS`: Array of tech components
+- `SKIP_GENERATION`: Boolean
+
+**TodoWrite**: Mark phase 1 completed
+
+---
+
+### Phase 2: Agent Produces Path-Conditional Rules
+
+**Skip Condition**: Skipped if `SKIP_GENERATION = true`
+
+**Goal**: Delegate to agent for Exa research and rule file generation
+
+**Template Files**:
+```
+~/.claude/workflows/cli-templates/prompts/rules/
+├── tech-rules-agent-prompt.txt  # Agent instructions
+├── rule-core.txt                # Core principles template
+├── rule-patterns.txt            # Implementation patterns template
+├── rule-testing.txt             # Testing rules template
+├── rule-config.txt              # Configuration rules template
+├── rule-api.txt                 # API rules template (backend)
+└── rule-components.txt          # Component rules template (frontend)
+```
+
+**Agent Task**:
+
+```javascript
+Task({
+  subagent_type: "general-purpose",
+  description: `Generate tech stack rules: ${TECH_STACK_NAME}`,
+  prompt: `
+You are generating path-conditional rules for Claude Code.
+
+## Context
+- Tech Stack: ${TECH_STACK_NAME}
+- Primary Language: ${PRIMARY_LANG}
+- File Extensions: ${FILE_EXT}
+- Framework Type: ${FRAMEWORK_TYPE}
+- Components: ${JSON.stringify(COMPONENTS)}
+- Output Directory: .claude/rules/tech/${TECH_STACK_NAME}/
+
+## Instructions
+
+Read the agent prompt template for detailed instructions.
+Use --rule rules-tech-rules-agent-prompt to load the template automatically.
+
+## Execution Steps
+
+1. Execute Exa research queries (see agent prompt)
+2. Read each rule template
+3. Generate rule files following template structure
+4. Write files to output directory
+5. Write metadata.json
+6. Report completion
+
+## Variable Substitutions
+
+Replace in templates:
+- {TECH_STACK_NAME} → ${TECH_STACK_NAME}
+- {PRIMARY_LANG} → ${PRIMARY_LANG}
+- {FILE_EXT} → ${FILE_EXT}
+- {FRAMEWORK_TYPE} → ${FRAMEWORK_TYPE}
+`
+})
+```
+
+**Completion Criteria**:
+- 4-6 rule files written with proper `paths` frontmatter
+- metadata.json written
+- Agent reports files created
+
+**TodoWrite**: Mark phase 2 completed
+
+---
+
+### Phase 3: Verify & Report
+
+**Goal**: Verify generated files and provide usage summary
+
+**Steps**:
+
+1. **Verify Files**:
+   ```bash
+   find ".claude/rules/tech/${TECH_STACK_NAME}" -name "*.md" -type f
+   ```
+
+2. **Validate Frontmatter**:
+   ```bash
+   head -5 ".claude/rules/tech/${TECH_STACK_NAME}/core.md"
+   ```
+
+3. **Read Metadata**:
+   ```javascript
+   Read(`.claude/rules/tech/${TECH_STACK_NAME}/metadata.json`)
+   ```
+
+4. **Generate Summary Report**:
+   ```
+   Tech Stack Rules Generated
+
+   Tech Stack: {TECH_STACK_NAME}
+   Location: .claude/rules/tech/{TECH_STACK_NAME}/
+
+   Files Created:
+   ├── core.md         → paths: **/*.{ext}
+   ├── patterns.md     → paths: src/**/*.{ext}
+   ├── testing.md      → paths: **/*.{test,spec}.{ext}
+   ├── config.md       → paths: *.config.*
+   ├── api.md          → paths: **/api/**/* (if backend)
+   └── components.md   → paths: **/components/**/* (if frontend)
+
+   Auto-Loading:
+   - Rules apply automatically when editing matching files
+   - No manual loading required
+
+   Example Activation:
+   - Edit src/components/Button.tsx → core.md + patterns.md + components.md
+   - Edit tests/api.test.ts → core.md + testing.md
+   - Edit package.json → config.md
+   ```
+
+**TodoWrite**: Mark phase 3 completed
+
+---
+
+## Path Pattern Reference
+
+| Pattern | Matches |
+|---------|---------|
+| `**/*.ts` | All .ts files |
+| `src/**/*` | All files under src/ |
+| `*.config.*` | Config files in root |
+| `**/*.{ts,tsx}` | .ts and .tsx files |
+
+| Tech Stack | Core Pattern | Test Pattern |
+|------------|--------------|--------------|
+| TypeScript | `**/*.{ts,tsx}` | `**/*.{test,spec}.{ts,tsx}` |
+| Python | `**/*.py` | `**/test_*.py, **/*_test.py` |
+| Rust | `**/*.rs` | `**/tests/**/*.rs` |
+| Go | `**/*.go` | `**/*_test.go` |
+
+---
+
+## Parameters
+
+```bash
+/memory:tech-research [session-id | "tech-stack-name"] [--regenerate]
+```
+
+**Arguments**:
+- **session-id**: `WFS-*` format - Extract from workflow session
+- **tech-stack-name**: Direct input - `"typescript"`, `"typescript-react"`
+- **--regenerate**: Force regenerate existing rules
+
+---
+
+## Examples
+
+### Single Language
+
+```bash
+/memory:tech-research "typescript"
+```
+
+**Output**: `.claude/rules/tech/typescript/` with 4 rule files
+
+### Frontend Stack
+
+```bash
+/memory:tech-research "typescript-react"
+```
+
+**Output**: `.claude/rules/tech/typescript-react/` with 5 rule files (includes components.md)
+
+### Backend Stack
+
+```bash
+/memory:tech-research "python-fastapi"
+```
+
+**Output**: `.claude/rules/tech/python-fastapi/` with 5 rule files (includes api.md)
+
+### From Session
+
+```bash
+/memory:tech-research WFS-user-auth-20251104
+```
+
+**Workflow**: Extract tech stack from session → Generate rules
+
+---
+
+## Comparison: Rules vs SKILL
+
+| Aspect | SKILL Memory | Rules |
+|--------|--------------|-------|
+| Loading | Manual: `Skill("tech")` | Automatic by path |
+| Scope | All files when loaded | Only matching files |
+| Granularity | Monolithic packages | Per-file-type |
+| Context | Full package | Only relevant rules |
+
+**When to Use**:
+- **Rules**: Tech stack conventions per file type
+- **SKILL**: Reference docs, APIs, examples for manual lookup

.claude/commands/memory/update-full.md

@@ -0,0 +1,332 @@
+---
+name: 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
+argument-hint: "[--tool gemini|qwen|codex] [--path <directory>]"
+---
+
+# Full Documentation Update (/memory:update-full)
+
+## Overview
+
+Orchestrates project-wide CLAUDE.md updates using batched agent execution with automatic tool fallback and 3-layer architecture support.
+
+**Parameters**:
+- `--tool <gemini|qwen|codex>`: Primary tool (default: gemini)
+- `--path <directory>`: Target specific directory (default: entire project)
+
+**Execution Flow**: Discovery → Plan Presentation → Execution → Safety Verification
+
+## 3-Layer Architecture & Auto-Strategy Selection
+
+### Layer Definition & Strategy Assignment
+
+| Layer | Depth | Strategy | Purpose | Context Pattern |
+|-------|-------|----------|---------|----------------|
+| **Layer 3** (Deepest) | ≥3 | `multi-layer` | Handle unstructured files, generate docs for all subdirectories | `@**/*` (all files) |
+| **Layer 2** (Middle) | 1-2 | `single-layer` | Aggregate from children + current code | `@*/CLAUDE.md @*.{ts,tsx,js,...}` |
+| **Layer 1** (Top) | 0 | `single-layer` | Aggregate from children + current code | `@*/CLAUDE.md @*.{ts,tsx,js,...}` |
+
+**Update 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
+
+#### Multi-Layer Strategy (Layer 3 Only)
+- **Use Case**: Deepest directories with unstructured file layouts
+- **Behavior**: Generates CLAUDE.md for current directory AND each subdirectory containing files
+- **Context**: All files in current directory tree (`@**/*`)
+
+
+#### Single-Layer Strategy (Layers 1-2)
+- **Use Case**: Upper layers that aggregate from existing documentation
+- **Behavior**: Generates CLAUDE.md only for current directory
+- **Context**: Direct children CLAUDE.md files + current directory code files
+
+### Example Flow
+```
+src/auth/handlers/ (depth 3) → MULTI-LAYER STRATEGY
+  CONTEXT: @**/* (all files in handlers/ and subdirs)
+  GENERATES: ./CLAUDE.md + CLAUDE.md in each subdir with files
+  ↓
+src/auth/ (depth 2) → SINGLE-LAYER STRATEGY
+  CONTEXT: @*/CLAUDE.md @*.ts (handlers/CLAUDE.md + current code)
+  GENERATES: ./CLAUDE.md only
+  ↓
+src/ (depth 1) → SINGLE-LAYER STRATEGY
+  CONTEXT: @*/CLAUDE.md (auth/CLAUDE.md, utils/CLAUDE.md)
+  GENERATES: ./CLAUDE.md only
+  ↓
+./ (depth 0) → SINGLE-LAYER STRATEGY
+  CONTEXT: @*/CLAUDE.md (src/CLAUDE.md, tests/CLAUDE.md)
+  GENERATES: ./CLAUDE.md only
+```
+
+## Core Execution Rules
+
+1. **Analyze First**: Git cache + module discovery before updates
+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 CLAUDE.md files modified
+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 update 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
+// Cache git changes
+Bash({command: "git add -A 2>/dev/null || true", run_in_background: false});
+
+// Get module structure
+Bash({command: "ccw tool exec get_modules_by_depth '{\"format\":\"list\"}'", run_in_background: false});
+
+// OR with --path
+Bash({command: "cd <target-path> && ccw tool exec get_modules_by_depth '{\"format\":\"list\"}'", run_in_background: false});
+```
+
+**Parse output** `depth:N|path:<PATH>|...` to extract module paths and count.
+
+**Smart filter**: Auto-detect and skip tests/build/config/docs based on project tech stack.
+
+### Phase 2: Plan Presentation
+
+**For <20 modules**:
+```
+Update Plan:
+  Tool: gemini (fallback: qwen → codex)
+  Total: 7 modules
+  Execution: Direct parallel (< 20 modules threshold)
+
+  Will update:
+  - ./core/interfaces (12 files) - depth 2 [Layer 2] - single-layer strategy
+  - ./core (22 files) - depth 1 [Layer 2] - single-layer strategy
+  - ./models (9 files) - depth 1 [Layer 2] - single-layer strategy
+  - ./utils (12 files) - depth 1 [Layer 2] - single-layer strategy
+  - . (5 files) - depth 0 [Layer 1] - single-layer strategy
+
+  Context Strategy (Auto-Selected):
+  - Layer 2 (depth 1-2): @*/CLAUDE.md + current code files
+  - Layer 1 (depth 0): @*/CLAUDE.md + current code files
+
+  Auto-skipped: ./tests, __pycache__, setup.py (15 paths)
+  Execution order: Layer 2 → Layer 1
+  Estimated time: ~5-10 minutes
+
+  Confirm execution? (y/n)
+```
+
+**For ≥20 modules**:
+```
+Update Plan:
+  Tool: gemini (fallback: qwen → codex)
+  Total: 31 modules
+  Execution: Agent batch processing (4 modules/agent)
+
+  Will update:
+  - ./src/features/auth (12 files) - depth 3 [Layer 3] - multi-layer strategy
+  - ./.claude/commands/cli (6 files) - depth 3 [Layer 3] - multi-layer strategy
+  - ./src/utils (8 files) - depth 2 [Layer 2] - single-layer strategy
+  ...
+
+  Context Strategy (Auto-Selected):
+  - Layer 3 (depth ≥3): @**/* (all files)
+  - Layer 2 (depth 1-2): @*/CLAUDE.md + current code files
+  - Layer 1 (depth 0): @*/CLAUDE.md + current code files
+  
+  Auto-skipped: ./tests, __pycache__, setup.py (15 paths)
+  Execution order: Layer 2 → Layer 1
+  Estimated time: ~5-10 minutes
+
+  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
+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 ? "multi-layer" : "single-layer";
+        for (let tool of tool_order) {
+          Bash({
+            command: `cd ${module.path} && ccw tool exec update_module_claude '{"strategy":"${strategy}","path":".","tool":"${tool}"}'`,
+            run_in_background: false
+          });
+          if (bash_result.exit_code === 0) {
+            report(`✅ ${module.path} (Layer ${layer}) updated 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);
+
+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=`Update ${batch.length} modules in Layer ${layer}`,
+        prompt=generate_batch_worker_prompt(batch, tool_order, layer)
+      )
+    );
+  }
+
+  await parallel_execute(worker_tasks);
+}
+```
+
+**Batch Worker Prompt Template**:
+```
+PURPOSE: Update CLAUDE.md for assigned modules with tool fallback
+
+TASK: Update documentation for assigned modules using specified strategies.
+
+MODULES:
+{{module_path_1}} (strategy: {{strategy_1}})
+{{module_path_2}} (strategy: {{strategy_2}})
+...
+
+TOOLS (try in order): {{tool_1}}, {{tool_2}}, {{tool_3}}
+
+EXECUTION SCRIPT: ccw tool exec update_module_claude
+  - Accepts strategy parameter: multi-layer | single-layer
+  - Tool execution via direct CLI commands (gemini/qwen/codex)
+
+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 update_module_claude '{"strategy":"{{strategy}}","path":".","tool":"${tool}"}'`,
+         run_in_background: false
+       })
+       exit_code=$?
+
+       if [ $exit_code -eq 0 ]; then
+         report "✅ {{module_path}} updated 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
+
+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 updated with {tool}
+    ⚠️  path/to/module failed with {tool}, trying next...
+    ❌ FAILED: path/to/module - all tools exhausted
+```
+### Phase 4: Safety Verification
+
+```javascript
+// Check only CLAUDE.md files modified
+Bash({command: 'git diff --cached --name-only | grep -v "CLAUDE.md" || echo "Only CLAUDE.md files modified"', run_in_background: false});
+
+// Display status
+Bash({command: "git status --short", run_in_background: false});
+```
+
+**Result Summary**:
+```
+Update Summary:
+  Total: 31 | Success: 29 | Failed: 2
+  Tool usage: gemini: 25, qwen: 4, codex: 0
+  Failed: path1, path2
+```
+
+## Error Handling
+
+**Batch Worker**: Tool fallback per module, batch isolation, clear status reporting
+**Coordinator**: Invalid path abort, user decline handling, safety check with auto-revert
+**Fallback Triggers**: Non-zero exit code, script timeout, unexpected output
+
+## Usage Examples
+
+```bash
+# Full project update (auto-strategy selection)
+/memory:update-full
+
+# Target specific directory
+/memory:update-full --path .claude
+/memory:update-full --path src/features/auth
+
+# Use specific tool
+/memory:update-full --tool qwen
+/memory:update-full --path .claude --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

.claude/commands/memory/update-related.md

@@ -0,0 +1,332 @@
+---
+name: 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
+argument-hint: "[--tool gemini|qwen|codex]"
+---
+
+# Related Documentation Update (/memory:update-related)
+
+## Overview
+
+Orchestrates context-aware CLAUDE.md updates for changed modules using batched agent execution with 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 Agent Execution → 4. Safety 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**: Update only changed modules and their parent contexts
+
+## 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 update script
+
+## Phase 1: Change Detection & Analysis
+
+```javascript
+// 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>` to extract affected modules.
+
+**Smart filter**: Auto-detect and skip tests/build/config/docs 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 Update Plan:
+  Tool: gemini (fallback: qwen → codex)
+  Changed: 4 modules | Batching: 4 modules/agent
+
+  Will update:
+  - ./src/api/auth (5 files) [new module]
+  - ./src/api (12 files) [parent of changed auth/]
+  - ./src (8 files) [parent context]
+  - . (14 files) [root level]
+
+  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]
+
+  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
+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 update_module_claude '{"strategy":"single-layer","path":".","tool":"${tool}"}'`,
+            run_in_background: false
+          });
+          if (bash_result.exit_code === 0) {
+            report(`✅ ${module.path} updated 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);
+
+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=`Update ${batch.length} modules at depth ${depth}`,
+        prompt=generate_batch_worker_prompt(batch, tool_order, "related")
+      )
+    );
+  }
+
+  await parallel_execute(worker_tasks);  // Batches run in parallel
+}
+```
+
+### Batch Worker Prompt Template
+
+```
+PURPOSE: Update CLAUDE.md for assigned modules with tool fallback (related mode)
+
+TASK:
+Update documentation for the following modules based on recent changes. For each module, try tools in order until success.
+
+MODULES:
+{{module_path_1}}
+{{module_path_2}}
+{{module_path_3}}
+{{module_path_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 update_module_claude '{"strategy":"single-layer","path":".","tool":"{{tool_1}}"}'`,
+       run_in_background: false
+     })
+     → Success: Report "✅ {{module_path}} updated with {{tool_1}}", proceed to next module
+     → Failure: Try tool 2
+  2. Try tool 2:
+     Bash({
+       command: `cd "{{module_path}}" && ccw tool exec update_module_claude '{"strategy":"single-layer","path":".","tool":"{{tool_2}}"}'`,
+       run_in_background: false
+     })
+     → Success: Report "✅ {{module_path}} updated with {{tool_2}}", proceed to next module
+     → Failure: Try tool 3
+  3. Try tool 3:
+     Bash({
+       command: `cd "{{module_path}}" && ccw tool exec update_module_claude '{"strategy":"single-layer","path":".","tool":"{{tool_3}}"}'`,
+       run_in_background: false
+     })
+     → Success: Report "✅ {{module_path}} updated with {{tool_3}}", proceed to next module
+     → Failure: Report "❌ FAILED: {{module_path}} failed all tools", proceed to next module
+
+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: Safety Verification
+
+```javascript
+// Check only CLAUDE.md modified
+Bash({command: 'git diff --cached --name-only | grep -v "CLAUDE.md" || echo "Only CLAUDE.md files modified"', run_in_background: false});
+
+// Display statistics
+Bash({command: "git diff --stat", run_in_background: false});
+```
+
+**Aggregate results**:
+```
+Update Summary:
+  Total: 4 | Success: 4 | Failed: 0
+
+  Tool usage:
+  - gemini: 4 modules
+  - qwen: 0 modules (fallback)
+  - codex: 0 modules
+
+  Changes:
+  src/api/auth/CLAUDE.md  | 45 +++++++++++++++++++++
+  src/api/CLAUDE.md       | 23 +++++++++--
+  src/CLAUDE.md           | 12 ++++--
+  CLAUDE.md               | 8 ++--
+  4 files changed, 82 insertions(+), 6 deletions(-)
+```
+
+## 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
+- Safety check fail: Auto-revert staging
+- Partial failures: Continue execution, report failed modules
+
+**Fallback Triggers**:
+- Non-zero exit code
+- Script timeout
+- Unexpected output
+
+## Tool Reference
+
+| Tool   | Best For                       | Fallback To    |
+|--------|--------------------------------|----------------|
+| gemini | Documentation, patterns        | qwen → codex   |
+| qwen   | Architecture, system design    | gemini → codex |
+| codex  | Implementation, code quality   | gemini → qwen  |
+
+## Usage Examples
+
+```bash
+# Daily development update
+/memory:update-related
+
+# After feature work with specific tool
+/memory:update-related --tool qwen
+
+# Code quality review after implementation
+/memory:update-related --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
+
+## Coordinator Checklist
+
+- Parse `--tool` (default: gemini)
+- Refresh code index for accurate change detection
+- Detect changed modules via detect_changed_modules.sh
+- **Smart filter modules** (auto-detect tech stack, skip tests/build/config/docs)
+- 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
+- Safety check (only CLAUDE.md modified)
+- Display git diff statistics + summary
+
+## Comparison with Full Update
+
+| Aspect | Related Update | Full Update |
+|--------|----------------|-------------|
+| **Scope** | Changed modules only | All project modules |
+| **Speed** | Fast (minutes) | Slower (10-30 min) |
+| **Use case** | Daily development | Major refactoring |
+| **Mode** | `"related"` | `"full"` |
+| **Trigger** | After commits | After major changes |
+| **Batching** | 4 modules/agent | 4 modules/agent |
+| **Fallback** | gemini→qwen→codex | gemini→qwen→codex |
+| **Complexity threshold** | ≤15 modules | ≤20 modules |

.claude/commands/memory/workflow-skill-memory.md

@@ -0,0 +1,517 @@
+---
+name: 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)
+argument-hint: "session <session-id> | all"
+allowed-tools: Task(*), TodoWrite(*), Bash(*), Read(*), Write(*)
+---
+
+# Workflow SKILL Memory Generator
+
+## Overview
+
+Generate SKILL package from archived workflow sessions using agent-driven analysis. Supports single-session incremental updates or parallel processing of all sessions.
+
+**Scope**: Only processes WFS-* workflow sessions. Other session types (e.g., doc sessions) are automatically ignored.
+
+## Usage
+
+```bash
+/memory:workflow-skill-memory session WFS-<session-id>   # Process single WFS session
+/memory:workflow-skill-memory all                        # Process all WFS sessions in parallel
+```
+
+## Execution Modes
+
+### Mode 1: Single Session (`session <session-id>`)
+
+**Purpose**: Incremental update - process one archived session and merge into existing SKILL package
+
+**Workflow**:
+1. **Validate session**: Check if session exists in `.workflow/.archives/{session-id}/`
+2. **Invoke agent**: Call `universal-executor` to analyze session and update SKILL documents
+3. **Agent tasks**:
+   - Read session data from `.workflow/.archives/{session-id}/`
+   - Extract lessons, conflicts, and outcomes
+   - Use Gemini for intelligent aggregation (optional)
+   - Update or create SKILL documents using templates
+   - Regenerate SKILL.md index
+
+**Command Example**:
+```bash
+/memory:workflow-skill-memory session WFS-user-auth
+```
+
+**Expected Output**:
+```
+Session WFS-user-auth processed
+Updated:
+- sessions-timeline.md (1 session added)
+- lessons-learned.md (3 lessons merged)
+- conflict-patterns.md (1 conflict added)
+- SKILL.md (index regenerated)
+```
+
+---
+
+### Mode 2: All Sessions (`all`)
+
+**Purpose**: Full regeneration - process all archived sessions in parallel for complete SKILL package
+
+**Workflow**:
+1. **List sessions**: Read manifest.json to get all archived session IDs
+2. **Parallel invocation**: Launch multiple `universal-executor` agents in parallel (one per session)
+3. **Agent coordination**:
+   - Each agent processes one session independently
+   - Agents use Gemini for analysis
+   - Agents collect data into JSON (no direct file writes)
+   - Final aggregator agent merges results and generates SKILL documents
+
+**Command Example**:
+```bash
+/memory:workflow-skill-memory all
+```
+
+**Expected Output**:
+```
+All sessions processed in parallel
+Sessions: 8 total
+Updated:
+- sessions-timeline.md (8 sessions)
+- lessons-learned.md (24 lessons aggregated)
+- conflict-patterns.md (12 conflicts documented)
+- SKILL.md (index regenerated)
+```
+
+---
+
+## Implementation Flow
+
+### Phase 1: Validation and Setup
+
+**Step 1.1: Parse Command Arguments**
+
+Extract mode and session ID:
+```javascript
+if (args === "all") {
+  mode = "all"
+} else if (args.startsWith("session ")) {
+  mode = "session"
+  session_id = args.replace("session ", "").trim()
+} else {
+  ERROR = "Invalid arguments. Usage: session <session-id> | all"
+  EXIT
+}
+```
+
+**Step 1.2: Validate Archive Directory**
+```bash
+bash(test -d .workflow/.archives && echo "exists" || echo "missing")
+```
+
+If missing, report error and exit.
+
+**Step 1.3: Mode-Specific Validation**
+
+**Single Session Mode**:
+```bash
+# Validate session ID format (must start with WFS-)
+if [[ ! "$session_id" =~ ^WFS- ]]; then
+  ERROR = "Invalid session ID format. Only WFS-* sessions are supported"
+  EXIT
+fi
+
+# Check if session exists
+bash(test -d .workflow/.archives/{session_id} && echo "exists" || echo "missing")
+```
+
+If missing, report error: "Session {session_id} not found in archives"
+
+**All Sessions Mode**:
+```bash
+# Read manifest and filter only WFS- sessions
+bash(cat .workflow/.archives/manifest.json | jq -r '.archives[].session_id | select(startswith("WFS-"))')
+```
+
+Store filtered session IDs in array. Ignore doc sessions and other non-WFS sessions.
+
+**Step 1.4: TodoWrite Initialization**
+
+**Single Session Mode**:
+```javascript
+TodoWrite({todos: [
+  {"content": "Validate session existence", "status": "completed", "activeForm": "Validating session"},
+  {"content": "Invoke agent to process session", "status": "in_progress", "activeForm": "Invoking agent"},
+  {"content": "Verify SKILL package updated", "status": "pending", "activeForm": "Verifying update"}
+]})
+```
+
+**All Sessions Mode**:
+```javascript
+TodoWrite({todos: [
+  {"content": "Read manifest and list sessions", "status": "completed", "activeForm": "Reading manifest"},
+  {"content": "Invoke agents in parallel", "status": "in_progress", "activeForm": "Invoking agents"},
+  {"content": "Verify SKILL package regenerated", "status": "pending", "activeForm": "Verifying regeneration"}
+]})
+```
+
+---
+
+### Phase 2: Agent Invocation
+
+#### Single Session Mode - Agent Task
+
+Invoke `universal-executor` with session-specific task:
+
+**Agent Prompt Structure**:
+```
+Task: Process Workflow Session for SKILL Package
+
+Context:
+- Session ID: {session_id}
+- Session Path: .workflow/.archives/{session_id}/
+- Mode: Incremental update
+
+Objectives:
+
+1. Read session data:
+   - workflow-session.json (metadata)
+   - IMPL_PLAN.md (implementation summary)
+   - TODO_LIST.md (if exists)
+   - manifest.json entry for lessons
+
+2. Extract key information:
+   - Description, tags, metrics
+   - Lessons (successes, challenges, watch_patterns)
+   - Context package path (reference only)
+   - Key outcomes from IMPL_PLAN
+
+3. Use Gemini for aggregation (optional):
+   Command pattern:
+   ccw cli -p "
+   PURPOSE: Extract lessons and conflicts from workflow session
+   TASK:
+   • Analyze IMPL_PLAN and lessons from manifest
+   • Identify success patterns and challenges
+   • Extract conflict patterns with resolutions
+   • Categorize by functional domain
+   MODE: analysis
+   CONTEXT: @IMPL_PLAN.md @workflow-session.json
+   EXPECTED: Structured lessons and conflicts in JSON format
+   RULES: Template reference from skill-aggregation.txt
+   " --tool gemini --mode analysis --cd .workflow/.archives/{session_id}
+
+3.5. **Generate SKILL.md Description** (CRITICAL for auto-loading):
+
+   Read skill-index.txt template Section: "Description Field Generation"
+
+   Execute command to get project root:
+   ```bash
+   git rev-parse --show-toplevel  # Example output: /d/Claude_dms3
+   ```
+
+   Apply description format:
+   ```
+   Progressive workflow development history (located at {project_root}).
+   Load this SKILL when continuing development, analyzing past implementations,
+   or learning from workflow history, especially when no relevant context exists in memory.
+   ```
+
+   **Validation**:
+   - [ ] Path uses forward slashes (not backslashes)
+   - [ ] All three use cases present
+   - [ ] Trigger optimization phrase included
+   - [ ] Path is absolute (starts with / or drive letter)
+
+4. Read templates for formatting guidance:
+   - ~/.claude/workflows/cli-templates/prompts/workflow/skill-sessions-timeline.txt
+   - ~/.claude/workflows/cli-templates/prompts/workflow/skill-lessons-learned.txt
+   - ~/.claude/workflows/cli-templates/prompts/workflow/skill-conflict-patterns.txt
+   - ~/.claude/workflows/cli-templates/prompts/workflow/skill-index.txt
+
+   **CRITICAL**: From skill-index.txt, read these sections:
+   - "Description Field Generation" - Rules for generating description
+   - "Variable Substitution Guide" - All required variables
+   - "Generation Instructions" - Step-by-step generation process
+   - "Validation Checklist" - Final validation steps
+
+5. Update SKILL documents:
+   - sessions-timeline.md: Append new session, update domain grouping
+   - lessons-learned.md: Merge lessons into categories, update frequencies
+   - conflict-patterns.md: Add conflicts, update recurring pattern frequencies
+   - SKILL.md: Regenerate index with updated counts
+
+   **For SKILL.md generation**:
+   - Follow "Generation Instructions" from skill-index.txt (Steps 1-7)
+   - Use git command for project_root: `git rev-parse --show-toplevel`
+   - Apply "Description Field Generation" rules
+   - Validate using "Validation Checklist"
+   - Increment version (patch level)
+
+6. Return result JSON:
+   {
+     "status": "success",
+     "session_id": "{session_id}",
+     "updates": {
+       "sessions_added": 1,
+       "lessons_merged": count,
+       "conflicts_added": count
+     }
+   }
+```
+
+---
+
+#### All Sessions Mode - Parallel Agent Tasks
+
+**Step 2.1: Launch parallel session analyzers**
+
+Invoke multiple agents in parallel (one message with multiple Task calls):
+
+**Per-Session Agent Prompt**:
+```
+Task: Extract Session Data for SKILL Package
+
+Context:
+- Session ID: {session_id}
+- Mode: Parallel analysis (no direct file writes)
+
+Objectives:
+
+1. Read session data (same as single mode)
+
+2. Extract key information (same as single mode)
+
+3. Use Gemini for analysis (same as single mode)
+
+4. Return structured data JSON:
+   {
+     "status": "success",
+     "session_id": "{session_id}",
+     "data": {
+       "metadata": {
+         "description": "...",
+         "archived_at": "...",
+         "tags": [...],
+         "metrics": {...}
+       },
+       "lessons": {
+         "successes": [...],
+         "challenges": [...],
+         "watch_patterns": [...]
+       },
+       "conflicts": [
+         {
+           "type": "architecture|dependencies|testing|performance",
+           "pattern": "...",
+           "resolution": "...",
+           "code_impact": [...]
+         }
+       ],
+       "impl_summary": "First 200 chars of IMPL_PLAN",
+       "context_package_path": "..."
+     }
+   }
+```
+
+**Step 2.2: Aggregate results**
+
+After all session agents complete, invoke aggregator agent:
+
+**Aggregator Agent Prompt**:
+```
+Task: Aggregate Session Results and Generate SKILL Package
+
+Context:
+- Mode: Full regeneration
+- Input: JSON results from {session_count} session agents
+
+Objectives:
+
+1. Aggregate all session data:
+   - Collect metadata from all sessions
+   - Merge lessons by category
+   - Group conflicts by type
+   - Sort sessions by date
+
+2. Use Gemini for final aggregation:
+   ccw cli -p "
+   PURPOSE: Aggregate lessons and conflicts from all workflow sessions
+   TASK:
+   • Group successes by functional domain
+   • Categorize challenges by severity (HIGH/MEDIUM/LOW)
+   • Identify recurring conflict patterns
+   • Calculate frequencies and prioritize
+   MODE: analysis
+   CONTEXT: [Provide aggregated JSON data]
+   EXPECTED: Final aggregated structure for SKILL documents
+   RULES: Template reference from skill-aggregation.txt
+   " --tool gemini --mode analysis
+
+3. Read templates for formatting (same 4 templates as single mode)
+
+4. Generate all SKILL documents:
+   - sessions-timeline.md (all sessions, sorted by date)
+   - lessons-learned.md (aggregated lessons with frequencies)
+   - conflict-patterns.md (recurring patterns with resolutions)
+   - SKILL.md (index with progressive loading)
+
+5. Write files to .claude/skills/workflow-progress/
+
+6. Return result JSON:
+   {
+     "status": "success",
+     "sessions_processed": count,
+     "files_generated": ["SKILL.md", "sessions-timeline.md", ...],
+     "summary": {
+       "total_sessions": count,
+       "functional_domains": [...],
+       "date_range": "...",
+       "lessons_count": count,
+       "conflicts_count": count
+     }
+   }
+```
+
+---
+
+### Phase 3: Verification
+
+**Step 3.1: Check SKILL Package Files**
+```bash
+bash(ls -lh .claude/skills/workflow-progress/)
+```
+
+Verify all 4 files exist:
+- SKILL.md
+- sessions-timeline.md
+- lessons-learned.md
+- conflict-patterns.md
+
+**Step 3.2: TodoWrite Completion**
+
+Mark all tasks as completed.
+
+**Step 3.3: Display Summary**
+
+**Single Session Mode**:
+```
+Session {session_id} processed successfully
+
+Updated:
+- sessions-timeline.md
+- lessons-learned.md
+- conflict-patterns.md
+- SKILL.md
+
+SKILL Location: .claude/skills/workflow-progress/SKILL.md
+```
+
+**All Sessions Mode**:
+```
+All sessions processed in parallel
+
+Sessions: {count} total
+Functional Domains: {domain_list}
+Date Range: {earliest} - {latest}
+
+Generated:
+- sessions-timeline.md ({count} sessions)
+- lessons-learned.md ({lessons_count} lessons)
+- conflict-patterns.md ({conflicts_count} conflicts)
+- SKILL.md (4-level progressive loading)
+
+SKILL Location: .claude/skills/workflow-progress/SKILL.md
+
+Usage:
+- Level 0: Quick refresh (~2K tokens)
+- Level 1: Recent history (~8K tokens)
+- Level 2: Complete analysis (~25K tokens)
+- Level 3: Deep dive (~40K tokens)
+```
+
+---
+
+## Agent Guidelines
+
+### Agent Capabilities
+
+**universal-executor agents can**:
+- Read files from `.workflow/.archives/`
+- Execute bash commands
+- Call Gemini CLI for intelligent analysis
+- Read template files for formatting guidance
+- Write SKILL package files (single mode) or return JSON (parallel mode)
+- Return structured results
+
+### Gemini Usage Pattern
+
+**When to use Gemini**:
+- Aggregating lessons from multiple sources
+- Identifying recurring patterns
+- Classifying conflicts by type and severity
+- Extracting structured data from IMPL_PLAN
+
+**Fallback Strategy**: If Gemini fails or times out, use direct file parsing with structured extraction logic.
+
+---
+
+## Template System
+
+### Template Files
+
+All templates located in: `~/.claude/workflows/cli-templates/prompts/workflow/`
+
+1. **skill-sessions-timeline.txt**: Format for sessions-timeline.md
+2. **skill-lessons-learned.txt**: Format for lessons-learned.md
+3. **skill-conflict-patterns.txt**: Format for conflict-patterns.md
+4. **skill-index.txt**: Format for SKILL.md index
+5. **skill-aggregation.txt**: Rules for Gemini aggregation (existing)
+
+### Template Usage in Agent
+
+**Agents read templates to understand**:
+- File structure and markdown format
+- Data sources (which files to read)
+- Update strategy (incremental vs full)
+- Formatting rules and conventions
+- Aggregation logic (for Gemini)
+
+**Templates are NOT shown in this command documentation** - agents read them directly as needed.
+
+---
+
+## Error Handling
+
+### Validation Errors
+- **No archives directory**: "Error: No workflow archives found at .workflow/.archives/"
+- **Invalid session ID format**: "Error: Invalid session ID format. Only WFS-* sessions are supported"
+- **Session not found**: "Error: Session {session_id} not found in archives"
+- **No WFS sessions in manifest**: "Error: No WFS-* workflow sessions found in manifest.json"
+
+### Agent Errors
+- If agent fails, report error message from agent result
+- If Gemini times out, agents use fallback direct parsing
+- If template read fails, agents use inline format
+
+### Recovery
+- Single session mode: Can be retried without affecting other sessions
+- All sessions mode: If one agent fails, others continue; retry failed sessions individually
+
+
+
+## Integration
+
+### Called by `/workflow:session:complete`
+
+Automatically invoked after session archival:
+```bash
+SlashCommand(command="/memory:workflow-skill-memory session {session_id}")
+```
+
+### Manual Invocation
+
+Users can manually process sessions:
+```bash
+/memory:workflow-skill-memory session WFS-custom-feature  # Single session
+/memory:workflow-skill-memory all                         # Full regeneration
+```

.claude/commands/task/breakdown.md

@@ -1,247 +1,204 @@
 ---
 name: breakdown
-description: Intelligent task decomposition with context-aware subtask generation
-usage: /task:breakdown <task-id>
-argument-hint: task-id
-examples:
-  - /task:breakdown IMPL-1
-  - /task:breakdown IMPL-1.1
-  - /task:breakdown impl-3
+description: Decompose complex task into subtasks with dependency mapping, creates child task JSONs with parent references and execution order
+argument-hint: "task-id"
 ---
 
 # Task Breakdown Command (/task:breakdown)
 
 ## Overview
-Intelligently breaks down complex tasks into manageable subtasks with automatic context distribution and agent assignment.
+Breaks down complex tasks into executable subtasks with context inheritance and agent assignment.
 
 ## Core Principles
-**Task Schema:** @~/.claude/workflows/workflow-architecture.md
+**File Cohesion:** Related files must stay in same task
+**10-Task Limit:** Total tasks cannot exceed 10 (triggers re-scoping)
 
-## Features
+## Core Features
 
-⚠️ **CRITICAL**: Before breakdown, MUST check for existing active session to avoid creating duplicate sessions.
+**CRITICAL**: Manual breakdown with safety controls to prevent file conflicts and task limit violations.
 
-### Session Check Process
-1. **Check Active Session**: Check for `.workflow/.active-*` marker file to identify active session containing the parent task.
-2. **Session Validation**: Use existing active session containing the parent task
-3. **Context Integration**: Load existing session state and task hierarchy
-
-### Smart Decomposition
-- **Auto Strategy**: AI-powered subtask generation based on title
-- **Interactive Mode**: Guided breakdown with suggestions
-- **Context Distribution**: Subtasks inherit parent context
-- **Agent Mapping**: Automatic agent assignment per subtask
-
-### Simplified Task Management
-- **JSON Task Hierarchy**: Creates hierarchical JSON subtasks (impl-N.M.P)
-- **Context Distribution**: Subtasks inherit parent context
-- **Basic Status Tracking**: Updates task relationships only
-- **No Complex Synchronization**: Simple parent-child relationships
+### Breakdown Process
+1. **Session Check**: Verify active session contains parent task
+2. **Task Validation**: Ensure parent is `pending` status
+3. **10-Task Limit Check**: Verify breakdown won't exceed total limit
+4. **Manual Decomposition**: User defines subtasks with validation
+5. **File Conflict Detection**: Warn if same files appear in multiple subtasks
+6. **Similar Function Warning**: Alert if subtasks have overlapping functionality
+7. **Context Distribution**: Inherit parent requirements and scope
+8. **Agent Assignment**: Auto-assign agents based on subtask type
+9. **TODO_LIST Update**: Regenerate TODO_LIST.md with new structure
 
 ### Breakdown Rules
 - Only `pending` tasks can be broken down
-- Parent becomes container (not directly executable)
-- Subtasks use hierarchical format: impl-N.M.P (e.g., impl-1.1.2)
-- Maximum depth: 3 levels (impl-N.M.P)
-- Parent-child relationships tracked in JSON only
+- **Manual breakdown only**: Automated breakdown disabled to prevent violations
+- Parent becomes `container` status (not executable)
+- Subtasks use format: IMPL-N.M (max 2 levels)
+- Context flows from parent to subtasks
+- All relationships tracked in JSON
+- **10-task limit enforced**: Breakdown rejected if total would exceed 10 tasks
+- **File cohesion preserved**: Same files cannot be split across subtasks
 
 ## Usage
 
 ### Basic Breakdown
 ```bash
-/task:breakdown IMPL-1
+/task:breakdown impl-1
 ```
 
-Interactive prompt:
+Interactive process:
 ```
 Task: Build authentication module
+Current total tasks: 6/10
 
-Suggested subtasks:
-1. Design authentication schema
-2. Implement login endpoint  
-3. Add JWT token handling
-4. Write unit tests
+MANUAL BREAKDOWN REQUIRED
+Define subtasks manually (remaining capacity: 4 tasks):
 
-Accept task breakdown? (y/n/edit): y
+1. Enter subtask title: User authentication core
+   Focus files: models/User.js, routes/auth.js, middleware/auth.js
+
+2. Enter subtask title: OAuth integration
+   Focus files: services/OAuthService.js, routes/oauth.js
+
+FILE CONFLICT DETECTED:
+   - routes/auth.js appears in multiple subtasks
+   - Recommendation: Merge related authentication routes
+
+SIMILAR FUNCTIONALITY WARNING:
+   - "User authentication" and "OAuth integration" both handle auth
+   - Consider combining into single task
+
+# Use AskUserQuestion for confirmation
+AskUserQuestion({
+  questions: [{
+    question: "File conflicts and/or similar functionality detected. How do you want to proceed?",
+    header: "Confirm",
+    options: [
+      { label: "Proceed with breakdown", description: "Accept the risks and create the subtasks as defined." },
+      { label: "Restart breakdown", description: "Discard current subtasks and start over." },
+      { label: "Cancel breakdown", description: "Abort the operation and leave the parent task as is." }
+    ],
+    multiSelect: false
+  }]
+})
+
+User selected: "Proceed with breakdown"
+
+Task IMPL-1 broken down:
+IMPL-1: Build authentication module (container)
+  ├── IMPL-1.1: User authentication core -> @code-developer
+  └── IMPL-1.2: OAuth integration -> @code-developer
+
+Files updated: .task/IMPL-1.json + 2 subtask files + TODO_LIST.md
 ```
 
-### Auto Strategy
-```bash
-/task:breakdown impl-1 --strategy=auto
-```
+## Decomposition Logic
 
-Automatic generation:
-```
-✅ Task impl-1 broken down:
-├── impl-1.1: Design authentication schema
-├── impl-1.2: Implement core auth logic
-├── impl-1.3: Add security middleware
-└── impl-1.4: Write comprehensive tests
+### Agent Assignment
+- **Design/Planning** → `@planning-agent`
+- **Implementation** → `@code-developer`
+- **Testing** → `@code-developer` (type: "test-gen")
+- **Test Validation** → `@test-fix-agent` (type: "test-fix")
+- **Review** → `@universal-executor` (optional)
 
-Agents assigned:
-- impl-1.1 → planning-agent
-- impl-1.2 → code-developer
-- impl-1.3 → code-developer
-- impl-1.4 → test-agent
+### Context Inheritance
+- Subtasks inherit parent requirements
+- Scope refined for specific subtask
+- Implementation details distributed appropriately
 
-JSON files created:
-- .task/impl-1.1.json
-- .task/impl-1.2.json
-- .task/impl-1.3.json
-- .task/impl-1.4.json
-```
+## Safety Controls
 
-## Decomposition Patterns
+### File Conflict Detection
+**Validates file cohesion across subtasks:**
+- Scans `focus_paths` in all subtasks
+- Warns if same file appears in multiple subtasks
+- Suggests merging subtasks with overlapping files
+- Blocks breakdown if critical conflicts detected
 
-### Feature Task Pattern
-```
-Feature: "Implement shopping cart"
-├── Design data model
-├── Build API endpoints
-├── Add state management
-├── Create UI components
-└── Write tests
-```
+### Similar Functionality Detection
+**Prevents functional overlap:**
+- Analyzes subtask titles for similar keywords
+- Warns about potential functional redundancy
+- Suggests consolidation of related functionality
+- Examples: "user auth" + "login system" → merge recommendation
 
-### Bug Fix Pattern
-```
-Bug: "Fix performance issue"
-├── Profile and identify bottleneck
-├── Implement optimization
-├── Verify fix
-└── Add regression test
-```
+### 10-Task Limit Enforcement
+**Hard limit compliance:**
+- Counts current total tasks in session
+- Calculates breakdown impact on total
+- Rejects breakdown if would exceed 10 tasks
+- Suggests re-scoping if limit reached
 
-### Refactor Pattern
-```
-Refactor: "Modernize auth system"
-├── Analyze current implementation
-├── Design new architecture
-├── Migrate incrementally
-├── Update documentation
-└── Deprecate old code
-```
+### Manual Control Requirements
+**User-driven breakdown only:**
+- No automatic subtask generation
+- User must define each subtask title and scope
+- Real-time validation during input
+- Confirmation required before execution
 
-## Context Distribution
+## Implementation Details
 
-Parent context is intelligently distributed:
-```json
-{
-  "parent": {
-    "id": "impl-1",
-    "context": {
-      "requirements": ["JWT auth", "2FA support"],
-      "scope": ["src/auth/*"],
-      "acceptance": ["Authentication system works"],
-      "inherited_from": "WFS-user-auth"
-    }
-  },
-  "subtasks": [
-    {
-      "id": "impl-1.1",
-      "title": "Design authentication schema",
-      "status": "pending",
-      "agent": "planning-agent",
-      "context": {
-        "requirements": ["JWT auth schema", "User model design"],
-        "scope": ["src/auth/models/*"],
-        "acceptance": ["Schema validates JWT tokens", "User model complete"],
-        "inherited_from": "impl-1"
-      },
-      "relations": {
-        "parent": "impl-1",
-        "subtasks": [],
-        "dependencies": []
-      }
-    }
-  ]
-}
-```
-
-## Agent Assignment Logic
-
-Based on subtask type:
-- **Design/Planning** → `planning-agent`
-- **Implementation** → `code-developer`
-- **Testing** → `test-agent`
-- **Documentation** → `docs-agent`
-- **Review** → `review-agent`
+- Complete task JSON schema
+- Implementation field structure
+- Context inheritance rules
+- Agent assignment logic
 
 ## Validation
 
 ### Pre-breakdown Checks
-1. Task exists and is valid
-2. Task status is `pending`
-3. Not already broken down
-4. Workflow in IMPLEMENT phase
+1. Active session exists
+2. Task found in session
+3. Task status is `pending`
+4. Not already broken down
+5. **10-task limit compliance**: Total tasks + new subtasks ≤ 10
+6. **Manual mode enabled**: No automatic breakdown allowed
 
 ### Post-breakdown Actions
-1. Update parent status to `container`
+1. Update parent to `container` status
 2. Create subtask JSON files
-3. Update parent task with subtask references
-4. Update workflow session stats
-
-## Simple File Management
-
-### File Structure Created
-```
-.workflow/WFS-[topic-slug]/
-├── workflow-session.json     # Session state
-├── IMPL_PLAN.md             # Static planning document
-└── .task/
-    ├── impl-1.json          # Parent task (container) 
-    ├── impl-1.1.json        # Subtask 1
-    └── impl-1.2.json        # Subtask 2
-```
-
-### Output Files
-- JSON subtask files in `.task/` directory
-- Updated parent task JSON with subtask references
-- Updated session stats in `workflow-session.json`
+3. Update parent subtasks list
+4. Update session stats
+5. **Regenerate TODO_LIST.md** with new hierarchy
+6. Validate file paths in focus_paths
+7. Update session task count
 
 ## Examples
 
-### Simple Breakdown
+### Basic Breakdown
 ```bash
 /task:breakdown impl-1
 
-Result:
 impl-1: Build authentication (container)
-├── impl-1.1: Design auth schema
-├── impl-1.2: Implement auth logic  
-├── impl-1.3: Add security middleware
-└── impl-1.4: Write tests
-```
-
-### Two-Level Breakdown
-```bash
-/task:breakdown impl-1 --depth=2
-
-Result:  
-impl-1: E-commerce checkout (container)
-├── impl-1.1: Payment processing
-│   ├── impl-1.1.1: Integrate gateway
-│   └── impl-1.1.2: Handle transactions
-├── impl-1.2: Order management
-│   └── impl-1.2.1: Create order model
-└── impl-1.3: Testing
+  ├── impl-1.1: Design schema -> @planning-agent
+  ├── impl-1.2: Implement logic + tests -> @code-developer
+  └── impl-1.3: Execute & fix tests -> @test-fix-agent
 ```
 
 ## Error Handling
 
 ```bash
 # Task not found
-❌ Task impl-5 not found
+Task IMPL-5 not found
 
 # Already broken down
-⚠️ Task impl-1 already has subtasks
+Task IMPL-1 already has subtasks
 
-# Max depth exceeded
-❌ Cannot create impl-1.2.3.4 (max 3 levels)
+# Wrong status
+Cannot breakdown completed task IMPL-2
+
+# 10-task limit exceeded
+Breakdown would exceed 10-task limit (current: 8, proposed: 4)
+Suggestion: Re-scope project into smaller iterations
+
+# File conflicts detected
+File conflict: routes/auth.js appears in IMPL-1.1 and IMPL-1.2
+Recommendation: Merge subtasks or redistribute files
+
+# Similar functionality warning
+Similar functions detected: "user login" and "authentication"
+Consider consolidating related functionality
+
+# Manual breakdown required
+Automatic breakdown disabled. Use manual breakdown process.
 ```
 
-## Related Commands
-
-- `/task:create` - Create new tasks
-- `/task:execute` - Execute subtasks  
-- `/context` - View task hierarchy
+**System ensures**: Manual breakdown control with file cohesion enforcement, similar functionality detection, and 10-task limit compliance

.claude/commands/task/create.md

@@ -1,42 +1,32 @@
 ---
 name: create
-description: Create implementation tasks with automatic context awareness
-usage: /task:create "title"
-argument-hint: "task title"
-examples:
-  - /task:create "Implement user authentication"
-  - /task:create "Build REST API endpoints"
-  - /task:create "Fix login validation bug"
+description: Generate task JSON from natural language description with automatic file pattern detection, scope inference, and dependency analysis
+argument-hint: "\"task title\""
 ---
 
 # Task Create Command (/task:create)
 
 ## Overview
-Creates new implementation tasks during IMPLEMENT phase with automatic context awareness and ID generation.
+Creates new implementation tasks with automatic context awareness and ID generation.
 
 ## Core Principles
-**Task Management:** @~/.claude/workflows/workflow-architecture.md
+**Task System:** @~/.claude/workflows/task-core.md
 
-## Features
+## Core Features
 
 ### Automatic Behaviors
-- **ID Generation**: Auto-generates impl-N hierarchical format (impl-N.M.P max depth)
-- **Context Inheritance**: Inherits from workflow session and IMPL_PLAN.md
-- **JSON File Creation**: Generates task JSON in `.workflow/WFS-[topic-slug]/.task/`
-- **Document Integration**: Creates/updates TODO_LIST.md based on complexity triggers
+- **ID Generation**: Auto-generates IMPL-N format (max 2 levels)
+- **Context Inheritance**: Inherits from active workflow session
+- **JSON Creation**: Creates task JSON in active session
 - **Status Setting**: Initial status = "pending"
-- **Workflow Sync**: Updates workflow-session.json task list automatically
 - **Agent Assignment**: Suggests agent based on task type
-- **Hierarchy Support**: Creates parent-child relationships up to 3 levels
-- **Progressive Structure**: Auto-triggers enhanced structure at complexity thresholds
-- **Dynamic Complexity Escalation**: Automatically upgrades workflow complexity when thresholds are exceeded
+- **Session Integration**: Updates workflow session stats
 
 ### Context Awareness
-- Detects current workflow phase (must be IMPLEMENT)
-- Reads existing tasks from `.task/` directory to avoid duplicates
-- Inherits requirements and scope from workflow-session.json
-- Suggests related tasks based on existing JSON task hierarchy
-- Analyzes complexity for structure level determination (Level 0-2)
+- Validates active workflow session exists
+- Avoids duplicate task IDs
+- Inherits session requirements and scope
+- Suggests task relationships
 
 ## Usage
 
@@ -47,17 +37,11 @@ Creates new implementation tasks during IMPLEMENT phase with automatic context a
 
 Output:
 ```
-✅ Task created: impl-1
+Task created: IMPL-1
 Title: Build authentication module
 Type: feature
+Agent: code-developer
 Status: pending
-Depth: 1 (main task)
-Context inherited from workflow
-```
-
-### With Options
-```bash
-/task:create "Fix security vulnerability" --type=bugfix --priority=critical
 ```
 
 ### Task Types
@@ -67,200 +51,102 @@ Context inherited from workflow
 - `test` - Test implementation
 - `docs` - Documentation
 
-### Priority Levels (Optional - moved to context)
-- `low` - Can be deferred  
-- `normal` - Standard priority (default)
-- `high` - Should be done soon
-- `critical` - Must be done immediately
+## Task Creation Process
 
-**Note**: Priority is now stored in `context.priority` if needed, removed from top level for simplification.
+1. **Session Validation**: Check active workflow session
+2. **ID Generation**: Auto-increment IMPL-N
+3. **Context Inheritance**: Load workflow context
+4. **Implementation Setup**: Initialize implementation field
+5. **Agent Assignment**: Select appropriate agent
+6. **File Creation**: Save JSON to .task/ directory
+7. **Session Update**: Update workflow stats
 
-## Simplified Task Structure
+**Task Schema**: See @~/.claude/workflows/task-core.md for complete JSON structure
 
-```json
-{
-  "id": "impl-1",
-  "title": "Build authentication module",
-  "status": "pending",
-  "type": "feature",
-  "agent": "code-developer",
-  
-  "context": {
-    "requirements": ["JWT authentication", "OAuth2 support"],
-    "scope": ["src/auth/*", "tests/auth/*"],
-    "acceptance": ["Module handles JWT tokens", "OAuth2 flow implemented"],
-    "inherited_from": "WFS-user-auth"
-  },
-  
-  "relations": {
-    "parent": null,
-    "subtasks": [],
-    "dependencies": []
-  },
-  
-  "execution": {
-    "attempts": 0,
-    "last_attempt": null
-  },
-  
-  "meta": {
-    "created": "2025-09-05T10:30:00Z",
-    "updated": "2025-09-05T10:30:00Z"
-  }
-}
+## Implementation Field Setup
+
+### Auto-Population Strategy
+- **Detailed info**: Extract from task description and scope
+- **Missing info**: Mark `pre_analysis` as multi-step array format for later pre-analysis
+- **Basic structure**: Initialize with standard template
+
+### Analysis Triggers
+When implementation details incomplete:
+```bash
+Task requires analysis for implementation details
+Suggest running: gemini analysis for file locations and dependencies
 ```
 
-## Simplified File Generation
+## File Management
 
-### JSON Task File Only
-**File Location**: `.task/impl-[N].json`
-**Naming**: Follows impl-N.M.P format for nested tasks  
-**Content**: Contains all task data (no document coordination needed)
+### JSON Task File
+- **Location**: `.task/IMPL-[N].json` in active session
+- **Content**: Complete task with implementation field
+- **Updates**: Session stats only
 
-### No Document Synchronization
-- Creates JSON task file only
-- Updates workflow-session.json stats only  
-- No automatic TODO_LIST.md generation
-- No complex cross-referencing needed
-
-### View Generation On-Demand
-- Use `/context` to generate views when needed
-- No persistent markdown files created
-- All data stored in JSON only
-
-## Simplified Task Management
-
-### Basic Task Statistics
-- Task count tracked in workflow-session.json
-- No automatic complexity escalation
-- Manual workflow type selection during init
-
-### Simple Creation Process
-```
-1. Create New Task → Generate JSON file only
-2. Update Session Stats → Increment task count  
-3. Notify User → Confirm task created
-```
-
-### Benefits of Simplification
-- **No Overhead**: Just create tasks, no complex logic
-- **Predictable**: Same process every time
-- **Fast**: Minimal processing needed
-- **Clear**: User controls complexity level
+### Simple Process
+1. Validate session and inputs
+2. Generate task JSON
+3. Update session stats
+4. Notify completion
 
 ## Context Inheritance
 
-Tasks automatically inherit:
-1. **Requirements** - From workflow-session.json and IMPL_PLAN.md
-2. **Scope** - File patterns from workflow context  
-3. **Parent Context** - When created as subtasks, inherit from parent
-4. **Session Context** - Global workflow context from active session
+Tasks inherit from:
+1. **Active Session** - Requirements and scope from workflow-session.json
+2. **Planning Document** - Context from IMPL_PLAN.md
+3. **Parent Task** - For subtasks (IMPL-N.M format)
 
-## Smart Suggestions
+## Agent Assignment
 
-Based on title analysis:
-```bash
-/task:create "Write unit tests for auth module"
-
-Suggestions:
-- Related task: impl-1 (Build authentication module)
-- Suggested agent: test-agent
-- Estimated effort: 2h
-- Dependencies: [impl-1]
-- Suggested hierarchy: impl-1.3 (as subtask of impl-1)
-```
+Based on task type and title keywords:
+- **Build/Implement** → @code-developer
+- **Design/Plan** → @planning-agent
+- **Test Generation** → @code-developer (type: "test-gen")
+- **Test Execution/Fix** → @test-fix-agent (type: "test-fix")
+- **Review/Audit** → @universal-executor (optional, only when explicitly requested)
 
 ## Validation Rules
 
-1. **Phase Check** - Must be in IMPLEMENT phase (from workflow-session.json)
-2. **Duplicate Check** - Title similarity detection across existing JSON files
-3. **Session Validation** - Active workflow session must exist in `.workflow/`
-4. **ID Uniqueness** - Auto-increment to avoid conflicts in `.task/` directory
-5. **Hierarchy Validation** - Parent-child relationships must be valid (max 3 levels)
-6. **File System Validation** - Proper directory structure and naming conventions
-7. **JSON Schema Validation** - All task files conform to unified schema
+1. **Session Check** - Active workflow session required
+2. **Duplicate Check** - Avoid similar task titles
+3. **ID Uniqueness** - Auto-increment task IDs
+4. **Schema Validation** - Ensure proper JSON structure
 
 ## Error Handling
 
 ```bash
-# Not in IMPLEMENT phase
-❌ Cannot create tasks in PLAN phase
-→ Use: /workflow implement
-
 # No workflow session
-❌ No active workflow found
-→ Use: /workflow init "project name"
+No active workflow found
+Use: /workflow init "project name"
 
 # Duplicate task
-⚠️ Similar task exists: impl-3
-→ Continue anyway? (y/n)
+Similar task exists: IMPL-3
+Continue anyway? (y/n)
 
-# Maximum depth exceeded
-❌ Cannot create impl-1.2.3.1 (exceeds 3-level limit)
-→ Suggest: impl-1.2.4 or promote to impl-2?
+# Max depth exceeded
+Cannot create IMPL-1.2.1 (max 2 levels)
+Use: IMPL-2 for new main task
 ```
 
-## Batch Creation
-
-Create multiple tasks at once:
-```bash
-/task:create --batch
-> Enter tasks (empty line to finish):
-> Build login endpoint
-> Add session management
-> Write authentication tests
->
-
-Created 3 tasks:
-- impl-1: Build login endpoint
-- impl-2: Add session management  
-- impl-3: Write authentication tests
-```
-
-## File Output
-
-### JSON Task File
-**Location**: `.task/impl-[id].json`
-**Schema**: Simplified task JSON schema  
-**Contents**: Complete task definition with context
-
-### Session Updates
-**File**: `workflow-session.json`
-**Updates**: Basic task count and active task list only
-
-## Integration
-
-### Simple Integration
-- Updates workflow-session.json stats
-- Creates JSON task file
-- No complex file coordination needed
-
-### Next Steps
-After creation, use:
-- `/task:breakdown` - Split into subtasks  
-- `/task:execute` - Run the task
-- `/context` - View task details and status
-
 ## Examples
 
-### Feature Development
+### Feature Task
 ```bash
-/task:create "Implement shopping cart functionality" --type=feature
+/task:create "Implement user authentication"
+
+Created IMPL-1: Implement user authentication
+Type: feature
+Agent: code-developer
+Status: pending
 ```
 
 ### Bug Fix
 ```bash
-/task:create "Fix memory leak in data processor" --type=bugfix --priority=high
-```
+/task:create "Fix login validation bug" --type=bugfix
 
-### Refactoring
-```bash
-/task:create "Refactor database connection pool" --type=refactor
-```
-
-## Related Commands
-
-- `/task:breakdown` - Break task into hierarchical subtasks
-- `/task:context` - View/modify task context
-- `/task:execute` - Execute task with agent
-- `/task:status` - View task status and hierarchy
+Created IMPL-2: Fix login validation bug
+Type: bugfix
+Agent: code-developer
+Status: pending
+```

.claude/commands/task/execute.md

@@ -1,20 +1,15 @@
 ---
 name: execute
-description: Execute tasks with appropriate agents and context-aware orchestration
-usage: /task:execute <task-id>
-argument-hint: task-id
-examples:
-  - /task:execute impl-1
-  - /task:execute impl-1.2
-  - /task:execute impl-3
+description: Execute task JSON using appropriate agent (@doc-generator/@implementation-agent/@test-agent) with pre-analysis context loading and status tracking
+argument-hint: "task-id"
 ---
 
-### 🚀 **Command Overview: `/task:execute`**
+## Command Overview: /task:execute
 
--   **Purpose**: Executes tasks using intelligent agent selection, context preparation, and progress tracking.
--   **Core Principles**: @~/.claude/workflows/workflow-architecture.md
+**Purpose**: Executes tasks using intelligent agent selection, context preparation, and progress tracking.
 
-### ⚙️ **Execution Modes**
+
+## Execution Modes
 
 -   **auto (Default)**
     -   Fully autonomous execution with automatic agent selection.
@@ -24,10 +19,10 @@ examples:
     -   Executes step-by-step, requiring user confirmation at each checkpoint.
     -   Allows for dynamic adjustments and manual review during the process.
 -   **review**
-    -   Executes under the supervision of a `review-agent`.
-    -   Performs quality checks and provides detailed feedback at each step.
+    -   Optional manual review using `@universal-executor`.
+    -   Used only when explicitly requested by user.
 
-### 🤖 **Agent Selection Logic**
+## Agent Selection Logic
 
 The system determines the appropriate agent for a task using the following logic.
 
@@ -42,32 +37,35 @@ FUNCTION select_agent(task, agent_override):
     ELSE:
         CASE task.title:
             WHEN CONTAINS "Build API", "Implement":
-                RETURN "code-developer"
+                RETURN "@code-developer"
             WHEN CONTAINS "Design schema", "Plan":
-                RETURN "planning-agent"
-            WHEN CONTAINS "Write tests":
-                RETURN "test-agent"
+                RETURN "@planning-agent"
+            WHEN CONTAINS "Write tests", "Generate tests":
+                RETURN "@code-developer" // type: test-gen
+            WHEN CONTAINS "Execute tests", "Fix tests", "Validate":
+                RETURN "@test-fix-agent" // type: test-fix
             WHEN CONTAINS "Review code":
-                RETURN "review-agent"
+                RETURN "@universal-executor" // Optional manual review
             DEFAULT:
-                RETURN "code-developer" // Default agent
+                RETURN "@code-developer" // Default agent
         END CASE
 END FUNCTION
 ```
 
-### 🔄 **Core Execution Protocol**
+## Core Execution Protocol
 
-`Pre-Execution` **->** `Execution` **->** `Post-Execution`
+`Pre-Execution` -> `Execution` -> `Post-Execution`
 
-### ✅ **Pre-Execution Protocol**
+### Pre-Execution Protocol
 
 `Validate Task & Dependencies` **->** `Prepare Execution Context` **->** `Coordinate with TodoWrite`
 
 -   **Validation**: Checks for the task's JSON file in `.task/` and resolves its dependencies.
 -   **Context Preparation**: Loads task and workflow context, preparing it for the selected agent.
+-   **Session Context Injection**: Provides workflow directory paths to agents for TODO_LIST.md and summary management.
 -   **TodoWrite Coordination**: Generates execution Todos and checkpoints, syncing with `TODO_LIST.md`.
 
-### 🏁 **Post-Execution Protocol**
+### Post-Execution Protocol
 
 `Update Task Status` **->** `Generate Summary` **->** `Save Artifacts` **->** `Sync All Progress` **->** `Validate File Integrity`
 
@@ -75,7 +73,7 @@ END FUNCTION
 -   Creates a summary in `.summaries/`.
 -   Stores outputs and syncs progress across the entire workflow session.
 
-### 🧠 **Task & Subtask Execution Logic**
+### Task & Subtask Execution Logic
 
 This logic defines how single, multiple, or parent tasks are handled.
 
@@ -101,7 +99,7 @@ FUNCTION execute_task_command(task_id, mode, parallel_flag):
 END FUNCTION
 ```
 
-### 🛡️ **Error Handling & Recovery Logic**
+### Error Handling & Recovery Logic
 
 ```pseudo
 FUNCTION pre_execution_check(task):
@@ -125,21 +123,15 @@ FUNCTION on_execution_failure(checkpoint):
 END FUNCTION
 ```
 
-### ✨ **Advanced Execution Controls**
 
--   **Dry Run (`--dry-run`)**: Simulates execution, showing the agent, estimated time, and files affected without making changes.
--   **Custom Checkpoints (`--checkpoints="..."`)**: Overrides the default checkpoints with a custom, comma-separated list (e.g., `"design,implement,deploy"`).
--   **Conditional Execution (`--if="..."`)**: Proceeds with execution only if a specified condition (e.g., `"tests-pass"`) is met.
--   **Rollback (`--rollback`)**: Reverts file modifications and restores the previous task state.
-
-### 📄 **Simplified Context Structure (JSON)**
+### Simplified Context Structure (JSON)
 
 This is the simplified data structure loaded to provide context for task execution.
 
 ```json
 {
   "task": {
-    "id": "impl-1",
+    "id": "IMPL-1",
     "title": "Build authentication module",
     "type": "feature",
     "status": "active",
@@ -152,13 +144,66 @@ This is the simplified data structure loaded to provide context for task executi
     },
     "relations": {
       "parent": null,
-      "subtasks": ["impl-1.1", "impl-1.2"],
-      "dependencies": ["impl-0"]
+      "subtasks": ["IMPL-1.1", "IMPL-1.2"],
+      "dependencies": ["IMPL-0"]
+    },
+    "implementation": {
+      "files": [
+        {
+          "path": "src/auth/login.ts",
+          "location": {
+            "function": "authenticateUser",
+            "lines": "25-65",
+            "description": "Main authentication logic"
+          },
+          "original_code": "// Code snippet extracted via gemini analysis",
+          "modifications": {
+            "current_state": "Basic password authentication only",
+            "proposed_changes": [
+              "Add JWT token generation",
+              "Implement OAuth2 callback handling",
+              "Add multi-factor authentication support"
+            ],
+            "logic_flow": [
+              "validateCredentials() ───► checkUserExists()",
+              "◊─── if password ───► generateJWT() ───► return token",
+              "◊─── if OAuth ───► validateOAuthCode() ───► exchangeForToken()",
+              "◊─── if MFA ───► sendMFACode() ───► awaitVerification()"
+            ],
+            "reason": "Support modern authentication standards and security requirements",
+            "expected_outcome": "Comprehensive authentication system supporting multiple methods"
+          }
+        }
+      ],
+      "context_notes": {
+        "dependencies": ["jsonwebtoken", "passport", "speakeasy"],
+        "affected_modules": ["user-session", "auth-middleware", "api-routes"],
+        "risks": [
+          "Breaking changes to existing login endpoints",
+          "Token storage and rotation complexity",
+          "OAuth provider configuration dependencies"
+        ],
+        "performance_considerations": "JWT validation adds ~10ms per request, OAuth callbacks may timeout",
+        "error_handling": "Ensure sensitive authentication errors don't leak user enumeration data"
+      },
+      "pre_analysis": [
+        {
+          "action": "analyze patterns",
+          "template": "~/.claude/workflows/cli-templates/prompts/analysis/02-analyze-code-patterns.txt",
+          "method": "gemini"
+        }
+      ]
     }
   },
   "workflow": {
     "session": "WFS-user-auth",
-    "phase": "IMPLEMENT"
+    "phase": "IMPLEMENT",
+    "session_context": {
+      "workflow_directory": ".workflow/active/WFS-user-auth/",
+      "todo_list_location": ".workflow/active/WFS-user-auth/TODO_LIST.md",
+      "summaries_directory": ".workflow/active/WFS-user-auth/.summaries/",
+      "task_json_location": ".workflow/active/WFS-user-auth/.task/"
+    }
   },
   "execution": {
     "agent": "code-developer",
@@ -168,26 +213,48 @@ This is the simplified data structure loaded to provide context for task executi
 }
 ```
 
-### 🎯 **Agent-Specific Context**
+### Agent-Specific Context
 
-Different agents receive context tailored to their function:
--   **`code-developer`**: Code patterns, dependencies, file scopes.
--   **`planning-agent`**: High-level requirements, constraints, success criteria.
--   **`test-agent`**: Test requirements, code to be tested, coverage goals.
--   **`review-agent`**: Quality standards, style guides, review criteria.
+Different agents receive context tailored to their function, including implementation details:
 
-### 🗃️ **Simplified File Output**
+**`@code-developer`**: 
+- Complete implementation.files array with file paths and locations
+- original_code snippets and proposed_changes for precise modifications
+- logic_flow diagrams for understanding data flow
+- Dependencies and affected modules for integration planning
+- Performance and error handling considerations
+
+**`@planning-agent`**: 
+- High-level requirements, constraints, success criteria
+- Implementation risks and mitigation strategies
+- Architecture implications from implementation.context_notes
+
+**`@test-fix-agent`**:
+- Test files to execute from task.context.focus_paths
+- Source files to fix from implementation.files[].path
+- Expected behaviors from implementation.modifications.logic_flow
+- Error conditions to validate from implementation.context_notes.error_handling
+- Performance requirements from implementation.context_notes.performance_considerations
+
+**`@universal-executor`**:
+- Used for optional manual reviews when explicitly requested
+- Code quality standards and implementation patterns
+- Security considerations from implementation.context_notes.risks
+- Dependency validation from implementation.context_notes.dependencies
+- Architecture compliance checks
+
+### Simplified File Output
 
 -   **Task JSON File (`.task/<task-id>.json`)**: Updated with status and last attempt time only.
 -   **Session File (`workflow-session.json`)**: Updated task stats (completed count).
 -   **Summary File**: Generated in `.summaries/` upon completion (optional).
 
-### 📝 **Simplified Summary Template**
+### Simplified Summary Template
 
-Optional summary file generated at `.summaries/impl-[task-id]-summary.md`.
+Optional summary file generated at `.summaries/IMPL-[task-id]-summary.md`.
 
 ```markdown
-# Task Summary: impl-1 Build Authentication Module
+# Task Summary: IMPL-1 Build Authentication Module
 
 ## What Was Done
 - Created src/auth/login.ts with JWT validation

.claude/commands/task/replan.md

@@ -1,515 +1,437 @@
 ---
 name: replan
-description: Replan individual tasks with detailed user input and change tracking
-usage: /task:replan <task-id> [input]
-argument-hint: task-id ["text"|file.md|ISS-001]
-examples:
-  - /task:replan impl-1 "Add OAuth2 authentication support"
-  - /task:replan impl-1 updated-specs.md
-  - /task:replan impl-1 ISS-001
+description: Update task JSON with new requirements or batch-update multiple tasks from verification report, tracks changes in task-changes.json
+argument-hint: "task-id [\"text\"|file.md] | --batch [verification-report.md]"
+allowed-tools: Read(*), Write(*), Edit(*), TodoWrite(*), Glob(*), Bash(*)
 ---
 
 # Task Replan Command (/task:replan)
 
+> **⚠️ DEPRECATION NOTICE**: This command is maintained for backward compatibility. For new workflows, use `/workflow:replan` which provides:
+> - Session-level replanning with comprehensive artifact updates
+> - Interactive boundary clarification
+> - Updates to IMPL_PLAN.md, TODO_LIST.md, and session metadata
+> - Better integration with workflow sessions
+>
+> **Migration**: Replace `/task:replan IMPL-1 "changes"` with `/workflow:replan IMPL-1 "changes"`
+
 ## Overview
-Replans individual tasks based on detailed user input with comprehensive change tracking, version management, and document synchronization. Focuses exclusively on single-task modifications with rich input options.
+Replans individual tasks or batch processes multiple tasks with change tracking and backup management.
 
-## Core Principles
-**Task Management:** @~/.claude/workflows/workflow-architecture.md
+**Modes**:
+- **Single Task Mode**: Replan one task with specific changes
+- **Batch Mode**: Process multiple tasks from action-plan verification report
 
-## Single-Task Focus
-This command operates on **individual tasks only**. For workflow-wide changes, use `/workflow:action-plan` instead.
+## Key Features
+- **Single/Batch Operations**: Single task or multiple tasks from verification report
+- **Multiple Input Sources**: Text, files, or verification report
+- **Backup Management**: Automatic backup of previous versions
+- **Change Documentation**: Track all modifications
+- **Progress Tracking**: TodoWrite integration for batch operations
 
-⚠️ **CRITICAL**: Before replanning, checks for existing active session to avoid conflicts.
+**CRITICAL**: Validates active session before replanning
 
-## Input Sources for Replanning
+## Operation Modes
 
-### Direct Text Input (Default)
+### Single Task Mode
+
+#### Direct Text (Default)
 ```bash
-/task:replan impl-1 "Add OAuth2 authentication support"
+/task:replan IMPL-1 "Add OAuth2 authentication support"
 ```
-**Processing**:
-- Parse specific changes and requirements
-- Extract new features or modifications needed
-- Apply directly to target task structure
 
-### File-based Requirements
+#### File-based Input
 ```bash
-/task:replan impl-1 --from-file updated-specs.md
-/task:replan impl-1 --from-file requirements-change.txt
+/task:replan IMPL-1 updated-specs.md
 ```
-**Supported formats**: .md, .txt, .json, .yaml
-**Processing**:
-- Read detailed requirement changes from file
-- Parse structured specifications and updates
-- Apply file content to task replanning
+Supports: .md, .txt, .json, .yaml
 
-### Issue-based Replanning
+#### Interactive Mode
 ```bash
-/task:replan impl-1 --from-issue ISS-001
-/task:replan impl-1 --from-issue "bug-report"
+/task:replan IMPL-1 --interactive
 ```
-**Processing**:
-- Load issue description and requirements
-- Extract necessary changes for task
-- Apply issue resolution to task structure
+Guided step-by-step modification process with validation
 
-### Detailed Mode
+### Batch Mode
+
+#### From Verification Report
 ```bash
-/task:replan impl-1 --detailed
-```
-**Guided Input**:
-1. **New Requirements**: What needs to be added/changed?
-2. **Scope Changes**: Expand/reduce task scope?
-3. **Subtask Modifications**: Add/remove/modify subtasks?
-4. **Dependencies**: Update task relationships?
-5. **Success Criteria**: Modify completion conditions?
-6. **Agent Assignment**: Change assigned agent?
-
-### Interactive Mode
-```bash
-/task:replan impl-1 --interactive
-```
-**Step-by-Step Process**:
-1. **Current Analysis**: Review existing task structure
-2. **Change Identification**: What needs modification?
-3. **Impact Assessment**: How changes affect task?
-4. **Structure Updates**: Add/modify subtasks
-5. **Validation**: Confirm changes before applying
-
-## Replanning Flow with Change Tracking
-
-### 1. Task Loading & Validation
-```
-Load Task → Read current task JSON file
-Validate → Check task exists and can be modified
-Session Check → Verify active workflow session
+/task:replan --batch ACTION_PLAN_VERIFICATION.md
 ```
 
-### 2. Input Processing
-```
-Detect Input Type → Identify source type
-Extract Requirements → Parse change requirements
-Analyze Impact → Determine modifications needed
-```
+**Workflow**:
+1. Parse verification report to extract replan recommendations
+2. Create TodoWrite task list for all modifications
+3. Process each task sequentially with confirmation
+4. Track progress and generate summary report
 
-### 3. Version Management
-```
-Create Version → Backup current task state
-Update Version → Increment task version number
-Archive → Store previous version in versions/
-```
+**Auto-detection**: If input file contains "Action Plan Verification Report" header, automatically enters batch mode
 
-### 4. Task Structure Updates
-```
-Modify Task → Update task JSON structure
-Update Subtasks → Add/remove/modify as needed
-Update Relations → Fix dependencies and hierarchy
-Update Context → Modify requirements and scope
-```
+## Replanning Process
 
-### 5. Document Synchronization
-```
-Update IMPL_PLAN → Regenerate task section
-Update TODO_LIST → Sync task hierarchy (if exists)
-Update Session → Reflect changes in workflow state
-```
+### Single Task Process
 
-### 6. Change Documentation
-```
-Create Change Log → Document all modifications
-Generate Summary → Create replan report
-Update History → Add to task replan history
-```
+1. **Load & Validate**: Read task JSON and validate session
+2. **Parse Input**: Process changes from input source
+3. **Create Backup**: Save previous version to backup folder
+4. **Update Task**: Modify JSON structure and relationships
+5. **Save Changes**: Write updated task and increment version
+6. **Update Session**: Reflect changes in workflow stats
 
-## Version Management (Simplified)
+### Batch Process
 
-### Version Tracking
-Each replan creates a new version with complete history:
+1. **Parse Verification Report**: Extract all replan recommendations
+2. **Initialize TodoWrite**: Create task list for tracking
+3. **For Each Task**:
+   - Mark todo as in_progress
+   - Load and validate task JSON
+   - Create backup
+   - Apply recommended changes
+   - Save updated task
+   - Mark todo as completed
+4. **Generate Summary**: Report all changes and backup locations
 
+## Backup Management
+
+### Backup Tracking
+Tasks maintain backup history:
 ```json
 {
-  "id": "impl-1",
-  "title": "Build authentication module",
+  "id": "IMPL-1",
   "version": "1.2",
   "replan_history": [
     {
-      "version": "1.1",
-      "date": "2025-09-08T10:00:00Z",
-      "reason": "Original plan",
-      "input_source": "initial_creation"
-    },
-    {
-      "version": "1.2", 
-      "date": "2025-09-08T14:00:00Z",
-      "reason": "Add OAuth2 authentication support",
+      "version": "1.2",
+      "reason": "Add OAuth2 support",
       "input_source": "direct_text",
-      "changes": [
-        "Added subtask impl-1.3: OAuth2 integration",
-        "Added subtask impl-1.4: Token management",
-        "Modified scope to include external auth"
-      ],
-      "backup_location": ".task/versions/impl-1-v1.1.json"
+      "backup_location": ".task/backup/IMPL-1-v1.1.json",
+      "timestamp": "2025-10-17T10:30:00Z"
     }
-  ],
-  "context": {
-    "requirements": ["Basic auth", "Session mgmt", "OAuth2 support"],
-    "scope": ["src/auth/*", "tests/auth/*"],
-    "acceptance": ["All auth methods work"]
-  }
+  ]
 }
 ```
 
-### File Structure After Replan
+**Complete schema**: See @~/.claude/workflows/task-core.md
+
+### File Structure
 ```
 .task/
-├── impl-1.json                    # Current version (1.2)
-├── impl-1.3.json                  # New subtask
-├── impl-1.4.json                  # New subtask  
-├── versions/
-│   └── impl-1-v1.1.json          # Previous version backup
-└── summaries/
-    └── replan-impl-1-20250908.md  # Change log
+├── IMPL-1.json                    # Current version
+├── backup/
+│   ├── IMPL-1-v1.0.json          # Original version
+│   ├── IMPL-1-v1.1.json          # Previous backup
+│   └── IMPL-1-v1.2.json          # Latest backup
+└── [new subtasks as needed]
 ```
 
-## IMPL_PLAN.md Updates
+**Backup Naming**: `{task-id}-v{version}.json`
 
-### Automatic Plan Regeneration
-When task is replanned, the corresponding section in IMPL_PLAN.md is updated:
+## Implementation Updates
 
-**Before Replan**:
-```markdown
-## Task Breakdown
-- **IMPL-001**: Build authentication module
-  - Basic login functionality
-  - Session management
-  - Password reset
-```
+### Change Detection
+Tracks modifications to:
+- Files in implementation.files array
+- Dependencies and affected modules
+- Risk assessments and performance notes
+- Logic flows and code locations
 
-**After Replan**:
-```markdown
-## Task Breakdown
-- **IMPL-001**: Build authentication module (v1.2)
-  - Basic login functionality
-  - Session management  
-  - OAuth2 integration (added)
-  - Token management (added)
-  - Password reset
+### Analysis Triggers
+May require gemini re-analysis when:
+- New files need code extraction
+- Function locations change
+- Dependencies require re-evaluation
 
-*Last updated: 2025-09-08 14:00 via task:replan*
-```
+## Document Updates
 
-### Plan Update Process
-1. **Locate Task Section**: Find task in IMPL_PLAN.md by ID
-2. **Update Description**: Modify task title if changed
-3. **Update Subtasks**: Add/remove bullet points for subtasks
-4. **Add Version Info**: Include version number and update timestamp
-5. **Preserve Context**: Keep surrounding plan structure intact
+### Planning Document
+May update IMPL_PLAN.md sections when task structure changes significantly
 
-## TODO_LIST.md Synchronization
-
-### Automatic TODO List Updates
-If TODO_LIST.md exists in workflow, synchronize task changes:
-
-**Before Replan**:
-```markdown
-## Implementation Tasks
-- [ ] impl-1: Build authentication module
-  - [x] impl-1.1: Design schema
-  - [ ] impl-1.2: Implement logic
-```
-
-**After Replan**:
-```markdown
-## Implementation Tasks
-- [ ] impl-1: Build authentication module (updated v1.2)
-  - [x] impl-1.1: Design schema
-  - [ ] impl-1.2: Implement logic  
-  - [ ] impl-1.3: OAuth2 integration (new)
-  - [ ] impl-1.4: Token management (new)
-```
-
-### TODO Update Rules
-- **Preserve Status**: Keep existing checkbox states [x] or [ ]
-- **Add New Items**: New subtasks get [ ] checkbox
-- **Mark Changes**: Add (updated), (new), (modified) indicators
-- **Remove Items**: Delete subtasks that were removed
-- **Update Hierarchy**: Maintain proper indentation structure
+### TODO List Sync
+If TODO_LIST.md exists, synchronizes:
+- New subtasks (with [ ] checkbox)
+- Modified tasks (marked as updated)
+- Removed subtasks (deleted from list)
 
 ## Change Documentation
 
-### Comprehensive Change Log
-Every replan generates detailed documentation:
+### Change Summary
+Generates brief change log with:
+- Version increment (1.1 → 1.2)
+- Input source and reason
+- Key modifications made
+- Files updated/created
+- Backup location
+
+## Session Updates
+
+Updates workflow-session.json with:
+- Modified task tracking
+- Task count changes (if subtasks added/removed)
+- Last modification timestamps
+
+## Rollback Support
+
+```bash
+/task:replan IMPL-1 --rollback v1.1
+
+Rollback to version 1.1:
+- Restore task from backup/.../IMPL-1-v1.1.json
+- Remove new subtasks if any
+- Update session stats
+
+# Use AskUserQuestion for confirmation
+AskUserQuestion({
+  questions: [{
+    question: "Are you sure you want to roll back this task to a previous version?",
+    header: "Confirm",
+    options: [
+      { label: "Yes, rollback", description: "Restore the task from the selected backup." },
+      { label: "No, cancel", description: "Keep the current version of the task." }
+    ],
+    multiSelect: false
+  }]
+})
+
+User selected: "Yes, rollback"
+
+Task rolled back to version 1.1
+```
+
+## Batch Processing with TodoWrite
+
+### Progress Tracking
+When processing multiple tasks, automatically creates TodoWrite task list:
 
 ```markdown
-# Task Replan Log: impl-1
-*Date: 2025-09-08T14:00:00Z*
-*Version: 1.1 → 1.2*
-*Input: Direct text - "Add OAuth2 authentication support"*
-
-## Changes Applied
-
-### Task Structure Updates
-- **Added Subtasks**:
-  - impl-1.3: OAuth2 provider integration
-  - impl-1.4: Token management system
-- **Modified Subtasks**:
-  - impl-1.2: Updated to include OAuth flow integration
-- **Removed Subtasks**: None
-
-### Context Modifications
-- **Requirements**: Added OAuth2 external authentication
-- **Scope**: Expanded to include third-party auth integration
-- **Acceptance**: Include OAuth2 token validation
-- **Dependencies**: No changes
-
-### File System Updates
-- **Updated**: .task/impl-1.json (version 1.2)
-- **Created**: .task/impl-1.3.json, .task/impl-1.4.json
-- **Backed Up**: .task/versions/impl-1-v1.1.json
-- **Updated**: IMPL_PLAN.md (task section regenerated)
-- **Updated**: TODO_LIST.md (2 new items added)
-
-## Impact Analysis
-- **Timeline**: +2 days for OAuth implementation
-- **Complexity**: Increased (simple → medium)
-- **Agent**: Remains code-developer, may need OAuth expertise
-- **Dependencies**: Task impl-2 may need OAuth context
-
-## Related Tasks Affected
-- impl-2: May need OAuth integration context
-- impl-5: Authentication dependency updated
-
-## Rollback Information
-- **Previous Version**: 1.1
-- **Backup Location**: .task/versions/impl-1-v1.1.json
-- **Rollback Command**: `/task:replan impl-1 --rollback v1.1`
+**Batch Replan Progress**:
+- [x] IMPL-002: Add FR-12 draft saving acceptance criteria
+- [x] IMPL-003: Add FR-14 history tracking acceptance criteria
+- [ ] IMPL-004: Add FR-09 response surface explicit coverage
+- [ ] IMPL-008: Add NFR performance validation steps
 ```
 
-## Session State Updates
+### Batch Report
+After completion, generates summary:
+```markdown
+## Batch Replan Summary
 
-### Workflow Integration
-After task replanning, update session information:
+**Total Tasks**: 4
+**Successful**: 3
+**Failed**: 1
+**Skipped**: 0
 
-```json
-{
-  "phases": {
-    "IMPLEMENT": {
-      "tasks": ["impl-1", "impl-2", "impl-3"],
-      "completed_tasks": [],
-      "modified_tasks": {
-        "impl-1": {
-          "version": "1.2", 
-          "last_replan": "2025-09-08T14:00:00Z",
-          "reason": "OAuth2 integration added"
-        }
-      },
-      "task_count": {
-        "total": 6,
-        "added_today": 2
-      }
-    }
-  },
-  "documents": {
-    "IMPL_PLAN.md": {
-      "last_updated": "2025-09-08T14:00:00Z",
-      "updated_sections": ["IMPL-001"]
-    },
-    "TODO_LIST.md": {
-      "last_updated": "2025-09-08T14:00:00Z", 
-      "items_added": 2
-    }
-  }
-}
+### Changes Made
+- IMPL-002 v1.0 → v1.1: Added FR-12 acceptance criteria
+- IMPL-003 v1.0 → v1.1: Added FR-14 acceptance criteria
+- IMPL-004 v1.0 → v1.1: Added FR-09 explicit coverage
+
+### Backups Created
+- .task/backup/IMPL-002-v1.0.json
+- .task/backup/IMPL-003-v1.0.json
+- .task/backup/IMPL-004-v1.0.json
+
+### Errors
+- IMPL-008: File not found (task may have been renamed)
 ```
 
-## Rollback Support (Simple)
+## Examples
 
-### Basic Version Rollback
+### Single Task - Text Input
 ```bash
-/task:replan impl-1 --rollback v1.1
+/task:replan IMPL-1 "Add OAuth2 authentication support"
 
-Rollback Analysis:
-Current Version: 1.2
-Target Version: 1.1
-Changes to Revert:
-- Remove subtasks: impl-1.3, impl-1.4
-- Restore previous context
-- Update IMPL_PLAN.md section
-- Update TODO_LIST.md structure
+Processing changes...
+Proposed updates:
++ Add OAuth2 integration
++ Update authentication flow
 
-Files Affected:
-- Restore: .task/impl-1.json from backup
-- Remove: .task/impl-1.3.json, .task/impl-1.4.json
-- Update: IMPL_PLAN.md, TODO_LIST.md
+# Use AskUserQuestion for confirmation
+AskUserQuestion({
+  questions: [{
+    question: "Do you want to apply these changes to the task?",
+    header: "Apply",
+    options: [
+      { label: "Yes, apply", description: "Create new version with these changes." },
+      { label: "No, cancel", description: "Discard changes and keep current version." }
+    ],
+    multiSelect: false
+  }]
+})
 
-Confirm rollback? (y/n): y
+User selected: "Yes, apply"
 
-Rolling back...
-✅ Task impl-1 rolled back to version 1.1
-✅ Documents updated
-✅ Change log created
+Version 1.2 created
+Context updated
+Backup saved to .task/backup/IMPL-1-v1.1.json
 ```
 
-## Practical Examples
-
-### Example 1: Add Feature with Full Tracking
+### Single Task - File Input
 ```bash
-/task:replan impl-1 "Add two-factor authentication"
+/task:replan IMPL-2 requirements.md
 
-Loading task impl-1 (current version: 1.2)...
+Loading requirements.md...
+Applying specification changes...
 
-Processing request: "Add two-factor authentication"
-Analyzing required changes...
-
-Proposed Changes:
-+ Add impl-1.5: Two-factor setup
-+ Add impl-1.6: 2FA validation
-~ Modify impl-1.2: Include 2FA in auth flow
-
-Apply changes? (y/n): y
-
-Executing replan...
-✓ Version 1.3 created
-✓ Added 2 new subtasks
-✓ Modified 1 existing subtask
-✓ IMPL_PLAN.md updated
-✓ TODO_LIST.md synchronized
-✓ Change log saved
-
-Result:
-- Task version: 1.2 → 1.3
-- Subtasks: 4 → 6
-- Documents updated: 2
-- Backup: .task/versions/impl-1-v1.2.json
+Task updated with new requirements
+Version 1.1 created
+Backup saved to .task/backup/IMPL-2-v1.0.json
 ```
 
-### Example 2: Issue-based Replanning
+### Batch Mode - From Verification Report
 ```bash
-/task:replan impl-2 --from-issue ISS-001
+/task:replan --batch .workflow/active/WFS-{session}/.process/ACTION_PLAN_VERIFICATION.md
 
-Loading issue ISS-001...
-Issue: "Database queries too slow - need caching"
-Priority: High
+Parsing verification report...
+Found 4 tasks requiring replanning:
+- IMPL-002: Add FR-12 draft saving acceptance criteria
+- IMPL-003: Add FR-14 history tracking acceptance criteria
+- IMPL-004: Add FR-09 response surface explicit coverage
+- IMPL-008: Add NFR performance validation steps
 
-Applying to task impl-2...
+Creating task tracking list...
 
-Required changes for performance fix:
-+ Add impl-2.4: Implement Redis caching
-+ Add impl-2.5: Query optimization
-~ Modify impl-2.1: Add cache checks
+Processing IMPL-002...
+Backup created: .task/backup/IMPL-002-v1.0.json
+Updated to v1.1
 
-Documents updating:
-✓ Task JSON updated (v1.0 → v1.1)  
-✓ IMPL_PLAN.md section regenerated
-✓ TODO_LIST.md: 2 new items added
-✓ Issue ISS-001 linked to task
+Processing IMPL-003...
+Backup created: .task/backup/IMPL-003-v1.0.json
+Updated to v1.1
 
-Summary:
-Performance improvements added to impl-2
-Timeline impact: +1 day for caching setup
+Processing IMPL-004...
+Backup created: .task/backup/IMPL-004-v1.0.json
+Updated to v1.1
+
+Processing IMPL-008...
+Backup created: .task/backup/IMPL-008-v1.0.json
+Updated to v1.1
+
+Batch replan completed: 4/4 successful
+Summary report saved
 ```
 
-### Example 3: Interactive Replanning
+### Batch Mode - Auto-detection
 ```bash
-/task:replan impl-3 --interactive
+# If file contains "Action Plan Verification Report", auto-enters batch mode
+/task:replan ACTION_PLAN_VERIFICATION.md
 
-Interactive Replan for impl-3: API integration
-Current version: 1.0
-
-1. What needs to change? "API spec updated, need webhook support"
-2. Add new requirements? "Webhook handling, signature validation"  
-3. Add subtasks? "y"
-   - New subtask 1: "Webhook receiver endpoint"
-   - New subtask 2: "Signature validation"
-   - Add more? "n"
-4. Modify existing subtasks? "n"
-5. Update dependencies? "Now depends on impl-1 (auth for webhooks)"
-6. Change agent assignment? "n"
-
-Applying interactive changes...
-✓ Added 2 subtasks for webhook functionality
-✓ Updated dependencies  
-✓ Context expanded for webhook requirements
-✓ Version 1.1 created
-✓ All documents synchronized
-
-Interactive replan complete!
+Detected verification report format
+Entering batch mode...
+[same as above]
 ```
 
 ## Error Handling
 
-### Input Validation Errors
+### Single Task Errors
 ```bash
 # Task not found
-❌ Task impl-5 not found in current session
-→ Check task ID with /context
-
-# No input provided
-❌ Please specify changes needed for replanning
-→ Use descriptive text or --detailed/--interactive
+Task IMPL-5 not found
+Check task ID with /workflow:status
 
 # Task completed
-⚠️ Task impl-1 is completed (cannot replan)
-→ Create new task for additional work
+Task IMPL-1 is completed (cannot replan)
+Create new task for additional work
 
 # File not found
-❌ File updated-specs.md not found
-→ Check file path and try again
+File requirements.md not found
+Check file path
+
+# No input provided
+Please specify changes needed
+Provide text, file, or verification report
 ```
 
-### Document Update Issues
+### Batch Mode Errors
 ```bash
-# Missing IMPL_PLAN.md
-⚠️ IMPL_PLAN.md not found in workflow
-→ Task update proceeding, plan regeneration skipped
+# Invalid verification report
+File does not contain valid verification report format
+Check report structure or use single task mode
 
-# TODO_LIST.md not writable
-⚠️ Cannot update TODO_LIST.md (permissions)
-→ Task updated, manual TODO sync needed
+# Partial failures
+Batch completed with errors: 3/4 successful
+Review error details in summary report
 
-# Session conflict
-⚠️ Task impl-1 being modified in another session
-→ Complete other operation first
+# No replan recommendations found
+Verification report contains no replan recommendations
+Check report content or use /workflow:action-plan-verify first
 ```
 
-## Integration Points
+## Batch Mode Integration
 
-### Command Workflow
-```bash
-# 1. Replan task with new requirements
-/task:replan impl-1 "Add advanced security features"
+### Input Format Expectations
+Batch mode parses verification reports looking for:
 
-# 2. View updated task structure  
-/context impl-1
-→ Shows new version with changes
+1. **Required Actions Section**: Commands like `/task:replan IMPL-X "changes"`
+2. **Findings Table**: Task IDs with recommendations
+3. **Next Actions Section**: Specific replan commands
 
-# 3. Check updated planning documents
-cat IMPL_PLAN.md
-→ Task section shows v1.3 with new features
+**Example Patterns**:
+```markdown
+#### 1. HIGH Priority - Address FR Coverage Gaps
+/task:replan IMPL-004 "
+Add explicit acceptance criteria:
+- FR-09: Response surface 3D visualization
+"
 
-# 4. Verify TODO list synchronization
-cat TODO_LIST.md
-→ New subtasks appear with [ ] checkboxes
-
-# 5. Execute replanned task
-/task:execute impl-1
-→ Works with updated task structure
+#### 2. MEDIUM Priority - Enhance NFR Coverage
+/task:replan IMPL-008 "
+Add performance testing:
+- NFR-01: Load test API endpoints
+"
 ```
 
-### Session Integration
-- **Task Count Updates**: Reflect additions/removals in session stats
-- **Document Sync**: Keep IMPL_PLAN.md and TODO_LIST.md current
-- **Version Tracking**: Complete audit trail in task JSON
-- **Change Traceability**: Link replans to input sources
+### Extraction Logic
+1. Scan for `/task:replan` commands in report
+2. Extract task ID and change description
+3. Group by priority (HIGH, MEDIUM, LOW)
+4. Process in priority order with TodoWrite tracking
 
-## Related Commands
+### Confirmation Behavior
+- **Default**: Confirm each task before applying
+- **With `--auto-confirm`**: Apply all changes without prompting
+  ```bash
+  /task:replan --batch report.md --auto-confirm
+  ```
 
-- `/context` - View task structure and version history
-- `/task:execute` - Execute replanned tasks with new structure  
-- `/workflow:action-plan` - For workflow-wide replanning
-- `/task:create` - Create new tasks for additional work
+## Implementation Details
 
----
+### Backup Management
+```typescript
+// Backup file naming convention
+const backupPath = `.task/backup/${taskId}-v${previousVersion}.json`;
 
-**System ensures**: Focused single-task replanning with comprehensive change tracking, document synchronization, and complete audit trail
+// Backup metadata in task JSON
+{
+  "replan_history": [
+    {
+      "version": "1.2",
+      "timestamp": "2025-10-17T10:30:00Z",
+      "reason": "Add FR-09 explicit coverage",
+      "input_source": "batch_verification_report",
+      "backup_location": ".task/backup/IMPL-004-v1.1.json"
+    }
+  ]
+}
+```
+
+### TodoWrite Integration
+```typescript
+// Initialize tracking for batch mode
+TodoWrite({
+  todos: taskList.map(task => ({
+    content: `${task.id}: ${task.changeDescription}`,
+    status: "pending",
+    activeForm: `Replanning ${task.id}`
+  }))
+});
+
+// Update progress during processing
+TodoWrite({
+  todos: updateTaskStatus(taskId, "in_progress")
+});
+
+// Mark completed
+TodoWrite({
+  todos: updateTaskStatus(taskId, "completed")
+});
+```

.claude/commands/update-memory-full.md

@@ -1,117 +0,0 @@
----
-name: update-memory-full
-description: Complete project-wide CLAUDE.md documentation update
-usage: /update-memory-full
-examples:
-  - /update-memory-full                      # Full project documentation update
----
-
-### 🚀 Command Overview: `/update-memory-full`
-
-Complete project-wide documentation update using depth-parallel execution.
-
-### 📝 Execution Template
-
-```bash
-#!/bin/bash
-# Complete project-wide CLAUDE.md documentation update
-
-# Step 1: Cache git changes
-Bash(git add -A 2>/dev/null || true)
-
-# Step 2: Get and display project structure
-modules=$(Bash(~/.claude/scripts/get_modules_by_depth.sh list))
-count=$(echo "$modules" | wc -l)
-
-# Step 3: Analysis handover → Model takes control
-# BASH_EXECUTION_STOPS → MODEL_ANALYSIS_BEGINS
-
-# Pseudocode flow:
-# IF (module_count > 20 OR complex_project_detected):
-#     → Task "Complex project full update" subagent_type: "memory-gemini-bridge"
-# ELSE:
-#     → Present plan and WAIT FOR USER APPROVAL before execution
-```
-
-### 🧠 Model Analysis Phase
-
-After the bash script completes the initial analysis, the model takes control to:
-
-1. **Analyze Complexity**: Review module count and project context
-2. **Parse CLAUDE.md Status**: Extract which modules have/need CLAUDE.md files
-3. **Choose Strategy**: 
-   - Simple projects: Present execution plan with CLAUDE.md paths to user
-   - Complex projects: Delegate to memory-gemini-bridge agent
-4. **Present Detailed Plan**: Show user exactly which CLAUDE.md files will be created/updated
-5. **⚠️ CRITICAL: WAIT FOR USER APPROVAL**: No execution without explicit user consent
-
-### 📋 Execution Strategies
-
-**For Simple Projects (≤20 modules):**
-
-Model will present detailed plan:
-```
-📋 Update Plan:
-  NEW CLAUDE.md files (X):
-    - ./src/components/CLAUDE.md
-    - ./src/services/CLAUDE.md
-  
-  UPDATE existing CLAUDE.md files (Y):
-    - ./CLAUDE.md
-    - ./src/CLAUDE.md
-    - ./tests/CLAUDE.md
-
-  Total: N CLAUDE.md files will be processed
-  
-  ⚠️ Confirm execution? (y/n)
-```
-
-```pseudo
-# ⚠️ MANDATORY: User confirmation → MUST await explicit approval  
-IF user_explicitly_confirms():
-    continue_execution()
-ELSE:
-    abort_execution()
-
-# Step 4: Organize modules by depth → Prepare execution
-depth_modules = organize_by_depth(modules)
-
-# Step 5: Execute depth-parallel updates → Process by depth
-FOR depth FROM max_depth DOWN TO 0:
-    FOR each module IN depth_modules[depth]:
-        WHILE active_jobs >= 4: wait(0.1)
-        Bash(~/.claude/scripts/update_module_claude.sh "$module" "full" &)
-    wait_all_jobs()
-
-# Step 6: Display changes → Final status
-Bash(git status --short)
-```
-
-**For Complex Projects (>20 modules):**
-The model will delegate to the memory-gemini-bridge agent using the Task tool:
-```
-Task "Complex project full update"
-prompt: "Execute full documentation update for [count] modules using depth-parallel execution"
-subagent_type: "memory-gemini-bridge"
-```
-
-
-### 📚 Usage Examples
-
-```bash
-# Complete project documentation refresh
-/update-memory-full
-
-# After major architectural changes
-/update-memory-full
-```
-
-### ✨ Features
-
-- **Separated Commands**: Each bash operation is a discrete, trackable step
-- **Intelligent Complexity Detection**: Model analyzes project context for optimal strategy
-- **Depth-Parallel Execution**: Same depth modules run in parallel, depths run sequentially
-- **Git Integration**: Auto-cache changes before, show status after
-- **Module Detection**: Uses get_modules_by_depth.sh for structure discovery
-- **User Confirmation**: Clear plan presentation with approval step
-- **CLAUDE.md Only**: Only updates documentation, never source code

.claude/commands/update-memory-related.md

@@ -1,123 +0,0 @@
----
-name: update-memory-related
-description: Context-aware CLAUDE.md documentation updates based on recent changes
-usage: /update-memory-related
-examples:
-  - /update-memory-related                    # Update documentation based on recent changes
----
-
-### 🚀 Command Overview: `/update-memory-related`
-
-Context-aware documentation update for modules affected by recent changes.
-
-
-### 📝 Execution Template
-
-```bash
-#!/bin/bash
-# Context-aware CLAUDE.md documentation update
-
-# Step 1: Cache git changes
-Bash(git add -A 2>/dev/null || true)
-
-# Step 2: Detect changed modules  
-changed=$(Bash(~/.claude/scripts/detect_changed_modules.sh list))
-if [ -z "$changed" ]; then
-    changed=$(Bash(~/.claude/scripts/get_modules_by_depth.sh list | head -10))
-fi
-count=$(echo "$changed" | wc -l)
-
-# Step 3: Analysis handover → Model takes control  
-# BASH_EXECUTION_STOPS → MODEL_ANALYSIS_BEGINS
-
-# Pseudocode flow:
-# IF (change_count > 15 OR complex_changes_detected):
-#     → Task "Complex project related update" subagent_type: "memory-gemini-bridge"
-# ELSE:
-#     → Present plan and WAIT FOR USER APPROVAL before execution
-```
-
-### 🧠 Model Analysis Phase
-
-After the bash script completes change detection, the model takes control to:
-
-1. **Analyze Changes**: Review change count and complexity  
-2. **Parse CLAUDE.md Status**: Extract which changed modules have/need CLAUDE.md files
-3. **Choose Strategy**: 
-   - Simple changes: Present execution plan with CLAUDE.md paths to user
-   - Complex changes: Delegate to memory-gemini-bridge agent
-4. **Present Detailed Plan**: Show user exactly which CLAUDE.md files will be created/updated for changed modules
-5. **⚠️ CRITICAL: WAIT FOR USER APPROVAL**: No execution without explicit user consent
-
-### 📋 Execution Strategies
-
-**For Simple Changes (≤15 modules):**
-
-Model will present detailed plan for affected modules:
-```
-📋 Related Update Plan:
-  CHANGED modules affecting CLAUDE.md:
-  
-  NEW CLAUDE.md files (X):
-    - ./src/api/auth/CLAUDE.md  [new module]
-    - ./src/utils/helpers/CLAUDE.md  [new module]
-  
-  UPDATE existing CLAUDE.md files (Y):
-    - ./src/api/CLAUDE.md  [parent of changed auth/]
-    - ./src/CLAUDE.md  [root level]
-
-  Total: N CLAUDE.md files will be processed for recent changes
-  
-  ⚠️ Confirm execution? (y/n)
-```
-
-```pseudo
-# ⚠️ MANDATORY: User confirmation → MUST await explicit approval
-IF user_explicitly_confirms():
-    continue_execution()
-ELSE:
-    abort_execution()
-
-# Step 4: Organize modules by depth → Prepare execution
-depth_modules = organize_by_depth(changed_modules)
-
-# Step 5: Execute depth-parallel updates → Process by depth
-FOR depth FROM max_depth DOWN TO 0:
-    FOR each module IN depth_modules[depth]:
-        WHILE active_jobs >= 4: wait(0.1)
-        Bash(~/.claude/scripts/update_module_claude.sh "$module" "related" &)
-    wait_all_jobs()
-
-# Step 6: Display changes → Final status
-Bash(git diff --stat)
-```
-
-**For Complex Changes (>15 modules):**
-The model will delegate to the memory-gemini-bridge agent using the Task tool:
-```
-Task "Complex project related update"
-prompt: "Execute context-aware update for [count] changed modules using depth-parallel execution"
-subagent_type: "memory-gemini-bridge"
-```
-
-
-### 📚 Usage Examples
-
-```bash
-# Daily development update
-/update-memory-related
-
-# After feature work
-/update-memory-related
-```
-
-### ✨ Features
-
-- **Separated Commands**: Each bash operation is a discrete, trackable step
-- **Intelligent Change Analysis**: Model analyzes change complexity for optimal strategy
-- **Change Detection**: Automatically finds affected modules using git diff
-- **Depth-Parallel Execution**: Same depth modules run in parallel, depths run sequentially  
-- **Git Integration**: Auto-cache changes, show diff statistics after
-- **Fallback Mode**: Updates recent files when no git changes found
-- **User Confirmation**: Clear plan presentation with approval step
-- **CLAUDE.md Only**: Only updates documentation, never source code

.claude/commands/version.md

@@ -0,0 +1,254 @@
+---
+name: version
+description: Display Claude Code version information and check for updates
+allowed-tools: Bash(*)
+---
+
+# Version Command (/version)
+
+## Purpose
+Display local and global installation versions, check for the latest updates from GitHub, and provide upgrade recommendations.
+
+## Execution Flow
+1. **Local Version Check**: Read version information from `./.claude/version.json` if it exists.
+2. **Global Version Check**: Read version information from `~/.claude/version.json` if it exists.
+3. **Fetch Remote Versions**: Use GitHub API to get the latest stable release tag and the latest commit hash from the main branch.
+4. **Compare & Suggest**: Compare installed versions with the latest remote versions and provide upgrade suggestions if applicable.
+
+## Step 1: Check Local Version
+
+### Check if local version.json exists
+```bash
+bash(test -f ./.claude/version.json && echo "found" || echo "not_found")
+```
+
+### Read local version (if exists)
+```bash
+bash(cat ./.claude/version.json)
+```
+
+### Extract version with jq (preferred)
+```bash
+bash(cat ./.claude/version.json | grep -o '"version": *"[^"]*"' | cut -d'"' -f4)
+```
+
+### Extract installation date
+```bash
+bash(cat ./.claude/version.json | grep -o '"installation_date_utc": *"[^"]*"' | cut -d'"' -f4)
+```
+
+**Output Format**:
+```
+Local Version: 3.2.1
+Installed: 2025-10-03T12:00:00Z
+```
+
+## Step 2: Check Global Version
+
+### Check if global version.json exists
+```bash
+bash(test -f ~/.claude/version.json && echo "found" || echo "not_found")
+```
+
+### Read global version
+```bash
+bash(cat ~/.claude/version.json)
+```
+
+### Extract version
+```bash
+bash(cat ~/.claude/version.json | grep -o '"version": *"[^"]*"' | cut -d'"' -f4)
+```
+
+### Extract installation date
+```bash
+bash(cat ~/.claude/version.json | grep -o '"installation_date_utc": *"[^"]*"' | cut -d'"' -f4)
+```
+
+**Output Format**:
+```
+Global Version: 3.2.1
+Installed: 2025-10-03T12:00:00Z
+```
+
+## Step 3: Fetch Latest Stable Release
+
+### Call GitHub API for latest release (with timeout)
+```bash
+bash(curl -fsSL "https://api.github.com/repos/catlog22/Claude-Code-Workflow/releases/latest" 2>/dev/null, timeout: 30000)
+```
+
+### Extract tag name (version)
+```bash
+bash(curl -fsSL "https://api.github.com/repos/catlog22/Claude-Code-Workflow/releases/latest" 2>/dev/null | grep -o '"tag_name": *"[^"]*"' | head -1 | cut -d'"' -f4, timeout: 30000)
+```
+
+### Extract release name
+```bash
+bash(curl -fsSL "https://api.github.com/repos/catlog22/Claude-Code-Workflow/releases/latest" 2>/dev/null | grep -o '"name": *"[^"]*"' | head -1 | cut -d'"' -f4, timeout: 30000)
+```
+
+### Extract published date
+```bash
+bash(curl -fsSL "https://api.github.com/repos/catlog22/Claude-Code-Workflow/releases/latest" 2>/dev/null | grep -o '"published_at": *"[^"]*"' | cut -d'"' -f4, timeout: 30000)
+```
+
+**Output Format**:
+```
+Latest Stable: v3.2.2
+Release: v3.2.2: Independent Test-Gen Workflow with Cross-Session Context
+Published: 2025-10-03T04:10:08Z
+```
+
+## Step 4: Fetch Latest Main Branch
+
+### Call GitHub API for latest commit on main (with timeout)
+```bash
+bash(curl -fsSL "https://api.github.com/repos/catlog22/Claude-Code-Workflow/commits/main" 2>/dev/null, timeout: 30000)
+```
+
+### Extract commit SHA (short)
+```bash
+bash(curl -fsSL "https://api.github.com/repos/catlog22/Claude-Code-Workflow/commits/main" 2>/dev/null | grep -o '"sha": *"[^"]*"' | head -1 | cut -d'"' -f4 | cut -c1-7, timeout: 30000)
+```
+
+### Extract commit message (first line only)
+```bash
+bash(curl -fsSL "https://api.github.com/repos/catlog22/Claude-Code-Workflow/commits/main" 2>/dev/null | grep '"message":' | cut -d'"' -f4 | cut -d'\' -f1, timeout: 30000)
+```
+
+### Extract commit date
+```bash
+bash(curl -fsSL "https://api.github.com/repos/catlog22/Claude-Code-Workflow/commits/main" 2>/dev/null | grep -o '"date": *"[^"]*"' | head -1 | cut -d'"' -f4, timeout: 30000)
+```
+
+**Output Format**:
+```
+Latest Dev: a03415b
+Message: feat: Add version tracking and upgrade check system
+Date: 2025-10-03T04:46:44Z
+```
+
+## Step 5: Compare Versions and Suggest Upgrade
+
+### Normalize versions (remove 'v' prefix)
+```bash
+bash(echo "v3.2.1" | sed 's/^v//')
+```
+
+### Compare two versions
+```bash
+bash(printf "%s\n%s" "3.2.1" "3.2.2" | sort -V | tail -n 1)
+```
+
+### Check if versions are equal
+```bash
+# If equal: Up to date
+# If remote newer: Upgrade available
+# If local newer: Development version
+```
+
+**Output Scenarios**:
+
+**Scenario 1: Up to date**
+```
+You are on the latest stable version (3.2.1)
+```
+
+**Scenario 2: Upgrade available**
+```
+A newer stable version is available: v3.2.2
+Your version: 3.2.1
+
+To upgrade:
+PowerShell: iex (iwr -useb https://raw.githubusercontent.com/catlog22/Claude-Code-Workflow/main/install-remote.ps1)
+Bash: bash <(curl -fsSL https://raw.githubusercontent.com/catlog22/Claude-Code-Workflow/main/install-remote.sh)
+```
+
+**Scenario 3: Development version**
+```
+You are running a development version (3.4.0-dev)
+This is newer than the latest stable release (v3.3.0)
+```
+
+## Simple Bash Commands
+
+### Basic Operations
+```bash
+# Check local version file
+bash(test -f ./.claude/version.json && cat ./.claude/version.json)
+
+# Check global version file
+bash(test -f ~/.claude/version.json && cat ~/.claude/version.json)
+
+# Extract version from JSON
+bash(cat version.json | grep -o '"version": *"[^"]*"' | cut -d'"' -f4)
+
+# Extract date from JSON
+bash(cat version.json | grep -o '"installation_date_utc": *"[^"]*"' | cut -d'"' -f4)
+
+# Fetch latest release (with timeout)
+bash(curl -fsSL "https://api.github.com/repos/catlog22/Claude-Code-Workflow/releases/latest" 2>/dev/null, timeout: 30000)
+
+# Extract tag name
+bash(curl -fsSL "https://api.github.com/repos/catlog22/Claude-Code-Workflow/releases/latest" 2>/dev/null | grep -o '"tag_name": *"[^"]*"' | cut -d'"' -f4, timeout: 30000)
+
+# Extract release name
+bash(curl -fsSL "https://api.github.com/repos/catlog22/Claude-Code-Workflow/releases/latest" 2>/dev/null | grep -o '"name": *"[^"]*"' | head -1 | cut -d'"' -f4, timeout: 30000)
+
+# Fetch latest commit (with timeout)
+bash(curl -fsSL "https://api.github.com/repos/catlog22/Claude-Code-Workflow/commits/main" 2>/dev/null, timeout: 30000)
+
+# Extract commit SHA
+bash(curl -fsSL "https://api.github.com/repos/catlog22/Claude-Code-Workflow/commits/main" 2>/dev/null | grep -o '"sha": *"[^"]*"' | head -1 | cut -d'"' -f4 | cut -c1-7, timeout: 30000)
+
+# Extract commit message (first line)
+bash(curl -fsSL "https://api.github.com/repos/catlog22/Claude-Code-Workflow/commits/main" 2>/dev/null | grep '"message":' | cut -d'"' -f4 | cut -d'\' -f1, timeout: 30000)
+
+# Compare versions
+bash(printf "%s\n%s" "3.2.1" "3.2.2" | sort -V | tail -n 1)
+
+# Remove 'v' prefix
+bash(echo "v3.2.1" | sed 's/^v//')
+```
+
+## Error Handling
+
+### No installation found
+```
+WARNING: Claude Code Workflow not installed
+Install using:
+PowerShell: iex (iwr -useb https://raw.githubusercontent.com/catlog22/Claude-Code-Workflow/main/install-remote.ps1)
+```
+
+### Network error
+```
+ERROR: Could not fetch latest version from GitHub
+Check your network connection
+```
+
+### Invalid version.json
+```
+ERROR: version.json is invalid or corrupted
+```
+
+## Design Notes
+
+- Uses simple, direct bash commands instead of complex functions
+- Each step is independent and can be executed separately
+- Fallback to grep/sed for JSON parsing (no jq dependency required)
+- Network calls use curl with error suppression and 30-second timeout
+- Version comparison uses `sort -V` for accurate semantic versioning
+- Use `/commits/main` API instead of `/branches/main` for more reliable commit info
+- Extract first line of commit message using `cut -d'\' -f1` to handle JSON escape sequences
+
+## API Endpoints
+
+### GitHub API Used
+- **Latest Release**: `https://api.github.com/repos/catlog22/Claude-Code-Workflow/releases/latest`
+  - Fields: `tag_name`, `name`, `published_at`
+- **Latest Commit**: `https://api.github.com/repos/catlog22/Claude-Code-Workflow/commits/main`
+  - Fields: `sha`, `commit.message`, `commit.author.date`
+
+### Timeout Configuration
+All network calls should use `timeout: 30000` (30 seconds) to handle slow connections.

.claude/commands/workflow/action-plan-verify.md

@@ -0,0 +1,447 @@
+---
+name: action-plan-verify
+description: Perform non-destructive cross-artifact consistency analysis between IMPL_PLAN.md and task JSONs with quality gate validation
+argument-hint: "[optional: --session session-id]"
+allowed-tools: Read(*), TodoWrite(*), Glob(*), Bash(*)
+---
+
+## User Input
+
+```text
+$ARGUMENTS
+```
+
+You **MUST** consider the user input before proceeding (if not empty).
+
+## Goal
+
+Identify inconsistencies, duplications, ambiguities, and underspecified items between action planning artifacts (`IMPL_PLAN.md`, `task.json`) and brainstorming artifacts (`role analysis documents`) before implementation. This command MUST run only after `/workflow:plan` has successfully produced complete `IMPL_PLAN.md` and task JSON files.
+
+## Operating Constraints
+
+**STRICTLY READ-ONLY**: Do **not** modify any files. Output a structured analysis report. Offer an optional remediation plan (user must explicitly approve before any follow-up editing commands).
+
+**Synthesis Authority**: The `role analysis documents` is **authoritative** for requirements and design decisions. Any conflicts between IMPL_PLAN/tasks and synthesis are automatically CRITICAL and require adjustment of the plan/tasks—not reinterpretation of requirements.
+
+## Execution Steps
+
+### 1. Initialize Analysis Context
+
+```bash
+# Detect active workflow session
+IF --session parameter provided:
+    session_id = provided session
+ELSE:
+    # Auto-detect active session
+    active_sessions = bash(find .workflow/active/ -name "WFS-*" -type d 2>/dev/null)
+    IF active_sessions is empty:
+        ERROR: "No active workflow session found. Use --session <session-id>"
+        EXIT
+    ELSE IF active_sessions has multiple entries:
+        # Use most recently modified session
+        session_id = bash(ls -td .workflow/active/WFS-*/ 2>/dev/null | head -1 | xargs basename)
+    ELSE:
+        session_id = basename(active_sessions[0])
+
+# Derive absolute paths
+session_dir = .workflow/active/WFS-{session}
+brainstorm_dir = session_dir/.brainstorming
+task_dir = session_dir/.task
+
+# Validate required artifacts
+# Note: "role analysis documents" refers to [role]/analysis.md files (e.g., product-manager/analysis.md)
+SYNTHESIS_DIR = brainstorm_dir  # Contains role analysis files: */analysis.md
+IMPL_PLAN = session_dir/IMPL_PLAN.md
+TASK_FILES = Glob(task_dir/*.json)
+
+# Abort if missing
+SYNTHESIS_FILES = Glob(brainstorm_dir/*/analysis.md)
+IF SYNTHESIS_FILES.count == 0:
+    ERROR: "No role analysis documents found in .brainstorming/*/analysis.md. Run /workflow:brainstorm:synthesis first"
+    EXIT
+
+IF NOT EXISTS(IMPL_PLAN):
+    ERROR: "IMPL_PLAN.md not found. Run /workflow:plan first"
+    EXIT
+
+IF TASK_FILES.count == 0:
+    ERROR: "No task JSON files found. Run /workflow:plan first"
+    EXIT
+```
+
+### 2. Load Artifacts (Progressive Disclosure)
+
+Load only minimal necessary context from each artifact:
+
+**From workflow-session.json** (NEW - PRIMARY REFERENCE):
+- Original user prompt/intent (project or description field)
+- User's stated goals and objectives
+- User's scope definition
+
+**From role analysis documents**:
+- Functional Requirements (IDs, descriptions, acceptance criteria)
+- Non-Functional Requirements (IDs, targets)
+- Business Requirements (IDs, success metrics)
+- Key Architecture Decisions
+- Risk factors and mitigation strategies
+- Implementation Roadmap (high-level phases)
+
+**From IMPL_PLAN.md**:
+- Summary and objectives
+- Context Analysis
+- Implementation Strategy
+- Task Breakdown Summary
+- Success Criteria
+- Brainstorming Artifacts References (if present)
+
+**From task.json files**:
+- Task IDs
+- Titles and descriptions
+- Status
+- Dependencies (depends_on, blocks)
+- Context (requirements, focus_paths, acceptance, artifacts)
+- Flow control (pre_analysis, implementation_approach)
+- Meta (complexity, priority)
+
+### 3. Build Semantic Models
+
+Create internal representations (do not include raw artifacts in output):
+
+**Requirements inventory**:
+- Each functional/non-functional/business requirement with stable ID
+- Requirement text, acceptance criteria, priority
+
+**Architecture decisions inventory**:
+- ADRs from synthesis
+- Technology choices
+- Data model references
+
+**Task coverage mapping**:
+- Map each task to one or more requirements (by ID reference or keyword inference)
+- Map each requirement to covering tasks
+
+**Dependency graph**:
+- Task-to-task dependencies (depends_on, blocks)
+- Requirement-level dependencies (from synthesis)
+
+### 4. Detection Passes (Token-Efficient Analysis)
+
+Focus on high-signal findings. Limit to 50 findings total; aggregate remainder in overflow summary.
+
+#### A. User Intent Alignment (NEW - CRITICAL)
+
+- **Goal Alignment**: IMPL_PLAN objectives match user's original intent
+- **Scope Drift**: Plan covers user's stated scope without unauthorized expansion
+- **Success Criteria Match**: Plan's success criteria reflect user's expectations
+- **Intent Conflicts**: Tasks contradicting user's original objectives
+
+#### B. Requirements Coverage Analysis
+
+- **Orphaned Requirements**: Requirements in synthesis with zero associated tasks
+- **Unmapped Tasks**: Tasks with no clear requirement linkage
+- **NFR Coverage Gaps**: Non-functional requirements (performance, security, scalability) not reflected in tasks
+
+#### C. Consistency Validation
+
+- **Requirement Conflicts**: Tasks contradicting synthesis requirements
+- **Architecture Drift**: IMPL_PLAN architecture not matching synthesis ADRs
+- **Terminology Drift**: Same concept named differently across IMPL_PLAN and tasks
+- **Data Model Inconsistency**: Tasks referencing entities/fields not in synthesis data model
+
+#### D. Dependency Integrity
+
+- **Circular Dependencies**: Task A depends on B, B depends on C, C depends on A
+- **Missing Dependencies**: Task requires outputs from another task but no explicit dependency
+- **Broken Dependencies**: Task depends on non-existent task ID
+- **Logical Ordering Issues**: Implementation tasks before foundational setup without dependency note
+
+#### E. Synthesis Alignment
+
+- **Priority Conflicts**: High-priority synthesis requirements mapped to low-priority tasks
+- **Success Criteria Mismatch**: IMPL_PLAN success criteria not covering synthesis acceptance criteria
+- **Risk Mitigation Gaps**: Critical risks in synthesis without corresponding mitigation tasks
+
+#### F. Task Specification Quality
+
+- **Ambiguous Focus Paths**: Tasks with vague or missing focus_paths
+- **Underspecified Acceptance**: Tasks without clear acceptance criteria
+- **Missing Artifacts References**: Tasks not referencing relevant brainstorming artifacts in context.artifacts
+- **Weak Flow Control**: Tasks without clear implementation_approach or pre_analysis steps
+- **Missing Target Files**: Tasks without flow_control.target_files specification
+
+#### G. Duplication Detection
+
+- **Overlapping Task Scope**: Multiple tasks with nearly identical descriptions
+- **Redundant Requirements Coverage**: Same requirement covered by multiple tasks without clear partitioning
+
+#### H. Feasibility Assessment
+
+- **Complexity Misalignment**: Task marked "simple" but requires multiple file modifications
+- **Resource Conflicts**: Parallel tasks requiring same resources/files
+- **Skill Gap Risks**: Tasks requiring skills not in team capability assessment (from synthesis)
+
+### 5. Severity Assignment
+
+Use this heuristic to prioritize findings:
+
+- **CRITICAL**:
+  - Violates user's original intent (goal misalignment, scope drift)
+  - Violates synthesis authority (requirement conflict)
+  - Core requirement with zero coverage
+  - Circular dependencies
+  - Broken dependencies
+
+- **HIGH**:
+  - NFR coverage gaps
+  - Priority conflicts
+  - Missing risk mitigation tasks
+  - Ambiguous acceptance criteria
+
+- **MEDIUM**:
+  - Terminology drift
+  - Missing artifacts references
+  - Weak flow control
+  - Logical ordering issues
+
+- **LOW**:
+  - Style/wording improvements
+  - Minor redundancy not affecting execution
+
+### 6. Produce Compact Analysis Report
+
+**Report Generation**: Generate report content and save to file.
+
+Output a Markdown report with the following structure:
+
+```markdown
+## Action Plan Verification Report
+
+**Session**: WFS-{session-id}
+**Generated**: {timestamp}
+**Artifacts Analyzed**: role analysis documents, IMPL_PLAN.md, {N} task files
+
+---
+
+### Executive Summary
+
+- **Overall Risk Level**: CRITICAL | HIGH | MEDIUM | LOW
+- **Recommendation**: (See decision matrix below)
+  - BLOCK_EXECUTION: Critical issues exist (must fix before proceeding)
+  - PROCEED_WITH_FIXES: High issues exist, no critical (fix recommended before execution)
+  - PROCEED_WITH_CAUTION: Medium issues only (proceed with awareness)
+  - PROCEED: Low issues only or no issues (safe to execute)
+- **Critical Issues**: {count}
+- **High Issues**: {count}
+- **Medium Issues**: {count}
+- **Low Issues**: {count}
+
+---
+
+### Findings Summary
+
+| ID | Category | Severity | Location(s) | Summary | Recommendation |
+|----|----------|----------|-------------|---------|----------------|
+| C1 | Coverage | CRITICAL | synthesis:FR-03 | Requirement "User auth" has zero task coverage | Add authentication implementation task |
+| H1 | Consistency | HIGH | IMPL-1.2 vs synthesis:ADR-02 | Task uses REST while synthesis specifies GraphQL | Align task with ADR-02 decision |
+| M1 | Specification | MEDIUM | IMPL-2.1 | Missing context.artifacts reference | Add @synthesis reference |
+| L1 | Duplication | LOW | IMPL-3.1, IMPL-3.2 | Similar scope | Consider merging |
+
+(Add one row per finding; generate stable IDs prefixed by severity initial.)
+
+---
+
+### Requirements Coverage Analysis
+
+| Requirement ID | Requirement Summary | Has Task? | Task IDs | Priority Match | Notes |
+|----------------|---------------------|-----------|----------|----------------|-------|
+| FR-01 | User authentication | Yes | IMPL-1.1, IMPL-1.2 | Match | Complete |
+| FR-02 | Data export | Yes | IMPL-2.3 | Mismatch | High req → Med priority task |
+| FR-03 | Profile management | No | - | - | **CRITICAL: Zero coverage** |
+| NFR-01 | Response time <200ms | No | - | - | **HIGH: No performance tasks** |
+
+**Coverage Metrics**:
+- Functional Requirements: 85% (17/20 covered)
+- Non-Functional Requirements: 40% (2/5 covered)
+- Business Requirements: 100% (5/5 covered)
+
+---
+
+### Unmapped Tasks
+
+| Task ID | Title | Issue | Recommendation |
+|---------|-------|-------|----------------|
+| IMPL-4.5 | Refactor utils | No requirement linkage | Link to technical debt or remove |
+
+---
+
+### Dependency Graph Issues
+
+**Circular Dependencies**: None detected
+
+**Broken Dependencies**:
+- IMPL-2.3 depends on "IMPL-2.4" (non-existent)
+
+**Logical Ordering Issues**:
+- IMPL-5.1 (integration test) has no dependency on IMPL-1.* (implementation tasks)
+
+---
+
+### Synthesis Alignment Issues
+
+| Issue Type | Synthesis Reference | IMPL_PLAN/Task | Impact | Recommendation |
+|------------|---------------------|----------------|--------|----------------|
+| Architecture Conflict | synthesis:ADR-01 (JWT auth) | IMPL_PLAN uses session cookies | HIGH | Update IMPL_PLAN to use JWT |
+| Priority Mismatch | synthesis:FR-02 (High) | IMPL-2.3 (Medium) | MEDIUM | Elevate task priority |
+| Missing Risk Mitigation | synthesis:Risk-03 (API rate limits) | No mitigation tasks | HIGH | Add rate limiting implementation task |
+
+---
+
+### Task Specification Quality Issues
+
+**Missing Artifacts References**: 12 tasks lack context.artifacts
+**Weak Flow Control**: 5 tasks lack implementation_approach
+**Missing Target Files**: 8 tasks lack flow_control.target_files
+
+**Sample Issues**:
+- IMPL-1.2: No context.artifacts reference to synthesis
+- IMPL-3.1: Missing flow_control.target_files specification
+- IMPL-4.2: Vague focus_paths ["src/"] - needs refinement
+
+---
+
+### Feasibility Concerns
+
+| Concern | Tasks Affected | Issue | Recommendation |
+|---------|----------------|-------|----------------|
+| Skill Gap | IMPL-6.1, IMPL-6.2 | Requires Kubernetes expertise not in team | Add training task or external consultant |
+| Resource Conflict | IMPL-3.1, IMPL-3.2 | Both modify src/auth/service.ts in parallel | Add dependency or serialize |
+
+---
+
+### Metrics
+
+- **Total Requirements**: 30 (20 functional, 5 non-functional, 5 business)
+- **Total Tasks**: 25
+- **Overall Coverage**: 77% (23/30 requirements with ≥1 task)
+- **Critical Issues**: 2
+- **High Issues**: 5
+- **Medium Issues**: 8
+- **Low Issues**: 3
+
+---
+
+### Next Actions
+
+#### Action Recommendations
+
+**Recommendation Decision Matrix**:
+
+| Condition | Recommendation | Action |
+|-----------|----------------|--------|
+| Critical > 0 | BLOCK_EXECUTION | Must resolve all critical issues before proceeding |
+| Critical = 0, High > 0 | PROCEED_WITH_FIXES | Fix high-priority issues before execution |
+| Critical = 0, High = 0, Medium > 0 | PROCEED_WITH_CAUTION | Proceed with awareness of medium issues |
+| Only Low or None | PROCEED | Safe to execute workflow |
+
+**If CRITICAL Issues Exist** (BLOCK_EXECUTION):
+- Resolve all critical issues before proceeding
+- Use TodoWrite to track required fixes
+- Fix broken dependencies and circular references first
+
+**If HIGH Issues Exist** (PROCEED_WITH_FIXES):
+- Fix high-priority issues before execution
+- Use TodoWrite to systematically track and complete improvements
+
+**If Only MEDIUM/LOW Issues** (PROCEED_WITH_CAUTION / PROCEED):
+- Can proceed with execution
+- Address issues during or after implementation
+
+#### TodoWrite-Based Remediation Workflow
+
+**Report Location**: `.workflow/active/WFS-{session}/.process/ACTION_PLAN_VERIFICATION.md`
+
+**Recommended Workflow**:
+1. **Create TodoWrite Task List**: Extract all findings from report
+2. **Process by Priority**: CRITICAL → HIGH → MEDIUM → LOW
+3. **Complete Each Fix**: Mark tasks as in_progress/completed as you work
+4. **Validate Changes**: Verify each modification against requirements
+
+**TodoWrite Task Structure Example**:
+```markdown
+Priority Order:
+1. Fix coverage gaps (CRITICAL)
+2. Resolve consistency conflicts (CRITICAL/HIGH)
+3. Add missing specifications (MEDIUM)
+4. Improve task quality (LOW)
+```
+
+**Notes**:
+- TodoWrite provides real-time progress tracking
+- Each finding becomes a trackable todo item
+- User can monitor progress throughout remediation
+- Architecture drift in IMPL_PLAN requires manual editing
+```
+
+### 7. Save Report and Execute TodoWrite-Based Remediation
+
+**Step 7.1: Save Analysis Report**:
+```bash
+report_path = ".workflow/active/WFS-{session}/.process/ACTION_PLAN_VERIFICATION.md"
+Write(report_path, full_report_content)
+```
+
+**Step 7.2: Display Report Summary to User**:
+- Show executive summary with counts
+- Display recommendation (BLOCK/PROCEED_WITH_FIXES/PROCEED_WITH_CAUTION/PROCEED)
+- List critical and high issues if any
+
+**Step 7.3: After Report Generation**:
+
+1. **Extract Findings**: Parse all issues by severity
+2. **Create TodoWrite Task List**: Convert findings to actionable todos
+3. **Execute Fixes**: Process each todo systematically
+4. **Update Task Files**: Apply modifications directly to task JSON files
+5. **Update IMPL_PLAN**: Apply strategic changes if needed
+
+At end of report, provide remediation guidance:
+
+```markdown
+### 🔧 Remediation Workflow
+
+**Recommended Approach**:
+1. **Initialize TodoWrite**: Create comprehensive task list from all findings
+2. **Process by Severity**: Start with CRITICAL, then HIGH, MEDIUM, LOW
+3. **Apply Fixes Directly**: Modify task.json files and IMPL_PLAN.md as needed
+4. **Track Progress**: Mark todos as completed after each fix
+
+**TodoWrite Execution Pattern**:
+```bash
+# Step 1: Create task list from verification report
+TodoWrite([
+  { content: "Fix FR-03 coverage gap - add authentication task", status: "pending", activeForm: "Fixing FR-03 coverage gap" },
+  { content: "Fix IMPL-1.2 consistency - align with ADR-02", status: "pending", activeForm: "Fixing IMPL-1.2 consistency" },
+  { content: "Add context.artifacts to IMPL-1.2", status: "pending", activeForm: "Adding context.artifacts to IMPL-1.2" },
+  # ... additional todos for each finding
+])
+
+# Step 2: Process each todo systematically
+# Mark as in_progress when starting
+# Apply fix using Read/Edit tools
+# Mark as completed when done
+# Move to next priority item
+```
+
+**File Modification Workflow**:
+```bash
+# For task JSON modifications:
+1. Read(.workflow/active/WFS-{session}/.task/IMPL-X.Y.json)
+2. Edit() to apply fixes
+3. Mark todo as completed
+
+# For IMPL_PLAN modifications:
+1. Read(.workflow/active/WFS-{session}/IMPL_PLAN.md)
+2. Edit() to apply strategic changes
+3. Mark todo as completed
+```
+
+**Note**: All fixes execute immediately after user confirmation without additional commands.

.claude/commands/workflow/brainstorm/CLAUDE.md

@@ -1,75 +0,0 @@
-# Module Analysis: `workflow:brainstorm`
-
-## 1. Module-specific Implementation Patterns
-
-### Role-Based Command Structure
-The `brainstorm` workflow is composed of multiple, distinct "role" commands. Each role is defined in its own Markdown file (e.g., `product-manager.md`, `system-architect.md`). This modular design allows for easy extension by adding new role files.
-
-- **Command Naming Convention**: Each role is invoked via a consistent command structure: `/workflow:brainstorm:<role-name> <topic>`.
-- **File Naming Convention**: The command's `<role-name>` corresponds directly to the filename (e.g., `product-manager.md` implements `/workflow:brainstorm:product-manager`).
-
-### Standardized Role Definition Structure
-Each role's `.md` file follows a strict, standardized structure:
-1.  **Frontmatter**: Defines the command `name`, `description`, `usage`, `argument-hint`, `examples`, and `allowed-tools`. All roles consistently use `Task(conceptual-planning-agent)` and `TodoWrite(*)`.
-2.  **Role Overview**: Defines the role's purpose, responsibilities, and success metrics.
-3.  **Analysis Framework**: References shared principles (`brainstorming-principles.md`, `brainstorming-framework.md`) and lists key questions specific to the role's perspective.
-4.  **Execution Protocol**: A multi-phase process detailing session detection, directory creation, task initialization (`TodoWrite`), and delegation to the `conceptual-planning-agent`.
-5.  **Output Specification**: Defines the directory structure and file templates for the analysis artifacts generated by the role.
-6.  **Session Integration**: Specifies how the role's output integrates with the parent session state (`workflow-session.json`).
-7.  **Quality Assurance**: Provides checklists and standards for validating the quality of the role's output.
-
-## 2. Internal Architecture and Design Decisions
-
-### Session-Based Workflow
-The entire workflow is stateful and session-based, managed within the `.workflow/` directory.
-- **State Management**: An active session is marked by a `.workflow/.active-*` file.
-- **Output Scaffolding**: Each role command creates a dedicated output directory: `.workflow/WFS-{topic-slug}/.brainstorming/<role-name>/`. This isolates each perspective's artifacts.
-
-### "Map-Reduce" Architectural Pattern
-The workflow follows a pattern analogous to Map-Reduce:
-- **Map Phase**: Each individual role command (`product-manager`, `ui-designer`, etc.) acts as a "mapper". It takes the input `{topic}` and produces a detailed analysis from its unique perspective.
-- **Reduce Phase**: The `synthesis` command acts as the "reducer". It collects the outputs from all completed roles, integrates them, identifies consensus and conflicts, and produces a single, comprehensive strategic report.
-
-### Delegation to `conceptual-planning-agent`
-The core analytical work is not performed by the commands themselves. Instead, they act as templating engines that construct a detailed prompt for the `conceptual-planning-agent`. This design decision centralizes the complex reasoning and generation logic into a single, powerful tool, while the Markdown files serve as declarative "configurations" for that tool.
-
-## 3. API Contracts and Interfaces
-
-### Command-Line Interface (CLI)
-The primary user-facing interface is the set of CLI commands:
-- **Role Commands**: `/workflow:brainstorm:<role-name> <topic>`
-- **Synthesis Command**: `/workflow:brainstorm:synthesis` (no arguments)
-
-### `conceptual-planning-agent` Contract
-The interface with the planning agent is a structured prompt passed to the `Task()` tool. This prompt consistently contains:
-- `ASSIGNED_ROLE` / `ROLE CONTEXT`: Defines the persona for the agent.
-- `USER_CONTEXT`: Injects user requirements from the session.
-- `ANALYSIS_REQUIREMENTS`: A detailed, numbered list of tasks for the agent to perform.
-- `OUTPUT REQUIREMENTS`: Specifies the exact file paths and high-level content structure for the generated artifacts.
-
-### Filesystem Contract
-The workflow relies on a strict filesystem structure for state and outputs:
-- **Session State**: `.workflow/WFS-{topic-slug}/workflow-session.json` is updated by each role to track progress.
-- **Role Outputs**: Each role must produce a set of `.md` files in its designated directory (e.g., `analysis.md`, `roadmap.md`).
-- **Synthesis Input**: The `synthesis` command expects to find these specific output files to perform its function.
-
-## 4. Module Dependencies and Relationships
-
-- **Internal Dependencies**:
-    - The `synthesis` command is dependent on the outputs of all other role commands. It cannot function until one or more roles have completed their analysis.
-    - Individual role commands are largely independent of one another.
-
-- **External Dependencies**:
-    - **`conceptual-planning-agent`**: All roles have a critical dependency on this tool for their core logic.
-    - **Shared Frameworks**: All roles include and depend on `@~/.claude/workflows/brainstorming-principles.md` and `@~/.claude/workflows/brainstorming-framework.md`, ensuring a consistent analytical foundation.
-
-## 5. Testing Strategies
-
-This module does not contain automated tests. Validation relies on a set of quality assurance standards defined within each role's Markdown file.
-
-- **Checklist-Based Validation**: Each file contains a "Quality Assurance" or "Quality Standards" section with checklists for:
-    - **Required Analysis Elements**: Ensures all necessary components are present in the output.
-    - **Core Principles**: Validates that the analysis adheres to the role's guiding principles (e.g., "User-Centric", "Data-Driven").
-    - **Quality Metrics**: Provides criteria for assessing the quality of the output (e.g., "Requirements completeness", "Feasibility of implementation plan").
-
-This approach serves as a form of manual, requirement-based testing for the output generated by the `conceptual-planning-agent`.

.claude/commands/workflow/brainstorm/api-designer.md

@@ -0,0 +1,587 @@
+---
+name: api-designer
+description: Generate or update api-designer/analysis.md addressing guidance-specification discussion points for API design perspective
+argument-hint: "optional topic - uses existing framework if available"
+allowed-tools: Task(conceptual-planning-agent), TodoWrite(*), Read(*), Write(*)
+---
+
+## 🔌 **API Designer Analysis Generator**
+
+### Purpose
+**Specialized command for generating api-designer/analysis.md** that addresses guidance-specification.md discussion points from backend API design perspective. Creates or updates role-specific analysis with framework references.
+
+### Core Function
+- **Framework-based Analysis**: Address each discussion point in guidance-specification.md
+- **API Design Focus**: RESTful/GraphQL API design, endpoint structure, and contract definition
+- **Update Mechanism**: Create new or update existing analysis.md
+- **Agent Delegation**: Use conceptual-planning-agent for analysis generation
+
+### Analysis Scope
+- **API Architecture**: RESTful/GraphQL design patterns and best practices
+- **Endpoint Design**: Resource modeling, URL structure, and HTTP method selection
+- **Data Contracts**: Request/response schemas, validation rules, and data transformation
+- **API Documentation**: OpenAPI/Swagger specifications and developer experience
+
+### Role Boundaries & Responsibilities
+
+#### **What This Role OWNS (API Contract Within Architectural Framework)**
+- **API Contract Definition**: Specific endpoint paths, HTTP methods, and status codes
+- **Resource Modeling**: Mapping domain entities to RESTful resources or GraphQL types
+- **Request/Response Schemas**: Detailed data contracts, validation rules, and error formats
+- **API Versioning Strategy**: Version management, deprecation policies, and migration paths
+- **Developer Experience**: API documentation (OpenAPI/Swagger), code examples, and SDKs
+
+#### **What This Role DOES NOT Own (Defers to Other Roles)**
+- **System Architecture Decisions**: Microservices vs monolithic, overall communication patterns → Defers to **System Architect**
+- **Canonical Data Model**: Underlying data schemas and entity relationships → Defers to **Data Architect**
+- **UI/Frontend Integration**: How clients consume the API → Defers to **UI Designer**
+
+#### **Handoff Points**
+- **FROM System Architect**: Receives architectural constraints (REST vs GraphQL, sync vs async) that define the design space
+- **FROM Data Architect**: Receives canonical data model and translates it into public API data contracts (as projection/view)
+- **TO Frontend Teams**: Provides complete API specifications, documentation, and integration guides
+
+## ⚙️ **Execution Protocol**
+
+### Phase 1: Session & Framework Detection
+```bash
+# Check active session and framework
+CHECK: find .workflow/active/ -name "WFS-*" -type d
+IF active_session EXISTS:
+    session_id = get_active_session()
+    brainstorm_dir = .workflow/active/WFS-{session}/.brainstorming/
+
+    CHECK: brainstorm_dir/guidance-specification.md
+    IF EXISTS:
+        framework_mode = true
+        load_framework = true
+    ELSE:
+        IF topic_provided:
+            framework_mode = false  # Create analysis without framework
+        ELSE:
+            ERROR: "No framework found and no topic provided"
+```
+
+### Phase 2: Analysis Mode Detection
+```bash
+# Check existing analysis
+CHECK: brainstorm_dir/api-designer/analysis.md
+IF EXISTS:
+    SHOW existing analysis summary
+    ASK: "Analysis exists. Do you want to:"
+    OPTIONS:
+      1. "Update with new insights" → Update existing
+      2. "Replace completely" → Generate new
+      3. "Cancel" → Exit without changes
+ELSE:
+    CREATE new analysis
+```
+
+### Phase 3: Agent Task Generation
+**Framework-Based Analysis** (when guidance-specification.md exists):
+```bash
+Task(subagent_type="conceptual-planning-agent",
+     run_in_background=false,
+     prompt="Generate API designer analysis addressing topic framework
+
+     ## Framework Integration Required
+     **MANDATORY**: Load and address guidance-specification.md discussion points
+     **Framework Reference**: @{session.brainstorm_dir}/guidance-specification.md
+     **Output Location**: {session.brainstorm_dir}/api-designer/analysis.md
+
+     ## Analysis Requirements
+     1. **Load Topic Framework**: Read guidance-specification.md completely
+     2. **Address Each Discussion Point**: Respond to all 5 framework sections from API design perspective
+     3. **Include Framework Reference**: Start analysis.md with @../guidance-specification.md
+     4. **API Design Focus**: Emphasize endpoint structure, data contracts, versioning strategies
+     5. **Structured Response**: Use framework structure for analysis organization
+
+     ## Framework Sections to Address
+     - Core Requirements (from API design perspective)
+     - Technical Considerations (detailed API architecture analysis)
+     - User Experience Factors (developer experience and API usability)
+     - Implementation Challenges (API design risks and solutions)
+     - Success Metrics (API performance metrics and adoption tracking)
+
+     ## Output Structure Required
+     ```markdown
+     # API Designer Analysis: [Topic]
+
+     **Framework Reference**: @../guidance-specification.md
+     **Role Focus**: Backend API Design and Contract Definition
+
+     ## Core Requirements Analysis
+     [Address framework requirements from API design perspective]
+
+     ## Technical Considerations
+     [Detailed API architecture and endpoint design analysis]
+
+     ## Developer Experience Factors
+     [API usability, documentation, and integration ease]
+
+     ## Implementation Challenges
+     [API design risks and mitigation strategies]
+
+     ## Success Metrics
+     [API performance metrics, adoption rates, and developer satisfaction]
+
+     ## API Design-Specific Recommendations
+     [Detailed API design recommendations and best practices]
+     ```",
+     description="Generate API designer framework-based analysis")
+```
+
+### Phase 4: Update Mechanism
+**Analysis Update Process**:
+```bash
+# For existing analysis updates
+IF update_mode = "incremental":
+    Task(subagent_type="conceptual-planning-agent",
+         run_in_background=false,
+         prompt="Update existing API designer analysis
+
+         ## Current Analysis Context
+         **Existing Analysis**: @{session.brainstorm_dir}/api-designer/analysis.md
+         **Framework Reference**: @{session.brainstorm_dir}/guidance-specification.md
+
+         ## Update Requirements
+         1. **Preserve Structure**: Maintain existing analysis structure
+         2. **Add New Insights**: Integrate new API design insights and recommendations
+         3. **Framework Alignment**: Ensure continued alignment with topic framework
+         4. **API Updates**: Add new endpoint patterns, versioning strategies, documentation improvements
+         5. **Maintain References**: Keep @../guidance-specification.md reference
+
+         ## Update Instructions
+         - Read existing analysis completely
+         - Identify areas for enhancement or new insights
+         - Add API design depth while preserving original structure
+         - Update recommendations with new API design patterns and approaches
+         - Maintain framework discussion point addressing",
+         description="Update API designer analysis incrementally")
+```
+
+## Document Structure
+
+### Output Files
+```
+.workflow/active/WFS-[topic]/.brainstorming/
+├── guidance-specification.md          # Input: Framework (if exists)
+└── api-designer/
+    └── analysis.md            # ★ OUTPUT: Framework-based analysis
+```
+
+### Analysis Structure
+**Required Elements**:
+- **Framework Reference**: @../guidance-specification.md (if framework exists)
+- **Role Focus**: Backend API Design and Contract Definition perspective
+- **5 Framework Sections**: Address each framework discussion point
+- **API Design Recommendations**: Endpoint-specific insights and solutions
+
+## ⚡ **Two-Step Execution Flow**
+
+### ⚠️ Session Management - FIRST STEP
+Session detection and selection:
+```bash
+# Check for active sessions
+active_sessions=$(find .workflow/active/ -name "WFS-*" -type d 2>/dev/null)
+if [ multiple_sessions ]; then
+  prompt_user_to_select_session()
+else
+  use_existing_or_create_new()
+fi
+```
+
+### Step 1: Context Gathering Phase
+**API Designer Perspective Questioning**
+
+Before agent assignment, gather comprehensive API design context:
+
+#### 📋 Role-Specific Questions
+1. **API Type & Architecture**
+   - RESTful, GraphQL, or hybrid API approach?
+   - Synchronous vs asynchronous communication patterns?
+   - Real-time requirements (WebSocket, Server-Sent Events)?
+
+2. **Resource Modeling & Endpoints**
+   - What are the core domain resources/entities?
+   - Expected CRUD operations for each resource?
+   - Complex query requirements (filtering, sorting, pagination)?
+
+3. **Data Contracts & Validation**
+   - Request/response data format requirements (JSON, XML, Protocol Buffers)?
+   - Input validation and sanitization requirements?
+   - Data transformation and mapping needs?
+
+4. **API Management & Governance**
+   - API versioning strategy requirements?
+   - Authentication and authorization mechanisms?
+   - Rate limiting and throttling requirements?
+   - API documentation and developer portal needs?
+
+5. **Integration & Compatibility**
+   - Client platforms consuming the API (web, mobile, third-party)?
+   - Backward compatibility requirements?
+   - External API integrations needed?
+
+#### Context Validation
+- **Minimum Response**: Each answer must be ≥50 characters
+- **Re-prompting**: Insufficient detail triggers follow-up questions
+- **Context Storage**: Save responses to `.brainstorming/api-designer-context.md`
+
+### Step 2: Agent Assignment with Flow Control
+**Dedicated Agent Execution**
+
+```bash
+Task(conceptual-planning-agent): "
+[FLOW_CONTROL]
+
+Execute dedicated api-designer conceptual analysis for: {topic}
+
+ASSIGNED_ROLE: api-designer
+OUTPUT_LOCATION: .brainstorming/api-designer/
+USER_CONTEXT: {validated_responses_from_context_gathering}
+
+Flow Control Steps:
+[
+  {
+    \"step\": \"load_role_template\",
+    \"action\": \"Load api-designer planning template\",
+    \"command\": \"bash($(cat ~/.claude/workflows/cli-templates/planning-roles/api-designer.md))\",
+    \"output_to\": \"role_template\"
+  }
+]
+
+Conceptual Analysis Requirements:
+- Apply api-designer perspective to topic analysis
+- Focus on endpoint design, data contracts, and API governance
+- Use loaded role template framework for analysis structure
+- Generate role-specific deliverables in designated output location
+- Address all user context from questioning phase
+
+Deliverables:
+- analysis.md: Main API design analysis
+- api-specification.md: Detailed endpoint specifications
+- data-contracts.md: Request/response schemas and validation rules
+- api-documentation.md: API documentation strategy and templates
+
+Embody api-designer role expertise for comprehensive conceptual planning."
+```
+
+### Progress Tracking
+TodoWrite tracking for two-step process:
+```json
+[
+  {"content": "Gather API designer context through role-specific questioning", "status": "in_progress", "activeForm": "Gathering context"},
+  {"content": "Validate context responses and save to api-designer-context.md", "status": "pending", "activeForm": "Validating context"},
+  {"content": "Load api-designer planning template via flow control", "status": "pending", "activeForm": "Loading template"},
+  {"content": "Execute dedicated conceptual-planning-agent for api-designer role", "status": "pending", "activeForm": "Executing agent"}
+]
+```
+
+## 📊 **Output Specification**
+
+### Output Location
+```
+.workflow/active/WFS-{topic-slug}/.brainstorming/api-designer/
+├── analysis.md                 # Primary API design analysis
+├── api-specification.md        # Detailed endpoint specifications (OpenAPI/Swagger)
+├── data-contracts.md           # Request/response schemas and validation rules
+├── versioning-strategy.md      # API versioning and backward compatibility plan
+└── developer-guide.md          # API usage documentation and integration examples
+```
+
+### Document Templates
+
+#### analysis.md Structure
+```markdown
+# API Design Analysis: {Topic}
+*Generated: {timestamp}*
+
+## Executive Summary
+[Key API design findings and recommendations overview]
+
+## API Architecture Overview
+### API Type Selection (REST/GraphQL/Hybrid)
+### Communication Patterns
+### Authentication & Authorization Strategy
+
+## Resource Modeling
+### Core Domain Resources
+### Resource Relationships
+### URL Structure and Naming Conventions
+
+## Endpoint Design
+### Resource Endpoints
+- GET /api/v1/resources
+- POST /api/v1/resources
+- GET /api/v1/resources/{id}
+- PUT /api/v1/resources/{id}
+- DELETE /api/v1/resources/{id}
+
+### Query Parameters
+- Filtering: ?filter[field]=value
+- Sorting: ?sort=field,-field2
+- Pagination: ?page=1&limit=20
+
+### HTTP Methods and Status Codes
+- Success responses (2xx)
+- Client errors (4xx)
+- Server errors (5xx)
+
+## Data Contracts
+### Request Schemas
+[JSON Schema or OpenAPI definitions]
+
+### Response Schemas
+[JSON Schema or OpenAPI definitions]
+
+### Validation Rules
+- Required fields
+- Data types and formats
+- Business logic constraints
+
+## API Versioning Strategy
+### Versioning Approach (URL/Header/Accept)
+### Version Lifecycle Management
+### Deprecation Policy
+### Migration Paths
+
+## Security & Governance
+### Authentication Mechanisms
+- OAuth 2.0 / JWT / API Keys
+### Authorization Patterns
+- RBAC / ABAC / Resource-based
+### Rate Limiting & Throttling
+### CORS and Security Headers
+
+## Error Handling
+### Standard Error Response Format
+```json
+{
+  "error": {
+    "code": "ERROR_CODE",
+    "message": "Human-readable error message",
+    "details": [],
+    "trace_id": "uuid"
+  }
+}
+```
+
+### Error Code Taxonomy
+### Validation Error Responses
+
+## API Documentation
+### OpenAPI/Swagger Specification
+### Developer Portal Requirements
+### Code Examples and SDKs
+### Changelog and Migration Guides
+
+## Performance Optimization
+### Response Caching Strategies
+### Compression (gzip, brotli)
+### Field Selection (sparse fieldsets)
+### Bulk Operations and Batch Endpoints
+
+## Monitoring & Observability
+### API Metrics
+- Request count, latency, error rates
+- Endpoint usage analytics
+### Logging Strategy
+### Distributed Tracing
+
+## Developer Experience
+### API Usability Assessment
+### Integration Complexity
+### SDK and Client Library Needs
+### Sandbox and Testing Environments
+```
+
+#### api-specification.md Structure
+```markdown
+# API Specification: {Topic}
+*OpenAPI 3.0 Specification*
+
+## API Information
+- **Title**: {API Name}
+- **Version**: 1.0.0
+- **Base URL**: https://api.example.com/v1
+- **Contact**: api-team@example.com
+
+## Endpoints
+
+### Users API
+
+#### GET /users
+**Description**: Retrieve a list of users
+
+**Parameters**:
+- `page` (query, integer): Page number (default: 1)
+- `limit` (query, integer): Items per page (default: 20, max: 100)
+- `sort` (query, string): Sort field (e.g., "created_at", "-updated_at")
+- `filter[status]` (query, string): Filter by user status
+
+**Response 200**:
+```json
+{
+  "data": [
+    {
+      "id": "uuid",
+      "username": "string",
+      "email": "string",
+      "created_at": "2025-10-15T00:00:00Z"
+    }
+  ],
+  "meta": {
+    "page": 1,
+    "limit": 20,
+    "total": 100
+  },
+  "links": {
+    "self": "/users?page=1",
+    "next": "/users?page=2",
+    "prev": null
+  }
+}
+```
+
+#### POST /users
+**Description**: Create a new user
+
+**Request Body**:
+```json
+{
+  "username": "string (required, 3-50 chars)",
+  "email": "string (required, valid email)",
+  "password": "string (required, min 8 chars)",
+  "profile": {
+    "first_name": "string (optional)",
+    "last_name": "string (optional)"
+  }
+}
+```
+
+**Response 201**:
+```json
+{
+  "data": {
+    "id": "uuid",
+    "username": "string",
+    "email": "string",
+    "created_at": "2025-10-15T00:00:00Z"
+  }
+}
+```
+
+**Response 400** (Validation Error):
+```json
+{
+  "error": {
+    "code": "VALIDATION_ERROR",
+    "message": "Request validation failed",
+    "details": [
+      {
+        "field": "email",
+        "message": "Invalid email format"
+      }
+    ]
+  }
+}
+```
+
+[Continue for all endpoints...]
+
+## Authentication
+
+### OAuth 2.0 Flow
+1. Client requests authorization
+2. User grants permission
+3. Client receives access token
+4. Client uses token in requests
+
+**Header Format**:
+```
+Authorization: Bearer {access_token}
+```
+
+## Rate Limiting
+
+**Headers**:
+- `X-RateLimit-Limit`: 1000
+- `X-RateLimit-Remaining`: 999
+- `X-RateLimit-Reset`: 1634270400
+
+**Response 429** (Too Many Requests):
+```json
+{
+  "error": {
+    "code": "RATE_LIMIT_EXCEEDED",
+    "message": "API rate limit exceeded",
+    "retry_after": 3600
+  }
+}
+```
+```
+
+## 🔄 **Session Integration**
+
+### Status Synchronization
+Upon completion, update `workflow-session.json`:
+```json
+{
+  "phases": {
+    "BRAINSTORM": {
+      "api_designer": {
+        "status": "completed",
+        "completed_at": "timestamp",
+        "output_directory": ".workflow/active/WFS-{topic}/.brainstorming/api-designer/",
+        "key_insights": ["endpoint_design", "versioning_strategy", "data_contracts"]
+      }
+    }
+  }
+}
+```
+
+### Cross-Role Collaboration
+API designer perspective provides:
+- **API Contract Specifications** → Frontend Developer
+- **Data Schema Requirements** → Data Architect
+- **Security Requirements** → Security Expert
+- **Integration Endpoints** → System Architect
+- **Performance Constraints** → DevOps Engineer
+
+## ✅ **Quality Assurance**
+
+### Required Analysis Elements
+- [ ] Complete endpoint inventory with HTTP methods and paths
+- [ ] Detailed request/response schemas with validation rules
+- [ ] Clear versioning strategy and backward compatibility plan
+- [ ] Comprehensive error handling and status code usage
+- [ ] API documentation strategy (OpenAPI/Swagger)
+
+### API Design Principles
+- [ ] **Consistency**: Uniform naming conventions and patterns across all endpoints
+- [ ] **Simplicity**: Intuitive resource modeling and URL structures
+- [ ] **Flexibility**: Support for filtering, sorting, pagination, and field selection
+- [ ] **Security**: Proper authentication, authorization, and input validation
+- [ ] **Performance**: Caching strategies, compression, and efficient data structures
+
+### Developer Experience Validation
+- [ ] API is self-documenting with clear endpoint descriptions
+- [ ] Error messages are actionable and helpful for debugging
+- [ ] Response formats are consistent and predictable
+- [ ] Code examples and integration guides are provided
+- [ ] Sandbox environment available for testing
+
+### Technical Completeness
+- [ ] **Resource Modeling**: All domain entities mapped to API resources
+- [ ] **CRUD Coverage**: Complete create, read, update, delete operations
+- [ ] **Query Capabilities**: Advanced filtering, sorting, and search functionality
+- [ ] **Versioning**: Clear version management and migration paths
+- [ ] **Monitoring**: API metrics, logging, and tracing strategies defined
+
+### Integration Readiness
+- [ ] **Client Compatibility**: API works with all target client platforms
+- [ ] **External Integration**: Third-party API dependencies identified
+- [ ] **Backward Compatibility**: Changes don't break existing clients
+- [ ] **Migration Path**: Clear upgrade paths for API consumers
+- [ ] **SDK Support**: Client libraries and code generation considered

.claude/commands/workflow/brainstorm/artifacts.md

@@ -0,0 +1,453 @@
+---
+name: artifacts
+description: Interactive clarification generating confirmed guidance specification through role-based analysis and synthesis
+argument-hint: "topic or challenge description [--count N]"
+allowed-tools: TodoWrite(*), Read(*), Write(*), Glob(*), AskUserQuestion(*)
+---
+
+## Overview
+
+Seven-phase workflow: **Context collection** → **Topic analysis** → **Role selection** → **Role questions** → **Conflict resolution** → **Final check** → **Generate specification**
+
+All user interactions use AskUserQuestion tool (max 4 questions per call, multi-round).
+
+**Input**: `"GOAL: [objective] SCOPE: [boundaries] CONTEXT: [background]" [--count N]`
+**Output**: `.workflow/active/WFS-{topic}/.brainstorming/guidance-specification.md`
+**Core Principle**: Questions dynamically generated from project context + topic keywords, NOT generic templates
+
+**Parameters**:
+- `topic` (required): Topic or challenge description (structured format recommended)
+- `--count N` (optional): Number of roles to select (system recommends N+2 options, default: 3)
+
+---
+
+## Quick Reference
+
+### Phase Summary
+
+| Phase | Goal | AskUserQuestion | Storage |
+|-------|------|-----------------|---------|
+| 0 | Context collection | - | context-package.json |
+| 1 | Topic analysis | 2-4 questions | intent_context |
+| 2 | Role selection | 1 multi-select | selected_roles |
+| 3 | Role questions | 3-4 per role | role_decisions[role] |
+| 4 | Conflict resolution | max 4 per round | cross_role_decisions |
+| 4.5 | Final check | progressive rounds | additional_decisions |
+| 5 | Generate spec | - | guidance-specification.md |
+
+### AskUserQuestion Pattern
+
+```javascript
+// Single-select (Phase 1, 3, 4)
+AskUserQuestion({
+  questions: [
+    {
+      question: "{问题文本}",
+      header: "{短标签}",  // max 12 chars
+      multiSelect: false,
+      options: [
+        { label: "{选项}", description: "{说明和影响}" },
+        { label: "{选项}", description: "{说明和影响}" },
+        { label: "{选项}", description: "{说明和影响}" }
+      ]
+    }
+    // ... max 4 questions per call
+  ]
+})
+
+// Multi-select (Phase 2)
+AskUserQuestion({
+  questions: [{
+    question: "请选择 {count} 个角色",
+    header: "角色选择",
+    multiSelect: true,
+    options: [/* max 4 options per call */]
+  }]
+})
+```
+
+### Multi-Round Execution
+
+```javascript
+const BATCH_SIZE = 4;
+for (let i = 0; i < allQuestions.length; i += BATCH_SIZE) {
+  const batch = allQuestions.slice(i, i + BATCH_SIZE);
+  AskUserQuestion({ questions: batch });
+  // Store responses before next round
+}
+```
+
+---
+
+## Task Tracking
+
+**TodoWrite Rule**: EXTEND auto-parallel's task list (NOT replace/overwrite)
+
+**When called from auto-parallel**:
+- Find artifacts parent task → Mark "in_progress"
+- APPEND sub-tasks (Phase 0-5) → Mark each as completes
+- When Phase 5 completes → Mark parent "completed"
+- PRESERVE all other auto-parallel tasks
+
+**Standalone Mode**:
+```json
+[
+  {"content": "Initialize session", "status": "pending", "activeForm": "Initializing"},
+  {"content": "Phase 0: Context collection", "status": "pending", "activeForm": "Phase 0"},
+  {"content": "Phase 1: Topic analysis (2-4 questions)", "status": "pending", "activeForm": "Phase 1"},
+  {"content": "Phase 2: Role selection", "status": "pending", "activeForm": "Phase 2"},
+  {"content": "Phase 3: Role questions (per role)", "status": "pending", "activeForm": "Phase 3"},
+  {"content": "Phase 4: Conflict resolution", "status": "pending", "activeForm": "Phase 4"},
+  {"content": "Phase 4.5: Final clarification", "status": "pending", "activeForm": "Phase 4.5"},
+  {"content": "Phase 5: Generate specification", "status": "pending", "activeForm": "Phase 5"}
+]
+```
+
+---
+
+## Execution Phases
+
+### Session Management
+
+- Check `.workflow/active/` for existing sessions
+- Multiple → Prompt selection | Single → Use it | None → Create `WFS-[topic-slug]`
+- Parse `--count N` parameter (default: 3)
+- Store decisions in `workflow-session.json`
+
+### Phase 0: Context Collection
+
+**Goal**: Gather project context BEFORE user interaction
+
+**Steps**:
+1. Check if `context-package.json` exists → Skip if valid
+2. Invoke `context-search-agent` (BRAINSTORM MODE - lightweight)
+3. Output: `.workflow/active/WFS-{session-id}/.process/context-package.json`
+
+**Graceful Degradation**: If agent fails, continue to Phase 1 without context
+
+```javascript
+Task(
+  subagent_type="context-search-agent",
+  run_in_background=false,
+  description="Gather project context for brainstorm",
+  prompt=`
+Execute context-search-agent in BRAINSTORM MODE (Phase 1-2 only).
+
+Session: ${session_id}
+Task: ${task_description}
+Output: .workflow/${session_id}/.process/context-package.json
+
+Required fields: metadata, project_context, assets, dependencies, conflict_detection
+`
+)
+```
+
+### Phase 1: Topic Analysis
+
+**Goal**: Extract keywords/challenges enriched by Phase 0 context
+
+**Steps**:
+1. Load Phase 0 context (tech_stack, modules, conflict_risk)
+2. Deep topic analysis (entities, challenges, constraints, metrics)
+3. Generate 2-4 context-aware probing questions
+4. AskUserQuestion → Store to `session.intent_context`
+
+**Example**:
+```javascript
+AskUserQuestion({
+  questions: [
+    {
+      question: "实时协作平台的主要技术挑战？",
+      header: "核心挑战",
+      multiSelect: false,
+      options: [
+        { label: "实时数据同步", description: "100+用户同时在线，状态同步复杂度高" },
+        { label: "可扩展性架构", description: "用户规模增长时的系统扩展能力" },
+        { label: "冲突解决机制", description: "多用户同时编辑的冲突处理策略" }
+      ]
+    },
+    {
+      question: "MVP阶段最关注的指标？",
+      header: "优先级",
+      multiSelect: false,
+      options: [
+        { label: "功能完整性", description: "实现所有核心功能" },
+        { label: "用户体验", description: "流畅的交互体验和响应速度" },
+        { label: "系统稳定性", description: "高可用性和数据一致性" }
+      ]
+    }
+  ]
+})
+```
+
+**⚠️ CRITICAL**: Questions MUST reference topic keywords. Generic "Project type?" violates dynamic generation.
+
+### Phase 2: Role Selection
+
+**Goal**: User selects roles from intelligent recommendations
+
+**Available Roles**: data-architect, product-manager, product-owner, scrum-master, subject-matter-expert, system-architect, test-strategist, ui-designer, ux-expert
+
+**Steps**:
+1. Analyze Phase 1 keywords → Recommend count+2 roles with rationale
+2. AskUserQuestion (multiSelect=true) → Store to `session.selected_roles`
+3. If count+2 > 4, split into multiple rounds
+
+**Example**:
+```javascript
+AskUserQuestion({
+  questions: [{
+    question: "请选择 3 个角色参与头脑风暴分析",
+    header: "角色选择",
+    multiSelect: true,
+    options: [
+      { label: "system-architect", description: "实时同步架构设计和技术选型" },
+      { label: "ui-designer", description: "协作界面用户体验和状态展示" },
+      { label: "product-manager", description: "功能优先级和MVP范围决策" },
+      { label: "data-architect", description: "数据同步模型和存储方案设计" }
+    ]
+  }]
+})
+```
+
+**⚠️ CRITICAL**: User MUST interact. NEVER auto-select without confirmation.
+
+### Phase 3: Role-Specific Questions
+
+**Goal**: Generate deep questions mapping role expertise to Phase 1 challenges
+
+**Algorithm**:
+1. FOR each selected role:
+   - Map Phase 1 challenges to role domain
+   - Generate 3-4 questions (implementation depth, trade-offs, edge cases)
+   - AskUserQuestion per role → Store to `session.role_decisions[role]`
+2. Process roles sequentially (one at a time for clarity)
+3. If role needs > 4 questions, split into multiple rounds
+
+**Example** (system-architect):
+```javascript
+AskUserQuestion({
+  questions: [
+    {
+      question: "100+ 用户实时状态同步方案？",
+      header: "状态同步",
+      multiSelect: false,
+      options: [
+        { label: "Event Sourcing", description: "完整事件历史，支持回溯，存储成本高" },
+        { label: "集中式状态管理", description: "实现简单，单点瓶颈风险" },
+        { label: "CRDT", description: "去中心化，自动合并，学习曲线陡" }
+      ]
+    },
+    {
+      question: "两个用户同时编辑冲突如何解决？",
+      header: "冲突解决",
+      multiSelect: false,
+      options: [
+        { label: "自动合并", description: "用户无感知，可能产生意外结果" },
+        { label: "手动解决", description: "用户控制，增加交互复杂度" },
+        { label: "版本控制", description: "保留历史，需要分支管理" }
+      ]
+    }
+  ]
+})
+```
+
+### Phase 4: Conflict Resolution
+
+**Goal**: Resolve ACTUAL conflicts from Phase 3 answers
+
+**Algorithm**:
+1. Analyze Phase 3 answers for conflicts:
+   - Contradictory choices (e.g., "fast iteration" vs "complex Event Sourcing")
+   - Missing integration (e.g., "Optimistic updates" but no conflict handling)
+   - Implicit dependencies (e.g., "Live cursors" but no auth defined)
+2. Generate clarification questions referencing SPECIFIC Phase 3 choices
+3. AskUserQuestion (max 4 per call, multi-round) → Store to `session.cross_role_decisions`
+4. If NO conflicts: Skip Phase 4 (inform user: "未检测到跨角色冲突，跳过Phase 4")
+
+**Example**:
+```javascript
+AskUserQuestion({
+  questions: [{
+    question: "CRDT 与 UI 回滚期望冲突，如何解决？\n背景：system-architect选择CRDT，ui-designer期望回滚UI",
+    header: "架构冲突",
+    multiSelect: false,
+    options: [
+      { label: "采用 CRDT", description: "保持去中心化，调整UI期望" },
+      { label: "显示合并界面", description: "增加用户交互，展示冲突详情" },
+      { label: "切换到 OT", description: "支持回滚，增加服务器复杂度" }
+    ]
+  }]
+})
+```
+
+### Phase 4.5: Final Clarification
+
+**Purpose**: Ensure no important points missed before generating specification
+
+**Steps**:
+1. Ask initial check:
+   ```javascript
+   AskUserQuestion({
+     questions: [{
+       question: "在生成最终规范之前，是否有前面未澄清的重点需要补充？",
+       header: "补充确认",
+       multiSelect: false,
+       options: [
+         { label: "无需补充", description: "前面的讨论已经足够完整" },
+         { label: "需要补充", description: "还有重要内容需要澄清" }
+       ]
+     }]
+   })
+   ```
+2. If "需要补充":
+   - Analyze user's additional points
+   - Generate progressive questions (not role-bound, interconnected)
+   - AskUserQuestion (max 4 per round) → Store to `session.additional_decisions`
+   - Repeat until user confirms completion
+3. If "无需补充": Proceed to Phase 5
+
+**Progressive Pattern**: Questions interconnected, each round informs next, continue until resolved.
+
+### Phase 5: Generate Specification
+
+**Steps**:
+1. Load all decisions: `intent_context` + `selected_roles` + `role_decisions` + `cross_role_decisions` + `additional_decisions`
+2. Transform Q&A to declarative: Questions → Headers, Answers → CONFIRMED/SELECTED statements
+3. Generate `guidance-specification.md`
+4. Update `workflow-session.json` (metadata only)
+5. Validate: No interrogative sentences, all decisions traceable
+
+---
+
+## Question Guidelines
+
+### Core Principle
+
+**Target**: 开发者（理解技术但需要从用户需求出发）
+
+**Question Structure**: `[业务场景/需求前提] + [技术关注点]`
+**Option Structure**: `标签：[技术方案] + 说明：[业务影响] + [技术权衡]`
+
+### Quality Rules
+
+**MUST Include**:
+- ✅ All questions in Chinese (用中文提问)
+- ✅ 业务场景作为问题前提
+- ✅ 技术选项的业务影响说明
+- ✅ 量化指标和约束条件
+
+**MUST Avoid**:
+- ❌ 纯技术选型无业务上下文
+- ❌ 过度抽象的用户体验问题
+- ❌ 脱离话题的通用架构问题
+
+### Phase-Specific Requirements
+
+| Phase | Focus | Key Requirements |
+|-------|-------|------------------|
+| 1 | 意图理解 | Reference topic keywords, 用户场景、业务约束、优先级 |
+| 2 | 角色推荐 | Intelligent analysis (NOT keyword mapping), explain relevance |
+| 3 | 角色问题 | Reference Phase 1 keywords, concrete options with trade-offs |
+| 4 | 冲突解决 | Reference SPECIFIC Phase 3 choices, explain impact on both roles |
+
+---
+
+## Output & Governance
+
+### Output Template
+
+**File**: `.workflow/active/WFS-{topic}/.brainstorming/guidance-specification.md`
+
+```markdown
+# [Project] - Confirmed Guidance Specification
+
+**Metadata**: [timestamp, type, focus, roles]
+
+## 1. Project Positioning & Goals
+**CONFIRMED Objectives**: [from topic + Phase 1]
+**CONFIRMED Success Criteria**: [from Phase 1 answers]
+
+## 2-N. [Role] Decisions
+### SELECTED Choices
+**[Question topic]**: [User's answer]
+- **Rationale**: [From option description]
+- **Impact**: [Implications]
+
+### Cross-Role Considerations
+**[Conflict resolved]**: [Resolution from Phase 4]
+- **Affected Roles**: [Roles involved]
+
+## Cross-Role Integration
+**CONFIRMED Integration Points**: [API/Data/Auth from multiple roles]
+
+## Risks & Constraints
+**Identified Risks**: [From answers] → Mitigation: [Approach]
+
+## Next Steps
+**⚠️ Automatic Continuation** (when called from auto-parallel):
+- auto-parallel assigns agents for role-specific analysis
+- Each selected role gets conceptual-planning-agent
+- Agents read this guidance-specification.md for context
+
+## Appendix: Decision Tracking
+| Decision ID | Category | Question | Selected | Phase | Rationale |
+|-------------|----------|----------|----------|-------|-----------|
+| D-001 | Intent | [Q] | [A] | 1 | [Why] |
+| D-002 | Roles | [Selected] | [Roles] | 2 | [Why] |
+| D-003+ | [Role] | [Q] | [A] | 3 | [Why] |
+```
+
+### File Structure
+
+```
+.workflow/active/WFS-[topic]/
+├── workflow-session.json              # Metadata ONLY
+├── .process/
+│   └── context-package.json           # Phase 0 output
+└── .brainstorming/
+    └── guidance-specification.md      # Full guidance content
+```
+
+### Session Metadata
+
+```json
+{
+  "session_id": "WFS-{topic-slug}",
+  "type": "brainstorming",
+  "topic": "{original user input}",
+  "selected_roles": ["system-architect", "ui-designer", "product-manager"],
+  "phase_completed": "artifacts",
+  "timestamp": "2025-10-24T10:30:00Z",
+  "count_parameter": 3
+}
+```
+
+**⚠️ Rule**: Session JSON stores ONLY metadata. All guidance content goes to guidance-specification.md.
+
+### Validation Checklist
+
+- ✅ No interrogative sentences (use CONFIRMED/SELECTED)
+- ✅ Every decision traceable to user answer
+- ✅ Cross-role conflicts resolved or documented
+- ✅ Next steps concrete and specific
+- ✅ No content duplication between .json and .md
+
+### Update Mechanism
+
+```
+IF guidance-specification.md EXISTS:
+  Prompt: "Regenerate completely / Update sections / Cancel"
+ELSE:
+  Run full Phase 0-5 flow
+```
+
+### Governance Rules
+
+- All decisions MUST use CONFIRMED/SELECTED (NO "?" in decision sections)
+- Every decision MUST trace to user answer
+- Conflicts MUST be resolved (not marked "TBD")
+- Next steps MUST be actionable
+- Topic preserved as authoritative reference
+
+**CRITICAL**: Guidance is single source of truth for downstream phases. Ambiguity violates governance.

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

@@ -0,0 +1,454 @@
+---
+name: auto-parallel
+description: Parallel brainstorming automation with dynamic role selection and concurrent execution across multiple perspectives
+argument-hint: "topic or challenge description" [--count N]
+allowed-tools: SlashCommand(*), Task(*), TodoWrite(*), Read(*), Write(*), Bash(*), Glob(*)
+---
+
+# Workflow Brainstorm Parallel Auto Command
+
+## Coordinator Role
+
+**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 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
+- Orchestrator **executes these attached tasks** sequentially (Phase 1, 3) or in parallel (Phase 2)
+- After completion, attached tasks are **collapsed** back to high-level phase summary
+- This is **task expansion**, not external delegation
+
+**Execution Model - Auto-Continue Workflow**:
+
+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. **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
+- When Phase 1 (artifacts) finishes executing, automatically load roles and launch Phase 2 agents
+- When Phase 2 (all agents) finishes executing, automatically execute Phase 3 synthesis
+- **⚠️ CONTINUOUS EXECUTION** - Do not stop until all phases complete
+
+## Core Rules
+
+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 execute next pending phase automatically
+5. **Track Progress**: Update TodoWrite dynamically with task attachment/collapse pattern
+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
+
+```bash
+/workflow:brainstorm:auto-parallel "<topic>" [--count N] [--style-skill package-name]
+```
+
+**Recommended Structured Format**:
+```bash
+/workflow:brainstorm:auto-parallel "GOAL: [objective] SCOPE: [boundaries] CONTEXT: [background]" [--count N] [--style-skill package-name]
+```
+
+**Parameters**:
+- `topic` (required): Topic or challenge description (structured format recommended)
+- `--count N` (optional): Number of roles to select (default: 3, max: 9)
+- `--style-skill package-name` (optional): Style SKILL package to load for UI design (located at `.claude/skills/style-{package-name}/`)
+
+## 3-Phase Execution
+
+### Phase 1: Interactive Framework Generation
+
+**Step 1: Execute** - Interactive framework generation via artifacts command
+
+```javascript
+SlashCommand(command="/workflow:brainstorm:artifacts \"{topic}\" --count {N}")
+```
+
+**What It Does**:
+- Topic analysis: Extract challenges, generate task-specific questions
+- Role selection: Recommend count+2 roles, user selects via AskUserQuestion
+- Role questions: Generate 3-4 questions per role, collect user decisions
+- Conflict resolution: Detect and resolve cross-role conflicts
+- Guidance generation: Transform Q&A to declarative guidance-specification.md
+
+**Parse Output**:
+- **⚠️ Memory Check**: If `selected_roles[]` already in conversation memory from previous load, skip file read
+- Extract: `selected_roles[]` from workflow-session.json (if not in memory)
+- Extract: `session_id` from workflow-session.json (if not in memory)
+- Verify: guidance-specification.md exists
+
+**Validation**:
+- guidance-specification.md created with confirmed decisions
+- workflow-session.json contains selected_roles[] (metadata only, no content duplication)
+- Session directory `.workflow/active/WFS-{topic}/.brainstorming/` exists
+
+**TodoWrite Update (Phase 1 SlashCommand executed - tasks attached)**:
+```json
+[
+  {"content": "Phase 0: Parameter Parsing", "status": "completed", "activeForm": "Parsing count parameter"},
+  {"content": "Phase 1: Interactive Framework Generation", "status": "in_progress", "activeForm": "Executing artifacts interactive framework"},
+  {"content": "  → Topic analysis and question generation", "status": "in_progress", "activeForm": "Analyzing topic"},
+  {"content": "  → Role selection and user confirmation", "status": "pending", "activeForm": "Selecting roles"},
+  {"content": "  → Role questions and user decisions", "status": "pending", "activeForm": "Collecting role questions"},
+  {"content": "  → Conflict detection and resolution", "status": "pending", "activeForm": "Resolving conflicts"},
+  {"content": "  → Guidance specification generation", "status": "pending", "activeForm": "Generating guidance"},
+  {"content": "Phase 2: Parallel Role Analysis", "status": "pending", "activeForm": "Executing parallel role analysis"},
+  {"content": "Phase 3: Synthesis Integration", "status": "pending", "activeForm": "Executing synthesis integration"}
+]
+```
+
+**Note**: SlashCommand execute **attaches** artifacts' 5 internal tasks. Orchestrator **executes** these tasks sequentially.
+
+**Next Action**: Tasks attached → **Execute Phase 1.1-1.5** sequentially
+
+**TodoWrite Update (Phase 1 completed - tasks collapsed)**:
+```json
+[
+  {"content": "Phase 0: Parameter Parsing", "status": "completed", "activeForm": "Parsing count parameter"},
+  {"content": "Phase 1: Interactive Framework Generation", "status": "completed", "activeForm": "Executing artifacts interactive framework"},
+  {"content": "Phase 2: Parallel Role Analysis", "status": "pending", "activeForm": "Executing parallel role analysis"},
+  {"content": "Phase 3: Synthesis Integration", "status": "pending", "activeForm": "Executing synthesis integration"}
+]
+```
+
+**Note**: Phase 1 tasks completed and collapsed to summary.
+
+**After Phase 1**: Auto-continue to Phase 2 (parallel role agent execution)
+
+---
+
+### Phase 2: Parallel Role Analysis Execution
+
+**For Each Selected Role**:
+```bash
+Task(conceptual-planning-agent): "
+[FLOW_CONTROL]
+
+Execute {role-name} analysis for existing topic framework
+
+## Context Loading
+ASSIGNED_ROLE: {role-name}
+OUTPUT_LOCATION: .workflow/active/WFS-{session}/.brainstorming/{role}/
+TOPIC: {user-provided-topic}
+
+## Flow Control Steps
+1. load_topic_framework → .workflow/active/WFS-{session}/.brainstorming/guidance-specification.md
+2. load_role_template → ~/.claude/workflows/cli-templates/planning-roles/{role}.md
+3. load_session_metadata → .workflow/active/WFS-{session}/workflow-session.json
+4. load_style_skill (ui-designer only, if style_skill_package) → .claude/skills/style-{style_skill_package}/
+
+## Analysis Requirements
+**Primary Reference**: Original user prompt from workflow-session.json is authoritative
+**Framework Source**: Address all discussion points in guidance-specification.md from {role-name} perspective
+**Role Focus**: {role-name} domain expertise aligned with user intent
+**Structured Approach**: Create analysis.md addressing framework discussion points
+**Template Integration**: Apply role template guidelines within framework structure
+
+## Expected Deliverables
+1. **analysis.md** (optionally with analysis-{slug}.md sub-documents)
+2. **Framework Reference**: @../guidance-specification.md
+3. **User Intent Alignment**: Validate against session_context
+
+## Completion Criteria
+- Address each discussion point from guidance-specification.md with {role-name} expertise
+- Provide actionable recommendations from {role-name} perspective within analysis files
+- All output files MUST start with `analysis` prefix (no recommendations.md or other naming)
+- Reference framework document using @ notation for integration
+- Update workflow-session.json with completion status
+"
+```
+
+**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
+- Each agent operates independently reading same guidance-specification.md
+
+**Input**:
+- `selected_roles[]` from Phase 1
+- `session_id` from Phase 1
+- guidance-specification.md path
+
+**Validation**:
+- Each role creates `.workflow/active/WFS-{topic}/.brainstorming/{role}/analysis.md`
+- Optionally with `analysis-{slug}.md` sub-documents (max 5)
+- **File pattern**: `analysis*.md` for globbing
+- **FORBIDDEN**: `recommendations.md` or any non-`analysis` prefixed files
+- All N role analyses completed
+
+**TodoWrite Update (Phase 2 agents executed - tasks attached in parallel)**:
+```json
+[
+  {"content": "Phase 0: Parameter Parsing", "status": "completed", "activeForm": "Parsing count parameter"},
+  {"content": "Phase 1: Interactive Framework Generation", "status": "completed", "activeForm": "Executing artifacts interactive framework"},
+  {"content": "Phase 2: Parallel Role Analysis", "status": "in_progress", "activeForm": "Executing parallel role analysis"},
+  {"content": "  → Execute system-architect analysis", "status": "in_progress", "activeForm": "Executing system-architect analysis"},
+  {"content": "  → Execute ui-designer analysis", "status": "in_progress", "activeForm": "Executing ui-designer analysis"},
+  {"content": "  → Execute product-manager analysis", "status": "in_progress", "activeForm": "Executing product-manager analysis"},
+  {"content": "Phase 3: Synthesis Integration", "status": "pending", "activeForm": "Executing synthesis integration"}
+]
+```
+
+**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
+
+**TodoWrite Update (Phase 2 completed - tasks collapsed)**:
+```json
+[
+  {"content": "Phase 0: Parameter Parsing", "status": "completed", "activeForm": "Parsing count parameter"},
+  {"content": "Phase 1: Interactive Framework Generation", "status": "completed", "activeForm": "Executing artifacts interactive framework"},
+  {"content": "Phase 2: Parallel Role Analysis", "status": "completed", "activeForm": "Executing parallel role analysis"},
+  {"content": "Phase 3: Synthesis Integration", "status": "pending", "activeForm": "Executing synthesis integration"}
+]
+```
+
+**Note**: Phase 2 parallel tasks completed and collapsed to summary.
+
+**After Phase 2**: Auto-continue to Phase 3 (synthesis)
+
+---
+
+### Phase 3: Synthesis Generation
+
+**Step 3: Execute** - Synthesis integration via synthesis command
+
+```javascript
+SlashCommand(command="/workflow:brainstorm:synthesis --session {sessionId}")
+```
+
+**What It Does**:
+- Load original user intent from workflow-session.json
+- Read all role analysis.md files
+- Integrate role insights into synthesis-specification.md
+- Validate alignment with user's original objectives
+
+**Input**: `sessionId` from Phase 1
+
+**Validation**:
+- `.workflow/active/WFS-{topic}/.brainstorming/synthesis-specification.md` exists
+- Synthesis references all role analyses
+
+**TodoWrite Update (Phase 3 SlashCommand executed - tasks attached)**:
+```json
+[
+  {"content": "Phase 0: Parameter Parsing", "status": "completed", "activeForm": "Parsing count parameter"},
+  {"content": "Phase 1: Interactive Framework Generation", "status": "completed", "activeForm": "Executing artifacts interactive framework"},
+  {"content": "Phase 2: Parallel Role Analysis", "status": "completed", "activeForm": "Executing parallel role analysis"},
+  {"content": "Phase 3: Synthesis Integration", "status": "in_progress", "activeForm": "Executing synthesis integration"},
+  {"content": "  → Load role analysis files", "status": "in_progress", "activeForm": "Loading role analyses"},
+  {"content": "  → Integrate insights across roles", "status": "pending", "activeForm": "Integrating insights"},
+  {"content": "  → Generate synthesis specification", "status": "pending", "activeForm": "Generating synthesis"}
+]
+```
+
+**Note**: SlashCommand execute **attaches** synthesis' internal tasks. Orchestrator **executes** these tasks sequentially.
+
+**Next Action**: Tasks attached → **Execute Phase 3.1-3.3** sequentially
+
+**TodoWrite Update (Phase 3 completed - tasks collapsed)**:
+```json
+[
+  {"content": "Phase 0: Parameter Parsing", "status": "completed", "activeForm": "Parsing count parameter"},
+  {"content": "Phase 1: Interactive Framework Generation", "status": "completed", "activeForm": "Executing artifacts interactive framework"},
+  {"content": "Phase 2: Parallel Role Analysis", "status": "completed", "activeForm": "Executing parallel role analysis"},
+  {"content": "Phase 3: Synthesis Integration", "status": "completed", "activeForm": "Executing synthesis integration"}
+]
+```
+
+**Note**: Phase 3 tasks completed and collapsed to summary.
+
+**Return to User**:
+```
+Brainstorming complete for session: {sessionId}
+Roles analyzed: {count}
+Synthesis: .workflow/active/WFS-{topic}/.brainstorming/synthesis-specification.md
+
+✅ Next Steps:
+1. /workflow:concept-clarify --session {sessionId}  # Optional refinement
+2. /workflow:plan --session {sessionId}  # Generate implementation plan
+```
+
+## TodoWrite Pattern
+
+**Core Concept**: Dynamic task attachment and collapse for parallel brainstorming workflow with interactive framework generation and concurrent role analysis.
+
+### Key Principles
+
+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
+   - Phase 3: `/workflow:brainstorm:synthesis` attaches 3 internal tasks (Phase 3.1-3.3)
+   - First attached task marked as `in_progress`, others as `pending`
+   - Orchestrator **executes** these attached tasks (sequentially for Phase 1, 3; in parallel for Phase 2)
+
+2. **Task Collapse** (after sub-tasks complete):
+   - Remove detailed sub-tasks from TodoWrite
+   - **Collapse** to high-level phase summary
+   - Example: Phase 1.1-1.5 collapse to "Execute artifacts interactive framework generation: completed"
+   - Phase 2: Multiple role tasks collapse to "Execute parallel role analysis: completed"
+   - Phase 3: Synthesis tasks collapse to "Execute synthesis integration: completed"
+   - Maintains clean orchestrator-level view
+
+3. **Continuous Execution**:
+   - After collapse, automatically proceed to next pending phase
+   - No user intervention required between phases
+   - TodoWrite dynamically reflects current execution state
+
+**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
+
+- **Phase 1**: Interactive framework generation with user Q&A (SlashCommand attachment)
+- **Phase 2**: Parallel role analysis execution with N concurrent agents (Task agent attachments)
+- **Phase 3**: Cross-role synthesis integration (SlashCommand attachment)
+- **Dynamic Role Count**: `--count N` parameter determines number of Phase 2 parallel tasks (default: 3, max: 9)
+- **Mixed Execution**: Sequential (Phase 1, 3) and Parallel (Phase 2) task execution
+
+
+## Input Processing
+
+**Count Parameter Parsing**:
+```javascript
+// Extract --count from user input
+IF user_input CONTAINS "--count":
+    EXTRACT count_value FROM "--count N" pattern
+    IF count_value > 9:
+        count_value = 9  // Cap at maximum 9 roles
+ELSE:
+    count_value = 3  // Default to 3 roles
+
+// Pass to artifacts command
+EXECUTE: /workflow:brainstorm:artifacts "{topic}" --count {count_value}
+```
+
+**Style-Skill Parameter Parsing**:
+```javascript
+// Extract --style-skill from user input
+IF user_input CONTAINS "--style-skill":
+    EXTRACT style_skill_name FROM "--style-skill package-name" pattern
+
+    // Validate SKILL package exists
+    skill_path = ".claude/skills/style-{style_skill_name}/SKILL.md"
+    IF file_exists(skill_path):
+        style_skill_package = style_skill_name
+        style_reference_path = ".workflow/reference_style/{style_skill_name}"
+        echo("✓ Style SKILL package found: style-{style_skill_name}")
+        echo("  Design reference: {style_reference_path}")
+    ELSE:
+        echo("⚠ WARNING: Style SKILL package not found: {style_skill_name}")
+        echo("  Expected location: {skill_path}")
+        echo("  Continuing without style reference...")
+        style_skill_package = null
+ELSE:
+    style_skill_package = null
+    echo("No style-skill specified, ui-designer will use default workflow")
+
+// Store for Phase 2 ui-designer context
+CONTEXT_VARS:
+    - style_skill_package: {style_skill_package}
+    - style_reference_path: {style_reference_path}
+```
+
+**Topic Structuring**:
+1. **Already Structured** → Pass directly to artifacts
+   ```
+   User: "GOAL: Build platform SCOPE: 100 users CONTEXT: Real-time"
+   → Pass as-is to artifacts
+   ```
+
+2. **Simple Text** → Pass directly (artifacts handles structuring)
+   ```
+   User: "Build collaboration platform"
+   → artifacts will analyze and structure
+   ```
+
+## Session Management
+
+**⚡ FIRST ACTION**: Check `.workflow/active/` for existing sessions before Phase 1
+
+**Multiple Sessions Support**:
+- Different Claude instances can have different brainstorming sessions
+- If multiple sessions found, prompt user to select
+- If single session found, use it
+- If no session exists, create `WFS-[topic-slug]`
+
+**Session Continuity**:
+- MUST use selected session for all phases
+- Each role's context stored in session directory
+- Session isolation: Each session maintains independent state
+
+## Output Structure
+
+**Phase 1 Output**:
+- `.workflow/active/WFS-{topic}/.brainstorming/guidance-specification.md` (framework content)
+- `.workflow/active/WFS-{topic}/workflow-session.json` (metadata: selected_roles[], topic, timestamps, style_skill_package)
+
+**Phase 2 Output**:
+- `.workflow/active/WFS-{topic}/.brainstorming/{role}/analysis.md` (one per role)
+- `.superdesign/design_iterations/` (ui-designer artifacts, if --style-skill provided)
+
+**Phase 3 Output**:
+- `.workflow/active/WFS-{topic}/.brainstorming/synthesis-specification.md` (integrated analysis)
+
+**⚠️ Storage Separation**: Guidance content in .md files, metadata in .json (no duplication)
+**⚠️ Style References**: When --style-skill provided, workflow-session.json stores style_skill_package name, ui-designer loads from `.claude/skills/style-{package-name}/`
+
+## Available Roles
+
+- data-architect (数据架构师)
+- product-manager (产品经理)
+- product-owner (产品负责人)
+- scrum-master (敏捷教练)
+- subject-matter-expert (领域专家)
+- system-architect (系统架构师)
+- test-strategist (测试策略师)
+- ui-designer (UI 设计师)
+- ux-expert (UX 专家)
+
+**Role Selection**: Handled by artifacts command (intelligent recommendation + user selection)
+
+## Error Handling
+
+- **Role selection failure**: artifacts defaults to product-manager with explanation
+- **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
+
+**File Structure**:
+```
+.workflow/active/WFS-[topic]/
+├── workflow-session.json              # Session metadata ONLY
+└── .brainstorming/
+    ├── guidance-specification.md      # Framework (Phase 1)
+    ├── {role}/
+    │   ├── analysis.md                # Main document (with optional @references)
+    │   └── analysis-{slug}.md         # Section documents (max 5)
+    └── synthesis-specification.md     # Integration (Phase 3)
+```
+
+**Template Source**: `~/.claude/workflows/cli-templates/planning-roles/`
+

.claude/commands/workflow/brainstorm/business-analyst.md

@@ -1,281 +0,0 @@
----
-name: business-analyst
-description: Business analyst perspective brainstorming for process optimization and business efficiency analysis
-usage: /workflow:brainstorm:business-analyst <topic>
-argument-hint: "topic or challenge to analyze from business analysis perspective"
-examples:
-  - /workflow:brainstorm:business-analyst "workflow automation opportunities"
-  - /workflow:brainstorm:business-analyst "business process optimization"
-  - /workflow:brainstorm:business-analyst "cost reduction initiatives"
-allowed-tools: Task(conceptual-planning-agent), TodoWrite(*)
----
-
-## 📊 **Role Overview: Business Analyst**
-
-### Role Definition
-Business process expert responsible for analyzing workflows, identifying requirements, and optimizing business operations to maximize value and efficiency.
-
-### Core Responsibilities
-- **Process Analysis**: Analyze existing business processes for efficiency and improvement opportunities
-- **Requirements Analysis**: Identify and define business requirements and functional specifications
-- **Value Assessment**: Evaluate solution business value and return on investment
-- **Change Management**: Plan and manage business process changes
-
-### Focus Areas
-- **Process Optimization**: Workflows, automation opportunities, efficiency improvements
-- **Data Analysis**: Business metrics, KPI design, performance measurement
-- **Cost-Benefit**: ROI analysis, cost optimization, value creation
-- **Risk Management**: Business risks, compliance requirements, change risks
-
-### Success Metrics
-- Process efficiency improvements (time/cost reduction)
-- Requirements clarity and completeness
-- Stakeholder satisfaction levels
-- ROI achievement and value delivery
-
-## 🧠 **Analysis Framework**
-
-@~/.claude/workflows/brainstorming-principles.md
-@~/.claude/workflows/brainstorming-framework.md
-
-### Key Analysis Questions
-
-**1. Business Process Analysis**
-- What are the bottlenecks and inefficiencies in current business processes?
-- Which processes can be automated or simplified?
-- What are the obstacles in cross-departmental collaboration?
-
-**2. Business Requirements Identification**
-- What are the core needs of stakeholders?
-- What are the business objectives and success metrics?
-- How should functional and non-functional requirements be prioritized?
-
-**3. Value and Benefit Analysis**
-- What is the expected business value of the solution?
-- How does implementation cost compare to expected benefits?
-- What are the risk assessments and mitigation strategies?
-
-**4. Implementation and Change Management**
-- How will changes impact existing processes?
-- What training and adaptation requirements exist?
-- What success metrics and monitoring mechanisms are needed?
-
-## ⚙️ **Execution Protocol**
-
-### Phase 1: Session Detection & Initialization
-```bash
-# Detect active workflow session
-CHECK: .workflow/.active-* marker files
-IF active_session EXISTS:
-    session_id = get_active_session()
-    load_context_from(session_id)
-ELSE:
-    request_user_for_session_creation()
-```
-
-### Phase 2: Directory Structure Creation
-```bash
-# Create business analyst analysis directory
-mkdir -p .workflow/WFS-{topic-slug}/.brainstorming/business-analyst/
-```
-
-### Phase 3: Task Tracking Initialization
-Initialize business analyst perspective analysis tracking:
-```json
-[
-  {"content": "Initialize business analyst brainstorming session", "status": "completed", "activeForm": "Initializing session"},
-  {"content": "Analyze current business processes and workflows", "status": "in_progress", "activeForm": "Analyzing business processes"},
-  {"content": "Identify business requirements and stakeholder needs", "status": "pending", "activeForm": "Identifying requirements"},
-  {"content": "Evaluate cost-benefit and ROI analysis", "status": "pending", "activeForm": "Evaluating cost-benefit"},
-  {"content": "Design process improvements and optimizations", "status": "pending", "activeForm": "Designing improvements"},
-  {"content": "Plan change management and implementation", "status": "pending", "activeForm": "Planning change management"},
-  {"content": "Generate comprehensive business analysis documentation", "status": "pending", "activeForm": "Generating documentation"}
-]
-```
-
-### Phase 4: Conceptual Planning Agent Coordination
-```bash
-Task(conceptual-planning-agent): "
-ASSIGNED_ROLE: business-analyst
-GEMINI_ANALYSIS_REQUIRED: true
-ANALYSIS_DIMENSIONS: 
-  - process_optimization
-  - cost_analysis
-  - efficiency_metrics
-  - workflow_patterns
-
-Conduct business analyst perspective brainstorming for: {topic}
-
-ROLE CONTEXT: Business Analyst
-- Focus Areas: Process optimization, requirements analysis, cost-benefit analysis, change management
-- Analysis Framework: Business-centric approach with emphasis on efficiency and value creation
-- Success Metrics: Process efficiency, cost reduction, stakeholder satisfaction, ROI achievement
-
-USER CONTEXT: {captured_user_requirements_from_session}
-
-ANALYSIS REQUIREMENTS:
-1. Current State Business Analysis
-   - Map existing business processes and workflows
-   - Identify process inefficiencies and bottlenecks
-   - Analyze current costs, resources, and time investments
-   - Assess stakeholder roles and responsibilities
-   - Document pain points and improvement opportunities
-
-2. Requirements Gathering and Analysis
-   - Identify key stakeholders and their needs
-   - Define functional and non-functional business requirements
-   - Prioritize requirements based on business value and urgency
-   - Analyze requirement dependencies and constraints
-   - Create requirements traceability matrix
-
-3. Process Design and Optimization
-   - Design optimized future state processes
-   - Identify automation opportunities and digital solutions
-   - Plan for process standardization and best practices
-   - Design quality gates and control points
-   - Create process documentation and standard operating procedures
-
-4. Cost-Benefit and ROI Analysis
-   - Calculate implementation costs (people, technology, time)
-   - Quantify expected benefits (cost savings, efficiency gains, revenue)
-   - Perform ROI analysis and payback period calculation
-   - Assess intangible benefits (customer satisfaction, employee morale)
-   - Create business case with financial justification
-
-5. Risk Assessment and Mitigation
-   - Identify business, operational, and technical risks
-   - Assess impact and probability of identified risks
-   - Develop risk mitigation strategies and contingency plans
-   - Plan for compliance and regulatory requirements
-   - Design risk monitoring and control measures
-
-6. Change Management and Implementation Planning
-   - Assess organizational change readiness and impact
-   - Design change management strategy and communication plan
-   - Plan training and knowledge transfer requirements
-   - Create implementation timeline with milestones
-   - Design success metrics and monitoring framework
-
-OUTPUT REQUIREMENTS: Save comprehensive analysis to:
-.workflow/WFS-{topic-slug}/.brainstorming/business-analyst/
-- analysis.md (main business analysis and process assessment)
-- requirements.md (detailed business requirements and specifications)
-- business-case.md (cost-benefit analysis and financial justification)
-- implementation-plan.md (change management and implementation strategy)
-
-Apply business analysis expertise to optimize processes and maximize business value."
-```
-
-## 📊 **Output Structure**
-
-### Output Location
-```
-.workflow/WFS-{topic-slug}/.brainstorming/business-analyst/
-├── analysis.md                 # Main business analysis and process assessment
-├── requirements.md             # Detailed business requirements and specifications
-├── business-case.md            # Cost-benefit analysis and financial justification
-└── implementation-plan.md      # Change management and implementation strategy
-```
-
-### Document Templates
-
-#### analysis.md Structure
-```markdown
-# Business Analyst Analysis: {Topic}
-*Generated: {timestamp}*
-
-## Executive Summary
-[Overview of key business analysis findings and recommendations]
-
-## Current State Assessment
-### Business Process Mapping
-### Stakeholder Analysis
-### Performance Metrics Analysis
-### Pain Points and Inefficiencies
-
-## Business Requirements
-### Functional Requirements
-### Non-Functional Requirements
-### Stakeholder Needs Analysis
-### Requirements Prioritization
-
-## Process Optimization Opportunities
-### Automation Potential
-### Workflow Improvements
-### Resource Optimization
-### Quality Enhancements
-
-## Financial Analysis
-### Cost-Benefit Analysis
-### ROI Calculations
-### Budget Requirements
-### Financial Projections
-
-## Risk Assessment
-### Business Risks
-### Operational Risks
-### Mitigation Strategies
-### Contingency Planning
-
-## Implementation Strategy
-### Change Management Plan
-### Training Requirements
-### Timeline and Milestones
-### Success Metrics and KPIs
-
-## Recommendations
-### Immediate Actions (0-3 months)
-### Medium-term Initiatives (3-12 months)
-### Long-term Strategic Goals (12+ months)
-### Resource Requirements
-```
-
-## 🔄 **Session Integration**
-
-### Status Synchronization
-After analysis completion, update `workflow-session.json`:
-```json
-{
-  "phases": {
-    "BRAINSTORM": {
-      "business_analyst": {
-        "status": "completed",
-        "completed_at": "timestamp",
-        "output_directory": ".workflow/WFS-{topic}/.brainstorming/business-analyst/",
-        "key_insights": ["process_optimization", "cost_saving", "efficiency_gain"]
-      }
-    }
-  }
-}
-```
-
-### Collaboration with Other Roles
-Business analyst perspective provides to other roles:
-- **Business requirements and constraints** → Product Manager
-- **Process technology requirements** → System Architect
-- **Business process interface needs** → UI Designer
-- **Business data requirements** → Data Architect
-- **Business security requirements** → Security Expert
-
-## ✅ **Quality Standards**
-
-### Required Analysis Elements
-- [ ] Detailed business process mapping
-- [ ] Clear requirements specifications and priorities
-- [ ] Quantified cost-benefit analysis
-- [ ] Comprehensive risk assessment
-- [ ] Actionable implementation plan
-
-### Business Analysis Principles Checklist
-- [ ] Value-oriented: Focus on business value creation
-- [ ] Data-driven: Analysis based on facts and data
-- [ ] Holistic thinking: Consider entire business ecosystem
-- [ ] Risk awareness: Identify and manage various risks
-- [ ] Sustainability: Long-term maintainability and improvement
-
-### Analysis Quality Metrics
-- [ ] Requirements completeness and accuracy
-- [ ] Quantified benefits from process optimization
-- [ ] Comprehensiveness of risk assessment
-- [ ] Feasibility of implementation plan
-- [ ] Stakeholder satisfaction levels

.claude/commands/workflow/brainstorm/data-architect.md

@@ -1,268 +1,220 @@
 ---
 name: data-architect
-description: Data architect perspective brainstorming for data modeling, flow, and analytics analysis
-usage: /workflow:brainstorm:data-architect <topic>
-argument-hint: "topic or challenge to analyze from data architecture perspective"
-examples:
-  - /workflow:brainstorm:data-architect "user analytics data pipeline"
-  - /workflow:brainstorm:data-architect "real-time data processing system"
-  - /workflow:brainstorm:data-architect "data warehouse modernization"
-allowed-tools: Task(conceptual-planning-agent), TodoWrite(*)
+description: Generate or update data-architect/analysis.md addressing guidance-specification discussion points for data architecture perspective
+argument-hint: "optional topic - uses existing framework if available"
+allowed-tools: Task(conceptual-planning-agent), TodoWrite(*), Read(*), Write(*)
 ---
 
-## 📊 **Role Overview: Data Architect**
+## 📊 **Data Architect Analysis Generator**
 
-### Role Definition
-Strategic data professional responsible for designing scalable, efficient data architectures that enable data-driven decision making through robust data models, processing pipelines, and analytics platforms.
+### Purpose
+**Specialized command for generating data-architect/analysis.md** that addresses guidance-specification.md discussion points from data architecture perspective. Creates or updates role-specific analysis with framework references.
 
-### Core Responsibilities
-- **Data Model Design**: Create efficient and scalable data models and schemas
-- **Data Flow Design**: Plan data collection, processing, and storage workflows
-- **Data Quality Management**: Ensure data accuracy, completeness, and consistency
-- **Analytics and Insights**: Design data analysis and business intelligence solutions
+### Core Function
+- **Framework-based Analysis**: Address each discussion point in guidance-specification.md
+- **Data Architecture Focus**: Data models, pipelines, governance, and analytics perspective
+- **Update Mechanism**: Create new or update existing analysis.md
+- **Agent Delegation**: Use conceptual-planning-agent for analysis generation
 
-### Focus Areas
-- **Data Modeling**: Relational models, NoSQL, data warehouses, lakehouse architectures
-- **Data Pipelines**: ETL/ELT processes, real-time processing, batch processing
-- **Data Governance**: Data quality, security, privacy, compliance frameworks
-- **Analytics Platforms**: BI tools, machine learning infrastructure, reporting systems
+### Analysis Scope
+- **Data Model Design**: Efficient and scalable data models and schemas
+- **Data Flow Design**: Data collection, processing, and storage workflows
+- **Data Quality Management**: Data accuracy, completeness, and consistency
+- **Analytics and Insights**: Data analysis and business intelligence solutions
 
-### Success Metrics
-- Data quality and consistency metrics
-- Processing performance and throughput
-- Analytics accuracy and business impact
-- Data governance and compliance adherence
+### Role Boundaries & Responsibilities
 
-## 🧠 **Analysis Framework**
+#### **What This Role OWNS (Canonical Data Model - Source of Truth)**
+- **Canonical Data Model**: The authoritative, system-wide data schema representing domain entities and relationships
+- **Entity-Relationship Design**: Defining entities, attributes, relationships, and constraints
+- **Data Normalization & Optimization**: Ensuring data integrity, reducing redundancy, and optimizing storage
+- **Database Schema Design**: Physical database structures, indexes, partitioning strategies
+- **Data Pipeline Architecture**: ETL/ELT processes, data warehousing, and analytics pipelines
+- **Data Governance**: Data quality standards, retention policies, and compliance requirements
 
-@~/.claude/workflows/brainstorming-principles.md
-@~/.claude/workflows/brainstorming-framework.md
+#### **What This Role DOES NOT Own (Defers to Other Roles)**
+- **API Data Contracts**: Public-facing request/response schemas exposed by APIs → Defers to **API Designer**
+- **System Integration Patterns**: How services communicate at the macro level → Defers to **System Architect**
+- **UI Data Presentation**: How data is displayed to users → Defers to **UI Designer**
 
-### Key Analysis Questions
-
-**1. Data Requirements and Sources**
-- What data is needed to support business decisions and analytics?
-- How reliable and high-quality are the available data sources?
-- What is the balance between real-time and historical data needs?
-
-**2. Data Architecture and Storage**
-- What is the most appropriate data storage solution for requirements?
-- How should we design scalable and maintainable data models?
-- What are the optimal data partitioning and indexing strategies?
-
-**3. Data Processing and Workflows**
-- What are the performance requirements for data processing?
-- How should we design fault-tolerant and resilient data pipelines?
-- What data versioning and change management strategies are needed?
-
-**4. Analytics and Reporting**
-- How can we support diverse analytical requirements and use cases?
-- What balance between real-time dashboards and periodic reports is optimal?
-- What self-service analytics and data visualization capabilities are needed?
+#### **Handoff Points**
+- **TO API Designer**: Provides canonical data model that API Designer translates into public API data contracts (as projection/view)
+- **TO System Architect**: Provides data flow requirements and storage constraints to inform system design
+- **FROM System Architect**: Receives system-level integration requirements and scalability constraints
 
 ## ⚙️ **Execution Protocol**
 
-### Phase 1: Session Detection & Initialization
+### Phase 1: Session & Framework Detection
 ```bash
-# Detect active workflow session
-CHECK: .workflow/.active-* marker files
+# Check active session and framework
+CHECK: find .workflow/active/ -name "WFS-*" -type d
 IF active_session EXISTS:
     session_id = get_active_session()
-    load_context_from(session_id)
-ELSE:
-    request_user_for_session_creation()
+    brainstorm_dir = .workflow/active/WFS-{session}/.brainstorming/
+
+    CHECK: brainstorm_dir/guidance-specification.md
+    IF EXISTS:
+        framework_mode = true
+        load_framework = true
+    ELSE:
+        IF topic_provided:
+            framework_mode = false  # Create analysis without framework
+        ELSE:
+            ERROR: "No framework found and no topic provided"
 ```
 
-### Phase 2: Directory Structure Creation
+### Phase 2: Analysis Mode Detection
 ```bash
-# Create data architect analysis directory
-mkdir -p .workflow/WFS-{topic-slug}/.brainstorming/data-architect/
+# Determine execution mode
+IF framework_mode == true:
+    mode = "framework_based_analysis"
+    topic_ref = load_framework_topic()
+    discussion_points = extract_framework_points()
+ELSE:
+    mode = "standalone_analysis"
+    topic_ref = provided_topic
+    discussion_points = generate_basic_structure()
 ```
 
-### Phase 3: Task Tracking Initialization
-Initialize data architect perspective analysis tracking:
-```json
-[
-  {"content": "Initialize data architect brainstorming session", "status": "completed", "activeForm": "Initializing session"},
-  {"content": "Analyze data requirements and sources", "status": "in_progress", "activeForm": "Analyzing data requirements"},
-  {"content": "Design optimal data model and schema", "status": "pending", "activeForm": "Designing data model"},
-  {"content": "Plan data pipeline and processing workflows", "status": "pending", "activeForm": "Planning data pipelines"},
-  {"content": "Evaluate data quality and governance", "status": "pending", "activeForm": "Evaluating data governance"},
-  {"content": "Design analytics and reporting solutions", "status": "pending", "activeForm": "Designing analytics"},
-  {"content": "Generate comprehensive data architecture documentation", "status": "pending", "activeForm": "Generating documentation"}
-]
-```
+### Phase 3: Agent Execution with Flow Control
+**Framework-Based Analysis Generation**
 
-### Phase 4: Conceptual Planning Agent Coordination
 ```bash
 Task(conceptual-planning-agent): "
-Conduct data architect perspective brainstorming for: {topic}
+[FLOW_CONTROL]
 
-ROLE CONTEXT: Data Architect
-- Focus Areas: Data modeling, data flow, storage optimization, analytics infrastructure
-- Analysis Framework: Data-driven approach with emphasis on scalability, quality, and insights
-- Success Metrics: Data quality, processing efficiency, analytics accuracy, scalability
+Execute data-architect analysis for existing topic framework
 
-USER CONTEXT: {captured_user_requirements_from_session}
+## Context Loading
+ASSIGNED_ROLE: data-architect
+OUTPUT_LOCATION: .workflow/active/WFS-{session}/.brainstorming/data-architect/
+ANALYSIS_MODE: {framework_mode ? "framework_based" : "standalone"}
 
-ANALYSIS REQUIREMENTS:
-1. Data Requirements Analysis
-   - Identify all data sources (internal, external, third-party)
-   - Define data collection requirements and constraints
-   - Analyze data volume, velocity, and variety characteristics
-   - Map data lineage and dependencies across systems
+## Flow Control Steps
+1. **load_topic_framework**
+   - Action: Load structured topic discussion framework
+   - Command: Read(.workflow/active/WFS-{session}/.brainstorming/guidance-specification.md)
+   - Output: topic_framework_content
 
-2. Data Model and Schema Design
-   - Design logical and physical data models for optimal performance
-   - Plan database schemas, indexes, and partitioning strategies
-   - Design data relationships and referential integrity constraints
-   - Plan for data archival, retention, and lifecycle management
+2. **load_role_template**
+   - Action: Load data-architect planning template
+   - Command: bash($(cat ~/.claude/workflows/cli-templates/planning-roles/data-architect.md))
+   - Output: role_template_guidelines
 
-3. Data Pipeline Architecture
-   - Design ETL/ELT processes for data ingestion and transformation
-   - Plan real-time and batch processing workflows
-   - Design error handling, monitoring, and alerting mechanisms
-   - Plan for data pipeline scalability and performance optimization
+3. **load_session_metadata**
+   - Action: Load session metadata and existing context
+   - Command: Read(.workflow/active/WFS-{session}/workflow-session.json)
+   - Output: session_context
 
-4. Data Quality and Governance
-   - Establish data quality metrics and validation rules
-   - Design data governance policies and procedures
-   - Plan data security, privacy, and compliance frameworks
-   - Create data cataloging and metadata management strategies
+## Analysis Requirements
+**Framework Reference**: Address all discussion points in guidance-specification.md from data architecture perspective
+**Role Focus**: Data models, pipelines, governance, analytics platforms
+**Structured Approach**: Create analysis.md addressing framework discussion points
+**Template Integration**: Apply role template guidelines within framework structure
 
-5. Analytics and Business Intelligence
-   - Design data warehouse and data mart architectures
-   - Plan for OLAP cubes, reporting, and dashboard requirements
-   - Design self-service analytics and data exploration capabilities
-   - Plan for machine learning and advanced analytics integration
+## Expected Deliverables
+1. **analysis.md**: Comprehensive data architecture analysis addressing all framework discussion points
+2. **Framework Reference**: Include @../guidance-specification.md reference in analysis
 
-6. Performance and Scalability Planning
-   - Analyze current and projected data volumes and growth
-   - Design horizontal and vertical scaling strategies
-   - Plan for high availability and disaster recovery
-   - Optimize query performance and resource utilization
-
-OUTPUT REQUIREMENTS: Save comprehensive analysis to:
-.workflow/WFS-{topic-slug}/.brainstorming/data-architect/
-- analysis.md (main data architecture analysis)
-- data-model.md (data models, schemas, and relationships)
-- pipeline-design.md (data processing and ETL/ELT workflows)
-- governance-plan.md (data quality, security, and governance)
-
-Apply data architecture expertise to create scalable, reliable, and insightful data solutions."
+## Completion Criteria
+- Address each discussion point from guidance-specification.md with data architecture expertise
+- Provide data model designs, pipeline architectures, and governance strategies
+- Include scalability, performance, and quality considerations
+- Reference framework document using @ notation for integration
+"
 ```
 
-## 📊 **Output Specification**
+## 📋 **TodoWrite Integration**
 
-### Output Location
-```
-.workflow/WFS-{topic-slug}/.brainstorming/data-architect/
-├── analysis.md                 # Primary data architecture analysis
-├── data-model.md               # Data models, schemas, and relationships
-├── pipeline-design.md          # Data processing and ETL/ELT workflows
-└── governance-plan.md          # Data quality, security, and governance
+### Workflow Progress Tracking
+```javascript
+TodoWrite({
+  todos: [
+    {
+      content: "Detect active session and locate topic framework",
+      status: "in_progress",
+      activeForm: "Detecting session and framework"
+    },
+    {
+      content: "Load guidance-specification.md and session metadata for context",
+      status: "pending",
+      activeForm: "Loading framework and session context"
+    },
+    {
+      content: "Execute data-architect analysis using conceptual-planning-agent with FLOW_CONTROL",
+      status: "pending",
+      activeForm: "Executing data-architect framework analysis"
+    },
+    {
+      content: "Generate analysis.md addressing all framework discussion points",
+      status: "pending",
+      activeForm: "Generating structured data-architect analysis"
+    },
+    {
+      content: "Update workflow-session.json with data-architect completion status",
+      status: "pending",
+      activeForm: "Updating session metadata"
+    }
+  ]
+});
 ```
 
-### Document Templates
+## 📊 **Output Structure**
 
-#### analysis.md Structure
+### Framework-Based Analysis
+```
+.workflow/active/WFS-{session}/.brainstorming/data-architect/
+└── analysis.md    # Structured analysis addressing guidance-specification.md discussion points
+```
+
+### Analysis Document Structure
 ```markdown
-# Data Architect Analysis: {Topic}
-*Generated: {timestamp}*
+# Data Architect Analysis: [Topic from Framework]
 
-## Executive Summary
-[Key data architecture findings and recommendations overview]
+## Framework Reference
+**Topic Framework**: @../guidance-specification.md
+**Role Focus**: Data Architecture perspective
 
-## Current Data Landscape
-### Existing Data Sources
-### Current Data Architecture
-### Data Quality Assessment
-### Performance Bottlenecks
+## Discussion Points Analysis
+[Address each point from guidance-specification.md with data architecture expertise]
 
-## Data Requirements Analysis
-### Business Data Needs
-### Technical Data Requirements
-### Data Volume and Growth Projections
-### Real-time vs Batch Processing Needs
+### Core Requirements (from framework)
+[Data architecture perspective on requirements]
 
-## Proposed Data Architecture
-### Data Model Design
-### Storage Architecture
-### Processing Pipeline Design
-### Integration Patterns
+### Technical Considerations (from framework)
+[Data model, pipeline, and storage considerations]
 
-## Data Quality and Governance
-### Data Quality Framework
-### Governance Policies
-### Security and Privacy Controls
-### Compliance Requirements
+### User Experience Factors (from framework)
+[Data access patterns and analytics user experience]
 
-## Analytics and Reporting Strategy
-### Business Intelligence Architecture
-### Self-Service Analytics Design
-### Performance Monitoring
-### Scalability Planning
+### Implementation Challenges (from framework)
+[Data migration, quality, and governance challenges]
 
-## Implementation Roadmap
-### Migration Strategy
-### Technology Stack Recommendations
-### Resource Requirements
-### Risk Mitigation Plan
+### Success Metrics (from framework)
+[Data quality metrics and analytics success criteria]
+
+## Data Architecture Specific Recommendations
+[Role-specific data architecture recommendations and solutions]
+
+---
+*Generated by data-architect analysis addressing structured framework*
 ```
 
 ## 🔄 **Session Integration**
 
-### Status Synchronization
-Upon completion, update `workflow-session.json`:
+### Completion Status Update
 ```json
 {
-  "phases": {
-    "BRAINSTORM": {
-      "data_architect": {
-        "status": "completed",
-        "completed_at": "timestamp",
-        "output_directory": ".workflow/WFS-{topic}/.brainstorming/data-architect/",
-        "key_insights": ["data_model_optimization", "pipeline_architecture", "analytics_strategy"]
-      }
-    }
+  "data_architect": {
+    "status": "completed",
+    "framework_addressed": true,
+    "output_location": ".workflow/active/WFS-{session}/.brainstorming/data-architect/analysis.md",
+    "framework_reference": "@../guidance-specification.md"
   }
 }
 ```
 
-### Cross-Role Collaboration
-Data architect perspective provides:
-- **Data Storage Requirements** → System Architect
-- **Analytics Data Requirements** → Product Manager
-- **Data Visualization Specifications** → UI Designer
-- **Data Security Framework** → Security Expert
-- **Feature Data Requirements** → Feature Planner
-
-## ✅ **Quality Assurance**
-
-### Required Architecture Elements
-- [ ] Comprehensive data model with clear relationships and constraints
-- [ ] Scalable data pipeline design with error handling and monitoring
-- [ ] Data quality framework with validation rules and metrics
-- [ ] Governance plan addressing security, privacy, and compliance
-- [ ] Analytics architecture supporting business intelligence needs
-
-### Data Architecture Principles
-- [ ] **Scalability**: Architecture can handle data volume and velocity growth
-- [ ] **Quality**: Built-in data validation, cleansing, and quality monitoring
-- [ ] **Security**: Data protection, access controls, and privacy compliance
-- [ ] **Performance**: Optimized for query performance and processing efficiency
-- [ ] **Maintainability**: Clear data lineage, documentation, and change management
-
-### Implementation Validation
-- [ ] **Technical Feasibility**: All proposed solutions are technically achievable
-- [ ] **Performance Requirements**: Architecture meets processing and query performance needs
-- [ ] **Cost Effectiveness**: Storage and processing costs are optimized and sustainable
-- [ ] **Governance Compliance**: Meets regulatory and organizational data requirements
-- [ ] **Future Readiness**: Design accommodates anticipated growth and changing needs
-
-### Data Quality Standards
-- [ ] **Accuracy**: Data validation rules ensure correctness and consistency
-- [ ] **Completeness**: Strategies for handling missing data and ensuring coverage
-- [ ] **Timeliness**: Data freshness requirements met through appropriate processing
-- [ ] **Consistency**: Data definitions and formats standardized across systems
-- [ ] **Lineage**: Complete data lineage tracking from source to consumption
+### Integration Points
+- **Framework Reference**: @../guidance-specification.md for structured discussion points
+- **Cross-Role Synthesis**: Data architecture insights available for synthesis-report.md integration
+- **Agent Autonomy**: Independent execution with framework guidance

.claude/commands/workflow/brainstorm/feature-planner.md

@@ -1,263 +0,0 @@
----
-name: planner
-description: Feature planner perspective brainstorming for feature development and planning analysis
-usage: /workflow:brainstorm:feature-planner <topic>
-argument-hint: "topic or challenge to analyze from feature planning perspective"
-examples:
-  - /workflow:brainstorm:feature-planner "user dashboard enhancement"
-  - /workflow:brainstorm:feature-planner "mobile app feature roadmap"
-  - /workflow:brainstorm:feature-planner "integration capabilities planning"
-allowed-tools: Task(conceptual-planning-agent), TodoWrite(*)
----
-
-## 🔧 **角色定义: Feature Planner**
-
-### 核心职责
-- **功能规划**: 设计和规划产品功能的开发路线图
-- **需求转化**: 将业务需求转化为具体的功能规范
-- **优先级排序**: 基于价值和资源平衡功能开发优先级
-- **交付规划**: 制定功能开发和发布时间表
-
-### 关注领域
-- **功能设计**: 功能规范、用户故事、验收标准
-- **开发规划**: 迭代计划、里程碑、依赖关系管理
-- **质量保证**: 测试策略、质量标准、验收流程
-- **发布管理**: 发布策略、版本控制、变更管理
-
-## 🧠 **分析框架**
-
-@~/.claude/workflows/brainstorming-principles.md
-@~/.claude/workflows/brainstorming-framework.md
-
-### 核心分析问题
-1. **功能需求分析**:
-   - 核心功能需求和用户故事？
-   - 功能的MVP和完整版本规划？
-   - 跨功能依赖和集成需求？
-
-2. **技术可行性评估**:
-   - 技术实现的复杂度和挑战？
-   - 现有系统的扩展和改造需求？
-   - 第三方服务和API集成？
-
-3. **开发资源和时间估算**:
-   - 开发工作量和时间预估？
-   - 所需技能和团队配置？
-   - 开发风险和缓解策略？
-
-4. **测试和质量保证**:
-   - 测试策略和测试用例设计？
-   - 质量标准和验收条件？
-   - 用户验收和反馈机制？
-
-## ⚙️ **执行协议**
-
-### Phase 1: 会话检测与初始化
-```bash
-# 自动检测活动会话
-CHECK: .workflow/.active-* marker files
-IF active_session EXISTS:
-    session_id = get_active_session()
-    load_context_from(session_id)
-ELSE:
-    request_user_for_session_creation()
-```
-
-### Phase 2: 目录结构创建
-```bash
-# 创建功能规划师分析目录
-mkdir -p .workflow/WFS-{topic-slug}/.brainstorming/feature-planner/
-```
-
-### Phase 3: TodoWrite 初始化
-设置功能规划师视角分析的任务跟踪：
-```json
-[
-  {"content": "Initialize feature planner brainstorming session", "status": "completed", "activeForm": "Initializing session"},
-  {"content": "Analyze feature requirements and user stories", "status": "in_progress", "activeForm": "Analyzing feature requirements"},
-  {"content": "Design feature architecture and specifications", "status": "pending", "activeForm": "Designing feature architecture"},
-  {"content": "Plan development phases and prioritization", "status": "pending", "activeForm": "Planning development phases"},
-  {"content": "Evaluate testing strategy and quality assurance", "status": "pending", "activeForm": "Evaluating testing strategy"},
-  {"content": "Create implementation timeline and milestones", "status": "pending", "activeForm": "Creating timeline"},
-  {"content": "Generate comprehensive feature planning documentation", "status": "pending", "activeForm": "Generating documentation"}
-]
-```
-
-### Phase 4: 概念规划代理协调
-```bash
-Task(conceptual-planning-agent): "
-Conduct feature planner perspective brainstorming for: {topic}
-
-ROLE CONTEXT: Feature Planner
-- Focus Areas: Feature specification, development planning, quality assurance, delivery management
-- Analysis Framework: Feature-centric approach with emphasis on deliverability and user value
-- Success Metrics: Feature completion, quality standards, user satisfaction, delivery timeline
-
-USER CONTEXT: {captured_user_requirements_from_session}
-
-ANALYSIS REQUIREMENTS:
-1. Feature Requirements Analysis
-   - Break down high-level requirements into specific feature specifications
-   - Create detailed user stories with acceptance criteria
-   - Identify feature dependencies and integration requirements
-   - Map features to user personas and use cases
-   - Define feature scope and boundaries (MVP vs full feature)
-
-2. Feature Architecture and Design
-   - Design feature workflows and user interaction patterns
-   - Plan feature integration with existing system components
-   - Define APIs and data interfaces required
-   - Plan for feature configuration and customization options
-   - Design feature monitoring and analytics capabilities
-
-3. Development Planning and Estimation
-   - Estimate development effort and complexity for each feature
-   - Identify technical risks and implementation challenges
-   - Plan feature development phases and incremental delivery
-   - Define development milestones and checkpoints
-   - Assess resource requirements and team capacity
-
-4. Quality Assurance and Testing Strategy
-   - Design comprehensive testing strategy (unit, integration, E2E)
-   - Create test scenarios and edge case coverage
-   - Plan performance testing and scalability validation
-   - Design user acceptance testing procedures
-   - Plan for accessibility and usability testing
-
-5. Feature Prioritization and Roadmap
-   - Apply prioritization frameworks (MoSCoW, Kano, RICE)
-   - Balance business value with development complexity
-   - Create feature release planning and versioning strategy
-   - Plan for feature flags and gradual rollout
-   - Design feature deprecation and sunset strategies
-
-6. Delivery and Release Management
-   - Plan feature delivery timeline and release schedule
-   - Design change management and deployment strategies
-   - Plan for feature documentation and user training
-   - Create feature success metrics and KPIs
-   - Design post-release monitoring and support plans
-
-OUTPUT REQUIREMENTS: Save comprehensive analysis to:
-.workflow/WFS-{topic-slug}/.brainstorming/feature-planner/
-- analysis.md (main feature analysis and specifications)
-- user-stories.md (detailed user stories and acceptance criteria)
-- development-plan.md (development timeline and resource planning)
-- testing-strategy.md (quality assurance and testing approach)
-
-Apply feature planning expertise to create deliverable, high-quality feature implementations."
-```
-
-## 📊 **输出结构**
-
-### 保存位置
-```
-.workflow/WFS-{topic-slug}/.brainstorming/feature-planner/
-├── analysis.md                 # 主要功能分析和规范
-├── user-stories.md             # 详细用户故事和验收标准
-├── development-plan.md         # 开发时间线和资源规划
-└── testing-strategy.md         # 质量保证和测试方法
-```
-
-### 文档模板
-
-#### analysis.md 结构
-```markdown
-# Feature Planner Analysis: {Topic}
-*Generated: {timestamp}*
-
-## Executive Summary
-[核心功能规划发现和建议概述]
-
-## Feature Requirements Overview
-### Core Feature Specifications
-### User Story Summary
-### Feature Scope and Boundaries
-### Success Criteria and KPIs
-
-## Feature Architecture Design
-### Feature Components and Modules
-### Integration Points and Dependencies
-### APIs and Data Interfaces
-### Configuration and Customization
-
-## Development Planning
-### Effort Estimation and Complexity
-### Development Phases and Milestones
-### Resource Requirements
-### Risk Assessment and Mitigation
-
-## Quality Assurance Strategy
-### Testing Approach and Coverage
-### Performance and Scalability Testing
-### User Acceptance Testing Plan
-### Quality Gates and Standards
-
-## Delivery and Release Strategy
-### Release Planning and Versioning
-### Deployment Strategy
-### Feature Rollout Plan
-### Post-Release Support
-
-## Feature Prioritization
-### Priority Matrix (High/Medium/Low)
-### Business Value Assessment
-### Development Complexity Analysis
-### Recommended Implementation Order
-
-## Implementation Roadmap
-### Phase 1: Core Features (Weeks 1-4)
-### Phase 2: Enhanced Features (Weeks 5-8)
-### Phase 3: Advanced Features (Weeks 9-12)
-### Continuous Improvement Plan
-```
-
-## 🔄 **会话集成**
-
-### 状态同步
-分析完成后，更新 `workflow-session.json`:
-```json
-{
-  "phases": {
-    "BRAINSTORM": {
-      "feature_planner": {
-        "status": "completed",
-        "completed_at": "timestamp",
-        "output_directory": ".workflow/WFS-{topic}/.brainstorming/feature-planner/",
-        "key_insights": ["feature_specification", "development_timeline", "quality_requirement"]
-      }
-    }
-  }
-}
-```
-
-### 与其他角色的协作
-功能规划师视角为其他角色提供：
-- **功能优先级和规划** → Product Manager
-- **技术实现需求** → System Architect
-- **界面功能要求** → UI Designer
-- **数据功能需求** → Data Architect
-- **功能安全需求** → Security Expert
-
-## ✅ **质量标准**
-
-### 必须包含的规划元素
-- [ ] 详细的功能规范和用户故事
-- [ ] 现实的开发时间估算
-- [ ] 全面的测试策略
-- [ ] 明确的质量标准
-- [ ] 可执行的发布计划
-
-### 功能规划原则检查
-- [ ] 用户价值：每个功能都有明确的用户价值
-- [ ] 可测试性：所有功能都有验收标准
-- [ ] 可维护性：考虑长期维护和扩展
-- [ ] 可交付性：计划符合团队能力和资源
-- [ ] 可测量性：有明确的成功指标
-
-### 交付质量评估
-- [ ] 功能完整性和正确性
-- [ ] 性能和稳定性指标
-- [ ] 用户体验和满意度
-- [ ] 代码质量和可维护性
-- [ ] 文档完整性和准确性

.claude/commands/workflow/brainstorm/innovation-lead.md

@@ -1,271 +0,0 @@
----
-name: innovation-lead
-description: Innovation lead perspective brainstorming for emerging technologies and future opportunities analysis
-usage: /workflow:brainstorm:innovation-lead <topic>
-argument-hint: "topic or challenge to analyze from innovation and emerging technology perspective"
-examples:
-  - /workflow:brainstorm:innovation-lead "AI integration opportunities"
-  - /workflow:brainstorm:innovation-lead "future technology trends"
-  - /workflow:brainstorm:innovation-lead "disruptive innovation strategy"
-allowed-tools: Task(conceptual-planning-agent), TodoWrite(*)
----
-
-## 🚀 **角色定义: Innovation Lead**
-
-### 核心职责
-- **趋势识别**: 识别和分析新兴技术趋势和市场机会
-- **创新策略**: 制定创新路线图和技术发展战略
-- **技术评估**: 评估新技术的应用潜力和可行性
-- **未来规划**: 设计面向未来的产品和服务概念
-
-### 关注领域
-- **新兴技术**: AI、区块链、IoT、AR/VR、量子计算等前沿技术
-- **市场趋势**: 行业变革、用户行为演进、商业模式创新
-- **创新机会**: 破坏性创新、蓝海市场、技术融合机会
-- **未来愿景**: 长期技术路线图、概念验证、原型开发
-
-## 🧠 **Analysis Framework**
-
-@~/.claude/workflows/brainstorming-principles.md
-@~/.claude/workflows/brainstorming-framework.md
-
-### 核心分析问题
-1. **技术趋势和机会**:
-   - 哪些新兴技术对我们的行业最有影响？
-   - 技术成熟度和采用时间轴？
-   - 技术融合创造的新机会？
-
-2. **创新潜力评估**:
-   - 破坏性创新的可能性和影响？
-   - 现有解决方案的创新空间？
-   - 未被满足的市场需求？
-
-3. **竞争和市场分析**:
-   - 竞争对手的创新动向？
-   - 市场空白和蓝海机会？
-   - 技术壁垒和先发优势？
-
-4. **实施和风险评估**:
-   - 技术实施的可行性和风险？
-   - 投资需求和预期回报？
-   - 组织创新能力和适应性？
-
-## ⚙️ **Execution Protocol**
-
-### Phase 1: Session Detection & Initialization
-```bash
-# Detect active workflow session
-CHECK: .workflow/.active-* marker files
-IF active_session EXISTS:
-    session_id = get_active_session()
-    load_context_from(session_id)
-ELSE:
-    request_user_for_session_creation()
-```
-
-### Phase 2: Directory Structure Creation
-```bash
-# Create innovation lead analysis directory
-mkdir -p .workflow/WFS-{topic-slug}/.brainstorming/innovation-lead/
-```
-
-### Phase 3: Task Tracking Initialization
-Initialize innovation lead perspective analysis tracking:
-```json
-[
-  {"content": "Initialize innovation lead brainstorming session", "status": "completed", "activeForm": "Initializing session"},
-  {"content": "Research emerging technology trends and opportunities", "status": "in_progress", "activeForm": "Researching technology trends"},
-  {"content": "Analyze innovation potential and market disruption", "status": "pending", "activeForm": "Analyzing innovation potential"},
-  {"content": "Evaluate competitive landscape and positioning", "status": "pending", "activeForm": "Evaluating competitive landscape"},
-  {"content": "Design future-oriented solutions and concepts", "status": "pending", "activeForm": "Designing future solutions"},
-  {"content": "Assess implementation feasibility and roadmap", "status": "pending", "activeForm": "Assessing implementation"},
-  {"content": "Generate comprehensive innovation strategy documentation", "status": "pending", "activeForm": "Generating documentation"}
-]
-```
-
-### Phase 4: Conceptual Planning Agent Coordination
-```bash
-Task(conceptual-planning-agent): "
-ASSIGNED_ROLE: innovation-lead
-GEMINI_ANALYSIS_REQUIRED: true
-ANALYSIS_DIMENSIONS: 
-  - emerging_patterns
-  - technology_trends
-  - disruption_potential
-  - innovation_opportunities
-
-Conduct innovation lead perspective brainstorming for: {topic}
-
-ROLE CONTEXT: Innovation Lead
-- Focus Areas: Emerging technologies, market disruption, future opportunities, innovation strategy
-- Analysis Framework: Forward-thinking approach with emphasis on breakthrough innovation and competitive advantage
-- Success Metrics: Innovation impact, market differentiation, technology adoption, future readiness
-
-USER CONTEXT: {captured_user_requirements_from_session}
-
-ANALYSIS REQUIREMENTS:
-1. Emerging Technology Landscape Analysis
-   - Research current and emerging technology trends relevant to the topic
-   - Analyze technology maturity levels and adoption curves
-   - Identify breakthrough technologies with disruptive potential
-   - Assess technology convergence opportunities and synergies
-   - Map technology evolution timelines and critical milestones
-
-2. Innovation Opportunity Assessment
-   - Identify unmet market needs and whitespace opportunities
-   - Analyze potential for disruptive innovation vs incremental improvement
-   - Assess blue ocean market opportunities and new value propositions
-   - Evaluate cross-industry innovation transfer possibilities
-   - Identify platform and ecosystem innovation opportunities
-
-3. Competitive Intelligence and Market Analysis
-   - Analyze competitor innovation strategies and technology investments
-   - Identify market leaders and emerging disruptors
-   - Assess patent landscapes and intellectual property opportunities
-   - Evaluate startup ecosystem and potential acquisition targets
-   - Analyze venture capital and funding trends in related areas
-
-4. Future Scenario Planning
-   - Design multiple future scenarios based on technology trends
-   - Create technology roadmaps with short, medium, and long-term horizons
-   - Identify potential black swan events and wild card scenarios
-   - Plan for technology convergence and platform shifts
-   - Design adaptive strategies for uncertain futures
-
-5. Innovation Concept Development
-   - Generate breakthrough product and service concepts
-   - Design minimum viable innovation experiments
-   - Create proof-of-concept prototyping strategies
-   - Plan innovation pilot programs and validation approaches
-   - Design scalable innovation frameworks and processes
-
-6. Implementation Strategy and Risk Assessment
-   - Assess organizational innovation readiness and capabilities
-   - Identify required technology investments and partnerships
-   - Evaluate risks including technology, market, and execution risks
-   - Design innovation governance and decision-making frameworks
-   - Plan talent acquisition and capability building strategies
-
-OUTPUT REQUIREMENTS: Save comprehensive analysis to:
-.workflow/WFS-{topic-slug}/.brainstorming/innovation-lead/
-- analysis.md (main innovation analysis and opportunity assessment)
-- technology-roadmap.md (technology trends and future scenarios)
-- innovation-concepts.md (breakthrough ideas and concept development)
-- strategy-implementation.md (innovation strategy and execution plan)
-
-Apply innovation leadership expertise to identify breakthrough opportunities and design future-ready strategies."
-```
-
-## 📊 **输出结构**
-
-### 保存位置
-```
-.workflow/WFS-{topic-slug}/.brainstorming/innovation-lead/
-├── analysis.md                 # 主要创新分析和机会评估
-├── technology-roadmap.md       # 技术趋势和未来场景
-├── innovation-concepts.md      # 突破性想法和概念开发
-└── strategy-implementation.md  # 创新策略和执行计划
-```
-
-### 文档模板
-
-#### analysis.md 结构
-```markdown
-# Innovation Lead Analysis: {Topic}
-*Generated: {timestamp}*
-
-## Executive Summary
-[核心创新机会和战略建议概述]
-
-## Technology Landscape Assessment
-### Emerging Technologies Overview
-### Technology Maturity Analysis
-### Convergence Opportunities
-### Disruptive Potential Assessment
-
-## Innovation Opportunity Analysis
-### Market Whitespace Identification
-### Unmet Needs and Pain Points
-### Disruptive Innovation Potential
-### Blue Ocean Opportunities
-
-## Competitive Intelligence
-### Competitor Innovation Strategies
-### Patent Landscape Analysis
-### Startup Ecosystem Insights
-### Investment and Funding Trends
-
-## Future Scenarios and Trends
-### Short-term Innovations (0-2 years)
-### Medium-term Disruptions (2-5 years)
-### Long-term Transformations (5+ years)
-### Wild Card Scenarios
-
-## Innovation Concepts
-### Breakthrough Ideas
-### Proof-of-Concept Opportunities
-### Platform Innovation Possibilities
-### Ecosystem Partnership Ideas
-
-## Strategic Recommendations
-### Innovation Investment Priorities
-### Technology Partnership Strategy
-### Capability Building Requirements
-### Risk Mitigation Approaches
-
-## Implementation Roadmap
-### Innovation Pilot Programs
-### Technology Validation Milestones
-### Scaling and Commercialization Plan
-### Success Metrics and KPIs
-```
-
-## 🔄 **会话集成**
-
-### 状态同步
-分析完成后，更新 `workflow-session.json`:
-```json
-{
-  "phases": {
-    "BRAINSTORM": {
-      "innovation_lead": {
-        "status": "completed",
-        "completed_at": "timestamp",
-        "output_directory": ".workflow/WFS-{topic}/.brainstorming/innovation-lead/",
-        "key_insights": ["breakthrough_opportunity", "emerging_technology", "disruptive_potential"]
-      }
-    }
-  }
-}
-```
-
-### 与其他角色的协作
-创新领导视角为其他角色提供：
-- **创新机会和趋势** → Product Manager
-- **新技术可行性** → System Architect
-- **未来用户体验趋势** → UI Designer
-- **新兴数据技术** → Data Architect
-- **创新安全挑战** → Security Expert
-
-## ✅ **质量标准**
-
-### 必须包含的创新元素
-- [ ] 全面的技术趋势分析
-- [ ] 明确的创新机会识别
-- [ ] 具体的概念验证方案
-- [ ] 现实的实施路线图
-- [ ] 前瞻性的风险评估
-
-### 创新思维原则检查
-- [ ] 前瞻性：关注未来3-10年趋势
-- [ ] 颠覆性：寻找破坏性创新机会
-- [ ] 系统性：考虑技术生态系统影响
-- [ ] 可行性：平衡愿景与现实可能
-- [ ] 差异化：创造独特竞争优势
-
-### 创新价值评估
-- [ ] 市场影响的潜在规模
-- [ ] 技术可行性和成熟度
-- [ ] 竞争优势的可持续性
-- [ ] 投资回报的时间框架
-- [ ] 组织实施的复杂度

.claude/commands/workflow/brainstorm/product-manager.md

@@ -1,235 +1,200 @@
 ---
 name: product-manager
-description: Product manager perspective brainstorming for user needs and business value analysis
-usage: /workflow:brainstorm:product-manager <topic>
-argument-hint: "topic or challenge to analyze from product management perspective"
-examples:
-  - /workflow:brainstorm:product-manager "user authentication redesign"
-  - /workflow:brainstorm:product-manager "mobile app performance optimization"
-  - /workflow:brainstorm:product-manager "feature prioritization strategy"
-allowed-tools: Task(conceptual-planning-agent), TodoWrite(*)
+description: Generate or update product-manager/analysis.md addressing guidance-specification discussion points for product management perspective
+argument-hint: "optional topic - uses existing framework if available"
+allowed-tools: Task(conceptual-planning-agent), TodoWrite(*), Read(*), Write(*)
 ---
 
-## 🎯 **Role Overview: Product Manager**
+## 🎯 **Product Manager Analysis Generator**
 
-### Role Definition
-Strategic product leader focused on maximizing user value and business impact through data-driven decisions and market-oriented thinking.
+### Purpose
+**Specialized command for generating product-manager/analysis.md** that addresses guidance-specification.md discussion points from product strategy perspective. Creates or updates role-specific analysis with framework references.
 
-### Core Responsibilities
-- **User Needs Analysis**: Identify and validate genuine user problems and requirements
-- **Business Value Assessment**: Quantify commercial impact and return on investment
-- **Market Positioning**: Analyze competitive landscape and identify opportunities
-- **Product Strategy**: Develop roadmaps, priorities, and go-to-market approaches
+### Core Function
+- **Framework-based Analysis**: Address each discussion point in guidance-specification.md
+- **Product Strategy Focus**: User needs, business value, and market positioning
+- **Update Mechanism**: Create new or update existing analysis.md
+- **Agent Delegation**: Use conceptual-planning-agent for analysis generation
 
-### Focus Areas
-- **User Experience**: Journey mapping, satisfaction metrics, conversion optimization
-- **Business Metrics**: ROI, user growth, retention rates, revenue impact
-- **Market Dynamics**: Competitive analysis, differentiation, market trends
-- **Product Lifecycle**: Feature evolution, technical debt management, scalability
-
-### Success Metrics
-- User satisfaction scores and engagement metrics
-- Business KPIs (revenue, growth, retention)
-- Market share and competitive positioning
-- Product adoption and feature utilization rates
-
-## 🧠 **Analysis Framework**
-
-@~/.claude/workflows/brainstorming-principles.md
-@~/.claude/workflows/brainstorming-framework.md
-
-### Key Analysis Questions
-
-**1. User Value Assessment**
-- What genuine user problem does this solve?
-- Who are the target users and what are their core needs?
-- How does this improve the user experience measurably?
-
-**2. Business Impact Evaluation**
-- What are the expected business outcomes?
-- How does the cost-benefit analysis look?
-- What impact will this have on existing workflows?
-
-**3. Market Opportunity Analysis**
-- What gaps exist in current market solutions?
-- What is our unique competitive advantage?
-- Is the timing right for this initiative?
-
-**4. Execution Feasibility**
-- What resources and timeline are required?
-- What are the technical and market risks?
-- Do we have the right team capabilities?
+### Analysis Scope
+- **User Needs Analysis**: Target users, problems, and value propositions
+- **Business Impact Assessment**: ROI, metrics, and commercial outcomes
+- **Market Positioning**: Competitive analysis and differentiation
+- **Product Strategy**: Roadmaps, priorities, and go-to-market approaches
 
 ## ⚙️ **Execution Protocol**
 
-### Phase 1: Session Detection & Initialization
+### Phase 1: Session & Framework Detection
 ```bash
-# Detect active workflow session
-CHECK: .workflow/.active-* marker files
+# Check active session and framework
+CHECK: find .workflow/active/ -name "WFS-*" -type d
 IF active_session EXISTS:
     session_id = get_active_session()
-    load_context_from(session_id)
-ELSE:
-    request_user_for_session_creation()
+    brainstorm_dir = .workflow/active/WFS-{session}/.brainstorming/
+
+    CHECK: brainstorm_dir/guidance-specification.md
+    IF EXISTS:
+        framework_mode = true
+        load_framework = true
+    ELSE:
+        IF topic_provided:
+            framework_mode = false  # Create analysis without framework
+        ELSE:
+            ERROR: "No framework found and no topic provided"
 ```
 
-### Phase 2: Directory Structure Creation
+### Phase 2: Analysis Mode Detection
 ```bash
-# Create product manager analysis directory
-mkdir -p .workflow/WFS-{topic-slug}/.brainstorming/product-manager/
+# Determine execution mode
+IF framework_mode == true:
+    mode = "framework_based_analysis"
+    topic_ref = load_framework_topic()
+    discussion_points = extract_framework_points()
+ELSE:
+    mode = "standalone_analysis"
+    topic_ref = provided_topic
+    discussion_points = generate_basic_structure()
 ```
 
-### Phase 3: Task Tracking Initialization
-Initialize product manager perspective analysis tracking:
-```json
-[
-  {"content": "Initialize product manager brainstorming session", "status": "completed", "activeForm": "Initializing session"},
-  {"content": "Analyze user needs and pain points", "status": "in_progress", "activeForm": "Analyzing user needs"},
-  {"content": "Evaluate business value and impact", "status": "pending", "activeForm": "Evaluating business impact"},
-  {"content": "Assess market opportunities", "status": "pending", "activeForm": "Assessing market opportunities"},
-  {"content": "Develop product strategy recommendations", "status": "pending", "activeForm": "Developing strategy"},
-  {"content": "Create prioritized action plan", "status": "pending", "activeForm": "Creating action plan"},
-  {"content": "Generate comprehensive product analysis", "status": "pending", "activeForm": "Generating analysis"}
-]
-```
+### Phase 3: Agent Execution with Flow Control
+**Framework-Based Analysis Generation**
 
-### Phase 4: Conceptual Planning Agent Coordination
 ```bash
 Task(conceptual-planning-agent): "
-Conduct product management perspective brainstorming for: {topic}
+[FLOW_CONTROL]
 
-ROLE CONTEXT: Product Manager
-- Focus Areas: User needs, business value, market positioning, product strategy
-- Analysis Framework: User-centric approach with business impact assessment
-- Success Metrics: User satisfaction, business growth, market differentiation
+Execute product-manager analysis for existing topic framework
 
-USER CONTEXT: {captured_user_requirements_from_session}
+## Context Loading
+ASSIGNED_ROLE: product-manager
+OUTPUT_LOCATION: .workflow/active/WFS-{session}/.brainstorming/product-manager/
+ANALYSIS_MODE: {framework_mode ? "framework_based" : "standalone"}
 
-ANALYSIS REQUIREMENTS:
-1. User Needs Analysis
-   - Identify core user problems and pain points
-   - Define target user segments and personas
-   - Map user journey and experience gaps
-   - Prioritize user requirements by impact and frequency
+## Flow Control Steps
+1. **load_topic_framework**
+   - Action: Load structured topic discussion framework
+   - Command: Read(.workflow/active/WFS-{session}/.brainstorming/guidance-specification.md)
+   - Output: topic_framework_content
 
-2. Business Value Assessment
-   - Quantify potential business impact (revenue, growth, efficiency)
-   - Analyze cost-benefit ratio and ROI projections
-   - Identify key success metrics and KPIs
-   - Assess risk factors and mitigation strategies
+2. **load_role_template**
+   - Action: Load product-manager planning template
+   - Command: bash($(cat ~/.claude/workflows/cli-templates/planning-roles/product-manager.md))
+   - Output: role_template_guidelines
 
-3. Market Opportunity Analysis
-   - Competitive landscape and gap analysis
-   - Market trends and emerging opportunities
-   - Differentiation strategies and unique value propositions
-   - Go-to-market considerations
+3. **load_session_metadata**
+   - Action: Load session metadata and existing context
+   - Command: Read(.workflow/active/WFS-{session}/workflow-session.json)
+   - Output: session_context
 
-4. Product Strategy Development
-   - Feature prioritization matrix
-   - Product roadmap recommendations
-   - Resource allocation strategies
-   - Implementation timeline and milestones
+## Analysis Requirements
+**Framework Reference**: Address all discussion points in guidance-specification.md from product strategy perspective
+**Role Focus**: User value, business impact, market positioning, product strategy
+**Structured Approach**: Create analysis.md addressing framework discussion points
+**Template Integration**: Apply role template guidelines within framework structure
 
-OUTPUT REQUIREMENTS: Save comprehensive analysis to:
-.workflow/WFS-{topic-slug}/.brainstorming/product-manager/
-- analysis.md (main product management analysis)
-- business-case.md (business justification and metrics)
-- user-research.md (user needs and market insights)
-- roadmap.md (strategic recommendations and timeline)
+## Expected Deliverables
+1. **analysis.md**: Comprehensive product strategy analysis addressing all framework discussion points
+2. **Framework Reference**: Include @../guidance-specification.md reference in analysis
 
-Apply product management expertise to generate actionable insights addressing business goals and user needs."
+## Completion Criteria
+- Address each discussion point from guidance-specification.md with product management expertise
+- Provide actionable business strategies and user value propositions
+- Include market analysis and competitive positioning insights
+- Reference framework document using @ notation for integration
+"
 ```
 
-## 📊 **Output Specification**
+## 📋 **TodoWrite Integration**
 
-### Output Location
-```
-.workflow/WFS-{topic-slug}/.brainstorming/product-manager/
-├── analysis.md                 # Primary product management analysis
-├── business-case.md            # Business justification and metrics
-├── user-research.md            # User research and market insights
-└── roadmap.md                  # Strategic recommendations and timeline
+### Workflow Progress Tracking
+```javascript
+TodoWrite({
+  todos: [
+    {
+      content: "Detect active session and locate topic framework",
+      status: "in_progress",
+      activeForm: "Detecting session and framework"
+    },
+    {
+      content: "Load guidance-specification.md and session metadata for context",
+      status: "pending",
+      activeForm: "Loading framework and session context"
+    },
+    {
+      content: "Execute product-manager analysis using conceptual-planning-agent with FLOW_CONTROL",
+      status: "pending",
+      activeForm: "Executing product-manager framework analysis"
+    },
+    {
+      content: "Generate analysis.md addressing all framework discussion points",
+      status: "pending",
+      activeForm: "Generating structured product-manager analysis"
+    },
+    {
+      content: "Update workflow-session.json with product-manager completion status",
+      status: "pending",
+      activeForm: "Updating session metadata"
+    }
+  ]
+});
 ```
 
-### Document Templates
+## 📊 **Output Structure**
 
-#### analysis.md Structure
+### Framework-Based Analysis
+```
+.workflow/active/WFS-{session}/.brainstorming/product-manager/
+└── analysis.md    # Structured analysis addressing guidance-specification.md discussion points
+```
+
+### Analysis Document Structure
 ```markdown
-# Product Manager Analysis: {Topic}
-*Generated: {timestamp}*
+# Product Manager Analysis: [Topic from Framework]
 
-## Executive Summary
-[Key findings and recommendations overview]
+## Framework Reference
+**Topic Framework**: @../guidance-specification.md
+**Role Focus**: Product Strategy perspective
 
-## User Needs Analysis
-### Target User Segments
-### Core Problems Identified
-### User Journey Mapping
-### Priority Requirements
+## Discussion Points Analysis
+[Address each point from guidance-specification.md with product management expertise]
 
-## Business Impact Assessment
-### Revenue Impact
-### Cost Analysis
-### ROI Projections
-### Risk Assessment
+### Core Requirements (from framework)
+[Product strategy perspective on user needs and requirements]
 
-## Competitive Analysis
-### Market Position
-### Differentiation Opportunities
-### Competitive Advantages
+### Technical Considerations (from framework)
+[Business and technical feasibility considerations]
 
-## Strategic Recommendations
-### Immediate Actions (0-3 months)
-### Medium-term Initiatives (3-12 months)
-### Long-term Vision (12+ months)
+### User Experience Factors (from framework)
+[User value proposition and market positioning analysis]
+
+### Implementation Challenges (from framework)
+[Business execution and go-to-market considerations]
+
+### Success Metrics (from framework)
+[Product success metrics and business KPIs]
+
+## Product Strategy Specific Recommendations
+[Role-specific product management strategies and business solutions]
+
+---
+*Generated by product-manager analysis addressing structured framework*
 ```
 
 ## 🔄 **Session Integration**
 
-### Status Synchronization
-Upon completion, update `workflow-session.json`:
+### Completion Status Update
 ```json
 {
-  "phases": {
-    "BRAINSTORM": {
-      "product_manager": {
-        "status": "completed",
-        "completed_at": "timestamp",
-        "output_directory": ".workflow/WFS-{topic}/.brainstorming/product-manager/",
-        "key_insights": ["user_value_proposition", "business_impact_assessment", "strategic_recommendations"]
-      }
-    }
+  "product_manager": {
+    "status": "completed",
+    "framework_addressed": true,
+    "output_location": ".workflow/active/WFS-{session}/.brainstorming/product-manager/analysis.md",
+    "framework_reference": "@../guidance-specification.md"
   }
 }
 ```
 
-### Cross-Role Collaboration
-Product manager perspective provides:
-- **User Requirements Definition** → UI Designer
-- **Business Constraints and Objectives** → System Architect
-- **Feature Prioritization** → Feature Planner
-- **Market Requirements** → Innovation Lead
-- **Success Metrics** → Business Analyst
-
-## ✅ **Quality Assurance**
-
-### Required Analysis Elements
-- [ ] Clear user value proposition with supporting evidence
-- [ ] Quantified business impact assessment with metrics
-- [ ] Actionable product strategy recommendations
-- [ ] Data-driven priority rankings
-- [ ] Well-defined success criteria and KPIs
-
-### Output Quality Standards
-- [ ] Analysis grounded in real user needs and market data
-- [ ] Business justification with clear logic and assumptions
-- [ ] Recommendations are specific and actionable
-- [ ] Timeline and milestones are realistic and achievable
-- [ ] Risk identification is comprehensive and accurate
-
-### Product Management Principles
-- [ ] **User-Centric**: All decisions prioritize user value and experience
-- [ ] **Data-Driven**: Conclusions supported by metrics and research
-- [ ] **Market-Aware**: Considers competitive landscape and trends
-- [ ] **Business-Focused**: Aligns with commercial objectives and constraints
-- [ ] **Execution-Ready**: Provides clear next steps and success measures
+### Integration Points
+- **Framework Reference**: @../guidance-specification.md for structured discussion points
+- **Cross-Role Synthesis**: Product strategy insights available for synthesis-report.md integration
+- **Agent Autonomy**: Independent execution with framework guidance

.claude/commands/workflow/brainstorm/product-owner.md

@@ -0,0 +1,200 @@
+---
+name: product-owner
+description: Generate or update product-owner/analysis.md addressing guidance-specification discussion points for product ownership perspective
+argument-hint: "optional topic - uses existing framework if available"
+allowed-tools: Task(conceptual-planning-agent), TodoWrite(*), Read(*), Write(*)
+---
+
+## 🎯 **Product Owner Analysis Generator**
+
+### Purpose
+**Specialized command for generating product-owner/analysis.md** that addresses guidance-specification.md discussion points from product backlog and feature prioritization perspective. Creates or updates role-specific analysis with framework references.
+
+### Core Function
+- **Framework-based Analysis**: Address each discussion point in guidance-specification.md
+- **Product Backlog Focus**: Feature prioritization, user stories, and acceptance criteria
+- **Update Mechanism**: Create new or update existing analysis.md
+- **Agent Delegation**: Use conceptual-planning-agent for analysis generation
+
+### Analysis Scope
+- **Backlog Management**: User story creation, refinement, and prioritization
+- **Stakeholder Alignment**: Requirements gathering, value definition, and expectation management
+- **Feature Prioritization**: ROI analysis, MoSCoW method, and value-driven delivery
+- **Acceptance Criteria**: Definition of Done, acceptance testing, and quality standards
+
+## ⚙️ **Execution Protocol**
+
+### Phase 1: Session & Framework Detection
+```bash
+# Check active session and framework
+CHECK: find .workflow/active/ -name "WFS-*" -type d
+IF active_session EXISTS:
+    session_id = get_active_session()
+    brainstorm_dir = .workflow/active/WFS-{session}/.brainstorming/
+
+    CHECK: brainstorm_dir/guidance-specification.md
+    IF EXISTS:
+        framework_mode = true
+        load_framework = true
+    ELSE:
+        IF topic_provided:
+            framework_mode = false  # Create analysis without framework
+        ELSE:
+            ERROR: "No framework found and no topic provided"
+```
+
+### Phase 2: Analysis Mode Detection
+```bash
+# Determine execution mode
+IF framework_mode == true:
+    mode = "framework_based_analysis"
+    topic_ref = load_framework_topic()
+    discussion_points = extract_framework_points()
+ELSE:
+    mode = "standalone_analysis"
+    topic_ref = provided_topic
+    discussion_points = generate_basic_structure()
+```
+
+### Phase 3: Agent Execution with Flow Control
+**Framework-Based Analysis Generation**
+
+```bash
+Task(conceptual-planning-agent): "
+[FLOW_CONTROL]
+
+Execute product-owner analysis for existing topic framework
+
+## Context Loading
+ASSIGNED_ROLE: product-owner
+OUTPUT_LOCATION: .workflow/active/WFS-{session}/.brainstorming/product-owner/
+ANALYSIS_MODE: {framework_mode ? "framework_based" : "standalone"}
+
+## Flow Control Steps
+1. **load_topic_framework**
+   - Action: Load structured topic discussion framework
+   - Command: Read(.workflow/active/WFS-{session}/.brainstorming/guidance-specification.md)
+   - Output: topic_framework_content
+
+2. **load_role_template**
+   - Action: Load product-owner planning template
+   - Command: bash($(cat ~/.claude/workflows/cli-templates/planning-roles/product-owner.md))
+   - Output: role_template_guidelines
+
+3. **load_session_metadata**
+   - Action: Load session metadata and existing context
+   - Command: Read(.workflow/active/WFS-{session}/workflow-session.json)
+   - Output: session_context
+
+## Analysis Requirements
+**Framework Reference**: Address all discussion points in guidance-specification.md from product backlog and feature prioritization perspective
+**Role Focus**: Backlog management, stakeholder alignment, feature prioritization, acceptance criteria
+**Structured Approach**: Create analysis.md addressing framework discussion points
+**Template Integration**: Apply role template guidelines within framework structure
+
+## Expected Deliverables
+1. **analysis.md**: Comprehensive product ownership analysis addressing all framework discussion points
+2. **Framework Reference**: Include @../guidance-specification.md reference in analysis
+
+## Completion Criteria
+- Address each discussion point from guidance-specification.md with product ownership expertise
+- Provide actionable user stories and acceptance criteria definitions
+- Include feature prioritization and stakeholder alignment strategies
+- Reference framework document using @ notation for integration
+"
+```
+
+## 📋 **TodoWrite Integration**
+
+### Workflow Progress Tracking
+```javascript
+TodoWrite({
+  todos: [
+    {
+      content: "Detect active session and locate topic framework",
+      status: "in_progress",
+      activeForm: "Detecting session and framework"
+    },
+    {
+      content: "Load guidance-specification.md and session metadata for context",
+      status: "pending",
+      activeForm: "Loading framework and session context"
+    },
+    {
+      content: "Execute product-owner analysis using conceptual-planning-agent with FLOW_CONTROL",
+      status: "pending",
+      activeForm: "Executing product-owner framework analysis"
+    },
+    {
+      content: "Generate analysis.md addressing all framework discussion points",
+      status: "pending",
+      activeForm: "Generating structured product-owner analysis"
+    },
+    {
+      content: "Update workflow-session.json with product-owner completion status",
+      status: "pending",
+      activeForm: "Updating session metadata"
+    }
+  ]
+});
+```
+
+## 📊 **Output Structure**
+
+### Framework-Based Analysis
+```
+.workflow/active/WFS-{session}/.brainstorming/product-owner/
+└── analysis.md    # Structured analysis addressing guidance-specification.md discussion points
+```
+
+### Analysis Document Structure
+```markdown
+# Product Owner Analysis: [Topic from Framework]
+
+## Framework Reference
+**Topic Framework**: @../guidance-specification.md
+**Role Focus**: Product Backlog & Feature Prioritization perspective
+
+## Discussion Points Analysis
+[Address each point from guidance-specification.md with product ownership expertise]
+
+### Core Requirements (from framework)
+[User story formulation and backlog refinement perspective]
+
+### Technical Considerations (from framework)
+[Technical feasibility and implementation sequencing considerations]
+
+### User Experience Factors (from framework)
+[User value definition and acceptance criteria analysis]
+
+### Implementation Challenges (from framework)
+[Sprint planning, dependency management, and delivery strategies]
+
+### Success Metrics (from framework)
+[Feature adoption, value delivery metrics, and stakeholder satisfaction indicators]
+
+## Product Owner Specific Recommendations
+[Role-specific backlog management and feature prioritization strategies]
+
+---
+*Generated by product-owner analysis addressing structured framework*
+```
+
+## 🔄 **Session Integration**
+
+### Completion Status Update
+```json
+{
+  "product_owner": {
+    "status": "completed",
+    "framework_addressed": true,
+    "output_location": ".workflow/active/WFS-{session}/.brainstorming/product-owner/analysis.md",
+    "framework_reference": "@../guidance-specification.md"
+  }
+}
+```
+
+### Integration Points
+- **Framework Reference**: @../guidance-specification.md for structured discussion points
+- **Cross-Role Synthesis**: Product ownership insights available for synthesis-report.md integration
+- **Agent Autonomy**: Independent execution with framework guidance

.claude/commands/workflow/brainstorm/scrum-master.md

@@ -0,0 +1,200 @@
+---
+name: scrum-master
+description: Generate or update scrum-master/analysis.md addressing guidance-specification discussion points for Agile process perspective
+argument-hint: "optional topic - uses existing framework if available"
+allowed-tools: Task(conceptual-planning-agent), TodoWrite(*), Read(*), Write(*)
+---
+
+## 🎯 **Scrum Master Analysis Generator**
+
+### Purpose
+**Specialized command for generating scrum-master/analysis.md** that addresses guidance-specification.md discussion points from agile process and team collaboration perspective. Creates or updates role-specific analysis with framework references.
+
+### Core Function
+- **Framework-based Analysis**: Address each discussion point in guidance-specification.md
+- **Agile Process Focus**: Sprint planning, team dynamics, and delivery optimization
+- **Update Mechanism**: Create new or update existing analysis.md
+- **Agent Delegation**: Use conceptual-planning-agent for analysis generation
+
+### Analysis Scope
+- **Sprint Planning**: Task breakdown, estimation, and iteration planning
+- **Team Collaboration**: Communication patterns, impediment removal, and facilitation
+- **Process Optimization**: Agile ceremonies, retrospectives, and continuous improvement
+- **Delivery Management**: Velocity tracking, burndown analysis, and release planning
+
+## ⚙️ **Execution Protocol**
+
+### Phase 1: Session & Framework Detection
+```bash
+# Check active session and framework
+CHECK: find .workflow/active/ -name "WFS-*" -type d
+IF active_session EXISTS:
+    session_id = get_active_session()
+    brainstorm_dir = .workflow/active/WFS-{session}/.brainstorming/
+
+    CHECK: brainstorm_dir/guidance-specification.md
+    IF EXISTS:
+        framework_mode = true
+        load_framework = true
+    ELSE:
+        IF topic_provided:
+            framework_mode = false  # Create analysis without framework
+        ELSE:
+            ERROR: "No framework found and no topic provided"
+```
+
+### Phase 2: Analysis Mode Detection
+```bash
+# Determine execution mode
+IF framework_mode == true:
+    mode = "framework_based_analysis"
+    topic_ref = load_framework_topic()
+    discussion_points = extract_framework_points()
+ELSE:
+    mode = "standalone_analysis"
+    topic_ref = provided_topic
+    discussion_points = generate_basic_structure()
+```
+
+### Phase 3: Agent Execution with Flow Control
+**Framework-Based Analysis Generation**
+
+```bash
+Task(conceptual-planning-agent): "
+[FLOW_CONTROL]
+
+Execute scrum-master analysis for existing topic framework
+
+## Context Loading
+ASSIGNED_ROLE: scrum-master
+OUTPUT_LOCATION: .workflow/active/WFS-{session}/.brainstorming/scrum-master/
+ANALYSIS_MODE: {framework_mode ? "framework_based" : "standalone"}
+
+## Flow Control Steps
+1. **load_topic_framework**
+   - Action: Load structured topic discussion framework
+   - Command: Read(.workflow/active/WFS-{session}/.brainstorming/guidance-specification.md)
+   - Output: topic_framework_content
+
+2. **load_role_template**
+   - Action: Load scrum-master planning template
+   - Command: bash($(cat ~/.claude/workflows/cli-templates/planning-roles/scrum-master.md))
+   - Output: role_template_guidelines
+
+3. **load_session_metadata**
+   - Action: Load session metadata and existing context
+   - Command: Read(.workflow/active/WFS-{session}/workflow-session.json)
+   - Output: session_context
+
+## Analysis Requirements
+**Framework Reference**: Address all discussion points in guidance-specification.md from agile process and team collaboration perspective
+**Role Focus**: Sprint planning, team dynamics, process optimization, delivery management
+**Structured Approach**: Create analysis.md addressing framework discussion points
+**Template Integration**: Apply role template guidelines within framework structure
+
+## Expected Deliverables
+1. **analysis.md**: Comprehensive agile process analysis addressing all framework discussion points
+2. **Framework Reference**: Include @../guidance-specification.md reference in analysis
+
+## Completion Criteria
+- Address each discussion point from guidance-specification.md with scrum mastery expertise
+- Provide actionable sprint planning and team facilitation strategies
+- Include process optimization and impediment removal insights
+- Reference framework document using @ notation for integration
+"
+```
+
+## 📋 **TodoWrite Integration**
+
+### Workflow Progress Tracking
+```javascript
+TodoWrite({
+  todos: [
+    {
+      content: "Detect active session and locate topic framework",
+      status: "in_progress",
+      activeForm: "Detecting session and framework"
+    },
+    {
+      content: "Load guidance-specification.md and session metadata for context",
+      status: "pending",
+      activeForm: "Loading framework and session context"
+    },
+    {
+      content: "Execute scrum-master analysis using conceptual-planning-agent with FLOW_CONTROL",
+      status: "pending",
+      activeForm: "Executing scrum-master framework analysis"
+    },
+    {
+      content: "Generate analysis.md addressing all framework discussion points",
+      status: "pending",
+      activeForm: "Generating structured scrum-master analysis"
+    },
+    {
+      content: "Update workflow-session.json with scrum-master completion status",
+      status: "pending",
+      activeForm: "Updating session metadata"
+    }
+  ]
+});
+```
+
+## 📊 **Output Structure**
+
+### Framework-Based Analysis
+```
+.workflow/active/WFS-{session}/.brainstorming/scrum-master/
+└── analysis.md    # Structured analysis addressing guidance-specification.md discussion points
+```
+
+### Analysis Document Structure
+```markdown
+# Scrum Master Analysis: [Topic from Framework]
+
+## Framework Reference
+**Topic Framework**: @../guidance-specification.md
+**Role Focus**: Agile Process & Team Collaboration perspective
+
+## Discussion Points Analysis
+[Address each point from guidance-specification.md with scrum mastery expertise]
+
+### Core Requirements (from framework)
+[Sprint planning and iteration breakdown perspective]
+
+### Technical Considerations (from framework)
+[Technical debt management and process considerations]
+
+### User Experience Factors (from framework)
+[User story refinement and acceptance criteria analysis]
+
+### Implementation Challenges (from framework)
+[Impediment identification and removal strategies]
+
+### Success Metrics (from framework)
+[Velocity tracking, burndown metrics, and team performance indicators]
+
+## Scrum Master Specific Recommendations
+[Role-specific agile process optimization and team facilitation strategies]
+
+---
+*Generated by scrum-master analysis addressing structured framework*
+```
+
+## 🔄 **Session Integration**
+
+### Completion Status Update
+```json
+{
+  "scrum_master": {
+    "status": "completed",
+    "framework_addressed": true,
+    "output_location": ".workflow/active/WFS-{session}/.brainstorming/scrum-master/analysis.md",
+    "framework_reference": "@../guidance-specification.md"
+  }
+}
+```
+
+### Integration Points
+- **Framework Reference**: @../guidance-specification.md for structured discussion points
+- **Cross-Role Synthesis**: Agile process insights available for synthesis-report.md integration
+- **Agent Autonomy**: Independent execution with framework guidance

.claude/commands/workflow/brainstorm/security-expert.md

@@ -1,268 +0,0 @@
----
-name: security-expert
-description: Security expert perspective brainstorming for threat modeling and security architecture analysis
-usage: /workflow:brainstorm:security-expert <topic>
-argument-hint: "topic or challenge to analyze from cybersecurity perspective"
-examples:
-  - /workflow:brainstorm:security-expert "user authentication security review"
-  - /workflow:brainstorm:security-expert "API security architecture"
-  - /workflow:brainstorm:security-expert "data protection compliance strategy"
-allowed-tools: Task(conceptual-planning-agent), TodoWrite(*)
----
-
-## 🔒 **Role Overview: Security Expert**
-
-### Role Definition
-Cybersecurity specialist focused on identifying threats, designing security controls, and ensuring comprehensive protection of systems, data, and users through proactive security architecture and risk management.
-
-### Core Responsibilities
-- **Threat Modeling**: Identify and analyze potential security threats and attack vectors
-- **Security Architecture**: Design robust security controls and defensive measures
-- **Risk Assessment**: Evaluate security risks and develop mitigation strategies
-- **Compliance Management**: Ensure adherence to security standards and regulations
-
-### Focus Areas
-- **Application Security**: Code security, input validation, authentication, authorization
-- **Infrastructure Security**: Network security, system hardening, access controls
-- **Data Protection**: Encryption, privacy controls, data classification, compliance
-- **Operational Security**: Monitoring, incident response, security awareness, procedures
-
-### Success Metrics
-- Vulnerability reduction and remediation rates
-- Security incident prevention and response times
-- Compliance audit results and regulatory adherence
-- Security awareness and training effectiveness
-
-## 🧠 **Analysis Framework**
-
-@~/.claude/workflows/brainstorming-principles.md
-@~/.claude/workflows/brainstorming-framework.md
-
-### Key Analysis Questions
-
-**1. Threat Landscape Assessment**
-- What are the primary threat vectors and attack scenarios?
-- Who are the potential threat actors and what are their motivations?
-- What are the current vulnerabilities and exposure risks?
-
-**2. Security Architecture Design**
-- What security controls and defensive measures are needed?
-- How should we implement defense-in-depth strategies?
-- What authentication and authorization mechanisms are appropriate?
-
-**3. Risk Management and Compliance**
-- What are the regulatory and compliance requirements?
-- How should we prioritize and manage identified security risks?
-- What security policies and procedures need to be established?
-
-**4. Implementation and Operations**
-- How should we integrate security into development and operations?
-- What monitoring and detection capabilities are required?
-- How should we plan for incident response and recovery?
-
-## ⚙️ **Execution Protocol**
-
-### Phase 1: Session Detection & Initialization
-```bash
-# Detect active workflow session
-CHECK: .workflow/.active-* marker files
-IF active_session EXISTS:
-    session_id = get_active_session()
-    load_context_from(session_id)
-ELSE:
-    request_user_for_session_creation()
-```
-
-### Phase 2: Directory Structure Creation
-```bash
-# Create security expert analysis directory
-mkdir -p .workflow/WFS-{topic-slug}/.brainstorming/security-expert/
-```
-
-### Phase 3: Task Tracking Initialization
-Initialize security expert perspective analysis tracking:
-```json
-[
-  {"content": "Initialize security expert brainstorming session", "status": "completed", "activeForm": "Initializing session"},
-  {"content": "Conduct threat modeling and risk assessment", "status": "in_progress", "activeForm": "Conducting threat modeling"},
-  {"content": "Design security architecture and controls", "status": "pending", "activeForm": "Designing security architecture"},
-  {"content": "Evaluate compliance and regulatory requirements", "status": "pending", "activeForm": "Evaluating compliance"},
-  {"content": "Plan security implementation and integration", "status": "pending", "activeForm": "Planning implementation"},
-  {"content": "Design monitoring and incident response", "status": "pending", "activeForm": "Designing monitoring"},
-  {"content": "Generate comprehensive security documentation", "status": "pending", "activeForm": "Generating documentation"}
-]
-```
-
-### Phase 4: Conceptual Planning Agent Coordination
-```bash
-Task(conceptual-planning-agent): "
-Conduct security expert perspective brainstorming for: {topic}
-
-ROLE CONTEXT: Security Expert
-- Focus Areas: Threat modeling, security architecture, risk management, compliance
-- Analysis Framework: Security-first approach with emphasis on defense-in-depth and risk mitigation
-- Success Metrics: Vulnerability reduction, incident prevention, compliance adherence, security maturity
-
-USER CONTEXT: {captured_user_requirements_from_session}
-
-ANALYSIS REQUIREMENTS:
-1. Threat Modeling and Risk Assessment
-   - Identify potential threat actors and their capabilities
-   - Map attack vectors and potential attack paths
-   - Analyze system vulnerabilities and exposure points
-   - Assess business impact and likelihood of security incidents
-
-2. Security Architecture Design
-   - Design authentication and authorization mechanisms
-   - Plan encryption and data protection strategies
-   - Design network security and access controls
-   - Plan security monitoring and logging architecture
-
-3. Application Security Analysis
-   - Review secure coding practices and input validation
-   - Analyze session management and state security
-   - Assess API security and integration points
-   - Plan for secure software development lifecycle
-
-4. Infrastructure and Operations Security
-   - Design system hardening and configuration management
-   - Plan security monitoring and SIEM integration
-   - Design incident response and recovery procedures
-   - Plan security awareness and training programs
-
-5. Compliance and Regulatory Analysis
-   - Identify applicable compliance frameworks (GDPR, SOX, PCI-DSS, etc.)
-   - Map security controls to regulatory requirements
-   - Plan compliance monitoring and audit procedures
-   - Design privacy protection and data handling policies
-
-6. Security Implementation Planning
-   - Prioritize security controls based on risk assessment
-   - Plan phased security implementation approach
-   - Design security testing and validation procedures
-   - Plan ongoing security maintenance and updates
-
-OUTPUT REQUIREMENTS: Save comprehensive analysis to:
-.workflow/WFS-{topic-slug}/.brainstorming/security-expert/
-- analysis.md (main security analysis and threat model)
-- security-architecture.md (security controls and defensive measures)
-- compliance-plan.md (regulatory compliance and policy framework)
-- implementation-guide.md (security implementation and operational procedures)
-
-Apply cybersecurity expertise to create comprehensive security solutions that protect against threats while enabling business objectives."
-```
-
-## 📊 **Output Specification**
-
-### Output Location
-```
-.workflow/WFS-{topic-slug}/.brainstorming/security-expert/
-├── analysis.md                 # Primary security analysis and threat modeling
-├── security-architecture.md    # Security controls and defensive measures
-├── compliance-plan.md          # Regulatory compliance and policy framework
-└── implementation-guide.md     # Security implementation and operational procedures
-```
-
-### Document Templates
-
-#### analysis.md Structure
-```markdown
-# Security Expert Analysis: {Topic}
-*Generated: {timestamp}*
-
-## Executive Summary
-[Key security findings and recommendations overview]
-
-## Threat Landscape Assessment
-### Threat Actor Analysis
-### Attack Vector Identification
-### Vulnerability Assessment
-### Risk Prioritization Matrix
-
-## Security Requirements Analysis
-### Functional Security Requirements
-### Compliance and Regulatory Requirements
-### Business Continuity Requirements
-### Privacy and Data Protection Needs
-
-## Security Architecture Design
-### Authentication and Authorization Framework
-### Data Protection and Encryption Strategy
-### Network Security and Access Controls
-### Monitoring and Detection Capabilities
-
-## Risk Management Strategy
-### Risk Assessment Methodology
-### Risk Mitigation Controls
-### Residual Risk Acceptance Criteria
-### Continuous Risk Monitoring Plan
-
-## Implementation Security Plan
-### Security Control Implementation Priorities
-### Security Testing and Validation Approach
-### Incident Response and Recovery Procedures
-### Security Awareness and Training Program
-
-## Compliance and Governance
-### Regulatory Compliance Framework
-### Security Policy and Procedure Requirements
-### Audit and Assessment Planning
-### Governance and Oversight Structure
-```
-
-## 🔄 **Session Integration**
-
-### Status Synchronization
-Upon completion, update `workflow-session.json`:
-```json
-{
-  "phases": {
-    "BRAINSTORM": {
-      "security_expert": {
-        "status": "completed",
-        "completed_at": "timestamp",
-        "output_directory": ".workflow/WFS-{topic}/.brainstorming/security-expert/",
-        "key_insights": ["threat_model", "security_controls", "compliance_requirements"]
-      }
-    }
-  }
-}
-```
-
-### Cross-Role Collaboration
-Security expert perspective provides:
-- **Security Architecture Requirements** → System Architect
-- **Security Compliance Constraints** → Product Manager
-- **Secure Interface Design Requirements** → UI Designer
-- **Data Protection Requirements** → Data Architect
-- **Security Feature Specifications** → Feature Planner
-
-## ✅ **Quality Assurance**
-
-### Required Security Elements
-- [ ] Comprehensive threat model with identified attack vectors and mitigations
-- [ ] Security architecture design with layered defensive controls
-- [ ] Risk assessment with prioritized mitigation strategies
-- [ ] Compliance framework addressing all relevant regulatory requirements
-- [ ] Implementation plan with security testing and validation procedures
-
-### Security Architecture Principles
-- [ ] **Defense-in-Depth**: Multiple layers of security controls and protective measures
-- [ ] **Least Privilege**: Minimal access rights granted based on need-to-know basis
-- [ ] **Zero Trust**: Verify and validate all access requests regardless of location
-- [ ] **Security by Design**: Security considerations integrated from initial design phase
-- [ ] **Fail Secure**: System failures default to secure state with controlled recovery
-
-### Risk Management Standards
-- [ ] **Threat Coverage**: All identified threats have corresponding mitigation controls
-- [ ] **Risk Tolerance**: Security risks align with organizational risk appetite
-- [ ] **Continuous Monitoring**: Ongoing security monitoring and threat detection capabilities
-- [ ] **Incident Response**: Comprehensive incident response and recovery procedures
-- [ ] **Compliance Adherence**: Full compliance with applicable regulatory frameworks
-
-### Implementation Readiness
-- [ ] **Control Effectiveness**: Security controls are tested and validated for effectiveness
-- [ ] **Integration Planning**: Security solutions integrate with existing infrastructure
-- [ ] **Operational Procedures**: Clear procedures for security operations and maintenance
-- [ ] **Training and Awareness**: Security awareness programs for all stakeholders
-- [ ] **Continuous Improvement**: Framework for ongoing security assessment and enhancement

.claude/commands/workflow/brainstorm/subject-matter-expert.md

@@ -0,0 +1,200 @@
+---
+name: subject-matter-expert
+description: Generate or update subject-matter-expert/analysis.md addressing guidance-specification discussion points for domain expertise perspective
+argument-hint: "optional topic - uses existing framework if available"
+allowed-tools: Task(conceptual-planning-agent), TodoWrite(*), Read(*), Write(*)
+---
+
+## 🎯 **Subject Matter Expert Analysis Generator**
+
+### Purpose
+**Specialized command for generating subject-matter-expert/analysis.md** that addresses guidance-specification.md discussion points from domain knowledge and technical expertise perspective. Creates or updates role-specific analysis with framework references.
+
+### Core Function
+- **Framework-based Analysis**: Address each discussion point in guidance-specification.md
+- **Domain Expertise Focus**: Deep technical knowledge, industry standards, and best practices
+- **Update Mechanism**: Create new or update existing analysis.md
+- **Agent Delegation**: Use conceptual-planning-agent for analysis generation
+
+### Analysis Scope
+- **Domain Knowledge**: Industry-specific expertise, regulatory requirements, and compliance
+- **Technical Standards**: Best practices, design patterns, and architectural guidelines
+- **Risk Assessment**: Technical debt, scalability concerns, and maintenance implications
+- **Knowledge Transfer**: Documentation strategies, training requirements, and expertise sharing
+
+## ⚙️ **Execution Protocol**
+
+### Phase 1: Session & Framework Detection
+```bash
+# Check active session and framework
+CHECK: find .workflow/active/ -name "WFS-*" -type d
+IF active_session EXISTS:
+    session_id = get_active_session()
+    brainstorm_dir = .workflow/active/WFS-{session}/.brainstorming/
+
+    CHECK: brainstorm_dir/guidance-specification.md
+    IF EXISTS:
+        framework_mode = true
+        load_framework = true
+    ELSE:
+        IF topic_provided:
+            framework_mode = false  # Create analysis without framework
+        ELSE:
+            ERROR: "No framework found and no topic provided"
+```
+
+### Phase 2: Analysis Mode Detection
+```bash
+# Determine execution mode
+IF framework_mode == true:
+    mode = "framework_based_analysis"
+    topic_ref = load_framework_topic()
+    discussion_points = extract_framework_points()
+ELSE:
+    mode = "standalone_analysis"
+    topic_ref = provided_topic
+    discussion_points = generate_basic_structure()
+```
+
+### Phase 3: Agent Execution with Flow Control
+**Framework-Based Analysis Generation**
+
+```bash
+Task(conceptual-planning-agent): "
+[FLOW_CONTROL]
+
+Execute subject-matter-expert analysis for existing topic framework
+
+## Context Loading
+ASSIGNED_ROLE: subject-matter-expert
+OUTPUT_LOCATION: .workflow/active/WFS-{session}/.brainstorming/subject-matter-expert/
+ANALYSIS_MODE: {framework_mode ? "framework_based" : "standalone"}
+
+## Flow Control Steps
+1. **load_topic_framework**
+   - Action: Load structured topic discussion framework
+   - Command: Read(.workflow/active/WFS-{session}/.brainstorming/guidance-specification.md)
+   - Output: topic_framework_content
+
+2. **load_role_template**
+   - Action: Load subject-matter-expert planning template
+   - Command: bash($(cat ~/.claude/workflows/cli-templates/planning-roles/subject-matter-expert.md))
+   - Output: role_template_guidelines
+
+3. **load_session_metadata**
+   - Action: Load session metadata and existing context
+   - Command: Read(.workflow/active/WFS-{session}/workflow-session.json)
+   - Output: session_context
+
+## Analysis Requirements
+**Framework Reference**: Address all discussion points in guidance-specification.md from domain expertise and technical standards perspective
+**Role Focus**: Domain knowledge, technical standards, risk assessment, knowledge transfer
+**Structured Approach**: Create analysis.md addressing framework discussion points
+**Template Integration**: Apply role template guidelines within framework structure
+
+## Expected Deliverables
+1. **analysis.md**: Comprehensive domain expertise analysis addressing all framework discussion points
+2. **Framework Reference**: Include @../guidance-specification.md reference in analysis
+
+## Completion Criteria
+- Address each discussion point from guidance-specification.md with subject matter expertise
+- Provide actionable technical standards and best practices recommendations
+- Include risk assessment and compliance considerations
+- Reference framework document using @ notation for integration
+"
+```
+
+## 📋 **TodoWrite Integration**
+
+### Workflow Progress Tracking
+```javascript
+TodoWrite({
+  todos: [
+    {
+      content: "Detect active session and locate topic framework",
+      status: "in_progress",
+      activeForm: "Detecting session and framework"
+    },
+    {
+      content: "Load guidance-specification.md and session metadata for context",
+      status: "pending",
+      activeForm: "Loading framework and session context"
+    },
+    {
+      content: "Execute subject-matter-expert analysis using conceptual-planning-agent with FLOW_CONTROL",
+      status: "pending",
+      activeForm: "Executing subject-matter-expert framework analysis"
+    },
+    {
+      content: "Generate analysis.md addressing all framework discussion points",
+      status: "pending",
+      activeForm: "Generating structured subject-matter-expert analysis"
+    },
+    {
+      content: "Update workflow-session.json with subject-matter-expert completion status",
+      status: "pending",
+      activeForm: "Updating session metadata"
+    }
+  ]
+});
+```
+
+## 📊 **Output Structure**
+
+### Framework-Based Analysis
+```
+.workflow/active/WFS-{session}/.brainstorming/subject-matter-expert/
+└── analysis.md    # Structured analysis addressing guidance-specification.md discussion points
+```
+
+### Analysis Document Structure
+```markdown
+# Subject Matter Expert Analysis: [Topic from Framework]
+
+## Framework Reference
+**Topic Framework**: @../guidance-specification.md
+**Role Focus**: Domain Expertise & Technical Standards perspective
+
+## Discussion Points Analysis
+[Address each point from guidance-specification.md with subject matter expertise]
+
+### Core Requirements (from framework)
+[Domain-specific requirements and industry standards perspective]
+
+### Technical Considerations (from framework)
+[Deep technical analysis, architectural patterns, and best practices]
+
+### User Experience Factors (from framework)
+[Domain-specific usability standards and industry conventions]
+
+### Implementation Challenges (from framework)
+[Technical risks, scalability concerns, and maintenance implications]
+
+### Success Metrics (from framework)
+[Domain-specific KPIs, compliance metrics, and quality standards]
+
+## Subject Matter Expert Specific Recommendations
+[Role-specific technical expertise and industry best practices]
+
+---
+*Generated by subject-matter-expert analysis addressing structured framework*
+```
+
+## 🔄 **Session Integration**
+
+### Completion Status Update
+```json
+{
+  "subject_matter_expert": {
+    "status": "completed",
+    "framework_addressed": true,
+    "output_location": ".workflow/active/WFS-{session}/.brainstorming/subject-matter-expert/analysis.md",
+    "framework_reference": "@../guidance-specification.md"
+  }
+}
+```
+
+### Integration Points
+- **Framework Reference**: @../guidance-specification.md for structured discussion points
+- **Cross-Role Synthesis**: Domain expertise insights available for synthesis-report.md integration
+- **Agent Autonomy**: Independent execution with framework guidance

.claude/commands/workflow/brainstorm/synthesis.md

@@ -1,309 +1,398 @@
 ---
 name: synthesis
-description: Synthesize all brainstorming role perspectives into comprehensive analysis and recommendations
-usage: /workflow:brainstorm:synthesis
-argument-hint: "no arguments required - analyzes existing brainstorming session outputs"
-examples:
-  - /workflow:brainstorm:synthesis
-allowed-tools: Read(*), Write(*), TodoWrite(*), Glob(*)
+description: Clarify and refine role analyses through intelligent Q&A and targeted updates with synthesis agent
+argument-hint: "[optional: --session session-id]"
+allowed-tools: Task(conceptual-planning-agent), TodoWrite(*), Read(*), Write(*), Edit(*), Glob(*), AskUserQuestion(*)
 ---
 
-## 🧩 **Command Overview: Brainstorm Synthesis**
+## Overview
 
-### Core Function
-Cross-role integration command that synthesizes all brainstorming role perspectives into comprehensive strategic analysis, actionable recommendations, and prioritized implementation roadmaps.
+Six-phase workflow to eliminate ambiguities and enhance conceptual depth in role analyses:
 
-### Primary Capabilities
-- **Cross-Role Integration**: Consolidate analysis results from all brainstorming role perspectives
-- **Insight Synthesis**: Identify consensus areas, disagreement points, and breakthrough opportunities
-- **Decision Support**: Generate prioritized recommendations and strategic action plans
-- **Comprehensive Reporting**: Create integrated brainstorming summary reports with implementation guidance
+**Phase 1-2**: Session detection → File discovery → Path preparation
+**Phase 3A**: Cross-role analysis agent → Generate recommendations
+**Phase 4**: User selects enhancements → User answers clarifications (via AskUserQuestion)
+**Phase 5**: Parallel update agents (one per role)
+**Phase 6**: Context package update → Metadata update → Completion report
 
-### Analysis Scope Coverage
-- **Product Management**: User needs, business value, market opportunities
-- **System Architecture**: Technical design, technology selection, implementation feasibility
-- **User Experience**: Interface design, usability, accessibility standards
-- **Data Architecture**: Data models, processing workflows, analytics capabilities
-- **Security Expert**: Threat assessment, security controls, compliance requirements
-- **User Research**: Behavioral insights, needs validation, experience optimization
-- **Business Analysis**: Process optimization, cost-benefit analysis, change management
-- **Innovation Leadership**: Technology trends, innovation opportunities, future planning
-- **Feature Planning**: Development planning, quality assurance, delivery management
+All user interactions use AskUserQuestion tool (max 4 questions per call, multi-round).
 
-## ⚙️ **Execution Protocol**
+**Document Flow**:
+- Input: `[role]/analysis*.md`, `guidance-specification.md`, session metadata
+- Output: Updated `[role]/analysis*.md` with Enhancements + Clarifications sections
 
-### Phase 1: Session Detection & Data Collection
-```bash
-# Detect active brainstorming session
-CHECK: .workflow/.active-* marker files
-IF active_session EXISTS:
-    session_id = get_active_session()
-    load_context_from(session_id)
-ELSE:
-    ERROR: "No active brainstorming session found. Please run role-specific brainstorming commands first."
-    EXIT
+---
+
+## Quick Reference
+
+### Phase Summary
+
+| Phase | Goal | Executor | Output |
+|-------|------|----------|--------|
+| 1 | Session detection | Main flow | session_id, brainstorm_dir |
+| 2 | File discovery | Main flow | role_analysis_paths |
+| 3A | Cross-role analysis | Agent | enhancement_recommendations |
+| 4 | User interaction | Main flow + AskUserQuestion | update_plan |
+| 5 | Document updates | Parallel agents | Updated analysis*.md |
+| 6 | Finalization | Main flow | context-package.json, report |
+
+### AskUserQuestion Pattern
+
+```javascript
+// Enhancement selection (multi-select)
+AskUserQuestion({
+  questions: [{
+    question: "请选择要应用的改进建议",
+    header: "改进选择",
+    multiSelect: true,
+    options: [
+      { label: "EP-001: API Contract", description: "添加详细的请求/响应 schema 定义" },
+      { label: "EP-002: User Intent", description: "明确用户需求优先级和验收标准" }
+    ]
+  }]
+})
+
+// Clarification questions (single-select, multi-round)
+AskUserQuestion({
+  questions: [
+    {
+      question: "MVP 阶段的核心目标是什么？",
+      header: "用户意图",
+      multiSelect: false,
+      options: [
+        { label: "快速验证", description: "最小功能集，快速上线获取反馈" },
+        { label: "技术壁垒", description: "完善架构，为长期发展打基础" },
+        { label: "功能完整", description: "覆盖所有规划功能，延迟上线" }
+      ]
+    }
+  ]
+})
 ```
 
-### Phase 2: Role Output Scanning
-```bash
-# Scan all role brainstorming outputs
-SCAN_DIRECTORY: .workflow/WFS-{session}/.brainstorming/
-COLLECT_OUTPUTS: [
-    product-manager/analysis.md,
-    system-architect/analysis.md,
-    ui-designer/analysis.md,
-    data-architect/analysis.md,
-    security-expert/analysis.md,
-    user-researcher/analysis.md,
-    business-analyst/analysis.md,
-    innovation-lead/analysis.md,
-    feature-planner/analysis.md
-]
-```
+---
+
+## Task Tracking
 
-### Phase 3: Task Tracking Initialization
-Initialize synthesis analysis task tracking:
 ```json
 [
-  {"content": "Initialize brainstorming synthesis session", "status": "completed", "activeForm": "Initializing synthesis"},
-  {"content": "Collect and analyze all role perspectives", "status": "in_progress", "activeForm": "Collecting role analyses"},
-  {"content": "Identify cross-role insights and patterns", "status": "pending", "activeForm": "Identifying insights"},
-  {"content": "Generate consensus and disagreement analysis", "status": "pending", "activeForm": "Analyzing consensus"},
-  {"content": "Create prioritized recommendations matrix", "status": "pending", "activeForm": "Creating recommendations"},
-  {"content": "Generate comprehensive synthesis report", "status": "pending", "activeForm": "Generating synthesis report"},
-  {"content": "Create action plan with implementation priorities", "status": "pending", "activeForm": "Creating action plan"}
+  {"content": "Detect session and validate analyses", "status": "pending", "activeForm": "Detecting session"},
+  {"content": "Discover role analysis file paths", "status": "pending", "activeForm": "Discovering paths"},
+  {"content": "Execute analysis agent (cross-role analysis)", "status": "pending", "activeForm": "Executing analysis"},
+  {"content": "Present enhancements via AskUserQuestion", "status": "pending", "activeForm": "Selecting enhancements"},
+  {"content": "Clarification questions via AskUserQuestion", "status": "pending", "activeForm": "Clarifying"},
+  {"content": "Execute parallel update agents", "status": "pending", "activeForm": "Updating documents"},
+  {"content": "Update context package and metadata", "status": "pending", "activeForm": "Finalizing"}
 ]
 ```
 
-### Phase 4: Cross-Role Analysis Execution
-
-#### 4.1 Data Collection and Preprocessing
-```pseudo
-FOR each role_directory in brainstorming_roles:
-    IF role_directory exists:
-        role_analysis = Read(role_directory + "/analysis.md")
-        role_recommendations = Read(role_directory + "/recommendations.md") IF EXISTS
-        role_insights[role] = extract_key_insights(role_analysis)
-        role_recommendations[role] = extract_recommendations(role_analysis)
-        role_concerns[role] = extract_concerns_risks(role_analysis)
-    END IF
-END FOR
-```
-
-#### 4.2 Cross-Role Insight Analysis
-```pseudo
-# Consensus identification
-consensus_areas = identify_common_themes(role_insights)
-agreement_matrix = create_agreement_matrix(role_recommendations)
-
-# Disagreement analysis
-disagreement_areas = identify_conflicting_views(role_insights)
-tension_points = analyze_role_conflicts(role_recommendations)
-
-# Innovation opportunity extraction
-innovation_opportunities = extract_breakthrough_ideas(role_insights)
-synergy_opportunities = identify_cross_role_synergies(role_insights)
-```
-
-#### 4.3 Priority and Decision Matrix Generation
-```pseudo
-# Create comprehensive evaluation matrix
-FOR each recommendation:
-    impact_score = calculate_business_impact(recommendation, role_insights)
-    feasibility_score = calculate_technical_feasibility(recommendation, role_insights)
-    effort_score = calculate_implementation_effort(recommendation, role_insights)
-    risk_score = calculate_associated_risks(recommendation, role_insights)
-    
-    priority_score = weighted_score(impact_score, feasibility_score, effort_score, risk_score)
-END FOR
-
-SORT recommendations BY priority_score DESC
-```
-
-## 📊 **Output Specification**
-
-### Output Location
-```
-.workflow/WFS-{topic-slug}/.brainstorming/
-├── synthesis-report.md          # Comprehensive synthesis analysis report
-├── recommendations-matrix.md    # Priority recommendation matrix
-├── action-plan.md              # Implementation action plan
-├── consensus-analysis.md       # Consensus and disagreement analysis
-└── brainstorm-summary.json     # Machine-readable synthesis data
-```
-
-### Core Output Documents
-
-#### synthesis-report.md Structure
-```markdown
-# Brainstorming Synthesis Report: {Topic}
-*Generated: {timestamp} | Session: WFS-{topic-slug}*
-
-## Executive Summary
-### Key Findings Overview
-### Strategic Recommendations
-### Implementation Priority
-### Success Metrics
-
-## Participating Perspectives Analysis
-### Roles Analyzed: {list_of_completed_roles}
-### Coverage Assessment: {completeness_percentage}%
-### Analysis Quality Score: {quality_assessment}
-
-## Cross-Role Insights Synthesis
-
-### 🤝 Consensus Areas
-**Strong Agreement (3+ roles)**:
-1. **{consensus_theme_1}**
-   - Supporting roles: {role1, role2, role3}
-   - Key insight: {shared_understanding}
-   - Business impact: {impact_assessment}
-
-2. **{consensus_theme_2}**
-   - Supporting roles: {role1, role2, role4}
-   - Key insight: {shared_understanding}
-   - Business impact: {impact_assessment}
-
-### ⚡ Breakthrough Ideas
-**Innovation Opportunities**:
-1. **{breakthrough_idea_1}**
-   - Origin: {source_role}
-   - Cross-role support: {supporting_roles}
-   - Innovation potential: {potential_assessment}
-
-2. **{breakthrough_idea_2}**
-   - Origin: {source_role}
-   - Cross-role support: {supporting_roles}
-   - Innovation potential: {potential_assessment}
-
-### 🔄 Areas of Disagreement
-**Tension Points Requiring Resolution**:
-1. **{disagreement_area_1}**
-   - Conflicting views: {role1_view} vs {role2_view}
-   - Root cause: {underlying_issue}
-   - Resolution approach: {recommended_resolution}
-
-2. **{disagreement_area_2}**
-   - Conflicting views: {role1_view} vs {role2_view}
-   - Root cause: {underlying_issue}
-   - Resolution approach: {recommended_resolution}
-
-## Comprehensive Recommendations Matrix
-
-### 🎯 High Priority (Immediate Action)
-| Recommendation | Business Impact | Technical Feasibility | Implementation Effort | Risk Level | Supporting Roles |
-|----------------|-----------------|----------------------|---------------------|------------|------------------|
-| {rec_1}        | High           | High                 | Medium              | Low        | PM, Arch, UX     |
-| {rec_2}        | High           | Medium               | Low                 | Medium     | BA, PM, FP       |
-
-### 📋 Medium Priority (Strategic Planning)
-| Recommendation | Business Impact | Technical Feasibility | Implementation Effort | Risk Level | Supporting Roles |
-|----------------|-----------------|----------------------|---------------------|------------|------------------|
-| {rec_3}        | Medium         | High                 | High                | Medium     | Arch, DA, Sec    |
-| {rec_4}        | Medium         | Medium               | Medium              | Low        | UX, UR, PM       |
-
-### 🔬 Research Priority (Future Investigation)
-| Recommendation | Business Impact | Technical Feasibility | Implementation Effort | Risk Level | Supporting Roles |
-|----------------|-----------------|----------------------|---------------------|------------|------------------|
-| {rec_5}        | High           | Unknown              | High                | High       | IL, Arch, PM     |
-| {rec_6}        | Medium         | Low                  | High                | High       | IL, DA, Sec      |
-
-## Implementation Strategy
-
-### Phase 1: Foundation (0-3 months)
-- **Focus**: High-priority, low-effort recommendations
-- **Key Actions**: {action_list}
-- **Success Metrics**: {metrics_list}
-- **Required Resources**: {resource_list}
-
-### Phase 2: Development (3-9 months)
-- **Focus**: Medium-priority strategic initiatives
-- **Key Actions**: {action_list}
-- **Success Metrics**: {metrics_list}
-- **Required Resources**: {resource_list}
-
-### Phase 3: Innovation (9+ months)
-- **Focus**: Research and breakthrough opportunities
-- **Key Actions**: {action_list}
-- **Success Metrics**: {metrics_list}
-- **Required Resources**: {resource_list}
-
-## Risk Assessment and Mitigation
-
-### Critical Risks Identified
-1. **{risk_1}**: {description} | Mitigation: {strategy}
-2. **{risk_2}**: {description} | Mitigation: {strategy}
-
-### Success Factors
-- {success_factor_1}
-- {success_factor_2}
-- {success_factor_3}
-
-## Next Steps and Follow-up
-### Immediate Actions Required
-### Decision Points Needing Resolution
-### Continuous Monitoring Requirements
-### Future Brainstorming Sessions Recommended
-
 ---
-*This synthesis integrates insights from {role_count} perspectives to provide comprehensive strategic guidance.*
+
+## Execution Phases
+
+### Phase 1: Discovery & Validation
+
+1. **Detect Session**: Use `--session` parameter or find `.workflow/active/WFS-*`
+2. **Validate Files**:
+   - `guidance-specification.md` (optional, warn if missing)
+   - `*/analysis*.md` (required, error if empty)
+3. **Load User Intent**: Extract from `workflow-session.json`
+
+### Phase 2: Role Discovery & Path Preparation
+
+**Main flow prepares file paths for Agent**:
+
+1. **Discover Analysis Files**:
+   - Glob: `.workflow/active/WFS-{session}/.brainstorming/*/analysis*.md`
+   - Supports: analysis.md + analysis-{slug}.md (max 5)
+
+2. **Extract Role Information**:
+   - `role_analysis_paths`: Relative paths
+   - `participating_roles`: Role names from directories
+
+3. **Pass to Agent**: session_id, brainstorm_dir, role_analysis_paths, participating_roles
+
+### Phase 3A: Analysis & Enhancement Agent
+
+**Agent executes cross-role analysis**:
+
+```javascript
+Task(conceptual-planning-agent, `
+## Agent Mission
+Analyze role documents, identify conflicts/gaps, generate enhancement recommendations
+
+## Input
+- brainstorm_dir: ${brainstorm_dir}
+- role_analysis_paths: ${role_analysis_paths}
+- participating_roles: ${participating_roles}
+
+## Flow Control Steps
+1. load_session_metadata → Read workflow-session.json
+2. load_role_analyses → Read all analysis files
+3. cross_role_analysis → Identify consensus, conflicts, gaps, ambiguities
+4. generate_recommendations → Format as EP-001, EP-002, ...
+
+## Output Format
+[
+  {
+    "id": "EP-001",
+    "title": "API Contract Specification",
+    "affected_roles": ["system-architect", "api-designer"],
+    "category": "Architecture",
+    "current_state": "High-level API descriptions",
+    "enhancement": "Add detailed contract definitions",
+    "rationale": "Enables precise implementation",
+    "priority": "High"
+  }
+]
+`)
 ```
 
-## 🔄 **Session Integration**
+### Phase 4: User Interaction
+
+**All interactions via AskUserQuestion (Chinese questions)**
+
+#### Step 1: Enhancement Selection
+
+```javascript
+// If enhancements > 4, split into multiple rounds
+const enhancements = [...]; // from Phase 3A
+const BATCH_SIZE = 4;
+
+for (let i = 0; i < enhancements.length; i += BATCH_SIZE) {
+  const batch = enhancements.slice(i, i + BATCH_SIZE);
+
+  AskUserQuestion({
+    questions: [{
+      question: `请选择要应用的改进建议 (第${Math.floor(i/BATCH_SIZE)+1}轮)`,
+      header: "改进选择",
+      multiSelect: true,
+      options: batch.map(ep => ({
+        label: `${ep.id}: ${ep.title}`,
+        description: `影响: ${ep.affected_roles.join(', ')} | ${ep.enhancement}`
+      }))
+    }]
+  })
+
+  // Store selections before next round
+}
+
+// User can also skip: provide "跳过" option
+```
+
+#### Step 2: Clarification Questions
+
+```javascript
+// Generate questions based on 9-category taxonomy scan
+// Categories: User Intent, Requirements, Architecture, UX, Feasibility, Risk, Process, Decisions, Terminology
+
+const clarifications = [...]; // from analysis
+const BATCH_SIZE = 4;
+
+for (let i = 0; i < clarifications.length; i += BATCH_SIZE) {
+  const batch = clarifications.slice(i, i + BATCH_SIZE);
+  const currentRound = Math.floor(i / BATCH_SIZE) + 1;
+  const totalRounds = Math.ceil(clarifications.length / BATCH_SIZE);
+
+  AskUserQuestion({
+    questions: batch.map(q => ({
+      question: q.question,
+      header: q.category.substring(0, 12),
+      multiSelect: false,
+      options: q.options.map(opt => ({
+        label: opt.label,
+        description: opt.description
+      }))
+    }))
+  })
+
+  // Store answers before next round
+}
+```
+
+### Question Guidelines
+
+**Target**: 开发者（理解技术但需要从用户需求出发）
+
+**Question Structure**: `[跨角色分析发现] + [需要澄清的决策点]`
+**Option Structure**: `标签：[具体方案] + 说明：[业务影响] + [技术权衡]`
+
+**9-Category Taxonomy**:
+
+| Category | Focus | Example Question Pattern |
+|----------|-------|--------------------------|
+| User Intent | 用户目标 | "MVP阶段核心目标？" + 验证/壁垒/完整性 |
+| Requirements | 需求细化 | "功能优先级如何排序？" + 核心/增强/可选 |
+| Architecture | 架构决策 | "技术栈选择考量？" + 熟悉度/先进性/成熟度 |
+| UX | 用户体验 | "交互复杂度取舍？" + 简洁/丰富/渐进 |
+| Feasibility | 可行性 | "资源约束下的范围？" + 最小/标准/完整 |
+| Risk | 风险管理 | "风险容忍度？" + 保守/平衡/激进 |
+| Process | 流程规范 | "迭代节奏？" + 快速/稳定/灵活 |
+| Decisions | 决策确认 | "冲突解决方案？" + 方案A/方案B/折中 |
+| Terminology | 术语统一 | "统一使用哪个术语？" + 术语A/术语B |
+
+**Quality Rules**:
+
+**MUST Include**:
+- ✅ All questions in Chinese (用中文提问)
+- ✅ 基于跨角色分析的具体发现
+- ✅ 选项包含业务影响说明
+- ✅ 解决实际的模糊点或冲突
+
+**MUST Avoid**:
+- ❌ 与角色分析无关的通用问题
+- ❌ 重复已在 artifacts 阶段确认的内容
+- ❌ 过于细节的实现级问题
+
+#### Step 3: Build Update Plan
+
+```javascript
+update_plan = {
+  "role1": {
+    "enhancements": ["EP-001", "EP-003"],
+    "clarifications": [
+      {"question": "...", "answer": "...", "category": "..."}
+    ]
+  },
+  "role2": {
+    "enhancements": ["EP-002"],
+    "clarifications": [...]
+  }
+}
+```
+
+### Phase 5: Parallel Document Update Agents
+
+**Execute in parallel** (one agent per role):
+
+```javascript
+// Single message with multiple Task calls for parallelism
+Task(conceptual-planning-agent, `
+## Agent Mission
+Apply enhancements and clarifications to ${role} analysis
+
+## Input
+- role: ${role}
+- analysis_path: ${brainstorm_dir}/${role}/analysis.md
+- enhancements: ${role_enhancements}
+- clarifications: ${role_clarifications}
+- original_user_intent: ${intent}
+
+## Flow Control Steps
+1. load_current_analysis → Read analysis file
+2. add_clarifications_section → Insert Q&A section
+3. apply_enhancements → Integrate into relevant sections
+4. resolve_contradictions → Remove conflicts
+5. enforce_terminology → Align terminology
+6. validate_intent → Verify alignment with user intent
+7. write_updated_file → Save changes
+
+## Output
+Updated ${role}/analysis.md
+`)
+```
+
+**Agent Characteristics**:
+- **Isolation**: Each agent updates exactly ONE role (parallel safe)
+- **Dependencies**: Zero cross-agent dependencies
+- **Validation**: All updates must align with original_user_intent
+
+### Phase 6: Finalization
+
+#### Step 1: Update Context Package
+
+```javascript
+// Sync updated analyses to context-package.json
+const context_pkg = Read(".workflow/active/WFS-{session}/.process/context-package.json")
+
+// Update guidance-specification if exists
+// Update synthesis-specification if exists
+// Re-read all role analysis files
+// Update metadata timestamps
+
+Write(context_pkg_path, JSON.stringify(context_pkg))
+```
+
+#### Step 2: Update Session Metadata
 
-### Status Synchronization
-Upon completion, update `workflow-session.json`:
 ```json
 {
   "phases": {
     "BRAINSTORM": {
-      "status": "completed",
-      "synthesis_completed": true,
+      "status": "clarification_completed",
+      "clarification_completed": true,
       "completed_at": "timestamp",
-      "participating_roles": ["product-manager", "system-architect", "ui-designer", ...],
-      "key_outputs": {
-        "synthesis_report": ".workflow/WFS-{topic}/.brainstorming/synthesis-report.md",
-        "action_plan": ".workflow/WFS-{topic}/.brainstorming/action-plan.md",
-        "recommendations_matrix": ".workflow/WFS-{topic}/.brainstorming/recommendations-matrix.md"
+      "participating_roles": [...],
+      "clarification_results": {
+        "enhancements_applied": ["EP-001", "EP-002"],
+        "questions_asked": 3,
+        "categories_clarified": ["Architecture", "UX"],
+        "roles_updated": ["role1", "role2"]
       },
-      "metrics": {
-        "roles_analyzed": 9,
-        "consensus_areas": 5,
-        "breakthrough_ideas": 3,
-        "high_priority_recommendations": 8,
-        "implementation_phases": 3
+      "quality_metrics": {
+        "user_intent_alignment": "validated",
+        "ambiguity_resolution": "complete",
+        "terminology_consistency": "enforced"
       }
     }
   }
 }
 ```
 
-## ✅ **Quality Assurance**
+#### Step 3: Completion Report
 
-### Required Synthesis Elements
-- [ ] Integration of all available role analyses with comprehensive coverage
-- [ ] Clear identification of consensus areas and disagreement points
-- [ ] Quantified priority recommendation matrix with evaluation criteria
-- [ ] Actionable implementation plan with phased approach
-- [ ] Comprehensive risk assessment with mitigation strategies
+```markdown
+## ✅ Clarification Complete
 
-### Synthesis Analysis Quality Standards
-- [ ] **Completeness**: Integrates all available role analyses without gaps
-- [ ] **Insight Generation**: Identifies cross-role patterns and deep insights
-- [ ] **Actionability**: Provides specific, executable recommendations and next steps
-- [ ] **Balance**: Considers all role perspectives and addresses concerns
-- [ ] **Forward-Looking**: Includes long-term strategic and innovation considerations
+**Enhancements Applied**: EP-001, EP-002, EP-003
+**Questions Answered**: 3/5
+**Roles Updated**: role1, role2, role3
 
-### Output Validation Criteria
-- [ ] **Priority-Based**: Recommendations prioritized using multi-dimensional evaluation
-- [ ] **Resource-Aware**: Implementation plans consider resource and time constraints
-- [ ] **Risk-Managed**: Comprehensive risk assessment with mitigation strategies
-- [ ] **Measurable Success**: Clear success metrics and monitoring frameworks
-- [ ] **Clear Actions**: Specific next steps with assigned responsibilities and timelines
+### Next Steps
+✅ PROCEED: `/workflow:plan --session WFS-{session-id}`
+```
 
-### Integration Excellence Standards
-- [ ] **Cross-Role Synthesis**: Successfully identifies and resolves role perspective conflicts
-- [ ] **Strategic Coherence**: Recommendations form coherent strategic direction
-- [ ] **Implementation Readiness**: Plans are detailed enough for immediate execution
-- [ ] **Stakeholder Alignment**: Addresses needs and concerns of all key stakeholders
-- [ ] **Continuous Improvement**: Establishes framework for ongoing optimization and learning
+---
+
+## Output
+
+**Location**: `.workflow/active/WFS-{session}/.brainstorming/[role]/analysis*.md`
+
+**Updated Structure**:
+```markdown
+## Clarifications
+### Session {date}
+- **Q**: {question} (Category: {category})
+  **A**: {answer}
+
+## {Existing Sections}
+{Refined content based on clarifications}
+```
+
+**Changes**:
+- User intent validated/corrected
+- Requirements more specific/measurable
+- Architecture with rationale
+- Ambiguities resolved, placeholders removed
+- Consistent terminology
+
+---
+
+## Quality Checklist
+
+**Content**:
+- ✅ All role analyses loaded/analyzed
+- ✅ Cross-role analysis (consensus, conflicts, gaps)
+- ✅ 9-category ambiguity scan
+- ✅ Questions prioritized
+
+**Analysis**:
+- ✅ User intent validated
+- ✅ Cross-role synthesis complete
+- ✅ Ambiguities resolved
+- ✅ Terminology consistent
+
+**Documents**:
+- ✅ Clarifications section formatted
+- ✅ Sections reflect answers
+- ✅ No placeholders (TODO/TBD)
+- ✅ Valid Markdown

.claude/commands/workflow/brainstorm/system-architect.md

@@ -1,58 +1,181 @@
 ---
 name: system-architect
-description: System architect perspective brainstorming for technical architecture and scalability analysis
-usage: /workflow:brainstorm:system-architect <topic>
-argument-hint: "topic or challenge to analyze from system architecture perspective"
-examples:
-  - /workflow:brainstorm:system-architect "user authentication redesign"
-  - /workflow:brainstorm:system-architect "microservices migration strategy"
-  - /workflow:brainstorm:system-architect "system performance optimization"
-allowed-tools: Task(conceptual-planning-agent), TodoWrite(*)
+description: Generate or update system-architect/analysis.md addressing guidance-specification discussion points for system architecture perspective
+argument-hint: "optional topic - uses existing framework if available"
+allowed-tools: Task(conceptual-planning-agent), TodoWrite(*), Read(*), Write(*)
 ---
 
-## 🏗️ **Role Overview: System Architect**
+## 🏗️ **System Architect Analysis Generator**
 
-### Role Definition
-Technical leader responsible for designing scalable, maintainable, and high-performance system architectures that align with business requirements and industry best practices.
+### Purpose
+**Specialized command for generating system-architect/analysis.md** that addresses guidance-specification.md discussion points from system architecture perspective. Creates or updates role-specific analysis with framework references.
 
-### Core Responsibilities
-- **Technical Architecture Design**: Create scalable and maintainable system architectures
-- **Technology Selection**: Evaluate and choose appropriate technology stacks and tools
-- **System Integration**: Design inter-system communication and integration patterns
-- **Performance Optimization**: Identify bottlenecks and propose optimization solutions
+### Core Function
+- **Framework-based Analysis**: Address each discussion point in guidance-specification.md
+- **Architecture Focus**: Technical architecture, scalability, and system design perspective
+- **Update Mechanism**: Create new or update existing analysis.md
+- **Agent Delegation**: Use conceptual-planning-agent for analysis generation
 
-### Focus Areas
-- **Scalability**: Capacity planning, load handling, elastic scaling strategies
-- **Reliability**: High availability design, fault tolerance, disaster recovery
-- **Security**: Architectural security, data protection, access control patterns
-- **Maintainability**: Code quality, modular design, technical debt management
+### Analysis Scope
+- **Technical Architecture**: Scalable and maintainable system design
+- **Technology Selection**: Stack evaluation and architectural decisions
+- **Performance & Scalability**: Capacity planning and optimization strategies
+- **Integration Patterns**: System communication and data flow design
 
-### Success Metrics
-- System performance benchmarks (latency, throughput)
-- Availability and uptime metrics
-- Scalability handling capacity growth
-- Technical debt and maintenance efficiency
+### Role Boundaries & Responsibilities
 
-## 🧠 **Analysis Framework**
+#### **What This Role OWNS (Macro-Architecture)**
+- **System-Level Architecture**: Service boundaries, deployment topology, and system composition
+- **Cross-Service Communication Patterns**: Choosing between microservices/monolithic, event-driven/request-response, sync/async patterns
+- **Technology Stack Decisions**: Language, framework, database, and infrastructure choices
+- **Non-Functional Requirements**: Scalability, performance, availability, disaster recovery, and monitoring strategies
+- **Integration Planning**: How systems and services connect at the macro level (not specific API contracts)
 
-@~/.claude/workflows/brainstorming-principles.md
-@~/.claude/workflows/brainstorming-framework.md
+#### **What This Role DOES NOT Own (Defers to Other Roles)**
+- **API Contract Details**: Specific endpoint definitions, URL structures, HTTP methods → Defers to **API Designer**
+- **Data Schemas**: Detailed data model design and entity relationships → Defers to **Data Architect**
+- **UI/UX Design**: Interface design and user experience → Defers to **UX Expert** and **UI Designer**
 
-### Key Analysis Questions
+#### **Handoff Points**
+- **TO API Designer**: Provides architectural constraints (REST vs GraphQL, sync vs async) that define the API design space
+- **TO Data Architect**: Provides system-level data flow requirements and integration patterns
+- **FROM Data Architect**: Receives canonical data model to inform system integration design
 
-**1. Architecture Design Assessment**
-- What are the strengths and limitations of current architecture?
-- How should we design architecture to meet business requirements?
-- What are the trade-offs between microservices vs monolithic approaches?
+## ⚙️ **Execution Protocol**
 
-**2. Technology Selection Strategy**
-- Which technology stack best fits current requirements?
-- What are the risks and benefits of introducing new technologies?
-- How well does team expertise align with technology choices?
+### Phase 1: Session & Framework Detection
+```bash
+# Check active session and framework
+CHECK: find .workflow/active/ -name "WFS-*" -type d
+IF active_session EXISTS:
+    session_id = get_active_session()
+    brainstorm_dir = .workflow/active/WFS-{session}/.brainstorming/
 
-**3. System Integration Planning**
-- How should systems efficiently integrate and communicate?
-- What are the third-party service integration strategies?
+    CHECK: brainstorm_dir/guidance-specification.md
+    IF EXISTS:
+        framework_mode = true
+        load_framework = true
+    ELSE:
+        IF topic_provided:
+            framework_mode = false  # Create analysis without framework
+        ELSE:
+            ERROR: "No framework found and no topic provided"
+```
+
+### Phase 2: Analysis Mode Detection
+```bash
+# Check existing analysis
+CHECK: brainstorm_dir/system-architect/analysis.md
+IF EXISTS:
+    SHOW existing analysis summary
+    ASK: "Analysis exists. Do you want to:"
+    OPTIONS:
+      1. "Update with new insights" → Update existing
+      2. "Replace completely" → Generate new
+      3. "Cancel" → Exit without changes
+ELSE:
+    CREATE new analysis
+```
+
+### Phase 3: Agent Task Generation
+**Framework-Based Analysis** (when guidance-specification.md exists):
+```bash
+Task(subagent_type="conceptual-planning-agent",
+     run_in_background=false,
+     prompt="Generate system architect analysis addressing topic framework
+
+     ## Framework Integration Required
+     **MANDATORY**: Load and address guidance-specification.md discussion points
+     **Framework Reference**: @{session.brainstorm_dir}/guidance-specification.md
+     **Output Location**: {session.brainstorm_dir}/system-architect/analysis.md
+
+     ## Analysis Requirements
+     1. **Load Topic Framework**: Read guidance-specification.md completely
+     2. **Address Each Discussion Point**: Respond to all 5 framework sections from system architecture perspective
+     3. **Include Framework Reference**: Start analysis.md with @../guidance-specification.md
+     4. **Technical Focus**: Emphasize scalability, architecture patterns, technology decisions
+     5. **Structured Response**: Use framework structure for analysis organization
+
+     ## Framework Sections to Address
+     - Core Requirements (from architecture perspective)
+     - Technical Considerations (detailed architectural analysis)
+     - User Experience Factors (technical UX considerations)
+     - Implementation Challenges (architecture risks and solutions)
+     - Success Metrics (technical metrics and monitoring)
+
+     ## Output Structure Required
+     ```markdown
+     # System Architect Analysis: [Topic]
+
+     **Framework Reference**: @../guidance-specification.md
+     **Role Focus**: System Architecture and Technical Design
+
+     ## Core Requirements Analysis
+     [Address framework requirements from architecture perspective]
+
+     ## Technical Considerations
+     [Detailed architectural analysis]
+
+     ## User Experience Factors
+     [Technical aspects of UX implementation]
+
+     ## Implementation Challenges
+     [Architecture risks and mitigation strategies]
+
+     ## Success Metrics
+     [Technical metrics and system monitoring]
+
+     ## Architecture-Specific Recommendations
+     [Detailed technical recommendations]
+     ```",
+     description="Generate system architect framework-based analysis")
+```
+
+### Phase 4: Update Mechanism
+**Analysis Update Process**:
+```bash
+# For existing analysis updates
+IF update_mode = "incremental":
+    Task(subagent_type="conceptual-planning-agent",
+         run_in_background=false,
+         prompt="Update existing system architect analysis
+
+         ## Current Analysis Context
+         **Existing Analysis**: @{session.brainstorm_dir}/system-architect/analysis.md
+         **Framework Reference**: @{session.brainstorm_dir}/guidance-specification.md
+
+         ## Update Requirements
+         1. **Preserve Structure**: Maintain existing analysis structure
+         2. **Add New Insights**: Integrate new technical insights and recommendations
+         3. **Framework Alignment**: Ensure continued alignment with topic framework
+         4. **Technical Updates**: Add new architecture patterns, technology considerations
+         5. **Maintain References**: Keep @../guidance-specification.md reference
+
+         ## Update Instructions
+         - Read existing analysis completely
+         - Identify areas for enhancement or new insights
+         - Add technical depth while preserving original structure
+         - Update recommendations with new architectural approaches
+         - Maintain framework discussion point addressing",
+         description="Update system architect analysis incrementally")
+```
+
+## Document Structure
+
+### Output Files
+```
+.workflow/active/WFS-[topic]/.brainstorming/
+├── guidance-specification.md          # Input: Framework (if exists)
+└── system-architect/
+    └── analysis.md            # ★ OUTPUT: Framework-based analysis
+```
+
+### Analysis Structure
+**Required Elements**:
+- **Framework Reference**: @../guidance-specification.md (if framework exists)
+- **Role Focus**: System Architecture and Technical Design perspective
+- **5 Framework Sections**: Address each framework discussion point
+- **Technical Recommendations**: Architecture-specific insights and solutions
 - How should we design APIs and manage versioning?
 
 **4. Performance and Scalability**
@@ -60,97 +183,105 @@ Technical leader responsible for designing scalable, maintainable, and high-perf
 - How should we handle traffic growth and scaling demands?
 - What database scaling and optimization strategies are needed?
 
-## ⚙️ **Execution Protocol**
+## ⚡ **Two-Step Execution Flow**
 
-### Phase 1: Session Detection & Initialization
+### ⚠️ Session Management - FIRST STEP
+Session detection and selection:
 ```bash
-# Detect active workflow session
-CHECK: .workflow/.active-* marker files
-IF active_session EXISTS:
-    session_id = get_active_session()
-    load_context_from(session_id)
-ELSE:
-    request_user_for_session_creation()
+# Check for existing sessions
+existing_sessions=$(find .workflow/active/ -name "WFS-*" -type d 2>/dev/null)
+if [ multiple_sessions ]; then
+  prompt_user_to_select_session()
+else
+  use_existing_or_create_new()
+fi
 ```
 
-### Phase 2: Directory Structure Creation
-```bash
-# Create system architect analysis directory
-mkdir -p .workflow/WFS-{topic-slug}/.brainstorming/system-architect/
-```
+### Step 1: Context Gathering Phase
+**System Architect Perspective Questioning**
 
-### Phase 3: Task Tracking Initialization
-Initialize system architect perspective analysis tracking:
-```json
-[
-  {"content": "Initialize system architect brainstorming session", "status": "completed", "activeForm": "Initializing session"},
-  {"content": "Analyze current system architecture", "status": "in_progress", "activeForm": "Analyzing architecture"},
-  {"content": "Evaluate technical requirements and constraints", "status": "pending", "activeForm": "Evaluating requirements"},
-  {"content": "Design optimal system architecture", "status": "pending", "activeForm": "Designing architecture"},
-  {"content": "Assess scalability and performance", "status": "pending", "activeForm": "Assessing scalability"},
-  {"content": "Plan technology stack and integration", "status": "pending", "activeForm": "Planning technology"},
-  {"content": "Generate comprehensive architecture documentation", "status": "pending", "activeForm": "Generating documentation"}
-]
-```
+Before agent assignment, gather comprehensive system architecture context:
+
+#### 📋 Role-Specific Questions
+1. **Scale & Performance Requirements**
+   - Expected user load and traffic patterns?
+   - Performance requirements (latency, throughput)?
+   - Data volume and growth projections?
+
+2. **Technical Constraints & Environment**
+   - Existing technology stack and constraints?
+   - Integration requirements with external systems?
+   - Infrastructure and deployment environment?
+
+3. **Architecture Complexity & Patterns**
+   - Microservices vs monolithic considerations?
+   - Data consistency and transaction requirements?
+   - Event-driven vs request-response patterns?
+
+4. **Non-Functional Requirements**
+   - High availability and disaster recovery needs?
+   - Security and compliance requirements?
+   - Monitoring and observability expectations?
+
+#### Context Validation
+- **Minimum Response**: Each answer must be ≥50 characters
+- **Re-prompting**: Insufficient detail triggers follow-up questions
+- **Context Storage**: Save responses to `.brainstorming/system-architect-context.md`
+
+### Step 2: Agent Assignment with Flow Control
+**Dedicated Agent Execution**
 
-### Phase 4: Conceptual Planning Agent Coordination
 ```bash
 Task(conceptual-planning-agent): "
-Conduct system architecture perspective brainstorming for: {topic}
+[FLOW_CONTROL]
 
-ROLE CONTEXT: System Architect
-- Focus Areas: Technical architecture, scalability, system integration, performance
-- Analysis Framework: Architecture-first approach with scalability and maintainability focus
-- Success Metrics: System performance, availability, maintainability, technical debt reduction
+Execute dedicated system-architect conceptual analysis for: {topic}
 
-USER CONTEXT: {captured_user_requirements_from_session}
+ASSIGNED_ROLE: system-architect
+OUTPUT_LOCATION: .brainstorming/system-architect/
+USER_CONTEXT: {validated_responses_from_context_gathering}
 
-ANALYSIS REQUIREMENTS:
-1. Current Architecture Assessment
-   - Analyze existing system architecture and identify pain points
-   - Evaluate current technology stack effectiveness
-   - Assess technical debt and maintenance overhead
-   - Identify architectural bottlenecks and limitations
+Flow Control Steps:
+[
+  {
+    \"step\": \"load_role_template\",
+    \"action\": \"Load system-architect planning template\",
+    \"command\": \"bash($(cat ~/.claude/workflows/cli-templates/planning-roles/system-architect.md))\",
+    \"output_to\": \"role_template\"
+  }
+]
 
-2. Requirements and Constraints Analysis
-   - Define functional and non-functional requirements
-   - Identify performance, scalability, and availability requirements
-   - Analyze security and compliance constraints
-   - Assess resource and budget limitations
+Conceptual Analysis Requirements:
+- Apply system-architect perspective to topic analysis
+- Focus on architectural patterns, scalability, and integration points
+- Use loaded role template framework for analysis structure
+- Generate role-specific deliverables in designated output location
+- Address all user context from questioning phase
 
-3. Architecture Design and Strategy
-   - Design optimal system architecture for the given requirements
-   - Recommend technology stack and architectural patterns
-   - Plan for microservices vs monolithic architecture decisions
-   - Design data architecture and storage strategies
+Deliverables:
+- analysis.md: Main system architecture analysis
+- recommendations.md: Architecture recommendations
+- deliverables/: Architecture-specific outputs as defined in role template
 
-4. Integration and Scalability Planning
-   - Design system integration patterns and APIs
-   - Plan for horizontal and vertical scaling strategies
-   - Design monitoring, logging, and observability systems
-   - Plan deployment and DevOps strategies
+Embody system-architect role expertise for comprehensive conceptual planning."
+```
 
-5. Risk Assessment and Mitigation
-   - Identify technical risks and failure points
-   - Design fault tolerance and disaster recovery strategies
-   - Plan for security vulnerabilities and mitigations
-   - Assess migration risks and strategies
-
-OUTPUT REQUIREMENTS: Save comprehensive analysis to:
-.workflow/WFS-{topic-slug}/.brainstorming/system-architect/
-- analysis.md (main architecture analysis)
-- architecture-design.md (detailed system design and diagrams)
-- technology-stack.md (technology recommendations and justifications)
-- integration-plan.md (system integration and API strategies)
-
-Apply system architecture expertise to generate scalable, maintainable, and performant solutions."
+### Progress Tracking
+TodoWrite tracking for two-step process:
+```json
+[
+  {"content": "Gather system architect context through role-specific questioning", "status": "in_progress", "activeForm": "Gathering context"},
+  {"content": "Validate context responses and save to system-architect-context.md", "status": "pending", "activeForm": "Validating context"},
+  {"content": "Load system-architect planning template via flow control", "status": "pending", "activeForm": "Loading template"},
+  {"content": "Execute dedicated conceptual-planning-agent for system-architect role", "status": "pending", "activeForm": "Executing agent"}
+]
 ```
 
 ## 📊 **Output Specification**
 
 ### Output Location
 ```
-.workflow/WFS-{topic-slug}/.brainstorming/system-architect/
+.workflow/active/WFS-{topic-slug}/.brainstorming/system-architect/
 ├── analysis.md                 # Primary architecture analysis
 ├── architecture-design.md      # Detailed system design and diagrams
 ├── technology-stack.md         # Technology stack recommendations and justifications
@@ -211,7 +342,7 @@ Upon completion, update `workflow-session.json`:
       "system_architect": {
         "status": "completed",
         "completed_at": "timestamp",
-        "output_directory": ".workflow/WFS-{topic}/.brainstorming/system-architect/",
+        "output_directory": ".workflow/active/WFS-{topic}/.brainstorming/system-architect/",
         "key_insights": ["scalability_bottleneck", "architecture_pattern", "technology_recommendation"]
       }
     }
@@ -255,4 +386,4 @@ System architect perspective provides:
 - [ ] **Resource Planning**: Resource requirements clearly defined and realistic
 - [ ] **Risk Management**: Technical risks identified with mitigation plans
 - [ ] **Performance Validation**: Architecture can meet performance requirements
-- [ ] **Evolution Strategy**: Design allows for future growth and changes
+- [ ] **Evolution Strategy**: Design allows for future growth and changes

.claude/commands/workflow/brainstorm/ui-designer.md

@@ -1,268 +1,221 @@
 ---
 name: ui-designer
-description: UI designer perspective brainstorming for user experience and interface design analysis
-usage: /workflow:brainstorm:ui-designer <topic>
-argument-hint: "topic or challenge to analyze from UI/UX design perspective"
-examples:
-  - /workflow:brainstorm:ui-designer "user authentication redesign"
-  - /workflow:brainstorm:ui-designer "mobile app navigation improvement"
-  - /workflow:brainstorm:ui-designer "accessibility enhancement strategy"
-allowed-tools: Task(conceptual-planning-agent), TodoWrite(*)
+description: Generate or update ui-designer/analysis.md addressing guidance-specification discussion points for UI design perspective
+argument-hint: "optional topic - uses existing framework if available"
+allowed-tools: Task(conceptual-planning-agent), TodoWrite(*), Read(*), Write(*)
 ---
 
-## 🎨 **Role Overview: UI Designer**
+## 🎨 **UI Designer Analysis Generator**
 
-### Role Definition
-Creative professional responsible for designing intuitive, accessible, and visually appealing user interfaces that create exceptional user experiences aligned with business goals and user needs.
+### Purpose
+**Specialized command for generating ui-designer/analysis.md** that addresses guidance-specification.md discussion points from UI/UX design perspective. Creates or updates role-specific analysis with framework references.
 
-### Core Responsibilities
-- **User Experience Design**: Create intuitive and efficient user experiences
-- **Interface Design**: Design beautiful and functional user interfaces
-- **Interaction Design**: Design smooth user interaction flows and micro-interactions
-- **Accessibility Design**: Ensure products are inclusive and accessible to all users
+### Core Function
+- **Framework-based Analysis**: Address each discussion point in guidance-specification.md
+- **UI/UX Focus**: User experience, interface design, and accessibility perspective
+- **Update Mechanism**: Create new or update existing analysis.md
+- **Agent Delegation**: Use conceptual-planning-agent for analysis generation
 
-### Focus Areas
-- **User Experience**: User journeys, usability, satisfaction metrics, conversion optimization
-- **Visual Design**: Interface aesthetics, brand consistency, visual hierarchy
-- **Interaction Design**: Workflow optimization, feedback mechanisms, responsiveness
-- **Accessibility**: WCAG compliance, inclusive design, assistive technology support
+### Analysis Scope
+- **Visual Design**: Color palettes, typography, spacing, and visual hierarchy implementation
+- **High-Fidelity Mockups**: Polished, pixel-perfect interface designs
+- **Design System Implementation**: Component libraries, design tokens, and style guides
+- **Micro-Interactions & Animations**: Transition effects, loading states, and interactive feedback
+- **Responsive Design**: Layout adaptations for different screen sizes and devices
 
-### Success Metrics
-- User satisfaction scores and usability metrics
-- Task completion rates and conversion metrics
-- Accessibility compliance scores
-- Visual design consistency and brand alignment
+### Role Boundaries & Responsibilities
 
-## 🧠 **Analysis Framework**
+#### **What This Role OWNS (Concrete Visual Interface Implementation)**
+- **Visual Design Language**: Colors, typography, iconography, spacing, and overall aesthetic
+- **High-Fidelity Mockups**: Polished designs showing exactly how the interface will look
+- **Design System Components**: Building and documenting reusable UI components (buttons, inputs, cards, etc.)
+- **Design Tokens**: Defining variables for colors, spacing, typography that can be used in code
+- **Micro-Interactions**: Hover states, transitions, animations, and interactive feedback details
+- **Responsive Layouts**: Adapting designs for mobile, tablet, and desktop breakpoints
 
-@~/.claude/workflows/brainstorming-principles.md
-@~/.claude/workflows/brainstorming-framework.md
+#### **What This Role DOES NOT Own (Defers to Other Roles)**
+- **User Research & Personas**: User behavior analysis and needs assessment → Defers to **UX Expert**
+- **Information Architecture**: Content structure and navigation strategy → Defers to **UX Expert**
+- **Low-Fidelity Wireframes**: Structural layouts without visual design → Defers to **UX Expert**
 
-### Key Analysis Questions
-
-**1. User Needs and Behavior Analysis**
-- What are the main pain points users experience during interactions?
-- What gaps exist between user expectations and actual experience?
-- What are the specific needs of different user segments?
-
-**2. Interface and Interaction Design**
-- How can we simplify operational workflows?
-- Is the information architecture logical and intuitive?
-- Are interaction feedback mechanisms timely and clear?
-
-**3. Visual and Brand Strategy**
-- Does the visual design support and strengthen brand identity?
-- Are color schemes, typography, and layouts appropriate and effective?
-- How can we ensure cross-platform consistency?
-
-**4. Technical Implementation Considerations**
-- What are the technical feasibility constraints for design concepts?
-- What responsive design requirements must be addressed?
-- How do performance considerations impact user experience?
+#### **Handoff Points**
+- **FROM UX Expert**: Receives wireframes, user flows, and information architecture as the foundation for visual design
+- **TO Frontend Developers**: Provides design specifications, component libraries, and design tokens for implementation
+- **WITH API Designer**: Coordinates on data presentation and form validation feedback (visual aspects only)
 
 ## ⚙️ **Execution Protocol**
 
-### Phase 1: Session Detection & Initialization
+### Phase 1: Session & Framework Detection
 ```bash
-# Detect active workflow session
-CHECK: .workflow/.active-* marker files
+# Check active session and framework
+CHECK: find .workflow/active/ -name "WFS-*" -type d
 IF active_session EXISTS:
     session_id = get_active_session()
-    load_context_from(session_id)
-ELSE:
-    request_user_for_session_creation()
+    brainstorm_dir = .workflow/active/WFS-{session}/.brainstorming/
+
+    CHECK: brainstorm_dir/guidance-specification.md
+    IF EXISTS:
+        framework_mode = true
+        load_framework = true
+    ELSE:
+        IF topic_provided:
+            framework_mode = false  # Create analysis without framework
+        ELSE:
+            ERROR: "No framework found and no topic provided"
 ```
 
-### Phase 2: Directory Structure Creation
+### Phase 2: Analysis Mode Detection
 ```bash
-# Create UI designer analysis directory
-mkdir -p .workflow/WFS-{topic-slug}/.brainstorming/ui-designer/
+# Determine execution mode
+IF framework_mode == true:
+    mode = "framework_based_analysis"
+    topic_ref = load_framework_topic()
+    discussion_points = extract_framework_points()
+ELSE:
+    mode = "standalone_analysis"
+    topic_ref = provided_topic
+    discussion_points = generate_basic_structure()
 ```
 
-### Phase 3: Task Tracking Initialization
-Initialize UI designer perspective analysis tracking:
-```json
-[
-  {"content": "Initialize UI designer brainstorming session", "status": "completed", "activeForm": "Initializing session"},
-  {"content": "Analyze current user experience and pain points", "status": "in_progress", "activeForm": "Analyzing user experience"},
-  {"content": "Design user journey and interaction flows", "status": "pending", "activeForm": "Designing user flows"},
-  {"content": "Create visual design concepts and mockups", "status": "pending", "activeForm": "Creating visual concepts"},
-  {"content": "Evaluate accessibility and usability", "status": "pending", "activeForm": "Evaluating accessibility"},
-  {"content": "Plan responsive design strategy", "status": "pending", "activeForm": "Planning responsive design"},
-  {"content": "Generate comprehensive UI/UX documentation", "status": "pending", "activeForm": "Generating documentation"}
-]
-```
+### Phase 3: Agent Execution with Flow Control
+**Framework-Based Analysis Generation**
 
-### Phase 4: Conceptual Planning Agent Coordination
 ```bash
 Task(conceptual-planning-agent): "
-Conduct UI designer perspective brainstorming for: {topic}
+[FLOW_CONTROL]
 
-ROLE CONTEXT: UI Designer
-- Focus Areas: User experience, interface design, visual design, accessibility
-- Analysis Framework: User-centered design approach with emphasis on usability and accessibility
-- Success Metrics: User satisfaction, task completion rates, accessibility compliance, visual appeal
+Execute ui-designer analysis for existing topic framework
 
-USER CONTEXT: {captured_user_requirements_from_session}
+## Context Loading
+ASSIGNED_ROLE: ui-designer
+OUTPUT_LOCATION: .workflow/active/WFS-{session}/.brainstorming/ui-designer/
+ANALYSIS_MODE: {framework_mode ? "framework_based" : "standalone"}
 
-ANALYSIS REQUIREMENTS:
-1. User Experience Analysis
-   - Identify current UX pain points and friction areas
-   - Map user journeys and identify optimization opportunities
-   - Analyze user behavior patterns and preferences
-   - Evaluate task completion flows and success rates
+## Flow Control Steps
+1. **load_topic_framework**
+   - Action: Load structured topic discussion framework
+   - Command: Read(.workflow/active/WFS-{session}/.brainstorming/guidance-specification.md)
+   - Output: topic_framework_content
 
-2. Interface Design Assessment
-   - Review current interface design and information architecture
-   - Identify visual hierarchy and navigation issues  
-   - Assess consistency across different screens and states
-   - Evaluate mobile and desktop interface differences
+2. **load_role_template**
+   - Action: Load ui-designer planning template
+   - Command: bash($(cat ~/.claude/workflows/cli-templates/planning-roles/ui-designer.md))
+   - Output: role_template_guidelines
 
-3. Visual Design Strategy
-   - Develop visual design concepts aligned with brand guidelines
-   - Create color schemes, typography, and spacing systems
-   - Design iconography and visual elements
-   - Plan for dark mode and theme variations
+3. **load_session_metadata**
+   - Action: Load session metadata and existing context
+   - Command: Read(.workflow/active/WFS-{session}/workflow-session.json)
+   - Output: session_context
 
-4. Interaction Design Planning
-   - Design micro-interactions and animation strategies
-   - Plan feedback mechanisms and loading states
-   - Create error handling and validation UX
-   - Design responsive behavior and breakpoints
+## Analysis Requirements
+**Framework Reference**: Address all discussion points in guidance-specification.md from UI/UX perspective
+**Role Focus**: User experience design, interface optimization, accessibility compliance
+**Structured Approach**: Create analysis.md addressing framework discussion points
+**Template Integration**: Apply role template guidelines within framework structure
 
-5. Accessibility and Inclusion
-   - Evaluate WCAG 2.1 compliance requirements
-   - Design for screen readers and assistive technologies
-   - Plan for color blindness and visual impairments
-   - Ensure keyboard navigation and focus management
+## Expected Deliverables
+1. **analysis.md**: Comprehensive UI/UX analysis addressing all framework discussion points
+2. **Framework Reference**: Include @../guidance-specification.md reference in analysis
 
-6. Prototyping and Testing Strategy
-   - Plan for wireframes, mockups, and interactive prototypes
-   - Design user testing scenarios and success metrics
-   - Create A/B testing strategies for key interactions
-   - Plan for iterative design improvements
-
-OUTPUT REQUIREMENTS: Save comprehensive analysis to:
-.workflow/WFS-{topic-slug}/.brainstorming/ui-designer/
-- analysis.md (main UI/UX analysis)
-- design-system.md (visual design guidelines and components)
-- user-flows.md (user journey maps and interaction flows)
-- accessibility-plan.md (accessibility requirements and implementation)
-
-Apply UI/UX design expertise to create user-centered, accessible, and visually appealing solutions."
+## Completion Criteria
+- Address each discussion point from guidance-specification.md with UI/UX design expertise
+- Provide actionable design recommendations and interface solutions
+- Include accessibility considerations and WCAG compliance planning
+- Reference framework document using @ notation for integration
+"
 ```
 
-## 📊 **Output Specification**
+## 📋 **TodoWrite Integration**
 
-### Output Location
-```
-.workflow/WFS-{topic-slug}/.brainstorming/ui-designer/
-├── analysis.md                 # Primary UI/UX analysis
-├── design-system.md            # Visual design guidelines and components
-├── user-flows.md               # User journey maps and interaction flows
-└── accessibility-plan.md       # Accessibility requirements and implementation
+### Workflow Progress Tracking
+```javascript
+TodoWrite({
+  todos: [
+    {
+      content: "Detect active session and locate topic framework",
+      status: "in_progress",
+      activeForm: "Detecting session and framework"
+    },
+    {
+      content: "Load guidance-specification.md and session metadata for context",
+      status: "pending",
+      activeForm: "Loading framework and session context"
+    },
+    {
+      content: "Execute ui-designer analysis using conceptual-planning-agent with FLOW_CONTROL",
+      status: "pending",
+      activeForm: "Executing ui-designer framework analysis"
+    },
+    {
+      content: "Generate analysis.md addressing all framework discussion points",
+      status: "pending",
+      activeForm: "Generating structured ui-designer analysis"
+    },
+    {
+      content: "Update workflow-session.json with ui-designer completion status",
+      status: "pending",
+      activeForm: "Updating session metadata"
+    }
+  ]
+});
 ```
 
-### Document Templates
+## 📊 **Output Structure**
 
-#### analysis.md Structure
+### Framework-Based Analysis
+```
+.workflow/active/WFS-{session}/.brainstorming/ui-designer/
+└── analysis.md    # Structured analysis addressing guidance-specification.md discussion points
+```
+
+### Analysis Document Structure
 ```markdown
-# UI Designer Analysis: {Topic}
-*Generated: {timestamp}*
+# UI Designer Analysis: [Topic from Framework]
 
-## Executive Summary
-[Key UX findings and design recommendations overview]
+## Framework Reference
+**Topic Framework**: @../guidance-specification.md
+**Role Focus**: UI/UX Design perspective
 
-## Current UX Assessment
-### User Pain Points
-### Interface Issues
-### Accessibility Gaps
-### Performance Impact on UX
+## Discussion Points Analysis
+[Address each point from guidance-specification.md with UI/UX expertise]
 
-## User Experience Strategy
-### Target User Personas
-### User Journey Mapping
-### Key Interaction Points
-### Success Metrics
+### Core Requirements (from framework)
+[UI/UX perspective on requirements]
 
-## Visual Design Approach
-### Brand Alignment
-### Color and Typography Strategy
-### Layout and Spacing System
-### Iconography and Visual Elements
+### Technical Considerations (from framework)
+[Interface and design system considerations]
 
-## Interface Design Plan
-### Information Architecture
-### Navigation Strategy
-### Component Library
-### Responsive Design Approach
+### User Experience Factors (from framework)
+[Detailed UX analysis and recommendations]
 
-## Accessibility Implementation
-### WCAG Compliance Plan
-### Assistive Technology Support
-### Inclusive Design Features
-### Testing Strategy
+### Implementation Challenges (from framework)
+[Design implementation and accessibility considerations]
 
-## Prototyping and Validation
-### Wireframe Strategy
-### Interactive Prototype Plan
-### User Testing Approach
-### Iteration Framework
+### Success Metrics (from framework)
+[UX metrics and usability success criteria]
+
+## UI/UX Specific Recommendations
+[Role-specific design recommendations and solutions]
+
+---
+*Generated by ui-designer analysis addressing structured framework*
 ```
 
 ## 🔄 **Session Integration**
 
-### Status Synchronization
-Upon completion, update `workflow-session.json`:
+### Completion Status Update
 ```json
 {
-  "phases": {
-    "BRAINSTORM": {
-      "ui_designer": {
-        "status": "completed",
-        "completed_at": "timestamp",
-        "output_directory": ".workflow/WFS-{topic}/.brainstorming/ui-designer/",
-        "key_insights": ["ux_improvement", "accessibility_requirement", "design_pattern"]
-      }
-    }
+  "ui_designer": {
+    "status": "completed",
+    "framework_addressed": true,
+    "output_location": ".workflow/active/WFS-{session}/.brainstorming/ui-designer/analysis.md",
+    "framework_reference": "@../guidance-specification.md"
   }
 }
 ```
 
-### Cross-Role Collaboration
-UI designer perspective provides:
-- **User Interface Requirements** → System Architect
-- **User Experience Metrics and Goals** → Product Manager
-- **Data Visualization Requirements** → Data Architect
-- **Secure Interaction Design Patterns** → Security Expert
-- **Feature Interface Specifications** → Feature Planner
-
-## ✅ **Quality Assurance**
-
-### Required Design Elements
-- [ ] Comprehensive user journey analysis with pain points identified
-- [ ] Complete interface design solution with visual mockups
-- [ ] Accessibility compliance plan meeting WCAG 2.1 standards
-- [ ] Responsive design strategy for multiple devices and screen sizes
-- [ ] Usability testing plan with clear success metrics
-
-### Design Principles Validation
-- [ ] **User-Centered**: All design decisions prioritize user needs and goals
-- [ ] **Consistency**: Interface elements and interactions maintain visual and functional consistency
-- [ ] **Accessibility**: Design meets WCAG guidelines and supports assistive technologies
-- [ ] **Usability**: Operations are simple, intuitive, with minimal learning curve
-- [ ] **Visual Appeal**: Design supports brand identity while creating positive user emotions
-
-### UX Quality Metrics
-- [ ] **Task Success**: High task completion rates with minimal errors
-- [ ] **Efficiency**: Optimal task completion times with streamlined workflows
-- [ ] **Satisfaction**: Positive user feedback and high satisfaction scores
-- [ ] **Accessibility**: Full compliance with accessibility standards and inclusive design
-- [ ] **Consistency**: Uniform experience across different devices and platforms
-
-### Implementation Readiness
-- [ ] **Design System**: Comprehensive component library and style guide
-- [ ] **Prototyping**: Interactive prototypes demonstrating key user flows
-- [ ] **Documentation**: Clear specifications for development implementation
-- [ ] **Testing Plan**: Structured approach for usability and accessibility validation
-- [ ] **Iteration Strategy**: Framework for continuous design improvement based on user feedback
+### Integration Points
+- **Framework Reference**: @../guidance-specification.md for structured discussion points
+- **Cross-Role Synthesis**: UI/UX insights available for synthesis-report.md integration
+- **Agent Autonomy**: Independent execution with framework guidance

.claude/commands/workflow/brainstorm/user-researcher.md

@@ -1,257 +0,0 @@
----
-name: user-researcher
-description: User researcher perspective brainstorming for user behavior analysis and research insights
-usage: /workflow:brainstorm:user-researcher <topic>
-argument-hint: "topic or challenge to analyze from user research perspective"
-examples:
-  - /workflow:brainstorm:user-researcher "user onboarding experience"
-  - /workflow:brainstorm:user-researcher "mobile app usability issues"
-  - /workflow:brainstorm:user-researcher "feature adoption analysis"
-allowed-tools: Task(conceptual-planning-agent), TodoWrite(*)
----
-
-## 🔍 **角色定义: User Researcher**
-
-### 核心职责
-- **用户行为研究**: 深度分析用户行为模式和动机
-- **用户需求发现**: 通过研究发现未满足的用户需求
-- **可用性评估**: 评估产品的可用性和用户体验问题
-- **用户洞察生成**: 将研究发现转化为可操作的产品洞察
-
-### 关注领域
-- **用户行为**: 使用模式、决策路径、任务完成方式
-- **用户需求**: 显性需求、隐性需求、情感需求
-- **用户体验**: 痛点、满意度、情感反应、期望值
-- **市场细分**: 用户画像、细分群体、使用场景
-
-## 🧠 **分析框架**
-
-@~/.claude/workflows/brainstorming-principles.md
-@~/.claude/workflows/brainstorming-framework.md
-
-### 核心分析问题
-1. **用户理解和洞察**:
-   - 目标用户的真实需求和痛点是什么？
-   - 用户的行为模式和使用场景？
-   - 不同用户群体的差异化需求？
-
-2. **用户体验分析**:
-   - 当前用户体验的主要问题？
-   - 用户任务完成的障碍和摩擦点？
-   - 用户满意度和期望差距？
-
-3. **研究方法和验证**:
-   - 哪些研究方法最适合当前问题？
-   - 如何验证假设和设计决策？
-   - 如何持续收集用户反馈？
-
-4. **洞察转化和应用**:
-   - 研究发现如何转化为产品改进？
-   - 如何影响产品决策和设计？
-   - 如何建立以用户为中心的文化？
-
-## ⚙️ **执行协议**
-
-### Phase 1: 会话检测与初始化
-```bash
-# 自动检测活动会话
-CHECK: .workflow/.active-* marker files
-IF active_session EXISTS:
-    session_id = get_active_session()
-    load_context_from(session_id)
-ELSE:
-    request_user_for_session_creation()
-```
-
-### Phase 2: 目录结构创建
-```bash
-# 创建用户研究员分析目录
-mkdir -p .workflow/WFS-{topic-slug}/.brainstorming/user-researcher/
-```
-
-### Phase 3: TodoWrite 初始化
-设置用户研究员视角分析的任务跟踪：
-```json
-[
-  {"content": "Initialize user researcher brainstorming session", "status": "completed", "activeForm": "Initializing session"},
-  {"content": "Analyze user behavior patterns and motivations", "status": "in_progress", "activeForm": "Analyzing user behavior"},
-  {"content": "Identify user needs and pain points", "status": "pending", "activeForm": "Identifying user needs"},
-  {"content": "Evaluate current user experience", "status": "pending", "activeForm": "Evaluating user experience"},
-  {"content": "Design user research methodology", "status": "pending", "activeForm": "Designing research methodology"},
-  {"content": "Generate user insights and recommendations", "status": "pending", "activeForm": "Generating insights"},
-  {"content": "Create comprehensive user research documentation", "status": "pending", "activeForm": "Creating documentation"}
-]
-```
-
-### Phase 4: 概念规划代理协调
-```bash
-Task(conceptual-planning-agent): "
-Conduct user researcher perspective brainstorming for: {topic}
-
-ROLE CONTEXT: User Researcher
-- Focus Areas: User behavior analysis, needs discovery, usability assessment, research methodology
-- Analysis Framework: Human-centered research approach with emphasis on behavioral insights
-- Success Metrics: User satisfaction, task success rates, insight quality, research impact
-
-USER CONTEXT: {captured_user_requirements_from_session}
-
-ANALYSIS REQUIREMENTS:
-1. User Behavior Analysis
-   - Analyze current user behavior patterns and usage data
-   - Identify user decision-making processes and mental models
-   - Map user journeys and touchpoint interactions
-   - Assess user motivations and goals across different scenarios
-   - Identify behavioral segments and usage patterns
-
-2. User Needs and Pain Points Discovery
-   - Conduct gap analysis between user needs and current solutions
-   - Identify unmet needs and latent requirements
-   - Analyze user feedback and support data for pain points
-   - Map emotional user journey and frustration points
-   - Prioritize needs based on user impact and frequency
-
-3. Usability and Experience Assessment
-   - Evaluate current user experience against best practices
-   - Identify usability heuristics violations and UX issues
-   - Assess cognitive load and task completion efficiency
-   - Analyze accessibility barriers and inclusive design gaps
-   - Evaluate user satisfaction and Net Promoter Score trends
-
-4. User Segmentation and Personas
-   - Define user segments based on behavior and needs
-   - Create detailed user personas with goals and contexts
-   - Map user scenarios and use case variations
-   - Analyze demographic and psychographic factors
-   - Identify key user archetypes and edge cases
-
-5. Research Methodology Design
-   - Recommend appropriate research methods (qualitative/quantitative)
-   - Design user interview guides and survey instruments
-   - Plan usability testing scenarios and success metrics
-   - Design A/B testing strategies for key hypotheses
-   - Plan longitudinal research and continuous feedback loops
-
-6. Insights Generation and Validation
-   - Synthesize research findings into actionable insights
-   - Identify opportunity areas and innovation potential
-   - Validate assumptions and hypotheses with evidence
-   - Prioritize insights based on business and user impact
-   - Create research-backed design principles and guidelines
-
-OUTPUT REQUIREMENTS: Save comprehensive analysis to:
-.workflow/WFS-{topic-slug}/.brainstorming/user-researcher/
-- analysis.md (main user research analysis)
-- user-personas.md (detailed user personas and segments)
-- research-plan.md (methodology and research approach)
-- insights-recommendations.md (key findings and actionable recommendations)
-
-Apply user research expertise to generate deep user understanding and actionable insights."
-```
-
-## 📊 **输出结构**
-
-### 保存位置
-```
-.workflow/WFS-{topic-slug}/.brainstorming/user-researcher/
-├── analysis.md                     # 主要用户研究分析
-├── user-personas.md                # 详细用户画像和细分
-├── research-plan.md                # 方法论和研究方法
-└── insights-recommendations.md     # 关键发现和可执行建议
-```
-
-### 文档模板
-
-#### analysis.md 结构
-```markdown
-# User Researcher Analysis: {Topic}
-*Generated: {timestamp}*
-
-## Executive Summary
-[核心用户研究发现和建议概述]
-
-## Current User Landscape
-### User Base Overview
-### Behavioral Patterns
-### Usage Statistics and Trends
-### Satisfaction Metrics
-
-## User Needs Analysis
-### Primary User Needs
-### Unmet Needs and Gaps
-### Need Prioritization Matrix
-### Emotional and Functional Needs
-
-## User Experience Assessment
-### Current UX Strengths
-### Major Pain Points and Friction
-### Usability Issues Identified
-### Accessibility Gaps
-
-## User Behavior Insights
-### User Journey Mapping
-### Decision-Making Patterns
-### Task Completion Analysis
-### Behavioral Segments
-
-## Research Recommendations
-### Recommended Research Methods
-### Key Research Questions
-### Success Metrics and KPIs
-### Research Timeline and Resources
-
-## Actionable Insights
-### Immediate UX Improvements
-### Product Feature Recommendations
-### Long-term User Strategy
-### Success Measurement Plan
-```
-
-## 🔄 **会话集成**
-
-### 状态同步
-分析完成后，更新 `workflow-session.json`:
-```json
-{
-  "phases": {
-    "BRAINSTORM": {
-      "user_researcher": {
-        "status": "completed",
-        "completed_at": "timestamp",
-        "output_directory": ".workflow/WFS-{topic}/.brainstorming/user-researcher/",
-        "key_insights": ["user_behavior_pattern", "unmet_need", "usability_issue"]
-      }
-    }
-  }
-}
-```
-
-### 与其他角色的协作
-用户研究员视角为其他角色提供：
-- **用户需求和洞察** → Product Manager
-- **用户行为数据** → Data Architect
-- **用户体验要求** → UI Designer
-- **用户安全需求** → Security Expert
-- **功能使用场景** → Feature Planner
-
-## ✅ **质量标准**
-
-### 必须包含的研究元素
-- [ ] 详细的用户行为分析
-- [ ] 明确的用户需求识别
-- [ ] 全面的用户体验评估
-- [ ] 科学的研究方法设计
-- [ ] 可执行的改进建议
-
-### 用户研究原则检查
-- [ ] 以人为本：所有分析以用户为中心
-- [ ] 基于证据：结论有数据和研究支撑
-- [ ] 行为导向：关注实际行为而非声明意图
-- [ ] 情境考虑：分析使用场景和环境因素
-- [ ] 持续迭代：建立持续研究和改进机制
-
-### 洞察质量评估
-- [ ] 洞察的新颖性和深度
-- [ ] 建议的可操作性和具体性
-- [ ] 影响评估的准确性
-- [ ] 研究方法的科学性
-- [ ] 用户代表性的覆盖度

.claude/commands/workflow/brainstorm/ux-expert.md

@@ -0,0 +1,221 @@
+---
+name: ux-expert
+description: Generate or update ux-expert/analysis.md addressing guidance-specification discussion points for UX perspective
+argument-hint: "optional topic - uses existing framework if available"
+allowed-tools: Task(conceptual-planning-agent), TodoWrite(*), Read(*), Write(*)
+---
+
+## 🎯 **UX Expert Analysis Generator**
+
+### Purpose
+**Specialized command for generating ux-expert/analysis.md** that addresses guidance-specification.md discussion points from user experience and interface design perspective. Creates or updates role-specific analysis with framework references.
+
+### Core Function
+- **Framework-based Analysis**: Address each discussion point in guidance-specification.md
+- **UX Design Focus**: User interface, interaction patterns, and usability optimization
+- **Update Mechanism**: Create new or update existing analysis.md
+- **Agent Delegation**: Use conceptual-planning-agent for analysis generation
+
+### Analysis Scope
+- **User Research**: User personas, behavioral analysis, and needs assessment
+- **Information Architecture**: Content structure, navigation hierarchy, and mental models
+- **User Journey Mapping**: User flows, task analysis, and interaction models
+- **Usability Strategy**: Accessibility planning, cognitive load reduction, and user testing frameworks
+- **Wireframing**: Low-fidelity layouts and structural prototypes (not visual design)
+
+### Role Boundaries & Responsibilities
+
+#### **What This Role OWNS (Abstract User Experience & Research)**
+- **User Research & Personas**: Understanding target users, their goals, pain points, and behaviors
+- **Information Architecture**: Organizing content and defining navigation structures at a conceptual level
+- **User Journey Mapping**: Defining user flows, task sequences, and interaction models
+- **Wireframes & Low-Fidelity Prototypes**: Structural layouts showing information hierarchy (boxes and arrows, not colors/fonts)
+- **Usability Testing Strategy**: Planning user testing, A/B tests, and validation methods
+- **Accessibility Planning**: WCAG compliance strategy and inclusive design principles
+
+#### **What This Role DOES NOT Own (Defers to Other Roles)**
+- **Visual Design**: Colors, typography, spacing, visual style → Defers to **UI Designer**
+- **High-Fidelity Mockups**: Polished, pixel-perfect designs → Defers to **UI Designer**
+- **Component Implementation**: Design system components, CSS, animations → Defers to **UI Designer**
+
+#### **Handoff Points**
+- **TO UI Designer**: Provides wireframes, user flows, and information architecture that UI Designer will transform into high-fidelity visual designs
+- **FROM User Research**: May receive external research data to inform UX decisions
+- **TO Product Owner**: Provides user insights and validation results to inform feature prioritization
+
+## ⚙️ **Execution Protocol**
+
+### Phase 1: Session & Framework Detection
+```bash
+# Check active session and framework
+CHECK: find .workflow/active/ -name "WFS-*" -type d
+IF active_session EXISTS:
+    session_id = get_active_session()
+    brainstorm_dir = .workflow/active/WFS-{session}/.brainstorming/
+
+    CHECK: brainstorm_dir/guidance-specification.md
+    IF EXISTS:
+        framework_mode = true
+        load_framework = true
+    ELSE:
+        IF topic_provided:
+            framework_mode = false  # Create analysis without framework
+        ELSE:
+            ERROR: "No framework found and no topic provided"
+```
+
+### Phase 2: Analysis Mode Detection
+```bash
+# Determine execution mode
+IF framework_mode == true:
+    mode = "framework_based_analysis"
+    topic_ref = load_framework_topic()
+    discussion_points = extract_framework_points()
+ELSE:
+    mode = "standalone_analysis"
+    topic_ref = provided_topic
+    discussion_points = generate_basic_structure()
+```
+
+### Phase 3: Agent Execution with Flow Control
+**Framework-Based Analysis Generation**
+
+```bash
+Task(conceptual-planning-agent): "
+[FLOW_CONTROL]
+
+Execute ux-expert analysis for existing topic framework
+
+## Context Loading
+ASSIGNED_ROLE: ux-expert
+OUTPUT_LOCATION: .workflow/active/WFS-{session}/.brainstorming/ux-expert/
+ANALYSIS_MODE: {framework_mode ? "framework_based" : "standalone"}
+
+## Flow Control Steps
+1. **load_topic_framework**
+   - Action: Load structured topic discussion framework
+   - Command: Read(.workflow/active/WFS-{session}/.brainstorming/guidance-specification.md)
+   - Output: topic_framework_content
+
+2. **load_role_template**
+   - Action: Load ux-expert planning template
+   - Command: bash($(cat ~/.claude/workflows/cli-templates/planning-roles/ux-expert.md))
+   - Output: role_template_guidelines
+
+3. **load_session_metadata**
+   - Action: Load session metadata and existing context
+   - Command: Read(.workflow/active/WFS-{session}/workflow-session.json)
+   - Output: session_context
+
+## Analysis Requirements
+**Framework Reference**: Address all discussion points in guidance-specification.md from user experience and interface design perspective
+**Role Focus**: UI design, interaction patterns, usability optimization, design systems
+**Structured Approach**: Create analysis.md addressing framework discussion points
+**Template Integration**: Apply role template guidelines within framework structure
+
+## Expected Deliverables
+1. **analysis.md**: Comprehensive UX design analysis addressing all framework discussion points
+2. **Framework Reference**: Include @../guidance-specification.md reference in analysis
+
+## Completion Criteria
+- Address each discussion point from guidance-specification.md with UX design expertise
+- Provide actionable interface design and usability optimization strategies
+- Include accessibility considerations and interaction pattern recommendations
+- Reference framework document using @ notation for integration
+"
+```
+
+## 📋 **TodoWrite Integration**
+
+### Workflow Progress Tracking
+```javascript
+TodoWrite({
+  todos: [
+    {
+      content: "Detect active session and locate topic framework",
+      status: "in_progress",
+      activeForm: "Detecting session and framework"
+    },
+    {
+      content: "Load guidance-specification.md and session metadata for context",
+      status: "pending",
+      activeForm: "Loading framework and session context"
+    },
+    {
+      content: "Execute ux-expert analysis using conceptual-planning-agent with FLOW_CONTROL",
+      status: "pending",
+      activeForm: "Executing ux-expert framework analysis"
+    },
+    {
+      content: "Generate analysis.md addressing all framework discussion points",
+      status: "pending",
+      activeForm: "Generating structured ux-expert analysis"
+    },
+    {
+      content: "Update workflow-session.json with ux-expert completion status",
+      status: "pending",
+      activeForm: "Updating session metadata"
+    }
+  ]
+});
+```
+
+## 📊 **Output Structure**
+
+### Framework-Based Analysis
+```
+.workflow/active/WFS-{session}/.brainstorming/ux-expert/
+└── analysis.md    # Structured analysis addressing guidance-specification.md discussion points
+```
+
+### Analysis Document Structure
+```markdown
+# UX Expert Analysis: [Topic from Framework]
+
+## Framework Reference
+**Topic Framework**: @../guidance-specification.md
+**Role Focus**: User Experience & Interface Design perspective
+
+## Discussion Points Analysis
+[Address each point from guidance-specification.md with UX design expertise]
+
+### Core Requirements (from framework)
+[User interface and interaction design requirements perspective]
+
+### Technical Considerations (from framework)
+[Design system implementation and technical feasibility considerations]
+
+### User Experience Factors (from framework)
+[Usability optimization, accessibility, and user-centered design analysis]
+
+### Implementation Challenges (from framework)
+[Design implementation challenges and progressive enhancement strategies]
+
+### Success Metrics (from framework)
+[UX metrics including usability testing, user satisfaction, and design KPIs]
+
+## UX Expert Specific Recommendations
+[Role-specific interface design patterns and usability optimization strategies]
+
+---
+*Generated by ux-expert analysis addressing structured framework*
+```
+
+## 🔄 **Session Integration**
+
+### Completion Status Update
+```json
+{
+  "ux_expert": {
+    "status": "completed",
+    "framework_addressed": true,
+    "output_location": ".workflow/active/WFS-{session}/.brainstorming/ux-expert/analysis.md",
+    "framework_reference": "@../guidance-specification.md"
+  }
+}
+```
+
+### Integration Points
+- **Framework Reference**: @../guidance-specification.md for structured discussion points
+- **Cross-Role Synthesis**: UX design insights available for synthesis-report.md integration
+- **Agent Autonomy**: Independent execution with framework guidance

.claude/commands/workflow/clean.md

@@ -0,0 +1,516 @@
+---
+name: clean
+description: Intelligent code cleanup with mainline detection, stale artifact discovery, and safe execution
+argument-hint: "[--dry-run] [\"focus area\"]"
+allowed-tools: TodoWrite(*), Task(*), AskUserQuestion(*), Read(*), Glob(*), Bash(*), Write(*)
+---
+
+# Clean Command (/workflow:clean)
+
+## Overview
+
+Intelligent cleanup command that explores the codebase to identify the development mainline, discovers artifacts that have drifted from it, and safely removes stale sessions, abandoned documents, and dead code.
+
+**Core capabilities:**
+- Mainline detection: Identify active development branches and core modules
+- Drift analysis: Find sessions, documents, and code that deviate from mainline
+- Intelligent discovery: cli-explore-agent based artifact scanning
+- Safe execution: Confirmation-based cleanup with dry-run preview
+
+## Usage
+
+```bash
+/workflow:clean                          # Full intelligent cleanup (explore → analyze → confirm → execute)
+/workflow:clean --dry-run                # Explore and analyze only, no execution
+/workflow:clean "auth module"            # Focus cleanup on specific area
+```
+
+## Execution Process
+
+```
+Phase 1: Mainline Detection
+   ├─ Analyze git history for development trends
+   ├─ Identify core modules (high commit frequency)
+   ├─ Map active vs stale branches
+   └─ Build mainline profile
+
+Phase 2: Drift Discovery (cli-explore-agent)
+   ├─ Scan workflow sessions for orphaned artifacts
+   ├─ Identify documents drifted from mainline
+   ├─ Detect dead code and unused exports
+   └─ Generate cleanup manifest
+
+Phase 3: Confirmation
+   ├─ Display cleanup summary by category
+   ├─ Show impact analysis (files, size, risk)
+   └─ AskUserQuestion: Select categories to clean
+
+Phase 4: Execution (unless --dry-run)
+   ├─ Execute cleanup by category
+   ├─ Update manifests and indexes
+   └─ Report results
+```
+
+## Implementation
+
+### Phase 1: Mainline Detection
+
+**Session Setup**:
+```javascript
+const getUtc8ISOString = () => new Date(Date.now() + 8 * 60 * 60 * 1000).toISOString()
+
+const dateStr = getUtc8ISOString().substring(0, 10)
+const sessionId = `clean-${dateStr}`
+const sessionFolder = `.workflow/.clean/${sessionId}`
+
+Bash(`mkdir -p ${sessionFolder}`)
+```
+
+**Step 1.1: Git History Analysis**
+```bash
+# Get commit frequency by directory (last 30 days)
+bash(git log --since="30 days ago" --name-only --pretty=format: | grep -v "^$" | cut -d/ -f1-2 | sort | uniq -c | sort -rn | head -20)
+
+# Get recent active branches
+bash(git for-each-ref --sort=-committerdate refs/heads/ --format='%(refname:short) %(committerdate:relative)' | head -10)
+
+# Get files with most recent changes
+bash(git log --since="7 days ago" --name-only --pretty=format: | grep -v "^$" | sort | uniq -c | sort -rn | head -30)
+```
+
+**Step 1.2: Build Mainline Profile**
+```javascript
+const mainlineProfile = {
+  coreModules: [],        // High-frequency directories
+  activeFiles: [],        // Recently modified files
+  activeBranches: [],     // Branches with recent commits
+  staleThreshold: {
+    sessions: 7,          // Days
+    branches: 30,
+    documents: 14
+  },
+  timestamp: getUtc8ISOString()
+}
+
+// Parse git log output to identify core modules
+// Modules with >5 commits in last 30 days = core
+// Modules with 0 commits in last 30 days = potentially stale
+
+Write(`${sessionFolder}/mainline-profile.json`, JSON.stringify(mainlineProfile, null, 2))
+```
+
+---
+
+### Phase 2: Drift Discovery
+
+**Launch cli-explore-agent for intelligent artifact scanning**:
+
+```javascript
+Task(
+  subagent_type="cli-explore-agent",
+  run_in_background=false,
+  description="Discover stale artifacts",
+  prompt=`
+## Task Objective
+Discover artifacts that have drifted from the development mainline. Identify stale sessions, abandoned documents, and dead code for cleanup.
+
+## Context
+- **Session Folder**: ${sessionFolder}
+- **Mainline Profile**: ${sessionFolder}/mainline-profile.json
+- **Focus Area**: ${focusArea || "全项目"}
+
+## Discovery Categories
+
+### Category 1: Stale Workflow Sessions
+Scan and analyze workflow session directories:
+
+**Locations to scan**:
+- .workflow/active/WFS-* (active sessions)
+- .workflow/archives/WFS-* (archived sessions)
+- .workflow/.lite-plan/* (lite-plan sessions)
+- .workflow/.debug/DBG-* (debug sessions)
+
+**Staleness criteria**:
+- Active sessions: No modification >7 days + no related git commits
+- 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
+
+**Analysis steps**:
+1. List all session directories with modification times
+2. Cross-reference with git log (are session topics in recent commits?)
+3. Check manifest.json for orphan entries
+4. Identify sessions with .archiving marker (interrupted)
+
+### Category 2: Drifted Documents
+Scan documentation that no longer aligns with code:
+
+**Locations to scan**:
+- .claude/rules/tech/* (generated tech rules)
+- .workflow/.scratchpad/* (temporary notes)
+- **/CLAUDE.md (module documentation)
+- **/README.md (outdated descriptions)
+
+**Drift criteria**:
+- Tech rules: Referenced files no longer exist
+- Scratchpad: Any file (always temporary)
+- Module docs: Describe functions/classes that were removed
+- READMEs: Reference deleted directories
+
+**Analysis steps**:
+1. Parse document content for file/function references
+2. Verify referenced entities still exist in codebase
+3. Flag documents with >30% broken references
+
+### Category 3: Dead Code
+Identify code that is no longer used:
+
+**Scan patterns**:
+- Unused exports (exported but never imported)
+- Orphan files (not imported anywhere)
+- Commented-out code blocks (>10 lines)
+- TODO/FIXME comments >90 days old
+
+**Analysis steps**:
+1. Build import graph using rg/grep
+2. Identify exports with no importers
+3. Find files not in import graph
+4. Scan for large comment blocks
+
+## Output Format
+
+Write to: ${sessionFolder}/cleanup-manifest.json
+
+\`\`\`json
+{
+  "generated_at": "ISO timestamp",
+  "mainline_summary": {
+    "core_modules": ["src/core", "src/api"],
+    "active_branches": ["main", "feature/auth"],
+    "health_score": 0.85
+  },
+  "discoveries": {
+    "stale_sessions": [
+      {
+        "path": ".workflow/active/WFS-old-feature",
+        "type": "active",
+        "age_days": 15,
+        "reason": "No related commits in 15 days",
+        "size_kb": 1024,
+        "risk": "low"
+      }
+    ],
+    "drifted_documents": [
+      {
+        "path": ".claude/rules/tech/deprecated-lib",
+        "type": "tech_rules",
+        "broken_references": 5,
+        "total_references": 6,
+        "drift_percentage": 83,
+        "reason": "Referenced library removed",
+        "risk": "low"
+      }
+    ],
+    "dead_code": [
+      {
+        "path": "src/utils/legacy.ts",
+        "type": "orphan_file",
+        "reason": "Not imported by any file",
+        "last_modified": "2025-10-01",
+        "risk": "medium"
+      }
+    ]
+  },
+  "summary": {
+    "total_items": 12,
+    "total_size_mb": 45.2,
+    "by_category": {
+      "stale_sessions": 5,
+      "drifted_documents": 4,
+      "dead_code": 3
+    },
+    "by_risk": {
+      "low": 8,
+      "medium": 3,
+      "high": 1
+    }
+  }
+}
+\`\`\`
+
+## Execution Commands
+
+\`\`\`bash
+# Session directories
+find .workflow -type d -name "WFS-*" -o -name "DBG-*" 2>/dev/null
+
+# Check modification times (Linux/Mac)
+stat -c "%Y %n" .workflow/active/WFS-* 2>/dev/null
+
+# Check modification times (Windows PowerShell via bash)
+powershell -Command "Get-ChildItem '.workflow/active/WFS-*' | ForEach-Object { Write-Output \"$($_.LastWriteTime) $($_.FullName)\" }"
+
+# Find orphan exports (TypeScript)
+rg "export (const|function|class|interface|type)" --type ts -l
+
+# Find imports
+rg "import.*from" --type ts
+
+# Find large comment blocks
+rg "^\\s*/\\*" -A 10 --type ts
+
+# Find old TODOs
+rg "TODO|FIXME" --type ts -n
+\`\`\`
+
+## Success Criteria
+- [ ] All session directories scanned with age calculation
+- [ ] Documents cross-referenced with existing code
+- [ ] Dead code detection via import graph analysis
+- [ ] cleanup-manifest.json written with complete data
+- [ ] Each item has risk level and cleanup reason
+`
+)
+```
+
+---
+
+### Phase 3: Confirmation
+
+**Step 3.1: Display Summary**
+```javascript
+const manifest = JSON.parse(Read(`${sessionFolder}/cleanup-manifest.json`))
+
+console.log(`
+## Cleanup Discovery Report
+
+**Mainline Health**: ${Math.round(manifest.mainline_summary.health_score * 100)}%
+**Core Modules**: ${manifest.mainline_summary.core_modules.join(', ')}
+
+### Summary
+| Category | Count | Size | Risk |
+|----------|-------|------|------|
+| Stale Sessions | ${manifest.summary.by_category.stale_sessions} | - | ${getRiskSummary('sessions')} |
+| Drifted Documents | ${manifest.summary.by_category.drifted_documents} | - | ${getRiskSummary('documents')} |
+| Dead Code | ${manifest.summary.by_category.dead_code} | - | ${getRiskSummary('code')} |
+
+**Total**: ${manifest.summary.total_items} items, ~${manifest.summary.total_size_mb} MB
+
+### Stale Sessions
+${manifest.discoveries.stale_sessions.map(s =>
+  `- ${s.path} (${s.age_days}d, ${s.risk}): ${s.reason}`
+).join('\n')}
+
+### Drifted Documents
+${manifest.discoveries.drifted_documents.map(d =>
+  `- ${d.path} (${d.drift_percentage}% broken, ${d.risk}): ${d.reason}`
+).join('\n')}
+
+### Dead Code
+${manifest.discoveries.dead_code.map(c =>
+  `- ${c.path} (${c.type}, ${c.risk}): ${c.reason}`
+).join('\n')}
+`)
+```
+
+**Step 3.2: Dry-Run Exit**
+```javascript
+if (flags.includes('--dry-run')) {
+  console.log(`
+---
+**Dry-run mode**: No changes made.
+Manifest saved to: ${sessionFolder}/cleanup-manifest.json
+
+To execute cleanup: /workflow:clean
+`)
+  return
+}
+```
+
+**Step 3.3: User Confirmation**
+```javascript
+AskUserQuestion({
+  questions: [
+    {
+      question: "Which categories to clean?",
+      header: "Categories",
+      multiSelect: true,
+      options: [
+        {
+          label: "Sessions",
+          description: `${manifest.summary.by_category.stale_sessions} stale workflow sessions`
+        },
+        {
+          label: "Documents",
+          description: `${manifest.summary.by_category.drifted_documents} drifted documents`
+        },
+        {
+          label: "Dead Code",
+          description: `${manifest.summary.by_category.dead_code} unused code files`
+        }
+      ]
+    },
+    {
+      question: "Risk level to include?",
+      header: "Risk",
+      multiSelect: false,
+      options: [
+        { label: "Low only", description: "Safest - only obviously stale items" },
+        { label: "Low + Medium", description: "Recommended - includes likely unused items" },
+        { label: "All", description: "Aggressive - includes high-risk items" }
+      ]
+    }
+  ]
+})
+```
+
+---
+
+### Phase 4: Execution
+
+**Step 4.1: Filter Items by Selection**
+```javascript
+const selectedCategories = userSelection.categories  // ['Sessions', 'Documents', ...]
+const riskLevel = userSelection.risk                 // 'Low only', 'Low + Medium', 'All'
+
+const riskFilter = {
+  'Low only': ['low'],
+  'Low + Medium': ['low', 'medium'],
+  'All': ['low', 'medium', 'high']
+}[riskLevel]
+
+const itemsToClean = []
+
+if (selectedCategories.includes('Sessions')) {
+  itemsToClean.push(...manifest.discoveries.stale_sessions.filter(s => riskFilter.includes(s.risk)))
+}
+if (selectedCategories.includes('Documents')) {
+  itemsToClean.push(...manifest.discoveries.drifted_documents.filter(d => riskFilter.includes(d.risk)))
+}
+if (selectedCategories.includes('Dead Code')) {
+  itemsToClean.push(...manifest.discoveries.dead_code.filter(c => riskFilter.includes(c.risk)))
+}
+
+TodoWrite({
+  todos: itemsToClean.map(item => ({
+    content: `Clean: ${item.path}`,
+    status: "pending",
+    activeForm: `Cleaning ${item.path}`
+  }))
+})
+```
+
+**Step 4.2: Execute Cleanup**
+```javascript
+const results = { deleted: [], failed: [], skipped: [] }
+
+for (const item of itemsToClean) {
+  TodoWrite({ todos: [...] })  // Mark current as in_progress
+
+  try {
+    if (item.type === 'orphan_file' || item.type === 'dead_export') {
+      // Dead code: Delete file or remove export
+      Bash({ command: `rm -rf "${item.path}"` })
+    } else {
+      // Sessions and documents: Delete directory/file
+      Bash({ command: `rm -rf "${item.path}"` })
+    }
+
+    results.deleted.push(item.path)
+    TodoWrite({ todos: [...] })  // Mark as completed
+  } catch (error) {
+    results.failed.push({ path: item.path, error: error.message })
+  }
+}
+```
+
+**Step 4.3: Update Manifests**
+```javascript
+// Update archives manifest if sessions were deleted
+if (selectedCategories.includes('Sessions')) {
+  const archiveManifestPath = '.workflow/archives/manifest.json'
+  if (fileExists(archiveManifestPath)) {
+    const archiveManifest = JSON.parse(Read(archiveManifestPath))
+    const deletedSessionIds = results.deleted
+      .filter(p => p.includes('WFS-'))
+      .map(p => p.split('/').pop())
+
+    const updatedManifest = archiveManifest.filter(entry =>
+      !deletedSessionIds.includes(entry.session_id)
+    )
+
+    Write(archiveManifestPath, JSON.stringify(updatedManifest, null, 2))
+  }
+}
+
+// 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)
+
+  project.features = project.features.filter(f =>
+    !deletedPaths.has(f.traceability?.archive_path)
+  )
+
+  project.statistics.total_features = project.features.length
+  project.statistics.last_updated = getUtc8ISOString()
+
+  Write(projectPath, JSON.stringify(project, null, 2))
+}
+```
+
+**Step 4.4: Report Results**
+```javascript
+console.log(`
+## Cleanup Complete
+
+**Deleted**: ${results.deleted.length} items
+**Failed**: ${results.failed.length} items
+**Skipped**: ${results.skipped.length} items
+
+### Deleted Items
+${results.deleted.map(p => `- ${p}`).join('\n')}
+
+${results.failed.length > 0 ? `
+### Failed Items
+${results.failed.map(f => `- ${f.path}: ${f.error}`).join('\n')}
+` : ''}
+
+Cleanup manifest archived to: ${sessionFolder}/cleanup-manifest.json
+`)
+```
+
+---
+
+## Session Folder Structure
+
+```
+.workflow/.clean/{YYYY-MM-DD}/
+├── mainline-profile.json     # Git history analysis
+└── cleanup-manifest.json     # Discovery results
+```
+
+## Risk Level Definitions
+
+| Risk | Description | Examples |
+|------|-------------|----------|
+| **Low** | Safe to delete, no dependencies | Empty sessions, scratchpad files, 100% broken docs |
+| **Medium** | Likely unused, verify before delete | Orphan files, old archives, partially broken docs |
+| **High** | May have hidden dependencies | Files with some imports, recent modifications |
+
+## Error Handling
+
+| Situation | Action |
+|-----------|--------|
+| No git repository | Skip mainline detection, use file timestamps only |
+| Session in use (.archiving) | Skip with warning |
+| Permission denied | Report error, continue with others |
+| Manifest parse error | Regenerate from filesystem scan |
+| Empty discovery | Report "codebase is clean" |
+
+## Related Commands
+
+- `/workflow:session:complete` - Properly archive active sessions
+- `/memory:compact` - Save session memory before cleanup
+- `/workflow:status` - View current workflow state

.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

@@ -0,0 +1,327 @@
+---
+name: debug
+description: Interactive hypothesis-driven debugging with NDJSON logging, iterative until resolved
+argument-hint: "\"bug description or error message\""
+allowed-tools: TodoWrite(*), Task(*), AskUserQuestion(*), Read(*), Grep(*), Glob(*), Bash(*), Edit(*), Write(*)
+---
+
+# Workflow Debug Command (/workflow:debug)
+
+## Overview
+
+Evidence-based interactive debugging command. Systematically identifies root causes through hypothesis-driven logging and iterative verification.
+
+**Core workflow**: Explore → Add Logging → Reproduce → Analyze Log → Fix → Verify
+
+## Usage
+
+```bash
+/workflow:debug <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 + debug.log has content → Analyze mode
+   └─ NOT_FOUND or empty log → Explore mode
+
+Explore Mode:
+   ├─ Locate error source in codebase
+   ├─ Generate testable hypotheses (dynamic count)
+   ├─ Add NDJSON logging instrumentation
+   └─ Output: Hypothesis list + await user reproduction
+
+Analyze Mode:
+   ├─ Parse debug.log, validate each hypothesis
+   └─ Decision:
+       ├─ Confirmed → Fix root cause
+       ├─ Inconclusive → Add more logging, iterate
+       └─ All rejected → Generate new hypotheses
+
+Fix & Cleanup:
+   ├─ Apply fix based on confirmed hypothesis
+   ├─ User verifies
+   ├─ 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`
+
+// Auto-detect mode
+const sessionExists = fs.existsSync(sessionFolder)
+const logHasContent = sessionExists && fs.existsSync(debugLogPath) && fs.statSync(debugLogPath).size > 0
+
+const mode = logHasContent ? 'analyze' : '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)
+// e.g., ['Stack Length', '未找到', 'registered 0']
+
+// Search codebase for error locations
+for (const keyword of keywords) {
+  Grep({ pattern: keyword, path: ".", output_mode: "content", "-C": 3 })
+}
+
+// Identify affected files and functions
+const affectedLocations = [...]  // from search results
+```
+
+**Step 1.2: Generate Hypotheses (Dynamic)**
+
+```javascript
+// Hypothesis categories based on error pattern
+const HYPOTHESIS_PATTERNS = {
+  "not found|missing|undefined|未找到": "data_mismatch",
+  "0|empty|zero|registered 0": "logic_error",
+  "timeout|connection|sync": "integration_issue",
+  "type|format|parse": "type_mismatch"
+}
+
+// Generate hypotheses based on actual issue (NOT fixed count)
+function generateHypotheses(bugDescription, affectedLocations) {
+  const hypotheses = []
+
+  // Analyze bug and create targeted hypotheses
+  // Each hypothesis has:
+  // - id: H1, H2, ... (dynamic count)
+  // - description: What might be wrong
+  // - testable_condition: What to log
+  // - logging_point: Where to add instrumentation
+
+  return hypotheses  // Could be 1, 3, 5, or more
+}
+
+const hypotheses = generateHypotheses(bug_description, affectedLocations)
+```
+
+**Step 1.3: Add NDJSON Instrumentation**
+
+For each hypothesis, add logging at the relevant location:
+
+**Python template**:
+```python
+# region debug [H{n}]
+try:
+    import json, time
+    _dbg = {
+        "sid": "{sessionId}",
+        "hid": "H{n}",
+        "loc": "{file}:{line}",
+        "msg": "{testable_condition}",
+        "data": {
+            # Capture relevant values here
+        },
+        "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
+```
+
+**JavaScript/TypeScript template**:
+```javascript
+// region debug [H{n}]
+try {
+  require('fs').appendFileSync("{debugLogPath}", JSON.stringify({
+    sid: "{sessionId}",
+    hid: "H{n}",
+    loc: "{file}:{line}",
+    msg: "{testable_condition}",
+    data: { /* Capture relevant values */ },
+    ts: Date.now()
+  }) + "\n");
+} catch(_) {}
+// endregion
+```
+
+**Output to user**:
+```
+## Hypotheses Generated
+
+Based on error "{bug_description}", generated {n} hypotheses:
+
+{hypotheses.map(h => `
+### ${h.id}: ${h.description}
+- Logging at: ${h.logging_point}
+- Testing: ${h.testable_condition}
+`).join('')}
+
+**Debug log**: ${debugLogPath}
+
+**Next**: Run reproduction steps, then come back for analysis.
+```
+
+---
+
+### Analyze Mode
+
+```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')
+
+// Validate each hypothesis
+for (const [hid, logs] of Object.entries(byHypothesis)) {
+  const hypothesis = hypotheses.find(h => h.id === hid)
+  const latestLog = logs[logs.length - 1]
+
+  // Check if evidence confirms or rejects hypothesis
+  const verdict = evaluateEvidence(hypothesis, latestLog.data)
+  // Returns: 'confirmed' | 'rejected' | 'inconclusive'
+}
+```
+
+**Output**:
+```
+## Evidence Analysis
+
+Analyzed ${entries.length} log entries.
+
+${results.map(r => `
+### ${r.id}: ${r.description}
+- **Status**: ${r.verdict}
+- **Evidence**: ${JSON.stringify(r.evidence)}
+- **Reason**: ${r.reason}
+`).join('')}
+
+${confirmedHypothesis ? `
+## Root Cause Identified
+
+**${confirmedHypothesis.id}**: ${confirmedHypothesis.description}
+
+Ready to fix.
+` : `
+## Need More Evidence
+
+Add more logging or refine hypotheses.
+`}
+```
+
+---
+
+### Fix & Cleanup
+
+```javascript
+// Apply fix based on confirmed hypothesis
+// ... Edit affected files
+
+// After user verifies fix works:
+
+// Remove debug instrumentation (search for region markers)
+const instrumentedFiles = Grep({
+  pattern: "# region debug|// region debug",
+  output_mode: "files_with_matches"
+})
+
+for (const file of instrumentedFiles) {
+  // Remove content between region markers
+  removeDebugRegions(file)
+}
+
+console.log(`
+## Debug Complete
+
+- Root cause: ${confirmedHypothesis.description}
+- Fix applied to: ${modifiedFiles.join(', ')}
+- Debug instrumentation removed
+`)
+```
+
+---
+
+## Debug Log Format (NDJSON)
+
+Each line is a JSON object:
+
+```json
+{"sid":"DBG-xxx-2025-12-18","hid":"H1","loc":"file.py:func:42","msg":"Check dict keys","data":{"keys":["a","b"],"target":"c","found":false},"ts":1734567890123}
+```
+
+| Field | Description |
+|-------|-------------|
+| `sid` | Session ID |
+| `hid` | Hypothesis ID (H1, H2, ...) |
+| `loc` | Code location |
+| `msg` | What's being tested |
+| `data` | Captured values |
+| `ts` | Timestamp (ms) |
+
+## Session Folder
+
+```
+.workflow/.debug/DBG-{slug}-{date}/
+├── debug.log          # NDJSON log (main artifact)
+└── resolution.md      # Summary after fix (optional)
+```
+
+## Iteration Flow
+
+```
+First Call (/workflow:debug "error"):
+   ├─ No session exists → Explore mode
+   ├─ Extract error keywords, search codebase
+   ├─ Generate hypotheses, add logging
+   └─ Await user reproduction
+
+After Reproduction (/workflow:debug "error"):
+   ├─ Session exists + debug.log has content → Analyze mode
+   ├─ Parse log, evaluate hypotheses
+   └─ Decision:
+       ├─ Confirmed → Fix → User verify
+       │   ├─ Fixed → Cleanup → Done
+       │   └─ Not fixed → Add logging → Iterate
+       ├─ Inconclusive → Add logging → Iterate
+       └─ All rejected → New hypotheses → Iterate
+
+Output:
+   └─ .workflow/.debug/DBG-{slug}-{date}/debug.log
+```
+
+## 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 | Generate new hypotheses with broader scope |
+| Fix doesn't work | Iterate with more granular logging |
+| >5 iterations | Escalate to `/workflow:lite-fix` with evidence |

.claude/commands/workflow/execute.md

@@ -1,266 +1,498 @@
 ---
 name: execute
-description: Coordinate agents for existing workflow tasks with automatic discovery
-usage: /workflow:execute
-argument-hint: none
-examples:
-  - /workflow:execute
+description: Coordinate agent execution for workflow tasks with automatic session discovery, parallel task processing, and status tracking
+argument-hint: "[--resume-session=\"session-id\"]"
 ---
 
-# Workflow Execute Command (/workflow:execute)
+# Workflow Execute Command
 
 ## Overview
-Coordinates multiple agents for executing existing workflow tasks through automatic discovery and intelligent task orchestration. Analyzes workflow folders, checks task statuses, and coordinates agent execution based on discovered plans.
+Orchestrates autonomous workflow execution through systematic task discovery, agent coordination, and progress tracking. **Executes entire workflow without user interruption** (except initial session selection if multiple active sessions exist), providing complete context to agents and ensuring proper flow control execution with comprehensive TodoWrite tracking.
 
-## Core Principles
-  
-**Session Management:** @~/.claude/workflows/workflow-architecture.md
-**Agent Orchestration:** @~/.claude/workflows/agent-orchestration-patterns.md
+**Resume Mode**: When called with `--resume-session` flag, skips discovery phase and directly enters TodoWrite generation and agent execution for the specified session.
+
+## Performance Optimization Strategy
+
+**Lazy Loading**: Task JSONs read **on-demand** during execution, not upfront. TODO_LIST.md + IMPL_PLAN.md provide metadata for planning.
+
+**Loading Strategy**:
+- **TODO_LIST.md**: Read in Phase 3 (task metadata, status, dependencies for TodoWrite generation)
+- **IMPL_PLAN.md**: Check existence in Phase 2 (normal mode), parse execution strategy in Phase 4A
+- **Task JSONs**: Lazy loading - read only when task is about to execute (Phase 4B)
+
+## 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.**
+**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
+- **Session Discovery**: Identify and select active workflow sessions
+- **Execution Strategy Parsing**: Extract execution model from IMPL_PLAN.md
+- **TodoWrite Progress Tracking**: Maintain real-time execution status throughout entire workflow
+- **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 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
+- **Autonomous completion**: Execute all tasks without user interruption until workflow complete
 
-The intelligent execution approach focuses on:
-- **Discovery-first execution** - Automatically discover existing plans and tasks
-- **Status-aware coordination** - Execute only tasks that are ready
-- **Context-rich agent assignment** - Use complete task JSON data for agent context  
-- **Dynamic task orchestration** - Coordinate based on discovered task relationships
-- **Progress tracking** - Update task status after agent completion
+## Execution Process
 
-**IMPORTANT**: Gemini context analysis is automatically applied based on discovered task scope and requirements.
-
-## Execution Flow
-
-### 1. Discovery & Analysis Phase
 ```
-Workflow Discovery:
-├── Locate workflow folder (provided or current session)
-├── Load workflow-session.json for session state  
-├── Scan .task/ directory for all task JSON files
-├── Read IMPL_PLAN.md for workflow context
-├── Analyze task statuses and dependencies
-└── Determine executable tasks
+Normal Mode:
+Phase 1: Discovery
+   ├─ Count active sessions
+   └─ Decision:
+      ├─ count=0 → ERROR: No active sessions
+      ├─ count=1 → Auto-select session → Phase 2
+      └─ count>1 → AskUserQuestion (max 4 options) → Phase 2
+
+Phase 2: Planning Document Validation
+   ├─ Check IMPL_PLAN.md exists
+   ├─ Check TODO_LIST.md exists
+   └─ Validate .task/ contains IMPL-*.json files
+
+Phase 3: TodoWrite Generation
+   ├─ Update session status to "active" (Step 0)
+   ├─ Parse TODO_LIST.md for task statuses
+   ├─ Generate TodoWrite for entire workflow
+   └─ Prepare session context paths
+
+Phase 4: Execution Strategy & Task Execution
+   ├─ Step 4A: Parse execution strategy from IMPL_PLAN.md
+   └─ Step 4B: Execute tasks with lazy loading
+      └─ Loop:
+         ├─ Get next in_progress task from TodoWrite
+         ├─ Lazy load task JSON
+         ├─ Launch agent with task context
+         ├─ Mark task completed (update IMPL-*.json status)
+         │  # Quick fix: Update task status for ccw dashboard
+         │  # TS=$(date -Iseconds) && jq --arg ts "$TS" '.status="completed" | .status_history=(.status_history // [])+[{"from":"in_progress","to":"completed","changed_at":$ts}]' IMPL-X.json > tmp.json && mv tmp.json IMPL-X.json
+         └─ Advance to next task
+
+Phase 5: Completion
+   ├─ Update task statuses in JSON files
+   ├─ Generate summaries
+   └─ AskUserQuestion: Choose next step
+      ├─ "Enter Review" → /workflow:review
+      └─ "Complete Session" → /workflow:session:complete
+
+Resume Mode (--resume-session):
+   ├─ Skip Phase 1 & Phase 2
+   └─ Entry Point: Phase 3 (TodoWrite Generation)
+      ├─ Update session status to "active" (if not already)
+      └─ Continue: Phase 4 → Phase 5
 ```
 
-**Discovery Logic:**
-- **Folder Detection**: Use provided folder or find current active session
-- **Task Inventory**: Load all impl-*.json files from .task/ directory
-- **Status Analysis**: Check pending/active/completed/blocked states
-- **Dependency Check**: Verify all task dependencies are met
-- **Execution Queue**: Build list of ready-to-execute tasks
+## Execution Lifecycle
 
-### 2. TodoWrite Coordination Setup
-**Always First**: Create comprehensive TodoWrite based on discovered tasks
+### Phase 1: Discovery
+**Applies to**: Normal mode only (skipped in resume mode)
 
-```markdown
-# Workflow Execute Coordination
-*Session: WFS-[topic-slug]*
+**Purpose**: Find and select active workflow session with user confirmation when multiple sessions exist
 
-## Execution Plan
-- [ ] **TASK-001**: [Agent: planning-agent] [GEMINI_CLI_REQUIRED] Design auth schema (impl-1.1)
-- [ ] **TASK-002**: [Agent: code-developer] [GEMINI_CLI_REQUIRED] Implement auth logic (impl-1.2)  
-- [ ] **TASK-003**: [Agent: code-review-agent] Review implementations
-- [ ] **TASK-004**: Update task statuses and session state
+**Process**:
+
+#### Step 1.1: Count Active Sessions
+```bash
+bash(find .workflow/active/ -name "WFS-*" -type d 2>/dev/null | wc -l)
 ```
 
-### 3. Agent Context Assignment
-For each executable task:
+#### Step 1.2: Handle Session Selection
 
-```json
-{
-  "task": {
-    "id": "impl-1.1",
-    "title": "Design auth schema",
-    "context": {
-      "requirements": ["JWT authentication", "User model design"],
-      "scope": ["src/auth/models/*"],
-      "acceptance": ["Schema validates JWT tokens"]
+**Case A: No Sessions** (count = 0)
+```
+ERROR: No active workflow sessions found
+Run /workflow:plan "task description" to create a session
+```
+
+**Case B: Single Session** (count = 1)
+```bash
+bash(find .workflow/active/ -name "WFS-*" -type d 2>/dev/null | head -1 | xargs basename)
+```
+Auto-select and continue to Phase 2.
+
+**Case C: Multiple Sessions** (count > 1)
+
+List sessions with metadata and prompt user selection:
+```bash
+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):
+```javascript
+// If more than 4 sessions, show most recent 4 with "Other" option for manual input
+const sessions = getActiveSessions()  // sorted by last modified
+const displaySessions = sessions.slice(0, 4)
+
+AskUserQuestion({
+  questions: [{
+    question: "Multiple active sessions detected. Select one:",
+    header: "Session",
+    multiSelect: false,
+    options: displaySessions.map(s => ({
+      label: s.id,
+      description: `${s.project} | ${s.progress}`
+    }))
+    // Note: User can select "Other" to manually enter session ID
+  }]
+})
+```
+
+**Input Validation**:
+- If user selects from options: Use selected session ID
+- If user selects "Other" and provides input: Validate session exists
+- If validation fails: Show error and re-prompt or suggest available sessions
+
+Parse user input (supports: number "1", full ID "WFS-auth-system", or partial "auth"), validate selection, and continue to Phase 2.
+
+#### Step 1.3: Load Session Metadata
+```bash
+bash(cat .workflow/active/${sessionId}/workflow-session.json)
+```
+
+**Output**: Store session metadata in memory
+**DO NOT read task JSONs yet** - defer until execution phase (lazy loading)
+
+**Resume Mode**: This entire phase is skipped when `--resume-session="session-id"` flag is provided.
+
+### Phase 2: Planning Document Validation
+**Applies to**: Normal mode only (skipped in resume mode)
+
+**Purpose**: Validate planning artifacts exist before execution
+
+**Process**:
+1. **Check IMPL_PLAN.md**: Verify file exists (defer detailed parsing to Phase 4A)
+2. **Check TODO_LIST.md**: Verify file exists (defer reading to Phase 3)
+3. **Validate Task Directory**: Ensure `.task/` contains at least one IMPL-*.json file
+
+**Key Optimization**: Only existence checks here. Actual file reading happens in later phases.
+
+**Resume Mode**: This phase is skipped when `--resume-session` flag is provided. Resume mode entry point is Phase 3.
+
+### Phase 3: TodoWrite Generation
+**Applies to**: Both normal and resume modes (resume mode entry point)
+
+**Step 0: Update Session Status to Active**
+Before generating TodoWrite, update session status from "planning" to "active":
+```bash
+# Update session status (idempotent - safe to run if already active)
+jq '.status = "active" | .execution_started_at = (.execution_started_at // now | todate)' \
+  .workflow/active/${sessionId}/workflow-session.json > tmp.json && \
+  mv tmp.json .workflow/active/${sessionId}/workflow-session.json
+```
+This ensures the dashboard shows the session as "ACTIVE" during execution.
+
+**Process**:
+1. **Create TodoWrite List**: Generate task list from TODO_LIST.md (not from task JSONs)
+   - Parse TODO_LIST.md to extract all tasks with current statuses
+   - Identify first pending task with met dependencies
+   - Generate comprehensive TodoWrite covering entire workflow
+2. **Prepare Session Context**: Inject workflow paths for agent use (using provided session-id)
+3. **Validate Prerequisites**: Ensure IMPL_PLAN.md and TODO_LIST.md exist and are valid
+
+**Resume Mode Behavior**:
+- Load existing TODO_LIST.md directly from `.workflow/active/{session-id}/`
+- Extract current progress from TODO_LIST.md
+- Generate TodoWrite from TODO_LIST.md state
+- Proceed immediately to agent execution (Phase 4)
+
+### Phase 4: Execution Strategy Selection & Task Execution
+**Applies to**: Both normal and resume modes
+
+**Step 4A: Parse Execution Strategy from IMPL_PLAN.md**
+
+Read IMPL_PLAN.md Section 4 to extract:
+- **Execution Model**: Sequential | Parallel | Phased | TDD Cycles
+- **Parallelization Opportunities**: Which tasks can run in parallel
+- **Serialization Requirements**: Which tasks must run sequentially
+- **Critical Path**: Priority execution order
+
+If IMPL_PLAN.md lacks execution strategy, use intelligent fallback (analyze task structure).
+
+**Step 4B: Execute Tasks with Lazy Loading**
+
+**Key Optimization**: Read task JSON **only when needed** for execution
+
+**Execution Loop Pattern**:
+```
+while (TODO_LIST.md has pending tasks) {
+  next_task_id = getTodoWriteInProgressTask()
+  task_json = Read(.workflow/active/{session}/.task/{next_task_id}.json)  // Lazy load
+  executeTaskWithAgent(task_json)
+  updateTodoListMarkCompleted(next_task_id)
+  advanceTodoWriteToNextTask()
+}
+```
+
+**Execution Process per Task**:
+1. **Identify Next Task**: From TodoWrite, get the next `in_progress` task ID
+2. **Load Task JSON on Demand**: Read `.task/{task-id}.json` for current task ONLY
+3. **Validate Task Structure**: Ensure all 5 required fields exist (id, title, status, meta, context, flow_control)
+4. **Launch Agent**: Invoke specialized agent with complete context including flow control steps
+5. **Monitor Progress**: Track agent execution and handle errors without user interruption
+6. **Collect Results**: Gather implementation results and outputs
+7. **Continue Workflow**: Identify next pending task from TODO_LIST.md and repeat
+
+**Note**: TODO_LIST.md updates are handled by agents (e.g., code-developer.md), not by the orchestrator.
+
+
+### Phase 5: Completion
+**Applies to**: Both normal and resume modes
+
+**Process**:
+1. **Update Task Status**: Mark completed tasks in JSON files
+2. **Generate Summary**: Create task summary in `.summaries/`
+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. **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)
+
+### Strategy Priority
+
+**IMPL_PLAN-Driven Execution (Recommended)**:
+1. **Read IMPL_PLAN.md execution strategy** (Section 4: Implementation Strategy)
+2. **Follow explicit guidance**:
+   - Execution Model (Sequential/Parallel/Phased/TDD)
+   - Parallelization Opportunities (which tasks can run in parallel)
+   - Serialization Requirements (which tasks must run sequentially)
+   - Critical Path (priority execution order)
+3. **Use TODO_LIST.md for status tracking** only
+4. **IMPL_PLAN decides "HOW"**, execute.md implements it
+
+**Intelligent Fallback (When IMPL_PLAN lacks execution details)**:
+1. **Analyze task structure**:
+   - Check `meta.execution_group` in task JSONs
+   - Analyze `depends_on` relationships
+   - Understand task complexity and risk
+2. **Apply smart defaults**:
+   - No dependencies + same execution_group → Parallel
+   - Has dependencies → Sequential (wait for deps)
+   - Critical/high-risk tasks → Sequential
+3. **Conservative approach**: When uncertain, prefer sequential execution
+
+### Execution Models
+
+#### 1. Sequential Execution
+**When**: IMPL_PLAN specifies "Sequential" OR no clear parallelization guidance
+**Pattern**: Execute tasks one by one in TODO_LIST order
+**TodoWrite**: ONE task marked as `in_progress` at a time
+
+#### 2. Parallel Execution
+**When**: IMPL_PLAN specifies "Parallel" with clear parallelization opportunities
+**Pattern**: Execute independent task groups concurrently by launching multiple agent instances
+**TodoWrite**: MULTIPLE tasks (in same batch) marked as `in_progress` simultaneously
+**Agent Instantiation**: Launch one agent instance per task (respects ONE AGENT = ONE TASK JSON rule)
+
+#### 3. Phased Execution
+**When**: IMPL_PLAN specifies "Phased" with phase breakdown
+**Pattern**: Execute tasks in phases, respect phase boundaries
+**TodoWrite**: Within each phase, follow Sequential or Parallel rules
+
+#### 4. Intelligent Fallback
+**When**: IMPL_PLAN lacks execution strategy details
+**Pattern**: Analyze task structure and apply smart defaults
+**TodoWrite**: Follow Sequential or Parallel rules based on analysis
+
+### Task Status Logic
+```
+pending + dependencies_met → executable
+completed → skip
+blocked → skip until dependencies clear
+```
+
+## TodoWrite Coordination
+
+### TodoWrite Rules (Unified)
+
+**Rule 1: Initial Creation**
+- **Normal Mode**: Generate TodoWrite from discovered pending tasks for entire workflow
+- **Resume Mode**: Generate from existing session state and current progress
+
+**Rule 2: In-Progress Task Count (Execution-Model-Dependent)**
+- **Sequential execution**: Mark ONLY ONE task as `in_progress` at a time
+- **Parallel batch execution**: Mark ALL tasks in current batch as `in_progress` simultaneously
+- **Execution group indicator**: Show `[execution_group: group-id]` for parallel tasks
+
+**Rule 3: Status Updates**
+- **Immediate Updates**: Update status after each task/batch completion without user interruption
+- **Status Synchronization**: Sync with JSON task files after updates
+- **Continuous Tracking**: Maintain TodoWrite throughout entire workflow execution until completion
+
+**Rule 4: Workflow Completion Check**
+- When all tasks marked `completed`, prompt user to choose review or complete session
+
+### TodoWrite Tool Usage
+
+**Example 1: Sequential Execution**
+```javascript
+TodoWrite({
+  todos: [
+    {
+      content: "Execute IMPL-1.1: Design auth schema [code-developer] [FLOW_CONTROL]",
+      status: "in_progress",  // ONE task in progress
+      activeForm: "Executing IMPL-1.1: Design auth schema"
+    },
+    {
+      content: "Execute IMPL-1.2: Implement auth logic [code-developer] [FLOW_CONTROL]",
+      status: "pending",
+      activeForm: "Executing IMPL-1.2: Implement auth logic"
     }
-  },
-  "workflow": {
-    "session": "WFS-user-auth", 
-    "phase": "IMPLEMENT",
-    "plan_context": "Authentication system with OAuth2 support"
-  },
-  "focus_modules": ["src/auth/", "tests/auth/"],
-  "gemini_required": true
-}
+  ]
+});
 ```
 
-**Context Assignment Rules:**
-- **Complete Context**: Use full task JSON context for agent execution
-- **Workflow Integration**: Include session state and IMPL_PLAN.md context
-- **Scope Focus**: Direct agents to specific files from task.context.scope
-- **Gemini Flags**: Automatically add [GEMINI_CLI_REQUIRED] for multi-file tasks
+**Example 2: Parallel Batch Execution**
+```javascript
+TodoWrite({
+  todos: [
+    {
+      content: "Execute IMPL-1.1: Build Auth API [code-developer] [execution_group: parallel-auth-api]",
+      status: "in_progress",  // Batch task 1
+      activeForm: "Executing IMPL-1.1: Build Auth API"
+    },
+    {
+      content: "Execute IMPL-1.2: Build User UI [code-developer] [execution_group: parallel-ui-comp]",
+      status: "in_progress",  // Batch task 2 (running concurrently)
+      activeForm: "Executing IMPL-1.2: Build User UI"
+    },
+    {
+      content: "Execute IMPL-1.3: Setup Database [code-developer] [execution_group: parallel-db-schema]",
+      status: "in_progress",  // Batch task 3 (running concurrently)
+      activeForm: "Executing IMPL-1.3: Setup Database"
+    },
+    {
+      content: "Execute IMPL-2.1: Integration Tests [test-fix-agent] [depends_on: IMPL-1.1, IMPL-1.2, IMPL-1.3]",
+      status: "pending",  // Next batch (waits for current batch completion)
+      activeForm: "Executing IMPL-2.1: Integration Tests"
+    }
+  ]
+});
+```
 
-### 4. Agent Execution & Progress Tracking
+## Agent Execution Pattern
+
+### Flow Control Execution
+**[FLOW_CONTROL]** marker indicates task JSON contains `flow_control.pre_analysis` steps for context preparation.
+
+**Note**: Orchestrator does NOT execute flow control steps - Agent interprets and executes them autonomously.
+
+### Agent Prompt Template
+**Path-Based Invocation**: Pass paths and trigger markers, let agent parse task JSON autonomously.
 
 ```bash
-Task(subagent_type="code-developer",
-     prompt="[GEMINI_CLI_REQUIRED] Implement authentication logic based on schema",
-     description="Execute impl-1.2 with full workflow context and status tracking")
+Task(subagent_type="{meta.agent}",
+     run_in_background=false,
+     prompt="Implement task {task.id}: {task.title}
+
+     [FLOW_CONTROL]
+
+     **Input**:
+     - Task JSON: {session.task_json_path}
+     - Context Package: {session.context_package_path}
+
+     **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}")
 ```
 
-**Execution Protocol:**
-- **Sequential Execution**: Respect task dependencies and execution order
-- **Progress Monitoring**: Track through TodoWrite updates
-- **Status Updates**: Update task JSON status after each completion
-- **Cross-Agent Handoffs**: Coordinate results between related tasks
+**Key Markers**:
+- `Implement` keyword: Triggers tech stack detection and guidelines loading
+- `[FLOW_CONTROL]`: Triggers flow_control.pre_analysis execution
 
-## Discovery & Analysis Process
+**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
 
-### File Structure Analysis
+Embedding task content in prompt creates duplication and conflicts with agent's parsing logic.
+
+### Agent Assignment Rules
 ```
-.workflow/WFS-[topic-slug]/
-├── workflow-session.json     # Session state and stats
-├── IMPL_PLAN.md             # Workflow context and requirements  
-├── .task/                   # Task definitions
-│   ├── impl-1.json         # Main tasks
-│   ├── impl-1.1.json       # Subtasks
-│   └── impl-1.2.json       # Detailed tasks
-└── .summaries/             # Completed task summaries
+meta.agent specified → Use specified agent
+meta.agent missing → Infer from meta.type:
+  - "feature" → @code-developer
+  - "test-gen" → @code-developer
+  - "test-fix" → @test-fix-agent
+  - "review" → @universal-executor
+  - "docs" → @doc-generator
 ```
 
-### Task Status Assessment
-```pseudo
-function analyze_tasks(task_files):
-  executable_tasks = []
-  
-  for task in task_files:
-    if task.status == "pending" and dependencies_met(task):
-      if task.subtasks.length == 0:  // leaf task
-        executable_tasks.append(task)
-      else:  // container task - check subtasks
-        if all_subtasks_ready(task):
-          executable_tasks.extend(task.subtasks)
-  
-  return executable_tasks
+## Workflow File Structure Reference
 ```
-
-### Automatic Agent Assignment
-Based on discovered task data:
-- **task.agent field**: Use specified agent from task JSON
-- **task.type analysis**: 
-  - "feature" → code-developer
-  - "test" → test-agent  
-  - "docs" → docs-agent
-  - "review" → code-review-agent
-- **Gemini context**: Auto-assign based on task.context.scope and requirements
-
-## Agent Task Assignment Patterns
-
-### Discovery-Based Assignment
-```bash
-# Agent receives complete discovered context
-Task(subagent_type="code-developer",
-     prompt="[GEMINI_CLI_REQUIRED] Execute impl-1.2: Implement auth logic
-     
-     Context from discovery:
-     - Requirements: JWT authentication, OAuth2 support
-     - Scope: src/auth/*, tests/auth/*
-     - Dependencies: impl-1.1 (completed)
-     - Workflow: WFS-user-auth authentication system",
-     
-     description="Agent executes with full discovered context")
-```
-
-### Status Tracking Integration
-```bash  
-# After agent completion, update discovered task status
-update_task_status("impl-1.2", "completed")
-mark_dependent_tasks_ready(task_dependencies)
-```
-
-## Coordination Strategies
-
-### Automatic Coordination
-- **Task Dependencies**: Execute in dependency order from discovered relationships
-- **Agent Handoffs**: Pass results between agents based on task hierarchy  
-- **Progress Updates**: Update TodoWrite and JSON files after each completion
-
-### Context Distribution
-- **Rich Context**: Each agent gets complete task JSON + workflow context
-- **Focus Areas**: Direct agents to specific files from task.context.scope
-- **Inheritance**: Subtasks inherit parent context automatically
-- **Session Integration**: Include workflow-session.json state in agent context
-
-## Status Management
-
-### Task Status Updates
-```json
-// Before execution
-{
-  "id": "impl-1.2",
-  "status": "pending",
-  "execution": {
-    "attempts": 0,
-    "last_attempt": null
-  }
-}
-
-// After execution  
-{
-  "id": "impl-1.2", 
-  "status": "completed",
-  "execution": {
-    "attempts": 1,
-    "last_attempt": "2025-09-08T14:30:00Z"
-  }
-}
-```
-
-### Session State Updates
-```json
-{
-  "current_phase": "EXECUTE",
-  "last_execute_run": "2025-09-08T14:30:00Z"
-}
+.workflow/active/WFS-[topic-slug]/
+├── workflow-session.json     # Session state and metadata
+├── IMPL_PLAN.md             # Planning document and requirements
+├── TODO_LIST.md             # Progress tracking (updated by agents)
+├── .task/                   # Task definitions (JSON only)
+│   ├── IMPL-1.json          # Main task definitions
+│   └── IMPL-1.1.json        # Subtask definitions
+├── .summaries/              # Task completion summaries
+│   ├── IMPL-1-summary.md    # Task completion details
+│   └── IMPL-1.1-summary.md  # Subtask completion details
+└── .process/                # Planning artifacts
+    ├── context-package.json # Smart context package
+    └── ANALYSIS_RESULTS.md  # Planning analysis results
 ```
 
 ## Error Handling & Recovery
 
-### Discovery Issues
-```bash
-# No active session found
-❌ No active workflow session found
-→ Use: /workflow:session:start "project name" first
+### Common Errors & Recovery
 
-# No executable tasks  
-⚠️ All tasks completed or blocked
-→ Check: /context for task status overview
+| Error Type | Cause | Recovery Strategy | Max Attempts |
+|-----------|-------|------------------|--------------|
+| **Discovery Errors** |
+| No active session | No sessions in `.workflow/active/` | Create or resume session: `/workflow:plan "project"` | N/A |
+| Multiple sessions | Multiple sessions in `.workflow/active/` | Prompt user selection | N/A |
+| Corrupted session | Invalid JSON files | Recreate session structure or validate files | N/A |
+| **Execution Errors** |
+| Agent failure | Agent crash/timeout | Retry with simplified context | 2 |
+| Flow control error | Command failure | Skip optional, fail critical | 1 per step |
+| Context loading error | Missing dependencies | Reload from JSON, use defaults | 3 |
+| JSON file corruption | File system issues | Restore from backup/recreate | 1 |
 
-# Missing task files
-❌ Task impl-1.2 referenced but JSON file missing
-→ Fix: /task/create or repair task references
-```
+### Error Prevention
+- **Pre-flight Checks**: Validate session integrity before execution
+- **Backup Strategy**: Create task snapshots before major operations
+- **Atomic Updates**: Update JSON files atomically to prevent corruption
+- **Dependency Validation**: Check all depends_on references exist
+- **Context Verification**: Ensure all required context is available
 
-### Execution Recovery
-- **Failed Agent**: Retry with adjusted context or different agent
-- **Blocked Dependencies**: Skip and continue with available tasks
-- **Context Issues**: Reload from JSON files and session state
-
-## Integration Points
-
-### Automatic Behaviors
-- **Discovery on start** - Analyze workflow folder structure
-- **TodoWrite coordination** - Generate based on discovered tasks  
-- **Agent context preparation** - Use complete task JSON data
-- **Status synchronization** - Update JSON files after completion
-
-### Next Actions
-```bash  
-# After /workflow:execute completion
-/context                  # View updated task status
-/task:execute impl-X      # Execute specific remaining tasks  
-/workflow:review          # Move to review phase when complete
-```
-
-## Related Commands
-
-- `/context` - View discovered tasks and current status
-- `/task:execute` - Execute individual tasks (user-controlled)
-- `/workflow:session:status` - Check session progress and dependencies
-- `/workflow:review` - Move to review phase after completion
-
----
-
-**System ensures**: Intelligent task discovery with context-rich agent coordination and automatic progress tracking

.claude/commands/workflow/init.md

@@ -0,0 +1,224 @@
+---
+name: init
+description: Initialize project-level state with intelligent project analysis using cli-explore-agent
+argument-hint: "[--regenerate]"
+examples:
+  - /workflow:init
+  - /workflow:init --regenerate
+---
+
+# Workflow Init Command (/workflow:init)
+
+## Overview
+Initialize `.workflow/project-tech.json` and `.workflow/project-guidelines.json` with comprehensive project understanding by delegating analysis to **cli-explore-agent**.
+
+**Dual File System**:
+- `project-tech.json`: Auto-generated technical analysis (stack, architecture, components)
+- `project-guidelines.json`: User-maintained rules and constraints (created as scaffold)
+
+**Note**: This command may be called by other workflow commands. Upon completion, return immediately to continue the calling workflow without interrupting the task flow.
+
+## Usage
+```bash
+/workflow:init                 # Initialize (skip if exists)
+/workflow:init --regenerate    # Force regeneration
+```
+
+## Execution Process
+
+```
+Input Parsing:
+   └─ Parse --regenerate flag → regenerate = true | false
+
+Decision:
+   ├─ BOTH_EXIST + no --regenerate → Exit: "Already initialized"
+   ├─ EXISTS + --regenerate → Backup existing → Continue analysis
+   └─ NOT_FOUND → Continue analysis
+
+Analysis Flow:
+   ├─ Get project metadata (name, root)
+   ├─ Invoke cli-explore-agent
+   │   ├─ Structural scan (get_modules_by_depth.sh, find, wc)
+   │   ├─ Semantic analysis (Gemini CLI)
+   │   ├─ Synthesis and merge
+   │   └─ Write .workflow/project-tech.json
+   ├─ Create guidelines scaffold (if not exists)
+   │   └─ Write .workflow/project-guidelines.json (empty structure)
+   └─ Display summary
+
+Output:
+   ├─ .workflow/project-tech.json (+ .backup if regenerate)
+   └─ .workflow/project-guidelines.json (scaffold if new)
+```
+
+## Implementation
+
+### Step 1: Parse Input and Check Existing State
+
+**Parse --regenerate flag**:
+```javascript
+const regenerate = $ARGUMENTS.includes('--regenerate')
+```
+
+**Check existing state**:
+
+```bash
+bash(test -f .workflow/project-tech.json && echo "TECH_EXISTS" || echo "TECH_NOT_FOUND")
+bash(test -f .workflow/project-guidelines.json && echo "GUIDELINES_EXISTS" || echo "GUIDELINES_NOT_FOUND")
+```
+
+**If BOTH_EXIST and no --regenerate**: Exit early
+```
+Project already initialized:
+- Tech analysis: .workflow/project-tech.json
+- Guidelines: .workflow/project-guidelines.json
+
+Use /workflow:init --regenerate to rebuild tech analysis
+Use /workflow:session:solidify to add guidelines
+Use /workflow:status --project to view state
+```
+
+### Step 2: Get Project Metadata
+
+```bash
+bash(basename "$(git rev-parse --show-toplevel 2>/dev/null || pwd)")
+bash(git rev-parse --show-toplevel 2>/dev/null || pwd)
+bash(mkdir -p .workflow)
+```
+
+### Step 3: Invoke cli-explore-agent
+
+**For --regenerate**: Backup and preserve existing data
+```bash
+bash(cp .workflow/project-tech.json .workflow/project-tech.json.backup)
+```
+
+**Delegate analysis to agent**:
+
+```javascript
+Task(
+  subagent_type="cli-explore-agent",
+  run_in_background=false,
+  description="Deep project analysis",
+  prompt=`
+Analyze project for workflow initialization and generate .workflow/project-tech.json.
+
+## MANDATORY FIRST STEPS
+1. Execute: cat ~/.claude/workflows/cli-templates/schemas/project-tech-schema.json (get schema reference)
+2. Execute: ccw tool exec get_modules_by_depth '{}' (get project structure)
+
+## Task
+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
+
+**Technology Stack**:
+- Languages: File counts, mark primary
+- Frameworks: From package.json, requirements.txt, go.mod, etc.
+- Build tools: npm, cargo, maven, webpack, vite
+- Test frameworks: jest, pytest, go test, junit
+
+**Architecture**:
+- Style: MVC, microservices, layered (from structure & imports)
+- Layers: presentation, business-logic, data-access
+- Patterns: singleton, factory, repository
+- Key components: 5-10 modules {name, path, description, importance}
+
+## Execution
+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_index and statistics from .workflow/project-tech.json.backup' : ''}
+5. Write JSON: Write('.workflow/project-tech.json', jsonContent)
+6. Report: Return brief completion summary
+
+Project root: ${projectRoot}
+`
+)
+```
+
+### Step 3.5: Create Guidelines Scaffold (if not exists)
+
+```javascript
+// Only create if not exists (never overwrite user guidelines)
+if (!file_exists('.workflow/project-guidelines.json')) {
+  const guidelinesScaffold = {
+    conventions: {
+      coding_style: [],
+      naming_patterns: [],
+      file_structure: [],
+      documentation: []
+    },
+    constraints: {
+      architecture: [],
+      tech_stack: [],
+      performance: [],
+      security: []
+    },
+    quality_rules: [],
+    learnings: [],
+    _metadata: {
+      created_at: new Date().toISOString(),
+      version: "1.0.0"
+    }
+  };
+
+  Write('.workflow/project-guidelines.json', JSON.stringify(guidelinesScaffold, null, 2));
+}
+```
+
+### Step 4: Display Summary
+
+```javascript
+const projectTech = JSON.parse(Read('.workflow/project-tech.json'));
+const guidelinesExists = file_exists('.workflow/project-guidelines.json');
+
+console.log(`
+✓ Project initialized successfully
+
+## Project Overview
+Name: ${projectTech.project_name}
+Description: ${projectTech.overview.description}
+
+### Technology Stack
+Languages: ${projectTech.overview.technology_stack.languages.map(l => l.name).join(', ')}
+Frameworks: ${projectTech.overview.technology_stack.frameworks.join(', ')}
+
+### Architecture
+Style: ${projectTech.overview.architecture.style}
+Components: ${projectTech.overview.key_components.length} core modules
+
+---
+Files created:
+- Tech analysis: .workflow/project-tech.json
+- Guidelines: .workflow/project-guidelines.json ${guidelinesExists ? '(scaffold)' : ''}
+${regenerate ? '- Backup: .workflow/project-tech.json.backup' : ''}
+
+Next steps:
+- Use /workflow:session:solidify to add project guidelines
+- Use /workflow:plan to start planning
+`);
+```
+
+## Error Handling
+
+**Agent Failure**: Fall back to basic initialization with placeholder overview
+**Missing Tools**: Agent uses Qwen fallback or bash-only
+**Empty Project**: Create minimal JSON with all gaps identified

.claude/commands/workflow/issue/close.md

@@ -1,142 +0,0 @@
----
-name: close
-description: Close a completed or obsolete workflow issue
-usage: /workflow:issue:close <issue-id> [reason]
-
-examples:
-  - /workflow:issue:close ISS-001
-  - /workflow:issue:close ISS-001 "Feature implemented in PR #42"
-  - /workflow:issue:close ISS-002 "Duplicate of ISS-001"
----
-
-# Close Workflow Issue (/workflow:issue:close)
-
-## Purpose
-Mark an issue as closed/resolved with optional reason documentation.
-
-## Usage
-```bash
-/workflow:issue:close <issue-id> ["reason"]
-```
-
-## Closing Process
-
-### Quick Close
-Simple closure without reason:
-```bash
-/workflow:issue:close ISS-001
-```
-
-### Close with Reason
-Include closure reason:
-```bash
-/workflow:issue:close ISS-001 "Feature implemented in PR #42"
-/workflow/issue/close ISS-002 "Duplicate of ISS-001"  
-/workflow/issue/close ISS-003 "No longer relevant"
-```
-
-### Interactive Close (Default)
-Without reason, prompts for details:
-```
-Closing Issue ISS-001: Add OAuth2 social login support
-Current Status: Open | Priority: High | Type: Feature
-
-Why is this issue being closed?
-1. ✅ Completed - Issue resolved successfully
-2. 🔄 Duplicate - Duplicate of another issue
-3. ❌ Invalid - Issue is invalid or not applicable  
-4. 🚫 Won't Fix - Decided not to implement
-5. 📝 Custom reason
-
-Choice: _
-```
-
-## Closure Categories
-
-### Completed (Default)
-- Issue was successfully resolved
-- Implementation finished
-- Requirements met
-- Ready for review/testing
-
-### Duplicate
-- Same as existing issue
-- Consolidated into another issue
-- Reference to primary issue provided
-
-### Invalid
-- Issue description unclear
-- Not a valid problem/request
-- Outside project scope
-- Misunderstanding resolved
-
-### Won't Fix
-- Decided not to implement
-- Business decision to decline
-- Technical constraints prevent
-- Priority too low
-
-### Custom Reason
-- Specific project context
-- Detailed explanation needed
-- Complex closure scenario
-
-## Closure Effects
-
-### Status Update
-- Changes status from "open" to "closed"
-- Records closure timestamp
-- Saves closure reason and category
-
-### Integration Cleanup
-- Unlinks from workflow tasks (if integrated)
-- Removes from active TodoWrite items
-- Updates session statistics
-
-### History Preservation
-- Maintains full issue history
-- Records closure details
-- Preserves for future reference
-
-## Session Updates
-
-### Statistics
-Updates session issue counts:
-- Decrements open issues
-- Increments closed issues
-- Updates completion metrics
-
-### Progress Tracking
-- Updates workflow progress
-- Refreshes TodoWrite status
-- Updates session health metrics
-
-## Output
-Displays:
-- Issue closure confirmation
-- Closure reason and category
-- Updated session statistics  
-- Related actions taken
-
-## Reopening
-Closed issues can be reopened:
-```bash
-/workflow/issue/update ISS-001 --status=open
-```
-
-## Error Handling
-- **Issue not found**: Lists available open issues
-- **Already closed**: Shows current status and closure info
-- **Integration conflicts**: Handles task unlinking gracefully
-- **File errors**: Validates and repairs issue files
-
-## Archive Management
-Closed issues:
-- Remain in .issues/ directory
-- Are excluded from default listings
-- Can be viewed with `/workflow/issue/list --closed`
-- Maintain full searchability
-
----
-
-**Result**: Issue properly closed with documented reason and session cleanup

.claude/commands/workflow/issue/create.md

@@ -1,106 +0,0 @@
----
-name: create
-description: Create a new issue or change request
-usage: /workflow:issue:create "issue description"
-
-examples:
-  - /workflow:issue:create "Add OAuth2 social login support"
-  - /workflow:issue:create "Fix user avatar security vulnerability"
----
-
-# Create Workflow Issue (/workflow:issue:create)
-
-## Purpose
-Create a new issue or change request within the current workflow session.
-
-## Usage
-```bash
-/workflow:issue:create "issue description"
-```
-
-## Automatic Behavior
-
-### Issue ID Generation
-- Generates unique ID: ISS-001, ISS-002, etc.
-- Sequential numbering within session
-- Stored in session's .issues/ directory
-
-### Type Detection
-Automatically detects issue type from description:
-- **Bug**: Contains words like "fix", "error", "bug", "broken"
-- **Feature**: Contains words like "add", "implement", "create", "new"
-- **Optimization**: Contains words like "improve", "optimize", "performance"
-- **Documentation**: Contains words like "document", "readme", "docs"
-- **Refactor**: Contains words like "refactor", "cleanup", "restructure"
-
-### Priority Assessment
-Auto-assigns priority based on keywords:
-- **Critical**: "critical", "urgent", "blocker", "security"
-- **High**: "important", "major", "significant"
-- **Medium**: Default for most issues
-- **Low**: "minor", "enhancement", "nice-to-have"
-
-## Issue Storage
-
-### File Structure
-```
-.workflow/WFS-[session]/.issues/
-├── ISS-001.json          # Issue metadata
-├── ISS-002.json          # Another issue
-└── issue-registry.json   # Issue index
-```
-
-### Issue Metadata
-Each issue stores:
-```json
-{
-  "id": "ISS-001",
-  "title": "Add OAuth2 social login support",
-  "type": "feature",
-  "priority": "high",
-  "status": "open",
-  "created_at": "2025-09-08T10:00:00Z",
-  "category": "authentication",
-  "estimated_impact": "medium",
-  "blocking": false,
-  "session_id": "WFS-oauth-integration"
-}
-```
-
-## Session Integration
-
-### Active Session Check
-- Uses current active session (marker file)
-- Creates .issues/ directory if needed
-- Updates session's issue tracking
-
-### TodoWrite Integration
-Optionally adds to task list:
-- Creates todo for issue investigation
-- Links issue to implementation tasks
-- Updates progress tracking
-
-## Output
-Displays:
-- Generated issue ID
-- Detected type and priority
-- Storage location
-- Integration status
-- Quick actions available
-
-## Quick Actions
-After creation:
-- **View**: `/workflow:issue:list`
-- **Update**: `/workflow:issue:update ISS-001`
-- **Integrate**: Link to workflow tasks
-- **Close**: `/workflow:issue:close ISS-001`
-
-## Error Handling
-- **No active session**: Prompts to start session first
-- **Directory creation**: Handles permission issues
-- **Duplicate description**: Warns about similar issues
-- **Invalid description**: Prompts for meaningful description
-
----
-
-**Result**: New issue created and ready for management within workflow

.claude/commands/workflow/issue/list.md

@@ -1,104 +0,0 @@
----
-name: list
-description: List and filter workflow issues
-usage: /workflow:issue:list
-examples:
-  - /workflow:issue:list
-  - /workflow:issue:list --open
-  - /workflow:issue:list --priority=high
----
-
-# List Workflow Issues (/workflow:issue:list)
-
-## Purpose
-Display all issues and change requests within the current workflow session.
-
-## Usage
-```bash
-/workflow:issue:list [filter]
-```
-
-## Optional Filters
-Simple keyword-based filtering:
-```bash
-/workflow:issue:list --open           # Only open issues
-/workflow:issue:list --closed         # Only closed issues
-/workflow:issue:list --critical       # Critical priority
-/workflow:issue:list --high           # High priority
-/workflow:issue:list --bug            # Bug type issues
-/workflow:issue:list --feature        # Feature type issues
-/workflow:issue:list --blocking       # Blocking issues only
-```
-
-## Display Format
-
-### Open Issues
-```
-🔴 ISS-001: Add OAuth2 social login support
-   Type: Feature | Priority: High | Created: 2025-09-07
-   Status: Open | Impact: Medium
-   
-🔴 ISS-002: Fix user avatar security vulnerability  
-   Type: Bug | Priority: Critical | Created: 2025-09-08
-   Status: Open | Impact: High | 🚫 BLOCKING
-```
-
-### Closed Issues
-```
-✅ ISS-003: Update authentication documentation
-   Type: Documentation | Priority: Low
-   Status: Closed | Completed: 2025-09-05
-   Reason: Documentation updated in PR #45
-```
-
-### Integrated Issues
-```
-🔗 ISS-004: Implement rate limiting
-   Type: Feature | Priority: Medium
-   Status: Integrated → IMPL-003
-   Integrated: 2025-09-06 | Task: impl-3.json
-```
-
-## Summary Stats
-```
-📊 Issue Summary for WFS-oauth-integration:
-   Total: 4 issues
-   🔴 Open: 2 | ✅ Closed: 1 | 🔗 Integrated: 1
-   🚫 Blocking: 1 | ⚡ Critical: 1 | 📈 High: 1
-```
-
-## Empty State
-If no issues exist:
-```
-No issues found for current session.
-
-Create your first issue:
-/workflow:issue:create "describe the issue or request"
-```
-
-## Quick Actions
-For each issue, shows available actions:
-- **Update**: `/workflow:issue:update ISS-001`
-- **Integrate**: Link to workflow tasks  
-- **Close**: `/workflow:issue:close ISS-001`
-- **View Details**: Full issue information
-
-## Session Context
-- Lists issues from current active session
-- Shows session name and directory
-- Indicates if .issues/ directory exists
-
-## Sorting
-Issues are sorted by:
-1. Blocking status (blocking first)
-2. Priority (critical → high → medium → low)
-3. Creation date (newest first)
-
-## Performance
-- Fast loading from JSON files
-- Cached issue registry
-- Efficient filtering
-
----
-
-**Result**: Complete overview of all workflow issues with their current status

.claude/commands/workflow/issue/update.md

@@ -1,136 +0,0 @@
----
-name: update
-description: Update an existing workflow issue
-usage: /workflow:issue:update <issue-id> [changes]
-
-examples:
-  - /workflow:issue:update ISS-001
-  - /workflow:issue:update ISS-001 --priority=critical
-  - /workflow:issue:update ISS-001 --status=closed
----
-
-# Update Workflow Issue (/workflow:issue:update)
-
-## Purpose
-Modify attributes and status of an existing workflow issue.
-
-## Usage
-```bash
-/workflow:issue:update <issue-id> [options]
-```
-
-## Quick Updates
-Simple attribute changes:
-```bash
-/workflow:issue:update ISS-001 --priority=critical
-/workflow:issue:update ISS-001 --status=closed
-/workflow:issue:update ISS-001 --blocking
-/workflow:issue:update ISS-001 --type=bug
-```
-
-## Interactive Mode (Default)
-Without options, opens interactive editor:
-```
-Issue ISS-001: Add OAuth2 social login support
-Current Status: Open | Priority: High | Type: Feature
-
-What would you like to update?
-1. Status (open → closed/integrated)
-2. Priority (high → critical/medium/low)  
-3. Type (feature → bug/optimization/etc)
-4. Description
-5. Add comment
-6. Toggle blocking status
-7. Cancel
-
-Choice: _
-```
-
-## Available Updates
-
-### Status Changes
-- **open** → **closed**: Issue resolved
-- **open** → **integrated**: Linked to workflow task
-- **closed** → **open**: Reopen issue
-- **integrated** → **open**: Unlink from tasks
-
-### Priority Levels
-- **critical**: Urgent, blocking progress
-- **high**: Important, should address soon
-- **medium**: Standard priority
-- **low**: Nice-to-have, can defer
-
-### Issue Types  
-- **bug**: Something broken that needs fixing
-- **feature**: New functionality to implement
-- **optimization**: Performance or efficiency improvement
-- **refactor**: Code structure improvement
-- **documentation**: Documentation updates
-
-### Additional Options
-- **blocking/non-blocking**: Whether issue blocks progress
-- **description**: Update issue description
-- **comments**: Add notes and updates
-
-## Update Process
-
-### Validation
-- Verifies issue exists in current session
-- Checks valid status transitions
-- Validates priority and type values
-
-### Change Tracking
-- Records update timestamp
-- Tracks who made changes
-- Maintains change history
-
-### File Updates
-- Updates ISS-XXX.json file
-- Refreshes issue-registry.json
-- Updates session statistics
-
-## Change History
-Maintains audit trail:
-```json
-{
-  "changes": [
-    {
-      "timestamp": "2025-09-08T10:30:00Z",
-      "field": "priority",
-      "old_value": "high",
-      "new_value": "critical",
-      "reason": "Security implications discovered"
-    }
-  ]
-}
-```
-
-## Integration Effects
-
-### Task Integration
-When status changes to "integrated":
-- Links to workflow task (optional)
-- Updates task context with issue reference
-- Creates bidirectional linking
-
-### Session Updates
-- Updates session issue statistics
-- Refreshes TodoWrite if applicable
-- Updates workflow progress tracking
-
-## Output
-Shows:
-- What was changed
-- Before and after values
-- Integration status
-- Available next actions
-
-## Error Handling
-- **Issue not found**: Lists available issues
-- **Invalid status**: Shows valid transitions
-- **Permission errors**: Clear error messages
-- **File corruption**: Validates and repairs
-
----
-
-**Result**: Issue successfully updated with change tracking and integration

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

@@ -0,0 +1,725 @@
+---
+name: lite-execute
+description: Execute tasks based on in-memory plan, prompt description, or file content
+argument-hint: "[--in-memory] [\"task description\"|file-path]"
+allowed-tools: TodoWrite(*), Task(*), Bash(*)
+---
+
+# Workflow Lite-Execute Command (/workflow:lite-execute)
+
+## Overview
+
+Flexible task execution command supporting three input modes: in-memory plan (from lite-plan), direct prompt description, or file content. Handles execution orchestration, progress tracking, and optional code review.
+
+**Core capabilities:**
+- Multi-mode input (in-memory plan, prompt description, or file path)
+- Execution orchestration (Agent or Codex) with full context
+- Live progress tracking via TodoWrite at execution call level
+- Optional code review with selected tool (Gemini, Agent, or custom)
+- Context continuity across multiple executions
+- Intelligent format detection (Enhanced Task JSON vs plain text)
+
+## Usage
+
+### Command Syntax
+```bash
+/workflow:lite-execute [FLAGS] <INPUT>
+
+# Flags
+--in-memory                Use plan from memory (called by lite-plan)
+
+# Arguments
+<input>                    Task description string, or path to file (required)
+```
+
+## Input Modes
+
+### Mode 1: In-Memory Plan
+
+**Trigger**: Called by lite-plan after Phase 4 approval with `--in-memory` flag
+
+**Input Source**: `executionContext` global variable set by lite-plan
+
+**Content**: Complete execution context (see Data Structures section)
+
+**Behavior**:
+- Skip execution method selection (already set by lite-plan)
+- Directly proceed to execution with full context
+- All planning artifacts available (exploration, clarifications, plan)
+
+### Mode 2: Prompt Description
+
+**Trigger**: User calls with task description string
+
+**Input**: Simple task description (e.g., "Add unit tests for auth module")
+
+**Behavior**:
+- Store prompt as `originalUserInput`
+- Create simple execution plan from prompt
+- AskUserQuestion: Select execution method (Agent/Codex/Auto)
+- AskUserQuestion: Select code review tool (Skip/Gemini/Agent/Other)
+- Proceed to execution with `originalUserInput` included
+
+**User Interaction**:
+```javascript
+AskUserQuestion({
+  questions: [
+    {
+      question: "Select 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: "Enable code review after execution?",
+      header: "Code Review",
+      multiSelect: false,
+      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" }
+      ]
+    }
+  ]
+})
+```
+
+### Mode 3: File Content
+
+**Trigger**: User calls with file path
+
+**Input**: Path to file containing task description or plan.json
+
+**Step 1: Read and Detect Format**
+
+```javascript
+fileContent = Read(filePath)
+
+// Attempt JSON parsing
+try {
+  jsonData = JSON.parse(fileContent)
+
+  // Check if plan.json from lite-plan session
+  if (jsonData.summary && jsonData.approach && jsonData.tasks) {
+    planObject = jsonData
+    originalUserInput = jsonData.summary
+    isPlanJson = true
+  } else {
+    // Valid JSON but not plan.json - treat as plain text
+    originalUserInput = fileContent
+    isPlanJson = false
+  }
+} catch {
+  // Not valid JSON - treat as plain text prompt
+  originalUserInput = fileContent
+  isPlanJson = false
+}
+```
+
+**Step 2: Create Execution Plan**
+
+If `isPlanJson === true`:
+- Use `planObject` directly
+- User selects execution method and code review
+
+If `isPlanJson === false`:
+- Treat file content as prompt (same behavior as Mode 2)
+- Create simple execution plan from content
+
+**Step 3: User Interaction**
+
+- AskUserQuestion: Select execution method (Agent/Codex/Auto)
+- AskUserQuestion: Select code review tool
+- Proceed to execution with full context
+
+## Execution Process
+
+```
+Input Parsing:
+   └─ Decision (mode detection):
+      ├─ --in-memory flag → Mode 1: Load executionContext → Skip user selection
+      ├─ Ends with .md/.json/.txt → Mode 3: Read file → Detect format
+      │   ├─ Valid plan.json → Use planObject → User selects method + review
+      │   └─ Not plan.json → Treat as prompt → User selects method + review
+      └─ Other → Mode 2: Prompt description → User selects method + review
+
+Execution:
+   ├─ Step 1: Initialize result tracking (previousExecutionResults = [])
+   ├─ Step 2: Task grouping & batch creation
+   │   ├─ Extract explicit depends_on (no file/keyword inference)
+   │   ├─ Group: independent tasks → single parallel batch (maximize utilization)
+   │   ├─ Group: dependent tasks → sequential phases (respect dependencies)
+   │   └─ Create TodoWrite list for batches
+   ├─ Step 3: Launch execution
+   │   ├─ Phase 1: All independent tasks (⚡ single batch, concurrent)
+   │   └─ Phase 2+: Dependent tasks by dependency order
+   ├─ Step 4: Track progress (TodoWrite updates per batch)
+   └─ Step 5: Code review (if codeReviewTool ≠ "Skip")
+
+Output:
+   └─ Execution complete with results in previousExecutionResults[]
+```
+
+## Detailed Execution Steps
+
+### Step 1: Initialize Execution Tracking
+
+**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
+
+**Dependency Analysis & Grouping Algorithm**:
+```javascript
+// Use explicit depends_on from plan.json (no inference from file/keywords)
+function extractDependencies(tasks) {
+  const taskIdToIndex = {}
+  tasks.forEach((t, i) => { taskIdToIndex[t.id] = i })
+
+  return tasks.map((task, i) => {
+    // Only use explicit depends_on from plan.json
+    const deps = (task.depends_on || [])
+      .map(depId => taskIdToIndex[depId])
+      .filter(idx => idx !== undefined && idx < i)
+    return { ...task, taskIndex: i, dependencies: deps }
+  })
+}
+
+// Group into batches: maximize parallel execution
+function createExecutionCalls(tasks, executionMethod) {
+  const tasksWithDeps = extractDependencies(tasks)
+  const processed = new Set()
+  const calls = []
+
+  // Phase 1: All independent tasks → single parallel batch (maximize utilization)
+  const independentTasks = tasksWithDeps.filter(t => t.dependencies.length === 0)
+  if (independentTasks.length > 0) {
+    independentTasks.forEach(t => processed.add(t.taskIndex))
+    calls.push({
+      method: executionMethod,
+      executionType: "parallel",
+      groupId: "P1",
+      taskSummary: independentTasks.map(t => t.title).join(' | '),
+      tasks: independentTasks
+    })
+  }
+
+  // Phase 2: Dependent tasks → sequential batches (respect dependencies)
+  let sequentialIndex = 1
+  let remaining = tasksWithDeps.filter(t => !processed.has(t.taskIndex))
+
+  while (remaining.length > 0) {
+    // Find tasks whose dependencies are all satisfied
+    const ready = remaining.filter(t =>
+      t.dependencies.every(d => processed.has(d))
+    )
+
+    if (ready.length === 0) {
+      console.warn('Circular dependency detected, forcing remaining tasks')
+      ready.push(...remaining)
+    }
+
+    // Group ready tasks (can run in parallel within this phase)
+    ready.forEach(t => processed.add(t.taskIndex))
+    calls.push({
+      method: executionMethod,
+      executionType: ready.length > 1 ? "parallel" : "sequential",
+      groupId: ready.length > 1 ? `P${calls.length + 1}` : `S${sequentialIndex++}`,
+      taskSummary: ready.map(t => t.title).join(ready.length > 1 ? ' | ' : ' → '),
+      tasks: ready
+    })
+
+    remaining = remaining.filter(t => !processed.has(t.taskIndex))
+  }
+
+  return calls
+}
+
+executionCalls = createExecutionCalls(planObject.tasks, executionMethod).map(c => ({ ...c, id: `[${c.groupId}]` }))
+
+TodoWrite({
+  todos: executionCalls.map(c => ({
+    content: `${c.executionType === "parallel" ? "⚡" : "→"} ${c.id} (${c.tasks.length} tasks)`,
+    status: "pending",
+    activeForm: `Executing ${c.id}`
+  }))
+})
+```
+
+### Step 3: Launch Execution
+
+**Executor Resolution** (任务级 executor 优先于全局设置):
+```javascript
+// 获取任务的 executor（优先使用 executorAssignments，fallback 到全局 executionMethod）
+function getTaskExecutor(task) {
+  const assignments = executionContext?.executorAssignments || {}
+  if (assignments[task.id]) {
+    return assignments[task.id].executor  // 'gemini' | 'codex' | 'agent'
+  }
+  // Fallback: 全局 executionMethod 映射
+  const method = executionContext?.executionMethod || 'Auto'
+  if (method === 'Agent') return 'agent'
+  if (method === 'Codex') return 'codex'
+  // Auto: 根据复杂度
+  return planObject.complexity === 'Low' ? 'agent' : 'codex'
+}
+
+// 按 executor 分组任务
+function groupTasksByExecutor(tasks) {
+  const groups = { gemini: [], codex: [], agent: [] }
+  tasks.forEach(task => {
+    const executor = getTaskExecutor(task)
+    groups[executor].push(task)
+  })
+  return groups
+}
+```
+
+**Execution Flow**: Parallel batches concurrently → Sequential batches in order
+```javascript
+const parallel = executionCalls.filter(c => c.executionType === "parallel")
+const sequential = executionCalls.filter(c => c.executionType === "sequential")
+
+// Phase 1: Launch all parallel batches (single message with multiple tool calls)
+if (parallel.length > 0) {
+  TodoWrite({ todos: executionCalls.map(c => ({ status: c.executionType === "parallel" ? "in_progress" : "pending" })) })
+  parallelResults = await Promise.all(parallel.map(c => executeBatch(c)))
+  previousExecutionResults.push(...parallelResults)
+  TodoWrite({ todos: executionCalls.map(c => ({ status: parallel.includes(c) ? "completed" : "pending" })) })
+}
+
+// Phase 2: Execute sequential batches one by one
+for (const call of sequential) {
+  TodoWrite({ todos: executionCalls.map(c => ({ status: c === call ? "in_progress" : "..." })) })
+  result = await executeBatch(call)
+  previousExecutionResults.push(result)
+  TodoWrite({ todos: executionCalls.map(c => ({ status: "completed" or "pending" })) })
+}
+```
+
+### 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:
+- `getTaskExecutor(task) === "agent"`
+- 或 `executionMethod = "Agent"` (全局 fallback)
+- 或 `executionMethod = "Auto" AND complexity = "Low"` (全局 fallback)
+
+```javascript
+Task(
+  subagent_type="code-developer",
+  run_in_background=false,
+  description=batch.taskSummary,
+  prompt=buildExecutionPrompt(batch)
+)
+```
+
+**Result Collection**: After completion, collect result following `executionResult` structure (see Data Structures section)
+
+**Option B: CLI Execution (Codex)**
+
+When to use:
+- `getTaskExecutor(task) === "codex"`
+- 或 `executionMethod = "Codex"` (全局 fallback)
+- 或 `executionMethod = "Auto" AND complexity = "Medium/High"` (全局 fallback)
+
+```bash
+ccw cli -p "${buildExecutionPrompt(batch)}" --tool codex --mode write
+```
+
+**Execution with fixed IDs** (predictable ID pattern):
+```javascript
+// Launch CLI in background, wait for task hook callback
+// Generate fixed execution ID: ${sessionId}-${groupId}
+const sessionId = executionContext?.session?.id || 'standalone'
+const fixedExecutionId = `${sessionId}-${batch.groupId}`  // e.g., "implement-auth-2025-12-13-P1"
+
+// Check if resuming from previous failed execution
+const previousCliId = batch.resumeFromCliId || null
+
+// Build command with fixed ID (and optional resume for continuation)
+const cli_command = previousCliId
+  ? `ccw cli -p "${buildExecutionPrompt(batch)}" --tool codex --mode write --id ${fixedExecutionId} --resume ${previousCliId}`
+  : `ccw cli -p "${buildExecutionPrompt(batch)}" --tool codex --mode write --id ${fixedExecutionId}`
+
+// Execute in background, stop output and wait for task hook callback
+Bash(
+  command=cli_command,
+  run_in_background=true
+)
+// STOP HERE - CLI executes in background, task hook will notify on completion
+```
+
+**Resume on Failure** (with fixed ID):
+```javascript
+// If execution failed or timed out, offer resume option
+if (bash_result.status === 'failed' || bash_result.status === 'timeout') {
+  console.log(`
+⚠️ Execution incomplete. Resume available:
+   Fixed ID: ${fixedExecutionId}
+   Lookup: ccw cli detail ${fixedExecutionId}
+   Resume: ccw cli -p "Continue tasks" --resume ${fixedExecutionId} --tool codex --mode write --id ${fixedExecutionId}-retry
+`)
+
+  // Store for potential retry in same session
+  batch.resumeFromCliId = fixedExecutionId
+}
+```
+
+**Result Collection**: After completion, analyze output and collect result following `executionResult` structure (include `cliExecutionId` for resume capability)
+
+**Option C: CLI Execution (Gemini)**
+
+When to use: `getTaskExecutor(task) === "gemini"` (分析类任务)
+
+```bash
+# 使用统一的 buildExecutionPrompt，切换 tool 和 mode
+ccw cli -p "${buildExecutionPrompt(batch)}" --tool gemini --mode analysis --id ${sessionId}-${batch.groupId}
+```
+
+### Step 4: Progress Tracking
+
+Progress tracked at batch level (not individual task level). Icons: ⚡ (parallel, concurrent), → (sequential, one-by-one)
+
+### Step 5: Code Review (Optional)
+
+**Skip Condition**: Only run if `codeReviewTool ≠ "Skip"`
+
+**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 and risk mitigations
+
+**Operations**:
+- Agent Review: Current agent performs direct review
+- Gemini Review: Execute gemini CLI with review prompt
+- 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 and risk mitigations
+
+**Shared Prompt Template** (used by all CLI tools):
+```
+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 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):
+
+```bash
+# Method 1: Agent Review (current agent)
+# - Read plan.json: ${executionContext.session.artifacts.plan}
+# - Apply unified review criteria (see Shared Prompt Template)
+# - Report findings directly
+
+# Method 2: Gemini Review (recommended)
+ccw cli -p "[Shared Prompt Template with artifacts]" --tool gemini --mode analysis
+# CONTEXT includes: @**/* @${plan.json} [@${exploration.json}]
+
+# Method 3: Qwen Review (alternative)
+ccw cli -p "[Shared Prompt Template with artifacts]" --tool qwen --mode analysis
+# Same prompt as Gemini, different execution engine
+
+# 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**:
+```javascript
+// Generate fixed review ID
+const reviewId = `${sessionId}-review`
+
+// First review pass with fixed ID
+const reviewResult = Bash(`ccw cli -p "[Review prompt]" --tool gemini --mode analysis --id ${reviewId}`)
+
+// If issues found, continue review dialog with fixed ID chain
+if (hasUnresolvedIssues(reviewResult)) {
+  // Resume with follow-up questions
+  Bash(`ccw cli -p "Clarify the security concerns you mentioned" --resume ${reviewId} --tool gemini --mode analysis --id ${reviewId}-followup`)
+}
+```
+
+**Implementation Note**: Replace `[Shared Prompt Template with artifacts]` placeholder with actual template content, substituting:
+- `@{plan.json}` → `@${executionContext.session.artifacts.plan}`
+- `[@{exploration.json}]` → exploration files from artifacts (if exists)
+
+### Step 6: Update Development Index
+
+**Trigger**: After all executions complete (regardless of code review)
+
+**Skip Condition**: Skip if `.workflow/project-tech.json` does not exist
+
+**Operations**:
+```javascript
+const projectJsonPath = '.workflow/project-tech.json'
+if (!fileExists(projectJsonPath)) return  // Silent skip
+
+const projectJson = JSON.parse(Read(projectJsonPath))
+
+// Initialize if needed
+if (!projectJson.development_index) {
+  projectJson.development_index = { feature: [], enhancement: [], bugfix: [], refactor: [], docs: [] }
+}
+
+// Detect category from keywords
+function detectCategory(text) {
+  text = text.toLowerCase()
+  if (/\b(fix|bug|error|issue|crash)\b/.test(text)) return 'bugfix'
+  if (/\b(refactor|cleanup|reorganize)\b/.test(text)) return 'refactor'
+  if (/\b(doc|readme|comment)\b/.test(text)) return 'docs'
+  if (/\b(add|new|create|implement)\b/.test(text)) return 'feature'
+  return 'enhancement'
+}
+
+// Detect sub_feature from task file paths
+function detectSubFeature(tasks) {
+  const dirs = tasks.map(t => t.file?.split('/').slice(-2, -1)[0]).filter(Boolean)
+  const counts = dirs.reduce((a, d) => { a[d] = (a[d] || 0) + 1; return a }, {})
+  return Object.entries(counts).sort((a, b) => b[1] - a[1])[0]?.[0] || 'general'
+}
+
+const category = detectCategory(`${planObject.summary} ${planObject.approach}`)
+const entry = {
+  title: planObject.summary.slice(0, 60),
+  sub_feature: detectSubFeature(planObject.tasks),
+  date: new Date().toISOString().split('T')[0],
+  description: planObject.approach.slice(0, 100),
+  status: previousExecutionResults.every(r => r.status === 'completed') ? 'completed' : 'partial',
+  session_id: executionContext?.session?.id || null
+}
+
+projectJson.development_index[category].push(entry)
+projectJson.statistics.last_updated = new Date().toISOString()
+Write(projectJsonPath, JSON.stringify(projectJson, null, 2))
+
+console.log(`✓ Development index: [${category}] ${entry.title}`)
+```
+
+## Best Practices
+
+**Input Modes**: In-memory (lite-plan), prompt (standalone), file (JSON/text)
+**Task Grouping**: Based on explicit depends_on only; independent tasks run in single parallel batch
+**Execution**: All independent tasks launch concurrently via single Claude message with multiple tool calls
+
+## Error Handling
+
+| Error | Cause | Resolution |
+|-------|-------|------------|
+| Missing executionContext | --in-memory without context | Error: "No execution context found. Only available when called by lite-plan." |
+| File not found | File path doesn't exist | Error: "File not found: {path}. Check file path." |
+| Empty file | File exists but no content | Error: "File is empty: {path}. Provide task description." |
+| Invalid Enhanced Task JSON | JSON missing required fields | Warning: "Missing required fields. Treating as plain text." |
+| Malformed JSON | JSON parsing fails | Treat as plain text (expected for non-JSON files) |
+| Execution failure | Agent/Codex crashes | Display error, use fixed ID `${sessionId}-${groupId}` for resume: `ccw cli -p "Continue" --resume <fixed-id> --id <fixed-id>-retry` |
+| Execution timeout | CLI exceeded timeout | Use fixed ID for resume with extended timeout |
+| Codex unavailable | Codex not installed | Show installation instructions, offer Agent execution |
+| Fixed ID not found | Custom ID lookup failed | Check `ccw cli history`, verify date directories |
+
+## Data Structures
+
+### executionContext (Input - Mode 1)
+
+Passed from lite-plan via global variable:
+
+```javascript
+{
+  planObject: {
+    summary: string,
+    approach: string,
+    tasks: [...],
+    estimated_time: string,
+    recommended_execution: string,
+    complexity: string
+  },
+  explorationsContext: {...} | null,       // Multi-angle explorations
+  explorationAngles: string[],             // List of exploration angles
+  explorationManifest: {...} | null,       // Exploration manifest
+  clarificationContext: {...} | null,
+  executionMethod: "Agent" | "Codex" | "Auto",  // 全局默认
+  codeReviewTool: "Skip" | "Gemini Review" | "Agent Review" | string,
+  originalUserInput: string,
+
+  // 任务级 executor 分配（优先于 executionMethod）
+  executorAssignments: {
+    [taskId]: { executor: "gemini" | "codex" | "agent", reason: string }
+  },
+
+  // Session artifacts location (saved by lite-plan)
+  session: {
+    id: string,                        // Session identifier: {taskSlug}-{shortTimestamp}
+    folder: string,                    // Session folder path: .workflow/.lite-plan/{session-id}
+    artifacts: {
+      explorations: [{angle, path}],   // exploration-{angle}.json paths
+      explorations_manifest: string,   // explorations-manifest.json path
+      plan: string                     // plan.json path (always present)
+    }
+  }
+}
+```
+
+**Artifact Usage**:
+- Artifact files contain detailed planning context
+- Pass artifact paths to CLI tools and agents for enhanced context
+- See execution options below for usage examples
+
+### executionResult (Output)
+
+Collected after each execution call completes:
+
+```javascript
+{
+  executionId: string,                 // e.g., "[Agent-1]", "[Codex-1]"
+  status: "completed" | "partial" | "failed",
+  tasksSummary: string,                // Brief description of tasks handled
+  completionSummary: string,           // What was completed
+  keyOutputs: string,                  // Files created/modified, key changes
+  notes: string,                       // Important context for next execution
+  fixedCliId: string | null            // Fixed CLI execution ID (e.g., "implement-auth-2025-12-13-P1")
+}
+```
+
+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:
+```bash
+# Lookup previous execution
+ccw cli detail ${fixedCliId}
+
+# Resume with new fixed ID for retry
+ccw cli -p "Continue from where we left off" --resume ${fixedCliId} --tool codex --mode write --id ${fixedCliId}-retry
+```

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

@@ -0,0 +1,730 @@
+---
+name: lite-fix
+description: Lightweight bug diagnosis and fix workflow with intelligent severity assessment and optional hotfix mode for production incidents
+argument-hint: "[--hotfix] \"bug description or issue reference\""
+allowed-tools: TodoWrite(*), Task(*), SlashCommand(*), AskUserQuestion(*)
+---
+
+# Workflow Lite-Fix Command (/workflow:lite-fix)
+
+## Overview
+
+Intelligent lightweight bug fixing command with dynamic workflow adaptation based on severity assessment. Focuses on diagnosis phases (root cause analysis, impact assessment, fix planning, confirmation) and delegates execution to `/workflow:lite-execute`.
+
+**Core capabilities:**
+- Intelligent bug analysis with automatic severity detection
+- Dynamic code diagnosis (cli-explore-agent) for root cause identification
+- 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 execute with complete context handoff to lite-execute
+
+## Usage
+
+```bash
+/workflow:lite-fix [FLAGS] <BUG_DESCRIPTION>
+
+# Flags
+--hotfix, -h               Production hotfix mode (minimal diagnosis, fast fix)
+
+# Arguments
+<bug-description>          Bug description, error message, or path to .md file (required)
+```
+
+## Execution Process
+
+```
+Phase 1: Bug Analysis & Diagnosis
+   |- Parse input (description, error message, or .md file)
+   |- Intelligent severity pre-assessment (Low/Medium/High/Critical)
+   |- Diagnosis decision (auto-detect or --hotfix flag)
+   |- Context protection: If file reading >=50k chars -> force cli-explore-agent
+   +- Decision:
+      |- needsDiagnosis=true -> Launch parallel cli-explore-agents (1-4 based on severity)
+      +- needsDiagnosis=false (hotfix) -> Skip directly to Phase 3 (Fix Planning)
+
+Phase 2: Clarification (optional, multi-round)
+   |- Aggregate clarification_needs from all diagnosis angles
+   |- Deduplicate similar questions
+   +- Decision:
+      |- Has clarifications -> AskUserQuestion (max 4 questions per round, multiple rounds allowed)
+      +- No clarifications -> Skip to Phase 3
+
+Phase 3: Fix Planning (NO CODE EXECUTION - planning only)
+   +- Decision (based on Phase 1 severity):
+      |- Low/Medium -> Load schema: cat ~/.claude/workflows/cli-templates/schemas/fix-plan-json-schema.json -> Direct Claude planning (following schema) -> fix-plan.json -> MUST proceed to Phase 4
+      +- High/Critical -> cli-lite-planning-agent -> fix-plan.json -> MUST proceed to Phase 4
+
+Phase 4: Confirmation & Selection
+   |- Display fix-plan summary (tasks, severity, estimated time)
+   +- AskUserQuestion:
+      |- Confirm: Allow / Modify / Cancel
+      |- Execution: Agent / Codex / Auto
+      +- Review: Gemini / Agent / Skip
+
+Phase 5: Execute
+   |- Build executionContext (fix-plan + diagnoses + clarifications + selections)
+   +- SlashCommand("/workflow:lite-execute --in-memory --mode bugfix")
+```
+
+## Implementation
+
+### Phase 1: Intelligent Multi-Angle Diagnosis
+
+**Session Setup** (MANDATORY - follow exactly):
+```javascript
+// Helper: Get UTC+8 (China Standard Time) ISO string
+const getUtc8ISOString = () => new Date(Date.now() + 8 * 60 * 60 * 1000).toISOString()
+
+const bugSlug = bug_description.toLowerCase().replace(/[^a-z0-9]+/g, '-').substring(0, 40)
+const dateStr = getUtc8ISOString().substring(0, 10)  // Format: 2025-11-29
+
+const sessionId = `${bugSlug}-${dateStr}`  // e.g., "user-avatar-upload-fails-2025-11-29"
+const sessionFolder = `.workflow/.lite-fix/${sessionId}`
+
+bash(`mkdir -p ${sessionFolder} && test -d ${sessionFolder} && echo "SUCCESS: ${sessionFolder}" || echo "FAILED: ${sessionFolder}"`)
+```
+
+**Diagnosis Decision Logic**:
+```javascript
+const hotfixMode = $ARGUMENTS.includes('--hotfix') || $ARGUMENTS.includes('-h')
+
+needsDiagnosis = (
+  !hotfixMode &&
+  (
+    bug.lacks_specific_error_message ||
+    bug.requires_codebase_context ||
+    bug.needs_execution_tracing ||
+    bug.root_cause_unclear
+  )
+)
+
+if (!needsDiagnosis) {
+  // Skip to Phase 2 (Clarification) or Phase 3 (Fix Planning)
+  proceed_to_next_phase()
+}
+```
+
+**Context Protection**: File reading >=50k chars -> force `needsDiagnosis=true` (delegate to cli-explore-agent)
+
+**Severity Pre-Assessment** (Intelligent Analysis):
+```javascript
+// Analyzes bug severity based on:
+// - Symptoms: Error messages, crash reports, user complaints
+// - Scope: How many users/features are affected?
+// - Urgency: Production down vs minor inconvenience
+// - Impact: Data loss, security, business impact
+
+const severity = analyzeBugSeverity(bug_description)
+// Returns: 'Low' | 'Medium' | 'High' | 'Critical'
+// Low: Minor UI issue, localized, no data impact
+// Medium: Multiple users affected, degraded functionality
+// High: Significant functionality broken, many users affected
+// Critical: Production down, data loss risk, security issue
+
+// Angle assignment based on bug type (orchestrator decides, not agent)
+const DIAGNOSIS_ANGLE_PRESETS = {
+  runtime_error: ['error-handling', 'dataflow', 'state-management', 'edge-cases'],
+  performance: ['performance', 'bottlenecks', 'caching', 'data-access'],
+  security: ['security', 'auth-patterns', 'dataflow', 'validation'],
+  data_corruption: ['data-integrity', 'state-management', 'transactions', 'validation'],
+  ui_bug: ['state-management', 'event-handling', 'rendering', 'data-binding'],
+  integration: ['api-contracts', 'error-handling', 'timeouts', 'fallbacks']
+}
+
+function selectDiagnosisAngles(bugDescription, count) {
+  const text = bugDescription.toLowerCase()
+  let preset = 'runtime_error' // default
+
+  if (/slow|timeout|performance|lag|hang/.test(text)) preset = 'performance'
+  else if (/security|auth|permission|access|token/.test(text)) preset = 'security'
+  else if (/corrupt|data|lost|missing|inconsistent/.test(text)) preset = 'data_corruption'
+  else if (/ui|display|render|style|click|button/.test(text)) preset = 'ui_bug'
+  else if (/api|integration|connect|request|response/.test(text)) preset = 'integration'
+
+  return DIAGNOSIS_ANGLE_PRESETS[preset].slice(0, count)
+}
+
+const selectedAngles = selectDiagnosisAngles(bug_description, severity === 'Critical' ? 4 : (severity === 'High' ? 3 : (severity === 'Medium' ? 2 : 1)))
+
+console.log(`
+## Diagnosis Plan
+
+Bug Severity: ${severity}
+Selected Angles: ${selectedAngles.join(', ')}
+
+Launching ${selectedAngles.length} parallel diagnoses...
+`)
+```
+
+**Launch Parallel Diagnoses** - Orchestrator assigns angle to each agent:
+
+```javascript
+// Launch agents with pre-assigned diagnosis angles
+const diagnosisTasks = selectedAngles.map((angle, index) =>
+  Task(
+    subagent_type="cli-explore-agent",
+    run_in_background=false,
+    description=`Diagnose: ${angle}`,
+    prompt=`
+## Task Objective
+Execute **${angle}** diagnosis for bug root cause analysis. Analyze codebase from this specific angle to discover root cause, affected paths, and fix hints.
+
+## Assigned Context
+- **Diagnosis Angle**: ${angle}
+- **Bug Description**: ${bug_description}
+- **Diagnosis Index**: ${index + 1} of ${selectedAngles.length}
+- **Output File**: ${sessionFolder}/diagnosis-${angle}.json
+
+## MANDATORY FIRST STEPS (Execute by Agent)
+**You (cli-explore-agent) MUST execute these steps in order:**
+1. Run: ccw tool exec get_modules_by_depth '{}' (project structure)
+2. Run: rg -l "{error_keyword_from_bug}" --type ts (locate relevant files)
+3. Execute: cat ~/.claude/workflows/cli-templates/schemas/diagnosis-json-schema.json (get output schema reference)
+4. Read: .workflow/project-tech.json (technology stack and architecture context)
+5. Read: .workflow/project-guidelines.json (user-defined constraints and conventions)
+
+## Diagnosis Strategy (${angle} focus)
+
+**Step 1: Error Tracing** (Bash)
+- rg for error messages, stack traces, log patterns
+- git log --since='2 weeks ago' for recent changes
+- Trace execution path in affected modules
+
+**Step 2: Root Cause Analysis** (Gemini CLI)
+- What code paths lead to this ${angle} issue?
+- What edge cases are not handled from ${angle} perspective?
+- What recent changes might have introduced this bug?
+
+**Step 3: Write Output**
+- Consolidate ${angle} findings into JSON
+- Identify ${angle}-specific clarification needs
+- Provide fix hints based on ${angle} analysis
+
+## Expected Output
+
+**File**: ${sessionFolder}/diagnosis-${angle}.json
+
+**Schema Reference**: Schema obtained in MANDATORY FIRST STEPS step 3, follow schema exactly
+
+**Required Fields** (all ${angle} focused):
+- symptom: Bug symptoms and error messages
+- root_cause: Root cause hypothesis from ${angle} perspective
+  **IMPORTANT**: Use structured format:
+  \`{file: "src/module/file.ts", line_range: "45-60", issue: "Description", confidence: 0.85}\`
+- affected_files: Files involved from ${angle} perspective
+  **IMPORTANT**: Use object format with relevance scores:
+  \`[{path: "src/file.ts", relevance: 0.85, rationale: "Contains ${angle} logic"}]\`
+- reproduction_steps: Steps to reproduce the bug
+- fix_hints: Suggested fix approaches from ${angle} viewpoint
+- dependencies: Dependencies relevant to ${angle} diagnosis
+- constraints: ${angle}-specific limitations affecting fix
+- clarification_needs: ${angle}-related ambiguities (options array + recommended index)
+- _metadata.diagnosis_angle: "${angle}"
+- _metadata.diagnosis_index: ${index + 1}
+
+## Success Criteria
+- [ ] Schema obtained via cat diagnosis-json-schema.json
+- [ ] get_modules_by_depth.sh executed
+- [ ] Root cause identified with confidence score
+- [ ] At least 3 affected files identified with ${angle} rationale
+- [ ] Fix hints are actionable (specific code changes, not generic advice)
+- [ ] Reproduction steps are verifiable
+- [ ] JSON output follows schema exactly
+- [ ] clarification_needs includes options + recommended
+
+## Output
+Write: ${sessionFolder}/diagnosis-${angle}.json
+Return: 2-3 sentence summary of ${angle} diagnosis findings
+`
+  )
+)
+
+// Execute all diagnosis tasks in parallel
+```
+
+**Auto-discover Generated Diagnosis Files**:
+```javascript
+// After diagnoses complete, auto-discover all diagnosis-*.json files
+const diagnosisFiles = bash(`find ${sessionFolder} -name "diagnosis-*.json" -type f`)
+  .split('\n')
+  .filter(f => f.trim())
+
+// Read metadata to build manifest
+const diagnosisManifest = {
+  session_id: sessionId,
+  bug_description: bug_description,
+  timestamp: getUtc8ISOString(),
+  severity: severity,
+  diagnosis_count: diagnosisFiles.length,
+  diagnoses: diagnosisFiles.map(file => {
+    const data = JSON.parse(Read(file))
+    const filename = path.basename(file)
+    return {
+      angle: data._metadata.diagnosis_angle,
+      file: filename,
+      path: file,
+      index: data._metadata.diagnosis_index
+    }
+  })
+}
+
+Write(`${sessionFolder}/diagnoses-manifest.json`, JSON.stringify(diagnosisManifest, null, 2))
+
+console.log(`
+## Diagnosis Complete
+
+Generated diagnosis files in ${sessionFolder}:
+${diagnosisManifest.diagnoses.map(d => `- diagnosis-${d.angle}.json (angle: ${d.angle})`).join('\n')}
+
+Manifest: diagnoses-manifest.json
+Angles diagnosed: ${diagnosisManifest.diagnoses.map(d => d.angle).join(', ')}
+`)
+```
+
+**Output**:
+- `${sessionFolder}/diagnosis-{angle1}.json`
+- `${sessionFolder}/diagnosis-{angle2}.json`
+- ... (1-4 files based on severity)
+- `${sessionFolder}/diagnoses-manifest.json`
+
+---
+
+### Phase 2: Clarification (Optional, Multi-Round)
+
+**Skip if**: No diagnosis or `clarification_needs` is empty across all diagnoses
+
+**⚠️ CRITICAL**: AskUserQuestion tool limits max 4 questions per call. **MUST execute multiple rounds** to exhaust all clarification needs - do NOT stop at round 1.
+
+**Aggregate clarification needs from all diagnosis angles**:
+```javascript
+// Load manifest and all diagnosis files
+const manifest = JSON.parse(Read(`${sessionFolder}/diagnoses-manifest.json`))
+const diagnoses = manifest.diagnoses.map(diag => ({
+  angle: diag.angle,
+  data: JSON.parse(Read(diag.path))
+}))
+
+// Aggregate clarification needs from all diagnoses
+const allClarifications = []
+diagnoses.forEach(diag => {
+  if (diag.data.clarification_needs?.length > 0) {
+    diag.data.clarification_needs.forEach(need => {
+      allClarifications.push({
+        ...need,
+        source_angle: diag.angle
+      })
+    })
+  }
+})
+
+// Deduplicate by question similarity
+function deduplicateClarifications(clarifications) {
+  const unique = []
+  clarifications.forEach(c => {
+    const isDuplicate = unique.some(u =>
+      u.question.toLowerCase() === c.question.toLowerCase()
+    )
+    if (!isDuplicate) unique.push(c)
+  })
+  return unique
+}
+
+const uniqueClarifications = deduplicateClarifications(allClarifications)
+
+// Multi-round clarification: batch questions (max 4 per round)
+// ⚠️ MUST execute ALL rounds until uniqueClarifications exhausted
+if (uniqueClarifications.length > 0) {
+  const BATCH_SIZE = 4
+  const totalRounds = Math.ceil(uniqueClarifications.length / BATCH_SIZE)
+
+  for (let i = 0; i < uniqueClarifications.length; i += BATCH_SIZE) {
+    const batch = uniqueClarifications.slice(i, i + BATCH_SIZE)
+    const currentRound = Math.floor(i / BATCH_SIZE) + 1
+
+    console.log(`### Clarification Round ${currentRound}/${totalRounds}`)
+
+    AskUserQuestion({
+      questions: batch.map(need => ({
+        question: `[${need.source_angle}] ${need.question}\n\nContext: ${need.context}`,
+        header: need.source_angle,
+        multiSelect: false,
+        options: need.options.map((opt, index) => {
+          const isRecommended = need.recommended === index
+          return {
+            label: isRecommended ? `${opt} ★` : opt,
+            description: isRecommended ? `Use ${opt} approach (Recommended)` : `Use ${opt} approach`
+          }
+        })
+      }))
+    })
+
+    // Store batch responses in clarificationContext before next round
+  }
+}
+```
+
+**Output**: `clarificationContext` (in-memory)
+
+---
+
+### Phase 3: Fix Planning
+
+**Planning Strategy Selection** (based on Phase 1 severity):
+
+**IMPORTANT**: Phase 3 is **planning only** - NO code execution. All execution happens in Phase 5 via lite-execute.
+
+**Low/Medium Severity** - Direct planning by Claude:
+```javascript
+// Step 1: Read schema
+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: "...",
+  strategy: "immediate_patch|comprehensive_fix|refactor",
+  tasks: [...],  // Each task: { id, title, scope, ..., depends_on, complexity }
+  estimated_time: "...",
+  recommended_execution: "Agent",
+  severity: severity,
+  risk_level: "...",
+
+  // 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: 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 5: MUST continue to Phase 4 (Confirmation) - DO NOT execute code here
+```
+
+**High/Critical Severity** - Invoke cli-lite-planning-agent:
+
+```javascript
+Task(
+  subagent_type="cli-lite-planning-agent",
+  run_in_background=false,
+  description="Generate detailed fix plan",
+  prompt=`
+Generate fix plan and write fix-plan.json.
+
+## Output Schema Reference
+Execute: cat ~/.claude/workflows/cli-templates/schemas/fix-plan-json-schema.json (get schema reference before generating plan)
+
+## Project Context (MANDATORY - Read Both Files)
+1. Read: .workflow/project-tech.json (technology stack, architecture, key components)
+2. Read: .workflow/project-guidelines.json (user-defined constraints and conventions)
+
+**CRITICAL**: All fix tasks MUST comply with constraints in project-guidelines.json
+
+## Bug Description
+${bug_description}
+
+## Multi-Angle Diagnosis Context
+
+${manifest.diagnoses.map(diag => `### Diagnosis: ${diag.angle} (${diag.file})
+Path: ${diag.path}
+
+Read this file for detailed ${diag.angle} analysis.`).join('\n\n')}
+
+Total diagnoses: ${manifest.diagnosis_count}
+Angles covered: ${manifest.diagnoses.map(d => d.angle).join(', ')}
+
+Manifest: ${sessionFolder}/diagnoses-manifest.json
+
+## User Clarifications
+${JSON.stringify(clarificationContext) || "None"}
+
+## Severity Level
+${severity}
+
+## Requirements
+Generate fix-plan.json with:
+- summary: 2-3 sentence overview of the fix
+- root_cause: Consolidated root cause from all diagnoses
+- strategy: "immediate_patch" | "comprehensive_fix" | "refactor"
+- tasks: 1-5 structured fix tasks (**IMPORTANT: group by fix area, NOT by file**)
+  - **Task Granularity Principle**: Each task = one complete fix unit
+  - title: action verb + target (e.g., "Fix token validation edge case")
+  - scope: module path (src/auth/) or feature name
+  - action: "Fix" | "Update" | "Refactor" | "Add" | "Delete"
+  - description
+  - modification_points: ALL files to modify for this fix (group related changes)
+  - implementation (2-5 steps covering all modification_points)
+  - 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
+1. **Group by fix area**: All changes for one fix = one task (even if 2-3 files)
+2. **Avoid file-per-task**: Do NOT create separate tasks for each file
+3. **Substantial tasks**: Each task should represent 10-45 minutes of work
+4. **True dependencies only**: Only use depends_on when Task B cannot start without Task A's output
+5. **Prefer parallel**: Most tasks should be independent (no depends_on)
+
+## Execution
+1. Read ALL diagnosis files for comprehensive context
+2. Execute CLI planning using Gemini (Qwen fallback) with --rule planning-fix-strategy template
+3. Synthesize findings from multiple diagnosis angles
+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)
+`
+)
+```
+
+**Output**: `${sessionFolder}/fix-plan.json`
+
+---
+
+### Phase 4: Task Confirmation & Execution Selection
+
+**Step 4.1: Display Fix Plan**
+```javascript
+const fixPlan = JSON.parse(Read(`${sessionFolder}/fix-plan.json`))
+
+console.log(`
+## Fix Plan
+
+**Summary**: ${fixPlan.summary}
+**Root Cause**: ${fixPlan.root_cause}
+**Strategy**: ${fixPlan.strategy}
+
+**Tasks** (${fixPlan.tasks.length}):
+${fixPlan.tasks.map((t, i) => `${i+1}. ${t.title} (${t.scope})`).join('\n')}
+
+**Severity**: ${fixPlan.severity}
+**Risk Level**: ${fixPlan.risk_level}
+**Estimated Time**: ${fixPlan.estimated_time}
+**Recommended**: ${fixPlan.recommended_execution}
+`)
+```
+
+**Step 4.2: Collect Confirmation**
+```javascript
+AskUserQuestion({
+  questions: [
+    {
+      question: `Confirm fix plan? (${fixPlan.tasks.length} tasks, ${fixPlan.severity} severity)`,
+      header: "Confirm",
+      multiSelect: true,
+      options: [
+        { label: "Allow", description: "Proceed as-is" },
+        { label: "Modify", description: "Adjust before execution" },
+        { label: "Cancel", description: "Abort workflow" }
+      ]
+    },
+    {
+      question: "Execution method:",
+      header: "Execution",
+      multiSelect: false,
+      options: [
+        { label: "Agent", description: "@code-developer agent" },
+        { label: "Codex", description: "codex CLI tool" },
+        { label: "Auto", description: `Auto: ${fixPlan.severity === 'Low' ? 'Agent' : 'Codex'}` }
+      ]
+    },
+    {
+      question: "Code review after fix?",
+      header: "Review",
+      multiSelect: false,
+      options: [
+        { label: "Gemini Review", description: "Gemini CLI" },
+        { label: "Agent Review", description: "@code-reviewer" },
+        { label: "Skip", description: "No review" }
+      ]
+    }
+  ]
+})
+```
+
+---
+
+### Phase 5: Execute to Execution
+
+**CRITICAL**: lite-fix NEVER executes code directly. ALL execution MUST go through lite-execute.
+
+**Step 5.1: Build executionContext**
+
+```javascript
+// Load manifest and all diagnosis files
+const manifest = JSON.parse(Read(`${sessionFolder}/diagnoses-manifest.json`))
+const diagnoses = {}
+
+manifest.diagnoses.forEach(diag => {
+  if (file_exists(diag.path)) {
+    diagnoses[diag.angle] = JSON.parse(Read(diag.path))
+  }
+})
+
+const fixPlan = JSON.parse(Read(`${sessionFolder}/fix-plan.json`))
+
+executionContext = {
+  mode: "bugfix",
+  severity: fixPlan.severity,
+  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,
+  clarificationContext: clarificationContext || null,
+  executionMethod: userSelection.execution_method,
+  codeReviewTool: userSelection.code_review_tool,
+  originalUserInput: bug_description,
+  session: {
+    id: sessionId,
+    folder: sessionFolder,
+    artifacts: {
+      diagnoses: manifest.diagnoses.map(diag => ({
+        angle: diag.angle,
+        path: diag.path
+      })),
+      diagnoses_manifest: `${sessionFolder}/diagnoses-manifest.json`,
+      fix_plan: `${sessionFolder}/fix-plan.json`
+    }
+  }
+}
+```
+
+**Step 5.2: Execute**
+
+```javascript
+SlashCommand(command="/workflow:lite-execute --in-memory --mode bugfix")
+```
+
+## Session Folder Structure
+
+```
+.workflow/.lite-fix/{bug-slug}-{YYYY-MM-DD}/
+|- diagnosis-{angle1}.json      # Diagnosis angle 1
+|- diagnosis-{angle2}.json      # Diagnosis angle 2
+|- diagnosis-{angle3}.json      # Diagnosis angle 3 (if applicable)
+|- diagnosis-{angle4}.json      # Diagnosis angle 4 (if applicable)
+|- diagnoses-manifest.json      # Diagnosis index
++- fix-plan.json                # Fix plan
+```
+
+**Example**:
+```
+.workflow/.lite-fix/user-avatar-upload-fails-413-2025-11-25-14-30-25/
+|- diagnosis-error-handling.json
+|- diagnosis-dataflow.json
+|- diagnosis-validation.json
+|- diagnoses-manifest.json
++- fix-plan.json
+```
+
+## Error Handling
+
+| Error | Resolution |
+|-------|------------|
+| Diagnosis agent failure | Skip diagnosis, continue with bug description only |
+| Planning agent failure | Fallback to direct planning by Claude |
+| Clarification timeout | Use diagnosis findings as-is |
+| Confirmation timeout | Save context, display resume instructions |
+| Modify loop > 3 times | Suggest breaking task or using /workflow:plan |
+| Root cause unclear | Extend diagnosis time or use broader angles |
+| Too complex for lite-fix | Escalate to /workflow:plan --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

@@ -0,0 +1,623 @@
+---
+name: lite-plan
+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(*)
+---
+
+# Workflow Lite-Plan Command (/workflow:lite-plan)
+
+## Overview
+
+Intelligent lightweight planning command with dynamic workflow adaptation based on task complexity. Focuses on planning phases (exploration, clarification, planning, confirmation) and delegates execution to `/workflow:lite-execute`.
+
+**Core capabilities:**
+- Intelligent task analysis with automatic exploration detection
+- Dynamic code exploration (cli-explore-agent) when codebase understanding needed
+- 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 execute with complete context handoff to lite-execute
+
+## Usage
+
+```bash
+/workflow:lite-plan [FLAGS] <TASK_DESCRIPTION>
+
+# Flags
+-e, --explore              Force code exploration phase (overrides auto-detection)
+
+# Arguments
+<task-description>         Task description or path to .md file (required)
+```
+
+## Execution Process
+
+```
+Phase 1: Task Analysis & Exploration
+   ├─ Parse input (description or .md file)
+   ├─ intelligent complexity assessment (Low/Medium/High)
+   ├─ Exploration decision (auto-detect or --explore flag)
+   ├─ Context protection: If file reading ≥50k chars → force cli-explore-agent
+   └─ Decision:
+      ├─ needsExploration=true → Launch parallel cli-explore-agents (1-4 based on complexity)
+      └─ needsExploration=false → Skip to Phase 2/3
+
+Phase 2: Clarification (optional, multi-round)
+   ├─ Aggregate clarification_needs from all exploration angles
+   ├─ Deduplicate similar questions
+   └─ Decision:
+      ├─ Has clarifications → AskUserQuestion (max 4 questions per round, multiple rounds allowed)
+      └─ No clarifications → Skip to Phase 3
+
+Phase 3: Planning (NO CODE EXECUTION - planning only)
+   └─ Decision (based on Phase 1 complexity):
+      ├─ Low → Load schema: cat ~/.claude/workflows/cli-templates/schemas/plan-json-schema.json → Direct Claude planning (following schema) → plan.json → MUST proceed to Phase 4
+      └─ Medium/High → cli-lite-planning-agent → plan.json → MUST proceed to Phase 4
+
+Phase 4: Confirmation & Selection
+   ├─ Display plan summary (tasks, complexity, estimated time)
+   └─ AskUserQuestion:
+      ├─ Confirm: Allow / Modify / Cancel
+      ├─ Execution: Agent / Codex / Auto
+      └─ Review: Gemini / Agent / Skip
+
+Phase 5: Execute
+   ├─ Build executionContext (plan + explorations + clarifications + selections)
+   └─ SlashCommand("/workflow:lite-execute --in-memory")
+```
+
+## Implementation
+
+### Phase 1: Intelligent Multi-Angle Exploration
+
+**Session Setup** (MANDATORY - follow exactly):
+```javascript
+// Helper: Get UTC+8 (China Standard Time) ISO string
+const getUtc8ISOString = () => new Date(Date.now() + 8 * 60 * 60 * 1000).toISOString()
+
+const taskSlug = task_description.toLowerCase().replace(/[^a-z0-9]+/g, '-').substring(0, 40)
+const dateStr = getUtc8ISOString().substring(0, 10)  // Format: 2025-11-29
+
+const sessionId = `${taskSlug}-${dateStr}`  // e.g., "implement-jwt-refresh-2025-11-29"
+const sessionFolder = `.workflow/.lite-plan/${sessionId}`
+
+bash(`mkdir -p ${sessionFolder} && test -d ${sessionFolder} && echo "SUCCESS: ${sessionFolder}" || echo "FAILED: ${sessionFolder}"`)
+```
+
+**Exploration Decision Logic**:
+```javascript
+needsExploration = (
+  flags.includes('--explore') || flags.includes('-e') ||
+  task.mentions_specific_files ||
+  task.requires_codebase_context ||
+  task.needs_architecture_understanding ||
+  task.modifies_existing_code
+)
+
+if (!needsExploration) {
+  // Skip to Phase 2 (Clarification) or Phase 3 (Planning)
+  proceed_to_next_phase()
+}
+```
+
+**⚠️ Context Protection**: File reading ≥50k chars → force `needsExploration=true` (delegate to cli-explore-agent)
+
+**Complexity Assessment** (Intelligent Analysis):
+```javascript
+// analyzes task complexity based on:
+// - Scope: How many systems/modules are affected?
+// - Depth: Surface change vs architectural impact?
+// - Risk: Potential for breaking existing functionality?
+// - Dependencies: How interconnected is the change?
+
+const complexity = analyzeTaskComplexity(task_description)
+// Returns: 'Low' | 'Medium' | 'High'
+// Low: Single file, isolated change, minimal risk
+// Medium: Multiple files, some dependencies, moderate risk
+// High: Cross-module, architectural, high risk
+
+// Angle assignment based on task type (orchestrator decides, not agent)
+const ANGLE_PRESETS = {
+  architecture: ['architecture', 'dependencies', 'modularity', 'integration-points'],
+  security: ['security', 'auth-patterns', 'dataflow', 'validation'],
+  performance: ['performance', 'bottlenecks', 'caching', 'data-access'],
+  bugfix: ['error-handling', 'dataflow', 'state-management', 'edge-cases'],
+  feature: ['patterns', 'integration-points', 'testing', 'dependencies']
+}
+
+function selectAngles(taskDescription, count) {
+  const text = taskDescription.toLowerCase()
+  let preset = 'feature' // default
+
+  if (/refactor|architect|restructure|modular/.test(text)) preset = 'architecture'
+  else if (/security|auth|permission|access/.test(text)) preset = 'security'
+  else if (/performance|slow|optimi|cache/.test(text)) preset = 'performance'
+  else if (/fix|bug|error|issue|broken/.test(text)) preset = 'bugfix'
+
+  return ANGLE_PRESETS[preset].slice(0, count)
+}
+
+const selectedAngles = selectAngles(task_description, complexity === 'High' ? 4 : (complexity === 'Medium' ? 3 : 1))
+
+// Planning strategy determination
+const planningStrategy = complexity === 'Low'
+  ? 'Direct Claude Planning'
+  : 'cli-lite-planning-agent'
+
+console.log(`
+## Exploration Plan
+
+Task Complexity: ${complexity}
+Selected Angles: ${selectedAngles.join(', ')}
+Planning Strategy: ${planningStrategy}
+
+Launching ${selectedAngles.length} parallel explorations...
+`)
+```
+
+**Launch Parallel Explorations** - Orchestrator assigns angle to each agent:
+
+**⚠️ CRITICAL - NO BACKGROUND EXECUTION**:
+- **MUST NOT use `run_in_background: true`** - exploration results are REQUIRED before planning
+
+
+```javascript
+// Launch agents with pre-assigned angles
+const explorationTasks = selectedAngles.map((angle, index) =>
+  Task(
+    subagent_type="cli-explore-agent",
+    run_in_background=false,  // ⚠️ MANDATORY: Must wait for results
+    description=`Explore: ${angle}`,
+    prompt=`
+## Task Objective
+Execute **${angle}** exploration for task planning context. Analyze codebase from this specific angle to discover relevant structure, patterns, and constraints.
+
+## Assigned Context
+- **Exploration Angle**: ${angle}
+- **Task Description**: ${task_description}
+- **Exploration Index**: ${index + 1} of ${selectedAngles.length}
+- **Output File**: ${sessionFolder}/exploration-${angle}.json
+
+## MANDATORY FIRST STEPS (Execute by Agent)
+**You (cli-explore-agent) MUST execute these steps in order:**
+1. Run: ccw tool exec get_modules_by_depth '{}' (project structure)
+2. Run: rg -l "{keyword_from_task}" --type ts (locate relevant files)
+3. Execute: cat ~/.claude/workflows/cli-templates/schemas/explore-json-schema.json (get output schema reference)
+4. Read: .workflow/project-tech.json (technology stack and architecture context)
+5. Read: .workflow/project-guidelines.json (user-defined constraints and conventions)
+
+## Exploration Strategy (${angle} focus)
+
+**Step 1: Structural Scan** (Bash)
+- get_modules_by_depth.sh → identify modules related to ${angle}
+- find/rg → locate files relevant to ${angle} aspect
+- Analyze imports/dependencies from ${angle} perspective
+
+**Step 2: Semantic Analysis** (Gemini CLI)
+- How does existing code handle ${angle} concerns?
+- What patterns are used for ${angle}?
+- Where would new code integrate from ${angle} viewpoint?
+
+**Step 3: Write Output**
+- Consolidate ${angle} findings into JSON
+- Identify ${angle}-specific clarification needs
+
+## Expected Output
+
+**File**: ${sessionFolder}/exploration-${angle}.json
+
+**Schema Reference**: Schema obtained in MANDATORY FIRST STEPS step 3, follow schema exactly
+
+**Required Fields** (all ${angle} focused):
+- project_structure: Modules/architecture relevant to ${angle}
+- relevant_files: Files affected from ${angle} perspective
+  **IMPORTANT**: Use object format with relevance scores for synthesis:
+  \`[{path: "src/file.ts", relevance: 0.85, rationale: "Core ${angle} logic"}]\`
+  Scores: 0.7+ high priority, 0.5-0.7 medium, <0.5 low
+- patterns: ${angle}-related patterns to follow
+- dependencies: Dependencies relevant to ${angle}
+- integration_points: Where to integrate from ${angle} viewpoint (include file:line locations)
+- constraints: ${angle}-specific limitations/conventions
+- clarification_needs: ${angle}-related ambiguities (options array + recommended index)
+- _metadata.exploration_angle: "${angle}"
+
+## Success Criteria
+- [ ] Schema obtained via cat explore-json-schema.json
+- [ ] get_modules_by_depth.sh executed
+- [ ] At least 3 relevant files identified with ${angle} rationale
+- [ ] Patterns are actionable (code examples, not generic advice)
+- [ ] Integration points include file:line locations
+- [ ] Constraints are project-specific to ${angle}
+- [ ] JSON output follows schema exactly
+- [ ] clarification_needs includes options + recommended
+
+## Output
+Write: ${sessionFolder}/exploration-${angle}.json
+Return: 2-3 sentence summary of ${angle} findings
+`
+  )
+)
+
+// Execute all exploration tasks in parallel
+```
+
+**Auto-discover Generated Exploration Files**:
+```javascript
+// After explorations complete, auto-discover all exploration-*.json files
+const explorationFiles = bash(`find ${sessionFolder} -name "exploration-*.json" -type f`)
+  .split('\n')
+  .filter(f => f.trim())
+
+// Read metadata to build manifest
+const explorationManifest = {
+  session_id: sessionId,
+  task_description: task_description,
+  timestamp: getUtc8ISOString(),
+  complexity: complexity,
+  exploration_count: explorationCount,
+  explorations: explorationFiles.map(file => {
+    const data = JSON.parse(Read(file))
+    const filename = path.basename(file)
+    return {
+      angle: data._metadata.exploration_angle,
+      file: filename,
+      path: file,
+      index: data._metadata.exploration_index
+    }
+  })
+}
+
+Write(`${sessionFolder}/explorations-manifest.json`, JSON.stringify(explorationManifest, null, 2))
+
+console.log(`
+## Exploration Complete
+
+Generated exploration files in ${sessionFolder}:
+${explorationManifest.explorations.map(e => `- exploration-${e.angle}.json (angle: ${e.angle})`).join('\n')}
+
+Manifest: explorations-manifest.json
+Angles explored: ${explorationManifest.explorations.map(e => e.angle).join(', ')}
+`)
+```
+
+**Output**:
+- `${sessionFolder}/exploration-{angle1}.json`
+- `${sessionFolder}/exploration-{angle2}.json`
+- ... (1-4 files based on complexity)
+- `${sessionFolder}/explorations-manifest.json`
+
+---
+
+### Phase 2: Clarification (Optional, Multi-Round)
+
+**Skip if**: No exploration or `clarification_needs` is empty across all explorations
+
+**⚠️ CRITICAL**: AskUserQuestion tool limits max 4 questions per call. **MUST execute multiple rounds** to exhaust all clarification needs - do NOT stop at round 1.
+
+**Aggregate clarification needs from all exploration angles**:
+```javascript
+// Load manifest and all exploration files
+const manifest = JSON.parse(Read(`${sessionFolder}/explorations-manifest.json`))
+const explorations = manifest.explorations.map(exp => ({
+  angle: exp.angle,
+  data: JSON.parse(Read(exp.path))
+}))
+
+// Aggregate clarification needs from all explorations
+const allClarifications = []
+explorations.forEach(exp => {
+  if (exp.data.clarification_needs?.length > 0) {
+    exp.data.clarification_needs.forEach(need => {
+      allClarifications.push({
+        ...need,
+        source_angle: exp.angle
+      })
+    })
+  }
+})
+
+// Intelligent deduplication: analyze allClarifications by intent
+// - Identify questions with similar intent across different angles
+// - Merge similar questions: combine options, consolidate context
+// - Produce dedupedClarifications with unique intents only
+const dedupedClarifications = intelligentMerge(allClarifications)
+
+// Multi-round clarification: batch questions (max 4 per round)
+if (dedupedClarifications.length > 0) {
+  const BATCH_SIZE = 4
+  const totalRounds = Math.ceil(dedupedClarifications.length / BATCH_SIZE)
+
+  for (let i = 0; i < dedupedClarifications.length; i += BATCH_SIZE) {
+    const batch = dedupedClarifications.slice(i, i + BATCH_SIZE)
+    const currentRound = Math.floor(i / BATCH_SIZE) + 1
+
+    console.log(`### Clarification Round ${currentRound}/${totalRounds}`)
+
+    AskUserQuestion({
+      questions: batch.map(need => ({
+        question: `[${need.source_angle}] ${need.question}\n\nContext: ${need.context}`,
+        header: need.source_angle.substring(0, 12),
+        multiSelect: false,
+        options: need.options.map((opt, index) => ({
+          label: need.recommended === index ? `${opt} ★` : opt,
+          description: need.recommended === index ? `Recommended` : `Use ${opt}`
+        }))
+      }))
+    })
+
+    // Store batch responses in clarificationContext before next round
+  }
+}
+```
+
+**Output**: `clarificationContext` (in-memory)
+
+---
+
+### Phase 3: Planning
+
+**Planning Strategy Selection** (based on Phase 1 complexity):
+
+**IMPORTANT**: Phase 3 is **planning only** - NO code execution. All execution happens in Phase 5 via lite-execute.
+
+**Executor Assignment** (Claude 智能分配，plan 生成后执行):
+
+```javascript
+// 分配规则（优先级从高到低）：
+// 1. 用户明确指定："用 gemini 分析..." → gemini, "codex 实现..." → codex
+// 2. 默认 → agent
+
+const executorAssignments = {}  // { taskId: { executor: 'gemini'|'codex'|'agent', reason: string } }
+plan.tasks.forEach(task => {
+  // Claude 根据上述规则语义分析，为每个 task 分配 executor
+  executorAssignments[task.id] = { executor: '...', reason: '...' }
+})
+```
+
+**Low Complexity** - Direct planning by Claude:
+```javascript
+// Step 1: Read schema
+const schema = Bash(`cat ~/.claude/workflows/cli-templates/schemas/plan-json-schema.json`)
+
+// Step 2: ⚠️ MANDATORY - Read and review ALL exploration files
+const manifest = JSON.parse(Read(`${sessionFolder}/explorations-manifest.json`))
+manifest.explorations.forEach(exp => {
+  const explorationData = Read(exp.path)
+  console.log(`\n### Exploration: ${exp.angle}\n${explorationData}`)
+})
+
+// Step 3: Generate plan following schema (Claude directly, no agent)
+// ⚠️ Plan MUST incorporate insights from exploration files read in Step 2
+const plan = {
+  summary: "...",
+  approach: "...",
+  tasks: [...],  // Each task: { id, title, scope, ..., depends_on, execution_group, complexity }
+  estimated_time: "...",
+  recommended_execution: "Agent",
+  complexity: "Low",
+  _metadata: { timestamp: getUtc8ISOString(), source: "direct-planning", planning_mode: "direct" }
+}
+
+// Step 4: Write plan to session folder
+Write(`${sessionFolder}/plan.json`, JSON.stringify(plan, null, 2))
+
+// Step 5: MUST continue to Phase 4 (Confirmation) - DO NOT execute code here
+```
+
+**Medium/High Complexity** - Invoke cli-lite-planning-agent:
+
+```javascript
+Task(
+  subagent_type="cli-lite-planning-agent",
+  run_in_background=false,
+  description="Generate detailed implementation plan",
+  prompt=`
+Generate implementation plan and write plan.json.
+
+## Output Schema Reference
+Execute: cat ~/.claude/workflows/cli-templates/schemas/plan-json-schema.json (get schema reference before generating plan)
+
+## Project Context (MANDATORY - Read Both Files)
+1. Read: .workflow/project-tech.json (technology stack, architecture, key components)
+2. Read: .workflow/project-guidelines.json (user-defined constraints and conventions)
+
+**CRITICAL**: All generated tasks MUST comply with constraints in project-guidelines.json
+
+## Task Description
+${task_description}
+
+## Multi-Angle Exploration Context
+
+${manifest.explorations.map(exp => `### Exploration: ${exp.angle} (${exp.file})
+Path: ${exp.path}
+
+Read this file for detailed ${exp.angle} analysis.`).join('\n\n')}
+
+Total explorations: ${manifest.exploration_count}
+Angles covered: ${manifest.explorations.map(e => e.angle).join(', ')}
+
+Manifest: ${sessionFolder}/explorations-manifest.json
+
+## User Clarifications
+${JSON.stringify(clarificationContext) || "None"}
+
+## Complexity Level
+${complexity}
+
+## Requirements
+Generate plan.json following the schema obtained above. Key constraints:
+- tasks: 2-7 structured tasks (**group by feature/module, NOT by file**)
+- _metadata.exploration_angles: ${JSON.stringify(manifest.explorations.map(e => e.angle))}
+
+## Task Grouping Rules
+1. **Group by feature**: All changes for one feature = one task (even if 3-5 files)
+2. **Group by context**: Tasks with similar context or related functional changes can be grouped together
+3. **Minimize agent count**: Simple, unrelated tasks can also be grouped to reduce agent execution overhead
+4. **Avoid file-per-task**: Do NOT create separate tasks for each file
+5. **Substantial tasks**: Each task should represent 15-60 minutes of work
+6. **True dependencies only**: Only use depends_on when Task B cannot start without Task A's output
+7. **Prefer parallel**: Most tasks should be independent (no depends_on)
+
+## Execution
+1. Read schema file (cat command above)
+2. Execute CLI planning using Gemini (Qwen fallback)
+3. Read ALL exploration files for comprehensive context
+4. Synthesize findings and generate plan following schema
+5. Write JSON: Write('${sessionFolder}/plan.json', jsonContent)
+6. Return brief completion summary
+`
+)
+```
+
+**Output**: `${sessionFolder}/plan.json`
+
+---
+
+### Phase 4: Task Confirmation & Execution Selection
+
+**Step 4.1: Display Plan**
+```javascript
+const plan = JSON.parse(Read(`${sessionFolder}/plan.json`))
+
+console.log(`
+## Implementation Plan
+
+**Summary**: ${plan.summary}
+**Approach**: ${plan.approach}
+
+**Tasks** (${plan.tasks.length}):
+${plan.tasks.map((t, i) => `${i+1}. ${t.title} (${t.file})`).join('\n')}
+
+**Complexity**: ${plan.complexity}
+**Estimated Time**: ${plan.estimated_time}
+**Recommended**: ${plan.recommended_execution}
+`)
+```
+
+**Step 4.2: Collect Confirmation**
+```javascript
+// Note: Execution "Other" option allows specifying CLI tools from ~/.claude/cli-tools.json
+AskUserQuestion({
+  questions: [
+    {
+      question: `Confirm plan? (${plan.tasks.length} tasks, ${plan.complexity})`,
+      header: "Confirm",
+      multiSelect: true,
+      options: [
+        { label: "Allow", description: "Proceed as-is" },
+        { label: "Modify", description: "Adjust before execution" },
+        { label: "Cancel", description: "Abort workflow" }
+      ]
+    },
+    {
+      question: "Execution method:",
+      header: "Execution",
+      multiSelect: false,
+      options: [
+        { label: "Agent", description: "@code-developer agent" },
+        { label: "Codex", description: "codex CLI tool" },
+        { label: "Auto", description: `Auto: ${plan.complexity === 'Low' ? 'Agent' : 'Codex'}` }
+      ]
+    },
+    {
+      question: "Code review after execution?",
+      header: "Review",
+      multiSelect: false,
+      options: [
+        { 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" }
+      ]
+    }
+  ]
+})
+```
+
+---
+
+### Phase 5: Execute to Execution
+
+**CRITICAL**: lite-plan NEVER executes code directly. ALL execution MUST go through lite-execute.
+
+**Step 5.1: Build executionContext**
+
+```javascript
+// Load manifest and all exploration files
+const manifest = JSON.parse(Read(`${sessionFolder}/explorations-manifest.json`))
+const explorations = {}
+
+manifest.explorations.forEach(exp => {
+  if (file_exists(exp.path)) {
+    explorations[exp.angle] = JSON.parse(Read(exp.path))
+  }
+})
+
+const plan = JSON.parse(Read(`${sessionFolder}/plan.json`))
+
+executionContext = {
+  planObject: plan,
+  explorationsContext: explorations,
+  explorationAngles: manifest.explorations.map(e => e.angle),
+  explorationManifest: manifest,
+  clarificationContext: clarificationContext || null,
+  executionMethod: userSelection.execution_method,  // 全局默认，可被 executorAssignments 覆盖
+  codeReviewTool: userSelection.code_review_tool,
+  originalUserInput: task_description,
+
+  // 任务级 executor 分配（优先于全局 executionMethod）
+  executorAssignments: executorAssignments,  // { taskId: { executor, reason } }
+
+  session: {
+    id: sessionId,
+    folder: sessionFolder,
+    artifacts: {
+      explorations: manifest.explorations.map(exp => ({
+        angle: exp.angle,
+        path: exp.path
+      })),
+      explorations_manifest: `${sessionFolder}/explorations-manifest.json`,
+      plan: `${sessionFolder}/plan.json`
+    }
+  }
+}
+```
+
+**Step 5.2: Execute**
+
+```javascript
+SlashCommand(command="/workflow:lite-execute --in-memory")
+```
+
+## Session Folder Structure
+
+```
+.workflow/.lite-plan/{task-slug}-{YYYY-MM-DD}/
+├── exploration-{angle1}.json      # Exploration angle 1
+├── exploration-{angle2}.json      # Exploration angle 2
+├── exploration-{angle3}.json      # Exploration angle 3 (if applicable)
+├── exploration-{angle4}.json      # Exploration angle 4 (if applicable)
+├── explorations-manifest.json     # Exploration index
+└── plan.json                      # Implementation plan
+```
+
+**Example**:
+```
+.workflow/.lite-plan/implement-jwt-refresh-2025-11-25-14-30-25/
+├── exploration-architecture.json
+├── exploration-auth-patterns.json
+├── exploration-security.json
+├── explorations-manifest.json
+└── plan.json
+```
+
+## Error Handling
+
+| Error | Resolution |
+|-------|------------|
+| Exploration agent failure | Skip exploration, continue with task description only |
+| Planning agent failure | Fallback to direct planning by Claude |
+| Clarification timeout | Use exploration findings as-is |
+| Confirmation timeout | Save context, display resume instructions |
+| Modify loop > 3 times | Suggest breaking task or using /workflow:plan |

.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-deep.md

@@ -1,225 +0,0 @@
----
-name: plan-deep
-description: Deep technical planning with Gemini CLI analysis and action-planning-agent
-usage: /workflow:plan-deep <task_description>
-argument-hint: "task description" | requirements.md
-examples:
-  - /workflow:plan-deep "Refactor authentication system to use JWT"
-  - /workflow:plan-deep "Implement real-time notifications across modules"
-  - /workflow:plan-deep requirements.md
----
-
-# Workflow Plan Deep Command (/workflow:plan-deep)
-
-## Overview
-Creates comprehensive implementation plans through deep codebase analysis using Gemini CLI and the action-planning-agent. This command enforces multi-dimensional context gathering before planning, ensuring technical decisions are grounded in actual codebase understanding.
-
-## Key Differentiators
-
-### vs /workflow:plan
-| Feature | /workflow:plan | /workflow:plan-deep |
-|---------|---------------|-------------------|
-| **Analysis Depth** | Basic requirements extraction | Deep codebase analysis |
-| **Gemini CLI** | Optional | **Mandatory (via agent)** |
-| **Context Scope** | Current input only | Multi-dimensional analysis |
-| **Agent Used** | None (direct processing) | action-planning-agent |
-| **Output Detail** | Standard IMPL_PLAN | Enhanced hierarchical plan |
-| **Best For** | Quick planning | Complex technical tasks |
-
-## When to Use This Command
-
-### Ideal Scenarios
-- **Cross-module refactoring** requiring understanding of multiple components
-- **Architecture changes** affecting system-wide patterns
-- **Complex feature implementation** spanning >3 modules
-- **Performance optimization** requiring deep code analysis
-- **Security enhancements** needing comprehensive vulnerability assessment
-- **Technical debt resolution** with broad impact
-
-### Not Recommended For
-- Simple, single-file changes
-- Documentation updates
-- Configuration adjustments
-- Tasks with clear, limited scope
-
-## Execution Flow
-
-### 1. Input Processing
-```
-Input Analysis:
-├── Parse task description or file
-├── Extract key technical terms
-├── Identify potential affected domains
-└── Prepare context for agent
-```
-
-### 2. Agent Invocation with Deep Analysis Flag
-The command invokes action-planning-agent with special parameters that **enforce** Gemini CLI analysis.
-
-### 3. Agent Processing (Delegated to action-planning-agent)
-
-**Agent Execution Flow**:
-```
-Agent receives DEEP_ANALYSIS_REQUIRED flag
-├── Executes 4-dimension Gemini CLI analysis in parallel:
-│   ├── Architecture Analysis (patterns, components)
-│   ├── Code Pattern Analysis (conventions, standards)
-│   ├── Impact Analysis (affected modules, dependencies)
-│   └── Testing Requirements (coverage, patterns)
-├── Consolidates Gemini results into gemini-analysis.md
-├── Creates workflow session directory
-├── Generates hierarchical IMPL_PLAN.md
-├── Creates TODO_LIST.md for tracking
-└── Saves all outputs to .workflow/WFS-[session-id]/
-```
-```markdown
-Task(action-planning-agent):
-  description: "Deep technical planning with mandatory codebase analysis"
-  prompt: |
-    Create implementation plan for: [task_description]
-    
-    EXECUTION MODE: DEEP_ANALYSIS_REQUIRED
-    
-    MANDATORY REQUIREMENTS:
-    - Execute comprehensive Gemini CLI analysis (4 dimensions)
-    - Skip PRD processing (no PRD provided)
-    - Skip session inheritance (standalone planning)
-    - Force GEMINI_CLI_REQUIRED flag = true
-    - Generate hierarchical task decomposition
-    - Create detailed IMPL_PLAN.md with subtasks
-    - Generate TODO_LIST.md for tracking
-    
-    GEMINI ANALYSIS DIMENSIONS (execute in parallel):
-    1. Architecture Analysis - design patterns, component relationships
-    2. Code Pattern Analysis - conventions, error handling, validation
-    3. Impact Analysis - affected modules, breaking changes
-    4. Testing Requirements - coverage needs, test patterns
-    
-    FOCUS: Technical implementation based on deep codebase understanding
-```
-
-### 4. Output Generation (by Agent)
-The action-planning-agent generates in `.workflow/WFS-[session-id]/`:
-- **IMPL_PLAN.md** - Hierarchical implementation plan with stages
-- **TODO_LIST.md** - Task tracking checklist (if complexity > simple)
-- **.task/*.json** - Task definitions for complex projects
-- **workflow-session.json** - Session tracking
-- **gemini-analysis.md** - Consolidated Gemini analysis results
-
-## Command Processing Logic
-
-```python
-def process_plan_deep_command(input):
-    # Step 1: Parse input
-    task_description = parse_input(input)
-    
-    # Step 2: Build agent prompt with deep analysis flag
-    agent_prompt = f"""
-    EXECUTION_MODE: DEEP_ANALYSIS_REQUIRED
-    TASK: {task_description}
-    
-    MANDATORY FLAGS:
-    - GEMINI_CLI_REQUIRED = true
-    - FORCE_PARALLEL_ANALYSIS = true
-    - SKIP_PRD = true
-    - SKIP_SESSION_INHERITANCE = true
-    
-    Execute comprehensive Gemini CLI analysis before planning.
-    """
-    
-    # Step 3: Invoke action-planning-agent
-    # Agent will handle session creation and Gemini execution
-    Task(
-        subagent_type="action-planning-agent",
-        description="Deep technical planning with mandatory analysis",
-        prompt=agent_prompt
-    )
-    
-    # Step 4: Agent handles all processing and outputs
-    return "Agent executing deep analysis and planning..."
-```
-
-## Error Handling
-
-### Common Issues and Solutions
-
-**Agent Execution Errors**
-- Verify action-planning-agent availability
-- Check for context size limits
-- Agent handles Gemini CLI failures internally
-
-**Gemini CLI Failures (handled by agent)**
-- Agent falls back to file-pattern based analysis
-- Agent retries with reduced scope automatically
-- Agent alerts if critical analysis fails
-
-**File Access Issues**
-- Verify permissions for workflow directory
-- Check file patterns for validity
-- Alert on missing CLAUDE.md files
-
-## Integration Points
-
-### Related Commands
-- `/workflow:plan` - Quick planning without deep analysis
-- `/workflow:execute` - Execute generated plans
-- `/workflow:review` - Review implementation progress
-- `/context` - View generated planning documents
-
-### Agent Dependencies
-- **action-planning-agent** - Core planning engine
-- **code-developer** - For execution phase
-- **code-review-agent** - For quality checks
-
-## Usage Examples
-
-### Example 1: Cross-Module Refactoring
-```bash
-/workflow:plan-deep "Refactor user authentication to use JWT tokens across all services"
-```
-Generates comprehensive plan analyzing:
-- Current auth implementation
-- All affected services
-- Migration strategy
-- Testing requirements
-
-### Example 2: Performance Optimization
-```bash
-/workflow:plan-deep "Optimize database query performance in reporting module"
-```
-Creates detailed plan including:
-- Current query patterns analysis
-- Bottleneck identification
-- Optimization strategies
-- Performance testing approach
-
-### Example 3: Architecture Enhancement
-```bash
-/workflow:plan-deep "Implement event-driven architecture for order processing"
-```
-Produces hierarchical plan with:
-- Current architecture assessment
-- Event flow design
-- Module integration points
-- Staged migration approach
-
-## Best Practices
-
-1. **Use for Complex Tasks**: Reserve for tasks requiring deep understanding
-2. **Provide Clear Descriptions**: Specific task descriptions yield better analysis
-3. **Review Gemini Output**: Check analysis results for accuracy
-4. **Iterate on Plans**: Refine based on initial analysis
-5. **Track Progress**: Use generated TODO_LIST.md for execution
-
-## Technical Notes
-
-- **Agent-Driven Analysis**: action-planning-agent executes all Gemini CLI commands
-- **Parallel Execution**: Agent runs 4 Gemini analyses concurrently for performance
-- **Context Management**: Agent handles context size limits automatically
-- **Structured Handoff**: Command passes DEEP_ANALYSIS_REQUIRED flag to agent
-- **Session Management**: Agent creates and manages workflow session
-- **Output Standards**: All documents follow established workflow formats
-
----
-
-**System ensures**: Deep technical understanding before planning through mandatory Gemini CLI analysis and intelligent agent orchestration

.claude/commands/workflow/plan.md

@@ -1,139 +1,551 @@
 ---
 name: plan
-description: Create implementation plans with intelligent input detection
-usage: /workflow:plan <input>
-argument-hint: "text description"|file.md|ISS-001|template-name
-examples:
-  - /workflow:plan "Build authentication system"
-  - /workflow:plan requirements.md
-  - /workflow:plan ISS-001
-  - /workflow:plan web-api
+description: 5-phase planning workflow with action-planning-agent task generation, outputs IMPL_PLAN.md and task JSONs
+argument-hint: "\"text description\"|file.md"
+allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*)
 ---
 
 # Workflow Plan Command (/workflow:plan)
 
-## Overview
-Creates actionable implementation plans with intelligent input source detection. Supports text, files, issues, and templates through automatic recognition.
+## Coordinator Role
 
-## Core Principles
-**File Structure:** @~/.claude/workflows/workflow-architecture.md
+**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**.
 
-## Usage
-```bash
-/workflow/plan <input>
+**Execution Model - Auto-Continue Workflow with Quality Gate**:
+
+This workflow runs **fully autonomously** once triggered. Phase 3 (conflict resolution) and Phase 4 (task generation) are delegated to specialized agents.
+
+
+1. **User triggers**: `/workflow:plan "task"`
+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 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
+
+**Auto-Continue Mechanism**:
+- TodoList tracks current phase status and dynamically manages task attachment/collapse
+- When each phase finishes executing, automatically execute next pending phase
+- All phases run autonomously without user interaction (clarification handled in brainstorm phase)
+- Progress updates shown at each phase for visibility
+- **⚠️ CONTINUOUS EXECUTION** - Do not stop until all phases complete
+
+## Core Rules
+
+1. **Start Immediately**: First action is TodoWrite initialization, second action is Phase 1 command execution
+2. **No Preliminary Analysis**: Do not read files, analyze structure, or gather context before Phase 1
+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 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
+
+```
+Input Parsing:
+   └─ Convert user input to structured format (GOAL/SCOPE/CONTEXT)
+
+Phase 1: Session Discovery
+   └─ /workflow:session:start --auto "structured-description"
+      └─ Output: sessionId (WFS-xxx)
+
+Phase 2: Context Gathering
+   └─ /workflow:tools:context-gather --session sessionId "structured-description"
+      ├─ Tasks attached: Analyze structure → Identify integration → Generate package
+      └─ Output: contextPath + conflict_risk
+
+Phase 3: Conflict Resolution 
+   └─ Decision (conflict_risk check):
+      ├─ conflict_risk ≥ medium → Execute /workflow:tools:conflict-resolution
+      │   ├─ Tasks attached: Detect conflicts → Present to user → Apply strategies
+      │   └─ Output: Modified brainstorm artifacts
+      └─ conflict_risk < medium → Skip to Phase 4
+
+Phase 4: Task Generation
+   └─ /workflow:tools:task-generate-agent --session sessionId
+      └─ Output: IMPL_PLAN.md, task JSONs, TODO_LIST.md
+
+Return:
+   └─ Summary with recommended next steps
 ```
 
-## Input Detection Logic
-The command automatically detects input type:
+## 5-Phase Execution
 
-### File Input (Auto-detected)
-```bash
-/workflow:plan requirements.md
-/workflow:plan PROJECT_SPEC.txt
-/workflow:plan config.json
-/workflow:plan spec.yaml
-```
-**Triggers**: Extensions: .md, .txt, .json, .yaml, .yml
-**Processing**: Reads file contents and extracts requirements
+### Phase 1: Session Discovery
 
-### Issue Input (Auto-detected)
-```bash
-/workflow:plan ISS-001
-/workflow:plan ISSUE-123
-/workflow:plan feature-request-45
-```
-**Triggers**: Patterns: ISS-*, ISSUE-*, *-request-*
-**Processing**: Loads issue data and acceptance criteria
+**Step 1.1: Execute** - Create or discover workflow session
 
-### Template Input (Auto-detected)
-```bash
-/workflow:plan web-api
-/workflow:plan mobile-app
-/workflow:plan database-migration
-/workflow:plan security-feature
-```
-**Triggers**: Known template names
-**Processing**: Loads template and prompts for customization
-
-### Text Input (Default)
-```bash
-/workflow:plan "Build user authentication with JWT and OAuth2"
-/workflow:plan "Fix performance issues in dashboard"
-```
-**Triggers**: Everything else
-**Processing**: Parse natural language requirements
-
-## Automatic Behaviors
-
-### Session Management
-- Creates new session if none exists
-- Uses active session if available
-- Generates session ID: WFS-[topic-slug]
-
-### Complexity Detection
-- **Simple**: <5 tasks → Direct IMPL_PLAN.md
-- **Medium**: 5-15 tasks → IMPL_PLAN.md + TODO_LIST.md
-- **Complex**: >15 tasks → Full decomposition
-
-### Task Generation
-- Automatically creates .task/ files when complexity warrants
-- Generates hierarchical task structure (max 3 levels)
-- Updates session state with task references
-
-## Session Check Process
-⚠️ **CRITICAL**: Check for existing active session before planning
-
-1. **Check Active Session**: Check for `.workflow/.active-*` marker file
-2. **Session Selection**: Use existing active session or create new
-3. **Context Integration**: Load session state and existing context
-
-## Output Documents
-
-### IMPL_PLAN.md (Always Created)
-```markdown
-# Implementation Plan - [Project Name]
-*Generated from: [input_source]*
-
-## Requirements
-[Extracted requirements from input source]
-
-## Task Breakdown
-- **IMPL-001**: [Task description]
-- **IMPL-002**: [Task description]
-
-## Success Criteria
-[Measurable completion conditions]
+```javascript
+SlashCommand(command="/workflow:session:start --auto \"[structured-task-description]\"")
 ```
 
-### Optional TODO_LIST.md (Auto-triggered)
-Created when complexity > simple or task count > 5
+**Task Description Structure**:
+```
+GOAL: [Clear, concise objective]
+SCOPE: [What's included/excluded]
+CONTEXT: [Relevant background or constraints]
+```
 
-### Task JSON Files (Auto-created)
-Generated in .task/ directory when decomposition enabled
+**Example**:
+```
+GOAL: Build JWT-based authentication system
+SCOPE: User registration, login, token validation
+CONTEXT: Existing user database schema, REST API endpoints
+```
 
-## Error Handling
+**Parse Output**:
+- Extract: `SESSION_ID: WFS-[id]` (store as `sessionId`)
 
-### Input Processing Errors
-- **File not found**: Clear error message with suggestions
-- **Invalid issue**: Verify issue ID exists
-- **Unknown template**: List available templates
-- **Empty input**: Prompt for valid input
+**Validation**:
+- Session ID successfully extracted
+- Session directory `.workflow/active/[sessionId]/` exists
 
-## Integration Points
+**Note**: Session directory contains `workflow-session.json` (metadata). Do NOT look for `manifest.json` here - it only exists in `.workflow/archives/` for archived sessions.
 
-### Related Commands
-- `/workflow:session:start` - Create new session first
-- `/context` - View generated plan
-- `/task/execute` - Execute decomposed tasks
-- `/workflow:execute` - Run implementation phase
+**TodoWrite**: Mark phase 1 completed, phase 2 in_progress
 
-### Template System
-Available templates:
-- `web-api`: REST API development
-- `mobile-app`: Mobile application
-- `database-migration`: Database changes
-- `security-feature`: Security implementation
+**After Phase 1**: Return to user showing Phase 1 results, then auto-continue to Phase 2
 
 ---
 
-**System ensures**: Unified planning interface with intelligent input detection and automatic complexity handling
+### Phase 2: Context Gathering
+
+**Step 2.1: Execute** - Gather project context and analyze codebase
+
+```javascript
+SlashCommand(command="/workflow:tools:context-gather --session [sessionId] \"[structured-task-description]\"")
+```
+
+**Use Same Structured Description**: Pass the same structured format from Phase 1
+
+**Input**: `sessionId` from Phase 1
+
+**Parse Output**:
+- Extract: context-package.json path (store as `contextPath`)
+- Typical pattern: `.workflow/active/[sessionId]/.process/context-package.json`
+
+**Validation**:
+- Context package path extracted
+- File exists and is valid JSON
+
+<!-- TodoWrite: When context-gather executed, INSERT 3 context-gather tasks, mark first as in_progress -->
+
+**TodoWrite Update (Phase 2 SlashCommand executed - tasks attached)**:
+```json
+[
+  {"content": "Phase 1: Session Discovery", "status": "completed", "activeForm": "Executing session discovery"},
+  {"content": "Phase 2: Context Gathering", "status": "in_progress", "activeForm": "Executing context gathering"},
+  {"content": "  → Analyze codebase structure", "status": "in_progress", "activeForm": "Analyzing codebase structure"},
+  {"content": "  → Identify integration points", "status": "pending", "activeForm": "Identifying integration points"},
+  {"content": "  → Generate context package", "status": "pending", "activeForm": "Generating context package"},
+  {"content": "Phase 4: Task Generation", "status": "pending", "activeForm": "Executing task generation"}
+]
+```
+
+**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 -->
+
+**TodoWrite Update (Phase 2 completed - tasks collapsed)**:
+```json
+[
+  {"content": "Phase 1: Session Discovery", "status": "completed", "activeForm": "Executing session discovery"},
+  {"content": "Phase 2: Context Gathering", "status": "completed", "activeForm": "Executing context gathering"},
+  {"content": "Phase 4: Task Generation", "status": "pending", "activeForm": "Executing task generation"}
+]
+```
+
+**Note**: Phase 2 tasks completed and collapsed to summary.
+
+**After Phase 2**: Return to user showing Phase 2 results, then auto-continue to Phase 3/4 (depending on conflict_risk)
+
+---
+
+### Phase 3: Conflict Resolution
+
+**Trigger**: Only execute when context-package.json indicates conflict_risk is "medium" or "high"
+
+**Step 3.1: Execute** - Detect and resolve conflicts with CLI analysis
+
+```javascript
+SlashCommand(command="/workflow:tools:conflict-resolution --session [sessionId] --context [contextPath]")
+```
+
+**Input**:
+- sessionId from Phase 1
+- contextPath from Phase 2
+- conflict_risk from context-package.json
+
+**Parse Output**:
+- Extract: Execution status (success/skipped/failed)
+- Verify: conflict-resolution.json file path (if executed)
+
+**Validation**:
+- File `.workflow/active/[sessionId]/.process/conflict-resolution.json` exists (if executed)
+
+**Skip Behavior**:
+- If conflict_risk is "none" or "low", skip directly to Phase 3.5
+- Display: "No significant conflicts detected, proceeding to clarification"
+
+<!-- TodoWrite: If conflict_risk ≥ medium, INSERT 3 conflict-resolution tasks -->
+
+**TodoWrite Update (Phase 3 SlashCommand executed - tasks attached, if conflict_risk ≥ medium)**:
+```json
+[
+  {"content": "Phase 1: Session Discovery", "status": "completed", "activeForm": "Executing session discovery"},
+  {"content": "Phase 2: Context Gathering", "status": "completed", "activeForm": "Executing context gathering"},
+  {"content": "Phase 3: Conflict Resolution", "status": "in_progress", "activeForm": "Resolving conflicts"},
+  {"content": "  → Detect conflicts with CLI analysis", "status": "in_progress", "activeForm": "Detecting conflicts"},
+  {"content": "  → Present conflicts to user", "status": "pending", "activeForm": "Presenting conflicts"},
+  {"content": "  → Apply resolution strategies", "status": "pending", "activeForm": "Applying resolution strategies"},
+  {"content": "Phase 4: Task Generation", "status": "pending", "activeForm": "Executing task generation"}
+]
+```
+
+**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 -->
+
+**TodoWrite Update (Phase 3 completed - tasks collapsed)**:
+```json
+[
+  {"content": "Phase 1: Session Discovery", "status": "completed", "activeForm": "Executing session discovery"},
+  {"content": "Phase 2: Context Gathering", "status": "completed", "activeForm": "Executing context gathering"},
+  {"content": "Phase 3: Conflict Resolution", "status": "completed", "activeForm": "Resolving conflicts"},
+  {"content": "Phase 4: Task Generation", "status": "pending", "activeForm": "Executing task generation"}
+]
+```
+
+**Note**: Phase 3 tasks completed and collapsed to summary.
+
+**After Phase 3**: Return to user showing conflict resolution results (if executed) and selected strategies, then auto-continue to Phase 3.5
+
+**Memory State Check**:
+- Evaluate current context window usage and memory state
+- If memory usage is high (>120K tokens or approaching context limits):
+
+  **Step 3.2: Execute** - Optimize memory before proceeding
+
+  ```javascript
+  SlashCommand(command="/compact")
+  ```
+
+- Memory compaction is particularly important after analysis phase which may generate extensive documentation
+- Ensures optimal performance and prevents context overflow
+
+---
+
+### Phase 3.5: Pre-Task Generation Validation (Optional Quality Gate)
+
+**Purpose**: Optional quality gate before task generation - primarily handled by brainstorm synthesis phase
+
+
+**Current Behavior**: Auto-skip to Phase 4 (Task Generation)
+
+**Future Enhancement**: Could add additional validation steps like:
+- Cross-reference checks between conflict resolution and brainstorm analyses
+- Final sanity checks before task generation
+- User confirmation prompt for proceeding
+
+**TodoWrite**: Mark phase 3.5 completed (auto-skip), phase 4 in_progress
+
+**After Phase 3.5**: Auto-continue to Phase 4 immediately
+
+---
+
+### Phase 4: Task Generation
+
+**Relationship with Brainstorm Phase**:
+- If brainstorm role analyses exist ([role]/analysis.md files), Phase 3 analysis incorporates them as input
+- **User's original intent is ALWAYS primary**: New or refined user goals override brainstorm recommendations
+- **Role analysis.md files define "WHAT"**: Requirements, design specs, role-specific insights
+- **IMPL_PLAN.md defines "HOW"**: Executable task breakdown, dependencies, implementation sequence
+- 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: Execute** - Generate implementation plan and task JSONs
+
+```javascript
+SlashCommand(command="/workflow:tools:task-generate-agent --session [sessionId]")
+```
+
+**CLI Execution Note**: CLI tool usage is now determined semantically by action-planning-agent based on user's task description. If user specifies "use Codex/Gemini/Qwen for X", the agent embeds `command` fields in relevant `implementation_approach` steps.
+
+**Input**: `sessionId` from Phase 1
+
+**Validation**:
+- `.workflow/active/[sessionId]/IMPL_PLAN.md` exists
+- `.workflow/active/[sessionId]/.task/IMPL-*.json` exists (at least one)
+- `.workflow/active/[sessionId]/TODO_LIST.md` exists
+
+<!-- TodoWrite: When task-generate-agent executed, ATTACH 1 agent task -->
+
+**TodoWrite Update (Phase 4 SlashCommand executed - agent task attached)**:
+```json
+[
+  {"content": "Phase 1: Session Discovery", "status": "completed", "activeForm": "Executing session discovery"},
+  {"content": "Phase 2: Context Gathering", "status": "completed", "activeForm": "Executing context gathering"},
+  {"content": "Phase 4: Task Generation", "status": "in_progress", "activeForm": "Executing task generation"}
+]
+```
+
+**Note**: Single agent task attached. Agent autonomously completes discovery, planning, and output generation internally.
+
+<!-- TodoWrite: After agent completes, mark task as completed -->
+
+**TodoWrite Update (Phase 4 completed)**:
+```json
+[
+  {"content": "Phase 1: Session Discovery", "status": "completed", "activeForm": "Executing session discovery"},
+  {"content": "Phase 2: Context Gathering", "status": "completed", "activeForm": "Executing context gathering"},
+  {"content": "Phase 4: Task Generation", "status": "completed", "activeForm": "Executing task generation"}
+]
+```
+
+**Note**: Agent task completed. No collapse needed (single task).
+
+**Return to User**:
+```
+Planning complete for session: [sessionId]
+Tasks generated: [count]
+Plan: .workflow/active/[sessionId]/IMPL_PLAN.md
+
+Recommended Next Steps:
+1. /workflow:action-plan-verify --session [sessionId]  # Verify plan quality before execution
+2. /workflow:status  # Review task breakdown
+3. /workflow:execute  # Start implementation (after verification)
+
+Quality Gate: Consider running /workflow:action-plan-verify to catch issues early
+```
+
+## TodoWrite Pattern
+
+**Core Concept**: Dynamic task attachment and collapse for real-time visibility into workflow execution.
+
+### Key Principles
+
+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")
+   - First attached task marked as `in_progress`, others as `pending`
+   - Orchestrator **executes** these attached tasks sequentially
+
+2. **Task Collapse** (after sub-tasks complete):
+   - **Applies to Phase 2, 3**: Remove detailed sub-tasks from TodoWrite
+   - **Collapse** to high-level phase summary
+   - Example: Phase 2.1-2.3 collapse to "Execute context gathering: completed"
+   - **Phase 4**: No collapse needed (single task, just mark completed)
+   - Maintains clean orchestrator-level view
+
+3. **Continuous Execution**:
+   - After completion, automatically proceed to next pending phase
+   - No user intervention required between phases
+   - TodoWrite dynamically reflects current execution state
+
+**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.
+
+
+
+**Note**: See individual Phase descriptions for detailed TodoWrite Update examples:
+- **Phase 2, 3**: Multiple sub-tasks with attach/collapse pattern
+- **Phase 4**: Single agent task (no collapse needed)
+
+## Input Processing
+
+**Convert User Input to Structured Format**:
+
+1. **Simple Text** → Structure it:
+   ```
+   User: "Build authentication system"
+
+   Structured:
+   GOAL: Build authentication system
+   SCOPE: Core authentication features
+   CONTEXT: New implementation
+   ```
+
+2. **Detailed Text** → Extract components:
+   ```
+   User: "Add JWT authentication with email/password login and token refresh"
+
+   Structured:
+   GOAL: Implement JWT-based authentication
+   SCOPE: Email/password login, token generation, token refresh endpoints
+   CONTEXT: JWT token-based security, refresh token rotation
+   ```
+
+3. **File Reference** (e.g., `requirements.md`) → Read and structure:
+   - Read file content
+   - Extract goal, scope, requirements
+   - Format into structured description
+
+## Data Flow
+
+```
+User Input (task description)
+    ↓
+[Convert to Structured Format]
+    ↓ Structured Description:
+    ↓   GOAL: [objective]
+    ↓   SCOPE: [boundaries]
+    ↓   CONTEXT: [background]
+    ↓
+Phase 1: session:start --auto "structured-description"
+    ↓ Output: sessionId
+    ↓ Session Memory: Previous tasks, context, artifacts
+    ↓
+Phase 2: context-gather --session sessionId "structured-description"
+    ↓ Input: sessionId + session memory + structured description
+    ↓ Output: contextPath (context-package.json) + conflict_risk
+    ↓
+Phase 3: conflict-resolution [AUTO-TRIGGERED if conflict_risk ≥ medium]
+    ↓ Input: sessionId + contextPath + conflict_risk
+    ↓ CLI-powered conflict detection (JSON output)
+    ↓ AskUserQuestion: Present conflicts + resolution strategies
+    ↓ User selects strategies (or skip)
+    ↓ Apply modifications via Edit tool:
+    ↓   - Update guidance-specification.md
+    ↓   - Update role analyses (*.md)
+    ↓   - Mark context-package.json as "resolved"
+    ↓ Output: Modified brainstorm artifacts (NO report file)
+    ↓ Skip if conflict_risk is none/low → proceed directly to Phase 4
+    ↓
+Phase 4: task-generate-agent --session sessionId
+    ↓ Input: sessionId + resolved brainstorm artifacts + session memory
+    ↓ Output: IMPL_PLAN.md, task JSONs, TODO_LIST.md
+    ↓
+Return summary to user
+```
+
+**Session Memory Flow**: Each phase receives session ID, which provides access to:
+- Previous task summaries
+- Existing context and analysis
+- Brainstorming artifacts (potentially modified by Phase 3)
+- Session-specific configuration
+
+
+## Execution Flow Diagram
+
+```
+User triggers: /workflow:plan "Build authentication system"
+  ↓
+[TodoWrite Init] 3 orchestrator-level tasks
+  ↓
+Phase 1: Session Discovery
+  → sessionId extracted
+  ↓
+Phase 2: Context Gathering (SlashCommand executed)
+  → ATTACH 3 sub-tasks: ← ATTACHED
+    - → Analyze codebase structure
+    - → Identify integration points
+    - → Generate context package
+  → Execute sub-tasks sequentially
+  → COLLAPSE tasks ← COLLAPSED
+  → contextPath + conflict_risk extracted
+  ↓
+Conditional Branch: Check conflict_risk
+  ├─ IF conflict_risk ≥ medium:
+  │   Phase 3: Conflict Resolution (SlashCommand executed)
+  │     → ATTACH 3 sub-tasks: ← ATTACHED
+  │       - → Detect conflicts with CLI analysis
+  │       - → Present conflicts to user
+  │       - → Apply resolution strategies
+  │     → Execute sub-tasks sequentially
+  │     → COLLAPSE tasks ← COLLAPSED
+  │
+  └─ ELSE: Skip Phase 3, proceed to Phase 4
+  ↓
+Phase 4: Task Generation (SlashCommand executed)
+  → Single agent task (no sub-tasks)
+  → Agent autonomously completes internally:
+    (discovery → planning → output)
+  → Outputs: IMPL_PLAN.md, IMPL-*.json, TODO_LIST.md
+  ↓
+Return summary to user
+```
+
+**Key Points**:
+- **← 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 executes if conflict_risk ≥ medium
+- **Continuous Flow**: No user intervention between phases
+
+## Error Handling
+
+- **Parsing Failure**: If output parsing fails, retry command once, then report error
+- **Validation Failure**: If validation fails, report which file/data is missing
+- **Command Failure**: Keep phase `in_progress`, report error to user, do not proceed to next phase
+
+## Coordinator Checklist
+
+- **Pre-Phase**: Convert user input to structured format (GOAL/SCOPE/CONTEXT)
+- Initialize TodoWrite before any command (Phase 3 added dynamically after Phase 2)
+- Execute Phase 1 immediately with structured description
+- Parse session ID from Phase 1 output, store in memory
+- Pass session ID and structured description to Phase 2 command
+- Parse context path from Phase 2 output, store in memory
+- **Extract conflict_risk from context-package.json**: Determine Phase 3 execution
+- **If conflict_risk ≥ medium**: Launch Phase 3 conflict-resolution with sessionId and contextPath
+- Wait for Phase 3 to finish executing (if executed), verify conflict-resolution.json created
+- **If conflict_risk is none/low**: Skip Phase 3, proceed directly to Phase 4
+- **Build Phase 4 command**: `/workflow:tools:task-generate-agent --session [sessionId]`
+- Pass session ID to Phase 4 command
+- Verify all Phase 4 outputs
+- Update TodoWrite after each phase (dynamically adjust for Phase 3 presence)
+- After each phase, automatically continue to next phase based on TodoList status
+
+## Structure Template Reference
+
+**Minimal Structure**:
+```
+GOAL: [What to achieve]
+SCOPE: [What's included]
+CONTEXT: [Relevant info]
+```
+
+**Detailed Structure** (optional, when more context available):
+```
+GOAL: [Primary objective]
+SCOPE: [Included features/components]
+CONTEXT: [Existing system, constraints, dependencies]
+REQUIREMENTS: [Specific technical requirements]
+CONSTRAINTS: [Limitations or boundaries]
+```
+
+**Usage in Commands**:
+```bash
+# Phase 1
+/workflow:session:start --auto "GOAL: Build authentication\nSCOPE: JWT, login, registration\nCONTEXT: REST API"
+
+# Phase 2
+/workflow:tools:context-gather --session WFS-123 "GOAL: Build authentication\nSCOPE: JWT, login, registration\nCONTEXT: REST API"
+```
+
+## Related Commands
+
+**Prerequisite Commands**:
+- `/workflow:brainstorm:artifacts` - Optional: Generate role-based analyses before planning (if complex requirements need multiple perspectives)
+- `/workflow:brainstorm:synthesis` - Optional: Refine brainstorm analyses with clarifications
+
+**Called by This Command** (5 phases):
+- `/workflow:session:start` - Phase 1: Create or discover workflow session
+- `/workflow:tools:context-gather` - Phase 2: Gather project context and analyze codebase
+- `/workflow:tools:conflict-resolution` - Phase 3: Detect and resolve conflicts (auto-triggered if conflict_risk ≥ medium)
+- `/compact` - Phase 3: Memory optimization (if context approaching limits)
+- `/workflow:tools:task-generate-agent` - Phase 4: Generate task JSON files with agent-driven approach
+
+**Follow-up Commands**:
+- `/workflow:action-plan-verify` - Recommended: Verify plan quality and catch issues before execution
+- `/workflow:status` - Review task breakdown and current progress
+- `/workflow:execute` - Begin implementation of generated tasks

.claude/commands/workflow/replan.md

@@ -0,0 +1,515 @@
+---
+name: replan
+description: Interactive workflow replanning with session-level artifact updates and boundary clarification through guided questioning
+argument-hint: "[--session session-id] [task-id] \"requirements\"|file.md [--interactive]"
+allowed-tools: Read(*), Write(*), Edit(*), TodoWrite(*), Glob(*), Bash(*)
+---
+
+# Workflow Replan Command
+
+## Overview
+Intelligently replans workflow sessions or individual tasks with interactive boundary clarification and comprehensive artifact updates.
+
+**Core Capabilities**:
+- **Session Replan**: Updates multiple artifacts (IMPL_PLAN.md, TODO_LIST.md, task JSONs)
+- **Task Replan**: Focused updates within session context
+- **Interactive Clarification**: Guided questioning to define modification boundaries
+- **Impact Analysis**: Automatic detection of affected files and dependencies
+- **Backup Management**: Preserves previous versions with restore capability
+
+## Operation Modes
+
+### Session Replan Mode
+
+```bash
+# Auto-detect active session
+/workflow:replan "添加双因素认证支持"
+
+# Explicit session
+/workflow:replan --session WFS-oauth "添加双因素认证支持"
+
+# File-based input
+/workflow:replan --session WFS-oauth requirements-update.md
+
+# Interactive mode
+/workflow:replan --interactive
+```
+
+### Task Replan Mode
+
+```bash
+# Direct task update
+/workflow:replan IMPL-1 "修改为使用 OAuth2.0 标准"
+
+# Task with explicit session
+/workflow:replan --session WFS-oauth IMPL-2 "增加单元测试覆盖率到 90%"
+
+# Interactive mode
+/workflow:replan IMPL-1 --interactive
+```
+
+## Execution Process
+
+```
+Input Parsing:
+   ├─ Parse flags: --session, --interactive
+   └─ Detect mode: task-id present → Task mode | Otherwise → Session mode
+
+Phase 1: Mode Detection & Session Discovery
+   ├─ Detect operation mode (Task vs Session)
+   ├─ Discover/validate session (--session flag or auto-detect)
+   └─ Load session context (workflow-session.json, IMPL_PLAN.md, TODO_LIST.md)
+
+Phase 2: Interactive Requirement Clarification
+   └─ Decision (by mode):
+      ├─ Session mode → 3-4 questions (scope, modules, changes, dependencies)
+      └─ Task mode → 2 questions (update type, ripple effect)
+
+Phase 3: Impact Analysis & Planning
+   ├─ Analyze required changes
+   ├─ Generate modification plan
+   └─ User confirmation (Execute / Adjust / Cancel)
+
+Phase 4: Backup Creation
+   └─ Backup all affected files with manifest
+
+Phase 5: Apply Modifications
+   ├─ Update IMPL_PLAN.md (if needed)
+   ├─ Update TODO_LIST.md (if needed)
+   ├─ Update/Create/Delete task JSONs
+   └─ Update session metadata
+
+Phase 6: Verification & Summary
+   ├─ Validate consistency (JSON validity, task limits, acyclic dependencies)
+   └─ Generate change summary
+```
+
+## Execution Lifecycle
+
+### Input Parsing
+
+**Parse flags**:
+```javascript
+const sessionFlag = $ARGUMENTS.match(/--session\s+(\S+)/)?.[1]
+const interactive = $ARGUMENTS.includes('--interactive')
+const taskIdMatch = $ARGUMENTS.match(/\b(IMPL-\d+(?:\.\d+)?)\b/)
+const taskId = taskIdMatch?.[1]
+```
+
+### Phase 1: Mode Detection & Session Discovery
+
+**Process**:
+1. **Detect Operation Mode**:
+   - Check if task ID provided (IMPL-N or IMPL-N.M format) → Task mode
+   - Otherwise → Session mode
+
+2. **Discover/Validate Session**:
+   - Use `--session` flag if provided
+   - Otherwise auto-detect from `.workflow/active/`
+   - Validate session exists
+
+3. **Load Session Context**:
+   - Read `workflow-session.json`
+   - List existing tasks
+   - Read `IMPL_PLAN.md` and `TODO_LIST.md`
+
+**Output**: Session validated, context loaded, mode determined
+
+---
+
+### Phase 2: Interactive Requirement Clarification
+
+**Purpose**: Define modification scope through guided questioning
+
+#### Session Mode Questions
+
+**Q1: Modification Scope**
+```javascript
+Options:
+- 仅更新任务细节 (tasks_only)
+- 修改规划方案 (plan_update)
+- 重构任务结构 (task_restructure)
+- 全面重规划 (comprehensive)
+```
+
+**Q2: Affected Modules** (if scope >= plan_update)
+```javascript
+Options: Dynamically generated from existing tasks' focus_paths
+- 认证模块 (src/auth)
+- 用户管理 (src/user)
+- 全部模块
+```
+
+**Q3: Task Changes** (if scope >= task_restructure)
+```javascript
+Options:
+- 添加/删除任务 (add_remove)
+- 合并/拆分任务 (merge_split)
+- 仅更新内容 (update_only)
+// Note: Max 4 options for AskUserQuestion
+```
+
+**Q4: Dependency Changes**
+```javascript
+Options:
+- 是,需要重新梳理依赖
+- 否,保持现有依赖
+```
+
+#### Task Mode Questions
+
+**Q1: Update Type**
+```javascript
+Options:
+- 需求和验收标准 (requirements & acceptance)
+- 实现方案 (implementation_approach)
+- 文件范围 (focus_paths)
+- 依赖关系 (depends_on)
+- 全部更新
+```
+
+**Q2: Ripple Effect**
+```javascript
+Options:
+- 是,需要同步更新依赖任务
+- 否,仅影响当前任务
+- 不确定,请帮我分析
+```
+
+**Output**: User selections stored, modification boundaries defined
+
+---
+
+### Phase 3: Impact Analysis & Planning
+
+**Step 3.1: Analyze Required Changes**
+
+Determine affected files based on clarification:
+
+```typescript
+interface ImpactAnalysis {
+  affected_files: {
+    impl_plan: boolean;
+    todo_list: boolean;
+    session_meta: boolean;
+    tasks: string[];
+  };
+
+  operations: {
+    type: 'create' | 'update' | 'delete' | 'merge' | 'split';
+    target: string;
+    reason: string;
+  }[];
+
+  backup_strategy: {
+    timestamp: string;
+    files: string[];
+  };
+}
+```
+
+**Step 3.2: Generate Modification Plan**
+
+```markdown
+## 修改计划
+
+### 影响范围
+- [ ] IMPL_PLAN.md: 更新技术方案第 3 节
+- [ ] TODO_LIST.md: 添加 2 个新任务,删除 1 个废弃任务
+- [ ] IMPL-001.json: 更新实现方案
+- [ ] workflow-session.json: 更新任务计数
+
+### 变更操作
+1. **创建**: IMPL-004.json (双因素认证实现)
+2. **更新**: IMPL-001.json (添加 2FA 准备工作)
+3. **删除**: IMPL-003.json (已被新方案替代)
+```
+
+**Step 3.3: User Confirmation**
+
+```javascript
+Options:
+- 确认执行: 开始应用所有修改
+- 调整计划: 重新回答问题调整范围
+- 取消操作: 放弃本次重规划
+```
+
+**Output**: Modification plan confirmed or adjusted
+
+---
+
+### Phase 4: Backup Creation
+
+**Process**:
+
+1. **Create Backup Directory**:
+```bash
+timestamp=$(date -u +"%Y-%m-%dT%H-%M-%S")
+backup_dir=".workflow/active/$SESSION_ID/.process/backup/replan-$timestamp"
+mkdir -p "$backup_dir"
+```
+
+2. **Backup All Affected Files**:
+   - IMPL_PLAN.md
+   - TODO_LIST.md
+   - workflow-session.json
+   - Affected task JSONs
+
+3. **Create Backup Manifest**:
+```markdown
+# Replan Backup Manifest
+
+**Timestamp**: {timestamp}
+**Reason**: {replan_reason}
+**Scope**: {modification_scope}
+
+## Restoration Command
+cp {backup_dir}/* .workflow/active/{session}/
+```
+
+**Output**: All files safely backed up with manifest
+
+---
+
+### Phase 5: Apply Modifications
+
+**Step 5.1: Update IMPL_PLAN.md** (if needed)
+
+Use Edit tool to modify specific sections:
+- Update affected technical sections
+- Update modification date
+
+**Step 5.2: Update TODO_LIST.md** (if needed)
+
+- Add new tasks with `[ ]` checkbox
+- Mark deleted tasks as `[x] ~~task~~ (已废弃)`
+- Update modified task descriptions
+
+**Step 5.3: Update Task JSONs**
+
+For each affected task:
+```typescript
+const updated_task = {
+  ...task,
+  context: {
+    ...task.context,
+    requirements: [...updated_requirements],
+    acceptance: [...updated_acceptance]
+  },
+  flow_control: {
+    ...task.flow_control,
+    implementation_approach: [...updated_steps]
+  }
+};
+
+Write({
+  file_path: `.workflow/active/${SESSION_ID}/.task/${task_id}.json`,
+  content: JSON.stringify(updated_task, null, 2)
+});
+```
+
+**Step 5.4: Create New Tasks** (if needed)
+
+Generate complete task JSON with all required fields:
+- id, title, status
+- meta (type, agent)
+- context (requirements, focus_paths, acceptance)
+- flow_control (pre_analysis, implementation_approach, target_files)
+
+**Step 5.5: Delete Obsolete Tasks** (if needed)
+
+Move to backup instead of hard delete:
+```bash
+mv ".workflow/active/$SESSION_ID/.task/{task-id}.json" "$backup_dir/"
+```
+
+**Step 5.6: Update Session Metadata**
+
+Update workflow-session.json:
+- progress.current_tasks
+- progress.last_replan
+- replan_history array
+
+**Output**: All modifications applied, artifacts updated
+
+---
+
+### Phase 6: Verification & Summary
+
+**Step 6.1: Verify Consistency**
+
+1. Validate all task JSONs are valid JSON
+2. Check task count within limits (max 10)
+3. Verify dependency graph is acyclic
+
+**Step 6.2: Generate Change Summary**
+
+```markdown
+## 重规划完成
+
+### 会话信息
+- **Session**: {session-id}
+- **时间**: {timestamp}
+- **备份**: {backup-path}
+
+### 变更摘要
+**范围**: {scope}
+**原因**: {reason}
+
+### 修改的文件
+- ✓ IMPL_PLAN.md: {changes}
+- ✓ TODO_LIST.md: {changes}
+- ✓ Task JSONs: {count} files updated
+
+### 任务变更
+- **新增**: {task-ids}
+- **删除**: {task-ids}
+- **更新**: {task-ids}
+
+### 回滚方法
+cp {backup-path}/* .workflow/active/{session}/
+```
+
+**Output**: Summary displayed, replan complete
+
+---
+
+## TodoWrite Progress Tracking
+
+### Session Mode Progress
+
+```json
+[
+  {"content": "检测模式和发现会话", "status": "completed", "activeForm": "检测模式和发现会话"},
+  {"content": "交互式需求明确", "status": "completed", "activeForm": "交互式需求明确"},
+  {"content": "影响分析和计划生成", "status": "completed", "activeForm": "影响分析和计划生成"},
+  {"content": "创建备份", "status": "completed", "activeForm": "创建备份"},
+  {"content": "更新会话产出文件", "status": "completed", "activeForm": "更新会话产出文件"},
+  {"content": "验证一致性", "status": "completed", "activeForm": "验证一致性"}
+]
+```
+
+### Task Mode Progress
+
+```json
+[
+  {"content": "检测会话和加载任务", "status": "completed", "activeForm": "检测会话和加载任务"},
+  {"content": "交互式更新确认", "status": "completed", "activeForm": "交互式更新确认"},
+  {"content": "应用任务修改", "status": "completed", "activeForm": "应用任务修改"}
+]
+```
+
+## Error Handling
+
+### Session Errors
+
+```bash
+# No active session found
+ERROR: No active session found
+Run /workflow:session:start to create a session
+
+# Session not found
+ERROR: Session WFS-invalid not found
+Available sessions: [list]
+
+# No changes specified
+WARNING: No modifications specified
+Use --interactive mode or provide requirements
+```
+
+### Task Errors
+
+```bash
+# Task not found
+ERROR: Task IMPL-999 not found in session
+Available tasks: [list]
+
+# Task completed
+WARNING: Task IMPL-001 is completed
+Consider creating new task for additional work
+
+# Circular dependency
+ERROR: Circular dependency detected
+Resolve dependency conflicts before proceeding
+```
+
+### Validation Errors
+
+```bash
+# Task limit exceeded
+ERROR: Replan would create 12 tasks (limit: 10)
+Consider: combining tasks, splitting sessions, or removing tasks
+
+# Invalid JSON
+ERROR: Generated invalid JSON
+Backup preserved, rolling back changes
+```
+
+## File Structure
+
+```
+.workflow/active/WFS-session-name/
+├── workflow-session.json
+├── IMPL_PLAN.md
+├── TODO_LIST.md
+├── .task/
+│   ├── IMPL-001.json
+│   ├── IMPL-002.json
+│   └── IMPL-003.json
+└── .process/
+    ├── context-package.json
+    └── backup/
+        └── replan-{timestamp}/
+            ├── MANIFEST.md
+            ├── IMPL_PLAN.md
+            ├── TODO_LIST.md
+            ├── workflow-session.json
+            └── IMPL-*.json
+```
+
+## Examples
+
+### Session Replan - Add Feature
+
+```bash
+/workflow:replan "添加双因素认证支持"
+
+# Interactive clarification
+Q: 修改范围?
+A: 全面重规划
+
+Q: 受影响模块?
+A: 认证模块, API接口
+
+Q: 任务变更?
+A: 添加新任务, 更新内容
+
+# Execution
+✓ 创建备份
+✓ 更新 IMPL_PLAN.md
+✓ 更新 TODO_LIST.md
+✓ 创建 IMPL-004.json
+✓ 更新 IMPL-001.json, IMPL-002.json
+
+重规划完成! 新增 1 任务,更新 2 任务
+```
+
+### Task Replan - Update Requirements
+
+```bash
+/workflow:replan IMPL-001 "支持 OAuth2.0 标准"
+
+# Interactive clarification
+Q: 更新部分?
+A: 需求和验收标准, 实现方案
+
+Q: 影响其他任务?
+A: 是,需要同步更新依赖任务
+
+# Execution
+✓ 创建备份
+✓ 更新 IMPL-001.json
+✓ 更新 IMPL-002.json (依赖任务)
+
+任务重规划完成! 更新 2 个任务
+```

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

@@ -0,0 +1,610 @@
+---
+name: 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.
+argument-hint: "<export-file|review-dir> [--resume] [--max-iterations=N]"
+allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*), Task(*), Edit(*), Write(*)
+---
+
+# Workflow Review-Fix Command
+
+## Quick Start
+
+```bash
+# Fix from exported findings file (session-based path)
+/workflow:review-fix .workflow/active/WFS-123/.review/fix-export-1706184622000.json
+
+# Fix from review directory (auto-discovers latest export)
+/workflow:review-fix .workflow/active/WFS-123/.review/
+
+# Resume interrupted fix session
+/workflow:review-fix --resume
+
+# Custom max retry attempts per finding
+/workflow:review-fix .workflow/active/WFS-123/.review/ --max-iterations=5
+```
+
+**Fix Source**: Exported findings from review cycle dashboard
+**Output Directory**: `{review-dir}/fixes/{fix-session-id}/` (within session .review/)
+**Default Max Iterations**: 3 (per finding, adjustable)
+**CLI Tools**: @cli-planning-agent (planning), @cli-execute-agent (fixing)
+
+## What & Why
+
+### Core Concept
+Automated fix orchestrator with **two-phase architecture**: AI-powered planning followed by coordinated parallel/serial execution. Generates fix timeline with intelligent grouping and dependency analysis, then executes fixes with conservative test verification.
+
+**Fix Process**:
+- **Planning Phase**: AI analyzes findings, generates fix plan with grouping and execution strategy
+- **Execution Phase**: Main orchestrator coordinates agents per timeline stages
+- **No rigid structure**: Adapts to task requirements, not bound to fixed JSON format
+
+**vs Manual Fixing**:
+- **Manual**: Developer reviews findings one-by-one, fixes sequentially
+- **Automated**: AI groups related issues, executes in optimal parallel/serial order with automatic test verification
+
+### Value Proposition
+1. **Intelligent Planning**: AI-powered analysis identifies optimal grouping and execution strategy
+2. **Multi-stage Coordination**: Supports complex parallel + serial execution with dependency management
+3. **Conservative Safety**: Mandatory test verification with automatic rollback on failure
+4. **Resume Support**: Checkpoint-based recovery for interrupted sessions
+
+### Orchestrator Boundary (CRITICAL)
+- **ONLY command** for automated review finding fixes
+- Manages: Planning phase coordination, stage-based execution, agent scheduling, progress tracking
+- Delegates: Fix planning to @cli-planning-agent, fix execution to @cli-execute-agent
+
+
+### Execution Flow
+
+```
+Phase 1: Discovery & Initialization
+   └─ Validate export file, create fix session structure, initialize state files
+
+Phase 2: Planning Coordination (@cli-planning-agent)
+   ├─ Analyze findings for patterns and dependencies
+   ├─ Group by file + dimension + root cause similarity
+   ├─ Determine execution strategy (parallel/serial/hybrid)
+   ├─ Generate fix timeline with stages
+   └─ Output: fix-plan.json
+
+Phase 3: Execution Orchestration (Stage-based)
+   For each timeline stage:
+   ├─ Load groups for this stage
+   ├─ If parallel: Launch all group agents simultaneously
+   ├─ If serial: Execute groups sequentially
+   ├─ Each agent:
+   │  ├─ Analyze code context
+   │  ├─ Apply fix per strategy
+   │  ├─ Run affected tests
+   │  ├─ On test failure: Rollback, retry up to max_iterations
+   │  └─ On success: Commit, update fix-progress-{N}.json
+   └─ Advance to next stage
+
+Phase 4: Completion & Aggregation
+   └─ Aggregate results → Generate fix-summary.md → Update history → Output summary
+
+Phase 5: Session Completion (Optional)
+   └─ If all fixes successful → Prompt to complete workflow session
+```
+
+### Agent Roles
+
+| Agent | Responsibility |
+|-------|---------------|
+| **Orchestrator** | Input validation, session management, planning coordination, stage-based execution scheduling, progress tracking, aggregation |
+| **@cli-planning-agent** | Findings analysis, intelligent grouping (file+dimension+root cause), execution strategy determination (parallel/serial/hybrid), timeline generation with dependency mapping |
+| **@cli-execute-agent** | Fix execution per group, code context analysis, Edit tool operations, test verification, git rollback on failure, completion JSON generation |
+
+## Enhanced Features
+
+### 1. Two-Phase Architecture
+
+**Phase Separation**:
+
+| Phase | Agent | Output | Purpose |
+|-------|-------|--------|---------|
+| **Planning** | @cli-planning-agent | fix-plan.json | Analyze findings, group intelligently, determine optimal execution strategy |
+| **Execution** | @cli-execute-agent | completions/*.json | Execute fixes per plan with test verification and rollback |
+
+**Benefits**:
+- Clear separation of concerns (analysis vs execution)
+- Reusable plans (can re-execute without re-planning)
+- Better error isolation (planning failures vs execution failures)
+
+### 2. Intelligent Grouping Strategy
+
+**Three-Level Grouping**:
+
+```javascript
+// Level 1: Primary grouping by file + dimension
+{file: "auth.ts", dimension: "security"} → Group A
+{file: "auth.ts", dimension: "quality"} → Group B
+{file: "query-builder.ts", dimension: "security"} → Group C
+
+// Level 2: Secondary grouping by root cause similarity
+Group A findings → Semantic similarity analysis (threshold 0.7)
+  → Sub-group A1: "missing-input-validation" (findings 1, 2)
+  → Sub-group A2: "insecure-crypto" (finding 3)
+
+// Level 3: Dependency analysis
+Sub-group A1 creates validation utilities
+Sub-group C4 depends on those utilities
+→ A1 must execute before C4 (serial stage dependency)
+```
+
+**Similarity Computation**:
+- Combine: `description + recommendation + category`
+- Vectorize: TF-IDF or LLM embedding
+- Cluster: Greedy algorithm with cosine similarity > 0.7
+
+### 3. Execution Strategy Determination
+
+**Strategy Types**:
+
+| Strategy | When to Use | Stage Structure |
+|----------|-------------|-----------------|
+| **Parallel** | All groups independent, different files | Single stage, all groups in parallel |
+| **Serial** | Strong dependencies, shared resources | Multiple stages, one group per stage |
+| **Hybrid** | Mixed dependencies | Multiple stages, parallel within stages |
+
+**Dependency Detection**:
+- Shared file modifications
+- Utility creation + usage patterns
+- Test dependency chains
+- Risk level clustering (high-risk groups isolated)
+
+### 4. Conservative Test Verification
+
+**Test Strategy** (per fix):
+
+```javascript
+// 1. Identify affected tests
+const testPattern = identifyTestPattern(finding.file);
+// e.g., "tests/auth/**/*.test.*" for src/auth/service.ts
+
+// 2. Run tests
+const result = await runTests(testPattern);
+
+// 3. Evaluate
+if (result.passRate < 100%) {
+  // Rollback
+  await gitCheckout(finding.file);
+
+  // Retry with failure context
+  if (attempts < maxIterations) {
+    const fixContext = analyzeFailure(result.stderr);
+    regenerateFix(finding, fixContext);
+    retry();
+  } else {
+    markFailed(finding.id);
+  }
+} else {
+  // Commit
+  await gitCommit(`Fix: ${finding.title} [${finding.id}]`);
+  markFixed(finding.id);
+}
+```
+
+**Pass Criteria**: 100% test pass rate (no partial fixes)
+
+## Core Responsibilities
+
+### Orchestrator
+
+**Phase 1: Discovery & Initialization**
+- Input validation: Check export file exists and is valid JSON
+- Auto-discovery: If review-dir provided, find latest `*-fix-export.json`
+- Session creation: Generate fix-session-id (`fix-{timestamp}`)
+- Directory structure: Create `{review-dir}/fixes/{fix-session-id}/` with subdirectories
+- State files: Initialize active-fix-session.json (session marker)
+- TodoWrite initialization: Set up 4-phase tracking
+
+**Phase 2: Planning Coordination**
+- Launch @cli-planning-agent with findings data and project context
+- Validate fix-plan.json output (schema conformance, includes metadata with session status)
+- Load plan into memory for execution phase
+- TodoWrite update: Mark planning complete, start execution
+
+**Phase 3: Execution Orchestration**
+- Load fix-plan.json timeline stages
+- For each stage:
+  - If parallel mode: Launch all group agents via `Promise.all()`
+  - If serial mode: Execute groups sequentially with `await`
+  - Assign agent IDs (agents update their fix-progress-{N}.json)
+- Handle agent failures gracefully (mark group as failed, continue)
+- Advance to next stage only when current stage complete
+
+**Phase 4: Completion & Aggregation**
+- Collect final status from all fix-progress-{N}.json files
+- Generate fix-summary.md with timeline and results
+- Update fix-history.json with new session entry
+- Remove active-fix-session.json
+- TodoWrite completion: Mark all phases done
+- Output summary to user
+
+**Phase 5: Session Completion (Optional)**
+- If all findings fixed successfully (no failures):
+  - Prompt user: "All fixes complete. Complete workflow session? [Y/n]"
+  - If confirmed: Execute `/workflow:session:complete` to archive session with lessons learned
+- If partial success (some failures):
+  - Output: "Some findings failed. Review fix-summary.md before completing session."
+  - Do NOT auto-complete session
+
+### Output File Structure
+
+```
+.workflow/active/WFS-{session-id}/.review/
+├── fix-export-{timestamp}.json     # Exported findings (input)
+└── fixes/{fix-session-id}/
+    ├── fix-plan.json               # Planning agent output (execution plan with metadata)
+    ├── fix-progress-1.json         # Group 1 progress (planning agent init → agent updates)
+    ├── fix-progress-2.json         # Group 2 progress (planning agent init → agent updates)
+    ├── fix-progress-3.json         # Group 3 progress (planning agent init → agent updates)
+    ├── fix-summary.md              # Final report (orchestrator generates)
+    ├── active-fix-session.json     # Active session marker
+    └── fix-history.json            # All sessions history
+```
+
+**File Producers**:
+- **Planning Agent**: `fix-plan.json` (with metadata), all `fix-progress-*.json` (initial state)
+- **Execution Agents**: Update assigned `fix-progress-{N}.json` in real-time
+
+
+### Agent Invocation Template
+
+**Planning Agent**:
+```javascript
+Task({
+  subagent_type: "cli-planning-agent",
+  description: `Generate fix plan and initialize progress files for ${findings.length} findings`,
+  prompt: `
+## Task Objective
+Analyze ${findings.length} code review findings and generate execution plan with intelligent grouping and timeline coordination.
+
+## Input Data
+Review Session: ${reviewId}
+Fix Session ID: ${fixSessionId}
+Total Findings: ${findings.length}
+
+Findings:
+${JSON.stringify(findings, null, 2)}
+
+Project Context:
+- Structure: ${projectStructure}
+- Test Framework: ${testFramework}
+- Git Status: ${gitStatus}
+
+## Output Requirements
+
+### 1. fix-plan.json
+Execute: cat ~/.claude/workflows/cli-templates/fix-plan-template.json
+
+Generate execution plan following template structure:
+
+**Key Generation Rules**:
+- **Metadata**: Populate fix_session_id, review_session_id, status ("planning"), created_at, started_at timestamps
+- **Execution Strategy**: Choose approach (parallel/serial/hybrid) based on dependency analysis, set parallel_limit and stages count
+- **Groups**: Create groups (G1, G2, ...) with intelligent grouping (see Analysis Requirements below), assign progress files (fix-progress-1.json, ...), populate fix_strategy with approach/complexity/test_pattern, assess risks, identify dependencies
+- **Timeline**: Define stages respecting dependencies, set execution_mode per stage, map groups to stages, calculate critical path
+
+### 2. fix-progress-{N}.json (one per group)
+Execute: cat ~/.claude/workflows/cli-templates/fix-progress-template.json
+
+For each group (G1, G2, G3, ...), generate fix-progress-{N}.json following template structure:
+
+**Initial State Requirements**:
+- Status: "pending", phase: "waiting"
+- Timestamps: Set last_update to now, others null
+- Findings: Populate from review findings with status "pending", all operation fields null
+- Summary: Initialize all counters to zero
+- Flow control: Empty implementation_approach array
+- Errors: Empty array
+
+**CRITICAL**: Ensure complete template structure - all fields must be present.
+
+## Analysis Requirements
+
+### Intelligent Grouping Strategy
+Group findings using these criteria (in priority order):
+
+1. **File Proximity**: Findings in same file or related files
+2. **Dimension Affinity**: Same dimension (security, performance, etc.)
+3. **Root Cause Similarity**: Similar underlying issues
+4. **Fix Approach Commonality**: Can be fixed with similar approach
+
+**Grouping Guidelines**:
+- Optimal group size: 2-5 findings per group
+- Avoid cross-cutting concerns in same group
+- Consider test isolation (different test suites → different groups)
+- Balance workload across groups for parallel execution
+
+### Execution Strategy Determination
+
+**Parallel Mode**: Use when groups are independent, no shared files
+**Serial Mode**: Use when groups have dependencies or shared resources
+**Hybrid Mode**: Use for mixed dependency graphs (recommended for most cases)
+
+**Dependency Analysis**:
+- Identify shared files between groups
+- Detect test dependency chains
+- Evaluate risk of concurrent modifications
+
+### Risk Assessment
+
+For each group, evaluate:
+- **Complexity**: Based on code structure, file size, existing tests
+- **Impact Scope**: Number of files affected, API surface changes
+- **Rollback Feasibility**: Ease of reverting changes if tests fail
+
+### Test Strategy
+
+For each group, determine:
+- **Test Pattern**: Glob pattern matching affected tests
+- **Pass Criteria**: All tests must pass (100% pass rate)
+- **Test Command**: Infer from project (package.json, pytest.ini, etc.)
+
+## Output Files
+
+Write to ${sessionDir}:
+- ./fix-plan.json
+- ./fix-progress-1.json
+- ./fix-progress-2.json
+- ./fix-progress-{N}.json (as many as groups created)
+
+## Quality Checklist
+
+Before finalizing outputs:
+- ✅ All findings assigned to exactly one group
+- ✅ Group dependencies correctly identified
+- ✅ Timeline stages respect dependencies
+- ✅ All progress files have complete initial structure
+- ✅ Test patterns are valid and specific
+- ✅ Risk assessments are realistic
+- ✅ Estimated times are reasonable
+  `
+})
+```
+
+**Execution Agent** (per group):
+```javascript
+Task({
+  subagent_type: "cli-execute-agent",
+  description: `Fix ${group.findings.length} issues: ${group.group_name}`,
+  prompt: `
+## Task Objective
+Execute fixes for code review findings in group ${group.group_id}. Update progress file in real-time with flow control tracking.
+
+## Assignment
+- Group ID: ${group.group_id}
+- Group Name: ${group.group_name}
+- Progress File: ${sessionDir}/${group.progress_file}
+- Findings Count: ${group.findings.length}
+- Max Iterations: ${maxIterations} (per finding)
+
+## Fix Strategy
+${JSON.stringify(group.fix_strategy, null, 2)}
+
+## Risk Assessment
+${JSON.stringify(group.risk_assessment, null, 2)}
+
+## Execution Flow
+
+### Initialization (Before Starting)
+
+1. Read ${group.progress_file} to load initial state
+2. Update progress file:
+   - assigned_agent: "${agentId}"
+   - status: "in-progress"
+   - started_at: Current ISO 8601 timestamp
+   - last_update: Current ISO 8601 timestamp
+3. Write updated state back to ${group.progress_file}
+
+### Main Execution Loop
+
+For EACH finding in ${group.progress_file}.findings:
+
+#### Step 1: Analyze Context
+
+**Before Step**:
+- Update finding: status→"in-progress", started_at→now()
+- Update current_finding: Populate with finding details, status→"analyzing", action→"Reading file and understanding code structure"
+- Update phase→"analyzing"
+- Update flow_control: Add "analyze_context" step to implementation_approach (status→"in-progress"), set current_step→"analyze_context"
+- Update last_update→now(), write to ${group.progress_file}
+
+**Action**:
+- Read file: finding.file
+- Understand code structure around line: finding.line
+- Analyze surrounding context (imports, dependencies, related functions)
+- Review recommendations: finding.recommendations
+
+**After Step**:
+- Update flow_control: Mark "analyze_context" step as "completed" with completed_at→now()
+- Update last_update→now(), write to ${group.progress_file}
+
+#### Step 2: Apply Fix
+
+**Before Step**:
+- Update current_finding: status→"fixing", action→"Applying code changes per recommendations"
+- Update phase→"fixing"
+- Update flow_control: Add "apply_fix" step to implementation_approach (status→"in-progress"), set current_step→"apply_fix"
+- Update last_update→now(), write to ${group.progress_file}
+
+**Action**:
+- Use Edit tool to implement code changes per finding.recommendations
+- Follow fix_strategy.approach
+- Maintain code style and existing patterns
+
+**After Step**:
+- Update flow_control: Mark "apply_fix" step as "completed" with completed_at→now()
+- Update last_update→now(), write to ${group.progress_file}
+
+#### Step 3: Test Verification
+
+**Before Step**:
+- Update current_finding: status→"testing", action→"Running test suite to verify fix"
+- Update phase→"testing"
+- Update flow_control: Add "run_tests" step to implementation_approach (status→"in-progress"), set current_step→"run_tests"
+- Update last_update→now(), write to ${group.progress_file}
+
+**Action**:
+- Run tests using fix_strategy.test_pattern
+- Require 100% pass rate
+- Capture test output
+
+**On Test Failure**:
+- Git rollback: \`git checkout -- \${finding.file}\`
+- Increment finding.attempts
+- Update flow_control: Mark "run_tests" step as "failed" with completed_at→now()
+- Update errors: Add entry (finding_id, error_type→"test_failure", message, timestamp)
+- If finding.attempts < ${maxIterations}:
+  - Reset flow_control: implementation_approach→[], current_step→null
+  - Retry from Step 1
+- Else:
+  - Update finding: status→"completed", result→"failed", error_message→"Max iterations reached", completed_at→now()
+  - Update summary counts, move to next finding
+
+**On Test Success**:
+- Update flow_control: Mark "run_tests" step as "completed" with completed_at→now()
+- Update last_update→now(), write to ${group.progress_file}
+- Proceed to Step 4
+
+#### Step 4: Commit Changes
+
+**Before Step**:
+- Update current_finding: status→"committing", action→"Creating git commit for successful fix"
+- Update phase→"committing"
+- Update flow_control: Add "commit_changes" step to implementation_approach (status→"in-progress"), set current_step→"commit_changes"
+- Update last_update→now(), write to ${group.progress_file}
+
+**Action**:
+- Git commit: \`git commit -m "fix(${finding.dimension}): ${finding.title} [${finding.id}]"\`
+- Capture commit hash
+
+**After Step**:
+- Update finding: status→"completed", result→"fixed", commit_hash→<captured>, test_passed→true, completed_at→now()
+- Update flow_control: Mark "commit_changes" step as "completed" with completed_at→now()
+- Update last_update→now(), write to ${group.progress_file}
+
+#### After Each Finding
+
+- Update summary: Recalculate counts (pending/in_progress/fixed/failed) and percent_complete
+- If all findings completed: Clear current_finding, reset flow_control
+- Update last_update→now(), write to ${group.progress_file}
+
+### Final Completion
+
+When all findings processed:
+- Update status→"completed", phase→"done", summary.percent_complete→100.0
+- Update last_update→now(), write final state to ${group.progress_file}
+
+## Critical Requirements
+
+### Progress File Updates
+- **MUST update after every significant action** (before/after each step)
+- **Always maintain complete structure** - never write partial updates
+- **Use ISO 8601 timestamps** - e.g., "2025-01-25T14:36:00Z"
+
+### Flow Control Format
+Follow action-planning-agent flow_control.implementation_approach format:
+- step: Identifier (e.g., "analyze_context", "apply_fix")
+- action: Human-readable description
+- status: "pending" | "in-progress" | "completed" | "failed"
+- started_at: ISO 8601 timestamp or null
+- completed_at: ISO 8601 timestamp or null
+
+### Error Handling
+- Capture all errors in errors[] array
+- Never leave progress file in invalid state
+- Always write complete updates, never partial
+- On unrecoverable error: Mark group as failed, preserve state
+
+## Test Patterns
+Use fix_strategy.test_pattern to run affected tests:
+- Pattern: ${group.fix_strategy.test_pattern}
+- Command: Infer from project (npm test, pytest, etc.)
+- Pass Criteria: 100% pass rate required
+  `
+})
+```
+
+
+
+### Error Handling
+
+**Planning Failures**:
+- Invalid template → Abort with error message
+- Insufficient findings data → Request complete export
+- Planning timeout → Retry once, then fail gracefully
+
+**Execution Failures**:
+- Agent crash → Mark group as failed, continue with other groups
+- Test command not found → Skip test verification, warn user
+- Git operations fail → Abort with error, preserve state
+
+**Rollback Scenarios**:
+- Test failure after fix → Automatic `git checkout` rollback
+- Max iterations reached → Leave file unchanged, mark as failed
+- Unrecoverable error → Rollback entire group, save checkpoint
+
+### TodoWrite Structure
+
+**Initialization**:
+```javascript
+TodoWrite({
+  todos: [
+    {content: "Phase 1: Discovery & Initialization", status: "completed"},
+    {content: "Phase 2: Planning", status: "in_progress"},
+    {content: "Phase 3: Execution", status: "pending"},
+    {content: "Phase 4: Completion", status: "pending"}
+  ]
+});
+```
+
+**During Execution**:
+```javascript
+TodoWrite({
+  todos: [
+    {content: "Phase 1: Discovery & Initialization", status: "completed"},
+    {content: "Phase 2: Planning", status: "completed"},
+    {content: "Phase 3: Execution", status: "in_progress"},
+    {content: "  → Stage 1: Parallel execution (3 groups)", status: "completed"},
+    {content: "    • Group G1: Auth validation (2 findings)", status: "completed"},
+    {content: "    • Group G2: Query security (3 findings)", status: "completed"},
+    {content: "    • Group G3: Config quality (1 finding)", status: "completed"},
+    {content: "  → Stage 2: Serial execution (1 group)", status: "in_progress"},
+    {content: "    • Group G4: Dependent fixes (2 findings)", status: "in_progress"},
+    {content: "Phase 4: Completion", status: "pending"}
+  ]
+});
+```
+
+**Update Rules**:
+- Add stage items dynamically based on fix-plan.json timeline
+- Add group items per stage
+- 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
+2. **Conservative Approach**: Test verification is mandatory - no fixes kept without passing tests
+3. **Parallel Efficiency**: Default 3 concurrent agents balances speed and resource usage
+4. **Resume Support**: Fix sessions can resume from checkpoints after interruption
+5. **Manual Review**: Always review failed fixes manually - may require architectural changes
+6. **Incremental Fixing**: Start with small batches (5-10 findings) before large-scale fixes
+
+## Related Commands
+
+### View Fix Progress
+Use `ccw view` to open the workflow dashboard in browser:
+
+```bash
+ccw view
+```
+
+

.claude/commands/workflow/review-module-cycle.md

@@ -0,0 +1,771 @@
+---
+name: 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.
+argument-hint: "<path-pattern> [--dimensions=security,architecture,...] [--max-iterations=N]"
+allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*), Task(*)
+---
+
+# Workflow Review-Module-Cycle Command
+
+## Quick Start
+
+```bash
+# Review specific module (all 7 dimensions)
+/workflow:review-module-cycle src/auth/**
+
+# Review multiple modules
+/workflow:review-module-cycle src/auth/**,src/payment/**
+
+# Review with custom dimensions
+/workflow:review-module-cycle src/payment/** --dimensions=security,architecture,quality
+
+# Review specific files
+/workflow:review-module-cycle src/payment/processor.ts,src/payment/validator.ts
+```
+
+**Review Scope**: Specified modules/files only (independent of git history)
+**Session Requirement**: Auto-creates workflow session via `/workflow:session:start`
+**Output Directory**: `.workflow/active/WFS-{session-id}/.review/` (session-based)
+**Default Dimensions**: Security, Architecture, Quality, Action-Items, Performance, Maintainability, Best-Practices
+**Max Iterations**: 3 (adjustable via --max-iterations)
+**Default Iterations**: 1 (deep-dive runs once; use --max-iterations=0 to skip)
+**CLI Tools**: Gemini → Qwen → Codex (fallback chain)
+
+## What & Why
+
+### Core Concept
+Independent multi-dimensional code review orchestrator with **hybrid parallel-iterative execution** for comprehensive quality assessment of **specific modules or files**.
+
+**Review Scope**:
+- **Module-based**: Reviews specified file patterns (e.g., `src/auth/**`, `*.ts`)
+- **Session-integrated**: Runs within workflow session context for unified tracking
+- **Output location**: `.review/` subdirectory within active session
+
+**vs Session Review**:
+- **Session Review** (`review-session-cycle`): Reviews git changes within a workflow session
+- **Module Review** (`review-module-cycle`): Reviews any specified code paths, regardless of git history
+- **Common output**: Both use same `.review/` directory structure within session
+
+### Value Proposition
+1. **Module-Focused Review**: Target specific code areas independent of git history
+2. **Session-Integrated**: Review results tracked within workflow session for unified management
+3. **Comprehensive Coverage**: Same 7 specialized dimensions as session review
+4. **Intelligent Prioritization**: Automatic identification of critical issues and cross-cutting concerns
+5. **Unified Archive**: Review results archived with session for historical reference
+
+### Orchestrator Boundary (CRITICAL)
+- **ONLY command** for independent multi-dimensional module review
+- Manages: dimension coordination, aggregation, iteration control, progress tracking
+- Delegates: Code exploration and analysis to @cli-explore-agent, dimension-specific reviews via Deep Scan mode
+
+## How It Works
+
+### Execution Flow
+
+```
+Phase 1: Discovery & Initialization
+   └─ Resolve file patterns, validate paths, initialize state, create output structure
+
+Phase 2: Parallel Reviews (for each dimension)
+   ├─ Launch 7 review agents simultaneously
+   ├─ Each executes CLI analysis via Gemini/Qwen on specified files
+   ├─ Generate dimension JSON + markdown reports
+   └─ Update review-progress.json
+
+Phase 3: Aggregation
+   ├─ Load all dimension JSON files
+   ├─ Calculate severity distribution (critical/high/medium/low)
+   ├─ Identify cross-cutting concerns (files in 3+ dimensions)
+   └─ Decision:
+      ├─ Critical findings OR high > 5 OR critical files → Phase 4 (Iterate)
+      └─ Else → Phase 5 (Complete)
+
+Phase 4: Iterative Deep-Dive (optional)
+   ├─ Select critical findings (max 5 per iteration)
+   ├─ Launch deep-dive agents for root cause analysis
+   ├─ Generate remediation plans with impact assessment
+   ├─ Re-assess severity based on analysis
+   └─ Loop until no critical findings OR max iterations
+
+Phase 5: Completion
+   └─ Finalize review-progress.json
+```
+
+### Agent Roles
+
+| Agent | Responsibility |
+|-------|---------------|
+| **Orchestrator** | Phase control, path resolution, state management, aggregation logic, iteration control |
+| **@cli-explore-agent** (Review) | Execute dimension-specific code analysis via Deep Scan mode, generate findings JSON with dual-source strategy (Bash + Gemini), create structured analysis reports |
+| **@cli-explore-agent** (Deep-dive) | Focused root cause analysis using dependency mapping, remediation planning with architectural insights, impact assessment, severity re-assessment |
+
+## Enhanced Features
+
+### 1. Review Dimensions Configuration
+
+**7 Specialized Dimensions** with priority-based allocation:
+
+| Dimension | Template | Priority | Timeout |
+|-----------|----------|----------|---------|
+| **Security** | 03-assess-security-risks.txt | 1 (Critical) | 60min |
+| **Architecture** | 02-review-architecture.txt | 2 (High) | 60min |
+| **Quality** | 02-review-code-quality.txt | 3 (Medium) | 40min |
+| **Action-Items** | 02-analyze-code-patterns.txt | 2 (High) | 40min |
+| **Performance** | 03-analyze-performance.txt | 3 (Medium) | 60min |
+| **Maintainability** | 02-review-code-quality.txt* | 3 (Medium) | 40min |
+| **Best-Practices** | 03-review-quality-standards.txt | 3 (Medium) | 40min |
+
+*Custom focus: "Assess technical debt and maintainability"
+
+**Category Definitions by Dimension**:
+
+```javascript
+const CATEGORIES = {
+  security: ['injection', 'authentication', 'authorization', 'encryption', 'input-validation', 'access-control', 'data-exposure'],
+  architecture: ['coupling', 'cohesion', 'layering', 'dependency', 'pattern-violation', 'scalability', 'separation-of-concerns'],
+  quality: ['code-smell', 'duplication', 'complexity', 'naming', 'error-handling', 'testability', 'readability'],
+  'action-items': ['requirement-coverage', 'acceptance-criteria', 'documentation', 'deployment-readiness', 'missing-functionality'],
+  performance: ['n-plus-one', 'inefficient-query', 'memory-leak', 'blocking-operation', 'caching', 'resource-usage'],
+  maintainability: ['technical-debt', 'magic-number', 'long-method', 'large-class', 'dead-code', 'commented-code'],
+  'best-practices': ['convention-violation', 'anti-pattern', 'deprecated-api', 'missing-validation', 'inconsistent-style']
+};
+```
+
+### 2. Path Pattern Resolution
+
+**Syntax Rules**:
+- All paths are **relative** from project root (e.g., `src/auth/**` not `/src/auth/**`)
+- Multiple patterns: comma-separated, **no spaces** (e.g., `src/auth/**,src/payment/**`)
+- Glob and specific files can be mixed (e.g., `src/auth/**,src/config.ts`)
+
+**Supported Patterns**:
+| Pattern Type | Example | Description |
+|--------------|---------|-------------|
+| Glob directory | `src/auth/**` | All files under src/auth/ |
+| Glob with extension | `src/**/*.ts` | All .ts files under src/ |
+| Specific file | `src/payment/processor.ts` | Single file |
+| Multiple patterns | `src/auth/**,src/payment/**` | Comma-separated (no spaces) |
+
+**Resolution Process**:
+1. Parse input pattern (split by comma, trim whitespace)
+2. Expand glob patterns to file list via `find` command
+3. Validate all files exist and are readable
+4. Error if pattern matches 0 files
+5. Store resolved file list in review-state.json
+
+### 3. Aggregation Logic
+
+**Cross-Cutting Concern Detection**:
+1. Files appearing in 3+ dimensions = **Critical Files**
+2. Same issue pattern across dimensions = **Systemic Issue**
+3. Severity clustering in specific files = **Hotspots**
+
+**Deep-Dive Selection Criteria**:
+- All critical severity findings (priority 1)
+- Top 3 high-severity findings in critical files (priority 2)
+- Max 5 findings per iteration (prevent overwhelm)
+
+### 4. Severity Assessment
+
+**Severity Levels**:
+- **Critical**: Security vulnerabilities, data corruption risks, system-wide failures, authentication/authorization bypass
+- **High**: Feature degradation, performance bottlenecks, architecture violations, significant technical debt
+- **Medium**: Code smells, minor performance issues, style inconsistencies, maintainability concerns
+- **Low**: Documentation gaps, minor refactoring opportunities, cosmetic issues
+
+**Iteration Trigger**:
+- Critical findings > 0 OR
+- High findings > 5 OR
+- Critical files count > 0
+
+## Core Responsibilities
+
+### Orchestrator
+
+**Phase 1: Discovery & Initialization**
+
+**Step 1: Session Creation**
+```javascript
+// Create workflow session for this review (type: review)
+SlashCommand(command="/workflow:session:start --type review \"Code review for [target_pattern]\"")
+
+// Parse output
+const sessionId = output.match(/SESSION_ID: (WFS-[^\s]+)/)[1];
+```
+
+**Step 2: Path Resolution & Validation**
+```bash
+# Expand glob pattern to file list (relative paths from project root)
+find . -path "./src/auth/**" -type f | sed 's|^\./||'
+
+# Validate files exist and are readable
+for file in ${resolvedFiles[@]}; do
+  test -r "$file" || error "File not readable: $file"
+done
+```
+- Parse and expand file patterns (glob support): `src/auth/**` → actual file list
+- Validation: Ensure all specified files exist and are readable
+- Store as **relative paths** from project root (e.g., `src/auth/service.ts`)
+- Agents construct absolute paths dynamically during execution
+
+**Step 3: Output Directory Setup**
+- Output directory: `.workflow/active/${sessionId}/.review/`
+- Create directory structure:
+  ```bash
+  mkdir -p ${sessionDir}/.review/{dimensions,iterations,reports}
+  ```
+
+**Step 4: Initialize Review State**
+- State initialization: Create `review-state.json` with metadata, dimensions, max_iterations, resolved_files (merged metadata + state)
+- Progress tracking: Create `review-progress.json` for progress tracking
+
+**Step 5: TodoWrite Initialization**
+- Set up progress tracking with hierarchical structure
+- Mark Phase 1 completed, Phase 2 in_progress
+
+**Phase 2: Parallel Review Coordination**
+- Launch 7 @cli-explore-agent instances simultaneously (Deep Scan mode)
+- Pass dimension-specific context (template, timeout, custom focus, **target files**)
+- Monitor completion via review-progress.json updates
+- TodoWrite updates: Mark dimensions as completed
+- CLI tool fallback: Gemini → Qwen → Codex (on error/timeout)
+
+**Phase 3: Aggregation**
+- Load all dimension JSON files from dimensions/
+- Calculate severity distribution: Count by critical/high/medium/low
+- Identify cross-cutting concerns: Files in 3+ dimensions
+- Select deep-dive findings: Critical + high in critical files (max 5)
+- Decision logic: Iterate if critical > 0 OR high > 5 OR critical files exist
+- Update review-state.json with aggregation results
+
+**Phase 4: Iteration Control**
+- Check iteration count < max_iterations (default 3)
+- Launch deep-dive agents for selected findings
+- Collect remediation plans and re-assessed severities
+- Update severity distribution based on re-assessments
+- Record iteration in review-state.json
+- Loop back to aggregation if still have critical/high findings
+
+**Phase 5: Completion**
+- Finalize review-progress.json with completion statistics
+- Update review-state.json with completion_time and phase=complete
+- TodoWrite completion: Mark all tasks done
+
+
+
+### Output File Structure
+
+```
+.workflow/active/WFS-{session-id}/.review/
+├── review-state.json                    # Orchestrator state machine (includes metadata)
+├── review-progress.json                 # Real-time progress for dashboard
+├── dimensions/                          # Per-dimension results
+│   ├── security.json
+│   ├── architecture.json
+│   ├── quality.json
+│   ├── action-items.json
+│   ├── performance.json
+│   ├── maintainability.json
+│   └── best-practices.json
+├── iterations/                          # Deep-dive results
+│   ├── iteration-1-finding-{uuid}.json
+│   └── iteration-2-finding-{uuid}.json
+└── reports/                             # Human-readable reports
+    ├── security-analysis.md
+    ├── security-cli-output.txt
+    ├── deep-dive-1-{uuid}.md
+    └── ...
+```
+
+**Session Context**:
+```
+.workflow/active/WFS-{session-id}/
+├── workflow-session.json
+├── IMPL_PLAN.md
+├── TODO_LIST.md
+├── .task/
+├── .summaries/
+└── .review/                             # Review results (this command)
+    └── (structure above)
+```
+
+### Review State JSON
+
+**Purpose**: Unified state machine and metadata (merged from metadata + state)
+
+```json
+{
+  "review_id": "review-20250125-143022",
+  "review_type": "module",
+  "session_id": "WFS-auth-system",
+  "metadata": {
+    "created_at": "2025-01-25T14:30:22Z",
+    "target_pattern": "src/auth/**",
+    "resolved_files": [
+      "src/auth/service.ts",
+      "src/auth/validator.ts",
+      "src/auth/middleware.ts"
+    ],
+    "dimensions": ["security", "architecture", "quality", "action-items", "performance", "maintainability", "best-practices"],
+    "max_iterations": 3
+  },
+  "phase": "parallel|aggregate|iterate|complete",
+  "current_iteration": 1,
+  "dimensions_reviewed": ["security", "architecture", "quality", "action-items", "performance", "maintainability", "best-practices"],
+  "selected_strategy": "comprehensive",
+  "next_action": "execute_parallel_reviews|aggregate_findings|execute_deep_dive|generate_final_report|complete",
+  "severity_distribution": {
+    "critical": 2,
+    "high": 5,
+    "medium": 12,
+    "low": 8
+  },
+  "critical_files": [...],
+  "iterations": [...],
+  "completion_criteria": {...}
+}
+```
+
+### Review Progress JSON
+
+**Purpose**: Real-time dashboard updates via polling
+
+```json
+{
+  "review_id": "review-20250125-143022",
+  "last_update": "2025-01-25T14:35:10Z",
+  "phase": "parallel|aggregate|iterate|complete",
+  "current_iteration": 1,
+  "progress": {
+    "parallel_review": {
+      "total_dimensions": 7,
+      "completed": 5,
+      "in_progress": 2,
+      "percent_complete": 71
+    },
+    "deep_dive": {
+      "total_findings": 6,
+      "analyzed": 2,
+      "in_progress": 1,
+      "percent_complete": 33
+    }
+  },
+  "agent_status": [
+    {
+      "agent_type": "review-agent",
+      "dimension": "security",
+      "status": "completed",
+      "started_at": "2025-01-25T14:30:00Z",
+      "completed_at": "2025-01-25T15:15:00Z",
+      "duration_ms": 2700000
+    },
+    {
+      "agent_type": "deep-dive-agent",
+      "finding_id": "sec-001-uuid",
+      "status": "in_progress",
+      "started_at": "2025-01-25T14:32:00Z"
+    }
+  ],
+  "estimated_completion": "2025-01-25T16:00:00Z"
+}
+```
+
+### Agent Output Schemas
+
+**Agent-produced JSON files follow standardized schemas**:
+
+1. **Dimension Results** (cli-explore-agent output from parallel reviews)
+   - Schema: `~/.claude/workflows/cli-templates/schemas/review-dimension-results-schema.json`
+   - Output: `{output-dir}/dimensions/{dimension}.json`
+   - Contains: findings array, summary statistics, cross_references
+
+2. **Deep-Dive Results** (cli-explore-agent output from iterations)
+   - Schema: `~/.claude/workflows/cli-templates/schemas/review-deep-dive-results-schema.json`
+   - Output: `{output-dir}/iterations/iteration-{N}-finding-{uuid}.json`
+   - Contains: root_cause, remediation_plan, impact_assessment, reassessed_severity
+
+### Agent Invocation Template
+
+**Review Agent** (parallel execution, 7 instances):
+
+```javascript
+Task(
+  subagent_type="cli-explore-agent",
+  run_in_background=false,
+  description=`Execute ${dimension} review analysis via Deep Scan`,
+  prompt=`
+    ## Task Objective
+    Conduct comprehensive ${dimension} code exploration and analysis using Deep Scan mode (Bash + Gemini dual-source strategy) for specified module files
+
+    ## Analysis Mode Selection
+    Use **Deep Scan mode** for this review:
+    - Phase 1: Bash structural scan for standard patterns (classes, functions, imports)
+    - Phase 2: Gemini semantic analysis for design intent, non-standard patterns, ${dimension}-specific concerns
+    - Phase 3: Synthesis with attribution (bash-discovered vs gemini-discovered findings)
+
+    ## MANDATORY FIRST STEPS (Execute by Agent)
+    **You (cli-explore-agent) MUST execute these steps in order:**
+    1. Read review state: ${reviewStateJsonPath}
+    2. Get target files: Read resolved_files from review-state.json
+    3. Validate file access: bash(ls -la ${targetFiles.join(' ')})
+    4. Execute: cat ~/.claude/workflows/cli-templates/schemas/review-dimension-results-schema.json (get output schema reference)
+    5. Read: .workflow/project-tech.json (technology stack and architecture context)
+    6. Read: .workflow/project-guidelines.json (user-defined constraints and conventions to validate against)
+
+    ## Review Context
+    - Review Type: module (independent)
+    - Review Dimension: ${dimension}
+    - Review ID: ${reviewId}
+    - Target Pattern: ${targetPattern}
+    - Resolved Files: ${resolvedFiles.length} files
+    - Output Directory: ${outputDir}
+
+    ## CLI Configuration
+    - Tool Priority: gemini → qwen → codex (fallback chain)
+    - Custom Focus: ${customFocus || 'Standard dimension analysis'}
+    - Mode: analysis (READ-ONLY)
+    - Context Pattern: ${targetFiles.map(f => `@${f}`).join(' ')}
+
+    ## Expected Deliverables
+
+    **Schema Reference**: Schema obtained in MANDATORY FIRST STEPS step 4, follow schema exactly
+
+    1. Dimension Results JSON: ${outputDir}/dimensions/${dimension}.json
+
+       **⚠️ CRITICAL JSON STRUCTURE REQUIREMENTS**:
+
+       Root structure MUST be array: \`[{ ... }]\` NOT \`{ ... }\`
+
+       Required top-level fields:
+       - dimension, review_id, analysis_timestamp (NOT timestamp/analyzed_at)
+       - cli_tool_used (gemini|qwen|codex), model, analysis_duration_ms
+       - summary (FLAT structure), findings, cross_references
+
+       Summary MUST be FLAT (NOT nested by_severity):
+       \`{ "total_findings": N, "critical": N, "high": N, "medium": N, "low": N, "files_analyzed": N, "lines_reviewed": N }\`
+
+       Finding required fields:
+       - id: format \`{dim}-{seq}-{uuid8}\` e.g., \`sec-001-a1b2c3d4\` (lowercase)
+       - severity: lowercase only (critical|high|medium|low)
+       - snippet (NOT code_snippet), impact (NOT exploit_scenario)
+       - metadata, iteration (0), status (pending_remediation), cross_references
+
+    2. Analysis Report: ${outputDir}/reports/${dimension}-analysis.md
+       - Human-readable summary with recommendations
+       - Grouped by severity: critical → high → medium → low
+       - Include file:line references for all findings
+
+    3. CLI Output Log: ${outputDir}/reports/${dimension}-cli-output.txt
+       - Raw CLI tool output for debugging
+       - Include full analysis text
+
+    ## Dimension-Specific Guidance
+    ${getDimensionGuidance(dimension)}
+
+    ## Success Criteria
+    - [ ] Schema obtained via cat review-dimension-results-schema.json
+    - [ ] All target files analyzed for ${dimension} concerns
+    - [ ] All findings include file:line references with code snippets
+    - [ ] Severity assessment follows established criteria (see reference)
+    - [ ] Recommendations are actionable with code examples
+    - [ ] JSON output follows schema exactly
+    - [ ] Report is comprehensive and well-organized
+  `
+)
+```
+
+**Deep-Dive Agent** (iteration execution):
+
+```javascript
+Task(
+  subagent_type="cli-explore-agent",
+  run_in_background=false,
+  description=`Deep-dive analysis for critical finding: ${findingTitle} via Dependency Map + Deep Scan`,
+  prompt=`
+    ## Task Objective
+    Perform focused root cause analysis using Dependency Map mode (for impact analysis) + Deep Scan mode (for semantic understanding) to generate comprehensive remediation plan for critical ${dimension} issue
+
+    ## Analysis Mode Selection
+    Use **Dependency Map mode** first to understand dependencies:
+    - Build dependency graph around ${file} to identify affected components
+    - Detect circular dependencies or tight coupling related to this finding
+    - Calculate change risk scores for remediation impact
+
+    Then apply **Deep Scan mode** for semantic analysis:
+    - Understand design intent and architectural context
+    - Identify non-standard patterns or implicit dependencies
+    - Extract remediation insights from code structure
+
+    ## Finding Context
+    - Finding ID: ${findingId}
+    - Original Dimension: ${dimension}
+    - Title: ${findingTitle}
+    - File: ${file}:${line}
+    - Severity: ${severity}
+    - Category: ${category}
+    - Original Description: ${description}
+    - Iteration: ${iteration}
+
+    ## MANDATORY FIRST STEPS (Execute by Agent)
+    **You (cli-explore-agent) MUST execute these steps in order:**
+    1. Read original finding: ${dimensionJsonPath}
+    2. Read affected file: ${file}
+    3. Identify related code: bash(grep -r "import.*${basename(file)}" ${projectDir}/src --include="*.ts")
+    4. Read test files: bash(find ${projectDir}/tests -name "*${basename(file, '.ts')}*" -type f)
+    5. Execute: cat ~/.claude/workflows/cli-templates/schemas/review-deep-dive-results-schema.json (get output schema reference)
+    6. Read: .workflow/project-tech.json (technology stack and architecture context)
+    7. Read: .workflow/project-guidelines.json (user-defined constraints for remediation compliance)
+
+    ## CLI Configuration
+    - Tool Priority: gemini → qwen → codex
+    - Template: ~/.claude/workflows/cli-templates/prompts/analysis/01-diagnose-bug-root-cause.txt
+    - Mode: analysis (READ-ONLY)
+
+    ## Expected Deliverables
+
+    **Schema Reference**: Schema obtained in MANDATORY FIRST STEPS step 5, follow schema exactly
+
+    1. Deep-Dive Results JSON: ${outputDir}/iterations/iteration-${iteration}-finding-${findingId}.json
+
+       **⚠️ CRITICAL JSON STRUCTURE REQUIREMENTS**:
+
+       Root structure MUST be array: \`[{ ... }]\` NOT \`{ ... }\`
+
+       Required top-level fields:
+       - finding_id, dimension, iteration, analysis_timestamp
+       - cli_tool_used, model, analysis_duration_ms
+       - original_finding, root_cause, remediation_plan
+       - impact_assessment, reassessed_severity, confidence_score, cross_references
+
+       All nested objects must follow schema exactly - read schema for field names
+
+    2. Analysis Report: ${outputDir}/reports/deep-dive-${iteration}-${findingId}.md
+       - Detailed root cause analysis
+       - Step-by-step remediation plan
+       - Impact assessment and rollback strategy
+
+    ## Success Criteria
+    - [ ] Schema obtained via cat review-deep-dive-results-schema.json
+    - [ ] Root cause clearly identified with supporting evidence
+    - [ ] Remediation plan is step-by-step actionable with exact file:line references
+    - [ ] Each step includes specific commands and validation tests
+    - [ ] Impact fully assessed (files, tests, breaking changes, dependencies)
+    - [ ] Severity re-evaluation justified with evidence
+    - [ ] Confidence score accurately reflects certainty of analysis
+    - [ ] JSON output follows schema exactly
+    - [ ] References include project-specific and external documentation
+  `
+)
+```
+
+### Dimension Guidance Reference
+
+```javascript
+function getDimensionGuidance(dimension) {
+  const guidance = {
+    security: `
+      Focus Areas:
+      - Input validation and sanitization
+      - Authentication and authorization mechanisms
+      - Data encryption (at-rest and in-transit)
+      - SQL/NoSQL injection vulnerabilities
+      - XSS, CSRF, and other web vulnerabilities
+      - Sensitive data exposure
+      - Access control and privilege escalation
+
+      Severity Criteria:
+      - Critical: Authentication bypass, SQL injection, RCE, sensitive data exposure
+      - High: Missing authorization checks, weak encryption, exposed secrets
+      - Medium: Missing input validation, insecure defaults, weak password policies
+      - Low: Security headers missing, verbose error messages, outdated dependencies
+    `,
+    architecture: `
+      Focus Areas:
+      - Layering and separation of concerns
+      - Coupling and cohesion
+      - Design pattern adherence
+      - Dependency management
+      - Scalability and extensibility
+      - Module boundaries
+      - API design consistency
+
+      Severity Criteria:
+      - Critical: Circular dependencies, god objects, tight coupling across layers
+      - High: Violated architectural principles, scalability bottlenecks
+      - Medium: Missing abstractions, inconsistent patterns, suboptimal design
+      - Low: Minor coupling issues, documentation gaps, naming inconsistencies
+    `,
+    quality: `
+      Focus Areas:
+      - Code duplication
+      - Complexity (cyclomatic, cognitive)
+      - Naming conventions
+      - Error handling patterns
+      - Code readability
+      - Comment quality
+      - Dead code
+
+      Severity Criteria:
+      - Critical: Severe complexity (CC > 20), massive duplication (>50 lines)
+      - High: High complexity (CC > 10), significant duplication, poor error handling
+      - Medium: Moderate complexity (CC > 5), naming issues, code smells
+      - Low: Minor duplication, documentation gaps, cosmetic issues
+    `,
+    'action-items': `
+      Focus Areas:
+      - Requirements coverage verification
+      - Acceptance criteria met
+      - Documentation completeness
+      - Deployment readiness
+      - Missing functionality
+      - Test coverage gaps
+      - Configuration management
+
+      Severity Criteria:
+      - Critical: Core requirements not met, deployment blockers
+      - High: Significant functionality missing, acceptance criteria not met
+      - Medium: Minor requirements gaps, documentation incomplete
+      - Low: Nice-to-have features missing, minor documentation gaps
+    `,
+    performance: `
+      Focus Areas:
+      - N+1 query problems
+      - Inefficient algorithms (O(n²) where O(n log n) possible)
+      - Memory leaks
+      - Blocking operations on main thread
+      - Missing caching opportunities
+      - Resource usage (CPU, memory, network)
+      - Database query optimization
+
+      Severity Criteria:
+      - Critical: Memory leaks, O(n²) in hot path, blocking main thread
+      - High: N+1 queries, missing indexes, inefficient algorithms
+      - Medium: Suboptimal caching, unnecessary computations, lazy loading issues
+      - Low: Minor optimization opportunities, redundant operations
+    `,
+    maintainability: `
+      Focus Areas:
+      - Technical debt indicators
+      - Magic numbers and hardcoded values
+      - Long methods (>50 lines)
+      - Large classes (>500 lines)
+      - Dead code and commented code
+      - Code documentation
+      - Test coverage
+
+      Severity Criteria:
+      - Critical: Massive methods (>200 lines), severe technical debt blocking changes
+      - High: Large methods (>100 lines), significant dead code, undocumented complex logic
+      - Medium: Magic numbers, moderate technical debt, missing tests
+      - Low: Minor refactoring opportunities, cosmetic improvements
+    `,
+    'best-practices': `
+      Focus Areas:
+      - Framework conventions adherence
+      - Language idioms
+      - Anti-patterns
+      - Deprecated API usage
+      - Coding standards compliance
+      - Error handling patterns
+      - Logging and monitoring
+
+      Severity Criteria:
+      - Critical: Severe anti-patterns, deprecated APIs with security risks
+      - High: Major convention violations, poor error handling, missing logging
+      - Medium: Minor anti-patterns, style inconsistencies, suboptimal patterns
+      - Low: Cosmetic style issues, minor convention deviations
+    `
+  };
+
+  return guidance[dimension] || 'Standard code review analysis';
+}
+```
+
+### Completion Conditions
+
+**Full Success**:
+- All dimensions reviewed
+- Critical findings = 0
+- High findings ≤ 5
+- Action: Generate final report, mark phase=complete
+
+**Partial Success**:
+- All dimensions reviewed
+- Max iterations reached
+- Still have critical/high findings
+- Action: Generate report with warnings, recommend follow-up
+
+### Error Handling
+
+**Phase-Level Error Matrix**:
+
+| Phase | Error | Blocking? | Action |
+|-------|-------|-----------|--------|
+| Phase 1 | Invalid path pattern | Yes | Error and exit |
+| Phase 1 | No files matched | Yes | Error and exit |
+| Phase 1 | Files not readable | Yes | Error and exit |
+| Phase 2 | Single dimension fails | No | Log warning, continue other dimensions |
+| Phase 2 | All dimensions fail | Yes | Error and exit |
+| Phase 3 | Missing dimension JSON | No | Skip in aggregation, log warning |
+| Phase 4 | Deep-dive agent fails | No | Skip finding, continue others |
+| Phase 4 | Max iterations reached | No | Generate partial report |
+
+**CLI Fallback Chain**: Gemini → Qwen → Codex → degraded mode
+
+**Fallback Triggers**:
+1. HTTP 429, 5xx errors, connection timeout
+2. Invalid JSON output (parse error, missing required fields)
+3. Low confidence score < 0.4
+4. Analysis too brief (< 100 words in report)
+
+**Fallback Behavior**:
+- On trigger: Retry with next tool in chain
+- After Codex fails: Enter degraded mode (skip analysis, log error)
+- Degraded mode: Continue workflow with available results
+
+### TodoWrite Structure
+
+```javascript
+TodoWrite({
+  todos: [
+    { content: "Phase 1: Discovery & Initialization", status: "completed", activeForm: "Initializing" },
+    { content: "Phase 2: Parallel Reviews (7 dimensions)", status: "in_progress", activeForm: "Reviewing" },
+    { content: "  → Security review", status: "in_progress", activeForm: "Analyzing security" },
+    // ... other dimensions as sub-items
+    { content: "Phase 3: Aggregation", status: "pending", activeForm: "Aggregating" },
+    { content: "Phase 4: Deep-dive", status: "pending", activeForm: "Deep-diving" },
+    { content: "Phase 5: Completion", status: "pending", activeForm: "Completing" }
+  ]
+});
+```
+
+## Best Practices
+
+1. **Start Specific**: Begin with focused module patterns for faster results
+2. **Expand Gradually**: Add more modules based on initial findings
+3. **Use Glob Wisely**: `src/auth/**` is more efficient than `src/**` with lots of irrelevant files
+4. **Trust Aggregation Logic**: Auto-selection based on proven heuristics
+5. **Monitor Logs**: Check reports/ directory for CLI analysis insights
+
+## Related Commands
+
+### View Review Progress
+Use `ccw view` to open the review dashboard in browser:
+
+```bash
+ccw view
+```
+
+### Automated Fix Workflow
+After completing a module review, use the generated findings JSON for automated fixing:
+
+```bash
+# Step 1: Complete review (this command)
+/workflow:review-module-cycle src/auth/**
+
+# Step 2: Run automated fixes using dimension findings
+/workflow:review-fix .workflow/active/WFS-{session-id}/.review/
+```
+
+See `/workflow:review-fix` for automated fixing with smart grouping, parallel execution, and test verification.
+