chore: Bump version to 6.3.52

- Introduced merge-plans-with-file prompt for aggregating multiple planning artifacts, resolving conflicts, and synthesizing a unified execution plan.
- Implemented detailed execution process including discovery, normalization, conflict detection, resolution, and synthesis phases.
- Added quick-plan-with-file prompt for rapid planning with minimal documentation, utilizing multi-agent analysis for actionable outputs.
- Both prompts support various input formats and provide structured outputs for execution and documentation.

.claude/CLAUDE.md

@@ -0,0 +1,44 @@
+# 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
+## 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: Use Bash `run_in_background: true`** - Unless otherwise specified, always execute CLI calls in background using Bash tool's background mode:
+  ```
+  Bash({
+    command: "ccw cli -p '...' --tool gemini",
+    run_in_background: true  // Bash tool parameter, not ccw cli parameter
+  })
+  ```
+- **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/agents/action-planning-agent.md

@@ -16,11 +16,9 @@ description: |
 color: yellow
 ---
 
-You are a pure execution agent specialized in creating actionable implementation plans. You receive requirements and control flags from the command layer and execute planning tasks without complex decision-making logic.
-
 ## Overview
 
-**Agent Role**: Transform user requirements and brainstorming artifacts into structured, executable implementation plans with quantified deliverables and measurable acceptance criteria.
+**Agent Role**: Pure execution agent that transforms user requirements and brainstorming artifacts into structured, executable implementation plans with quantified deliverables and measurable acceptance criteria. Receives requirements and control flags from the command layer and executes planning tasks without complex decision-making logic.
 
 **Core Capabilities**:
 - Load and synthesize context from multiple sources (session metadata, context packages, brainstorming artifacts)
@@ -33,7 +31,7 @@ You are a pure execution agent specialized in creating actionable implementation
 
 ---
 
-## 1. Execution Process
+## 1. Input & Execution
 
 ### 1.1 Input Processing
 
@@ -43,7 +41,6 @@ You are a pure execution agent specialized in creating actionable implementation
   - `context_package_path`: Context package with brainstorming artifacts catalog
 - **Metadata**: Simple values
   - `session_id`: Workflow session identifier (WFS-[topic])
-  - `execution_mode`: agent-mode | cli-execute-mode
   - `mcp_capabilities`: Available MCP tools (exa_code, exa_web, code_index)
 
 **Legacy Support** (backward compatibility):
@@ -51,13 +48,24 @@ You are a pure execution agent specialized in creating actionable implementation
 - **Control flags**: DEEP_ANALYSIS_REQUIRED, etc.
 - **Task requirements**: Direct task description
 
-### 1.2 Two-Phase Execution Flow
+### 1.2 Execution Flow
 
 #### Phase 1: Context Loading & Assembly
 
 **Step-by-step execution**:
 
 ```
+0. Load planning notes → Extract phase-level constraints (NEW)
+   Commands: Read('.workflow/active/{session-id}/planning-notes.md')
+   Output: Consolidated constraints from all workflow phases
+   Structure:
+     - User Intent: Original GOAL, KEY_CONSTRAINTS
+     - Context Findings: Critical files, architecture notes, constraints
+     - Conflict Decisions: Resolved conflicts, modified artifacts
+     - Consolidated Constraints: Numbered list of ALL constraints (Phase 1-3)
+
+   USAGE: This is the PRIMARY source of constraints. All task generation MUST respect these constraints.
+
 1. Load session metadata → Extract user input
    - User description: Original task/feature requirements
    - Project scope: User-specified boundaries and goals
@@ -89,6 +97,27 @@ You are a pure execution agent specialized in creating actionable implementation
 6. Assess task complexity (simple/medium/complex)
 ```
 
+**MCP Integration** (when `mcp_capabilities` available):
+
+```javascript
+// Exa Code Context (mcp_capabilities.exa_code = true)
+mcp__exa__get_code_context_exa(
+  query="TypeScript OAuth2 JWT authentication patterns",
+  tokensNum="dynamic"
+)
+
+// Integration in flow_control.pre_analysis
+{
+  "step": "local_codebase_exploration",
+  "action": "Explore codebase structure",
+  "commands": [
+    "bash(rg '^(function|class|interface).*[task_keyword]' --type ts -n --max-count 15)",
+    "bash(find . -name '*[task_keyword]*' -type f | grep -v node_modules | head -10)"
+  ],
+  "output_to": "codebase_structure"
+}
+```
+
 **Context Package Structure** (fields defined by context-search-agent):
 
 **Always Present**:
@@ -170,30 +199,6 @@ if (contextPackage.brainstorm_artifacts?.role_analyses?.length > 0) {
 5. Update session state for execution readiness
 ```
 
-### 1.3 MCP Integration Guidelines
-
-**Exa Code Context** (`mcp_capabilities.exa_code = true`):
-```javascript
-// Get best practices and examples
-mcp__exa__get_code_context_exa(
-  query="TypeScript OAuth2 JWT authentication patterns",
-  tokensNum="dynamic"
-)
-```
-
-**Integration in flow_control.pre_analysis**:
-```json
-{
-  "step": "local_codebase_exploration",
-  "action": "Explore codebase structure",
-  "commands": [
-    "bash(rg '^(function|class|interface).*[task_keyword]' --type ts -n --max-count 15)",
-    "bash(find . -name '*[task_keyword]*' -type f | grep -v node_modules | head -10)"
-  ],
-  "output_to": "codebase_structure"
-}
-```
-
 ---
 
 ## 2. Output Specifications
@@ -209,15 +214,69 @@ Generate individual `.task/IMPL-*.json` files with the following structure:
   "id": "IMPL-N",
   "title": "Descriptive task name",
   "status": "pending|active|completed|blocked",
-  "context_package_path": ".workflow/active/WFS-{session}/.process/context-package.json"
+  "context_package_path": ".workflow/active/WFS-{session}/.process/context-package.json",
+  "cli_execution_id": "WFS-{session}-IMPL-N",
+  "cli_execution": {
+    "strategy": "new|resume|fork|merge_fork",
+    "resume_from": "parent-cli-id",
+    "merge_from": ["id1", "id2"]
+  }
 }
 ```
 
 **Field Descriptions**:
-- `id`: Task identifier (format: `IMPL-N`)
+- `id`: Task identifier
+  - Single module format: `IMPL-N` (e.g., IMPL-001, IMPL-002)
+  - Multi-module format: `IMPL-{prefix}{seq}` (e.g., IMPL-A1, IMPL-B1, IMPL-C1)
+    - Prefix: A, B, C... (assigned by module detection order)
+    - Sequence: 1, 2, 3... (per-module increment)
 - `title`: Descriptive task name summarizing the work
 - `status`: Task state - `pending` (not started), `active` (in progress), `completed` (done), `blocked` (waiting on dependencies)
 - `context_package_path`: Path to smart context package containing project structure, dependencies, and brainstorming artifacts catalog
+- `cli_execution_id`: Unique CLI conversation ID (format: `{session_id}-{task_id}`)
+- `cli_execution`: CLI execution strategy based on task dependencies
+  - `strategy`: Execution pattern (`new`, `resume`, `fork`, `merge_fork`)
+  - `resume_from`: Parent task's cli_execution_id (for resume/fork)
+  - `merge_from`: Array of parent cli_execution_ids (for merge_fork)
+
+**CLI Execution Strategy Rules** (MANDATORY - apply to all tasks):
+
+| Dependency Pattern | Strategy | CLI Command Pattern |
+|--------------------|----------|---------------------|
+| No `depends_on` | `new` | `--id {cli_execution_id}` |
+| 1 parent, parent has 1 child | `resume` | `--resume {resume_from}` |
+| 1 parent, parent has N children | `fork` | `--resume {resume_from} --id {cli_execution_id}` |
+| N parents | `merge_fork` | `--resume {merge_from.join(',')} --id {cli_execution_id}` |
+
+**Strategy Selection Algorithm**:
+```javascript
+function computeCliStrategy(task, allTasks) {
+  const deps = task.context?.depends_on || []
+  const childCount = allTasks.filter(t =>
+    t.context?.depends_on?.includes(task.id)
+  ).length
+
+  if (deps.length === 0) {
+    return { strategy: "new" }
+  } else if (deps.length === 1) {
+    const parentTask = allTasks.find(t => t.id === deps[0])
+    const parentChildCount = allTasks.filter(t =>
+      t.context?.depends_on?.includes(deps[0])
+    ).length
+
+    if (parentChildCount === 1) {
+      return { strategy: "resume", resume_from: parentTask.cli_execution_id }
+    } else {
+      return { strategy: "fork", resume_from: parentTask.cli_execution_id }
+    }
+  } else {
+    const mergeFrom = deps.map(depId =>
+      allTasks.find(t => t.id === depId).cli_execution_id
+    )
+    return { strategy: "merge_fork", merge_from: mergeFrom }
+  }
+}
+```
 
 #### Meta Object
 
@@ -226,7 +285,14 @@ Generate individual `.task/IMPL-*.json` files with the following structure:
   "meta": {
     "type": "feature|bugfix|refactor|test-gen|test-fix|docs",
     "agent": "@code-developer|@action-planning-agent|@test-fix-agent|@universal-executor",
-    "execution_group": "parallel-abc123|null"
+    "execution_group": "parallel-abc123|null",
+    "module": "frontend|backend|shared|null",
+    "execution_config": {
+      "method": "agent|hybrid|cli",
+      "cli_tool": "codex|gemini|qwen|auto",
+      "enable_resume": true,
+      "previous_cli_id": "string|null"
+    }
   }
 }
 ```
@@ -235,6 +301,31 @@ Generate individual `.task/IMPL-*.json` files with the following structure:
 - `type`: Task category - `feature` (new functionality), `bugfix` (fix defects), `refactor` (restructure code), `test-gen` (generate tests), `test-fix` (fix failing tests), `docs` (documentation)
 - `agent`: Assigned agent for execution
 - `execution_group`: Parallelization group ID (tasks with same ID can run concurrently) or `null` for sequential tasks
+- `module`: Module identifier for multi-module projects (e.g., `frontend`, `backend`, `shared`) or `null` for single-module
+- `execution_config`: CLI execution settings (MUST align with userConfig from task-generate-agent)
+  - `method`: Execution method - `agent` (direct), `hybrid` (agent + CLI), `cli` (CLI only)
+  - `cli_tool`: Preferred CLI tool - `codex`, `gemini`, `qwen`, `auto`, or `null` (for agent-only)
+  - `enable_resume`: Whether to use `--resume` for CLI continuity (default: true)
+  - `previous_cli_id`: Previous task's CLI execution ID for resume (populated at runtime)
+
+**execution_config Alignment Rules** (MANDATORY):
+```
+userConfig.executionMethod → meta.execution_config
+
+"agent" →
+  meta.execution_config = { method: "agent", cli_tool: null, enable_resume: false }
+  Execution: Agent executes pre_analysis, then directly implements implementation_approach
+
+"cli" →
+  meta.execution_config = { method: "cli", cli_tool: userConfig.preferredCliTool, enable_resume: true }
+  Execution: Agent executes pre_analysis, then hands off context + implementation_approach to CLI
+
+"hybrid" →
+  meta.execution_config = { method: "hybrid", cli_tool: userConfig.preferredCliTool, enable_resume: true }
+  Execution: Agent decides which tasks to handoff to CLI based on complexity
+```
+
+**Note**: implementation_approach steps NO LONGER contain `command` fields. CLI execution is controlled by task-level `meta.execution_config` only.
 
 **Test Task Extensions** (for type="test-gen" or type="test-fix"):
 
@@ -244,8 +335,7 @@ Generate individual `.task/IMPL-*.json` files with the following structure:
     "type": "test-gen|test-fix",
     "agent": "@code-developer|@test-fix-agent",
     "test_framework": "jest|vitest|pytest|junit|mocha",
-    "coverage_target": "80%",
-    "use_codex": true|false
+    "coverage_target": "80%"
   }
 }
 ```
@@ -253,7 +343,8 @@ Generate individual `.task/IMPL-*.json` files with the following structure:
 **Test-Specific Fields**:
 - `test_framework`: Existing test framework from project (required for test tasks)
 - `coverage_target`: Target code coverage percentage (optional)
-- `use_codex`: Whether to use Codex for automated fixes in test-fix tasks (optional, default: false)
+
+**Note**: CLI tool usage for test-fix tasks is now controlled via `flow_control.implementation_approach` steps with `command` fields, not via `meta.use_codex`.
 
 #### Context Object
 
@@ -392,7 +483,7 @@ Generate individual `.task/IMPL-*.json` files with the following structure:
   // Pattern: Project structure analysis
   {
     "step": "analyze_project_architecture",
-    "commands": ["bash(~/.claude/scripts/get_modules_by_depth.sh)"],
+    "commands": ["bash(ccw tool exec get_modules_by_depth '{}')"],
     "output_to": "project_architecture"
   },
 
@@ -409,14 +500,14 @@ Generate individual `.task/IMPL-*.json` files with the following structure:
   // Pattern: Gemini CLI deep analysis
   {
     "step": "gemini_analyze_[aspect]",
-    "command": "bash(cd [path] && gemini -p 'PURPOSE: [goal]\\nTASK: [tasks]\\nMODE: analysis\\nCONTEXT: @[paths]\\nEXPECTED: [output]\\nRULES: $(cat [template]) | [constraints] | analysis=READ-ONLY')",
+    "command": "ccw cli -p 'PURPOSE: [goal]\\nTASK: [tasks]\\nMODE: analysis\\nCONTEXT: @[paths]\\nEXPECTED: [output]\\nRULES: $(cat [template]) | [constraints] | analysis=READ-ONLY' --tool gemini --mode analysis --cd [path]",
     "output_to": "analysis_result"
   },
 
   // Pattern: Qwen CLI analysis (fallback/alternative)
   {
     "step": "qwen_analyze_[aspect]",
-    "command": "bash(cd [path] && qwen -p '[similar to gemini pattern]')",
+    "command": "ccw cli -p '[similar to gemini pattern]' --tool qwen --mode analysis --cd [path]",
     "output_to": "analysis_result"
   },
 
@@ -457,7 +548,7 @@ The examples above demonstrate **patterns**, not fixed requirements. Agent MUST:
 4. **Command Composition Patterns**:
    - **Single command**: `bash([simple_search])`
    - **Multiple commands**: `["bash([cmd1])", "bash([cmd2])"]`
-   - **CLI analysis**: `bash(cd [path] && gemini -p '[prompt]')`
+   - **CLI analysis**: `ccw cli -p '[prompt]' --tool gemini --mode analysis --cd [path]`
    - **MCP integration**: `mcp__[tool]__[function]([params])`
 
 **Key Principle**: Examples show **structure patterns**, not specific implementations. Agent must create task-appropriate steps dynamically.
@@ -479,21 +570,38 @@ The `implementation_approach` supports **two execution modes** based on the pres
    - Specified command executes the step directly
    - Leverages specialized CLI tools (codex/gemini/qwen) for complex reasoning
    - **Use for**: Large-scale features, complex refactoring, or when user explicitly requests CLI tool usage
-   - **Required fields**: Same as default mode **PLUS** `command`
-   - **Command patterns**:
-     - `bash(codex -C [path] --full-auto exec '[prompt]' --skip-git-repo-check -s danger-full-access)`
-     - `bash(codex --full-auto exec '[task]' resume --last --skip-git-repo-check -s danger-full-access)` (multi-step)
-     - `bash(cd [path] && gemini -p '[prompt]' --approval-mode yolo)` (write mode)
+   - **Required fields**: Same as default mode **PLUS** `command`, `resume_from` (optional)
+   - **Command patterns** (with resume support):
+     - `ccw cli -p '[prompt]' --tool codex --mode write --cd [path]`
+     - `ccw cli -p '[prompt]' --resume ${previousCliId} --tool codex --mode write` (resume from previous)
+     - `ccw cli -p '[prompt]' --tool gemini --mode write --cd [path]` (write mode)
+   - **Resume mechanism**: When step depends on previous CLI execution, include `--resume` with previous execution ID
 
-**Mode Selection Strategy**:
-- **Default to agent execution** for most tasks
-- **Use CLI mode** when:
-  - User explicitly requests CLI tool (codex/gemini/qwen)
-  - Task requires multi-step autonomous reasoning beyond agent capability
-  - Complex refactoring needs specialized tool analysis
-  - Building on previous CLI execution context (use `resume --last`)
+**Semantic CLI Tool Selection**:
 
-**Key Principle**: The `command` field is **optional**. Agent must decide based on task complexity and user preference.
+Agent determines CLI tool usage per-step based on user semantics and task nature.
+
+**Source**: Scan `metadata.task_description` from context-package.json for CLI tool preferences.
+
+**User Semantic Triggers** (patterns to detect in task_description):
+- "use Codex/codex" → Add `command` field with Codex CLI
+- "use Gemini/gemini" → Add `command` field with Gemini CLI
+- "use Qwen/qwen" → Add `command` field with Qwen CLI
+- "CLI execution" / "automated" → Infer appropriate CLI tool
+
+**Task-Based Selection** (when no explicit user preference):
+- **Implementation/coding**: Codex preferred for autonomous development
+- **Analysis/exploration**: Gemini preferred for large context analysis
+- **Documentation**: Gemini/Qwen with write mode (`--mode write`)
+- **Testing**: Depends on complexity - simple=agent, complex=Codex
+
+**Default Behavior**: Agent always executes the workflow. CLI commands are embedded in `implementation_approach` steps:
+- Agent orchestrates task execution
+- When step has `command` field, agent executes it via CCW CLI
+- When step has no `command` field, agent implements directly
+- This maintains agent control while leveraging CLI tool power
+
+**Key Principle**: The `command` field is **optional**. Agent decides based on user semantics and task complexity.
 
 **Examples**:
 
@@ -538,17 +646,6 @@ The `implementation_approach` supports **two execution modes** based on the pres
     "output": "implementation"
   },
 
-  // === CLI MODE: Command Execution (optional command field) ===
-  {
-    "step": 3,
-    "title": "Execute implementation using CLI tool",
-    "description": "Use Codex/Gemini for complex autonomous execution",
-    "command": "bash(codex -C [path] --full-auto exec '[prompt]' --skip-git-repo-check -s danger-full-access)",
-    "modification_points": ["[Same as default mode]"],
-    "logic_flow": ["[Same as default mode]"],
-    "depends_on": [1, 2],
-    "output": "cli_implementation"
-  }
 ]
 ```
 
@@ -589,10 +686,42 @@ The `implementation_approach` supports **two execution modes** based on the pres
 - Analysis results (technical approach, architecture decisions)
 - Brainstorming artifacts (role analyses, guidance specifications)
 
+**Multi-Module Format** (when modules detected):
+
+When multiple modules are detected (frontend/backend, etc.), organize IMPL_PLAN.md by module:
+
+```markdown
+# Implementation Plan
+
+## Module A: Frontend (N tasks)
+### IMPL-A1: [Task Title]
+[Task details...]
+
+### IMPL-A2: [Task Title]
+[Task details...]
+
+## Module B: Backend (N tasks)
+### IMPL-B1: [Task Title]
+[Task details...]
+
+### IMPL-B2: [Task Title]
+[Task details...]
+
+## Cross-Module Dependencies
+- IMPL-A1 → IMPL-B1 (Frontend depends on Backend API)
+- IMPL-A2 → IMPL-B2 (UI state depends on Backend service)
+```
+
+**Cross-Module Dependency Notation**:
+- During parallel planning, use `CROSS::{module}::{pattern}` format
+- Example: `depends_on: ["CROSS::B::api-endpoint"]`
+- Integration phase resolves to actual task IDs: `CROSS::B::api → IMPL-B1`
+
 ### 2.3 TODO_LIST.md Structure
 
 Generate at `.workflow/active/{session_id}/TODO_LIST.md`:
 
+**Single Module Format**:
 ```markdown
 # Tasks: {Session Topic}
 
@@ -606,30 +735,56 @@ Generate at `.workflow/active/{session_id}/TODO_LIST.md`:
 - `- [x]` = Completed task
 ```
 
+**Multi-Module Format** (hierarchical by module):
+```markdown
+# Tasks: {Session Topic}
+
+## Module A (Frontend)
+- [ ] **IMPL-A1**: [Task Title] → [📋](./.task/IMPL-A1.json)
+- [ ] **IMPL-A2**: [Task Title] → [📋](./.task/IMPL-A2.json)
+
+## Module B (Backend)
+- [ ] **IMPL-B1**: [Task Title] → [📋](./.task/IMPL-B1.json)
+- [ ] **IMPL-B2**: [Task Title] → [📋](./.task/IMPL-B2.json)
+
+## Cross-Module Dependencies
+- IMPL-A1 → IMPL-B1 (Frontend depends on Backend API)
+
+## Status Legend
+- `- [ ]` = Pending task
+- `- [x]` = Completed task
+```
+
 **Linking Rules**:
 - Todo items → task JSON: `[📋](./.task/IMPL-XXX.json)`
 - Completed tasks → summaries: `[✅](./.summaries/IMPL-XXX-summary.md)`
-- Consistent ID schemes: IMPL-XXX
+- Consistent ID schemes: `IMPL-N` (single) or `IMPL-{prefix}{seq}` (multi-module)
 
-### 2.4 Complexity-Based Structure Selection
+### 2.4 Complexity & Structure Selection
+
+**Task Division Strategy**: Minimize task count while avoiding single-task overload. Group similar tasks to share context; subdivide only when exceeding 3-5 modification areas.
 
 Use `analysis_results.complexity` or task count to determine structure:
 
-**Simple Tasks** (≤5 tasks):
-- Flat structure: IMPL_PLAN.md + TODO_LIST.md + task JSONs
-- All tasks at same level
+**Single Module Mode**:
+- **Simple Tasks** (≤4 tasks): Flat structure
+- **Medium Tasks** (5-8 tasks): Flat structure
+- **Complex Tasks** (>8 tasks): Re-scope required (maximum 8 tasks hard limit)
 
-**Medium Tasks** (6-12 tasks):
-- Flat structure: IMPL_PLAN.md + TODO_LIST.md + task JSONs
-- All tasks at same level
+**Multi-Module Mode** (N+1 parallel planning):
+- **Per-module limit**: ≤6 tasks per module
+- **Total limit**: No total limit (each module independently capped at 6 tasks)
+- **Task ID format**: `IMPL-{prefix}{seq}` (e.g., IMPL-A1, IMPL-B1)
+- **Structure**: Hierarchical by module in IMPL_PLAN.md and TODO_LIST.md
 
-**Complex Tasks** (>12 tasks):
-- **Re-scope required**: Maximum 12 tasks hard limit
-- If analysis_results contains >12 tasks, consolidate or request re-scoping
+**Multi-Module Detection Triggers**:
+- Explicit frontend/backend separation (`src/frontend`, `src/backend`)
+- Monorepo structure (`packages/*`, `apps/*`)
+- Context-package dependency clustering (2+ distinct module groups)
 
 ---
 
-## 3. Quality & Standards
+## 3. Quality Standards
 
 ### 3.1 Quantification Requirements (MANDATORY)
 
@@ -655,53 +810,59 @@ Use `analysis_results.complexity` or task count to determine structure:
 - [ ] Each implementation step has its own acceptance criteria
 
 **Examples**:
-- ✅ GOOD: `"Implement 5 commands: [cmd1, cmd2, cmd3, cmd4, cmd5]"`
-- ❌ BAD: `"Implement new commands"`
-- ✅ GOOD: `"5 files created: verify by ls .claude/commands/*.md | wc -l = 5"`
-- ❌ BAD: `"All commands implemented successfully"`
+- GOOD: `"Implement 5 commands: [cmd1, cmd2, cmd3, cmd4, cmd5]"`
+- BAD: `"Implement new commands"`
+- GOOD: `"5 files created: verify by ls .claude/commands/*.md | wc -l = 5"`
+- BAD: `"All commands implemented successfully"`
 
-### 3.2 Planning Principles
+### 3.2 Planning & Organization Standards
 
+**Planning Principles**:
 - Each stage produces working, testable code
 - Clear success criteria for each deliverable
 - Dependencies clearly identified between stages
 - Incremental progress over big bangs
 
-### 3.3 File Organization
-
+**File Organization**:
 - Session naming: `WFS-[topic-slug]`
-- Task IDs: IMPL-XXX (flat structure only)
-- Directory structure: flat task organization
-
-### 3.4 Document Standards
+- Task IDs:
+  - Single module: `IMPL-N` (e.g., IMPL-001, IMPL-002)
+  - Multi-module: `IMPL-{prefix}{seq}` (e.g., IMPL-A1, IMPL-B1)
+- Directory structure: flat task organization (all tasks in `.task/`)
 
+**Document Standards**:
 - Proper linking between documents
 - Consistent navigation and references
 
----
-
-## 4. Key Reminders
+### 3.3 Guidelines Checklist
 
 **ALWAYS:**
-- **Apply Quantification Requirements**: All requirements, acceptance criteria, and modification points MUST include explicit counts and enumerations
-- **Load IMPL_PLAN template**: Read(~/.claude/workflows/cli-templates/prompts/workflow/impl-plan-template.txt) before generating IMPL_PLAN.md
-- **Use provided context package**: Extract all information from structured context
-- **Respect memory-first rule**: Use provided content (already loaded from memory/file)
-- **Follow 6-field schema**: All task JSONs must have id, title, status, context_package_path, meta, context, flow_control
-- **Map artifacts**: Use artifacts_inventory to populate task.context.artifacts array
-- **Add MCP integration**: Include MCP tool steps in flow_control.pre_analysis when capabilities available
-- **Validate task count**: Maximum 12 tasks hard limit, request re-scope if exceeded
-- **Use session paths**: Construct all paths using provided session_id
-- **Link documents properly**: Use correct linking format (📋 for JSON, ✅ for summaries)
-- **Run validation checklist**: Verify all quantification requirements before finalizing task JSONs
-- **Apply 举一反三 principle**: Adapt pre-analysis patterns to task-specific needs dynamically
-- **Follow template validation**: Complete IMPL_PLAN.md template validation checklist before finalization
+- **Load planning-notes.md FIRST**: Read planning-notes.md before context-package.json. Use its Consolidated Constraints as primary constraint source for all task generation
+- **Search Tool Priority**: ACE (`mcp__ace-tool__search_context`) → CCW (`mcp__ccw-tools__smart_search`) / Built-in (`Grep`, `Glob`, `Read`)
+- Apply Quantification Requirements to all requirements, acceptance criteria, and modification points
+- Load IMPL_PLAN template: `Read(~/.claude/workflows/cli-templates/prompts/workflow/impl-plan-template.txt)` before generating IMPL_PLAN.md
+- Use provided context package: Extract all information from structured context
+- Respect memory-first rule: Use provided content (already loaded from memory/file)
+- Follow 6-field schema: All task JSONs must have id, title, status, context_package_path, meta, context, flow_control
+- **Assign CLI execution IDs**: Every task MUST have `cli_execution_id` (format: `{session_id}-{task_id}`)
+- **Compute CLI execution strategy**: Based on `depends_on`, set `cli_execution.strategy` (new/resume/fork/merge_fork)
+- Map artifacts: Use artifacts_inventory to populate task.context.artifacts array
+- Add MCP integration: Include MCP tool steps in flow_control.pre_analysis when capabilities available
+- Validate task count: Maximum 8 tasks (single module) or 6 tasks per module (multi-module), request re-scope if exceeded
+- Use session paths: Construct all paths using provided session_id
+- Link documents properly: Use correct linking format (📋 for JSON, ✅ for summaries)
+- Run validation checklist: Verify all quantification requirements before finalizing task JSONs
+- Apply 举一反三 principle: Adapt pre-analysis patterns to task-specific needs dynamically
+- Follow template validation: Complete IMPL_PLAN.md template validation checklist before finalization
+
+**Bash Tool**:
+- Use `run_in_background=false` for all Bash/CLI calls to ensure foreground execution
 
 **NEVER:**
 - Load files directly (use provided context package instead)
 - Assume default locations (always use session_id in paths)
 - Create circular dependencies in task.depends_on
-- Exceed 12 tasks without re-scoping
+- Exceed 8 tasks (single module) or 6 tasks per module (multi-module) without re-scoping
 - Skip artifact integration when artifacts_inventory is provided
 - Ignore MCP capabilities when available
 - Use fixed pre-analysis steps without task-specific adaptation

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

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

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

@@ -61,13 +61,38 @@ Score = 0
 
 **Extract Keywords**: domains (auth, api, database, ui), technologies (react, typescript, node), actions (implement, refactor, test)
 
+**Plan Context Loading** (when executing from plan.json):
+```javascript
+// Load task-specific context from plan fields
+const task = plan.tasks.find(t => t.id === taskId)
+const context = {
+  // Base context
+  scope: task.scope,
+  modification_points: task.modification_points,
+  implementation: task.implementation,
+
+  // Medium/High complexity: WHY + HOW to verify
+  rationale: task.rationale?.chosen_approach,        // Why this approach
+  verification: task.verification?.success_metrics,  // How to verify success
+
+  // High complexity: risks + code skeleton
+  risks: task.risks?.map(r => r.mitigation),         // Risk mitigations to follow
+  code_skeleton: task.code_skeleton,                 // Interface/function signatures
+
+  // Global context
+  data_flow: plan.data_flow?.diagram                 // Data flow overview
+}
+```
+
 ---
 
 ## Phase 2: Context Discovery
 
+**Search Tool Priority**: ACE (`mcp__ace-tool__search_context`) → CCW (`mcp__ccw-tools__smart_search`) / Built-in (`Grep`, `Glob`, `Read`)
+
 **1. Project Structure**:
 ```bash
-~/.claude/scripts/get_modules_by_depth.sh
+ccw tool exec get_modules_by_depth '{}'
 ```
 
 **2. Content Search**:
@@ -100,7 +125,7 @@ CONTEXT: @**/*
 # Specific patterns
 CONTEXT: @CLAUDE.md @src/**/* @*.ts
 
-# Cross-directory (requires --include-directories)
+# Cross-directory (requires --includeDirs)
 CONTEXT: @**/* @../shared/**/* @../types/**/*
 ```
 
@@ -112,9 +137,10 @@ plan → planning/architecture-planning.txt | planning/task-breakdown.txt
 bug-fix → development/bug-diagnosis.txt
 ```
 
-**3. RULES Field**:
-- Use `$(cat ~/.claude/workflows/cli-templates/prompts/{path}.txt)` directly
-- NEVER escape: `\$`, `\"`, `\'` breaks command substitution
+**3. CONSTRAINTS Field**:
+- Use `--rule <template>` option to auto-load protocol + template (appended to prompt)
+- Template names: `category-function` format (e.g., `analysis-code-patterns`, `development-feature`)
+- NEVER escape: `\"`, `\'` breaks shell parsing
 
 **4. Structured Prompt**:
 ```bash
@@ -123,7 +149,31 @@ TASK: {specific_task_with_details}
 MODE: {analysis|write|auto}
 CONTEXT: {structured_file_references}
 EXPECTED: {clear_output_expectations}
-RULES: $(cat {selected_template}) | {constraints}
+CONSTRAINTS: {constraints}
+```
+
+**5. Plan-Aware Prompt Enhancement** (when executing from plan.json):
+```bash
+# Include rationale in PURPOSE (Medium/High)
+PURPOSE: {task.description}
+  Approach: {task.rationale.chosen_approach}
+  Decision factors: {task.rationale.decision_factors.join(', ')}
+
+# Include code skeleton in TASK (High)
+TASK: {task.implementation.join('\n')}
+  Key interfaces: {task.code_skeleton.interfaces.map(i => i.signature)}
+  Key functions: {task.code_skeleton.key_functions.map(f => f.signature)}
+
+# Include verification in EXPECTED
+EXPECTED: {task.acceptance.join(', ')}
+  Success metrics: {task.verification.success_metrics.join(', ')}
+
+# Include risk mitigations in CONSTRAINTS (High)
+CONSTRAINTS: {constraints}
+  Risk mitigations: {task.risks.map(r => r.mitigation).join('; ')}
+
+# Include data flow context (High)
+Memory: Data flow: {plan.data_flow.diagram}
 ```
 
 ---
@@ -134,7 +184,7 @@ RULES: $(cat {selected_template}) | {constraints}
 ```
 analyze|plan → gemini (qwen fallback) + mode=analysis
 execute (simple|medium) → gemini (qwen fallback) + mode=write
-execute (complex) → codex + mode=auto
+execute (complex) → codex + mode=write
 discuss → multi (gemini + codex parallel)
 ```
 
@@ -144,46 +194,45 @@ discuss → multi (gemini + codex parallel)
 - Codex: `gpt-5` (default), `gpt5-codex` (large context)
 - **Position**: `-m` after prompt, before flags
 
-### Command Templates
+### Command Templates (CCW Unified CLI)
 
 **Gemini/Qwen (Analysis)**:
 ```bash
-cd {dir} && gemini -p "
+ccw cli -p "
 PURPOSE: {goal}
 TASK: {task}
 MODE: analysis
 CONTEXT: @**/*
 EXPECTED: {output}
-RULES: $(cat ~/.claude/workflows/cli-templates/prompts/analysis/pattern.txt)
-" -m gemini-2.5-pro
+CONSTRAINTS: {constraints}
+" --tool gemini --mode analysis --rule analysis-code-patterns --cd {dir}
 
-# Qwen fallback: Replace 'gemini' with 'qwen'
+# Qwen fallback: Replace '--tool gemini' with '--tool qwen'
 ```
 
 **Gemini/Qwen (Write)**:
 ```bash
-cd {dir} && gemini -p "..." --approval-mode yolo
+ccw cli -p "..." --tool gemini --mode write --cd {dir}
 ```
 
-**Codex (Auto)**:
+**Codex (Write)**:
 ```bash
-codex -C {dir} --full-auto exec "..." --skip-git-repo-check -s danger-full-access
-
-# Resume: Add 'resume --last' after prompt
-codex --full-auto exec "..." resume --last --skip-git-repo-check -s danger-full-access
+ccw cli -p "..." --tool codex --mode write --cd {dir}
 ```
 
 **Cross-Directory** (Gemini/Qwen):
 ```bash
-cd src/auth && gemini -p "CONTEXT: @**/* @../shared/**/*" --include-directories ../shared
+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 `--include-directories` + explicit CONTEXT reference
+- 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
@@ -203,11 +252,25 @@ find .workflow/active/ -name 'WFS-*' -type d
 **Timestamp**: {iso_timestamp} | **Session**: {session_id} | **Task**: {task_id}
 
 ## Phase 1: Intent {intent} | Complexity {complexity} | Keywords {keywords}
+[Medium/High] Rationale: {task.rationale.chosen_approach}
+[High] Risks: {task.risks.map(r => `${r.description} → ${r.mitigation}`).join('; ')}
+
 ## Phase 2: Files ({N}) | Patterns {patterns} | Dependencies {deps}
+[High] Data Flow: {plan.data_flow.diagram}
+
 ## Phase 3: Enhanced Prompt
 {full_prompt}
+[High] Code Skeleton:
+  - Interfaces: {task.code_skeleton.interfaces.map(i => i.name).join(', ')}
+  - Functions: {task.code_skeleton.key_functions.map(f => f.signature).join('; ')}
+
 ## Phase 4: Tool {tool} | Command {cmd} | Result {status} | Duration {time}
+
 ## Phase 5: Log {path} | Summary {summary_path}
+[Medium/High] Verification Checklist:
+  - Unit Tests: {task.verification.unit_tests.join(', ')}
+  - Success Metrics: {task.verification.success_metrics.join(', ')}
+
 ## Next Steps: {actions}
 ```
 

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

@@ -67,7 +67,7 @@ Phase 4: Output Generation
 
 ```bash
 # Project structure
-~/.claude/scripts/get_modules_by_depth.sh
+ccw tool exec get_modules_by_depth '{}'
 
 # Pattern discovery (adapt based on language)
 rg "^export (class|interface|function) " --type ts -n
@@ -78,14 +78,14 @@ rg "^import .* from " -n | head -30
 ### Gemini Semantic Analysis (deep-scan, dependency-map)
 
 ```bash
-cd {dir} && gemini -p "
+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
@@ -165,7 +165,8 @@ Brief summary:
 ## Key Reminders
 
 **ALWAYS**:
-1. Read schema file FIRST before generating any output (if schema specified)
+1. **Search Tool Priority**: ACE (`mcp__ace-tool__search_context`) → CCW (`mcp__ccw-tools__smart_search`) / Built-in (`Grep`, `Glob`, `Read`)
+2. Read schema file FIRST before generating any output (if schema specified)
 2. Copy field names EXACTLY from schema (case-sensitive)
 3. Verify root structure matches schema (array vs object)
 4. Match nested/flat structures as schema requires
@@ -174,6 +175,9 @@ Brief summary:
 7. Include file:line references in findings
 8. Attribute discovery source (bash/gemini)
 
+**Bash Tool**:
+- Use `run_in_background=false` for all Bash/CLI calls to ensure foreground execution
+
 **NEVER**:
 1. Modify any files (read-only agent)
 2. Skip schema reading step when schema is specified

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

@@ -1,128 +1,162 @@
 ---
 name: cli-lite-planning-agent
 description: |
-  Specialized agent for executing CLI planning tools (Gemini/Qwen) to generate detailed implementation plans. Used by lite-plan workflow for Medium/High complexity tasks.
+  Generic planning agent for lite-plan and lite-fix workflows. Generates structured plan JSON based on provided schema reference.
 
   Core capabilities:
-  - Task decomposition (1-10 tasks with IDs: T1, T2...)
-  - Dependency analysis (depends_on references)
-  - Flow control (parallel/sequential phases)
-  - Multi-angle exploration context integration
+  - 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 specialized execution agent that bridges CLI planning tools (Gemini/Qwen) with lite-plan workflow. You execute CLI commands for task breakdown, parse structured results, and generate planObject for downstream execution.
+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.
 
-## Output Schema
+**CRITICAL**: After generating plan.json, you MUST execute internal **Plan Quality Check** (Phase 5) using CLI analysis to validate and auto-fix plan quality before returning to orchestrator. Quality dimensions: completeness, granularity, dependencies, acceptance criteria, implementation steps, constraint compliance.
 
-**Reference**: `~/.claude/workflows/cli-templates/schemas/plan-json-schema.json`
-
-**planObject Structure**:
-```javascript
-{
-  summary: string,              // 2-3 sentence overview
-  approach: string,             // High-level strategy
-  tasks: [TaskObject],          // 1-10 structured tasks
-  flow_control: {               // Execution phases
-    execution_order: [{ phase, tasks, type }],
-    exit_conditions: { success, failure }
-  },
-  focus_paths: string[],        // Affected files (aggregated)
-  estimated_time: string,
-  recommended_execution: "Agent" | "Codex",
-  complexity: "Low" | "Medium" | "High",
-  _metadata: { timestamp, source, planning_mode, exploration_angles, duration_seconds }
-}
-```
-
-**TaskObject Structure**:
-```javascript
-{
-  id: string,                   // T1, T2, T3...
-  title: string,                // Action verb + target
-  file: string,                 // Target file path
-  action: string,               // Create|Update|Implement|Refactor|Add|Delete|Configure|Test|Fix
-  description: string,          // What to implement (1-2 sentences)
-  modification_points: [{       // Precise changes (optional)
-    file: string,
-    target: string,             // function:lineRange
-    change: string
-  }],
-  implementation: string[],     // 2-7 actionable steps
-  reference: {                  // Pattern guidance (optional)
-    pattern: string,
-    files: string[],
-    examples: string
-  },
-  acceptance: string[],         // 1-4 quantified criteria
-  depends_on: string[]          // Task IDs: ["T1", "T2"]
-}
-```
 
 ## Input Context
 
 ```javascript
 {
-  task_description: string,
-  explorationsContext: { [angle]: ExplorationResult } | null,
-  explorationAngles: string[],
+  // 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",
-  cli_config: { tool, template, timeout, fallback },
-  session: { id, folder, artifacts }
+  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: CLI Execution
-├─ Aggregate multi-angle exploration findings
+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 2: Parsing & Enhancement
-├─ Parse CLI output sections (Summary, Approach, Tasks, Flow Control)
+Phase 3: Parsing & Enhancement
+├─ Parse CLI output sections
 ├─ Validate and enhance task objects
-└─ Infer missing fields from exploration context
+└─ Infer missing fields from context
 
-Phase 3: planObject Generation
-├─ Build planObject from parsed results
-├─ Generate flow_control from depends_on if not provided
-├─ Aggregate focus_paths from all tasks
-└─ Return to orchestrator (lite-plan)
+Phase 4: planObject Generation
+├─ Build planObject conforming to schema
+├─ Assign CLI execution IDs and strategies
+├─ Generate flow_control from depends_on
+└─ Write initial plan.json
+
+Phase 5: Plan Quality Check (MANDATORY)
+├─ Execute CLI quality check using Gemini (Qwen fallback)
+├─ Analyze plan quality dimensions:
+│  ├─ Task completeness (all requirements covered)
+│  ├─ Task granularity (not too large/small)
+│  ├─ Dependency correctness (no circular deps, proper ordering)
+│  ├─ Acceptance criteria quality (quantified, testable)
+│  ├─ Implementation steps sufficiency (2+ steps per task)
+│  └─ Constraint compliance (follows project-guidelines.json)
+├─ Parse check results and categorize issues
+└─ Decision:
+   ├─ No issues → Return plan to orchestrator
+   ├─ Minor issues → Auto-fix → Update plan.json → Return
+   └─ Critical issues → Report → Suggest regeneration
 ```
 
 ## CLI Command Template
 
+### Base Template (All Complexity Levels)
+
 ```bash
-cd {project_root} && {cli_tool} -p "
-PURPOSE: Generate implementation plan for {complexity} task
+ccw cli -p "
+PURPOSE: Generate plan for {task_description}
 TASK:
-• Analyze: {task_description}
-• Break down into 1-10 tasks with: id, title, file, action, description, modification_points, implementation, reference, acceptance, depends_on
-• Identify parallel vs sequential execution phases
+• 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: {exploration_summary}
+CONTEXT: @**/* | Memory: {context_summary}
 EXPECTED:
-## Implementation Summary
+## Summary
 [overview]
 
-## High-Level Approach
-[strategy]
+## Approach
+[high-level strategy]
+
+## Complexity: {Low|Medium|High}
 
 ## Task Breakdown
-### T1: [Title]
-**File**: [path]
+### 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: [name] - Files: [paths] - Examples: [guidance]
+**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]
@@ -130,11 +164,16 @@ EXPECTED:
 ## Time Estimate
 **Total**: [time]
 
-RULES: $(cat ~/.claude/workflows/cli-templates/prompts/planning/02-breakdown-task-steps.txt) |
-- Acceptance must be quantified (counts, method names, metrics)
-- Dependencies use task IDs (T1, T2)
+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
@@ -150,43 +189,80 @@ function extractSection(cliOutput, header) {
 }
 
 // Parse structured tasks from CLI output
-function extractStructuredTasks(cliOutput) {
+function extractStructuredTasks(cliOutput, complexity) {
   const tasks = []
-  const taskPattern = /### (T\d+): (.+?)\n\*\*File\*\*: (.+?)\n\*\*Action\*\*: (.+?)\n\*\*Description\*\*: (.+?)\n\*\*Modification Points\*\*:\n((?:- .+?\n)*)\*\*Implementation\*\*:\n((?:\d+\. .+?\n)+)\*\*Reference\*\*:\n((?:- .+?\n)+)\*\*Acceptance\*\*:\n((?:- .+?\n)+)\*\*Depends On\*\*: (.+)/g
+  // Split by task headers
+  const taskBlocks = cliOutput.split(/### (T\d+):/).slice(1)
+
+  for (let i = 0; i < taskBlocks.length; i += 2) {
+    const taskId = taskBlocks[i].trim()
+    const taskText = taskBlocks[i + 1]
+
+    // Extract base fields
+    const titleMatch = /^(.+?)(?=\n)/.exec(taskText)
+    const scopeMatch = /\*\*Scope\*\*: (.+?)(?=\n)/.exec(taskText)
+    const actionMatch = /\*\*Action\*\*: (.+?)(?=\n)/.exec(taskText)
+    const descMatch = /\*\*Description\*\*: (.+?)(?=\n)/.exec(taskText)
+    const depsMatch = /\*\*Depends On\*\*: (.+?)(?=\n|$)/.exec(taskText)
 
-  let match
-  while ((match = taskPattern.exec(cliOutput)) !== null) {
     // Parse modification points
-    const modPoints = match[6].trim().split('\n').filter(s => s.startsWith('-')).map(s => {
-      const m = /- \[(.+?)\]: \[(.+?)\] - (.+)/.exec(s)
-      return m ? { file: m[1], target: m[2], change: m[3] } : null
-    }).filter(Boolean)
-
-    // Parse reference
-    const refText = match[8].trim()
-    const reference = {
-      pattern: (/- Pattern: (.+)/m.exec(refText) || [])[1]?.trim() || "No pattern",
-      files: ((/- Files: (.+)/m.exec(refText) || [])[1] || "").split(',').map(f => f.trim()).filter(Boolean),
-      examples: (/- Examples: (.+)/m.exec(refText) || [])[1]?.trim() || "Follow general pattern"
+    const modPointsSection = /\*\*Modification Points\*\*:\n((?:- .+?\n)*)/.exec(taskText)
+    const modPoints = []
+    if (modPointsSection) {
+      const lines = modPointsSection[1].split('\n').filter(s => s.trim().startsWith('-'))
+      lines.forEach(line => {
+        const m = /- \[(.+?)\]: \[(.+?)\] - (.+)/.exec(line)
+        if (m) modPoints.push({ file: m[1].trim(), target: m[2].trim(), change: m[3].trim() })
+      })
     }
 
-    // Parse depends_on
-    const depsText = match[10].trim()
-    const depends_on = depsText === '[]' ? [] : depsText.replace(/[\[\]]/g, '').split(',').map(s => s.trim()).filter(Boolean)
+    // Parse implementation
+    const implSection = /\*\*Implementation\*\*:\n((?:\d+\. .+?\n)+)/.exec(taskText)
+    const implementation = implSection
+      ? implSection[1].split('\n').map(s => s.replace(/^\d+\. /, '').trim()).filter(Boolean)
+      : []
 
-    tasks.push({
-      id: match[1].trim(),
-      title: match[2].trim(),
-      file: match[3].trim(),
-      action: match[4].trim(),
-      description: match[5].trim(),
+    // Parse reference
+    const refSection = /\*\*Reference\*\*:\n((?:- .+?\n)+)/.exec(taskText)
+    const reference = refSection ? {
+      pattern: (/- Pattern: (.+)/m.exec(refSection[1]) || [])[1]?.trim() || "No pattern",
+      files: ((/- Files: (.+)/m.exec(refSection[1]) || [])[1] || "").split(',').map(f => f.trim()).filter(Boolean),
+      examples: (/- Examples: (.+)/m.exec(refSection[1]) || [])[1]?.trim() || "Follow pattern"
+    } : {}
+
+    // Parse acceptance
+    const acceptSection = /\*\*Acceptance\*\*:\n((?:- .+?\n)+)/.exec(taskText)
+    const acceptance = acceptSection
+      ? acceptSection[1].split('\n').map(s => s.replace(/^- /, '').trim()).filter(Boolean)
+      : []
+
+    const task = {
+      id: taskId,
+      title: titleMatch?.[1].trim() || "Untitled",
+      scope: scopeMatch?.[1].trim() || "",
+      action: actionMatch?.[1].trim() || "Implement",
+      description: descMatch?.[1].trim() || "",
       modification_points: modPoints,
-      implementation: match[7].trim().split('\n').map(s => s.replace(/^\d+\. /, '')).filter(Boolean),
+      implementation,
       reference,
-      acceptance: match[9].trim().split('\n').map(s => s.replace(/^- /, '')).filter(Boolean),
-      depends_on
-    })
+      acceptance,
+      depends_on: depsMatch?.[1] === '[]' ? [] : (depsMatch?.[1] || "").replace(/[\[\]]/g, '').split(',').map(s => s.trim()).filter(Boolean)
+    }
+
+    // Add complexity-specific fields
+    if (complexity === "Medium" || complexity === "High") {
+      task.rationale = extractRationale(taskText)
+      task.verification = extractVerification(taskText)
+    }
+
+    if (complexity === "High") {
+      task.risks = extractRisks(taskText)
+      task.code_skeleton = extractCodeSkeleton(taskText)
+    }
+
+    tasks.push(task)
   }
+
   return tasks
 }
 
@@ -209,14 +285,155 @@ function extractFlowControl(cliOutput) {
   }
 }
 
+// Parse rationale section for a task
+function extractRationale(taskText) {
+  const rationaleMatch = /\*\*Rationale\*\*:\n- Chosen Approach: (.+?)\n- Alternatives Considered: (.+?)\n- Decision Factors: (.+?)\n- Tradeoffs: (.+)/s.exec(taskText)
+  if (!rationaleMatch) return null
+
+  return {
+    chosen_approach: rationaleMatch[1].trim(),
+    alternatives_considered: rationaleMatch[2].split(',').map(s => s.trim()).filter(Boolean),
+    decision_factors: rationaleMatch[3].split(',').map(s => s.trim()).filter(Boolean),
+    tradeoffs: rationaleMatch[4].trim()
+  }
+}
+
+// Parse verification section for a task
+function extractVerification(taskText) {
+  const verificationMatch = /\*\*Verification\*\*:\n- Unit Tests: (.+?)\n- Integration Tests: (.+?)\n- Manual Checks: (.+?)\n- Success Metrics: (.+)/s.exec(taskText)
+  if (!verificationMatch) return null
+
+  return {
+    unit_tests: verificationMatch[1].split(',').map(s => s.trim()).filter(Boolean),
+    integration_tests: verificationMatch[2].split(',').map(s => s.trim()).filter(Boolean),
+    manual_checks: verificationMatch[3].split(',').map(s => s.trim()).filter(Boolean),
+    success_metrics: verificationMatch[4].split(',').map(s => s.trim()).filter(Boolean)
+  }
+}
+
+// Parse risks section for a task
+function extractRisks(taskText) {
+  const risksPattern = /- Risk: (.+?) \| Probability: ([LMH]) \| Impact: ([LMH]) \| Mitigation: (.+?)(?: \| Fallback: (.+?))?(?=\n|$)/g
+  const risks = []
+  let match
+
+  while ((match = risksPattern.exec(taskText)) !== null) {
+    risks.push({
+      description: match[1].trim(),
+      probability: match[2] === 'L' ? 'Low' : match[2] === 'M' ? 'Medium' : 'High',
+      impact: match[3] === 'L' ? 'Low' : match[3] === 'M' ? 'Medium' : 'High',
+      mitigation: match[4].trim(),
+      fallback: match[5]?.trim() || undefined
+    })
+  }
+
+  return risks.length > 0 ? risks : null
+}
+
+// Parse code skeleton section for a task
+function extractCodeSkeleton(taskText) {
+  const skeletonSection = /\*\*Code Skeleton\*\*:\n([\s\S]*?)(?=\n\*\*|$)/.exec(taskText)
+  if (!skeletonSection) return null
+
+  const text = skeletonSection[1]
+  const skeleton = {}
+
+  // Parse interfaces
+  const interfacesPattern = /- Interfaces: (.+?): (.+?) - (.+?)(?=\n|$)/g
+  const interfaces = []
+  let match
+  while ((match = interfacesPattern.exec(text)) !== null) {
+    interfaces.push({ name: match[1].trim(), definition: match[2].trim(), purpose: match[3].trim() })
+  }
+  if (interfaces.length > 0) skeleton.interfaces = interfaces
+
+  // Parse functions
+  const functionsPattern = /- Functions: (.+?) - (.+?) - returns (.+?)(?=\n|$)/g
+  const functions = []
+  while ((match = functionsPattern.exec(text)) !== null) {
+    functions.push({ signature: match[1].trim(), purpose: match[2].trim(), returns: match[3].trim() })
+  }
+  if (functions.length > 0) skeleton.key_functions = functions
+
+  // Parse classes
+  const classesPattern = /- Classes: (.+?) - (.+?) - methods: (.+?)(?=\n|$)/g
+  const classes = []
+  while ((match = classesPattern.exec(text)) !== null) {
+    classes.push({
+      name: match[1].trim(),
+      purpose: match[2].trim(),
+      methods: match[3].split(',').map(s => s.trim()).filter(Boolean)
+    })
+  }
+  if (classes.length > 0) skeleton.classes = classes
+
+  return Object.keys(skeleton).length > 0 ? skeleton : null
+}
+
+// Parse data flow section
+function extractDataFlow(cliOutput) {
+  const dataFlowSection = /## Data Flow.*?\n([\s\S]*?)(?=\n## |$)/.exec(cliOutput)
+  if (!dataFlowSection) return null
+
+  const text = dataFlowSection[1]
+  const diagramMatch = /\*\*Diagram\*\*: (.+?)(?=\n|$)/.exec(text)
+  const depsMatch = /\*\*Dependencies\*\*: (.+?)(?=\n|$)/.exec(text)
+
+  // Parse stages
+  const stagesPattern = /- Stage (.+?): Input=(.+?) → Output=(.+?) \| Component=(.+?)(?: \| Transforms=(.+?))?(?=\n|$)/g
+  const stages = []
+  let match
+  while ((match = stagesPattern.exec(text)) !== null) {
+    stages.push({
+      stage: match[1].trim(),
+      input: match[2].trim(),
+      output: match[3].trim(),
+      component: match[4].trim(),
+      transformations: match[5] ? match[5].split(',').map(s => s.trim()).filter(Boolean) : undefined
+    })
+  }
+
+  return {
+    diagram: diagramMatch?.[1].trim() || null,
+    stages: stages.length > 0 ? stages : undefined,
+    dependencies: depsMatch ? depsMatch[1].split(',').map(s => s.trim()).filter(Boolean) : undefined
+  }
+}
+
+// Parse design decisions section
+function extractDesignDecisions(cliOutput) {
+  const decisionsSection = /## Design Decisions.*?\n([\s\S]*?)(?=\n## |$)/.exec(cliOutput)
+  if (!decisionsSection) return null
+
+  const decisionsPattern = /- Decision: (.+?) \| Rationale: (.+?)(?: \| Tradeoff: (.+?))?(?=\n|$)/g
+  const decisions = []
+  let match
+
+  while ((match = decisionsPattern.exec(decisionsSection[1])) !== null) {
+    decisions.push({
+      decision: match[1].trim(),
+      rationale: match[2].trim(),
+      tradeoff: match[3]?.trim() || undefined
+    })
+  }
+
+  return decisions.length > 0 ? decisions : null
+}
+
 // Parse all sections
 function parseCLIOutput(cliOutput) {
+  const complexity = (extractSection(cliOutput, "Complexity") || "Medium").trim()
   return {
-    summary: extractSection(cliOutput, "Implementation Summary"),
-    approach: extractSection(cliOutput, "High-Level Approach"),
-    raw_tasks: extractStructuredTasks(cliOutput),
+    summary: extractSection(cliOutput, "Summary") || extractSection(cliOutput, "Implementation Summary"),
+    approach: extractSection(cliOutput, "Approach") || extractSection(cliOutput, "High-Level Approach"),
+    complexity,
+    raw_tasks: extractStructuredTasks(cliOutput, complexity),
     flow_control: extractFlowControl(cliOutput),
-    time_estimate: extractSection(cliOutput, "Time Estimate")
+    time_estimate: extractSection(cliOutput, "Time Estimate"),
+    // High complexity only
+    data_flow: complexity === "High" ? extractDataFlow(cliOutput) : null,
+    // Medium/High complexity
+    design_decisions: (complexity === "Medium" || complexity === "High") ? extractDesignDecisions(cliOutput) : null
   }
 }
 ```
@@ -279,6 +496,51 @@ function inferFile(task, ctx) {
 }
 ```
 
+### 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
@@ -303,22 +565,108 @@ function inferFlowControl(tasks) {
 ### planObject Generation
 
 ```javascript
-function generatePlanObject(parsed, enrichedContext, input) {
-  const tasks = validateAndEnhanceTasks(parsed.raw_tasks, enrichedContext)
+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.modification_points.map(m => m.file)]).filter(Boolean))]
+  const focus_paths = [...new Set(tasks.flatMap(t => [t.file || t.scope, ...t.modification_points.map(m => m.file)]).filter(Boolean))]
 
-  return {
-    summary: parsed.summary || `Implementation plan for: ${input.task_description.slice(0, 100)}`,
-    approach: parsed.approach || "Step-by-step implementation",
+  // 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: input.complexity === "Low" ? "Agent" : "Codex",
-    complexity: input.complexity,
-    _metadata: { timestamp: new Date().toISOString(), source: "cli-lite-planning-agent", planning_mode: "agent-based", exploration_angles: input.explorationAngles || [], duration_seconds: Math.round((Date.now() - startTime) / 1000) }
+    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
+  })
 }
 ```
 
@@ -383,14 +731,98 @@ function validateTask(task) {
 ## Key Reminders
 
 **ALWAYS**:
-- Generate task IDs (T1, T2, T3...)
+- **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 [])
-- Quantify acceptance criteria
+- **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**
+- **Skip Phase 5 Plan Quality Check**
+
+---
+
+## Phase 5: Plan Quality Check (MANDATORY)
+
+### Overview
+
+After generating plan.json, **MUST** execute CLI quality check before returning to orchestrator. This is a mandatory step for ALL plans regardless of complexity.
+
+### Quality Dimensions
+
+| Dimension | Check Criteria | Critical? |
+|-----------|---------------|-----------|
+| **Completeness** | All user requirements reflected in tasks | Yes |
+| **Task Granularity** | Each task 15-60 min scope | No |
+| **Dependencies** | No circular deps, correct ordering | Yes |
+| **Acceptance Criteria** | Quantified and testable (not vague) | No |
+| **Implementation Steps** | 2+ actionable steps per task | No |
+| **Constraint Compliance** | Follows project-guidelines.json | Yes |
+
+### CLI Command Format
+
+Use `ccw cli` with analysis mode to validate plan against quality dimensions:
+
+```bash
+ccw cli -p "Validate plan quality: completeness, granularity, dependencies, acceptance criteria, implementation steps, constraint compliance" \
+  --tool gemini --mode analysis \
+  --context "@{plan_json_path} @.workflow/project-guidelines.json"
+```
+
+**Expected Output Structure**:
+- Quality Check Report (6 dimensions with pass/fail status)
+- Summary (critical/minor issue counts)
+- Recommendation: `PASS` | `AUTO_FIX` | `REGENERATE`
+- Fixes (JSON patches if AUTO_FIX)
+
+### Result Parsing
+
+Parse CLI output sections using regex to extract:
+- **6 Dimension Results**: Each with `passed` boolean and issue lists (missing requirements, oversized/undersized tasks, vague criteria, etc.)
+- **Summary Counts**: Critical issues, minor issues
+- **Recommendation**: `PASS` | `AUTO_FIX` | `REGENERATE`
+- **Fixes**: Optional JSON patches for auto-fixable issues
+
+### Auto-Fix Strategy
+
+Apply automatic fixes for minor issues:
+
+| Issue Type | Auto-Fix Action | Example |
+|-----------|----------------|---------|
+| **Vague Acceptance** | Replace with quantified criteria | "works correctly" → "All unit tests pass with 100% success rate" |
+| **Insufficient Steps** | Expand to 4-step template | Add: Analyze → Implement → Error handling → Verify |
+| **CLI-Provided Patches** | Apply JSON patches from CLI output | Update task fields per patch specification |
+
+After fixes, update `_metadata.quality_check` with fix log.
+
+### Execution Flow
+
+After Phase 4 planObject generation:
+
+1. **Write Initial Plan** → `${sessionFolder}/plan.json`
+2. **Execute CLI Check** → Gemini (Qwen fallback)
+3. **Parse Results** → Extract recommendation and issues
+4. **Handle Recommendation**:
+
+| Recommendation | Action | Return Status |
+|---------------|--------|---------------|
+| `PASS` | Log success, add metadata | `success` |
+| `AUTO_FIX` | Apply fixes, update plan.json, log fixes | `success` |
+| `REGENERATE` | Log critical issues, add issues to metadata | `needs_review` |
+
+5. **Return** → Plan with `_metadata.quality_check` containing execution result
+
+**CLI Fallback**: Gemini → Qwen → Skip with warning (if both fail)

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

@@ -66,8 +66,7 @@ You are a specialized execution agent that bridges CLI analysis tools with task
   "task_config": {
     "agent": "@test-fix-agent",
     "type": "test-fix-iteration",
-    "max_iterations": 5,
-    "use_codex": false
+    "max_iterations": 5
   }
 }
 ```
@@ -108,7 +107,7 @@ Phase 3: Task JSON Generation
 
 **Template-Based Command Construction with Test Layer Awareness**:
 ```bash
-cd {project_root} && {cli_tool} -p "
+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}]
@@ -128,14 +127,14 @@ EXPECTED: Structured fix strategy with:
 - Fix approach ensuring business logic correctness (not just test passage)
 - Expected outcome and verification steps
 - Impact assessment: Will this fix potentially mask other issues?
-RULES: $(cat ~/.claude/workflows/cli-templates/prompts/{template}) |
+CONSTRAINTS:
 - For {test_type} tests: {layer_specific_guidance}
 - Avoid 'surgical fixes' that mask underlying issues
 - Provide specific line numbers for modifications
 - Consider previous iteration failures
 - Validate fix doesn't introduce new vulnerabilities
 - analysis=READ-ONLY
-" {timeout_flag}
+" --tool {cli_tool} --mode analysis --rule {template} --cd {project_root} --timeout {timeout_value}
 ```
 
 **Layer-Specific Guidance Injection**:
@@ -263,7 +262,6 @@ function extractModificationPoints() {
     "analysis_report": ".process/iteration-{iteration}-analysis.md",
     "cli_output": ".process/iteration-{iteration}-cli-output.txt",
     "max_iterations": "{task_config.max_iterations}",
-    "use_codex": "{task_config.use_codex}",
     "parent_task": "{parent_task_id}",
     "created_by": "@cli-planning-agent",
     "created_at": "{timestamp}"
@@ -438,6 +436,7 @@ See: `.process/iteration-{iteration}-cli-output.txt`
 ## Key Reminders
 
 **ALWAYS:**
+- **Search Tool Priority**: ACE (`mcp__ace-tool__search_context`) → CCW (`mcp__ccw-tools__smart_search`) / Built-in (`Grep`, `Glob`, `Read`)
 - **Validate context package**: Ensure all required fields present before CLI execution
 - **Handle CLI errors gracefully**: Use fallback chain (Gemini → Qwen → degraded mode)
 - **Parse CLI output structurally**: Extract specific sections (RCA, 修复建议, 验证建议)
@@ -448,6 +447,9 @@ See: `.process/iteration-{iteration}-cli-output.txt`
 - **Generate measurable acceptance criteria**: Include verification commands
 - **Apply layer-specific guidance**: Use test_type to customize analysis approach
 
+**Bash Tool**:
+- Use `run_in_background=false` for all Bash/CLI calls to ensure foreground execution
+
 **NEVER:**
 - Execute tests directly (orchestrator manages test execution)
 - Skip CLI analysis (always run CLI even for simple failures)
@@ -529,9 +531,9 @@ See: `.process/iteration-{iteration}-cli-output.txt`
 1. **Detect test_type**: "integration" → Apply integration-specific diagnosis
 2. **Execute CLI**:
    ```bash
-   gemini -p "PURPOSE: Analyze integration test failure...
+   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"
+   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):

.claude/agents/code-developer.md

@@ -24,8 +24,6 @@ You are a code execution specialist focused on implementing high-quality, produc
 - **Context-driven** - Use provided context and existing code patterns
 - **Quality over speed** - Write boring, reliable code that works
 
-
-
 ## Execution Process
 
 ### 1. Context Assessment
@@ -36,17 +34,50 @@ You are a code execution specialist focused on implementing high-quality, produc
 - **context-package.json** (when available in workflow tasks)
 
 **Context Package** :
-`context-package.json` provides artifact paths - extract dynamically using `jq`:
+`context-package.json` provides artifact paths - read using Read tool or ccw session:
 ```bash
-# Get role analysis paths from context package
-jq -r '.brainstorm_artifacts.role_analyses[].files[].path' context-package.json
+# 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.
 ```
 
+**Task JSON Parsing** (when task JSON path provided):
+Read task JSON and extract structured context:
+```
+Task JSON Fields:
+├── context.requirements[]     → What to implement (list of requirements)
+├── context.acceptance[]       → How to verify (validation commands)
+├── context.focus_paths[]      → Where to focus (directories/files)
+├── context.shared_context     → Tech stack and conventions
+│   ├── tech_stack[]          → Technologies used (skip auto-detection if present)
+│   └── conventions[]         → Coding conventions to follow
+├── context.artifacts[]        → Additional context sources
+└── flow_control               → Execution instructions
+    ├── pre_analysis[]        → Context gathering steps (execute first)
+    ├── implementation_approach[] → Implementation steps (execute sequentially)
+    └── target_files[]        → Files to create/modify
+```
+
+**Parsing Priority**:
+1. Read task JSON from provided path
+2. Extract `context.requirements` as implementation goals
+3. Extract `context.acceptance` as verification criteria
+4. If `context.shared_context.tech_stack` exists → skip auto-detection, use provided stack
+5. Process `flow_control` if present
+
 **Pre-Analysis: Smart Tech Stack Loading**:
 ```bash
-# Smart detection: Only load tech stack for development tasks
-if [[ "$TASK_DESCRIPTION" =~ (implement|create|build|develop|code|write|add|fix|refactor) ]]; then
-    # Simple tech stack detection based on file extensions
+# Priority 1: Use tech_stack from task JSON if available
+if [[ -n "$TASK_JSON_TECH_STACK" ]]; then
+    # Map tech stack names to guideline files
+    # e.g., ["FastAPI", "SQLAlchemy"] → python-dev.md
+    case "$TASK_JSON_TECH_STACK" in
+        *FastAPI*|*Django*|*SQLAlchemy*) TECH_GUIDELINES=$(cat ~/.claude/workflows/cli-templates/tech-stacks/python-dev.md) ;;
+        *React*|*Next*) TECH_GUIDELINES=$(cat ~/.claude/workflows/cli-templates/tech-stacks/react-dev.md) ;;
+        *TypeScript*) TECH_GUIDELINES=$(cat ~/.claude/workflows/cli-templates/tech-stacks/typescript-dev.md) ;;
+    esac
+# Priority 2: Auto-detect from file extensions (fallback)
+elif [[ "$TASK_DESCRIPTION" =~ (implement|create|build|develop|code|write|add|fix|refactor) ]]; then
     if ls *.ts *.tsx 2>/dev/null | head -1; then
         TECH_GUIDELINES=$(cat ~/.claude/workflows/cli-templates/tech-stacks/typescript-dev.md)
     elif grep -q "react" package.json 2>/dev/null; then
@@ -65,28 +96,65 @@ fi
 
 **Context Evaluation**:
 ```
-IF task is development-related (implement|create|build|develop|code|write|add|fix|refactor):
-    → Execute smart tech stack detection and load guidelines into [tech_guidelines] variable
-    → All subsequent development must follow loaded tech stack principles
-ELSE:
-    → Skip tech stack loading for non-development tasks
+STEP 1: Parse Task JSON (if path provided)
+    → Read task JSON file from provided path
+    → Extract and store in memory:
+      • [requirements] ← context.requirements[]
+      • [acceptance_criteria] ← context.acceptance[]
+      • [tech_stack] ← context.shared_context.tech_stack[] (skip auto-detection if present)
+      • [conventions] ← context.shared_context.conventions[]
+      • [focus_paths] ← context.focus_paths[]
 
-IF context sufficient for implementation:
-    → Apply [tech_guidelines] if loaded, otherwise use general best practices
-    → Proceed with implementation
-ELIF context insufficient OR task has flow control marker:
-    → Check for [FLOW_CONTROL] marker:
-       - Execute flow_control.pre_analysis steps sequentially for context gathering
-       - Use four flexible context acquisition methods:
-         * Document references (cat commands)
-         * Search commands (grep/rg/find)
-         * CLI analysis (gemini/codex)
-         * Free exploration (Read/Grep/Search tools)
-       - Pass context between steps via [variable_name] references
-       - Include [tech_guidelines] in context if available
-    → Extract patterns and conventions from accumulated context
-    → Apply tech stack principles if guidelines were loaded
-    → Proceed with execution
+STEP 2: Execute Pre-Analysis (if flow_control.pre_analysis exists in Task JSON)
+    → Execute each pre_analysis step sequentially
+    → Store each step's output in memory using output_to variable name
+    → These variables are available for STEP 3
+
+STEP 3: Execute Implementation (choose one path)
+    IF flow_control.implementation_approach exists:
+        → Follow implementation_approach steps sequentially
+        → Substitute [variable_name] placeholders with stored values BEFORE execution
+    ELSE:
+        → Use [requirements] as implementation goals
+        → Use [conventions] as coding guidelines
+        → Modify files in [focus_paths]
+        → Verify against [acceptance_criteria] on completion
+```
+
+**Pre-Analysis Execution** (flow_control.pre_analysis):
+```
+For each step in pre_analysis[]:
+  step.step      → Step identifier (string name)
+  step.action    → Description of what to do
+  step.commands  → Array of commands to execute (see Command-to-Tool Mapping)
+  step.output_to → Variable name to store results in memory
+  step.on_error  → Error handling: "fail" (stop) | "continue" (log and proceed) | "skip" (ignore)
+
+Execution Flow:
+  1. For each step in order:
+  2.   For each command in step.commands[]:
+  3.     Parse command format → Map to actual tool
+  4.     Execute tool → Capture output
+  5.   Concatenate all outputs → Store in [step.output_to] variable
+  6. Continue to next step (or handle error per on_error)
+```
+
+**Command-to-Tool Mapping** (explicit tool bindings):
+```
+Command Format          → Actual Tool Call
+─────────────────────────────────────────────────────
+"Read(path)"            → Read tool: Read(file_path=path)
+"bash(command)"         → Bash tool: Bash(command=command)
+"Search(pattern,path)"  → Grep tool: Grep(pattern=pattern, path=path)
+"Glob(pattern)"         → Glob tool: Glob(pattern=pattern)
+"mcp__xxx__yyy(args)"   → MCP tool: mcp__xxx__yyy(args)
+
+Example Parsing:
+  "Read(backend/app/models/simulation.py)"
+  → Tool: Read
+  → Parameter: file_path = "backend/app/models/simulation.py"
+  → Execute: Read(file_path="backend/app/models/simulation.py")
+  → Store output in [output_to] variable
 ```
 ### Module Verification Guidelines
 
@@ -103,29 +171,165 @@ ELIF context insufficient OR task has flow control marker:
 
 **Implementation Approach Execution**:
 When task JSON contains `flow_control.implementation_approach` array:
-1. **Sequential Processing**: Execute steps in order, respecting `depends_on` dependencies
-2. **Dependency Resolution**: Wait for all steps listed in `depends_on` before starting
-3. **Variable Substitution**: Use `[variable_name]` to reference outputs from previous steps
-4. **Step Structure**:
-   - `step`: Unique identifier (1, 2, 3...)
-   - `title`: Step title
-   - `description`: Detailed description with variable references
-   - `modification_points`: Code modification targets
-   - `logic_flow`: Business logic sequence
-   - `command`: Optional CLI command (only when explicitly specified)
-   - `depends_on`: Array of step numbers that must complete first
-   - `output`: Variable name for this step's output
-5. **Execution Rules**:
-   - Execute step 1 first (typically has `depends_on: []`)
-   - For each subsequent step, verify all `depends_on` steps completed
-   - Substitute `[variable_name]` with actual outputs from previous steps
-   - Store this step's result in the `output` variable for future steps
-   - If `command` field present, execute it; otherwise use agent capabilities
 
-**CLI Command Execution (CLI Execute Mode)**:
-When step contains `command` field with Codex CLI, execute via Bash tool. For Codex resume:
-- First task (`depends_on: []`): `codex -C [path] --full-auto exec "..." --skip-git-repo-check -s danger-full-access`
-- Subsequent tasks (has `depends_on`): Add `resume --last` flag to maintain session context
+**Step Structure**:
+```
+step                 → Unique identifier (1, 2, 3...)
+title                → Step title for logging
+description          → What to implement (may contain [variable_name] placeholders)
+modification_points  → Specific code changes required (files to create/modify)
+logic_flow           → Business logic sequence to implement
+command              → (Optional) CLI command to execute
+depends_on           → Array of step numbers that must complete first
+output               → Variable name to store this step's result
+```
+
+**Execution Flow**:
+```
+// Read task-level execution config (Single Source of Truth)
+const executionMethod = task.meta?.execution_config?.method || 'agent';
+const cliTool = task.meta?.execution_config?.cli_tool || getDefaultCliTool();  // See ~/.claude/cli-tools.json
+
+// Phase 1: Execute pre_analysis (always by Agent)
+const preAnalysisResults = {};
+for (const step of task.flow_control.pre_analysis || []) {
+  const result = executePreAnalysisStep(step);
+  preAnalysisResults[step.output_to] = result;
+}
+
+// Phase 2: Determine execution mode
+const hasLegacyCommands = task.flow_control.implementation_approach
+  .some(step => step.command);
+
+IF hasLegacyCommands:
+  // Backward compatibility: Old mode with step.command fields
+  FOR each step in implementation_approach[]:
+    IF step.command exists:
+      → Execute via Bash: Bash({ command: step.command, timeout: 3600000 })
+    ELSE:
+      → Agent direct implementation
+
+ELSE IF executionMethod === 'cli':
+  // New mode: CLI Handoff
+  → const cliPrompt = buildCliHandoffPrompt(preAnalysisResults, task)
+  → const cliCommand = buildCliCommand(task, cliTool, cliPrompt)
+  → Bash({ command: cliCommand, run_in_background: false, timeout: 3600000 })
+
+ELSE IF executionMethod === 'hybrid':
+  // Hybrid mode: Agent decides based on task complexity
+  → IF task is complex (multiple files, complex logic):
+      Use CLI Handoff (same as cli mode)
+    ELSE:
+      Use Agent direct implementation
+
+ELSE (executionMethod === 'agent'):
+  // Default: Agent direct implementation
+  FOR each step in implementation_approach[]:
+    1. Variable Substitution: Replace [variable_name] with preAnalysisResults
+    2. Read modification_points[] as files to create/modify
+    3. Read logic_flow[] as implementation sequence
+    4. For each file in modification_points:
+       • If "Create new file: path" → Use Write tool
+       • If "Modify file: path" → Use Edit tool
+       • If "Add to file: path" → Use Edit tool (append)
+    5. Follow logic_flow sequence
+    6. Use [focus_paths] from context as working directory scope
+    7. Store result in [step.output] variable
+```
+
+**CLI Handoff Functions**:
+
+```javascript
+// Get default CLI tool from cli-tools.json
+function getDefaultCliTool() {
+  // Read ~/.claude/cli-tools.json and return first enabled tool
+  // Fallback order: gemini → qwen → codex (first enabled in config)
+  return firstEnabledTool || 'gemini';  // System default fallback
+}
+
+// Build CLI prompt from pre-analysis results and task
+function buildCliHandoffPrompt(preAnalysisResults, task) {
+  const contextSection = Object.entries(preAnalysisResults)
+    .map(([key, value]) => `### ${key}\n${value}`)
+    .join('\n\n');
+
+  const approachSection = task.flow_control.implementation_approach
+    .map((step, i) => `
+### Step ${step.step}: ${step.title}
+${step.description}
+
+**Modification Points**:
+${step.modification_points?.map(m => `- ${m}`).join('\n') || 'N/A'}
+
+**Logic Flow**:
+${step.logic_flow?.map((l, j) => `${j + 1}. ${l}`).join('\n') || 'Follow modification points'}
+`).join('\n');
+
+  return `
+PURPOSE: ${task.title}
+Complete implementation based on pre-analyzed context.
+
+## PRE-ANALYSIS CONTEXT
+${contextSection}
+
+## REQUIREMENTS
+${task.context.requirements?.map(r => `- ${r}`).join('\n') || task.context.requirements}
+
+## IMPLEMENTATION APPROACH
+${approachSection}
+
+## ACCEPTANCE CRITERIA
+${task.context.acceptance?.map(a => `- ${a}`).join('\n') || task.context.acceptance}
+
+## TARGET FILES
+${task.flow_control.target_files?.map(f => `- ${f}`).join('\n') || 'See modification points above'}
+
+MODE: write
+CONSTRAINTS: Follow existing patterns | No breaking changes
+`.trim();
+}
+
+// Build CLI command with resume strategy
+function buildCliCommand(task, cliTool, cliPrompt) {
+  const cli = task.cli_execution || {};
+  const escapedPrompt = cliPrompt.replace(/"/g, '\\"');
+  const baseCmd = `ccw cli -p "${escapedPrompt}"`;
+
+  switch (cli.strategy) {
+    case 'new':
+      return `${baseCmd} --tool ${cliTool} --mode write --id ${task.cli_execution_id}`;
+    case 'resume':
+      return `${baseCmd} --resume ${cli.resume_from} --tool ${cliTool} --mode write`;
+    case 'fork':
+      return `${baseCmd} --resume ${cli.resume_from} --id ${task.cli_execution_id} --tool ${cliTool} --mode write`;
+    case 'merge_fork':
+      return `${baseCmd} --resume ${cli.merge_from.join(',')} --id ${task.cli_execution_id} --tool ${cliTool} --mode write`;
+    default:
+      // Fallback: no resume, no id
+      return `${baseCmd} --tool ${cliTool} --mode write`;
+  }
+}
+```
+
+**Execution Config Reference** (from task.meta.execution_config):
+| Field | Values | Description |
+|-------|--------|-------------|
+| `method` | `agent` / `cli` / `hybrid` | Execution mode (default: agent) |
+| `cli_tool` | See `~/.claude/cli-tools.json` | CLI tool preference (first enabled tool as default) |
+| `enable_resume` | `true` / `false` | Enable CLI session resume |
+
+**CLI Execution Reference** (from task.cli_execution):
+| Field | Values | Description |
+|-------|--------|-------------|
+| `strategy` | `new` / `resume` / `fork` / `merge_fork` | Resume strategy |
+| `resume_from` | `{session}-{task_id}` | Parent task CLI ID (resume/fork) |
+| `merge_from` | `[{id1}, {id2}]` | Parent task CLI IDs (merge_fork) |
+
+**Resume Strategy Examples**:
+- **New task** (no dependencies): `--id WFS-001-IMPL-001`
+- **Resume** (single dependency, single child): `--resume WFS-001-IMPL-001`
+- **Fork** (single dependency, multiple children): `--resume WFS-001-IMPL-001 --id WFS-001-IMPL-002`
+- **Merge** (multiple dependencies): `--resume WFS-001-IMPL-001,WFS-001-IMPL-002 --id WFS-001-IMPL-003`
 
 **Test-Driven Development**:
 - Write tests first (red → green → refactor)
@@ -297,7 +501,16 @@ Before completing any task, verify:
 - Make assumptions - verify with existing code
 - Create unnecessary complexity
 
+**Bash Tool (CLI Execution in Agent)**:
+- Use `run_in_background=false` for all Bash/CLI calls - agent cannot receive task hook callbacks
+- Set timeout ≥60 minutes for CLI commands (hooks don't propagate to subagents):
+  ```javascript
+  Bash(command="ccw cli -p '...' --tool <cli-tool> --mode write", timeout=3600000)  // 60 min
+  // <cli-tool>: First enabled tool from ~/.claude/cli-tools.json (e.g., gemini, qwen, codex)
+  ```
+
 **ALWAYS:**
+- **Search Tool Priority**: ACE (`mcp__ace-tool__search_context`) → CCW (`mcp__ccw-tools__smart_search`) / Built-in (`Grep`, `Glob`, `Read`)
 - Verify module/package existence with rg/grep/search before referencing
 - Write working code incrementally
 - Test your implementation thoroughly

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

@@ -27,6 +27,8 @@ You are a conceptual planning specialist focused on **dedicated single-role** st
 
 ## Core Responsibilities
 
+**Search Tool Priority**: ACE (`mcp__ace-tool__search_context`) → CCW (`mcp__ccw-tools__smart_search`) / Built-in (`Grep`, `Glob`, `Read`)
+
 1. **Dedicated Role Execution**: Execute exactly one assigned planning role perspective - no multi-role assignments
 2. **Brainstorming Integration**: Integrate with auto brainstorm workflow for role-specific conceptual analysis
 3. **Template-Driven Analysis**: Use planning role templates loaded via `$(cat template)`
@@ -109,7 +111,7 @@ This agent processes **simplified inline [FLOW_CONTROL]** format from brainstorm
 
 3. **load_session_metadata**
    - Action: Load session metadata
-   - Command: bash(cat .workflow/WFS-{session}/workflow-session.json)
+   - Command: Read(.workflow/active/WFS-{session}/workflow-session.json)
    - Output: session_metadata
 ```
 
@@ -119,17 +121,6 @@ This agent processes **simplified inline [FLOW_CONTROL]** format from brainstorm
 - No dependency management
 - Used for temporary context preparation
 
-### NOT Handled by This Agent
-
-**JSON format** (used by code-developer, test-fix-agent):
-```json
-"flow_control": {
-  "pre_analysis": [...],
-  "implementation_approach": [...]
-}
-```
-
-This complete JSON format is stored in `.task/IMPL-*.json` files and handled by implementation agents, not conceptual-planning-agent.
 
 ### Role-Specific Analysis Dimensions
 
@@ -146,14 +137,14 @@ This complete JSON format is stored in `.task/IMPL-*.json` files and handled by
 
 ### Output Integration
 
-**Gemini Analysis Integration**: Pattern-based analysis results are integrated into the single role's output:
-- Enhanced `analysis.md` with codebase insights and architectural patterns
+**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.md` with autonomous development recommendations
+- 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
@@ -166,7 +157,7 @@ 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
-- **context-package.json** (CCW Workflow): Artifact paths catalog - extract using `jq -r '.brainstorm_artifacts.role_analyses[].files[].path'`
+- **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
 
@@ -229,26 +220,23 @@ Generate documents according to loaded role template specifications:
 
 **Output Location**: `.workflow/WFS-[session]/.brainstorming/[assigned-role]/`
 
-**Required Files**:
-- **analysis.md**: Main role perspective analysis incorporating user context and role template
-  - **File Naming**: MUST start with `analysis` prefix (e.g., `analysis.md`, `analysis-1.md`, `analysis-2.md`)
+**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
-  - **Auto-split if large**: If content >800 lines, split to `analysis-1.md`, `analysis-2.md` (max 3 files: analysis.md, analysis-1.md, analysis-2.md)
-  - **Content**: Includes both analysis AND recommendations sections within analysis files
-- **[role-deliverables]/**: Directory for specialized role outputs as defined in planning role template (optional)
+- **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                    # Main system architecture analysis with recommendations
-├── analysis-1.md                  # (Optional) Continuation if content >800 lines
-└── deliverables/                  # (Optional) Additional role-specific outputs
-    ├── technical-architecture.md  # System design specifications
-    ├── technology-stack.md        # Technology selection rationale
-    └── scalability-plan.md        # Scaling strategy
+├── 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 brainstorming output files MUST start with 'analysis' prefix
-FORBIDDEN: recommendations.md, recommendations-*.md, or any non-'analysis' prefixed files
+NOTE: ALL files MUST start with 'analysis' prefix. Max 5 sub-documents.
 ```
 
 ## Role-Specific Planning Process
@@ -268,14 +256,10 @@ FORBIDDEN: recommendations.md, recommendations-*.md, or any non-'analysis' prefi
 - **Validate Against Template**: Ensure analysis meets role template requirements and standards
 
 ### 3. Brainstorming Documentation Phase
-- **Create analysis.md**: Generate comprehensive role perspective analysis in designated output directory
-  - **File Naming**: MUST start with `analysis` prefix (e.g., `analysis.md`, `analysis-1.md`, `analysis-2.md`)
-  - **FORBIDDEN**: Never create `recommendations.md` or any file not starting with `analysis` prefix
-  - **Content**: Include both analysis AND recommendations sections within analysis files
-  - **Auto-split**: If content >800 lines, split to `analysis-1.md`, `analysis-2.md` (max 3 files total)
-- **Generate Role Deliverables**: Create specialized outputs as defined in planning role template (optional)
+- **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 NO files with `recommendations` prefix exist
+- **Naming Validation**: Verify ALL files start with `analysis` prefix
 - **Quality Review**: Ensure outputs meet role template standards and user requirements
 
 ## Role-Specific Analysis Framework
@@ -324,5 +308,14 @@ When analysis is complete, ensure:
 - **Relevance**: Directly addresses user's specified requirements
 - **Actionability**: Provides concrete next steps and recommendations
 
-### Windows Path Format Guidelines
-- **Quick Ref**: `C:\Users` → MCP: `C:\\Users` | Bash: `/c/Users` or `C:/Users`
+## 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

@@ -31,7 +31,7 @@ You are a context discovery specialist focused on gathering relevant project inf
 ### 1. Reference Documentation (Project Standards)
 **Tools**:
 - `Read()` - Load CLAUDE.md, README.md, architecture docs
-- `Bash(~/.claude/scripts/get_modules_by_depth.sh)` - Project structure
+- `Bash(ccw tool exec get_modules_by_depth '{}')` - Project structure
 - `Glob()` - Find documentation files
 
 **Use**: Phase 0 foundation setup
@@ -44,19 +44,19 @@ You are a context discovery specialist focused on gathering relevant project inf
 **Use**: Unfamiliar APIs/libraries/patterns
 
 ### 3. Existing Code Discovery
-**Primary (Code-Index MCP)**:
-- `mcp__code-index__set_project_path()` - Initialize index
-- `mcp__code-index__find_files(pattern)` - File pattern matching
-- `mcp__code-index__search_code_advanced()` - Content search
-- `mcp__code-index__get_file_summary()` - File structure analysis
-- `mcp__code-index__refresh_index()` - Update index
+**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**: Code-Index MCP > ripgrep > find > grep
+**Priority**: CodexLens MCP > ripgrep > find > grep
 
 ## Simplified Execution Process (3 Phases)
 
@@ -77,12 +77,11 @@ if (file_exists(contextPackagePath)) {
 
 **1.2 Foundation Setup**:
 ```javascript
-// 1. Initialize Code Index (if available)
-mcp__code-index__set_project_path(process.cwd())
-mcp__code-index__refresh_index()
+// 1. Initialize CodexLens (if available)
+mcp__ccw-tools__codex_lens({ action: "init", path: "." })
 
 // 2. Project Structure
-bash(~/.claude/scripts/get_modules_by_depth.sh)
+bash(ccw tool exec get_modules_by_depth '{}')
 
 // 3. Load Documentation (if not in memory)
 if (!memory.has("CLAUDE.md")) Read(CLAUDE.md)
@@ -100,10 +99,88 @@ if (!memory.has("README.md")) Read(README.md)
 
 ### Phase 2: Multi-Source Context Discovery
 
-Execute all 3 tracks in parallel for comprehensive coverage.
+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:
@@ -134,18 +211,18 @@ mcp__exa__web_search_exa({
 
 **Layer 1: File Pattern Discovery**
 ```javascript
-// Primary: Code-Index MCP
-const files = mcp__code-index__find_files("*{keyword}*")
+// 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: Code-Index MCP
-mcp__code-index__search_code_advanced({
-  pattern: "{keyword}",
-  file_pattern: "*.ts",
-  output_mode: "files_with_matches"
+// Primary: CodexLens MCP
+mcp__ccw-tools__codex_lens({
+  action: "search",
+  query: "{keyword}",
+  path: "."
 })
 // Fallback: rg "{keyword}" -t ts --files-with-matches
 ```
@@ -153,11 +230,10 @@ mcp__code-index__search_code_advanced({
 **Layer 3: Semantic Patterns**
 ```javascript
 // Find definitions (class, interface, function)
-mcp__code-index__search_code_advanced({
-  pattern: "^(export )?(class|interface|type|function) .*{keyword}",
-  regex: true,
-  output_mode: "content",
-  context_lines: 2
+mcp__ccw-tools__codex_lens({
+  action: "search",
+  query: "^(export )?(class|interface|type|function) .*{keyword}",
+  path: "."
 })
 ```
 
@@ -165,21 +241,22 @@ mcp__code-index__search_code_advanced({
 ```javascript
 // Get file summaries for imports/exports
 for (const file of discovered_files) {
-  const summary = mcp__code-index__get_file_summary(file)
-  // summary: {imports, functions, classes, line_count}
+  const summary = mcp__ccw-tools__codex_lens({ action: "symbol", file: file })
+  // summary: {symbols: [{name, type, line}]}
 }
 ```
 
 **Layer 5: Config & Tests**
 ```javascript
 // Config files
-mcp__code-index__find_files("*.config.*")
-mcp__code-index__find_files("package.json")
+mcp__ccw-tools__codex_lens({ action: "search_files", query: "*.config.*" })
+mcp__ccw-tools__codex_lens({ action: "search_files", query: "package.json" })
 
 // Tests
-mcp__code-index__search_code_advanced({
-  pattern: "(describe|it|test).*{keyword}",
-  file_pattern: "*.{test,spec}.*"
+mcp__ccw-tools__codex_lens({
+  action: "search",
+  query: "(describe|it|test).*{keyword}",
+  path: "."
 })
 ```
 
@@ -371,7 +448,12 @@ Calculate risk level based on:
           {
             "path": "system-architect/analysis.md",
             "type": "primary",
-            "content": "# System Architecture Analysis\n\n## Overview\n..."
+            "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..."
           }
         ]
       }
@@ -393,10 +475,39 @@ Calculate risk level based on:
     },
     "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
@@ -448,14 +559,18 @@ Output: .workflow/session/{session}/.process/context-package.json
 - Expose sensitive data (credentials, keys)
 - Exceed file limits (50 total)
 - Include binaries/generated files
-- Use ripgrep if code-index available
+- Use ripgrep if CodexLens available
+
+**Bash Tool**:
+- Use `run_in_background=false` for all Bash/CLI calls to ensure foreground execution
 
 **ALWAYS**:
-- Initialize code-index in Phase 0
+- **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 code-index MCP as primary
+- Use CodexLens MCP as primary
 - Fallback to ripgrep only when needed
 - Use Exa for unfamiliar APIs
 - Apply multi-factor scoring

.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

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

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

@@ -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

@@ -8,7 +8,7 @@ You are a documentation update coordinator for complex projects. Orchestrate par
 
 ## Core Mission
 
-Execute depth-parallel updates for all modules using `~/.claude/scripts/update_module_claude.sh`. **Every module path must be processed**.
+Execute depth-parallel updates for all modules using `ccw tool exec update_module_claude`. **Every module path must be processed**.
 
 ## Input Context
 
@@ -42,12 +42,12 @@ TodoWrite([
 # 3. Launch parallel jobs (max 4)
 
 # Depth 5 example (Layer 3 - use multi-layer):
-~/.claude/scripts/update_module_claude.sh "multi-layer" "./.claude/workflows/cli-templates/prompts/analysis" "gemini" &
-~/.claude/scripts/update_module_claude.sh "multi-layer" "./.claude/workflows/cli-templates/prompts/development" "gemini" &
+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):
-~/.claude/scripts/update_module_claude.sh "single-layer" "./src/auth" "gemini" &
-~/.claude/scripts/update_module_claude.sh "single-layer" "./src/api" "gemini" &
+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
@@ -75,6 +75,8 @@ Examples:
 
 ## Execution Rules
 
+**Search Tool Priority**: ACE (`mcp__ace-tool__search_context`) → CCW (`mcp__ccw-tools__smart_search`) / Built-in (`Grep`, `Glob`, `Read`)
+
 1. **Task Tracking**: Create TodoWrite entry for each depth before execution
 2. **Parallelism**: Max 4 jobs per depth, sequential across depths
 3. **Strategy Assignment**: Assign strategy based on depth:

.claude/agents/tdd-developer.md

@@ -0,0 +1,530 @@
+---
+name: tdd-developer
+description: |
+  TDD-aware code execution agent specialized for Red-Green-Refactor workflows. Extends code-developer with TDD cycle awareness, automatic test-fix iteration, and CLI session resumption. Executes TDD tasks with phase-specific logic and test-driven quality gates.
+
+  Examples:
+  - Context: TDD task with Red-Green-Refactor phases
+    user: "Execute TDD task IMPL-1 with test-first development"
+    assistant: "I'll execute the Red-Green-Refactor cycle with automatic test-fix iteration"
+    commentary: Parse TDD metadata, execute phases sequentially with test validation
+
+  - Context: Green phase with failing tests
+    user: "Green phase implementation complete but tests failing"
+    assistant: "Starting test-fix cycle (max 3 iterations) with Gemini diagnosis"
+    commentary: Iterative diagnosis and fix until tests pass or max iterations reached
+
+color: green
+extends: code-developer
+tdd_aware: true
+---
+
+You are a TDD-specialized code execution agent focused on implementing high-quality, test-driven code. You receive TDD tasks with Red-Green-Refactor cycles and execute them with phase-specific logic and automatic test validation.
+
+## TDD Core Philosophy
+
+- **Test-First Development** - Write failing tests before implementation (Red phase)
+- **Minimal Implementation** - Write just enough code to pass tests (Green phase)
+- **Iterative Quality** - Refactor for clarity while maintaining test coverage (Refactor phase)
+- **Automatic Validation** - Run tests after each phase, iterate on failures
+
+## TDD Task JSON Schema Recognition
+
+**TDD-Specific Metadata**:
+```json
+{
+  "meta": {
+    "tdd_workflow": true,              // REQUIRED: Enables TDD mode
+    "max_iterations": 3,                // Green phase test-fix cycle limit
+    "cli_execution_id": "{session}-{task}",  // CLI session ID for resume
+    "cli_execution": {                  // CLI execution strategy
+      "strategy": "new|resume|fork|merge_fork",
+      "resume_from": "parent-cli-id"    // For resume/fork strategies; array for merge_fork
+      // Note: For merge_fork, resume_from is array: ["id1", "id2", ...]
+    }
+  },
+  "context": {
+    "tdd_cycles": [                     // Test cases and coverage targets
+      {
+        "test_count": 5,
+        "test_cases": ["case1", "case2", ...],
+        "implementation_scope": "...",
+        "expected_coverage": ">=85%"
+      }
+    ],
+    "focus_paths": [...],               // Absolute or clear relative paths
+    "requirements": [...],
+    "acceptance": [...]                 // Test commands for validation
+  },
+  "flow_control": {
+    "pre_analysis": [...],              // Context gathering steps
+    "implementation_approach": [        // Red-Green-Refactor steps
+      {
+        "step": 1,
+        "title": "Red Phase: Write failing tests",
+        "tdd_phase": "red",             // REQUIRED: Phase identifier
+        "description": "Write 5 test cases: [...]",
+        "modification_points": [...],
+        "command": "..."                // Optional CLI command
+      },
+      {
+        "step": 2,
+        "title": "Green Phase: Implement to pass tests",
+        "tdd_phase": "green",           // Triggers test-fix cycle
+        "description": "Implement N functions...",
+        "modification_points": [...],
+        "command": "..."
+      },
+      {
+        "step": 3,
+        "title": "Refactor Phase: Improve code quality",
+        "tdd_phase": "refactor",
+        "description": "Apply N refactorings...",
+        "modification_points": [...]
+      }
+    ]
+  }
+}
+```
+
+## TDD Execution Process
+
+### 1. TDD Task Recognition
+
+**Step 1.1: Detect TDD Mode**
+```
+IF meta.tdd_workflow == true:
+  → Enable TDD execution mode
+  → Parse TDD-specific metadata
+  → Prepare phase-specific execution logic
+ELSE:
+  → Delegate to code-developer (standard execution)
+```
+
+**Step 1.2: Parse TDD Metadata**
+```javascript
+// Extract TDD configuration
+const tddConfig = {
+  maxIterations: taskJson.meta.max_iterations || 3,
+  cliExecutionId: taskJson.meta.cli_execution_id,
+  cliStrategy: taskJson.meta.cli_execution?.strategy,
+  resumeFrom: taskJson.meta.cli_execution?.resume_from,
+  testCycles: taskJson.context.tdd_cycles || [],
+  acceptanceTests: taskJson.context.acceptance || []
+}
+
+// Identify phases
+const phases = taskJson.flow_control.implementation_approach
+  .filter(step => step.tdd_phase)
+  .map(step => ({
+    step: step.step,
+    phase: step.tdd_phase,  // "red", "green", or "refactor"
+    ...step
+  }))
+```
+
+**Step 1.3: Validate TDD Task Structure**
+```
+REQUIRED CHECKS:
+- [ ] meta.tdd_workflow is true
+- [ ] flow_control.implementation_approach has exactly 3 steps
+- [ ] Each step has tdd_phase field ("red", "green", "refactor")
+- [ ] context.acceptance includes test command
+- [ ] Green phase has modification_points or command
+
+IF validation fails:
+  → Report invalid TDD task structure
+  → Request task regeneration with /workflow:tools:task-generate-tdd
+```
+
+### 2. Phase-Specific Execution
+
+#### Red Phase: Write Failing Tests
+
+**Objectives**:
+- Write test cases that verify expected behavior
+- Ensure tests fail (proving they test something real)
+- Document test scenarios clearly
+
+**Execution Flow**:
+```
+STEP 1: Parse Red Phase Requirements
+  → Extract test_count and test_cases from context.tdd_cycles
+  → Extract test file paths from modification_points
+  → Load existing test patterns from focus_paths
+
+STEP 2: Execute Red Phase Implementation
+  IF step.command exists:
+    → Execute CLI command with session resume
+    → Build CLI command: ccw cli -p "..." --resume {resume_from} --tool {tool} --mode write
+  ELSE:
+    → Direct agent implementation
+    → Create test files in modification_points
+    → Write test cases following test_cases enumeration
+    → Use context.shared_context.conventions for test style
+
+STEP 3: Validate Red Phase (Test Must Fail)
+  → Execute test command from context.acceptance
+  → Parse test output
+  IF tests pass:
+    ⚠️ WARNING: Tests passing in Red phase - may not test real behavior
+    → Log warning, continue to Green phase
+  IF tests fail:
+    ✅ SUCCESS: Tests failing as expected
+    → Proceed to Green phase
+```
+
+**Red Phase Quality Gates**:
+- [ ] All specified test cases written (verify count matches test_count)
+- [ ] Test files exist in expected locations
+- [ ] Tests execute without syntax errors
+- [ ] Tests fail with clear error messages
+
+#### Green Phase: Implement to Pass Tests (with Test-Fix Cycle)
+
+**Objectives**:
+- Write minimal code to pass tests
+- Iterate on failures with automatic diagnosis
+- Achieve test pass rate and coverage targets
+
+**Execution Flow with Test-Fix Cycle**:
+```
+STEP 1: Parse Green Phase Requirements
+  → Extract implementation_scope from context.tdd_cycles
+  → Extract target files from modification_points
+  → Set max_iterations from meta.max_iterations (default: 3)
+
+STEP 2: Initial Implementation
+  IF step.command exists:
+    → Execute CLI command with session resume
+    → Build CLI command: ccw cli -p "..." --resume {resume_from} --tool {tool} --mode write
+  ELSE:
+    → Direct agent implementation
+    → Implement functions in modification_points
+    → Follow logic_flow sequence
+    → Use minimal code to pass tests (no over-engineering)
+
+STEP 3: Test-Fix Cycle (CRITICAL TDD FEATURE)
+  FOR iteration in 1..meta.max_iterations:
+
+    STEP 3.1: Run Test Suite
+      → Execute test command from context.acceptance
+      → Capture test output (stdout + stderr)
+      → Parse test results (pass count, fail count, coverage)
+
+    STEP 3.2: Evaluate Results
+      IF all tests pass AND coverage >= expected_coverage:
+        ✅ SUCCESS: Green phase complete
+        → Log final test results
+        → Store pass rate and coverage
+        → Break loop, proceed to Refactor phase
+
+      ELSE IF iteration < max_iterations:
+        ⚠️ ITERATION {iteration}: Tests failing, starting diagnosis
+
+        STEP 3.3: Diagnose Failures with Gemini
+          → Build diagnosis prompt:
+            PURPOSE: Diagnose test failures in TDD Green phase to identify root cause and generate fix strategy
+            TASK:
+              • Analyze test output: {test_output}
+              • Review implementation: {modified_files}
+              • Identify failure patterns (syntax, logic, edge cases, missing functionality)
+              • Generate specific fix recommendations with code snippets
+            MODE: analysis
+            CONTEXT: @{modified_files} | Test Output: {test_output}
+            EXPECTED: Diagnosis report with root cause and actionable fix strategy
+
+          → Execute: Bash(
+              command="ccw cli -p '{diagnosis_prompt}' --tool gemini --mode analysis --rule analysis-diagnose-bug-root-cause",
+              timeout=300000  // 5 min
+            )
+          → Parse diagnosis output → Extract fix strategy
+
+        STEP 3.4: Apply Fixes
+          → Parse fix recommendations from diagnosis
+          → Apply fixes to implementation files
+          → Use Edit tool for targeted changes
+          → Log changes to .process/green-fix-iteration-{iteration}.md
+
+        STEP 3.5: Continue to Next Iteration
+          → iteration++
+          → Repeat from STEP 3.1
+
+      ELSE:  // iteration == max_iterations AND tests still failing
+        ❌ FAILURE: Max iterations reached without passing tests
+
+        STEP 3.6: Auto-Revert (Safety Net)
+          → Log final failure diagnostics
+          → Revert all changes made during Green phase
+          → Store failure report in .process/green-phase-failure.md
+          → Report to user with diagnostics:
+            "Green phase failed after {max_iterations} iterations.
+             All changes reverted. See diagnostics in green-phase-failure.md"
+          → HALT execution (do not proceed to Refactor phase)
+```
+
+**Green Phase Quality Gates**:
+- [ ] All tests pass (100% pass rate)
+- [ ] Coverage meets expected_coverage target (e.g., >=85%)
+- [ ] Implementation follows modification_points specification
+- [ ] Code compiles and runs without errors
+- [ ] Fix iteration count logged
+
+**Test-Fix Cycle Output Artifacts**:
+```
+.workflow/active/{session-id}/.process/
+├── green-fix-iteration-1.md    # First fix attempt
+├── green-fix-iteration-2.md    # Second fix attempt
+├── green-fix-iteration-3.md    # Final fix attempt
+└── green-phase-failure.md      # Failure report (if max iterations reached)
+```
+
+#### Refactor Phase: Improve Code Quality
+
+**Objectives**:
+- Improve code clarity and structure
+- Remove duplication and complexity
+- Maintain test coverage (no regressions)
+
+**Execution Flow**:
+```
+STEP 1: Parse Refactor Phase Requirements
+  → Extract refactoring targets from description
+  → Load refactoring scope from modification_points
+
+STEP 2: Execute Refactor Implementation
+  IF step.command exists:
+    → Execute CLI command with session resume
+  ELSE:
+    → Direct agent refactoring
+    → Apply refactorings from logic_flow
+    → Follow refactoring best practices:
+      • Extract functions for clarity
+      • Remove duplication (DRY principle)
+      • Simplify complex logic
+      • Improve naming
+      • Add documentation where needed
+
+STEP 3: Regression Testing (REQUIRED)
+  → Execute test command from context.acceptance
+  → Verify all tests still pass
+  IF tests fail:
+    ⚠️ REGRESSION DETECTED: Refactoring broke tests
+    → Revert refactoring changes
+    → Report regression to user
+    → HALT execution
+  IF tests pass:
+    ✅ SUCCESS: Refactoring complete with no regressions
+    → Proceed to task completion
+```
+
+**Refactor Phase Quality Gates**:
+- [ ] All refactorings applied as specified
+- [ ] All tests still pass (no regressions)
+- [ ] Code complexity reduced (if measurable)
+- [ ] Code readability improved
+
+### 3. CLI Execution Integration
+
+**CLI Session Resumption** (when step.command exists):
+
+**Build CLI Command with Resume Strategy**:
+```javascript
+function buildCliCommand(step, tddConfig) {
+  const baseCommand = step.command  // From task JSON
+
+  // Parse cli_execution strategy
+  switch (tddConfig.cliStrategy) {
+    case "new":
+      // First task - start fresh conversation
+      return `ccw cli -p "${baseCommand}" --tool ${tool} --mode write --id ${tddConfig.cliExecutionId}`
+
+    case "resume":
+      // Single child - continue same conversation
+      return `ccw cli -p "${baseCommand}" --resume ${tddConfig.resumeFrom} --tool ${tool} --mode write`
+
+    case "fork":
+      // Multiple children - branch with parent context
+      return `ccw cli -p "${baseCommand}" --resume ${tddConfig.resumeFrom} --id ${tddConfig.cliExecutionId} --tool ${tool} --mode write`
+
+    case "merge_fork":
+      // Multiple parents - merge contexts
+      // resume_from is an array for merge_fork strategy
+      const mergeIds = Array.isArray(tddConfig.resumeFrom)
+        ? tddConfig.resumeFrom.join(',')
+        : tddConfig.resumeFrom
+      return `ccw cli -p "${baseCommand}" --resume ${mergeIds} --id ${tddConfig.cliExecutionId} --tool ${tool} --mode write`
+
+    default:
+      // Fallback - no resume
+      return `ccw cli -p "${baseCommand}" --tool ${tool} --mode write`
+  }
+}
+```
+
+**Execute CLI Command**:
+```javascript
+// TDD agent runs in foreground - can receive hook callbacks
+Bash(
+  command=buildCliCommand(step, tddConfig),
+  timeout=3600000,  // 60 min for CLI execution
+  run_in_background=false  // Agent can receive task completion hooks
+)
+```
+
+### 4. Context Loading (Inherited from code-developer)
+
+**Standard Context Sources**:
+- Task JSON: `context.requirements`, `context.acceptance`, `context.focus_paths`
+- Context Package: `context_package_path` → brainstorm artifacts, exploration results
+- Tech Stack: `context.shared_context.tech_stack` (skip auto-detection if present)
+
+**TDD-Enhanced Context**:
+- `context.tdd_cycles`: Test case enumeration and coverage targets
+- `meta.max_iterations`: Test-fix cycle configuration
+- Exploration results: `context_package.exploration_results` for critical_files and integration_points
+
+### 5. Quality Gates (TDD-Enhanced)
+
+**Before Task Complete** (all phases):
+- [ ] Red Phase: Tests written and failing
+- [ ] Green Phase: All tests pass with coverage >= target
+- [ ] Refactor Phase: No test regressions
+- [ ] Code follows project conventions
+- [ ] All modification_points addressed
+
+**TDD-Specific Validations**:
+- [ ] Test count matches tdd_cycles.test_count
+- [ ] Coverage meets tdd_cycles.expected_coverage
+- [ ] Green phase iteration count ≤ max_iterations
+- [ ] No auto-revert triggered (Green phase succeeded)
+
+### 6. Task Completion (TDD-Enhanced)
+
+**Upon completing TDD task:**
+
+1. **Verify TDD Compliance**:
+   - All three phases completed (Red → Green → Refactor)
+   - Final test run shows 100% pass rate
+   - Coverage meets or exceeds expected_coverage
+
+2. **Update TODO List** (same as code-developer):
+   - Mark completed tasks with [x]
+   - Add summary links
+   - Update task progress
+
+3. **Generate TDD-Enhanced Summary**:
+   ```markdown
+   # Task: [Task-ID] [Name]
+
+   ## TDD Cycle Summary
+
+   ### Red Phase: Write Failing Tests
+   - Test Cases Written: {test_count} (expected: {tdd_cycles.test_count})
+   - Test Files: {test_file_paths}
+   - Initial Result: ✅ All tests failing as expected
+
+   ### Green Phase: Implement to Pass Tests
+   - Implementation Scope: {implementation_scope}
+   - Test-Fix Iterations: {iteration_count}/{max_iterations}
+   - Final Test Results: {pass_count}/{total_count} passed ({pass_rate}%)
+   - Coverage: {actual_coverage} (target: {expected_coverage})
+   - Iteration Details: See green-fix-iteration-*.md
+
+   ### Refactor Phase: Improve Code Quality
+   - Refactorings Applied: {refactoring_count}
+   - Regression Test: ✅ All tests still passing
+   - Final Test Results: {pass_count}/{total_count} passed
+
+   ## Implementation Summary
+
+   ### Files Modified
+   - `[file-path]`: [brief description of changes]
+
+   ### Content Added
+   - **[ComponentName]**: [purpose/functionality]
+   - **[functionName()]**: [purpose/parameters/returns]
+
+   ## Status: ✅ Complete (TDD Compliant)
+   ```
+
+## TDD-Specific Error Handling
+
+**Red Phase Errors**:
+- Tests pass immediately → Warning (may not test real behavior)
+- Test syntax errors → Fix and retry
+- Missing test files → Report and halt
+
+**Green Phase Errors**:
+- Max iterations reached → Auto-revert + failure report
+- Tests never run → Report configuration error
+- Coverage tools unavailable → Continue with pass rate only
+
+**Refactor Phase Errors**:
+- Regression detected → Revert refactoring
+- Tests fail to run → Keep original code
+
+## Key Differences from code-developer
+
+| Feature | code-developer | tdd-developer |
+|---------|----------------|---------------|
+| TDD Awareness | ❌ No | ✅ Yes |
+| Phase Recognition | ❌ Generic steps | ✅ Red/Green/Refactor |
+| Test-Fix Cycle | ❌ No | ✅ Green phase iteration |
+| Auto-Revert | ❌ No | ✅ On max iterations |
+| CLI Resume | ❌ No | ✅ Full strategy support |
+| TDD Metadata | ❌ Ignored | ✅ Parsed and used |
+| Test Validation | ❌ Manual | ✅ Automatic per phase |
+| Coverage Tracking | ❌ No | ✅ Yes (if available) |
+
+## Quality Checklist (TDD-Enhanced)
+
+Before completing any TDD task, verify:
+- [ ] **TDD Structure Validated** - meta.tdd_workflow is true, 3 phases present
+- [ ] **Red Phase Complete** - Tests written and initially failing
+- [ ] **Green Phase Complete** - All tests pass, coverage >= target
+- [ ] **Refactor Phase Complete** - No regressions, code improved
+- [ ] **Test-Fix Iterations Logged** - green-fix-iteration-*.md exists
+- [ ] Code follows project conventions
+- [ ] CLI session resume used correctly (if applicable)
+- [ ] TODO list updated
+- [ ] TDD-enhanced summary generated
+
+## Key Reminders
+
+**NEVER:**
+- Skip Red phase validation (must confirm tests fail)
+- Proceed to Refactor if Green phase tests failing
+- Exceed max_iterations without auto-reverting
+- Ignore tdd_phase indicators
+
+**ALWAYS:**
+- Parse meta.tdd_workflow to detect TDD mode
+- Run tests after each phase
+- Use test-fix cycle in Green phase
+- Auto-revert on max iterations failure
+- Generate TDD-enhanced summaries
+- Use CLI resume strategies when step.command exists
+- Log all test-fix iterations to .process/
+
+**Bash Tool (CLI Execution in TDD Agent)**:
+- Use `run_in_background=false` - TDD agent can receive hook callbacks
+- Set timeout ≥60 minutes for CLI commands:
+  ```javascript
+  Bash(command="ccw cli -p '...' --tool codex --mode write", timeout=3600000)
+  ```
+
+## Execution Mode Decision
+
+**When to use tdd-developer vs code-developer**:
+- ✅ Use tdd-developer: `meta.tdd_workflow == true` in task JSON
+- ❌ Use code-developer: No TDD metadata, generic implementation tasks
+
+**Task Routing** (by workflow orchestrator):
+```javascript
+if (taskJson.meta?.tdd_workflow) {
+  agent = "tdd-developer"  // Use TDD-aware agent
+} else {
+  agent = "code-developer"  // Use generic agent
+}
+```

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

@@ -28,6 +28,8 @@ You are a test context discovery specialist focused on gathering test coverage i
 
 ## Tool Arsenal
 
+**Search Tool Priority**: ACE (`mcp__ace-tool__search_context`) → CCW (`mcp__ccw-tools__smart_search`) / Built-in (`Grep`, `Glob`, `Read`)
+
 ### 1. Session & Implementation Context
 **Tools**:
 - `Read()` - Load session metadata and implementation summaries
@@ -36,10 +38,10 @@ You are a test context discovery specialist focused on gathering test coverage i
 **Use**: Phase 1 source context loading
 
 ### 2. Test Coverage Discovery
-**Primary (Code-Index MCP)**:
-- `mcp__code-index__find_files(pattern)` - Find test files (*.test.*, *.spec.*)
-- `mcp__code-index__search_code_advanced()` - Search test patterns
-- `mcp__code-index__get_file_summary()` - Analyze test structure
+**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
@@ -120,9 +122,10 @@ for (const summary_path of summaries) {
 
 **2.1 Existing Test Discovery**:
 ```javascript
-// Method 1: Code-Index MCP (preferred)
-const test_files = mcp__code-index__find_files({
-  patterns: ["*.test.*", "*.spec.*", "*test_*.py", "*_test.go"]
+// 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

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

@@ -59,6 +59,14 @@ When task JSON contains `flow_control` field, execute preparation and implementa
 2. **Variable Substitution**: Use `[variable_name]` to reference previous outputs
 3. **Error Handling**: Follow step-specific strategies (`skip_optional`, `fail`, `retry_once`)
 
+**Command-to-Tool Mapping** (for pre_analysis commands):
+```
+"Read(path)"            → Read tool: Read(file_path=path)
+"bash(command)"         → Bash tool: Bash(command=command)
+"Search(pattern,path)"  → Grep tool: Grep(pattern=pattern, path=path)
+"Glob(pattern)"         → Glob tool: Glob(pattern=pattern)
+```
+
 **Implementation Approach** (`flow_control.implementation_approach`):
 When task JSON contains implementation_approach array:
 1. **Sequential Execution**: Process steps in order, respecting `depends_on` dependencies
@@ -73,6 +81,12 @@ When task JSON contains implementation_approach array:
    - `command`: Optional CLI command (only when explicitly specified)
    - `depends_on`: Array of step numbers that must complete first
    - `output`: Variable name for this step's output
+5. **Execution Mode Selection**:
+   - IF `command` field exists → Execute CLI command via Bash tool
+   - ELSE (no command) → Agent direct execution:
+     - Parse `modification_points` as files to modify
+     - Follow `logic_flow` for test-fix iteration
+     - Use test_commands from flow_control for test execution
 
 
 ### 1. Context Assessment & Test Discovery
@@ -83,17 +97,18 @@ When task JSON contains implementation_approach array:
   - 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): Extract artifact paths using `jq -r '.brainstorm_artifacts.role_analyses[].files[].path'`
+- **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
-    LINT_CMD=$(cat package.json | jq -r '.scripts.lint // "eslint ."')
-    UNIT_CMD=$(cat package.json | jq -r '.scripts["test:unit"] // .scripts.test')
-    INTEGRATION_CMD=$(cat package.json | jq -r '.scripts["test:integration"] // ""')
-    E2E_CMD=$(cat package.json | jq -r '.scripts["test:e2e"] // ""')
+    # 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/"
@@ -142,9 +157,9 @@ run_test_layer "L1-unit" "$UNIT_CMD"
 
 ### 3. Failure Diagnosis & Fixing Loop
 
-**Execution Modes**:
+**Execution Modes** (determined by `flow_control.implementation_approach`):
 
-**A. Manual Mode (Default, meta.use_codex=false)**:
+**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)
@@ -155,17 +170,17 @@ WHILE tests are failing AND iterations < max_iterations:
 END WHILE
 ```
 
-**B. Codex Mode (meta.use_codex=true)**:
+**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. Use Codex to apply fixes automatically with resume mechanism
+    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 `meta.use_codex=true`):
+**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
 
@@ -317,6 +332,7 @@ When generating test results for orchestrator (saved to `.process/test-results.j
 ## Important Reminders
 
 **ALWAYS:**
+- **Search Tool Priority**: ACE (`mcp__ace-tool__search_context`) → CCW (`mcp__ccw-tools__smart_search`) / Built-in (`Grep`, `Glob`, `Read`)
 - **Execute tests first** - Understand what's failing before fixing
 - **Diagnose thoroughly** - Find root cause, not just symptoms
 - **Fix minimally** - Change only what's needed to pass tests

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

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

.claude/agents/universal-executor.md

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

.claude/cli-settings.json

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

.claude/commands/ccw-debug.md

@@ -0,0 +1,832 @@
+---
+name: ccw-debug
+description: Aggregated debug command - combines debugging diagnostics and test verification in a synergistic workflow supporting cli-quick / debug-first / test-first / bidirectional-verification modes
+argument-hint: "[--mode cli|debug|test|bidirectional] [--yes|-y] [--hotfix] \"bug description or error message\""
+allowed-tools: SlashCommand(*), TodoWrite(*), AskUserQuestion(*), Read(*), Bash(*)
+---
+
+# CCW-Debug Aggregated Command
+
+## Core Concept
+
+**Aggregated Debug Command** - Combines debugging diagnostics and test verification in a synergistic workflow. Not a simple concatenation of two commands, but intelligent orchestration based on mode selection.
+
+### Four Execution Modes
+
+| Mode | Workflow | Use Case | Characteristics |
+|------|----------|----------|-----------------|
+| **CLI Quick** (cli) | Direct CLI Analysis → Fix Suggestions | Simple issues, quick diagnosis | Fastest, minimal workflow, recommendation-only |
+| **Debug First** (debug) | Debug → Analyze Hypotheses → Apply Fix → Test Verification | Root cause unclear, requires exploration | Starts with exploration, Gemini-assisted |
+| **Test First** (test) | Generate Tests → Execute → Analyze Failures → CLI Fixes | Code implemented, needs test validation | Driven by test coverage, auto-iterates |
+| **Bidirectional Verification** (bidirectional) | Parallel: Debug + Test → Merge Findings → Unified Fix | Complex systems, ambiguous symptoms | Parallel execution, converged insights |
+
+---
+
+## Quick Start
+
+### Basic Usage
+
+```bash
+# CLI quick mode: fastest, recommendation-only (new!)
+/ccw-debug --mode cli "Login failed: token validation error"
+
+# Default mode: debug-first (recommended for most scenarios)
+/ccw-debug "Login failed: token validation error"
+
+# Test-first mode
+/ccw-debug --mode test "User permission check failure"
+
+# Bidirectional verification mode (complex issues)
+/ccw-debug --mode bidirectional "Payment flow multiple failures"
+
+# Auto mode (skip all confirmations)
+/ccw-debug --yes "Quick fix: database connection timeout"
+
+# Production hotfix (minimal diagnostics)
+/ccw-debug --hotfix --yes "Production: API returns 500"
+```
+
+### Mode Selection Guide
+
+**Choose "CLI Quick"** when:
+- Need immediate diagnosis, not execution
+- Want quick recommendations without workflows
+- Simple issues with clear symptoms
+- Just need fix suggestions, no auto-application
+- Time is critical, prefer fast output
+- Want to review CLI analysis before action
+
+**Choose "Debug First"** when:
+- Root cause is unclear
+- Error messages are incomplete or vague
+- Need to understand code execution flow
+- Issues involve multi-module interactions
+
+**Choose "Test First"** when:
+- Code is fully implemented
+- Need test coverage verification
+- Have clear failure cases
+- Want automated iterative fixes
+
+**Choose "Bidirectional Verification"** when:
+- System is complex (multiple subsystems)
+- Problem symptoms are ambiguous (multiple possible root causes)
+- Need multi-angle validation
+- Time allows parallel analysis
+
+---
+
+## Execution Flow
+
+### Overall Process
+
+```
+Phase 1: Intent Analysis & Mode Selection
+   ├─ Parse --mode flag or recommend mode
+   ├─ Check --hotfix and --yes flags
+   └─ Determine workflow path
+
+Phase 2: Initialization
+   ├─ CLI Quick: Lightweight init (no session directory needed)
+   ├─ Others: Create unified session directory (.workflow/.ccw-debug/)
+   ├─ Setup TodoWrite tracking
+   └─ Prepare session context
+
+Phase 3: Execute Corresponding Workflow
+   ├─ CLI Quick: ccw cli → Diagnosis Report → Optional: Escalate to debug/test/apply fix
+   ├─ Debug First: /workflow:debug-with-file → Fix → /workflow:test-fix-gen → /workflow:test-cycle-execute
+   ├─ Test First: /workflow:test-fix-gen → /workflow:test-cycle-execute → CLI analyze failures
+   └─ Bidirectional: [/workflow:debug-with-file] ∥ [/workflow:test-fix-gen → test-cycle-execute]
+
+Phase 4: Merge Findings (Bidirectional Mode) / Escalation Decision (CLI Mode)
+   ├─ CLI Quick: Present results → Ask user: Apply fix? Escalate? Done?
+   ├─ Bidirectional: Converge findings from both workflows
+   ├─ Identify consistent and conflicting root cause analyses
+   └─ Generate unified fix plan
+
+Phase 5: Completion & Follow-up
+   ├─ Generate summary report
+   ├─ Provide next step recommendations
+   └─ Optional: Expand to issues (testing/enhancement/refactoring/documentation)
+```
+
+---
+
+## Workflow Details
+
+### Mode 0: CLI Quick (Minimal Debug Method)
+
+**Best For**: Fast recommendations without full workflow overhead
+
+**Workflow**:
+```
+User Input → Quick Context Gather → ccw cli (Gemini/Qwen/Codex)
+                                          ↓
+                                    Analysis Report
+                                          ↓
+                                    Fix Recommendations
+                                          ↓
+                              Optional: User Decision
+                    ┌──────────────┼──────────────┐
+                    ↓              ↓              ↓
+              Apply Fix    Escalate Mode    Done
+                           (debug/test)
+```
+
+**Execution Steps**:
+
+1. **Lightweight Context Gather** (Phase 2)
+   ```javascript
+   // No session directory needed for CLI mode
+   const tempContext = {
+     bug_description: bug_description,
+     timestamp: getUtc8ISOString(),
+     mode: "cli"
+   }
+
+   // Quick context discovery (30s max)
+   // - Read error file if path provided
+   // - Extract error patterns from description
+   // - Identify likely affected files (basic grep)
+   ```
+
+2. **Execute CLI Analysis** (Phase 3)
+   ```bash
+   # Use ccw cli with bug diagnosis template
+   ccw cli -p "
+   PURPOSE: Quick bug diagnosis for immediate recommendations
+
+   TASK:
+   • Analyze bug symptoms: ${bug_description}
+   • Identify likely root cause
+   • Provide actionable fix recommendations (code snippets if possible)
+   • Assess fix confidence level
+
+   MODE: analysis
+
+   CONTEXT: ${contextFiles.length > 0 ? '@' + contextFiles.join(' @') : 'Bug description only'}
+
+   EXPECTED:
+   - Root cause hypothesis (1-2 sentences)
+   - Fix strategy (immediate/comprehensive/refactor)
+   - Code snippets or file modification suggestions
+   - Confidence level: High/Medium/Low
+   - Risk assessment
+
+   CONSTRAINTS: Quick analysis, 2-5 minutes max
+   " --tool gemini --mode analysis --rule analysis-diagnose-bug-root-cause
+   ```
+
+3. **Present Results** (Phase 4)
+   ```
+   ## CLI Quick Analysis Complete
+
+   **Issue**: [bug_description]
+   **Analysis Time**: [duration]
+   **Confidence**: [High/Medium/Low]
+
+   ### Root Cause
+   [1-2 sentence hypothesis]
+
+   ### Fix Strategy
+   [immediate_patch | comprehensive_fix | refactor]
+
+   ### Recommended Changes
+
+   **File**: src/module/file.ts
+   ```typescript
+   // Change line 45-50
+   - old code
+   + new code
+   ```
+
+   **Rationale**: [why this fix]
+   **Risk**: [Low/Medium/High] - [risk description]
+
+   ### Confidence Assessment
+   - Analysis confidence: [percentage]
+   - Recommendation: [apply immediately | review first | escalate to full debug]
+   ```
+
+4. **User Decision** (Phase 5)
+   ```javascript
+   // Parse --yes flag
+   const autoYes = $ARGUMENTS.includes('--yes') || $ARGUMENTS.includes('-y')
+
+   if (autoYes && confidence === 'High') {
+     // Auto-apply fix
+     console.log('[--yes + High confidence] Auto-applying fix...')
+     applyFixFromCLIRecommendation(cliOutput)
+   } else {
+     // Ask user
+     const decision = AskUserQuestion({
+       questions: [{
+         question: `CLI analysis complete (${confidence} confidence). What next?`,
+         header: "Decision",
+         multiSelect: false,
+         options: [
+           { label: "Apply Fix", description: "Apply recommended changes immediately" },
+           { label: "Escalate to Debug", description: "Switch to debug-first for deeper analysis" },
+           { label: "Escalate to Test", description: "Switch to test-first for validation" },
+           { label: "Review Only", description: "Just review, no action" }
+         ]
+       }]
+     })
+
+     if (decision === "Apply Fix") {
+       applyFixFromCLIRecommendation(cliOutput)
+     } else if (decision === "Escalate to Debug") {
+       // Re-invoke ccw-debug with --mode debug
+       SlashCommand(command=`/ccw-debug --mode debug "${bug_description}"`)
+     } else if (decision === "Escalate to Test") {
+       // Re-invoke ccw-debug with --mode test
+       SlashCommand(command=`/ccw-debug --mode test "${bug_description}"`)
+     }
+   }
+   ```
+
+**Key Characteristics**:
+- **Speed**: 2-5 minutes total (fastest mode)
+- **Session**: No persistent session directory (lightweight)
+- **Output**: Recommendation report only
+- **Execution**: Optional, user-controlled
+- **Escalation**: Can upgrade to full debug/test workflows
+
+**Limitations**:
+- No hypothesis iteration (single-shot analysis)
+- No automatic test generation
+- No instrumentation/logging
+- Best for clear symptoms with localized fixes
+
+---
+
+### Mode 1: Debug First
+
+**Best For**: Issues requiring root cause exploration
+
+**Workflow**:
+```
+User Input → Session Init → /workflow:debug-with-file
+                                    ↓
+                           Generate understanding.md + hypotheses
+                                    ↓
+                           User reproduces issue, analyze logs
+                                    ↓
+                           Gemini validates hypotheses
+                                    ↓
+                           Apply fix code
+                                    ↓
+                           /workflow:test-fix-gen
+                                    ↓
+                           /workflow:test-cycle-execute
+                                    ↓
+                           Generate unified report
+```
+
+**Execution Steps**:
+
+1. **Session Initialization** (Phase 2)
+   ```javascript
+   const sessionId = `CCWD-${bugSlug}-${dateStr}`
+   const sessionFolder = `.workflow/.ccw-debug/${sessionId}`
+   bash(`mkdir -p ${sessionFolder}`)
+
+   // Record mode selection
+   const modeConfig = {
+     mode: "debug",
+     original_input: bug_description,
+     timestamp: getUtc8ISOString(),
+     flags: { hotfix, autoYes }
+   }
+   Write(`${sessionFolder}/mode-config.json`, JSON.stringify(modeConfig, null, 2))
+   ```
+
+2. **Start Debug** (Phase 3)
+   ```javascript
+   SlashCommand(command=`/workflow:debug-with-file "${bug_description}"`)
+
+   // Update TodoWrite
+   TodoWrite({
+     todos: [
+       { content: "Phase 1: Debug & Analysis", status: "completed" },
+       { content: "Phase 2: Apply Fix from Debug Findings", status: "in_progress" },
+       { content: "Phase 3: Generate & Execute Tests", status: "pending" },
+       { content: "Phase 4: Generate Report", status: "pending" }
+     ]
+   })
+   ```
+
+3. **Apply Fix** (Handled by debug command)
+
+4. **Test Generation & Execution**
+   ```javascript
+   // Auto-continue after debug command completes
+   SlashCommand(command=`/workflow:test-fix-gen "Test validation for: ${bug_description}"`)
+   SlashCommand(command="/workflow:test-cycle-execute")
+   ```
+
+5. **Generate Report** (Phase 5)
+   ```
+   ## Debug-First Workflow Completed
+
+   **Issue**: [bug_description]
+   **Mode**: Debug First
+   **Session**: [sessionId]
+
+   ### Debug Phase Results
+   - Root Cause: [extracted from understanding.md]
+   - Hypothesis Confirmation: [from hypotheses.json]
+   - Fixes Applied: [list of modified files]
+
+   ### Test Phase Results
+   - Tests Created: [test files generated by IMPL-001]
+   - Pass Rate: [final test pass rate]
+   - Iteration Count: [fix iterations]
+
+   ### Key Findings
+   - [learning points from debugging]
+   - [coverage insights from testing]
+   ```
+
+---
+
+### Mode 2: Test First
+
+**Best For**: Implemented code needing test validation
+
+**Workflow**:
+```
+User Input → Session Init → /workflow:test-fix-gen
+                                    ↓
+                           Generate test tasks (IMPL-001, IMPL-002)
+                                    ↓
+                           /workflow:test-cycle-execute
+                                    ↓
+                           Auto-iterate: Test → Analyze Failures → CLI Fix
+                                    ↓
+                           Until pass rate ≥ 95%
+                                    ↓
+                           Generate report
+```
+
+**Execution Steps**:
+
+1. **Session Initialization** (Phase 2)
+   ```javascript
+   const modeConfig = {
+     mode: "test",
+     original_input: bug_description,
+     timestamp: getUtc8ISOString(),
+     flags: { hotfix, autoYes }
+   }
+   ```
+
+2. **Generate Tests** (Phase 3)
+   ```javascript
+   SlashCommand(command=`/workflow:test-fix-gen "${bug_description}"`)
+
+   // Update TodoWrite
+   TodoWrite({
+     todos: [
+       { content: "Phase 1: Generate Tests", status: "completed" },
+       { content: "Phase 2: Execute & Fix Tests", status: "in_progress" },
+       { content: "Phase 3: Final Validation", status: "pending" },
+       { content: "Phase 4: Generate Report", status: "pending" }
+     ]
+   })
+   ```
+
+3. **Execute & Iterate** (Phase 3 cont.)
+   ```javascript
+   SlashCommand(command="/workflow:test-cycle-execute")
+
+   // test-cycle-execute handles:
+   // - Execute tests
+   // - Analyze failures
+   // - Generate fix tasks via CLI
+   // - Iterate fixes until pass
+   ```
+
+4. **Generate Report** (Phase 5)
+
+---
+
+### Mode 3: Bidirectional Verification
+
+**Best For**: Complex systems, multi-dimensional analysis
+
+**Workflow**:
+```
+User Input → Session Init → Parallel execution:
+                    ┌──────────────────────────────┐
+                    │                              │
+                    ↓                              ↓
+         /workflow:debug-with-file    /workflow:test-fix-gen
+                    │                              │
+         Generate hypotheses & understanding    Generate test tasks
+                    │                              │
+                    ↓                              ↓
+              Apply debug fixes       /workflow:test-cycle-execute
+                    │                              │
+                    └──────────────┬───────────────┘
+                                   ↓
+                        Phase 4: Merge Findings
+                    ├─ Converge root cause analyses
+                    ├─ Identify consistency (mutual validation)
+                    ├─ Identify conflicts (need coordination)
+                    └─ Generate unified report
+```
+
+**Execution Steps**:
+
+1. **Parallel Execution** (Phase 3)
+   ```javascript
+   // Start debug
+   const debugTask = SlashCommand(
+     command=`/workflow:debug-with-file "${bug_description}"`,
+     run_in_background=false
+   )
+
+   // Start test generation (synchronous execution, SlashCommand blocks)
+   const testTask = SlashCommand(
+     command=`/workflow:test-fix-gen "${bug_description}"`,
+     run_in_background=false
+   )
+
+   // Execute test cycle
+   const testCycleTask = SlashCommand(
+     command="/workflow:test-cycle-execute",
+     run_in_background=false
+   )
+   ```
+
+2. **Merge Findings** (Phase 4)
+   ```javascript
+   // Read debug results
+   const understandingMd = Read(`${debugSessionFolder}/understanding.md`)
+   const hypothesesJson = JSON.parse(Read(`${debugSessionFolder}/hypotheses.json`))
+
+   // Read test results
+   const testResultsJson = JSON.parse(Read(`${testSessionFolder}/.process/test-results.json`))
+   const fixPlanJson = JSON.parse(Read(`${testSessionFolder}/.task/IMPL-002.json`))
+
+   // Merge analysis
+   const convergence = {
+     debug_root_cause: hypothesesJson.confirmed_hypothesis,
+     test_failure_pattern: testResultsJson.failures,
+     consistency: analyzeConsistency(debugRootCause, testFailures),
+     conflicts: identifyConflicts(debugRootCause, testFailures),
+     unified_root_cause: mergeRootCauses(debugRootCause, testFailures),
+     recommended_fix: selectBestFix(debugRootCause, testRootCause)
+   }
+   ```
+
+3. **Generate Report** (Phase 5)
+   ```
+   ## Bidirectional Verification Workflow Completed
+
+   **Issue**: [bug_description]
+   **Mode**: Bidirectional Verification
+
+   ### Debug Findings
+   - Root Cause (hypothesis): [from understanding.md]
+   - Confidence: [from hypotheses.json]
+   - Key code paths: [file:line]
+
+   ### Test Findings
+   - Failure pattern: [list of failing tests]
+   - Error type: [error type]
+   - Impact scope: [affected modules]
+
+   ### Merged Analysis
+   - ✓ Consistent: Both workflows identified same root cause
+   - ⚠ Conflicts: [list any conflicts]
+   - → Unified Root Cause: [final confirmed root cause]
+
+   ### Recommended Fix
+   - Strategy: [selected fix strategy]
+   - Rationale: [why this strategy]
+   - Risks: [known risks]
+   ```
+
+---
+
+## Command Line Interface
+
+### Complete Syntax
+
+```bash
+/ccw-debug [OPTIONS] <BUG_DESCRIPTION>
+
+Options:
+  --mode <cli|debug|test|bidirectional>  Execution mode (default: debug)
+  --yes, -y                              Auto mode (skip all confirmations)
+  --hotfix, -h                           Production hotfix mode (only for debug mode)
+  --no-tests                             Skip test generation in debug-first mode
+  --skip-report                          Don't generate final report
+  --resume <session-id>                  Resume interrupted session
+
+Arguments:
+  <BUG_DESCRIPTION>                      Issue description, error message, or .md file path
+```
+
+### Examples
+
+```bash
+# CLI quick mode: fastest, recommendation-only (NEW!)
+/ccw-debug --mode cli "User login timeout"
+/ccw-debug --mode cli --yes "Quick fix: API 500 error"  # Auto-apply if high confidence
+
+# Debug first (default)
+/ccw-debug "User login timeout"
+
+# Test first
+/ccw-debug --mode test "Payment validation failure"
+
+# Bidirectional verification
+/ccw-debug --mode bidirectional "Multi-module data consistency issue"
+
+# Hotfix auto mode
+/ccw-debug --hotfix --yes "API 500 error"
+
+# Debug first, skip tests
+/ccw-debug --no-tests "Understand code flow"
+
+# Resume interrupted session
+/ccw-debug --resume CCWD-login-timeout-2025-01-27
+```
+
+---
+
+## Session Structure
+
+### File Organization
+
+```
+.workflow/.ccw-debug/CCWD-{slug}-{date}/
+├── mode-config.json                # Mode configuration and flags
+├── session-manifest.json            # Session index and status
+├── final-report.md                  # Final report
+│
+├── debug/                           # Debug workflow (if mode includes debug)
+│   ├── debug-session-id.txt
+│   ├── understanding.md
+│   ├── hypotheses.json
+│   └── debug.log
+│
+├── test/                            # Test workflow (if mode includes test)
+│   ├── test-session-id.txt
+│   ├── IMPL_PLAN.md
+│   ├── test-results.json
+│   └── iteration-state.json
+│
+└── fusion/                          # Fusion analysis (bidirectional mode)
+    ├── convergence-analysis.json
+    ├── consistency-report.md
+    └── unified-root-cause.json
+```
+
+### Session State Management
+
+```json
+{
+  "session_id": "CCWD-login-timeout-2025-01-27",
+  "mode": "debug|test|bidirectional",
+  "status": "running|completed|failed|paused",
+  "phases": {
+    "phase_1": { "status": "completed", "timestamp": "..." },
+    "phase_2": { "status": "in_progress", "timestamp": "..." },
+    "phase_3": { "status": "pending" },
+    "phase_4": { "status": "pending" },
+    "phase_5": { "status": "pending" }
+  },
+  "sub_sessions": {
+    "debug_session": "DBG-...",
+    "test_session": "WFS-test-..."
+  },
+  "artifacts": {
+    "debug_understanding": "...",
+    "test_results": "...",
+    "fusion_analysis": "..."
+  }
+}
+```
+
+---
+
+## Mode Selection Logic
+
+### Auto Mode Recommendation
+
+When user doesn't specify `--mode`, recommend based on input analysis:
+
+```javascript
+function recommendMode(bugDescription) {
+  const indicators = {
+    cli_signals: [
+      /quick|fast|simple|immediate/,
+      /recommendation|suggest|advice/,
+      /just need|only want|quick look/,
+      /straightforward|obvious|clear/
+    ],
+    debug_signals: [
+      /unclear|don't know|maybe|uncertain|why/,
+      /error|crash|fail|exception|stack trace/,
+      /execution flow|code path|how does/
+    ],
+    test_signals: [
+      /test|coverage|verify|pass|fail/,
+      /implementation|implemented|complete/,
+      /case|scenario|should/
+    ],
+    complex_signals: [
+      /multiple|all|system|integration/,
+      /module|subsystem|network|distributed/,
+      /concurrent|async|race/
+    ]
+  }
+
+  let score = { cli: 0, debug: 0, test: 0, bidirectional: 0 }
+
+  // CLI signals (lightweight preference)
+  for (const pattern of indicators.cli_signals) {
+    if (pattern.test(bugDescription)) score.cli += 3
+  }
+
+  // Debug signals
+  for (const pattern of indicators.debug_signals) {
+    if (pattern.test(bugDescription)) score.debug += 2
+  }
+
+  // Test signals
+  for (const pattern of indicators.test_signals) {
+    if (pattern.test(bugDescription)) score.test += 2
+  }
+
+  // Complex signals (prefer bidirectional for complex issues)
+  for (const pattern of indicators.complex_signals) {
+    if (pattern.test(bugDescription)) {
+      score.bidirectional += 3
+      score.cli -= 2  // Complex issues not suitable for CLI quick
+    }
+  }
+
+  // If description is short and has clear error, prefer CLI
+  if (bugDescription.length < 100 && /error|fail|crash/.test(bugDescription)) {
+    score.cli += 2
+  }
+
+  // Return highest scoring mode
+  return Object.entries(score).sort((a, b) => b[1] - a[1])[0][0]
+}
+```
+
+---
+
+## Best Practices
+
+### When to Use Each Mode
+
+| Issue Characteristic | Recommended Mode | Rationale |
+|----------------------|-----------------|-----------|
+| Simple error, clear symptoms | CLI Quick | Fastest recommendation |
+| Incomplete error info, requires exploration | Debug First | Deep diagnostic capability |
+| Code complete, needs test coverage | Test First | Automated iterative fixes |
+| Cross-module issue, ambiguous symptoms | Bidirectional | Multi-angle insights |
+| Production failure, needs immediate guidance | CLI Quick + --yes | Fastest guidance, optional escalation |
+| Production failure, needs safe fix | Debug First + --hotfix | Minimal diagnosis time |
+| Want to understand why it failed | Debug First | Records understanding evolution |
+| Want to ensure all scenarios pass | Test First | Complete coverage-driven |
+
+### Performance Tips
+
+- **CLI Quick**: 2-5 minutes, no file I/O, recommendation-only
+- **Debug First**: Usually requires manual issue reproduction (after logging added), then 15-30 min
+- **Test First**: Fully automated, 20-45 min depending on test suite size
+- **Bidirectional**: Most comprehensive but slowest (parallel workflows), 30-60 min
+
+### Workflow Continuity
+
+- **CLI Quick**: Can escalate to debug/test/apply fix based on user decision
+- **Debug First**: Auto-launches test generation and execution after completion
+- **Test First**: With high failure rates suggests switching to debug mode for root cause
+- **Bidirectional**: Always executes complete flow
+
+---
+
+## Follow-up Expansion
+
+After completion, offer to expand to issues:
+
+```
+## Done! What's next?
+
+- [ ] Create Test issue (improve test coverage)
+- [ ] Create Enhancement issue (optimize code quality)
+- [ ] Create Refactor issue (improve architecture)
+- [ ] Create Documentation issue (record learnings)
+- [ ] Don't create any issue, end workflow
+```
+
+Selected items call: `/issue:new "{issue summary} - {dimension}"`
+
+---
+
+## Error Handling
+
+| Error | CLI Quick | Debug First | Test First | Bidirectional |
+|-------|-----------|-------------|-----------|---------------|
+| Session creation failed | N/A (no session) | Retry → abort | Retry → abort | Retry → abort |
+| CLI analysis failed | Retry with fallback tool → manual | N/A | N/A | N/A |
+| Diagnosis/test failed | N/A | Continue with partial results | Direct failure | Use alternate workflow results |
+| Low confidence result | Ask escalate or review | N/A | N/A | N/A |
+| Merge conflicts | N/A | N/A | N/A | Select highest confidence plan |
+| Fix application failed | Report error, no auto-retry | Request manual fix | Mark failed, request intervention | Try alternative plan |
+
+---
+
+## Relationship with ccw Command
+
+| Feature | ccw | ccw-debug |
+|---------|-----|----------|
+| **Design** | General workflow orchestration | Debug + test aggregation |
+| **Intent Detection** | ✅ Detects task type | ✅ Detects issue type |
+| **Automation** | ✅ Auto-selects workflow | ✅ Auto-selects mode |
+| **Quick Mode** | ❌ None | ✅ CLI Quick (2-5 min) |
+| **Parallel Execution** | ❌ Sequential | ✅ Bidirectional mode parallel |
+| **Fusion Analysis** | ❌ None | ✅ Bidirectional mode fusion |
+| **Workflow Scope** | Broad (feature/bugfix/tdd/ui etc.) | Deep focus (debug + test) |
+| **CLI Integration** | Yes | Yes (4 levels: quick/deep/iterative/fusion) |
+
+---
+
+## Usage Recommendations
+
+1. **First Time**: Use default mode (debug-first), observe workflow
+2. **Quick Decision**: Use CLI Quick (--mode cli) for immediate recommendations
+3. **Quick Fix**: Use `--hotfix --yes` for minimal diagnostics (debug mode)
+4. **Learning**: Use debug-first, read `understanding.md`
+5. **Complete Validation**: Use bidirectional for multi-dimensional insights
+6. **Auto Repair**: Use test-first for automatic iteration
+7. **Escalation**: Start with CLI Quick, escalate to other modes as needed
+
+---
+
+## Reference
+
+### Related Commands
+
+- `ccw cli` - Direct CLI analysis (used by CLI Quick mode)
+- `/workflow:debug-with-file` - Deep debug diagnostics
+- `/workflow:test-fix-gen` - Test generation
+- `/workflow:test-cycle-execute` - Test execution
+- `/workflow:lite-fix` - Lightweight fix
+- `/ccw` - General workflow orchestration
+
+### Configuration Files
+
+- `~/.claude/cli-tools.json` - CLI tool configuration (Gemini/Qwen/Codex)
+- `.workflow/project-tech.json` - Project technology stack
+- `.workflow/project-guidelines.json` - Project conventions
+
+### CLI Tool Fallback Chain (for CLI Quick mode)
+
+When CLI analysis fails, fallback order:
+1. **Gemini** (primary): `gemini-2.5-pro`
+2. **Qwen** (fallback): `coder-model`
+3. **Codex** (fallback): `gpt-5.2`
+
+---
+
+## Summary: Mode Selection Decision Tree
+
+```
+User calls: /ccw-debug <bug_description>
+
+┌─ Explicit --mode specified?
+│  ├─ YES → Use specified mode
+│  │         ├─ cli → 2-5 min analysis, optionally escalate
+│  │         ├─ debug → Full debug-with-file workflow
+│  │         ├─ test → Test-first workflow
+│  │         └─ bidirectional → Parallel debug + test
+│  │
+│  └─ NO → Auto-recommend based on bug description
+│          ├─ Keywords: "quick", "fast", "simple" → CLI Quick
+│          ├─ Keywords: "error", "crash", "exception" → Debug First (or CLI if simple)
+│          ├─ Keywords: "test", "verify", "coverage" → Test First
+│          └─ Keywords: "multiple", "system", "distributed" → Bidirectional
+│
+├─ Check --yes flag
+│  ├─ YES → Auto-confirm all decisions
+│  │         ├─ CLI mode: Auto-apply if confidence High
+│  │         └─ Others: Auto-select default options
+│  │
+│  └─ NO → Interactive mode, ask user for confirmations
+│
+├─ Check --hotfix flag (debug mode only)
+│  ├─ YES → Minimal diagnostics, fast fix
+│  └─ NO → Full analysis
+│
+└─ Execute selected mode workflow
+   └─ Return results or escalation options
+```

.claude/commands/ccw.md

@@ -0,0 +1,567 @@
+---
+name: ccw
+description: Main workflow orchestrator - analyze intent, select workflow, execute command chain in main process
+argument-hint: "\"task description\""
+allowed-tools: SlashCommand(*), TodoWrite(*), AskUserQuestion(*), Read(*), Grep(*), Glob(*)
+---
+
+# CCW Command - Main Workflow Orchestrator
+
+Main process orchestrator: intent analysis → workflow selection → command chain execution.
+
+## Core Concept: Minimum Execution Units (最小执行单元)
+
+**Definition**: A set of commands that must execute together as an atomic group to achieve a meaningful workflow milestone.
+
+**Why This Matters**:
+- **Prevents Incomplete States**: Avoid stopping after task generation without execution
+- **User Experience**: User gets complete results, not intermediate artifacts requiring manual follow-up
+- **Workflow Integrity**: Maintains logical coherence of multi-step operations
+
+**Key Units in CCW**:
+
+| Unit Type | Pattern | Example |
+|-----------|---------|---------|
+| **Planning + Execution** | plan-cmd → execute-cmd | lite-plan → lite-execute |
+| **Testing** | test-gen-cmd → test-exec-cmd | test-fix-gen → test-cycle-execute |
+| **Review** | review-cmd → fix-cmd | review-session-cycle → review-cycle-fix |
+
+**Atomic Rules**:
+1. CCW automatically groups commands into minimum units - never splits them
+2. Pipeline visualization shows units with `【 】` markers
+3. Error handling preserves unit boundaries (retry/skip affects whole unit)
+
+## Execution Model
+
+**Synchronous (Main Process)**: Commands execute via SlashCommand in main process, blocking until complete.
+
+```
+User Input → Analyze Intent → Select Workflow → [Confirm] → Execute Chain
+                                                              ↓
+                                                    SlashCommand (blocking)
+                                                              ↓
+                                                    Update TodoWrite
+                                                              ↓
+                                                    Next Command...
+```
+
+**vs ccw-coordinator**: External CLI execution with background tasks and hook callbacks.
+
+## 5-Phase Workflow
+
+### Phase 1: Analyze Intent
+
+```javascript
+function analyzeIntent(input) {
+  return {
+    goal: extractGoal(input),
+    scope: extractScope(input),
+    constraints: extractConstraints(input),
+    task_type: detectTaskType(input),       // bugfix|feature|tdd|review|exploration|...
+    complexity: assessComplexity(input),    // low|medium|high
+    clarity_score: calculateClarity(input)  // 0-3 (>=2 = clear)
+  };
+}
+
+// Task type detection (priority order)
+function detectTaskType(text) {
+  const patterns = {
+    'bugfix-hotfix': /urgent|production|critical/ && /fix|bug/,
+    // With-File workflows (documented exploration with multi-CLI collaboration)
+    'brainstorm': /brainstorm|ideation|头脑风暴|创意|发散思维|creative thinking|multi-perspective.*think|compare perspectives|探索.*可能/,
+    'brainstorm-to-issue': /brainstorm.*issue|头脑风暴.*issue|idea.*issue|想法.*issue|从.*头脑风暴|convert.*brainstorm/,
+    'debug-file': /debug.*document|hypothesis.*debug|troubleshoot.*track|investigate.*log|调试.*记录|假设.*验证|systematic debug|深度调试/,
+    'analyze-file': /analyze.*document|explore.*concept|understand.*architecture|investigate.*discuss|collaborative analysis|分析.*讨论|深度.*理解|协作.*分析/,
+    // Standard workflows
+    'bugfix': /fix|bug|error|crash|fail|debug/,
+    'issue-batch': /issues?|batch/ && /fix|resolve/,
+    'issue-transition': /issue workflow|structured workflow|queue|multi-stage/,
+    'exploration': /uncertain|explore|research|what if/,
+    'quick-task': /quick|simple|small/ && /feature|function/,
+    'ui-design': /ui|design|component|style/,
+    'tdd': /tdd|test-driven|test first/,
+    'test-fix': /test fail|fix test|failing test/,
+    'review': /review|code review/,
+    'documentation': /docs|documentation|readme/
+  };
+  for (const [type, pattern] of Object.entries(patterns)) {
+    if (pattern.test(text)) return type;
+  }
+  return 'feature';
+}
+```
+
+**Output**: `Type: [task_type] | Goal: [goal] | Complexity: [complexity] | Clarity: [clarity_score]/3`
+
+---
+
+### Phase 1.5: Requirement Clarification (if clarity_score < 2)
+
+```javascript
+async function clarifyRequirements(analysis) {
+  if (analysis.clarity_score >= 2) return analysis;
+
+  const questions = generateClarificationQuestions(analysis);  // Goal, Scope, Constraints
+  const answers = await AskUserQuestion({ questions });
+  return updateAnalysis(analysis, answers);
+}
+```
+
+**Questions**: Goal (Create/Fix/Optimize/Analyze), Scope (Single file/Module/Cross-module/System), Constraints (Backward compat/Skip tests/Urgent hotfix)
+
+---
+
+### Phase 2: Select Workflow & Build Command Chain
+
+```javascript
+function selectWorkflow(analysis) {
+  const levelMap = {
+    'bugfix-hotfix':     { level: 2, flow: 'bugfix.hotfix' },
+    // With-File workflows (documented exploration with multi-CLI collaboration)
+    'brainstorm':        { level: 4, flow: 'brainstorm-with-file' },   // Multi-perspective ideation
+    'brainstorm-to-issue': { level: 4, flow: 'brainstorm-to-issue' }, // Brainstorm → Issue workflow
+    'debug-file':        { level: 3, flow: 'debug-with-file' },         // Hypothesis-driven debugging
+    'analyze-file':      { level: 3, flow: 'analyze-with-file' },       // Collaborative analysis
+    // Standard workflows
+    'bugfix':            { level: 2, flow: 'bugfix.standard' },
+    'issue-batch':       { level: 'Issue', flow: 'issue' },
+    'issue-transition':  { level: 2.5, flow: 'rapid-to-issue' },  // Bridge workflow
+    'exploration':       { level: 4, flow: 'full' },
+    'quick-task':        { level: 1, flow: 'lite-lite-lite' },
+    'ui-design':         { level: analysis.complexity === 'high' ? 4 : 3, flow: 'ui' },
+    'tdd':               { level: 3, flow: 'tdd' },
+    'test-fix':          { level: 3, flow: 'test-fix-gen' },
+    'review':            { level: 3, flow: 'review-cycle-fix' },
+    'documentation':     { level: 2, flow: 'docs' },
+    'feature':           { level: analysis.complexity === 'high' ? 3 : 2, flow: analysis.complexity === 'high' ? 'coupled' : 'rapid' }
+  };
+
+  const selected = levelMap[analysis.task_type] || levelMap['feature'];
+  return buildCommandChain(selected, analysis);
+}
+
+// Build command chain (port-based matching with Minimum Execution Units)
+function buildCommandChain(workflow, analysis) {
+  const chains = {
+    // Level 1 - Rapid
+    'lite-lite-lite': [
+      { cmd: '/workflow:lite-lite-lite', args: `"${analysis.goal}"` }
+    ],
+
+    // Level 2 - Lightweight
+    'rapid': [
+      // Unit: Quick Implementation【lite-plan → lite-execute】
+      { cmd: '/workflow:lite-plan', args: `"${analysis.goal}"`, unit: 'quick-impl' },
+      { cmd: '/workflow:lite-execute', args: '--in-memory', unit: 'quick-impl' },
+      // Unit: Test Validation【test-fix-gen → test-cycle-execute】
+      ...(analysis.constraints?.includes('skip-tests') ? [] : [
+        { cmd: '/workflow:test-fix-gen', args: '', unit: 'test-validation' },
+        { cmd: '/workflow:test-cycle-execute', args: '', unit: 'test-validation' }
+      ])
+    ],
+
+    // Level 2 Bridge - Lightweight to Issue Workflow
+    'rapid-to-issue': [
+      // Unit: Quick Implementation【lite-plan → convert-to-plan】
+      { cmd: '/workflow:lite-plan', args: `"${analysis.goal}"`, unit: 'quick-impl-to-issue' },
+      { cmd: '/issue:convert-to-plan', args: '--latest-lite-plan -y', unit: 'quick-impl-to-issue' },
+      // Auto-continue to issue workflow
+      { cmd: '/issue:queue', args: '' },
+      { cmd: '/issue:execute', args: '--queue auto' }
+    ],
+
+    'bugfix.standard': [
+      // Unit: Bug Fix【lite-fix → lite-execute】
+      { cmd: '/workflow:lite-fix', args: `"${analysis.goal}"`, unit: 'bug-fix' },
+      { cmd: '/workflow:lite-execute', args: '--in-memory', unit: 'bug-fix' },
+      // Unit: Test Validation【test-fix-gen → test-cycle-execute】
+      ...(analysis.constraints?.includes('skip-tests') ? [] : [
+        { cmd: '/workflow:test-fix-gen', args: '', unit: 'test-validation' },
+        { cmd: '/workflow:test-cycle-execute', args: '', unit: 'test-validation' }
+      ])
+    ],
+
+    'bugfix.hotfix': [
+      { cmd: '/workflow:lite-fix', args: `--hotfix "${analysis.goal}"` }
+    ],
+
+    'multi-cli-plan': [
+      // Unit: Multi-CLI Planning【multi-cli-plan → lite-execute】
+      { cmd: '/workflow:multi-cli-plan', args: `"${analysis.goal}"`, unit: 'multi-cli' },
+      { cmd: '/workflow:lite-execute', args: '--in-memory', unit: 'multi-cli' },
+      // Unit: Test Validation【test-fix-gen → test-cycle-execute】
+      ...(analysis.constraints?.includes('skip-tests') ? [] : [
+        { cmd: '/workflow:test-fix-gen', args: '', unit: 'test-validation' },
+        { cmd: '/workflow:test-cycle-execute', args: '', unit: 'test-validation' }
+      ])
+    ],
+
+    'docs': [
+      // Unit: Quick Implementation【lite-plan → lite-execute】
+      { cmd: '/workflow:lite-plan', args: `"${analysis.goal}"`, unit: 'quick-impl' },
+      { cmd: '/workflow:lite-execute', args: '--in-memory', unit: 'quick-impl' }
+    ],
+
+    // With-File workflows (documented exploration with multi-CLI collaboration)
+    'brainstorm-with-file': [
+      { cmd: '/workflow:brainstorm-with-file', args: `"${analysis.goal}"` }
+      // Note: Has built-in post-completion options (create plan, create issue, deep analysis)
+    ],
+
+    // Brainstorm-to-Issue workflow (bridge from brainstorm to issue execution)
+    'brainstorm-to-issue': [
+      // Note: Assumes brainstorm session already exists, or run brainstorm first
+      { cmd: '/issue:from-brainstorm', args: `SESSION="${extractBrainstormSession(analysis)}" --auto` },
+      { cmd: '/issue:queue', args: '' },
+      { cmd: '/issue:execute', args: '--queue auto' }
+    ],
+
+    'debug-with-file': [
+      { cmd: '/workflow:debug-with-file', args: `"${analysis.goal}"` }
+      // Note: Self-contained with hypothesis-driven iteration and Gemini validation
+    ],
+
+    'analyze-with-file': [
+      { cmd: '/workflow:analyze-with-file', args: `"${analysis.goal}"` }
+      // Note: Self-contained with multi-round discussion and CLI exploration
+    ],
+
+    // Level 3 - Standard
+    'coupled': [
+      // Unit: Verified Planning【plan → plan-verify】
+      { cmd: '/workflow:plan', args: `"${analysis.goal}"`, unit: 'verified-planning' },
+      { cmd: '/workflow:plan-verify', args: '', unit: 'verified-planning' },
+      // Execution
+      { cmd: '/workflow:execute', args: '' },
+      // Unit: Code Review【review-session-cycle → review-cycle-fix】
+      { cmd: '/workflow:review-session-cycle', args: '', unit: 'code-review' },
+      { cmd: '/workflow:review-cycle-fix', args: '', unit: 'code-review' },
+      // Unit: Test Validation【test-fix-gen → test-cycle-execute】
+      ...(analysis.constraints?.includes('skip-tests') ? [] : [
+        { cmd: '/workflow:test-fix-gen', args: '', unit: 'test-validation' },
+        { cmd: '/workflow:test-cycle-execute', args: '', unit: 'test-validation' }
+      ])
+    ],
+
+    'tdd': [
+      // Unit: TDD Planning + Execution【tdd-plan → execute】
+      { cmd: '/workflow:tdd-plan', args: `"${analysis.goal}"`, unit: 'tdd-planning' },
+      { cmd: '/workflow:execute', args: '', unit: 'tdd-planning' },
+      // TDD Verification
+      { cmd: '/workflow:tdd-verify', args: '' }
+    ],
+
+    'test-fix-gen': [
+      // Unit: Test Validation【test-fix-gen → test-cycle-execute】
+      { cmd: '/workflow:test-fix-gen', args: `"${analysis.goal}"`, unit: 'test-validation' },
+      { cmd: '/workflow:test-cycle-execute', args: '', unit: 'test-validation' }
+    ],
+
+    'review-cycle-fix': [
+      // Unit: Code Review【review-session-cycle → review-cycle-fix】
+      { cmd: '/workflow:review-session-cycle', args: '', unit: 'code-review' },
+      { cmd: '/workflow:review-cycle-fix', args: '', unit: 'code-review' },
+      // Unit: Test Validation【test-fix-gen → test-cycle-execute】
+      { cmd: '/workflow:test-fix-gen', args: '', unit: 'test-validation' },
+      { cmd: '/workflow:test-cycle-execute', args: '', unit: 'test-validation' }
+    ],
+
+    'ui': [
+      { cmd: '/workflow:ui-design:explore-auto', args: `"${analysis.goal}"` },
+      // Unit: Planning + Execution【plan → execute】
+      { cmd: '/workflow:plan', args: '', unit: 'plan-execute' },
+      { cmd: '/workflow:execute', args: '', unit: 'plan-execute' }
+    ],
+
+    // Level 4 - Brainstorm
+    'full': [
+      { cmd: '/workflow:brainstorm:auto-parallel', args: `"${analysis.goal}"` },
+      // Unit: Verified Planning【plan → plan-verify】
+      { cmd: '/workflow:plan', args: '', unit: 'verified-planning' },
+      { cmd: '/workflow:plan-verify', args: '', unit: 'verified-planning' },
+      // Execution
+      { cmd: '/workflow:execute', args: '' },
+      // Unit: Test Validation【test-fix-gen → test-cycle-execute】
+      { cmd: '/workflow:test-fix-gen', args: '', unit: 'test-validation' },
+      { cmd: '/workflow:test-cycle-execute', args: '', unit: 'test-validation' }
+    ],
+
+    // Issue Workflow
+    'issue': [
+      { cmd: '/issue:discover', args: '' },
+      { cmd: '/issue:plan', args: '--all-pending' },
+      { cmd: '/issue:queue', args: '' },
+      { cmd: '/issue:execute', args: '' }
+    ]
+  };
+
+  return chains[workflow.flow] || chains['rapid'];
+}
+```
+
+**Output**: `Level [X] - [flow] | Pipeline: [...] | Commands: [1. /cmd1 2. /cmd2 ...]`
+
+---
+
+### Phase 3: User Confirmation
+
+```javascript
+async function getUserConfirmation(chain) {
+  const response = await AskUserQuestion({
+    questions: [{
+      question: "Execute this command chain?",
+      header: "Confirm",
+      options: [
+        { label: "Confirm", description: "Start" },
+        { label: "Adjust", description: "Modify" },
+        { label: "Cancel", description: "Abort" }
+      ]
+    }]
+  });
+
+  if (response.error === "Cancel") throw new Error("Cancelled");
+  if (response.error === "Adjust") return await adjustChain(chain);
+  return chain;
+}
+```
+
+---
+
+### Phase 4: Setup TODO Tracking
+
+```javascript
+function setupTodoTracking(chain, workflow) {
+  const todos = chain.map((step, i) => ({
+    content: `CCW:${workflow}: [${i + 1}/${chain.length}] ${step.cmd}`,
+    status: i === 0 ? 'in_progress' : 'pending',
+    activeForm: `Executing ${step.cmd}`
+  }));
+  TodoWrite({ todos });
+}
+```
+
+**Output**: `-> CCW:rapid: [1/3] /workflow:lite-plan | CCW:rapid: [2/3] /workflow:lite-execute | ...`
+
+---
+
+### Phase 5: Execute Command Chain
+
+```javascript
+async function executeCommandChain(chain, workflow) {
+  let previousResult = null;
+
+  for (let i = 0; i < chain.length; i++) {
+    try {
+      const fullCommand = assembleCommand(chain[i], previousResult);
+      const result = await SlashCommand({ command: fullCommand });
+
+      previousResult = { ...result, success: true };
+      updateTodoStatus(i, chain.length, workflow, 'completed');
+
+    } catch (error) {
+      const action = await handleError(chain[i], error, i);
+      if (action === 'retry') {
+        i--;  // Retry
+      } else if (action === 'abort') {
+        return { success: false, error: error.message };
+      }
+      // 'skip' - continue
+    }
+  }
+
+  return { success: true, completed: chain.length };
+}
+
+// Assemble full command with session/plan parameters
+function assembleCommand(step, previousResult) {
+  let command = step.cmd;
+  if (step.args) {
+    command += ` ${step.args}`;
+  } else if (previousResult?.session_id) {
+    command += ` --session="${previousResult.session_id}"`;
+  }
+  return command;
+}
+
+// Update TODO: mark current as complete, next as in-progress
+function updateTodoStatus(index, total, workflow, status) {
+  const todos = getAllCurrentTodos();
+  const updated = todos.map(todo => {
+    if (todo.content.startsWith(`CCW:${workflow}:`)) {
+      const stepNum = extractStepIndex(todo.content);
+      if (stepNum === index + 1) return { ...todo, status };
+      if (stepNum === index + 2 && status === 'completed') return { ...todo, status: 'in_progress' };
+    }
+    return todo;
+  });
+  TodoWrite({ todos: updated });
+}
+
+// Error handling: Retry/Skip/Abort
+async function handleError(step, error, index) {
+  const response = await AskUserQuestion({
+    questions: [{
+      question: `${step.cmd} failed: ${error.message}`,
+      header: "Error",
+      options: [
+        { label: "Retry", description: "Re-execute" },
+        { label: "Skip", description: "Continue next" },
+        { label: "Abort", description: "Stop" }
+      ]
+    }]
+  });
+  return { Retry: 'retry', Skip: 'skip', Abort: 'abort' }[response.Error] || 'abort';
+}
+```
+
+---
+
+## Execution Flow Summary
+
+```
+User Input
+    |
+Phase 1: Analyze Intent
+    |-- Extract: goal, scope, constraints, task_type, complexity, clarity
+    +-- If clarity < 2 -> Phase 1.5: Clarify Requirements
+    |
+Phase 2: Select Workflow & Build Chain
+    |-- Map task_type -> Level (1/2/3/4/Issue)
+    |-- Select flow based on complexity
+    +-- Build command chain (port-based)
+    |
+Phase 3: User Confirmation (optional)
+    |-- Show pipeline visualization
+    +-- Allow adjustment
+    |
+Phase 4: Setup TODO Tracking
+    +-- Create todos with CCW prefix
+    |
+Phase 5: Execute Command Chain
+    |-- For each command:
+    |   |-- Assemble full command
+    |   |-- Execute via SlashCommand
+    |   |-- Update TODO status
+    |   +-- Handle errors (retry/skip/abort)
+    +-- Return workflow result
+```
+
+---
+
+## Pipeline Examples (with Minimum Execution Units)
+
+**Note**: `【 】` marks Minimum Execution Units - commands execute together as atomic groups.
+
+| Input | Type | Level | Pipeline (with Units) |
+|-------|------|-------|-----------------------|
+| "Add API endpoint" | feature (low) | 2 |【lite-plan → lite-execute】→【test-fix-gen → test-cycle-execute】|
+| "Fix login timeout" | bugfix | 2 |【lite-fix → lite-execute】→【test-fix-gen → test-cycle-execute】|
+| "Use issue workflow" | issue-transition | 2.5 |【lite-plan → convert-to-plan】→ queue → execute |
+| "头脑风暴: 通知系统重构" | brainstorm | 4 | brainstorm-with-file → (built-in post-completion) |
+| "从头脑风暴创建 issue" | brainstorm-to-issue | 4 | from-brainstorm → queue → execute |
+| "深度调试 WebSocket 连接断开" | debug-file | 3 | debug-with-file → (hypothesis iteration) |
+| "协作分析: 认证架构优化" | analyze-file | 3 | analyze-with-file → (multi-round discussion) |
+| "OAuth2 system" | feature (high) | 3 |【plan → plan-verify】→ execute →【review-session-cycle → review-cycle-fix】→【test-fix-gen → test-cycle-execute】|
+| "Implement with TDD" | tdd | 3 |【tdd-plan → execute】→ tdd-verify |
+| "Uncertain: real-time arch" | exploration | 4 | brainstorm:auto-parallel →【plan → plan-verify】→ execute →【test-fix-gen → test-cycle-execute】|
+
+---
+
+## Key Design Principles
+
+1. **Main Process Execution** - Use SlashCommand in main process, no external CLI
+2. **Intent-Driven** - Auto-select workflow based on task intent
+3. **Port-Based Chaining** - Build command chain using port matching
+4. **Minimum Execution Units** - Commands grouped into atomic units, never split (e.g., lite-plan → lite-execute)
+5. **Progressive Clarification** - Low clarity triggers clarification phase
+6. **TODO Tracking** - Use CCW prefix to isolate workflow todos
+7. **Unit-Aware Error Handling** - Retry/skip/abort affects whole unit, not individual commands
+8. **User Control** - Optional user confirmation at each phase
+
+---
+
+## State Management
+
+**TodoWrite-Based Tracking**: All execution state tracked via TodoWrite with `CCW:` prefix.
+
+```javascript
+// Initial state
+todos = [
+  { content: "CCW:rapid: [1/3] /workflow:lite-plan", status: "in_progress" },
+  { content: "CCW:rapid: [2/3] /workflow:lite-execute", status: "pending" },
+  { content: "CCW:rapid: [3/3] /workflow:test-cycle-execute", status: "pending" }
+];
+
+// After command 1 completes
+todos = [
+  { content: "CCW:rapid: [1/3] /workflow:lite-plan", status: "completed" },
+  { content: "CCW:rapid: [2/3] /workflow:lite-execute", status: "in_progress" },
+  { content: "CCW:rapid: [3/3] /workflow:test-cycle-execute", status: "pending" }
+];
+```
+
+**vs ccw-coordinator**: Extensive state.json with task_id, status transitions, hook callbacks.
+
+---
+
+## With-File Workflows
+
+**With-File workflows** provide documented exploration with multi-CLI collaboration. They are self-contained and generate comprehensive session artifacts.
+
+| Workflow | Purpose | Key Features | Output Folder |
+|----------|---------|--------------|---------------|
+| **brainstorm-with-file** | Multi-perspective ideation | Gemini/Codex/Claude perspectives, diverge-converge cycles | `.workflow/.brainstorm/` |
+| **debug-with-file** | Hypothesis-driven debugging | Gemini validation, understanding evolution, NDJSON logging | `.workflow/.debug/` |
+| **analyze-with-file** | Collaborative analysis | Multi-round Q&A, CLI exploration, documented discussions | `.workflow/.analysis/` |
+
+**Detection Keywords**:
+- **brainstorm**: 头脑风暴, 创意, 发散思维, multi-perspective, compare perspectives
+- **debug-file**: 深度调试, 假设验证, systematic debug, hypothesis debug
+- **analyze-file**: 协作分析, 深度理解, collaborative analysis, explore concept
+
+**Characteristics**:
+1. **Self-Contained**: Each workflow handles its own iteration loop
+2. **Documented Process**: Creates evolving documents (brainstorm.md, understanding.md, discussion.md)
+3. **Multi-CLI**: Uses Gemini/Codex/Claude for different perspectives
+4. **Built-in Post-Completion**: Offers follow-up options (create plan, issue, etc.)
+
+---
+
+## Type Comparison: ccw vs ccw-coordinator
+
+| Aspect | ccw | ccw-coordinator |
+|--------|-----|-----------------|
+| **Type** | Main process (SlashCommand) | External CLI (ccw cli + hook callbacks) |
+| **Execution** | Synchronous blocking | Async background with hook completion |
+| **Workflow** | Auto intent-based selection | Manual chain building |
+| **Intent Analysis** | 5-phase clarity check | 3-phase requirement analysis |
+| **State** | TodoWrite only (in-memory) | state.json + checkpoint/resume |
+| **Error Handling** | Retry/skip/abort (interactive) | Retry/skip/abort (via AskUser) |
+| **Use Case** | Auto workflow for any task | Manual orchestration, large chains |
+
+---
+
+## Usage
+
+```bash
+# Auto-select workflow
+ccw "Add user authentication"
+
+# Complex requirement (triggers clarification)
+ccw "Optimize system performance"
+
+# Bug fix
+ccw "Fix memory leak in WebSocket handler"
+
+# TDD development
+ccw "Implement user registration with TDD"
+
+# Exploratory task
+ccw "Uncertain about architecture for real-time notifications"
+
+# With-File workflows (documented exploration with multi-CLI collaboration)
+ccw "头脑风暴: 用户通知系统重新设计"           # → brainstorm-with-file
+ccw "从头脑风暴 BS-通知系统-2025-01-28 创建 issue"  # → brainstorm-to-issue (bridge)
+ccw "深度调试: 系统随机崩溃问题"              # → debug-with-file
+ccw "协作分析: 理解现有认证架构的设计决策"     # → analyze-with-file
+```

.claude/commands/cli/cli-init.md

@@ -3,6 +3,7 @@ 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(*)
+group: cli
 ---
 
 # CLI Initialization Command (/cli:cli-init)
@@ -191,7 +192,7 @@ target/
 ### Step 2: Workspace Analysis (MANDATORY FIRST)
 ```bash
 # Analyze workspace structure
-bash(~/.claude/scripts/get_modules_by_depth.sh json)
+bash(ccw tool exec get_modules_by_depth '{"format":"json"}')
 ```
 
 ### Step 3: Technology Detection

.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/enhance-prompt.md

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

.claude/commands/issue/convert-to-plan.md

@@ -0,0 +1,718 @@
+---
+name: convert-to-plan
+description: Convert planning artifacts (lite-plan, workflow session, markdown) to issue solutions
+argument-hint: "[-y|--yes] [--issue <id>] [--supplement] <SOURCE>"
+allowed-tools: TodoWrite(*), Bash(*), Read(*), Write(*), Glob(*), AskUserQuestion(*)
+---
+
+## Auto Mode
+
+When `--yes` or `-y`: Skip confirmation, auto-create issue and bind solution.
+
+# Issue Convert-to-Plan Command (/issue:convert-to-plan)
+
+## Overview
+
+Converts various planning artifact formats into issue workflow solutions with intelligent detection and automatic binding.
+
+**Supported Sources** (auto-detected):
+- **lite-plan**: `.workflow/.lite-plan/{slug}/plan.json`
+- **workflow-session**: `WFS-xxx` ID or `.workflow/active/{session}/` folder
+- **markdown**: Any `.md` file with implementation/task content
+- **json**: Direct JSON files matching plan-json-schema
+
+## Quick Reference
+
+```bash
+# Convert lite-plan to new issue (auto-creates issue)
+/issue:convert-to-plan ".workflow/.lite-plan/implement-auth-2026-01-25"
+
+# Convert workflow session to existing issue
+/issue:convert-to-plan WFS-auth-impl --issue GH-123
+
+# Supplement existing solution with additional tasks
+/issue:convert-to-plan "./docs/additional-tasks.md" --issue ISS-001 --supplement
+
+# Auto mode - skip confirmations
+/issue:convert-to-plan ".workflow/.lite-plan/my-plan" -y
+```
+
+## Command Options
+
+| Option | Description | Default |
+|--------|-------------|---------|
+| `<SOURCE>` | Planning artifact path or WFS-xxx ID | Required |
+| `--issue <id>` | Bind to existing issue instead of creating new | Auto-create |
+| `--supplement` | Add tasks to existing solution (requires --issue) | false |
+| `-y, --yes` | Skip all confirmations | false |
+
+## Core Data Access Principle
+
+**⚠️ Important**: Use CLI commands for all issue/solution operations.
+
+| Operation | Correct | Incorrect |
+|-----------|---------|-----------|
+| Get issue | `ccw issue status <id> --json` | Read issues.jsonl directly |
+| Create issue | `ccw issue init <id> --title "..."` | Write to issues.jsonl |
+| Bind solution | `ccw issue bind <id> <sol-id>` | Edit issues.jsonl |
+| List solutions | `ccw issue solutions --issue <id> --brief` | Read solutions/*.jsonl |
+
+## Solution Schema Reference
+
+Target format for all extracted data (from solution-schema.json):
+
+```typescript
+interface Solution {
+  id: string;                    // SOL-{issue-id}-{4-char-uid}
+  description?: string;          // High-level summary
+  approach?: string;             // Technical strategy
+  tasks: Task[];                 // Required: at least 1 task
+  exploration_context?: object;  // Optional: source context
+  analysis?: { risk, impact, complexity };
+  score?: number;                // 0.0-1.0
+  is_bound: boolean;
+  created_at: string;
+  bound_at?: string;
+}
+
+interface Task {
+  id: string;                    // T1, T2, T3... (pattern: ^T[0-9]+$)
+  title: string;                 // Required: action verb + target
+  scope: string;                 // Required: module path or feature area
+  action: Action;                // Required: Create|Update|Implement|...
+  description?: string;
+  modification_points?: Array<{file, target, change}>;
+  implementation: string[];      // Required: step-by-step guide
+  test?: { unit?, integration?, commands?, coverage_target? };
+  acceptance: { criteria: string[], verification: string[] };  // Required
+  commit?: { type, scope, message_template, breaking? };
+  depends_on?: string[];
+  priority?: number;             // 1-5 (default: 3)
+}
+
+type Action = 'Create' | 'Update' | 'Implement' | 'Refactor' | 'Add' | 'Delete' | 'Configure' | 'Test' | 'Fix';
+```
+
+## Implementation
+
+### Phase 1: Parse Arguments & Detect Source Type
+
+```javascript
+const input = userInput.trim();
+const flags = parseFlags(userInput);  // --issue, --supplement, -y/--yes
+
+// Extract source path (first non-flag argument)
+const source = extractSourceArg(input);
+
+// Detect source type
+function detectSourceType(source) {
+  // Check for WFS-xxx pattern (workflow session ID)
+  if (source.match(/^WFS-[\w-]+$/)) {
+    return { type: 'workflow-session-id', path: `.workflow/active/${source}` };
+  }
+
+  // Check if directory
+  const isDir = Bash(`test -d "${source}" && echo "dir" || echo "file"`).trim() === 'dir';
+
+  if (isDir) {
+    // Check for lite-plan indicator
+    const hasPlanJson = Bash(`test -f "${source}/plan.json" && echo "yes" || echo "no"`).trim() === 'yes';
+    if (hasPlanJson) {
+      return { type: 'lite-plan', path: source };
+    }
+
+    // Check for workflow session indicator
+    const hasSession = Bash(`test -f "${source}/workflow-session.json" && echo "yes" || echo "no"`).trim() === 'yes';
+    if (hasSession) {
+      return { type: 'workflow-session', path: source };
+    }
+  }
+
+  // Check file extensions
+  if (source.endsWith('.json')) {
+    return { type: 'json-file', path: source };
+  }
+  if (source.endsWith('.md')) {
+    return { type: 'markdown-file', path: source };
+  }
+
+  // Check if path exists at all
+  const exists = Bash(`test -e "${source}" && echo "yes" || echo "no"`).trim() === 'yes';
+  if (!exists) {
+    throw new Error(`E001: Source not found: ${source}`);
+  }
+
+  return { type: 'unknown', path: source };
+}
+
+const sourceInfo = detectSourceType(source);
+if (sourceInfo.type === 'unknown') {
+  throw new Error(`E002: Unable to detect source format for: ${source}`);
+}
+
+console.log(`Detected source type: ${sourceInfo.type}`);
+```
+
+### Phase 2: Extract Data Using Format-Specific Extractor
+
+```javascript
+let extracted = { title: '', approach: '', tasks: [], metadata: {} };
+
+switch (sourceInfo.type) {
+  case 'lite-plan':
+    extracted = extractFromLitePlan(sourceInfo.path);
+    break;
+  case 'workflow-session':
+  case 'workflow-session-id':
+    extracted = extractFromWorkflowSession(sourceInfo.path);
+    break;
+  case 'markdown-file':
+    extracted = await extractFromMarkdownAI(sourceInfo.path);
+    break;
+  case 'json-file':
+    extracted = extractFromJsonFile(sourceInfo.path);
+    break;
+}
+
+// Validate extraction
+if (!extracted.tasks || extracted.tasks.length === 0) {
+  throw new Error('E006: No tasks extracted from source');
+}
+
+// Ensure task IDs are normalized to T1, T2, T3...
+extracted.tasks = normalizeTaskIds(extracted.tasks);
+
+console.log(`Extracted: ${extracted.tasks.length} tasks`);
+```
+
+#### Extractor: Lite-Plan
+
+```javascript
+function extractFromLitePlan(folderPath) {
+  const planJson = Read(`${folderPath}/plan.json`);
+  const plan = JSON.parse(planJson);
+
+  return {
+    title: plan.summary?.split('.')[0]?.trim() || 'Untitled Plan',
+    description: plan.summary,
+    approach: plan.approach,
+    tasks: plan.tasks.map(t => ({
+      id: t.id,
+      title: t.title,
+      scope: t.scope || '',
+      action: t.action || 'Implement',
+      description: t.description || t.title,
+      modification_points: t.modification_points || [],
+      implementation: Array.isArray(t.implementation) ? t.implementation : [t.implementation || ''],
+      test: t.verification ? {
+        unit: t.verification.unit_tests,
+        integration: t.verification.integration_tests,
+        commands: t.verification.manual_checks
+      } : {},
+      acceptance: {
+        criteria: Array.isArray(t.acceptance) ? t.acceptance : [t.acceptance || ''],
+        verification: t.verification?.manual_checks || []
+      },
+      depends_on: t.depends_on || [],
+      priority: 3
+    })),
+    metadata: {
+      source_type: 'lite-plan',
+      source_path: folderPath,
+      complexity: plan.complexity,
+      estimated_time: plan.estimated_time,
+      exploration_angles: plan._metadata?.exploration_angles || [],
+      original_timestamp: plan._metadata?.timestamp
+    }
+  };
+}
+```
+
+#### Extractor: Workflow Session
+
+```javascript
+function extractFromWorkflowSession(sessionPath) {
+  // Load session metadata
+  const sessionJson = Read(`${sessionPath}/workflow-session.json`);
+  const session = JSON.parse(sessionJson);
+
+  // Load IMPL_PLAN.md for approach (if exists)
+  let approach = '';
+  const implPlanPath = `${sessionPath}/IMPL_PLAN.md`;
+  const hasImplPlan = Bash(`test -f "${implPlanPath}" && echo "yes" || echo "no"`).trim() === 'yes';
+  if (hasImplPlan) {
+    const implPlan = Read(implPlanPath);
+    // Extract overview/approach section
+    const overviewMatch = implPlan.match(/##\s*(?:Overview|Approach|Strategy)\s*\n([\s\S]*?)(?=\n##|$)/i);
+    approach = overviewMatch?.[1]?.trim() || implPlan.split('\n').slice(0, 10).join('\n');
+  }
+
+  // Load all task JSONs from .task folder
+  const taskFiles = Glob({ pattern: `${sessionPath}/.task/IMPL-*.json` });
+  const tasks = taskFiles.map(f => {
+    const taskJson = Read(f);
+    const task = JSON.parse(taskJson);
+    return {
+      id: task.id?.replace(/^IMPL-0*/, 'T') || 'T1',  // IMPL-001 → T1
+      title: task.title,
+      scope: task.scope || inferScopeFromTask(task),
+      action: capitalizeAction(task.type) || 'Implement',
+      description: task.description,
+      modification_points: task.implementation?.modification_points || [],
+      implementation: task.implementation?.steps || [],
+      test: task.implementation?.test || {},
+      acceptance: {
+        criteria: task.acceptance_criteria || [],
+        verification: task.verification_steps || []
+      },
+      commit: task.commit,
+      depends_on: (task.depends_on || []).map(d => d.replace(/^IMPL-0*/, 'T')),
+      priority: task.priority || 3
+    };
+  });
+
+  return {
+    title: session.name || session.description?.split('.')[0] || 'Workflow Session',
+    description: session.description || session.name,
+    approach: approach || session.description,
+    tasks: tasks,
+    metadata: {
+      source_type: 'workflow-session',
+      source_path: sessionPath,
+      session_id: session.id,
+      created_at: session.created_at
+    }
+  };
+}
+
+function inferScopeFromTask(task) {
+  if (task.implementation?.modification_points?.length) {
+    const files = task.implementation.modification_points.map(m => m.file);
+    // Find common directory prefix
+    const dirs = files.map(f => f.split('/').slice(0, -1).join('/'));
+    return [...new Set(dirs)][0] || '';
+  }
+  return '';
+}
+
+function capitalizeAction(type) {
+  if (!type) return 'Implement';
+  const map = { feature: 'Implement', bugfix: 'Fix', refactor: 'Refactor', test: 'Test', docs: 'Update' };
+  return map[type.toLowerCase()] || type.charAt(0).toUpperCase() + type.slice(1);
+}
+```
+
+#### Extractor: Markdown (AI-Assisted via Gemini)
+
+```javascript
+async function extractFromMarkdownAI(filePath) {
+  const fileContent = Read(filePath);
+
+  // Use Gemini CLI for intelligent extraction
+  const cliPrompt = `PURPOSE: Extract implementation plan from markdown document for issue solution conversion. Must output ONLY valid JSON.
+TASK: • Analyze document structure • Identify title/summary • Extract approach/strategy section • Parse tasks from any format (lists, tables, sections, code blocks) • Normalize each task to solution schema
+MODE: analysis
+CONTEXT: Document content provided below
+EXPECTED: Valid JSON object with format:
+{
+  "title": "extracted title",
+  "approach": "extracted approach/strategy",
+  "tasks": [
+    {
+      "id": "T1",
+      "title": "task title",
+      "scope": "module or feature area",
+      "action": "Implement|Update|Create|Fix|Refactor|Add|Delete|Configure|Test",
+      "description": "what to do",
+      "implementation": ["step 1", "step 2"],
+      "acceptance": ["criteria 1", "criteria 2"]
+    }
+  ]
+}
+CONSTRAINTS: Output ONLY valid JSON - no markdown, no explanation | Action must be one of: Create, Update, Implement, Refactor, Add, Delete, Configure, Test, Fix | Tasks must have id, title, scope, action, implementation (array), acceptance (array)
+
+DOCUMENT CONTENT:
+${fileContent}`;
+
+  // Execute Gemini CLI
+  const result = Bash(`ccw cli -p '${cliPrompt.replace(/'/g, "'\\''")}' --tool gemini --mode analysis`, { timeout: 120000 });
+
+  // Parse JSON from result (may be wrapped in markdown code block)
+  let jsonText = result.trim();
+  const jsonMatch = jsonText.match(/```(?:json)?\s*([\s\S]*?)```/);
+  if (jsonMatch) {
+    jsonText = jsonMatch[1].trim();
+  }
+
+  try {
+    const extracted = JSON.parse(jsonText);
+
+    // Normalize tasks
+    const tasks = (extracted.tasks || []).map((t, i) => ({
+      id: t.id || `T${i + 1}`,
+      title: t.title || 'Untitled task',
+      scope: t.scope || '',
+      action: validateAction(t.action) || 'Implement',
+      description: t.description || t.title,
+      modification_points: t.modification_points || [],
+      implementation: Array.isArray(t.implementation) ? t.implementation : [t.implementation || ''],
+      test: t.test || {},
+      acceptance: {
+        criteria: Array.isArray(t.acceptance) ? t.acceptance : [t.acceptance || ''],
+        verification: t.verification || []
+      },
+      depends_on: t.depends_on || [],
+      priority: t.priority || 3
+    }));
+
+    return {
+      title: extracted.title || 'Extracted Plan',
+      description: extracted.summary || extracted.title,
+      approach: extracted.approach || '',
+      tasks: tasks,
+      metadata: {
+        source_type: 'markdown',
+        source_path: filePath,
+        extraction_method: 'gemini-ai'
+      }
+    };
+  } catch (e) {
+    // Provide more context for debugging
+    throw new Error(`E005: Failed to extract tasks from markdown. Gemini response was not valid JSON. Error: ${e.message}. Response preview: ${jsonText.substring(0, 200)}...`);
+  }
+}
+
+function validateAction(action) {
+  const validActions = ['Create', 'Update', 'Implement', 'Refactor', 'Add', 'Delete', 'Configure', 'Test', 'Fix'];
+  if (!action) return null;
+  const normalized = action.charAt(0).toUpperCase() + action.slice(1).toLowerCase();
+  return validActions.includes(normalized) ? normalized : null;
+}
+```
+
+#### Extractor: JSON File
+
+```javascript
+function extractFromJsonFile(filePath) {
+  const content = Read(filePath);
+  const plan = JSON.parse(content);
+
+  // Detect if it's already solution format or plan format
+  if (plan.tasks && Array.isArray(plan.tasks)) {
+    // Map tasks to normalized format
+    const tasks = plan.tasks.map((t, i) => ({
+      id: t.id || `T${i + 1}`,
+      title: t.title,
+      scope: t.scope || '',
+      action: t.action || 'Implement',
+      description: t.description || t.title,
+      modification_points: t.modification_points || [],
+      implementation: Array.isArray(t.implementation) ? t.implementation : [t.implementation || ''],
+      test: t.test || t.verification || {},
+      acceptance: normalizeAcceptance(t.acceptance),
+      depends_on: t.depends_on || [],
+      priority: t.priority || 3
+    }));
+
+    return {
+      title: plan.summary?.split('.')[0] || plan.title || 'JSON Plan',
+      description: plan.summary || plan.description,
+      approach: plan.approach,
+      tasks: tasks,
+      metadata: {
+        source_type: 'json',
+        source_path: filePath,
+        complexity: plan.complexity,
+        original_metadata: plan._metadata
+      }
+    };
+  }
+
+  throw new Error('E002: JSON file does not contain valid plan structure (missing tasks array)');
+}
+
+function normalizeAcceptance(acceptance) {
+  if (!acceptance) return { criteria: [], verification: [] };
+  if (typeof acceptance === 'object' && acceptance.criteria) return acceptance;
+  if (Array.isArray(acceptance)) return { criteria: acceptance, verification: [] };
+  return { criteria: [String(acceptance)], verification: [] };
+}
+```
+
+### Phase 3: Normalize Task IDs
+
+```javascript
+function normalizeTaskIds(tasks) {
+  return tasks.map((t, i) => ({
+    ...t,
+    id: `T${i + 1}`,
+    // Also normalize depends_on references
+    depends_on: (t.depends_on || []).map(d => {
+      // Handle various ID formats: IMPL-001, T1, 1, etc.
+      const num = d.match(/\d+/)?.[0];
+      return num ? `T${parseInt(num)}` : d;
+    })
+  }));
+}
+```
+
+### Phase 4: Resolve Issue (Create or Find)
+
+```javascript
+let issueId = flags.issue;
+let existingSolution = null;
+
+if (issueId) {
+  // Validate issue exists
+  let issueCheck;
+  try {
+    issueCheck = Bash(`ccw issue status ${issueId} --json 2>/dev/null`).trim();
+    if (!issueCheck || issueCheck === '') {
+      throw new Error('empty response');
+    }
+  } catch (e) {
+    throw new Error(`E003: Issue not found: ${issueId}`);
+  }
+
+  const issue = JSON.parse(issueCheck);
+
+  // Check if issue already has bound solution
+  if (issue.bound_solution_id && !flags.supplement) {
+    throw new Error(`E004: Issue ${issueId} already has bound solution (${issue.bound_solution_id}). Use --supplement to add tasks.`);
+  }
+
+  // Load existing solution for supplement mode
+  if (flags.supplement && issue.bound_solution_id) {
+    try {
+      const solResult = Bash(`ccw issue solution ${issue.bound_solution_id} --json`).trim();
+      existingSolution = JSON.parse(solResult);
+      console.log(`Loaded existing solution with ${existingSolution.tasks.length} tasks`);
+    } catch (e) {
+      throw new Error(`Failed to load existing solution: ${e.message}`);
+    }
+  }
+} else {
+  // Create new issue via ccw issue create (auto-generates correct ID)
+  // Smart extraction: title from content, priority from complexity
+  const title = extracted.title || 'Converted Plan';
+  const context = extracted.description || extracted.approach || title;
+
+  // Auto-determine priority based on complexity
+  const complexityMap = { high: 2, medium: 3, low: 4 };
+  const priority = complexityMap[extracted.metadata.complexity?.toLowerCase()] || 3;
+
+  try {
+    // Use heredoc to avoid shell escaping issues
+    const createResult = Bash(`ccw issue create << 'EOF'
+{
+  "title": ${JSON.stringify(title)},
+  "context": ${JSON.stringify(context)},
+  "priority": ${priority},
+  "source": "converted"
+}
+EOF`).trim();
+
+    // Parse result to get created issue ID
+    const created = JSON.parse(createResult);
+    issueId = created.id;
+    console.log(`Created issue: ${issueId} (priority: ${priority})`);
+  } catch (e) {
+    throw new Error(`Failed to create issue: ${e.message}`);
+  }
+}
+```
+
+### Phase 5: Generate Solution
+
+```javascript
+// Generate solution ID
+function generateSolutionId(issueId) {
+  const chars = 'abcdefghijklmnopqrstuvwxyz0123456789';
+  let uid = '';
+  for (let i = 0; i < 4; i++) {
+    uid += chars[Math.floor(Math.random() * chars.length)];
+  }
+  return `SOL-${issueId}-${uid}`;
+}
+
+let solution;
+const solutionId = generateSolutionId(issueId);
+
+if (flags.supplement && existingSolution) {
+  // Supplement mode: merge with existing solution
+  const maxTaskId = Math.max(...existingSolution.tasks.map(t => parseInt(t.id.slice(1))));
+
+  const newTasks = extracted.tasks.map((t, i) => ({
+    ...t,
+    id: `T${maxTaskId + i + 1}`
+  }));
+
+  solution = {
+    ...existingSolution,
+    tasks: [...existingSolution.tasks, ...newTasks],
+    approach: existingSolution.approach + '\n\n[Supplementary] ' + (extracted.approach || ''),
+    updated_at: new Date().toISOString()
+  };
+
+  console.log(`Supplementing: ${existingSolution.tasks.length} existing + ${newTasks.length} new = ${solution.tasks.length} total tasks`);
+} else {
+  // New solution
+  solution = {
+    id: solutionId,
+    description: extracted.description || extracted.title,
+    approach: extracted.approach,
+    tasks: extracted.tasks,
+    exploration_context: extracted.metadata.exploration_angles ? {
+      exploration_angles: extracted.metadata.exploration_angles
+    } : undefined,
+    analysis: {
+      risk: 'medium',
+      impact: 'medium',
+      complexity: extracted.metadata.complexity?.toLowerCase() || 'medium'
+    },
+    is_bound: false,
+    created_at: new Date().toISOString(),
+    _conversion_metadata: {
+      source_type: extracted.metadata.source_type,
+      source_path: extracted.metadata.source_path,
+      converted_at: new Date().toISOString()
+    }
+  };
+}
+```
+
+### Phase 6: Confirm & Persist
+
+```javascript
+// Display preview
+console.log(`
+## Conversion Summary
+
+**Issue**: ${issueId}
+**Solution**: ${flags.supplement ? existingSolution.id : solutionId}
+**Tasks**: ${solution.tasks.length}
+**Mode**: ${flags.supplement ? 'Supplement' : 'New'}
+
+### Tasks:
+${solution.tasks.map(t => `- ${t.id}: ${t.title} [${t.action}]`).join('\n')}
+`);
+
+// Confirm if not auto mode
+if (!flags.yes && !flags.y) {
+  const confirm = AskUserQuestion({
+    questions: [{
+      question: `Create solution for issue ${issueId} with ${solution.tasks.length} tasks?`,
+      header: 'Confirm',
+      multiSelect: false,
+      options: [
+        { label: 'Yes, create solution', description: 'Create and bind solution' },
+        { label: 'Cancel', description: 'Abort without changes' }
+      ]
+    }]
+  });
+
+  if (!confirm.answers?.['Confirm']?.includes('Yes')) {
+    console.log('Cancelled.');
+    return;
+  }
+}
+
+// Persist solution (following issue-plan-agent pattern)
+Bash(`mkdir -p .workflow/issues/solutions`);
+
+const solutionFile = `.workflow/issues/solutions/${issueId}.jsonl`;
+
+if (flags.supplement) {
+  // Supplement mode: update existing solution line atomically
+  try {
+    const existingContent = Read(solutionFile);
+    const lines = existingContent.trim().split('\n').filter(l => l);
+    const updatedLines = lines.map(line => {
+      const sol = JSON.parse(line);
+      if (sol.id === existingSolution.id) {
+        return JSON.stringify(solution);
+      }
+      return line;
+    });
+    // Atomic write: write entire content at once
+    Write({ file_path: solutionFile, content: updatedLines.join('\n') + '\n' });
+    console.log(`✓ Updated solution: ${existingSolution.id}`);
+  } catch (e) {
+    throw new Error(`Failed to update solution: ${e.message}`);
+  }
+
+  // Note: No need to rebind - solution is already bound to issue
+} else {
+  // New solution: append to JSONL file (following issue-plan-agent pattern)
+  try {
+    const solutionLine = JSON.stringify(solution);
+
+    // Read existing content, append new line, write atomically
+    const existing = Bash(`test -f "${solutionFile}" && cat "${solutionFile}" || echo ""`).trim();
+    const newContent = existing ? existing + '\n' + solutionLine + '\n' : solutionLine + '\n';
+    Write({ file_path: solutionFile, content: newContent });
+
+    console.log(`✓ Created solution: ${solutionId}`);
+  } catch (e) {
+    throw new Error(`Failed to write solution: ${e.message}`);
+  }
+
+  // Bind solution to issue
+  try {
+    Bash(`ccw issue bind ${issueId} ${solutionId}`);
+    console.log(`✓ Bound solution to issue`);
+  } catch (e) {
+    // Cleanup: remove solution file on bind failure
+    try {
+      Bash(`rm -f "${solutionFile}"`);
+    } catch (cleanupError) {
+      // Ignore cleanup errors
+    }
+    throw new Error(`Failed to bind solution: ${e.message}`);
+  }
+
+  // Update issue status to planned
+  try {
+    Bash(`ccw issue update ${issueId} --status planned`);
+  } catch (e) {
+    throw new Error(`Failed to update issue status: ${e.message}`);
+  }
+}
+```
+
+### Phase 7: Summary
+
+```javascript
+console.log(`
+## Done
+
+**Issue**: ${issueId}
+**Solution**: ${flags.supplement ? existingSolution.id : solutionId}
+**Tasks**: ${solution.tasks.length}
+**Status**: planned
+
+### Next Steps:
+- \`/issue:queue\` → Form execution queue
+- \`ccw issue status ${issueId}\` → View issue details
+- \`ccw issue solution ${flags.supplement ? existingSolution.id : solutionId}\` → View solution
+`);
+```
+
+## Error Handling
+
+| Error | Code | Resolution |
+|-------|------|------------|
+| Source not found | E001 | Check path exists |
+| Invalid source format | E002 | Verify file contains valid plan structure |
+| Issue not found | E003 | Check issue ID or omit --issue to create new |
+| Solution already bound | E004 | Use --supplement to add tasks |
+| AI extraction failed | E005 | Check markdown structure, try simpler format |
+| No tasks extracted | E006 | Source must contain at least 1 task |
+
+## Related Commands
+
+- `/issue:plan` - Generate solutions from issue exploration
+- `/issue:queue` - Form execution queue from bound solutions
+- `/issue:execute` - Execute queue with DAG parallelism
+- `ccw issue status <id>` - View issue details
+- `ccw issue solution <id>` - View solution details

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

@@ -0,0 +1,768 @@
+---
+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: "[-y|--yes] <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(*)
+---
+
+## Auto Mode
+
+When `--yes` or `-y`: Auto-continue all iterations, skip confirmations.
+
+# 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,472 @@
+---
+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: "[-y|--yes] <path-pattern> [--perspectives=bug,ux,...] [--external]"
+allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*), Task(*), AskUserQuestion(*), Glob(*), Grep(*)
+---
+
+## Auto Mode
+
+When `--yes` or `-y`: Auto-select all perspectives, skip confirmations.
+
+# 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,580 @@
+---
+name: execute
+description: Execute queue with DAG-based parallel orchestration (one commit per solution)
+argument-hint: "[-y|--yes] --queue <queue-id> [--worktree [<existing-path>]]"
+allowed-tools: TodoWrite(*), Bash(*), Read(*), AskUserQuestion(*)
+---
+
+## Auto Mode
+
+When `--yes` or `-y`: Auto-confirm execution, use recommended settings.
+
+# 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
+
+  // Pre-defined values (replaced at dispatch time, NOT by executor)
+  const SOLUTION_ID = solutionId;
+  const WORK_DIR = worktreePath || null;
+
+  // Build prompt without markdown code blocks to avoid escaping issues
+  const prompt = `
+## Execute Solution: ${SOLUTION_ID}
+${WORK_DIR ? `Working Directory: ${WORK_DIR}` : ''}
+
+### Step 1: Get Solution Details
+Run this command to get the full solution with all tasks:
+  ccw issue detail ${SOLUTION_ID}
+
+### 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:
+- Follow task.implementation steps
+- Run task.test commands
+- Verify task.acceptance criteria
+- Do NOT commit after each task
+
+### Step 3: Commit Solution (Once)
+After ALL tasks pass, commit once with formatted summary.
+
+Command:
+  git add -A
+  git commit -m "<type>(<scope>): <description>
+
+  Solution: ${SOLUTION_ID}
+  Tasks completed: <list task IDs>
+
+  Changes:
+  - <file1>: <what changed>
+  - <file2>: <what changed>
+
+  Verified: all tests passed"
+
+Replace <type> with: feat|fix|refactor|docs|test
+Replace <scope> with: affected module name
+Replace <description> with: brief summary from solution
+
+### Step 4: Report Completion
+On success, run:
+  ccw issue done ${SOLUTION_ID} --result '{"summary": "<brief>", "files_modified": ["<file1>", "<file2>"], "commit": {"hash": "<hash>", "type": "<type>"}, "tasks_completed": <N>}'
+
+On failure, run:
+  ccw issue done ${SOLUTION_ID} --fail --reason '{"task_id": "<TX>", "error_type": "<test_failure|build_error|other>", "message": "<error details>"}'
+
+### Important Notes
+- Do NOT cleanup worktree - it is shared by all solutions in the queue
+- Replace all <placeholder> values with actual values from your execution
+`;
+
+  // 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/from-brainstorm.md

@@ -0,0 +1,382 @@
+---
+name: from-brainstorm
+description: Convert brainstorm session ideas into issue with executable solution for parallel-dev-cycle
+argument-hint: "SESSION=\"<session-id>\" [--idea=<index>] [--auto] [-y|--yes]"
+allowed-tools: TodoWrite(*), Bash(*), Read(*), Write(*), Glob(*), AskUserQuestion(*)
+---
+
+## Auto Mode
+
+When `--yes` or `-y`: Auto-select highest-scored idea, skip confirmations, create issue directly.
+
+# Issue From-Brainstorm Command (/issue:from-brainstorm)
+
+## Overview
+
+Bridge command that converts **brainstorm-with-file** session output into executable **issue + solution** for parallel-dev-cycle consumption.
+
+**Core workflow**: Load Session → Select Idea → Convert to Issue → Generate Solution → Bind & Ready
+
+**Input sources**:
+- **synthesis.json** - Main brainstorm results with top_ideas
+- **perspectives.json** - Multi-CLI perspectives (creative/pragmatic/systematic)
+- **.brainstorming/** - Synthesis artifacts (clarifications, enhancements from role analyses)
+
+**Output**:
+- **Issue** (ISS-YYYYMMDD-NNN) - Full context with clarifications
+- **Solution** (SOL-{issue-id}-{uid}) - Structured tasks for parallel-dev-cycle
+
+## Quick Reference
+
+```bash
+# Interactive mode - select idea, confirm before creation
+/issue:from-brainstorm SESSION="BS-rate-limiting-2025-01-28"
+
+# Pre-select idea by index
+/issue:from-brainstorm SESSION="BS-auth-system-2025-01-28" --idea=0
+
+# Auto mode - select highest scored, no confirmations
+/issue:from-brainstorm SESSION="BS-caching-2025-01-28" --auto -y
+```
+
+## Arguments
+
+| Argument | Required | Type | Default | Description |
+|----------|----------|------|---------|-------------|
+| SESSION | Yes | String | - | Session ID or path to `.workflow/.brainstorm/BS-xxx` |
+| --idea | No | Integer | - | Pre-select idea by index (0-based) |
+| --auto | No | Flag | false | Auto-select highest-scored idea |
+| -y, --yes | No | Flag | false | Skip all confirmations |
+
+## Data Structures
+
+### Issue Schema (Output)
+
+```typescript
+interface Issue {
+  id: string;                    // ISS-YYYYMMDD-NNN
+  title: string;                 // From idea.title
+  status: 'planned';             // Auto-set after solution binding
+  priority: number;              // 1-5 (derived from idea.score)
+  context: string;               // Full description with clarifications
+  source: 'brainstorm';
+  labels: string[];              // ['brainstorm', perspective, feasibility]
+
+  // Structured fields
+  expected_behavior: string;     // From key_strengths
+  actual_behavior: string;       // From main_challenges
+  affected_components: string[]; // Extracted from description
+
+  _brainstorm_metadata: {
+    session_id: string;
+    idea_score: number;
+    novelty: number;
+    feasibility: string;
+    clarifications_count: number;
+  };
+}
+```
+
+### Solution Schema (Output)
+
+```typescript
+interface Solution {
+  id: string;                    // SOL-{issue-id}-{4-char-uid}
+  description: string;           // idea.title
+  approach: string;              // idea.description
+  tasks: Task[];                 // Generated from idea.next_steps
+
+  analysis: {
+    risk: 'low' | 'medium' | 'high';
+    impact: 'low' | 'medium' | 'high';
+    complexity: 'low' | 'medium' | 'high';
+  };
+
+  is_bound: boolean;             // true
+  created_at: string;
+  bound_at: string;
+}
+
+interface Task {
+  id: string;                    // T1, T2, T3...
+  title: string;                 // Actionable task name
+  scope: string;                 // design|implementation|testing|documentation
+  action: string;                // Implement|Design|Research|Test|Document
+  description: string;
+
+  implementation: string[];      // Step-by-step guide
+  acceptance: {
+    criteria: string[];          // What defines success
+    verification: string[];      // How to verify
+  };
+
+  priority: number;              // 1-5
+  depends_on: string[];          // Task dependencies
+}
+```
+
+## Execution Flow
+
+```
+Phase 1: Session Loading
+   ├─ Validate session path
+   ├─ Load synthesis.json (required)
+   ├─ Load perspectives.json (optional - multi-CLI insights)
+   ├─ Load .brainstorming/** (optional - synthesis artifacts)
+   └─ Validate top_ideas array exists
+
+Phase 2: Idea Selection
+   ├─ Auto mode: Select highest scored idea
+   ├─ Pre-selected: Use --idea=N index
+   └─ Interactive: Display table, ask user to select
+
+Phase 3: Enrich Issue Context
+   ├─ Base: idea.description + key_strengths + main_challenges
+   ├─ Add: Relevant clarifications (Requirements/Architecture/Feasibility)
+   ├─ Add: Multi-perspective insights (creative/pragmatic/systematic)
+   └─ Add: Session metadata (session_id, completion date, clarification count)
+
+Phase 4: Create Issue
+   ├─ Generate issue data with enriched context
+   ├─ Calculate priority from idea.score (0-10 → 1-5)
+   ├─ Create via: ccw issue create (heredoc for JSON)
+   └─ Returns: ISS-YYYYMMDD-NNN
+
+Phase 5: Generate Solution Tasks
+   ├─ T1: Research & Validate (if main_challenges exist)
+   ├─ T2: Design & Specification (if key_strengths exist)
+   ├─ T3+: Implementation tasks (from idea.next_steps)
+   └─ Each task includes: implementation steps + acceptance criteria
+
+Phase 6: Bind Solution
+   ├─ Write solution to .workflow/issues/solutions/{issue-id}.jsonl
+   ├─ Bind via: ccw issue bind {issue-id} {solution-id}
+   ├─ Update issue status to 'planned'
+   └─ Returns: SOL-{issue-id}-{uid}
+
+Phase 7: Next Steps
+   └─ Offer: Form queue | Convert another idea | View details | Done
+```
+
+## Context Enrichment Logic
+
+### Base Context (Always Included)
+
+- **Description**: `idea.description`
+- **Why This Idea**: `idea.key_strengths[]`
+- **Challenges to Address**: `idea.main_challenges[]`
+- **Implementation Steps**: `idea.next_steps[]`
+
+### Enhanced Context (If Available)
+
+**From Synthesis Artifacts** (`.brainstorming/*/analysis*.md`):
+- Extract clarifications matching categories: Requirements, Architecture, Feasibility
+- Format: `**{Category}** ({role}): {question} → {answer}`
+- Limit: Top 3 most relevant
+
+**From Perspectives** (`perspectives.json`):
+- **Creative**: First insight from `perspectives.creative.insights[0]`
+- **Pragmatic**: First blocker from `perspectives.pragmatic.blockers[0]`
+- **Systematic**: First pattern from `perspectives.systematic.patterns[0]`
+
+**Session Metadata**:
+- Session ID, Topic, Completion Date
+- Clarifications count (if synthesis artifacts loaded)
+
+## Task Generation Strategy
+
+### Task 1: Research & Validation
+**Trigger**: `idea.main_challenges.length > 0`
+- **Title**: "Research & Validate Approach"
+- **Scope**: design
+- **Action**: Research
+- **Implementation**: Investigate blockers, review similar implementations, validate with team
+- **Acceptance**: Blockers documented, feasibility assessed, approach validated
+
+### Task 2: Design & Specification
+**Trigger**: `idea.key_strengths.length > 0`
+- **Title**: "Design & Create Specification"
+- **Scope**: design
+- **Action**: Design
+- **Implementation**: Create design doc, define success criteria, plan phases
+- **Acceptance**: Design complete, metrics defined, plan outlined
+
+### Task 3+: Implementation Tasks
+**Trigger**: `idea.next_steps[]`
+- **Title**: From `next_steps[i]` (max 60 chars)
+- **Scope**: Inferred from keywords (test→testing, api→backend, ui→frontend)
+- **Action**: Detected from verbs (implement, create, update, fix, test, document)
+- **Implementation**: Execute step + follow design + write tests
+- **Acceptance**: Step implemented + tests passing + code reviewed
+
+### Fallback Task
+**Trigger**: No tasks generated from above
+- **Title**: `idea.title`
+- **Scope**: implementation
+- **Action**: Implement
+- **Generic implementation + acceptance criteria**
+
+## Priority Calculation
+
+### Issue Priority (1-5)
+```
+idea.score: 0-10
+priority = max(1, min(5, ceil((10 - score) / 2)))
+
+Examples:
+score 9-10 → priority 1 (critical)
+score 7-8  → priority 2 (high)
+score 5-6  → priority 3 (medium)
+score 3-4  → priority 4 (low)
+score 0-2  → priority 5 (lowest)
+```
+
+### Task Priority (1-5)
+- Research task: 1 (highest)
+- Design task: 2
+- Implementation tasks: 3 by default, decrement for later tasks
+- Testing/documentation: 4-5
+
+### Complexity Analysis
+```
+risk: main_challenges.length > 2 ? 'high' : 'medium'
+impact: score >= 8 ? 'high' : score >= 6 ? 'medium' : 'low'
+complexity: main_challenges > 3 OR tasks > 5 ? 'high'
+            tasks > 3 ? 'medium' : 'low'
+```
+
+## CLI Integration
+
+### Issue Creation
+```bash
+# Uses heredoc to avoid shell escaping
+ccw issue create << 'EOF'
+{
+  "title": "...",
+  "context": "...",
+  "priority": 3,
+  "source": "brainstorm",
+  "labels": ["brainstorm", "creative", "feasibility-high"],
+  ...
+}
+EOF
+```
+
+### Solution Binding
+```bash
+# Append solution to JSONL file
+echo '{"id":"SOL-xxx","tasks":[...]}' >> .workflow/issues/solutions/{issue-id}.jsonl
+
+# Bind to issue
+ccw issue bind {issue-id} {solution-id}
+
+# Update status
+ccw issue update {issue-id} --status planned
+```
+
+## Error Handling
+
+| Error | Message | Resolution |
+|-------|---------|------------|
+| Session not found | synthesis.json missing | Check session ID, list available sessions |
+| No ideas | top_ideas array empty | Complete brainstorm workflow first |
+| Invalid idea index | Index out of range | Check valid range 0 to N-1 |
+| Issue creation failed | ccw issue create error | Verify CLI endpoint working |
+| Solution binding failed | Bind error | Check issue exists, retry |
+
+## Examples
+
+### Interactive Mode
+
+```bash
+/issue:from-brainstorm SESSION="BS-rate-limiting-2025-01-28"
+
+# Output:
+# | # | Title | Score | Feasibility |
+# |---|-------|-------|-------------|
+# | 0 | Token Bucket Algorithm | 8.5 | High |
+# | 1 | Sliding Window Counter | 7.2 | Medium |
+# | 2 | Fixed Window | 6.1 | High |
+
+# User selects: #0
+
+# Result:
+# ✓ Created issue: ISS-20250128-001
+# ✓ Created solution: SOL-ISS-20250128-001-ab3d
+# ✓ Bound solution to issue
+# → Next: /issue:queue
+```
+
+### Auto Mode
+
+```bash
+/issue:from-brainstorm SESSION="BS-caching-2025-01-28" --auto
+
+# Result:
+# Auto-selected: Redis Cache Layer (Score: 9.2/10)
+# ✓ Created issue: ISS-20250128-002
+# ✓ Solution with 4 tasks
+# → Status: planned
+```
+
+## Integration Flow
+
+```
+brainstorm-with-file
+        │
+        ├─ synthesis.json
+        ├─ perspectives.json
+        └─ .brainstorming/** (optional)
+        │
+        ▼
+ /issue:from-brainstorm  ◄─── This command
+        │
+        ├─ ISS-YYYYMMDD-NNN (enriched issue)
+        └─ SOL-{issue-id}-{uid} (structured solution)
+        │
+        ▼
+ /issue:queue
+        │
+        ▼
+ /parallel-dev-cycle
+        │
+        ▼
+   RA → EP → CD → VAS
+```
+
+## Session Files Reference
+
+### Input Files
+
+```
+.workflow/.brainstorm/BS-{slug}-{date}/
+├── synthesis.json           # REQUIRED - Top ideas with scores
+├── perspectives.json        # OPTIONAL - Multi-CLI insights
+├── brainstorm.md           # Reference only
+└── .brainstorming/         # OPTIONAL - Synthesis artifacts
+    ├── system-architect/
+    │   └── analysis.md     # Contains clarifications + enhancements
+    ├── api-designer/
+    │   └── analysis.md
+    └── ...
+```
+
+### Output Files
+
+```
+.workflow/issues/
+├── solutions/
+│   └── ISS-YYYYMMDD-001.jsonl  # Created solution (JSONL)
+└── (managed by ccw issue CLI)
+```
+
+## Related Commands
+
+- `/workflow:brainstorm-with-file` - Generate brainstorm sessions
+- `/workflow:brainstorm:synthesis` - Add clarifications to brainstorm
+- `/issue:new` - Create issues from GitHub or text
+- `/issue:plan` - Generate solutions via exploration
+- `/issue:queue` - Form execution queue
+- `/issue:execute` - Execute with parallel-dev-cycle
+- `ccw issue status <id>` - View issue
+- `ccw issue solution <id>` - View solution

.claude/commands/issue/new.md

@@ -0,0 +1,416 @@
+---
+name: new
+description: Create structured issue from GitHub URL or text description
+argument-hint: "[-y|--yes] <github-url | text-description> [--priority 1-5]"
+allowed-tools: TodoWrite(*), Bash(*), Read(*), AskUserQuestion(*), mcp__ace-tool__search_context(*)
+---
+
+## Auto Mode
+
+When `--yes` or `-y`: Skip clarification questions, create issue with inferred details.
+
+# 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,335 @@
+---
+name: plan
+description: Batch plan issue resolution using issue-plan-agent (explore + plan closed-loop)
+argument-hint: "[-y|--yes] --all-pending <issue-id>[,<issue-id>,...] [--batch-size 3]"
+allowed-tools: TodoWrite(*), Task(*), SlashCommand(*), AskUserQuestion(*), Bash(*), Read(*), Write(*)
+---
+
+## Auto Mode
+
+When `--yes` or `-y`: Auto-bind solutions without confirmation, use recommended settings.
+
+# 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 & Intelligent Grouping
+   ├─ Parse input (single, comma-separated, or --all-pending)
+   ├─ Fetch issue metadata (ID, title, tags)
+   ├─ Validate issues exist (create if needed)
+   └─ Intelligent grouping via Gemini (semantic similarity, 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`
+
+// Intelligent grouping: Analyze issues by title/tags, group semantically similar ones
+// Strategy: Same module/component, related bugs, feature clusters
+// Constraint: Max ${batchSize} issues per batch
+
+console.log(`Processing ${issues.length} issues in ${batches.length} batch(es)`);
+
+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. **CRITICAL - Binding Decision**:
+   - Single solution → **MUST execute**: ccw issue bind <issue-id> <solution-id>
+   - Multiple solutions → Return pending_selection only (no bind)
+
+### 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
+
+    // Verify binding for bound issues (agent should have executed bind)
+    for (const item of summary.bound || []) {
+      const status = JSON.parse(Bash(`ccw issue status ${item.issue_id} --json`).trim());
+      if (status.bound_solution_id === item.solution_id) {
+        console.log(`✓ ${item.issue_id}: ${item.solution_id} (${item.task_count} tasks)`);
+      } else {
+        // Fallback: agent failed to bind, execute here
+        Bash(`ccw issue bind ${item.issue_id} ${item.solution_id}`);
+        console.log(`✓ ${item.issue_id}: ${item.solution_id} (${item.task_count} tasks) [recovered]`);
+      }
+    }
+    // Collect pending selections for Phase 3
+    for (const pending of summary.pending_selection || []) {
+      pendingSelections.push(pending);
+    }
+    updateTodo(`Plan batch ${batchIndex + 1}`, 'completed');
+  }
+}
+```
+
+### Phase 3: Solution Selection (if pending)
+
+```javascript
+// Handle multi-solution issues
+for (const pending of pendingSelections) {
+  if (pending.solutions.length === 0) continue;
+
+  const options = pending.solutions.slice(0, 4).map(sol => ({
+    label: `${sol.id} (${sol.task_count} tasks)`,
+    description: sol.description || sol.approach || 'No description'
+  }));
+
+  const answer = AskUserQuestion({
+    questions: [{
+      question: `Issue ${pending.issue_id}: which solution to bind?`,
+      header: pending.issue_id,
+      options: options,
+      multiSelect: false
+    }]
+  });
+
+  const selected = answer[Object.keys(answer)[0]];
+  if (!selected || selected === 'Other') continue;
+
+  const solId = selected.split(' ')[0];
+  Bash(`ccw issue bind ${pending.issue_id} ${solId}`);
+  console.log(`✓ ${pending.issue_id}: ${solId} bound`);
+}
+```
+
+### 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,445 @@
+---
+name: queue
+description: Form execution queue from bound solutions using issue-queue-agent (solution-level)
+argument-hint: "[-y|--yes] [--queues <n>] [--issue <id>]"
+allowed-tools: TodoWrite(*), Task(*), Bash(*), Read(*), Write(*)
+---
+
+## Auto Mode
+
+When `--yes` or `-y`: Auto-confirm queue formation, use recommended conflict resolutions.
+
+# 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')` |
+| **Batch solutions (NEW)** | `ccw issue solutions --status planned --brief` | Loop `ccw issue solution <id>` |
+| 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 (single) | `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 solutions --status planned --brief` to get all planned issues with solutions in **one call**
+- Returns: Array of `{ issue_id, solution_id, is_bound, task_count, files_touched[], priority }`
+- If no bound solutions found → display message, suggest `/issue:plan`
+
+**Build Solution Objects:**
+```javascript
+// Single CLI call replaces N individual queries
+const result = Bash(`ccw issue solutions --status planned --brief`).trim();
+const solutions = result ? JSON.parse(result) : [];
+
+if (solutions.length === 0) {
+  console.log('No bound solutions found. Run /issue:plan first.');
+  return;
+}
+
+// solutions already in correct format:
+// { issue_id, solution_id, is_bound, task_count, files_touched[], priority }
+```
+
+**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

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

.claude/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

@@ -101,10 +101,10 @@ src/ (depth 1) → SINGLE STRATEGY
 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: "~/.claude/scripts/get_modules_by_depth.sh list | ~/.claude/scripts/classify-folders.sh", run_in_background: false});
+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> && ~/.claude/scripts/get_modules_by_depth.sh list | ~/.claude/scripts/classify-folders.sh", run_in_background: false});
+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.
@@ -200,7 +200,7 @@ for (let layer of [3, 2, 1]) {
         let strategy = module.depth >= 3 ? "full" : "single";
         for (let tool of tool_order) {
           Bash({
-            command: `cd ${module.path} && ~/.claude/scripts/generate_module_docs.sh "${strategy}" "." "${project_name}" "${tool}"`,
+            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) {
@@ -263,7 +263,7 @@ MODULES:
 
 TOOLS (try in order): {{tool_1}}, {{tool_2}}, {{tool_3}}
 
-EXECUTION SCRIPT: ~/.claude/scripts/generate_module_docs.sh
+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)
@@ -273,7 +273,7 @@ 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}}" && ~/.claude/scripts/generate_module_docs.sh "{{strategy}}" "." "{{project_name}}" "${tool}"`,
+         command: `cd "{{module_path}}" && ccw tool exec generate_module_docs '{"strategy":"{{strategy}}","sourcePath":".","projectName":"{{project_name}}","tool":"${tool}"}'`,
          run_in_background: false
        })
        exit_code=$?
@@ -322,7 +322,7 @@ let project_root = get_project_root();
 report("Generating project README.md...");
 for (let tool of tool_order) {
   Bash({
-    command: `cd ${project_root} && ~/.claude/scripts/generate_module_docs.sh "project-readme" "." "${project_name}" "${tool}"`,
+    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) {
@@ -335,7 +335,7 @@ for (let tool of tool_order) {
 report("Generating ARCHITECTURE.md and EXAMPLES.md...");
 for (let tool of tool_order) {
   Bash({
-    command: `cd ${project_root} && ~/.claude/scripts/generate_module_docs.sh "project-architecture" "." "${project_name}" "${tool}"`,
+    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) {
@@ -350,7 +350,7 @@ if (bash_result.stdout.includes("API_FOUND")) {
   report("Generating HTTP API documentation...");
   for (let tool of tool_order) {
     Bash({
-      command: `cd ${project_root} && ~/.claude/scripts/generate_module_docs.sh "http-api" "." "${project_name}" "${tool}"`,
+      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) {

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

@@ -51,7 +51,7 @@ Orchestrates context-aware documentation generation/update for changed modules u
 Bash({command: "pwd && basename \"$(pwd)\" && git rev-parse --show-toplevel 2>/dev/null || pwd", run_in_background: false});
 
 // Detect changed modules
-Bash({command: "~/.claude/scripts/detect_changed_modules.sh list", run_in_background: false});
+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});
@@ -123,7 +123,7 @@ for (let depth of sorted_depths.reverse()) {  // N → 0
       return async () => {
         for (let tool of tool_order) {
           Bash({
-            command: `cd ${module.path} && ~/.claude/scripts/generate_module_docs.sh "single" "." "${project_name}" "${tool}"`,
+            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) {
@@ -207,21 +207,21 @@ EXECUTION:
 For each module above:
   1. Try tool 1:
      Bash({
-       command: `cd "{{module_path}}" && ~/.claude/scripts/generate_module_docs.sh "single" "." "{{project_name}}" "{{tool_1}}"`,
+       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}}" && ~/.claude/scripts/generate_module_docs.sh "single" "." "{{project_name}}" "{{tool_2}}"`,
+       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}}" && ~/.claude/scripts/generate_module_docs.sh "single" "." "{{project_name}}" "{{tool_3}}"`,
+       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

.claude/commands/memory/docs.md

@@ -1,610 +0,0 @@
----
-name: docs
-description: Plan documentation workflow with dynamic grouping (≤10 docs/task), generates IMPL tasks for parallel module trees, README, ARCHITECTURE, and HTTP API docs
-argument-hint: "[path] [--tool <gemini|qwen|codex>] [--mode <full|partial>] [--cli-execute]"
----
-
-# Documentation Workflow (/memory:docs)
-
-## Overview
-Lightweight planner that analyzes project structure, decomposes documentation work into tasks, and generates execution plans. Does NOT generate documentation content itself - delegates to doc-generator agent.
-
-**Execution Strategy**:
-- **Dynamic Task Grouping**: Level 1 tasks grouped by top-level directories with document count limit
-  - **Primary constraint**: Each task generates ≤10 documents (API.md + README.md count)
-  - **Optimization goal**: Prefer grouping 2 top-level directories per task for context sharing
-  - **Conflict resolution**: If 2 dirs exceed 10 docs, reduce to 1 dir/task; if 1 dir exceeds 10 docs, split by subdirectories
-  - **Context benefit**: Same-task directories analyzed together via single Gemini call
-- **Parallel Execution**: Multiple Level 1 tasks execute concurrently for faster completion
-- **Pre-computed Analysis**: Phase 2 performs unified analysis once, stored in `.process/` for reuse
-- **Efficient Data Loading**: All existing docs loaded once in Phase 2, shared across tasks
-
-**Path Mirroring**: Documentation structure mirrors source code under `.workflow/docs/{project_name}/`
-- Example: `my_app/src/core/` → `.workflow/docs/my_app/src/core/API.md`
-
-**Two Execution Modes**:
-- **Default (Agent Mode)**: CLI analyzes in `pre_analysis` (MODE=analysis), agent writes docs
-- **--cli-execute (CLI Mode)**: CLI generates docs in `implementation_approach` (MODE=write), agent executes CLI commands
-
-## Path Mirroring Strategy
-
-**Principle**: Documentation structure **mirrors** source code structure under project-specific directory.
-
-| Source Path | Project Name | Documentation Path |
-|------------|--------------|-------------------|
-| `my_app/src/core/` | `my_app` | `.workflow/docs/my_app/src/core/API.md` |
-| `my_app/src/modules/auth/` | `my_app` | `.workflow/docs/my_app/src/modules/auth/API.md` |
-| `another_project/lib/utils/` | `another_project` | `.workflow/docs/another_project/lib/utils/API.md` |
-
-
-## Parameters
-
-```bash
-/memory:docs [path] [--tool <gemini|qwen|codex>] [--mode <full|partial>] [--cli-execute]
-```
-
-- **path**: Source directory to analyze (default: current directory)
-  - Specifies the source code directory to be documented
-  - Documentation is generated in a separate `.workflow/docs/{project_name}/` directory at the workspace root, **not** within the source `path` itself
-  - The source path's structure is mirrored within the project-specific documentation folder
-  - Example: analyzing `src/modules` produces documentation at `.workflow/docs/{project_name}/src/modules/`
-- **--mode**: Documentation generation mode (default: full)
-  - `full`: Complete documentation (modules + README + ARCHITECTURE + EXAMPLES + HTTP API)
-  - `partial`: Module documentation only (API.md + README.md)
-- **--tool**: CLI tool selection (default: gemini)
-  - `gemini`: Comprehensive documentation, pattern recognition
-  - `qwen`: Architecture analysis, system design focus
-  - `codex`: Implementation validation, code quality
-- **--cli-execute**: Enable CLI-based documentation generation (optional)
-
-## Planning Workflow
-
-### Phase 1: Initialize Session
-
-```bash
-# Get target path, project name, and root
-bash(pwd && basename "$(pwd)" && git rev-parse --show-toplevel 2>/dev/null || pwd && date +%Y%m%d-%H%M%S)
-
-# Create session directories (replace timestamp)
-bash(mkdir -p .workflow/active/WFS-docs-{timestamp}/.{task,process,summaries})
-
-# Create workflow-session.json (replace values)
-bash(echo '{"session_id":"WFS-docs-{timestamp}","project":"{project} documentation","status":"planning","timestamp":"2024-01-20T14:30:22+08:00","path":".","target_path":"{target_path}","project_root":"{project_root}","project_name":"{project_name}","mode":"full","tool":"gemini","cli_execute":false}' | jq '.' > .workflow/active/WFS-docs-{timestamp}/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(~/.claude/scripts/get_modules_by_depth.sh | ~/.claude/scripts/classify-folders.sh)
-
-# 2. Get top-level directories (first 2 path levels)
-bash(~/.claude/scripts/get_modules_by_depth.sh | ~/.claude/scripts/classify-folders.sh | 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 | --approval-mode yolo | Execute CLI commands, validate output |
-
-**Command Patterns**:
-- Gemini/Qwen: `cd dir && gemini -p "..."`
-- CLI Mode: `cd dir && gemini --approval-mode yolo -p "..."`
-- Codex: `codex -C dir --full-auto exec "..." --skip-git-repo-check -s danger-full-access`
-
-**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": "bash(dirs=$(jq -r '.groups.assignments[] | select(.group_id == \"${group_number}\") | .directories[]' ${session_dir}/.process/doc-planning-data.json); for dir in $dirs; do cd \"$dir\" && gemini --approval-mode yolo -p \"PURPOSE: Generate module docs\\nTASK: Create documentation\\nMODE: write\\nCONTEXT: @**/* [phase2_context]\\nEXPECTED: API.md and README.md\\nRULES: Mirror structure\" || echo \"Failed: $dir\"; cd -; done)",
-  "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(gemini \"PURPOSE: Analyze project structure\\nTASK: Extract overview from modules\\nMODE: analysis\\nCONTEXT: [all_module_docs]\\nEXPECTED: Project outline\")",
-        "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(gemini \"PURPOSE: Analyze system architecture\\nTASK: Synthesize architectural overview and examples\\nMODE: analysis\\nCONTEXT: [all_docs]\\nEXPECTED: Architecture + Examples outline\")", "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(gemini \"PURPOSE: Document HTTP API\\nTASK: Analyze endpoints\\nMODE: analysis\\nCONTEXT: @src/api/**/* [endpoint_discovery]\\nEXPECTED: API outline\")", "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 | --approval-mode yolo | 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

@@ -1,182 +0,0 @@
----
-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

@@ -5,7 +5,7 @@ argument-hint: "[--tool gemini|qwen] \"task context description\""
 allowed-tools: Task(*), Bash(*)
 examples:
   - /memory:load "在当前前端基础上开发用户认证功能"
-  - /memory:load --tool qwen -p "重构支付模块API"
+  - /memory:load --tool qwen "重构支付模块API"
 ---
 
 # Memory Load Command (/memory:load)
@@ -39,7 +39,7 @@ 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 MCP code-index or rg/find to locate relevant files
+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
 
@@ -109,7 +109,7 @@ Task(
 
 1. **Project Structure**
    \`\`\`bash
-   bash(~/.claude/scripts/get_modules_by_depth.sh)
+   bash(ccw tool exec get_modules_by_depth '{}')
    \`\`\`
 
 2. **Core Documentation**
@@ -136,7 +136,7 @@ Task(
 Execute Gemini/Qwen CLI for deep analysis (saves main thread tokens):
 
 \`\`\`bash
-cd . && ${tool} -p "
+ccw cli -p "
 PURPOSE: Extract project core context for task: ${task_description}
 TASK: Analyze project architecture, tech stack, key patterns, relevant files
 MODE: analysis
@@ -147,7 +147,7 @@ RULES:
 - 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
@@ -212,7 +212,7 @@ Before returning:
 ### Example 2: Using Qwen Tool
 
 ```bash
-/memory:load --tool qwen -p "重构支付模块API"
+/memory:load --tool qwen "重构支付模块API"
 ```
 
 Agent uses Qwen CLI for analysis, returns same structured package.

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

@@ -1,525 +0,0 @@
----
-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/tech-research.md

@@ -1,477 +0,0 @@
----
-name: tech-research
-description: 3-phase orchestrator: extract tech stack from session/name → delegate to agent for Exa research and module generation → generate SKILL.md index (skips phase 2 if exists)
-argument-hint: "[session-id | tech-stack-name] [--regenerate] [--tool <gemini|qwen>]"
-allowed-tools: SlashCommand(*), TodoWrite(*), Bash(*), Read(*), Write(*), Task(*)
----
-
-# Tech Stack Research SKILL Generator
-
-## Overview
-
-**Pure Orchestrator with Agent Delegation**: Prepares context paths and delegates ALL work to agent. Agent produces files directly.
-
-**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 SKILL OR `--regenerate` specified)
-- **Skip Path**: Phase 1 → Phase 3 (existing SKILL found AND no `--regenerate` flag)
-- **Phase 3 Always Executes**: SKILL index is always generated or updated
-
-**Agent Responsibility**:
-- Agent does ALL the work: context reading, Exa research, content synthesis, file writing
-- Orchestrator only provides context paths and waits for completion
-
-## Core Rules
-
-1. **Start Immediately**: First action is TodoWrite initialization, second action is Phase 1 execution
-2. **Context Path Delegation**: Pass session directory or tech stack name to agent, let agent do discovery
-3. **Agent Produces Files**: Agent directly writes all module files, orchestrator does NOT parse agent output
-4. **Auto-Continue**: After completing each phase, update TodoWrite and immediately execute next phase
-5. **No User Prompts**: Never ask user questions or wait for input between phases
-6. **Track Progress**: Update TodoWrite after EVERY phase completion before starting next phase
-7. **Lightweight Index**: Phase 3 only generates SKILL.md index by reading existing files
-
----
-
-## 3-Phase Execution
-
-### Phase 1: Prepare Context Paths
-
-**Goal**: Detect input mode, prepare context paths for agent, check existing SKILL
-
-**Input Mode Detection**:
-```bash
-# Get input parameter
-input="$1"
-
-# Detect mode
-if [[ "$input" == WFS-* ]]; then
-  MODE="session"
-  SESSION_ID="$input"
-  CONTEXT_PATH=".workflow/${SESSION_ID}"
-else
-  MODE="direct"
-  TECH_STACK_NAME="$input"
-  CONTEXT_PATH="$input"  # Pass tech stack name as context
-fi
-```
-
-**Check Existing SKILL**:
-```bash
-# For session mode, peek at session to get tech stack name
-if [[ "$MODE" == "session" ]]; then
-  bash(test -f ".workflow/${SESSION_ID}/workflow-session.json")
-  Read(.workflow/${SESSION_ID}/workflow-session.json)
-  # Extract tech_stack_name (minimal extraction)
-fi
-
-# Normalize and check
-normalized_name=$(echo "$TECH_STACK_NAME" | tr '[:upper:]' '[:lower:]' | tr ' ' '-')
-bash(test -d ".claude/skills/${normalized_name}" && echo "exists" || echo "not_exists")
-bash(find ".claude/skills/${normalized_name}" -name "*.md" 2>/dev/null | wc -l || echo 0)
-```
-
-**Skip Decision**:
-```javascript
-if (existing_files > 0 && !regenerate_flag) {
-  SKIP_GENERATION = true
-  message = "Tech stack SKILL already exists, skipping Phase 2. Use --regenerate to force regeneration."
-} else if (regenerate_flag) {
-  bash(rm -rf ".claude/skills/${normalized_name}")
-  SKIP_GENERATION = false
-  message = "Regenerating tech stack SKILL from scratch."
-} else {
-  SKIP_GENERATION = false
-  message = "No existing SKILL found, generating new tech stack documentation."
-}
-```
-
-**Output Variables**:
-- `MODE`: `session` or `direct`
-- `SESSION_ID`: Session ID (if session mode)
-- `CONTEXT_PATH`: Path to session directory OR tech stack name
-- `TECH_STACK_NAME`: Extracted or provided tech stack name
-- `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: Agent Produces All Files
-
-**Skip Condition**: Skipped if `SKIP_GENERATION = true`
-
-**Goal**: Delegate EVERYTHING to agent - context reading, Exa research, content synthesis, and file writing
-
-**Agent Task Specification**:
-
-```
-Task(
-  subagent_type: "general-purpose",
-  description: "Generate tech stack SKILL: {CONTEXT_PATH}",
-  prompt: "
-Generate a complete tech stack SKILL package with Exa research.
-
-**Context Provided**:
-- Mode: {MODE}
-- Context Path: {CONTEXT_PATH}
-
-**Templates Available**:
-- Module Format: ~/.claude/workflows/cli-templates/prompts/tech/tech-module-format.txt
-- SKILL Index: ~/.claude/workflows/cli-templates/prompts/tech/tech-skill-index.txt
-
-**Your Responsibilities**:
-
-1. **Extract Tech Stack Information**:
-
-   IF MODE == 'session':
-     - Read `.workflow/active/{session_id}/workflow-session.json`
-     - Read `.workflow/active/{session_id}/.process/context-package.json`
-     - Extract tech_stack: {language, frameworks, libraries}
-     - Build tech stack name: \"{language}-{framework1}-{framework2}\"
-     - Example: \"typescript-react-nextjs\"
-
-   IF MODE == 'direct':
-     - Tech stack name = CONTEXT_PATH
-     - Parse composite: split by '-' delimiter
-     - Example: \"typescript-react-nextjs\" → [\"typescript\", \"react\", \"nextjs\"]
-
-2. **Execute Exa Research** (4-6 parallel queries):
-
-   Base Queries (always execute):
-   - mcp__exa__get_code_context_exa(query: \"{tech} core principles best practices 2025\", tokensNum: 8000)
-   - mcp__exa__get_code_context_exa(query: \"{tech} common patterns architecture examples\", tokensNum: 7000)
-   - mcp__exa__web_search_exa(query: \"{tech} configuration setup tooling 2025\", numResults: 5)
-   - mcp__exa__get_code_context_exa(query: \"{tech} testing strategies\", tokensNum: 5000)
-
-   Component Queries (if composite):
-   - For each additional component:
-     mcp__exa__get_code_context_exa(query: \"{main_tech} {component} integration\", tokensNum: 5000)
-
-3. **Read Module Format Template**:
-
-   Read template for structure guidance:
-   ```bash
-   Read(~/.claude/workflows/cli-templates/prompts/tech/tech-module-format.txt)
-   ```
-
-4. **Synthesize Content into 6 Modules**:
-
-   Follow template structure from tech-module-format.txt:
-   - **principles.md** - Core concepts, philosophies (~3K tokens)
-   - **patterns.md** - Implementation patterns with code examples (~5K tokens)
-   - **practices.md** - Best practices, anti-patterns, pitfalls (~4K tokens)
-   - **testing.md** - Testing strategies, frameworks (~3K tokens)
-   - **config.md** - Setup, configuration, tooling (~3K tokens)
-   - **frameworks.md** - Framework integration (only if composite, ~4K tokens)
-
-   Each module follows template format:
-   - Frontmatter (YAML)
-   - Main sections with clear headings
-   - Code examples from Exa research
-   - Best practices sections
-   - References to Exa sources
-
-5. **Write Files Directly**:
-
-   ```javascript
-   // Create directory
-   bash(mkdir -p \".claude/skills/{tech_stack_name}\")
-
-   // Write each module file using Write tool
-   Write({ file_path: \".claude/skills/{tech_stack_name}/principles.md\", content: ... })
-   Write({ file_path: \".claude/skills/{tech_stack_name}/patterns.md\", content: ... })
-   Write({ file_path: \".claude/skills/{tech_stack_name}/practices.md\", content: ... })
-   Write({ file_path: \".claude/skills/{tech_stack_name}/testing.md\", content: ... })
-   Write({ file_path: \".claude/skills/{tech_stack_name}/config.md\", content: ... })
-   // Write frameworks.md only if composite
-
-   // Write metadata.json
-   Write({
-     file_path: \".claude/skills/{tech_stack_name}/metadata.json\",
-     content: JSON.stringify({
-       tech_stack_name,
-       components,
-       is_composite,
-       generated_at: timestamp,
-       source: \"exa-research\",
-       research_summary: { total_queries, total_sources }
-     })
-   })
-   ```
-
-6. **Report Completion**:
-
-   Provide summary:
-   - Tech stack name
-   - Files created (count)
-   - Exa queries executed
-   - Sources consulted
-
-**CRITICAL**:
-- MUST read external template files before generating content (step 3 for modules, step 4 for index)
-- You have FULL autonomy - read files, execute Exa, synthesize content, write files
-- Do NOT return JSON or structured data - produce actual .md files
-- Handle errors gracefully (Exa failures, missing files, template read failures)
-- If tech stack cannot be determined, ask orchestrator to clarify
-  "
-)
-```
-
-**Completion Criteria**:
-- Agent task executed successfully
-- 5-6 modular files written to `.claude/skills/{tech_stack_name}/`
-- metadata.json written
-- Agent reports completion
-
-**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 module files and create SKILL.md index with loading recommendations
-
-**Steps**:
-
-1. **Verify Generated Files**:
-   ```bash
-   bash(find ".claude/skills/${TECH_STACK_NAME}" -name "*.md" -type f | sort)
-   ```
-
-2. **Read metadata.json**:
-   ```javascript
-   Read(.claude/skills/${TECH_STACK_NAME}/metadata.json)
-   // Extract: tech_stack_name, components, is_composite, research_summary
-   ```
-
-3. **Read Module Headers** (optional, first 20 lines):
-   ```javascript
-   Read(.claude/skills/${TECH_STACK_NAME}/principles.md, limit: 20)
-   // Repeat for other modules
-   ```
-
-4. **Read SKILL Index Template**:
-
-   ```javascript
-   Read(~/.claude/workflows/cli-templates/prompts/tech/tech-skill-index.txt)
-   ```
-
-5. **Generate SKILL.md Index**:
-
-   Follow template from tech-skill-index.txt with variable substitutions:
-   - `{TECH_STACK_NAME}`: From metadata.json
-   - `{MAIN_TECH}`: Primary technology
-   - `{ISO_TIMESTAMP}`: Current timestamp
-   - `{QUERY_COUNT}`: From research_summary
-   - `{SOURCE_COUNT}`: From research_summary
-   - Conditional sections for composite tech stacks
-
-   Template provides structure for:
-   - Frontmatter with metadata
-   - Overview and tech stack description
-   - Module organization (Core/Practical/Config sections)
-   - Loading recommendations (Quick/Implementation/Complete)
-   - Usage guidelines and auto-trigger keywords
-   - Research metadata and version history
-
-6. **Write SKILL.md**:
-   ```javascript
-   Write({
-     file_path: `.claude/skills/${TECH_STACK_NAME}/SKILL.md`,
-     content: generatedIndexMarkdown
-   })
-   ```
-
-**Completion Criteria**:
-- SKILL.md index written
-- All module files verified
-- Loading recommendations included
-
-**TodoWrite**: Mark phase 3 completed
-
-**Final Report**:
-```
-Tech Stack SKILL Package Complete
-
-Tech Stack: {TECH_STACK_NAME}
-Location: .claude/skills/{TECH_STACK_NAME}/
-
-Files: SKILL.md + 5-6 modules + metadata.json
-Exa Research: {queries} queries, {sources} sources
-
-Usage: Skill(command: "{TECH_STACK_NAME}")
-```
-
----
-
-## Implementation Details
-
-### TodoWrite Patterns
-
-**Initialization** (Before Phase 1):
-```javascript
-TodoWrite({todos: [
-  {"content": "Prepare context paths", "status": "in_progress", "activeForm": "Preparing context paths"},
-  {"content": "Agent produces all module files", "status": "pending", "activeForm": "Agent producing files"},
-  {"content": "Generate SKILL.md index", "status": "pending", "activeForm": "Generating SKILL index"}
-]})
-```
-
-**Full Path** (SKIP_GENERATION = false):
-```javascript
-// After Phase 1
-TodoWrite({todos: [
-  {"content": "Prepare context paths", "status": "completed", ...},
-  {"content": "Agent produces all module files", "status": "in_progress", ...},
-  {"content": "Generate SKILL.md index", "status": "pending", ...}
-]})
-
-// After Phase 2
-TodoWrite({todos: [
-  {"content": "Prepare context paths", "status": "completed", ...},
-  {"content": "Agent produces all module files", "status": "completed", ...},
-  {"content": "Generate SKILL.md index", "status": "in_progress", ...}
-]})
-
-// After Phase 3
-TodoWrite({todos: [
-  {"content": "Prepare context paths", "status": "completed", ...},
-  {"content": "Agent produces all module 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": "Prepare context paths", "status": "completed", ...},
-  {"content": "Agent produces all module files", "status": "completed", ...},  // Skipped
-  {"content": "Generate SKILL.md index", "status": "in_progress", ...}
-]})
-```
-
-### Execution Flow
-
-**Full Path**:
-```
-User → TodoWrite Init → Phase 1 (prepare) → Phase 2 (agent writes files) → Phase 3 (write index) → Report
-```
-
-**Skip Path**:
-```
-User → TodoWrite Init → Phase 1 (detect existing) → Phase 3 (update index) → Report
-```
-
-### Error Handling
-
-**Phase 1 Errors**:
-- Invalid session ID: Report error, verify session exists
-- Missing context-package: Warn, fall back to direct mode
-- No tech stack detected: Ask user to specify tech stack name
-
-**Phase 2 Errors (Agent)**:
-- Agent task fails: Retry once, report if fails again
-- Exa API failures: Agent handles internally with retries
-- Incomplete results: Warn user, proceed with partial data if minimum sections available
-
-**Phase 3 Errors**:
-- Write failures: Report which files failed
-- Missing files: Note in SKILL.md, suggest regeneration
-
----
-
-## Parameters
-
-```bash
-/memory:tech-research [session-id | "tech-stack-name"] [--regenerate] [--tool <gemini|qwen>]
-```
-
-**Arguments**:
-- **session-id | tech-stack-name**: Input source (auto-detected by WFS- prefix)
-  - Session mode: `WFS-user-auth-v2` - Extract tech stack from workflow
-  - Direct mode: `"typescript"`, `"typescript-react-nextjs"` - User specifies
-- **--regenerate**: Force regenerate existing SKILL (deletes and recreates)
-- **--tool**: Reserved for future CLI integration (default: gemini)
-
----
-
-## Examples
-
-**Generated File Structure** (for all examples):
-```
-.claude/skills/{tech-stack}/
-├── SKILL.md           # Index (Phase 3)
-├── principles.md      # Agent (Phase 2)
-├── patterns.md        # Agent
-├── practices.md       # Agent
-├── testing.md         # Agent
-├── config.md          # Agent
-├── frameworks.md      # Agent (if composite)
-└── metadata.json      # Agent
-```
-
-### Direct Mode - Single Stack
-
-```bash
-/memory:tech-research "typescript"
-```
-
-**Workflow**:
-1. Phase 1: Detects direct mode, checks existing SKILL
-2. Phase 2: Agent executes 4 Exa queries, writes 5 modules
-3. Phase 3: Generates SKILL.md index
-
-### Direct Mode - Composite Stack
-
-```bash
-/memory:tech-research "typescript-react-nextjs"
-```
-
-**Workflow**:
-1. Phase 1: Decomposes into ["typescript", "react", "nextjs"]
-2. Phase 2: Agent executes 6 Exa queries (4 base + 2 components), writes 6 modules (adds frameworks.md)
-3. Phase 3: Generates SKILL.md index with framework integration
-
-### Session Mode - Extract from Workflow
-
-```bash
-/memory:tech-research WFS-user-auth-20251104
-```
-
-**Workflow**:
-1. Phase 1: Reads session, extracts tech stack: `python-fastapi-sqlalchemy`
-2. Phase 2: Agent researches Python + FastAPI + SQLAlchemy, writes 6 modules
-3. Phase 3: Generates SKILL.md index
-
-### Regenerate Existing
-
-```bash
-/memory:tech-research "react" --regenerate
-```
-
-**Workflow**:
-1. Phase 1: Deletes existing SKILL due to --regenerate
-2. Phase 2: Agent executes fresh Exa research (latest 2025 practices)
-3. Phase 3: Generates updated SKILL.md
-
-### Skip Path - Fast Update
-
-```bash
-/memory:tech-research "python"
-```
-
-**Scenario**: SKILL already exists with 7 files
-
-**Workflow**:
-1. Phase 1: Detects existing SKILL, sets SKIP_GENERATION = true
-2. Phase 2: **SKIPPED**
-3. Phase 3: Updates SKILL.md index only (5-10x faster)
-
-

.claude/commands/memory/tips.md

@@ -0,0 +1,332 @@
+---
+name: tips
+description: Quick note-taking command to capture ideas, snippets, reminders, and insights for later reference
+argument-hint: "<note content> [--tag <tag1,tag2>] [--context <context>]"
+allowed-tools: mcp__ccw-tools__core_memory(*), Read(*)
+examples:
+  - /memory:tips "Remember to use Redis for rate limiting"
+  - /memory:tips "Auth pattern: JWT with refresh tokens" --tag architecture,auth
+  - /memory:tips "Bug: memory leak in WebSocket handler after 24h" --context websocket-service
+  - /memory:tips "Performance: lazy loading reduced bundle by 40%" --tag performance
+---
+
+# Memory Tips Command (/memory:tips)
+
+## 1. Overview
+
+The `memory:tips` command provides **quick note-taking** for capturing:
+- Quick ideas and insights
+- Code snippets and patterns
+- Reminders and follow-ups
+- Bug notes and debugging hints
+- Performance observations
+- Architecture decisions
+- Library/tool recommendations
+
+**Core Philosophy**:
+- **Speed First**: Minimal friction for capturing thoughts
+- **Searchable**: Tagged for easy retrieval
+- **Context-Aware**: Optional context linking
+- **Lightweight**: No complex session analysis
+
+## 2. Parameters
+
+- `<note content>` (Required): The tip/note content to save
+- `--tag <tags>` (Optional): Comma-separated tags for categorization
+- `--context <context>` (Optional): Related context (file, module, feature)
+
+**Examples**:
+```bash
+/memory:tips "Use Zod for runtime validation - better DX than class-validator"
+/memory:tips "Redis connection pool: max 10, min 2" --tag config,redis
+/memory:tips "Fix needed: race condition in payment processor" --tag bug,payment --context src/payments
+```
+
+## 3. Structured Output Format
+
+```markdown
+## Tip ID
+TIP-YYYYMMDD-HHMMSS
+
+## Timestamp
+YYYY-MM-DD HH:MM:SS
+
+## Project Root
+[Absolute path to project root, e.g., D:\Claude_dms3]
+
+## Content
+[The tip/note content exactly as provided]
+
+## Tags
+[Comma-separated tags, or (none)]
+
+## Context
+[Optional context linking - file, module, or feature reference]
+
+## Session Link
+[WFS-ID if workflow session active, otherwise (none)]
+
+## Auto-Detected Context
+[Files/topics from current conversation if relevant]
+```
+
+## 4. Field Definitions
+
+| Field | Purpose | Example |
+|-------|---------|---------|
+| **Tip ID** | Unique identifier with timestamp | TIP-20260128-143052 |
+| **Timestamp** | When tip was created | 2026-01-28 14:30:52 |
+| **Project Root** | Current project path | D:\Claude_dms3 |
+| **Content** | The actual tip/note | "Use Redis for rate limiting" |
+| **Tags** | Categorization labels | architecture, auth, performance |
+| **Context** | Related code/feature | src/auth/**, payment-module |
+| **Session Link** | Link to workflow session | WFS-auth-20260128 |
+| **Auto-Detected Context** | Files from conversation | src/api/handler.ts |
+
+## 5. Execution Flow
+
+### Step 1: Parse Arguments
+
+```javascript
+const parseTipsCommand = (input) => {
+  // Extract note content (everything before flags)
+  const contentMatch = input.match(/^"([^"]+)"|^([^\s-]+)/);
+  const content = contentMatch ? (contentMatch[1] || contentMatch[2]) : '';
+
+  // Extract tags
+  const tagsMatch = input.match(/--tag\s+([^\s-]+)/);
+  const tags = tagsMatch ? tagsMatch[1].split(',').map(t => t.trim()) : [];
+
+  // Extract context
+  const contextMatch = input.match(/--context\s+([^\s-]+)/);
+  const context = contextMatch ? contextMatch[1] : '';
+
+  return { content, tags, context };
+};
+```
+
+### Step 2: Gather Context
+
+```javascript
+const gatherTipContext = async () => {
+  // Get project root
+  const projectRoot = process.cwd(); // or detect from environment
+
+  // Get current session if active
+  const manifest = await mcp__ccw-tools__session_manager({
+    operation: "list",
+    location: "active"
+  });
+  const sessionId = manifest.sessions?.[0]?.id || null;
+
+  // Auto-detect files from recent conversation
+  const recentFiles = extractRecentFilesFromConversation(); // Last 5 messages
+
+  return {
+    projectRoot,
+    sessionId,
+    autoDetectedContext: recentFiles
+  };
+};
+```
+
+### Step 3: Generate Structured Text
+
+```javascript
+const generateTipText = (parsed, context) => {
+  const timestamp = new Date().toISOString().replace('T', ' ').slice(0, 19);
+  const tipId = `TIP-${new Date().toISOString().slice(0,10).replace(/-/g, '')}-${new Date().toTimeString().slice(0,8).replace(/:/g, '')}`;
+
+  return `## Tip ID
+${tipId}
+
+## Timestamp
+${timestamp}
+
+## Project Root
+${context.projectRoot}
+
+## Content
+${parsed.content}
+
+## Tags
+${parsed.tags.length > 0 ? parsed.tags.join(', ') : '(none)'}
+
+## Context
+${parsed.context || '(none)'}
+
+## Session Link
+${context.sessionId || '(none)'}
+
+## Auto-Detected Context
+${context.autoDetectedContext.length > 0
+  ? context.autoDetectedContext.map(f => `- ${f}`).join('\n')
+  : '(none)'}`;
+};
+```
+
+### Step 4: Save to Core Memory
+
+```javascript
+mcp__ccw-tools__core_memory({
+  operation: "import",
+  text: structuredText
+})
+```
+
+**Response Format**:
+```json
+{
+  "operation": "import",
+  "id": "CMEM-YYYYMMDD-HHMMSS",
+  "message": "Created memory: CMEM-YYYYMMDD-HHMMSS"
+}
+```
+
+### Step 5: Confirm to User
+
+```
+✓ Tip saved successfully
+
+  ID: CMEM-YYYYMMDD-HHMMSS
+  Tags: architecture, auth
+  Context: src/auth/**
+
+  To retrieve: /memory:search "auth patterns"
+  Or via MCP: core_memory(operation="search", query="auth")
+```
+
+## 6. Tag Categories (Suggested)
+
+**Technical**:
+- `architecture` - Design decisions and patterns
+- `performance` - Optimization insights
+- `security` - Security considerations
+- `bug` - Bug notes and fixes
+- `config` - Configuration settings
+- `api` - API design patterns
+
+**Development**:
+- `testing` - Test strategies and patterns
+- `debugging` - Debugging techniques
+- `refactoring` - Refactoring notes
+- `documentation` - Doc improvements
+
+**Domain Specific**:
+- `auth` - Authentication/authorization
+- `database` - Database patterns
+- `frontend` - UI/UX patterns
+- `backend` - Backend logic
+- `devops` - Infrastructure and deployment
+
+**Organizational**:
+- `reminder` - Follow-up items
+- `research` - Research findings
+- `idea` - Feature ideas
+- `review` - Code review notes
+
+## 7. Search Integration
+
+Tips can be retrieved using:
+
+```bash
+# Via command (if /memory:search exists)
+/memory:search "rate limiting"
+
+# Via MCP tool
+mcp__ccw-tools__core_memory({
+  operation: "search",
+  query: "rate limiting",
+  source_type: "core_memory",
+  top_k: 10
+})
+
+# Via CLI
+ccw core-memory search --query "rate limiting" --top-k 10
+```
+
+## 8. Quality Checklist
+
+Before saving:
+- [ ] Content is clear and actionable
+- [ ] Tags are relevant and consistent
+- [ ] Context provides enough reference
+- [ ] Auto-detected context is accurate
+- [ ] Project root is absolute path
+- [ ] Timestamp is properly formatted
+
+## 9. Best Practices
+
+### Good Tips Examples
+
+✅ **Specific and Actionable**:
+```
+"Use connection pooling for Redis: { max: 10, min: 2, acquireTimeoutMillis: 30000 }"
+--tag config,redis
+```
+
+✅ **With Context**:
+```
+"Auth middleware must validate both access and refresh tokens"
+--tag security,auth --context src/middleware/auth.ts
+```
+
+✅ **Problem + Solution**:
+```
+"Memory leak fixed by unsubscribing event listeners in componentWillUnmount"
+--tag bug,react --context src/components/Chat.tsx
+```
+
+### Poor Tips Examples
+
+❌ **Too Vague**:
+```
+"Fix the bug" --tag bug
+```
+
+❌ **Too Long** (use /memory:compact instead):
+```
+"Here's the complete implementation plan for the entire auth system... [3 paragraphs]"
+```
+
+❌ **No Context**:
+```
+"Remember to update this later"
+```
+
+## 10. Use Cases
+
+### During Development
+```bash
+/memory:tips "JWT secret must be 256-bit minimum" --tag security,auth
+/memory:tips "Use debounce (300ms) for search input" --tag performance,ux
+```
+
+### After Bug Fixes
+```bash
+/memory:tips "Race condition in payment: lock with Redis SETNX" --tag bug,payment
+```
+
+### Code Review Insights
+```bash
+/memory:tips "Prefer early returns over nested ifs" --tag style,readability
+```
+
+### Architecture Decisions
+```bash
+/memory:tips "Chose PostgreSQL over MongoDB for ACID compliance" --tag architecture,database
+```
+
+### Library Recommendations
+```bash
+/memory:tips "Zod > Yup for TypeScript validation - better type inference" --tag library,typescript
+```
+
+## 11. Notes
+
+- **Frequency**: Use liberally - capture all valuable insights
+- **Retrieval**: Search by tags, content, or context
+- **Lifecycle**: Tips persist across sessions
+- **Organization**: Tags enable filtering and categorization
+- **Integration**: Can reference tips in later workflows
+- **Lightweight**: No complex session analysis required

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

@@ -99,10 +99,10 @@ src/ (depth 1) → SINGLE-LAYER STRATEGY
 Bash({command: "git add -A 2>/dev/null || true", run_in_background: false});
 
 // Get module structure
-Bash({command: "~/.claude/scripts/get_modules_by_depth.sh list", run_in_background: false});
+Bash({command: "ccw tool exec get_modules_by_depth '{\"format\":\"list\"}'", run_in_background: false});
 
 // OR with --path
-Bash({command: "cd <target-path> && ~/.claude/scripts/get_modules_by_depth.sh list", run_in_background: false});
+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.
@@ -185,7 +185,7 @@ for (let layer of [3, 2, 1]) {
         let strategy = module.depth >= 3 ? "multi-layer" : "single-layer";
         for (let tool of tool_order) {
           Bash({
-            command: `cd ${module.path} && ~/.claude/scripts/update_module_claude.sh "${strategy}" "." "${tool}"`,
+            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) {
@@ -244,7 +244,7 @@ MODULES:
 
 TOOLS (try in order): {{tool_1}}, {{tool_2}}, {{tool_3}}
 
-EXECUTION SCRIPT: ~/.claude/scripts/update_module_claude.sh
+EXECUTION SCRIPT: ccw tool exec update_module_claude
   - Accepts strategy parameter: multi-layer | single-layer
   - Tool execution via direct CLI commands (gemini/qwen/codex)
 
@@ -252,7 +252,7 @@ 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}}" && ~/.claude/scripts/update_module_claude.sh "{{strategy}}" "." "${tool}"`,
+         command: `cd "{{module_path}}" && ccw tool exec update_module_claude '{"strategy":"{{strategy}}","path":".","tool":"${tool}"}'`,
          run_in_background: false
        })
        exit_code=$?

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

@@ -41,7 +41,7 @@ Orchestrates context-aware CLAUDE.md updates for changed modules using batched a
 
 ```javascript
 // Detect changed modules
-Bash({command: "~/.claude/scripts/detect_changed_modules.sh list", run_in_background: false});
+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});
@@ -102,7 +102,7 @@ for (let depth of sorted_depths.reverse()) {  // N → 0
       return async () => {
         for (let tool of tool_order) {
           Bash({
-            command: `cd ${module.path} && ~/.claude/scripts/update_module_claude.sh "single-layer" "." "${tool}"`,
+            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) {
@@ -184,21 +184,21 @@ EXECUTION:
 For each module above:
   1. Try tool 1:
      Bash({
-       command: `cd "{{module_path}}" && ~/.claude/scripts/update_module_claude.sh "single-layer" "." "{{tool_1}}"`,
+       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}}" && ~/.claude/scripts/update_module_claude.sh "single-layer" "." "{{tool_2}}"`,
+       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}}" && ~/.claude/scripts/update_module_claude.sh "single-layer" "." "{{tool_3}}"`,
+       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

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

@@ -1,517 +0,0 @@
----
-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:
-   cd .workflow/.archives/{session_id} && gemini -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
-   "
-
-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:
-   gemini -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
-   "
-
-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,204 +0,0 @@
----
-name: breakdown
-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
-Breaks down complex tasks into executable subtasks with context inheritance and agent assignment.
-
-## Core Principles
-**File Cohesion:** Related files must stay in same task
-**10-Task Limit:** Total tasks cannot exceed 10 (triggers re-scoping)
-
-## Core Features
-
-**CRITICAL**: Manual breakdown with safety controls to prevent file conflicts and task limit violations.
-
-### 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
-- **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
-```
-
-Interactive process:
-```
-Task: Build authentication module
-Current total tasks: 6/10
-
-MANUAL BREAKDOWN REQUIRED
-Define subtasks manually (remaining capacity: 4 tasks):
-
-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
-```
-
-## Decomposition Logic
-
-### 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)
-
-### Context Inheritance
-- Subtasks inherit parent requirements
-- Scope refined for specific subtask
-- Implementation details distributed appropriately
-
-## Safety Controls
-
-### 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
-
-### 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
-
-### 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
-
-### 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
-
-## Implementation Details
-
-- Complete task JSON schema
-- Implementation field structure
-- Context inheritance rules
-- Agent assignment logic
-
-## Validation
-
-### Pre-breakdown Checks
-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 to `container` status
-2. Create subtask JSON files
-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
-
-### Basic Breakdown
-```bash
-/task:breakdown impl-1
-
-impl-1: Build authentication (container)
-  ├── 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
-
-# Already broken down
-Task IMPL-1 already has subtasks
-
-# 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.
-```
-
-**System ensures**: Manual breakdown control with file cohesion enforcement, similar functionality detection, and 10-task limit compliance

.claude/commands/task/create.md

@@ -1,152 +0,0 @@
----
-name: create
-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 with automatic context awareness and ID generation.
-
-## Core Principles
-**Task System:** @~/.claude/workflows/task-core.md
-
-## Core Features
-
-### Automatic Behaviors
-- **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"
-- **Agent Assignment**: Suggests agent based on task type
-- **Session Integration**: Updates workflow session stats
-
-### Context Awareness
-- Validates active workflow session exists
-- Avoids duplicate task IDs
-- Inherits session requirements and scope
-- Suggests task relationships
-
-## Usage
-
-### Basic Creation
-```bash
-/task:create "Build authentication module"
-```
-
-Output:
-```
-Task created: IMPL-1
-Title: Build authentication module
-Type: feature
-Agent: code-developer
-Status: pending
-```
-
-### Task Types
-- `feature` - New functionality (default)
-- `bugfix` - Bug fixes
-- `refactor` - Code improvements
-- `test` - Test implementation
-- `docs` - Documentation
-
-## Task Creation Process
-
-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
-
-**Task Schema**: See @~/.claude/workflows/task-core.md for complete JSON structure
-
-## 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
-```
-
-## File Management
-
-### JSON Task File
-- **Location**: `.task/IMPL-[N].json` in active session
-- **Content**: Complete task with implementation field
-- **Updates**: Session stats only
-
-### Simple Process
-1. Validate session and inputs
-2. Generate task JSON
-3. Update session stats
-4. Notify completion
-
-## Context Inheritance
-
-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)
-
-## Agent Assignment
-
-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. **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
-# No workflow session
-No active workflow found
-Use: /workflow init "project name"
-
-# Duplicate task
-Similar task exists: IMPL-3
-Continue anyway? (y/n)
-
-# Max depth exceeded
-Cannot create IMPL-1.2.1 (max 2 levels)
-Use: IMPL-2 for new main task
-```
-
-## Examples
-
-### Feature Task
-```bash
-/task:create "Implement user authentication"
-
-Created IMPL-1: Implement user authentication
-Type: feature
-Agent: code-developer
-Status: pending
-```
-
-### Bug Fix
-```bash
-/task:create "Fix login validation bug" --type=bugfix
-
-Created IMPL-2: Fix login validation bug
-Type: bugfix
-Agent: code-developer
-Status: pending
-```

.claude/commands/task/execute.md

@@ -1,270 +0,0 @@
----
-name: execute
-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
-
-**Purpose**: Executes tasks using intelligent agent selection, context preparation, and progress tracking.
-
-
-## Execution Modes
-
--   **auto (Default)**
-    -   Fully autonomous execution with automatic agent selection.
-    -   Provides progress updates at each checkpoint.
-    -   Automatically completes the task when done.
--   **guided**
-    -   Executes step-by-step, requiring user confirmation at each checkpoint.
-    -   Allows for dynamic adjustments and manual review during the process.
--   **review**
-    -   Optional manual review using `@universal-executor`.
-    -   Used only when explicitly requested by user.
-
-## Agent Selection Logic
-
-The system determines the appropriate agent for a task using the following logic.
-
-```pseudo
-FUNCTION select_agent(task, agent_override):
-    // A manual override always takes precedence.
-    // Corresponds to the --agent=<agent-type> flag.
-    IF agent_override IS NOT NULL:
-        RETURN agent_override
-
-    // If no override, select based on keywords in the task title.
-    ELSE:
-        CASE task.title:
-            WHEN CONTAINS "Build API", "Implement":
-                RETURN "@code-developer"
-            WHEN CONTAINS "Design schema", "Plan":
-                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 "@universal-executor" // Optional manual review
-            DEFAULT:
-                RETURN "@code-developer" // Default agent
-        END CASE
-END FUNCTION
-```
-
-## Core Execution Protocol
-
-`Pre-Execution` -> `Execution` -> `Post-Execution`
-
-### 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
-
-`Update Task Status` **->** `Generate Summary` **->** `Save Artifacts` **->** `Sync All Progress` **->** `Validate File Integrity`
-
--   Updates status in the task's JSON file and `TODO_LIST.md`.
--   Creates a summary in `.summaries/`.
--   Stores outputs and syncs progress across the entire workflow session.
-
-### Task & Subtask Execution Logic
-
-This logic defines how single, multiple, or parent tasks are handled.
-
-```pseudo
-FUNCTION execute_task_command(task_id, mode, parallel_flag):
-    // Handle parent tasks by executing their subtasks.
-    IF is_parent_task(task_id):
-        subtasks = get_subtasks(task_id)
-        EXECUTE_SUBTASK_BATCH(subtasks, mode)
-
-    // Handle wildcard execution (e.g., IMPL-001.*)
-    ELSE IF task_id CONTAINS "*":
-        subtasks = find_matching_tasks(task_id)
-        IF parallel_flag IS true:
-            EXECUTE_IN_PARALLEL(subtasks)
-        ELSE:
-            FOR each subtask in subtasks:
-                EXECUTE_SINGLE_TASK(subtask, mode)
-  
-    // Default case for a single task ID.
-    ELSE:
-        EXECUTE_SINGLE_TASK(task_id, mode)
-END FUNCTION
-```
-
-### Error Handling & Recovery Logic
-
-```pseudo
-FUNCTION pre_execution_check(task):
-    // Ensure dependencies are met before starting.
-    IF task.dependencies ARE NOT MET:
-        LOG_ERROR("Cannot execute " + task.id)
-        LOG_INFO("Blocked by: " + unmet_dependencies)
-        HALT_EXECUTION()
-
-FUNCTION on_execution_failure(checkpoint):
-    // Provide user with recovery options upon failure.
-    LOG_WARNING("Execution failed at checkpoint " + checkpoint)
-    PRESENT_OPTIONS([
-        "Retry from checkpoint",
-        "Retry from beginning",
-        "Switch to guided mode",
-        "Abort execution"
-    ])
-    AWAIT user_input
-    // System performs the selected action.
-END FUNCTION
-```
-
-
-### Simplified Context Structure (JSON)
-
-This is the simplified data structure loaded to provide context for task execution.
-
-```json
-{
-  "task": {
-    "id": "IMPL-1",
-    "title": "Build authentication module",
-    "type": "feature",
-    "status": "active",
-    "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": ["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",
-    "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",
-    "mode": "auto",
-    "attempts": 0
-  }
-}
-```
-
-### Agent-Specific Context
-
-Different agents receive context tailored to their function, including implementation details:
-
-**`@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
-
-Optional summary file generated at `.summaries/IMPL-[task-id]-summary.md`.
-
-```markdown
-# Task Summary: IMPL-1 Build Authentication Module
-
-## What Was Done
-- Created src/auth/login.ts with JWT validation
-- Added tests in tests/auth.test.ts
-
-## Execution Results
-- **Agent**: code-developer
-- **Status**: completed
-
-## Files Modified
-- `src/auth/login.ts` (created)
-- `tests/auth.test.ts` (created)
-```

.claude/commands/task/replan.md

@@ -1,437 +0,0 @@
----
-name: replan
-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 or batch processes multiple tasks with change tracking and backup management.
-
-**Modes**:
-- **Single Task Mode**: Replan one task with specific changes
-- **Batch Mode**: Process multiple tasks from action-plan verification report
-
-## 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**: Validates active session before replanning
-
-## Operation Modes
-
-### Single Task Mode
-
-#### Direct Text (Default)
-```bash
-/task:replan IMPL-1 "Add OAuth2 authentication support"
-```
-
-#### File-based Input
-```bash
-/task:replan IMPL-1 updated-specs.md
-```
-Supports: .md, .txt, .json, .yaml
-
-#### Interactive Mode
-```bash
-/task:replan IMPL-1 --interactive
-```
-Guided step-by-step modification process with validation
-
-### Batch Mode
-
-#### From Verification Report
-```bash
-/task:replan --batch ACTION_PLAN_VERIFICATION.md
-```
-
-**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
-
-**Auto-detection**: If input file contains "Action Plan Verification Report" header, automatically enters batch mode
-
-## Replanning Process
-
-### Single Task Process
-
-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
-
-### Batch Process
-
-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",
-  "version": "1.2",
-  "replan_history": [
-    {
-      "version": "1.2",
-      "reason": "Add OAuth2 support",
-      "input_source": "direct_text",
-      "backup_location": ".task/backup/IMPL-1-v1.1.json",
-      "timestamp": "2025-10-17T10:30:00Z"
-    }
-  ]
-}
-```
-
-**Complete schema**: See @~/.claude/workflows/task-core.md
-
-### File Structure
-```
-.task/
-├── 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]
-```
-
-**Backup Naming**: `{task-id}-v{version}.json`
-
-## Implementation Updates
-
-### Change Detection
-Tracks modifications to:
-- Files in implementation.files array
-- Dependencies and affected modules
-- Risk assessments and performance notes
-- Logic flows and code locations
-
-### Analysis Triggers
-May require gemini re-analysis when:
-- New files need code extraction
-- Function locations change
-- Dependencies require re-evaluation
-
-## Document Updates
-
-### Planning Document
-May update IMPL_PLAN.md sections when task structure changes significantly
-
-### 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
-
-### 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
-**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
-```
-
-### Batch Report
-After completion, generates summary:
-```markdown
-## Batch Replan Summary
-
-**Total Tasks**: 4
-**Successful**: 3
-**Failed**: 1
-**Skipped**: 0
-
-### 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)
-```
-
-## Examples
-
-### Single Task - Text Input
-```bash
-/task:replan IMPL-1 "Add OAuth2 authentication support"
-
-Processing changes...
-Proposed updates:
-+ Add OAuth2 integration
-+ Update authentication flow
-
-# 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
-  }]
-})
-
-User selected: "Yes, apply"
-
-Version 1.2 created
-Context updated
-Backup saved to .task/backup/IMPL-1-v1.1.json
-```
-
-### Single Task - File Input
-```bash
-/task:replan IMPL-2 requirements.md
-
-Loading requirements.md...
-Applying specification changes...
-
-Task updated with new requirements
-Version 1.1 created
-Backup saved to .task/backup/IMPL-2-v1.0.json
-```
-
-### Batch Mode - From Verification Report
-```bash
-/task:replan --batch .workflow/active/WFS-{session}/.process/ACTION_PLAN_VERIFICATION.md
-
-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
-
-Creating task tracking list...
-
-Processing IMPL-002...
-Backup created: .task/backup/IMPL-002-v1.0.json
-Updated to v1.1
-
-Processing IMPL-003...
-Backup created: .task/backup/IMPL-003-v1.0.json
-Updated to v1.1
-
-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
-```
-
-### Batch Mode - Auto-detection
-```bash
-# If file contains "Action Plan Verification Report", auto-enters batch mode
-/task:replan ACTION_PLAN_VERIFICATION.md
-
-Detected verification report format
-Entering batch mode...
-[same as above]
-```
-
-## Error Handling
-
-### Single Task Errors
-```bash
-# Task not found
-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
-
-# File not found
-File requirements.md not found
-Check file path
-
-# No input provided
-Please specify changes needed
-Provide text, file, or verification report
-```
-
-### Batch Mode Errors
-```bash
-# Invalid verification report
-File does not contain valid verification report format
-Check report structure or use single task mode
-
-# Partial failures
-Batch completed with errors: 3/4 successful
-Review error details in summary report
-
-# No replan recommendations found
-Verification report contains no replan recommendations
-Check report content or use /workflow:action-plan-verify first
-```
-
-## Batch Mode Integration
-
-### Input Format Expectations
-Batch mode parses verification reports looking for:
-
-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
-
-**Example Patterns**:
-```markdown
-#### 1. HIGH Priority - Address FR Coverage Gaps
-/task:replan IMPL-004 "
-Add explicit acceptance criteria:
-- FR-09: Response surface 3D visualization
-"
-
-#### 2. MEDIUM Priority - Enhance NFR Coverage
-/task:replan IMPL-008 "
-Add performance testing:
-- NFR-01: Load test API endpoints
-"
-```
-
-### 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
-
-### Confirmation Behavior
-- **Default**: Confirm each task before applying
-- **With `--auto-confirm`**: Apply all changes without prompting
-  ```bash
-  /task:replan --batch report.md --auto-confirm
-  ```
-
-## Implementation Details
-
-### Backup Management
-```typescript
-// Backup file naming convention
-const backupPath = `.task/backup/${taskId}-v${previousVersion}.json`;
-
-// 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/version.md

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

@@ -0,0 +1,367 @@
+---
+name: ccw view
+description: Dashboard - Open CCW workflow dashboard for managing tasks and sessions
+category: general
+---
+
+# CCW View Command
+
+Open the CCW workflow dashboard for visualizing and managing project tasks, sessions, and workflow execution status.
+
+## Description
+
+`ccw view` launches an interactive web dashboard that provides:
+- **Workflow Overview**: Visualize current workflow status and command chain execution
+- **Session Management**: View and manage active workflow sessions
+- **Task Tracking**: Monitor TODO items and task progress
+- **Workspace Switching**: Switch between different project workspaces
+- **Real-time Updates**: Live updates of command execution and status
+
+## Usage
+
+```bash
+# Open dashboard for current workspace
+ccw view
+
+# Specify workspace path
+ccw view --path /path/to/workspace
+
+# Custom port (default: 3456)
+ccw view --port 3000
+
+# Bind to specific host
+ccw view --host 0.0.0.0 --port 3456
+
+# Open without launching browser
+ccw view --no-browser
+
+# Show URL without opening browser
+ccw view --no-browser
+```
+
+## Options
+
+| Option | Default | Description |
+|--------|---------|-------------|
+| `--path <path>` | Current directory | Workspace path to display |
+| `--port <port>` | 3456 | Server port for dashboard |
+| `--host <host>` | 127.0.0.1 | Server host/bind address |
+| `--no-browser` | false | Don't launch browser automatically |
+| `-h, --help` | - | Show help message |
+
+## Features
+
+### Dashboard Sections
+
+#### 1. **Workflow Overview**
+- Current workflow status
+- Command chain visualization (with Minimum Execution Units marked)
+- Live progress tracking
+- Error alerts
+
+#### 2. **Session Management**
+- List active sessions by type (workflow, review, tdd)
+- Session details (created time, last activity, session ID)
+- Quick actions (resume, pause, complete)
+- Session logs/history
+
+#### 3. **Task Tracking**
+- TODO list with status indicators
+- Progress percentage
+- Task grouping by workflow stage
+- Quick inline task updates
+
+#### 4. **Workspace Switcher**
+- Browse available workspaces
+- Switch context with one click
+- Recent workspaces list
+
+#### 5. **Command History**
+- Recent commands executed
+- Execution time and status
+- Quick re-run options
+
+### Keyboard Shortcuts
+
+| Shortcut | Action |
+|----------|--------|
+| `R` | Refresh dashboard |
+| `Cmd/Ctrl + J` | Jump to session search |
+| `Cmd/Ctrl + K` | Open command palette |
+| `?` | Show help |
+
+## Multi-Instance Support
+
+The dashboard supports multiple concurrent instances:
+
+```bash
+# Terminal 1: Workspace A on port 3456
+ccw view --path ~/projects/workspace-a
+
+# Terminal 2: Workspace B on port 3457
+ccw view --path ~/projects/workspace-b --port 3457
+
+# Switching workspaces on the same port
+ccw view --path ~/projects/workspace-c  # Auto-switches existing server
+```
+
+When the server is already running and you execute `ccw view` with a different path:
+1. Detects running server on the port
+2. Sends workspace switch request
+3. Updates dashboard to new workspace
+4. Opens browser with updated context
+
+## Server Lifecycle
+
+### Startup
+
+```
+ccw view
+  ├─ Check if server running on port
+  │  ├─ If yes: Send switch-path request
+  │  └─ If no: Start new server
+  ├─ Launch browser (unless --no-browser)
+  └─ Display dashboard URL
+```
+
+### Running
+
+The dashboard server continues running until:
+- User explicitly stops it (Ctrl+C)
+- All connections close after timeout
+- System shutdown
+
+### Multiple Workspaces
+
+Switching to a different workspace keeps the same server instance:
+```
+Server State Before: workspace-a on port 3456
+ccw view --path ~/projects/workspace-b
+Server State After: workspace-b on port 3456 (same instance)
+```
+
+## Environment Variables
+
+```bash
+# Set default port
+export CCW_VIEW_PORT=4000
+ccw view  # Uses port 4000
+
+# Set default host
+export CCW_VIEW_HOST=localhost
+ccw view --port 3456  # Binds to localhost:3456
+
+# Disable browser launch by default
+export CCW_VIEW_NO_BROWSER=true
+ccw view  # Won't auto-launch browser
+```
+
+## Integration with CCW Workflows
+
+The dashboard is fully integrated with CCW commands:
+
+### Viewing Workflow Progress
+
+```bash
+# Start a workflow
+ccw "Add user authentication"
+
+# In another terminal, view progress
+ccw view  # Shows execution progress in real-time
+```
+
+### Session Management from Dashboard
+
+- Start new session: Click "New Session" button
+- Resume paused session: Sessions list → Resume button
+- View session logs: Click session name
+- Complete session: Sessions list → Complete button
+
+### Real-time Command Execution
+
+- View active command chain execution
+- Watch command transition through Minimum Execution Units
+- See error alerts and recovery options
+- View command output logs
+
+## Troubleshooting
+
+### Port Already in Use
+
+```bash
+# Use different port
+ccw view --port 3457
+
+# Or kill existing server
+lsof -i :3456  # Find process
+kill -9 <pid>   # Kill it
+ccw view        # Start fresh
+```
+
+### Dashboard Not Loading
+
+```bash
+# Try without browser
+ccw view --no-browser
+
+# Check server logs
+tail -f ~/.ccw/logs/dashboard.log
+
+# Verify network access
+curl http://localhost:3456/api/health
+```
+
+### Workspace Path Not Found
+
+```bash
+# Use full absolute path
+ccw view --path "$(pwd)"
+
+# Or specify explicit path
+ccw view --path ~/projects/my-project
+```
+
+## Related Commands
+
+- **`/ccw`** - Main workflow orchestrator
+- **`/workflow:session:list`** - List workflow sessions
+- **`/workflow:session:resume`** - Resume paused session
+- **`/memory:compact`** - Compact session memory for dashboard display
+
+## Examples
+
+### Basic Dashboard View
+
+```bash
+cd ~/projects/my-app
+ccw view
+# → Launches http://localhost:3456 in browser
+```
+
+### Network-Accessible Dashboard
+
+```bash
+# Allow remote access
+ccw view --host 0.0.0.0 --port 3000
+# → Dashboard accessible at http://machine-ip:3000
+```
+
+### Multiple Workspaces on Different Ports
+
+```bash
+# Terminal 1: Main project
+ccw view --path ~/projects/main --port 3456
+
+# Terminal 2: Side project
+ccw view --path ~/projects/side --port 3457
+
+# View both simultaneously
+# → http://localhost:3456 (main)
+# → http://localhost:3457 (side)
+```
+
+### Headless Dashboard
+
+```bash
+# Run dashboard without browser
+ccw view --port 3000 --no-browser
+echo "Dashboard available at http://localhost:3000"
+
+# Share URL with team
+# Can be proxied through nginx/port forwarding
+```
+
+### Environment-Based Configuration
+
+```bash
+# Script for CI/CD
+export CCW_VIEW_HOST=0.0.0.0
+export CCW_VIEW_PORT=8080
+ccw view --path /workspace
+
+# → Dashboard accessible on port 8080 to all interfaces
+```
+
+## Dashboard Pages
+
+### Overview Page (`/`)
+- Current workflow status
+- Active sessions summary
+- Recent commands
+- System health indicators
+
+### Sessions Page (`/sessions`)
+- All sessions (grouped by type)
+- Session details and metadata
+- Session logs viewer
+- Quick actions (resume/complete)
+
+### Tasks Page (`/tasks`)
+- Current TODO items
+- Progress tracking
+- Inline task editing
+- Workflow history
+
+### Workspace Page (`/workspace`)
+- Current workspace info
+- Available workspaces
+- Workspace switcher
+- Workspace settings
+
+### Settings Page (`/settings`)
+- Port configuration
+- Theme preferences
+- Auto-refresh settings
+- Export settings
+
+## Server Health Monitoring
+
+The dashboard includes health monitoring:
+
+```bash
+# Check health endpoint
+curl http://localhost:3456/api/health
+# → { "status": "ok", "uptime": 12345 }
+
+# Monitor metrics
+curl http://localhost:3456/api/metrics
+# → { "sessions": 3, "tasks": 15, "lastUpdate": "2025-01-29T10:30:00Z" }
+```
+
+## Advanced Usage
+
+### Custom Port with Dynamic Discovery
+
+```bash
+# Find next available port
+available_port=$(find-available-port 3456)
+ccw view --port $available_port
+
+# Display in CI/CD
+echo "Dashboard: http://localhost:$available_port"
+```
+
+### Dashboard Behind Proxy
+
+```bash
+# Configure nginx reverse proxy
+# Proxy http://proxy.example.com/dashboard → http://localhost:3456
+
+ccw view --host 127.0.0.1 --port 3456
+
+# Access via proxy
+# http://proxy.example.com/dashboard
+```
+
+### Session Export from Dashboard
+
+- View → Sessions → Export JSON
+- Exports session metadata and progress
+- Useful for record-keeping and reporting
+
+## See Also
+
+- **CCW Commands**: `/ccw` - Auto workflow orchestration
+- **Session Management**: `/workflow:session:start`, `/workflow:session:list`
+- **Task Tracking**: `TodoWrite` tool for programmatic task management
+- **Workflow Status**: `/workflow:status` for CLI-based status view

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

@@ -1,447 +0,0 @@
----
-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, use_codex)
-
-### 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/analyze-with-file.md

@@ -0,0 +1,804 @@
+---
+name: analyze-with-file
+description: Interactive collaborative analysis with documented discussions, CLI-assisted exploration, and evolving understanding
+argument-hint: "[-y|--yes] [-c|--continue] \"topic or question\""
+allowed-tools: TodoWrite(*), Task(*), AskUserQuestion(*), Read(*), Grep(*), Glob(*), Bash(*), Edit(*), Write(*)
+---
+
+## Auto Mode
+
+When `--yes` or `-y`: Auto-confirm exploration decisions, use recommended analysis angles.
+
+# Workflow Analyze-With-File Command (/workflow:analyze-with-file)
+
+## Overview
+
+Interactive collaborative analysis workflow with **documented discussion process**. Records understanding evolution, facilitates multi-round Q&A, and uses CLI tools (Gemini/Codex) for deep exploration.
+
+**Core workflow**: Topic → Explore → Discuss → Document → Refine → Conclude
+
+**Key features**:
+- **discussion.md**: Timeline of discussions and understanding evolution
+- **Multi-round Q&A**: Iterative clarification with user
+- **CLI-assisted exploration**: Gemini/Codex for codebase and concept analysis
+- **Consolidated insights**: Synthesizes discussions into actionable conclusions
+- **Flexible continuation**: Resume analysis sessions to build on previous work
+
+## Usage
+
+```bash
+/workflow:analyze-with-file [FLAGS] <TOPIC_OR_QUESTION>
+
+# Flags
+-y, --yes              Skip confirmations, use recommended settings
+-c, --continue         Continue existing session (auto-detected if exists)
+
+# Arguments
+<topic-or-question>    Analysis topic, question, or concept to explore (required)
+
+# Examples
+/workflow:analyze-with-file "如何优化这个项目的认证架构"
+/workflow:analyze-with-file --continue "认证架构"              # Continue existing session
+/workflow:analyze-with-file -y "性能瓶颈分析"                  # Auto mode
+```
+
+## Execution Process
+
+```
+Session Detection:
+   ├─ Check if analysis session exists for topic
+   ├─ EXISTS + discussion.md exists → Continue mode
+   └─ NOT_FOUND → New session mode
+
+Phase 1: Topic Understanding
+   ├─ Parse topic/question
+   ├─ Identify analysis dimensions (architecture, implementation, concept, etc.)
+   ├─ Initial scoping with user (AskUserQuestion)
+   └─ Document initial understanding in discussion.md
+
+Phase 2: CLI Exploration (Parallel)
+   ├─ Launch cli-explore-agent for codebase context
+   ├─ Use Gemini/Codex for deep analysis
+   └─ Aggregate findings into exploration summary
+
+Phase 3: Interactive Discussion (Multi-Round)
+   ├─ Present exploration findings
+   ├─ Facilitate Q&A with user (AskUserQuestion)
+   ├─ Capture user insights and requirements
+   ├─ Update discussion.md with each round
+   └─ Repeat until user is satisfied or clarity achieved
+
+Phase 4: Synthesis & Conclusion
+   ├─ Consolidate all insights
+   ├─ Update discussion.md with conclusions
+   ├─ Generate actionable recommendations
+   └─ Optional: Create follow-up tasks or issues
+
+Output:
+   ├─ .workflow/.analysis/{slug}-{date}/discussion.md (evolving document)
+   ├─ .workflow/.analysis/{slug}-{date}/explorations.json (CLI findings)
+   └─ .workflow/.analysis/{slug}-{date}/conclusions.json (final synthesis)
+```
+
+## Implementation
+
+### Session Setup & Mode Detection
+
+```javascript
+const getUtc8ISOString = () => new Date(Date.now() + 8 * 60 * 60 * 1000).toISOString()
+
+const topicSlug = topic_or_question.toLowerCase().replace(/[^a-z0-9\u4e00-\u9fa5]+/g, '-').substring(0, 40)
+const dateStr = getUtc8ISOString().substring(0, 10)
+
+const sessionId = `ANL-${topicSlug}-${dateStr}`
+const sessionFolder = `.workflow/.analysis/${sessionId}`
+const discussionPath = `${sessionFolder}/discussion.md`
+const explorationsPath = `${sessionFolder}/explorations.json`
+const conclusionsPath = `${sessionFolder}/conclusions.json`
+
+// Auto-detect mode
+const sessionExists = fs.existsSync(sessionFolder)
+const hasDiscussion = sessionExists && fs.existsSync(discussionPath)
+const forcesContinue = $ARGUMENTS.includes('--continue') || $ARGUMENTS.includes('-c')
+
+const mode = (hasDiscussion || forcesContinue) ? 'continue' : 'new'
+
+if (!sessionExists) {
+  bash(`mkdir -p ${sessionFolder}`)
+}
+```
+
+---
+
+### Phase 1: Topic Understanding
+
+**Step 1.1: Parse Topic & Identify Dimensions**
+
+```javascript
+// Analyze topic to determine analysis dimensions
+const ANALYSIS_DIMENSIONS = {
+  architecture: ['架构', 'architecture', 'design', 'structure', '设计'],
+  implementation: ['实现', 'implement', 'code', 'coding', '代码'],
+  performance: ['性能', 'performance', 'optimize', 'bottleneck', '优化'],
+  security: ['安全', 'security', 'auth', 'permission', '权限'],
+  concept: ['概念', 'concept', 'theory', 'principle', '原理'],
+  comparison: ['比较', 'compare', 'vs', 'difference', '区别'],
+  decision: ['决策', 'decision', 'choice', 'tradeoff', '选择']
+}
+
+function identifyDimensions(topic) {
+  const text = topic.toLowerCase()
+  const matched = []
+
+  for (const [dimension, keywords] of Object.entries(ANALYSIS_DIMENSIONS)) {
+    if (keywords.some(k => text.includes(k))) {
+      matched.push(dimension)
+    }
+  }
+
+  return matched.length > 0 ? matched : ['general']
+}
+
+const dimensions = identifyDimensions(topic_or_question)
+```
+
+**Step 1.2: Initial Scoping (New Session Only)**
+
+```javascript
+const autoYes = $ARGUMENTS.includes('--yes') || $ARGUMENTS.includes('-y')
+
+if (mode === 'new' && !autoYes) {
+  // Ask user to scope the analysis
+  AskUserQuestion({
+    questions: [
+      {
+        question: `分析范围: "${topic_or_question}"\n\n您想重点关注哪些方面?`,
+        header: "Focus",
+        multiSelect: true,
+        options: [
+          { label: "代码实现", description: "分析现有代码实现" },
+          { label: "架构设计", description: "架构层面的分析" },
+          { label: "最佳实践", description: "行业最佳实践对比" },
+          { label: "问题诊断", description: "识别潜在问题" }
+        ]
+      },
+      {
+        question: "分析深度?",
+        header: "Depth",
+        multiSelect: false,
+        options: [
+          { label: "Quick Overview", description: "快速概览 (10-15分钟)" },
+          { label: "Standard Analysis", description: "标准分析 (30-60分钟)" },
+          { label: "Deep Dive", description: "深度分析 (1-2小时)" }
+        ]
+      }
+    ]
+  })
+}
+```
+
+**Step 1.3: Create/Update discussion.md**
+
+For new session:
+```markdown
+# Analysis Discussion
+
+**Session ID**: ${sessionId}
+**Topic**: ${topic_or_question}
+**Started**: ${getUtc8ISOString()}
+**Dimensions**: ${dimensions.join(', ')}
+
+---
+
+## User Context
+
+**Focus Areas**: ${userFocusAreas.join(', ')}
+**Analysis Depth**: ${analysisDepth}
+
+---
+
+## Discussion Timeline
+
+### Round 1 - Initial Understanding (${timestamp})
+
+#### Topic Analysis
+
+Based on the topic "${topic_or_question}":
+
+- **Primary dimensions**: ${dimensions.join(', ')}
+- **Initial scope**: ${initialScope}
+- **Key questions to explore**:
+  - ${question1}
+  - ${question2}
+  - ${question3}
+
+#### Next Steps
+
+- Launch CLI exploration for codebase context
+- Gather external insights via Gemini
+- Prepare discussion points for user
+
+---
+
+## Current Understanding
+
+${initialUnderstanding}
+```
+
+For continue session, append:
+```markdown
+### Round ${n} - Continuation (${timestamp})
+
+#### Previous Context
+
+Resuming analysis based on prior discussion.
+
+#### New Focus
+
+${newFocusFromUser}
+```
+
+---
+
+### Phase 2: CLI Exploration
+
+**Step 2.1: Launch Parallel Explorations**
+
+```javascript
+const explorationPromises = []
+
+// CLI Explore Agent for codebase
+if (dimensions.includes('implementation') || dimensions.includes('architecture')) {
+  explorationPromises.push(
+    Task(
+      subagent_type="cli-explore-agent",
+      run_in_background=false,
+      description=`Explore codebase: ${topicSlug}`,
+      prompt=`
+## Analysis Context
+Topic: ${topic_or_question}
+Dimensions: ${dimensions.join(', ')}
+Session: ${sessionFolder}
+
+## MANDATORY FIRST STEPS
+1. Run: ccw tool exec get_modules_by_depth '{}'
+2. Execute relevant searches based on topic keywords
+3. Read: .workflow/project-tech.json (if exists)
+
+## Exploration Focus
+${dimensions.map(d => `- ${d}: Identify relevant code patterns and structures`).join('\n')}
+
+## Output
+Write findings to: ${sessionFolder}/exploration-codebase.json
+
+Schema:
+{
+  "relevant_files": [{path, relevance, rationale}],
+  "patterns": [],
+  "key_findings": [],
+  "questions_for_user": [],
+  "_metadata": { "exploration_type": "codebase", "timestamp": "..." }
+}
+`
+    )
+  )
+}
+
+// Gemini CLI for deep analysis
+explorationPromises.push(
+  Bash({
+    command: `ccw cli -p "
+PURPOSE: Analyze topic '${topic_or_question}' from ${dimensions.join(', ')} perspectives
+Success criteria: Actionable insights with clear reasoning
+
+TASK:
+• Identify key considerations for this topic
+• Analyze common patterns and anti-patterns
+• Highlight potential issues or opportunities
+• Generate discussion points for user clarification
+
+MODE: analysis
+
+CONTEXT: @**/* | Topic: ${topic_or_question}
+
+EXPECTED:
+- Structured analysis with clear sections
+- Specific insights tied to evidence
+- Questions to deepen understanding
+- Recommendations with rationale
+
+CONSTRAINTS: Focus on ${dimensions.join(', ')}
+" --tool gemini --mode analysis`,
+    run_in_background: true
+  })
+)
+```
+
+**Step 2.2: Aggregate Findings**
+
+```javascript
+// After explorations complete, aggregate into explorations.json
+const explorations = {
+  session_id: sessionId,
+  timestamp: getUtc8ISOString(),
+  topic: topic_or_question,
+  dimensions: dimensions,
+  sources: [
+    { type: "codebase", file: "exploration-codebase.json" },
+    { type: "gemini", summary: geminiOutput }
+  ],
+  key_findings: [...],
+  discussion_points: [...],
+  open_questions: [...]
+}
+
+Write(explorationsPath, JSON.stringify(explorations, null, 2))
+```
+
+**Step 2.3: Update discussion.md**
+
+```markdown
+#### Exploration Results (${timestamp})
+
+**Sources Analyzed**:
+${sources.map(s => `- ${s.type}: ${s.summary}`).join('\n')}
+
+**Key Findings**:
+${keyFindings.map((f, i) => `${i+1}. ${f}`).join('\n')}
+
+**Points for Discussion**:
+${discussionPoints.map((p, i) => `${i+1}. ${p}`).join('\n')}
+
+**Open Questions**:
+${openQuestions.map((q, i) => `- ${q}`).join('\n')}
+```
+
+---
+
+### Phase 3: Interactive Discussion (Multi-Round)
+
+**Step 3.1: Present Findings & Gather Feedback**
+
+```javascript
+// Maximum discussion rounds
+const MAX_ROUNDS = 5
+let roundNumber = 1
+let discussionComplete = false
+
+while (!discussionComplete && roundNumber <= MAX_ROUNDS) {
+  // Display current findings
+  console.log(`
+## Discussion Round ${roundNumber}
+
+${currentFindings}
+
+### Key Points for Your Input
+${discussionPoints.map((p, i) => `${i+1}. ${p}`).join('\n')}
+`)
+
+  // Gather user input
+  const userResponse = AskUserQuestion({
+    questions: [
+      {
+        question: "对以上分析有什么看法或补充?",
+        header: "Feedback",
+        multiSelect: false,
+        options: [
+          { label: "同意，继续深入", description: "分析方向正确，继续探索" },
+          { label: "需要调整方向", description: "我有不同的理解或重点" },
+          { label: "分析完成", description: "已获得足够信息" },
+          { label: "有具体问题", description: "我想问一些具体问题" }
+        ]
+      }
+    ]
+  })
+
+  // Process user response
+  switch (userResponse.feedback) {
+    case "同意，继续深入":
+      // Deepen analysis in current direction
+      await deepenAnalysis()
+      break
+    case "需要调整方向":
+      // Get user's adjusted focus
+      const adjustment = AskUserQuestion({
+        questions: [{
+          question: "请说明您希望调整的方向或重点:",
+          header: "Direction",
+          multiSelect: false,
+          options: [
+            { label: "更多代码细节", description: "深入代码实现" },
+            { label: "更多架构视角", description: "关注整体设计" },
+            { label: "更多实践对比", description: "对比最佳实践" }
+          ]
+        }]
+      })
+      await adjustAnalysisDirection(adjustment)
+      break
+    case "分析完成":
+      discussionComplete = true
+      break
+    case "有具体问题":
+      // Let user ask specific questions, then answer
+      await handleUserQuestions()
+      break
+  }
+
+  // Update discussion.md with this round
+  updateDiscussionDocument(roundNumber, userResponse, findings)
+  roundNumber++
+}
+```
+
+**Step 3.2: Document Each Round**
+
+Append to discussion.md:
+```markdown
+### Round ${n} - Discussion (${timestamp})
+
+#### User Input
+
+${userInputSummary}
+
+${userResponse === 'adjustment' ? `
+**Direction Adjustment**: ${adjustmentDetails}
+` : ''}
+
+${userResponse === 'questions' ? `
+**User Questions**:
+${userQuestions.map((q, i) => `${i+1}. ${q}`).join('\n')}
+
+**Answers**:
+${answers.map((a, i) => `${i+1}. ${a}`).join('\n')}
+` : ''}
+
+#### Updated Understanding
+
+Based on user feedback:
+- ${insight1}
+- ${insight2}
+
+#### Corrected Assumptions
+
+${corrections.length > 0 ? corrections.map(c => `
+- ~~${c.wrong}~~ → ${c.corrected}
+  - Reason: ${c.reason}
+`).join('\n') : 'None'}
+
+#### New Insights
+
+${newInsights.map(i => `- ${i}`).join('\n')}
+```
+
+---
+
+### Phase 4: Synthesis & Conclusion
+
+**Step 4.1: Consolidate Insights**
+
+```javascript
+const conclusions = {
+  session_id: sessionId,
+  topic: topic_or_question,
+  completed: getUtc8ISOString(),
+  total_rounds: roundNumber,
+
+  summary: "...",
+
+  key_conclusions: [
+    { point: "...", evidence: "...", confidence: "high|medium|low" }
+  ],
+
+  recommendations: [
+    { action: "...", rationale: "...", priority: "high|medium|low" }
+  ],
+
+  open_questions: [...],
+
+  follow_up_suggestions: [
+    { type: "issue", summary: "..." },
+    { type: "task", summary: "..." }
+  ]
+}
+
+Write(conclusionsPath, JSON.stringify(conclusions, null, 2))
+```
+
+**Step 4.2: Final discussion.md Update**
+
+```markdown
+---
+
+## Conclusions (${timestamp})
+
+### Summary
+
+${summaryParagraph}
+
+### Key Conclusions
+
+${conclusions.key_conclusions.map((c, i) => `
+${i+1}. **${c.point}** (Confidence: ${c.confidence})
+   - Evidence: ${c.evidence}
+`).join('\n')}
+
+### Recommendations
+
+${conclusions.recommendations.map((r, i) => `
+${i+1}. **${r.action}** (Priority: ${r.priority})
+   - Rationale: ${r.rationale}
+`).join('\n')}
+
+### Remaining Questions
+
+${conclusions.open_questions.map(q => `- ${q}`).join('\n')}
+
+---
+
+## Current Understanding (Final)
+
+### What We Established
+
+${establishedPoints.map(p => `- ${p}`).join('\n')}
+
+### What Was Clarified/Corrected
+
+${corrections.map(c => `- ~~${c.original}~~ → ${c.corrected}`).join('\n')}
+
+### Key Insights
+
+${keyInsights.map(i => `- ${i}`).join('\n')}
+
+---
+
+## Session Statistics
+
+- **Total Rounds**: ${totalRounds}
+- **Duration**: ${duration}
+- **Sources Used**: ${sources.join(', ')}
+- **Artifacts Generated**: discussion.md, explorations.json, conclusions.json
+```
+
+**Step 4.3: Post-Completion Options**
+
+```javascript
+AskUserQuestion({
+  questions: [{
+    question: "分析完成。是否需要后续操作?",
+    header: "Next Steps",
+    multiSelect: true,
+    options: [
+      { label: "创建Issue", description: "将结论转为可执行的Issue" },
+      { label: "生成任务", description: "创建实施任务" },
+      { label: "导出报告", description: "生成独立的分析报告" },
+      { label: "完成", description: "不需要后续操作" }
+    ]
+  }]
+})
+
+// Handle selections
+if (selection.includes("创建Issue")) {
+  SlashCommand("/issue:new", `${topic_or_question} - 分析结论实施`)
+}
+if (selection.includes("生成任务")) {
+  SlashCommand("/workflow:lite-plan", `实施分析结论: ${summary}`)
+}
+if (selection.includes("导出报告")) {
+  exportAnalysisReport(sessionFolder)
+}
+```
+
+---
+
+## Session Folder Structure
+
+```
+.workflow/.analysis/ANL-{slug}-{date}/
+├── discussion.md       # Evolution of understanding & discussions
+├── explorations.json   # CLI exploration findings
+├── conclusions.json    # Final synthesis
+└── exploration-*.json  # Individual exploration results (optional)
+```
+
+## Discussion Document Template
+
+```markdown
+# Analysis Discussion
+
+**Session ID**: ANL-xxx-2025-01-25
+**Topic**: [topic or question]
+**Started**: 2025-01-25T10:00:00+08:00
+**Dimensions**: [architecture, implementation, ...]
+
+---
+
+## User Context
+
+**Focus Areas**: [user-selected focus]
+**Analysis Depth**: [quick|standard|deep]
+
+---
+
+## Discussion Timeline
+
+### Round 1 - Initial Understanding (2025-01-25 10:00)
+
+#### Topic Analysis
+...
+
+#### Exploration Results
+...
+
+### Round 2 - Discussion (2025-01-25 10:15)
+
+#### User Input
+...
+
+#### Updated Understanding
+...
+
+#### Corrected Assumptions
+- ~~[wrong]~~ → [corrected]
+
+### Round 3 - Deep Dive (2025-01-25 10:30)
+...
+
+---
+
+## Conclusions (2025-01-25 11:00)
+
+### Summary
+...
+
+### Key Conclusions
+...
+
+### Recommendations
+...
+
+---
+
+## Current Understanding (Final)
+
+### What We Established
+- [confirmed points]
+
+### What Was Clarified/Corrected
+- ~~[original assumption]~~ → [corrected understanding]
+
+### Key Insights
+- [insights gained]
+
+---
+
+## Session Statistics
+
+- **Total Rounds**: 3
+- **Duration**: 1 hour
+- **Sources Used**: codebase exploration, Gemini analysis
+- **Artifacts Generated**: discussion.md, explorations.json, conclusions.json
+```
+
+## Iteration Flow
+
+```
+First Call (/workflow:analyze-with-file "topic"):
+   ├─ No session exists → New mode
+   ├─ Identify analysis dimensions
+   ├─ Scope with user (unless --yes)
+   ├─ Create discussion.md with initial understanding
+   ├─ Launch CLI explorations
+   └─ Enter discussion loop
+
+Continue Call (/workflow:analyze-with-file --continue "topic"):
+   ├─ Session exists → Continue mode
+   ├─ Load discussion.md
+   ├─ Resume from last round
+   └─ Continue discussion loop
+
+Discussion Loop:
+   ├─ Present current findings
+   ├─ Gather user feedback (AskUserQuestion)
+   ├─ Process response:
+   │   ├─ Agree → Deepen analysis
+   │   ├─ Adjust → Change direction
+   │   ├─ Question → Answer then continue
+   │   └─ Complete → Exit loop
+   ├─ Update discussion.md
+   └─ Repeat until complete or max rounds
+
+Completion:
+   ├─ Generate conclusions.json
+   ├─ Update discussion.md with final synthesis
+   └─ Offer follow-up options (issue, task, report)
+```
+
+## CLI Integration Points
+
+### 1. Codebase Exploration (cli-explore-agent)
+
+**Purpose**: Gather relevant code context
+
+**When**: Topic involves implementation or architecture analysis
+
+### 2. Gemini Deep Analysis
+
+**Purpose**: Conceptual analysis, pattern identification, best practices
+
+**Prompt Pattern**:
+```
+PURPOSE: Analyze topic + identify insights
+TASK: Explore dimensions + generate discussion points
+CONTEXT: Codebase + topic
+EXPECTED: Structured analysis + questions
+```
+
+### 3. Follow-up CLI Calls
+
+**Purpose**: Deepen specific areas based on user feedback
+
+**Dynamic invocation** based on discussion direction
+
+## Consolidation Rules
+
+When updating "Current Understanding":
+
+1. **Promote confirmed insights**: Move validated findings to "What We Established"
+2. **Track corrections**: Keep important wrong→right transformations
+3. **Focus on current state**: What do we know NOW
+4. **Avoid timeline repetition**: Don't copy discussion details
+5. **Preserve key learnings**: Keep insights valuable for future reference
+
+**Bad (cluttered)**:
+```markdown
+## Current Understanding
+
+In round 1 we discussed X, then in round 2 user said Y, and we explored Z...
+```
+
+**Good (consolidated)**:
+```markdown
+## Current Understanding
+
+### What We Established
+- The authentication flow uses JWT with refresh tokens
+- Rate limiting is implemented at API gateway level
+
+### What Was Clarified
+- ~~Assumed Redis for sessions~~ → Actually uses database-backed sessions
+
+### Key Insights
+- Current architecture supports horizontal scaling
+- Security audit recommended before production
+```
+
+## Error Handling
+
+| Situation | Action |
+|-----------|--------|
+| CLI exploration fails | Continue with available context, note limitation |
+| User timeout in discussion | Save state, show resume command |
+| Max rounds reached | Force synthesis, offer continuation option |
+| No relevant findings | Broaden search, ask user for clarification |
+| Session folder conflict | Append timestamp suffix |
+| Gemini unavailable | Fallback to Codex or manual analysis |
+
+
+## Usage Recommendations
+
+Use `/workflow:analyze-with-file` when:
+- Exploring a complex topic collaboratively
+- Need documented discussion trail
+- Decision-making requires multiple perspectives
+- Want to iterate on understanding with user input
+- Building shared understanding before implementation
+
+Use `/workflow:debug-with-file` when:
+- Diagnosing specific bugs
+- Need hypothesis-driven investigation
+- Focus on evidence and verification
+
+Use `/workflow:lite-plan` when:
+- Ready to implement (past analysis phase)
+- Need structured task breakdown
+- Focus on execution planning

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

@@ -1,585 +0,0 @@
----
-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",
-     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",
-         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

@@ -1,453 +1,365 @@
 ---
 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(*)
+argument-hint: "[-y|--yes] topic or challenge description [--count N]"
+allowed-tools: TodoWrite(*), Read(*), Write(*), Glob(*), AskUserQuestion(*)
 ---
 
+## Auto Mode
+
+When `--yes` or `-y`: Auto-select recommended roles, skip all clarification questions, use default answers.
+
 ## Overview
 
-Six-phase workflow: **Automatic project context collection** → Extract topic challenges → Select roles → Generate task-specific questions → Detect conflicts → Generate confirmed guidance (declarative statements only).
+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` (CONFIRMED/SELECTED format)
-**Core Principle**: Questions dynamically generated from project context + topic keywords/challenges, NOT from generic templates
+**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 user WANTS to select (system will recommend N+2 options for user to choose from, default: 3)
+- `--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)
+**TodoWrite Rule**: EXTEND auto-parallel's task list (NOT replace/overwrite)
 
 **When called from auto-parallel**:
-- Find the artifacts parent task: "Execute artifacts command for interactive framework generation"
-- Mark parent task as "in_progress"
-- APPEND artifacts sub-tasks AFTER the parent task (Phase 0-5)
-- Mark each sub-task as it completes
-- When Phase 5 completes, mark parent task as "completed"
-- **PRESERVE all other auto-parallel tasks** (role agents, synthesis)
+- 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 (.workflow/active/ session check, parse --count parameter)", "status": "pending", "activeForm": "Initializing"},
-  {"content": "Phase 0: Automatic project context collection (call context-gather)", "status": "pending", "activeForm": "Phase 0 context collection"},
-  {"content": "Phase 1: Extract challenges, output 2-4 task-specific questions, wait for user input", "status": "pending", "activeForm": "Phase 1 topic analysis"},
-  {"content": "Phase 2: Recommend count+2 roles, output role selection, wait for user input", "status": "pending", "activeForm": "Phase 2 role selection"},
-  {"content": "Phase 3: Generate 3-4 questions per role, output and wait for answers (max 10 per round)", "status": "pending", "activeForm": "Phase 3 role questions"},
-  {"content": "Phase 4: Detect conflicts, output clarifications, wait for answers (max 10 per round)", "status": "pending", "activeForm": "Phase 4 conflict resolution"},
-  {"content": "Phase 5: Transform Q&A to declarative statements, write guidance-specification.md", "status": "pending", "activeForm": "Phase 5 document generation"}
+  {"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"}
 ]
 ```
 
-## User Interaction Protocol
-
-### Question Output Format
-
-All questions output as structured text (detailed format with descriptions):
-
-```markdown
-【问题{N} - {短标签}】{问题文本}
-a) {选项标签}
-   说明：{选项说明和影响}
-b) {选项标签}
-   说明：{选项说明和影响}
-c) {选项标签}
-   说明：{选项说明和影响}
-
-请回答：{N}a 或 {N}b 或 {N}c
-```
-
-**Multi-select format** (Phase 2 role selection):
-```markdown
-【角色选择】请选择 {count} 个角色参与头脑风暴分析
-
-a) {role-name} ({中文名})
-   推荐理由：{基于topic的相关性说明}
-b) {role-name} ({中文名})
-   推荐理由：{基于topic的相关性说明}
-...
-
-支持格式：
-- 分别选择：2a 2c 2d (选择第2题的a、c、d选项)
-- 合并语法：2acd (选择a、c、d)
-- 逗号分隔：2a,c,d
-
-请输入选择：
-```
-
-### Input Parsing Rules
-
-**Supported formats** (intelligent parsing):
-
-1. **Space-separated**: `1a 2b 3c` → Q1:a, Q2:b, Q3:c
-2. **Comma-separated**: `1a,2b,3c` → Q1:a, Q2:b, Q3:c
-3. **Multi-select combined**: `2abc` → Q2: options a,b,c
-4. **Multi-select spaces**: `2 a b c` → Q2: options a,b,c
-5. **Multi-select comma**: `2a,b,c` → Q2: options a,b,c
-6. **Natural language**: `问题1选a` → 1a (fallback parsing)
-
-**Parsing algorithm**:
-- Extract question numbers and option letters
-- Validate question numbers match output
-- Validate option letters exist for each question
-- If ambiguous/invalid, output example format and request re-input
-
-**Error handling** (lenient):
-- Recognize common variations automatically
-- If parsing fails, show example and wait for clarification
-- Support re-input without penalty
-
-### Batching Strategy
-
-**Batch limits**:
-- **Default**: Maximum 10 questions per round
-- **Phase 2 (role selection)**: Display all recommended roles at once (count+2 roles)
-- **Auto-split**: If questions > 10, split into multiple rounds with clear round indicators
-
-**Round indicators**:
-```markdown
-===== 第 1 轮问题 (共2轮) =====
-【问题1 - ...】...
-【问题2 - ...】...
-...
-【问题10 - ...】...
-
-请回答 (格式: 1a 2b ... 10c)：
-```
-
-### Interaction Flow
-
-**Standard flow**:
-1. Output questions in formatted text
-2. Output expected input format example
-3. Wait for user input
-4. Parse input with intelligent matching
-5. If parsing succeeds → Store answers and continue
-6. If parsing fails → Show error, example, and wait for re-input
-
-**No question/option limits**: Text-based interaction removes previous 4-question and 4-option restrictions
+---
 
 ## Execution Phases
 
 ### Session Management
+
 - Check `.workflow/active/` for existing sessions
-- Multiple sessions → Prompt selection | Single → Use it | None → Create `WFS-[topic-slug]`
-- Parse `--count N` parameter from user input (default: 3 if not specified)
-- Store decisions in `workflow-session.json` including count parameter
+- 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: Automatic Project Context Collection
+### Phase 0: Context Collection
 
-**Goal**: Gather project architecture, documentation, and relevant code context BEFORE user interaction
+**Goal**: Gather project context BEFORE user interaction
 
-**Detection Mechanism** (execute first):
-```javascript
-// Check if context-package already exists
-const contextPackagePath = `.workflow/active/WFS-{session-id}/.process/context-package.json`;
+**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`
 
-if (file_exists(contextPackagePath)) {
-  // Validate package
-  const package = Read(contextPackagePath);
-  if (package.metadata.session_id === session_id) {
-    console.log("✅ Valid context-package found, skipping Phase 0");
-    return; // Skip to Phase 1
-  }
-}
-```
-
-**Implementation**: Invoke `context-search-agent` only if package doesn't exist
+**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=`
-You are executing as context-search-agent (.claude/agents/context-search-agent.md).
+Execute context-search-agent in BRAINSTORM MODE (Phase 1-2 only).
 
-## Execution Mode
-**BRAINSTORM MODE** (Lightweight) - Phase 1-2 only (skip deep analysis)
+Session: ${session_id}
+Task: ${task_description}
+Output: .workflow/${session_id}/.process/context-package.json
 
-## Session Information
-- **Session ID**: ${session_id}
-- **Task Description**: ${task_description}
-- **Output Path**: .workflow/${session_id}/.process/context-package.json
-
-## Mission
-Execute complete context-search-agent workflow for implementation planning:
-
-### Phase 1: Initialization & Pre-Analysis
-1. **Detection**: Check for existing context-package (early exit if valid)
-2. **Foundation**: Initialize code-index, get project structure, load docs
-3. **Analysis**: Extract keywords, determine scope, classify complexity
-
-### Phase 2: Multi-Source Context Discovery
-Execute all 3 discovery tracks:
-- **Track 1**: Reference documentation (CLAUDE.md, architecture docs)
-- **Track 2**: Web examples (use Exa MCP for unfamiliar tech/APIs)
-- **Track 3**: Codebase analysis (5-layer discovery: files, content, patterns, deps, config/tests)
-
-### Phase 3: Synthesis, Assessment & Packaging
-1. Apply relevance scoring and build dependency graph
-2. Synthesize 3-source data (docs > code > web)
-3. Integrate brainstorm artifacts (if .brainstorming/ exists, read content)
-4. Perform conflict detection with risk assessment
-5. Generate and validate context-package.json
-
-## Output Requirements
-Complete context-package.json with:
-- **metadata**: task_description, keywords, complexity, tech_stack, session_id
-- **project_context**: architecture_patterns, coding_conventions, tech_stack
-- **assets**: {documentation[], source_code[], config[], tests[]} with relevance scores
-- **dependencies**: {internal[], external[]} with dependency graph
-- **brainstorm_artifacts**: {guidance_specification, role_analyses[], synthesis_output} with content
-- **conflict_detection**: {risk_level, risk_factors, affected_modules[], mitigation_strategy}
-
-## Quality Validation
-Before completion verify:
-- [ ] Valid JSON format with all required fields
-- [ ] File relevance accuracy >80%
-- [ ] Dependency graph complete (max 2 transitive levels)
-- [ ] Conflict risk level calculated correctly
-- [ ] No sensitive data exposed
-- [ ] Total files ≤50 (prioritize high-relevance)
-
-Execute autonomously following agent documentation.
-Report completion with statistics.
+Required fields: metadata, project_context, assets, dependencies, conflict_detection
 `
 )
 ```
 
-**Graceful Degradation**:
-- If agent fails: Log warning, continue to Phase 1 without project context
-- If package invalid: Re-run context-search-agent
+### Phase 1: Topic Analysis
 
-### Phase 1: Topic Analysis & Intent Classification
-
-**Goal**: Extract keywords/challenges to drive all subsequent question generation, **enriched by Phase 0 project context**
+**Goal**: Extract keywords/challenges enriched by Phase 0 context
 
 **Steps**:
-1. **Load Phase 0 context** (if available):
-   - Read `.workflow/active/WFS-{session-id}/.process/context-package.json`
-   - Extract: tech_stack, existing modules, conflict_risk, relevant files
+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`
 
-2. **Deep topic analysis** (context-aware):
-   - Extract technical entities from topic + existing codebase
-   - Identify core challenges considering existing architecture
-   - Consider constraints (timeline/budget/compliance)
-   - Define success metrics based on current project state
-
-3. **Generate 2-4 context-aware probing questions**:
-   - Reference existing tech stack in questions
-   - Consider integration with existing modules
-   - Address identified conflict risks from Phase 0
-   - Target root challenges and trade-off priorities
-
-4. **User interaction**: Output questions using text format (see User Interaction Protocol), wait for user input
-
-5. **Parse user answers**: Use intelligent parsing to extract answers from user input (support multiple formats)
-
-6. **Storage**: Store answers to `session.intent_context` with `{extracted_keywords, identified_challenges, user_answers, project_context_used}`
-
-**Example Output**:
-```markdown
-===== Phase 1: 项目意图分析 =====
-
-【问题1 - 核心挑战】实时协作平台的主要技术挑战？
-a) 实时数据同步
-   说明：100+用户同时在线，状态同步复杂度高
-b) 可扩展性架构
-   说明：用户规模增长时的系统扩展能力
-c) 冲突解决机制
-   说明：多用户同时编辑的冲突处理策略
-
-【问题2 - 优先级】MVP阶段最关注的指标？
-a) 功能完整性
-   说明：实现所有核心功能
-b) 用户体验
-   说明：流畅的交互体验和响应速度
-c) 系统稳定性
-   说明：高可用性和数据一致性
-
-请回答 (格式: 1a 2b)：
+**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: "高可用性和数据一致性" }
+      ]
+    }
+  ]
+})
 ```
 
-**User input examples**:
-- `1a 2c` → Q1:a, Q2:c
-- `1a,2c` → Q1:a, Q2:c
-
 **⚠️ CRITICAL**: Questions MUST reference topic keywords. Generic "Project type?" violates dynamic generation.
 
 ### Phase 2: Role Selection
 
-**⚠️ CRITICAL**: User MUST interact to select roles. NEVER auto-select without user confirmation.
+**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 (UI 设计师)
-- ux-expert (UX 专家)
+**Available Roles**: data-architect, product-manager, product-owner, scrum-master, subject-matter-expert, system-architect, test-strategist, ui-designer, ux-expert
 
 **Steps**:
-1. **Intelligent role recommendation** (AI analysis):
-   - Analyze Phase 1 extracted keywords and challenges
-   - Use AI reasoning to determine most relevant roles for the specific topic
-   - Recommend count+2 roles (e.g., if user wants 3 roles, recommend 5 options)
-   - Provide clear rationale for each recommended role based on topic context
+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
 
-2. **User selection** (text interaction):
-   - Output all recommended roles at once (no batching needed for count+2 roles)
-   - Display roles with labels and relevance rationale
-   - Wait for user input in multi-select format
-   - Parse user input (support multiple formats)
-   - **Storage**: Store selections to `session.selected_roles`
-
-**Example Output**:
-```markdown
-===== Phase 2: 角色选择 =====
-
-【角色选择】请选择 3 个角色参与头脑风暴分析
-
-a) system-architect (系统架构师)
-   推荐理由：实时同步架构设计和技术选型的核心角色
-b) ui-designer (UI设计师)
-   推荐理由：协作界面用户体验和实时状态展示
-c) product-manager (产品经理)
-   推荐理由：功能优先级和MVP范围决策
-d) data-architect (数据架构师)
-   推荐理由：数据同步模型和存储方案设计
-e) ux-expert (UX专家)
-   推荐理由：多用户协作交互流程优化
-
-支持格式：
-- 分别选择：2a 2c 2d (选择a、c、d)
-- 合并语法：2acd (选择a、c、d)
-- 逗号分隔：2a,c,d (选择a、c、d)
-
-请输入选择：
+**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: "数据同步模型和存储方案设计" }
+    ]
+  }]
+})
 ```
 
-**User input examples**:
-- `2acd` → Roles: a, c, d (system-architect, product-manager, data-architect)
-- `2a 2c 2d` → Same result
-- `2a,c,d` → Same result
+**⚠️ CRITICAL**: User MUST interact. NEVER auto-select without confirmation.
 
-**Role Recommendation Rules**:
-- NO hardcoded keyword-to-role mappings
-- Use intelligent analysis of topic, challenges, and requirements
-- Consider role synergies and coverage gaps
-- Explain WHY each role is relevant to THIS specific topic
-- Default recommendation: count+2 roles for user to choose from
-
-### Phase 3: Role-Specific Questions (Dynamic Generation)
+### Phase 3: Role-Specific Questions
 
 **Goal**: Generate deep questions mapping role expertise to Phase 1 challenges
 
 **Algorithm**:
-```
-FOR each selected role:
-  1. Map Phase 1 challenges to role domain:
-     - "real-time sync" + system-architect → State management pattern
-     - "100 users" + system-architect → Communication protocol
-     - "low latency" + system-architect → Conflict resolution
+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
 
-  2. Generate 3-4 questions per role probing implementation depth, trade-offs, edge cases:
-     Q: "How handle real-time state sync for 100+ users?" (explores approach)
-     Q: "How resolve conflicts when 2 users edit simultaneously?" (explores edge case)
-     Options: [Event Sourcing/Centralized/CRDT] (concrete, explain trade-offs for THIS use case)
-
-  3. Output questions in text format per role:
-     - Display all questions for current role (3-4 questions, no 10-question limit)
-     - Questions in Chinese (用中文提问)
-     - Wait for user input
-     - Parse answers using intelligent parsing
-     - Store answers to session.role_decisions[role]
+**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: "保留历史，需要分支管理" }
+      ]
+    }
+  ]
+})
 ```
 
-**Batching Strategy**:
-- Each role outputs all its questions at once (typically 3-4 questions)
-- No need to split per role (within 10-question batch limit)
-- Multiple roles processed sequentially (one role at a time for clarity)
+### Phase 4: Conflict Resolution
 
-**Output Format**: Follow standard format from "User Interaction Protocol" section (single-choice question format)
-
-**Example Topic-Specific Questions** (system-architect role for "real-time collaboration platform"):
-- "100+ 用户实时状态同步方案?" → Options: Event Sourcing / 集中式状态管理 / CRDT
-- "两个用户同时编辑冲突如何解决?" → Options: 自动合并 / 手动解决 / 版本控制
-- "低延迟通信协议选择?" → Options: WebSocket / SSE / 轮询
-- "系统扩展性架构方案?" → Options: 微服务 / 单体+缓存 / Serverless
-
-**Quality Requirements**: See "Question Generation Guidelines" section for detailed rules
-
-### Phase 4: Cross-Role Clarification (Conflict Detection)
-
-**Goal**: Resolve ACTUAL conflicts from Phase 3 answers, not pre-defined relationships
+**Goal**: Resolve ACTUAL conflicts from Phase 3 answers
 
 **Algorithm**:
-```
 1. Analyze Phase 3 answers for conflicts:
-   - Contradictory choices: product-manager "fast iteration" vs system-architect "complex Event Sourcing"
-   - Missing integration: ui-designer "Optimistic updates" but system-architect didn't address conflict handling
-   - Implicit dependencies: ui-designer "Live cursors" but no auth approach defined
-
-2. FOR each detected conflict:
-   Generate clarification questions referencing SPECIFIC Phase 3 choices
-
-3. Output clarification questions in text format:
-   - Batch conflicts into rounds (max 10 questions per round)
-   - Display questions with context from Phase 3 answers
-   - Questions in Chinese (用中文提问)
-   - Wait for user input
-   - Parse answers using intelligent parsing
-   - Store answers to session.cross_role_decisions
-
+   - 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: "支持回滚，增加服务器复杂度" }
+    ]
+  }]
+})
 ```
 
-**Batching Strategy**:
-- Maximum 10 clarification questions per round
-- If conflicts > 10, split into multiple rounds
-- Prioritize most critical conflicts first
+### Phase 4.5: Final Clarification
 
-**Output Format**: Follow standard format from "User Interaction Protocol" section (single-choice question format with background context)
-
-**Example Conflict Detection** (from Phase 3 answers):
-- **Architecture Conflict**: "CRDT 与 UI 回滚期望冲突，如何解决?"
-  - Background: system-architect chose CRDT, ui-designer expects rollback UI
-  - Options: 采用 CRDT / 显示合并界面 / 切换到 OT
-- **Integration Gap**: "实时光标功能缺少身份认证方案"
-  - Background: ui-designer chose live cursors, no auth defined
-  - Options: OAuth 2.0 / JWT Token / Session-based
-
-**Quality Requirements**: See "Question Generation Guidelines" section for conflict-specific rules
-
-### Phase 5: Generate Guidance Specification
+**Purpose**: Ensure no important points missed before generating specification
 
 **Steps**:
-1. Load all decisions: `intent_context` + `selected_roles` + `role_decisions` + `cross_role_decisions`
-2. Transform Q&A pairs to declarative: Questions → Headers, Answers → CONFIRMED/SELECTED statements
-3. Generate guidance-specification.md (template below) - **PRIMARY OUTPUT FILE**
-4. Update workflow-session.json with **METADATA ONLY**:
-   - session_id (e.g., "WFS-topic-slug")
-   - selected_roles[] (array of role names, e.g., ["system-architect", "ui-designer", "product-manager"])
-   - topic (original user input string)
-   - timestamp (ISO-8601 format)
-   - phase_completed: "artifacts"
-   - count_parameter (number from --count flag)
-5. Validate: No interrogative sentences in .md file, all decisions traceable, no content duplication in .json
+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
 
-**⚠️ CRITICAL OUTPUT SEPARATION**:
-- **guidance-specification.md**: Full guidance content (decisions, rationale, integration points)
-- **workflow-session.json**: Session metadata ONLY (no guidance content, no decisions, no Q&A pairs)
-- **NO content duplication**: Guidance stays in .md, metadata stays in .json
+**Progressive Pattern**: Questions interconnected, each round informs next, continue until resolved.
 
-## Output Document Template
+### 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`
 
@@ -478,9 +390,9 @@ FOR each selected role:
 
 ## Next Steps
 **⚠️ Automatic Continuation** (when called from auto-parallel):
-- auto-parallel will assign agents to generate role-specific analysis documents
-- Each selected role gets dedicated conceptual-planning-agent
-- Agents read this guidance-specification.md for framework context
+- 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 |
@@ -490,95 +402,19 @@ FOR each selected role:
 | D-003+ | [Role] | [Q] | [A] | 3 | [Why] |
 ```
 
-## Question Generation Guidelines
-
-### Core Principle: Developer-Facing Questions with User Context
-
-**Target Audience**: 开发者（理解技术但需要从用户需求出发）
-
-**Generation Philosophy**:
-1. **Phase 1**: 用户场景、业务约束、优先级（建立上下文）
-2. **Phase 2**: 基于话题分析的智能角色推荐（非关键词映射）
-3. **Phase 3**: 业务需求 + 技术选型（需求驱动的技术决策）
-4. **Phase 4**: 技术冲突的业务权衡（帮助开发者理解影响）
-
-### Universal Quality Rules
-
-**Question Structure** (all phases):
-```
-[业务场景/需求前提] + [技术关注点]
-```
-
-**Option Structure** (all phases):
-```
-标签：[技术方案简称] + (业务特征)
-说明：[业务影响] + [技术权衡]
-```
-
-**MUST Include** (all phases):
-- ✅ All questions in Chinese (用中文提问)
-- ✅ 业务场景作为问题前提
-- ✅ 技术选项的业务影响说明
-- ✅ 量化指标和约束条件
-
-**MUST Avoid** (all phases):
-- ❌ 纯技术选型无业务上下文
-- ❌ 过度抽象的用户体验问题
-- ❌ 脱离话题的通用架构问题
-
-### Phase-Specific Requirements
-
-**Phase 1 Requirements**:
-- Questions MUST reference topic keywords (NOT generic "Project type?")
-- Focus: 用户使用场景（谁用？怎么用？多频繁？）、业务约束（预算、时间、团队、合规）
-- Success metrics: 性能指标、用户体验目标
-- Priority ranking: MVP vs 长期规划
-
-**Phase 3 Requirements**:
-- Questions MUST reference Phase 1 keywords (e.g., "real-time", "100 users")
-- Options MUST be concrete approaches with relevance to topic
-- Each option includes trade-offs specific to this use case
-- Include 业务需求驱动的技术问题、量化指标（并发数、延迟、可用性）
-
-**Phase 4 Requirements**:
-- Questions MUST reference SPECIFIC Phase 3 choices in background context
-- Options address the detected conflict directly
-- Each option explains impact on both conflicting roles
-- NEVER use static "Cross-Role Matrix" - ALWAYS analyze actual Phase 3 answers
-- Focus: 技术冲突的业务权衡、帮助开发者理解不同选择的影响
-
-## Validation Checklist
-
-Generated guidance-specification.md MUST:
-- ✅ No interrogative sentences (use CONFIRMED/SELECTED)
-- ✅ Every decision traceable to user answer
-- ✅ Cross-role conflicts resolved or documented
-- ✅ Next steps concrete and specific
-- ✅ All Phase 1-4 decisions in session metadata
-
-## Update Mechanism
+### File Structure
 
 ```
-IF guidance-specification.md EXISTS:
-  Prompt: "Regenerate completely / Update sections / Cancel"
-ELSE:
-  Run full Phase 1-5 flow
+.workflow/active/WFS-[topic]/
+├── workflow-session.json              # Metadata ONLY
+├── .process/
+│   └── context-package.json           # Phase 0 output
+└── .brainstorming/
+    └── guidance-specification.md      # Full guidance content
 ```
 
-## Governance Rules
+### Session Metadata
 
-**Output Requirements**:
-- 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 in session
-
-**CRITICAL**: Guidance is single source of truth for downstream phases. Ambiguity violates governance.
-
-## Storage Validation
-
-**workflow-session.json** (metadata only):
 ```json
 {
   "session_id": "WFS-{topic-slug}",
@@ -591,14 +427,31 @@ ELSE:
 }
 ```
 
-**⚠️ Rule**: Session JSON stores ONLY metadata (session_id, selected_roles[], topic, timestamps). All guidance content goes to guidance-specification.md.
+**⚠️ Rule**: Session JSON stores ONLY metadata. All guidance content goes to guidance-specification.md.
 
-## File Structure
+### 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
 
 ```
-.workflow/active/WFS-[topic]/
-├── workflow-session.json              # Session metadata ONLY
-└── .brainstorming/
-    └── guidance-specification.md      # Full guidance content
+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

@@ -1,19 +1,23 @@
 ---
 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]
+argument-hint: "[-y|--yes] topic or challenge description [--count N]"
 allowed-tools: SlashCommand(*), Task(*), TodoWrite(*), Read(*), Write(*), Bash(*), Glob(*)
 ---
 
+## Auto Mode
+
+When `--yes` or `-y`: Auto-select recommended roles, skip all clarification questions, use default answers.
+
 # Workflow Brainstorm Parallel Auto Command
 
 ## Coordinator Role
 
-**This command is a pure orchestrator**: Execute 3 phases in sequence (interactive framework → parallel role analysis → synthesis), coordinating specialized commands/agents through task attachment model.
+**This command is a pure orchestrator**: Executes 3 phases in sequence (interactive framework → parallel role analysis → synthesis), coordinating specialized commands/agents through task attachment model.
 
 **Task Attachment Model**:
-- SlashCommand invocation **expands workflow** by attaching sub-tasks to current TodoWrite
-- Task agent execution **attaches analysis tasks** to orchestrator's TodoWrite
+- SlashCommand execute **expands workflow** by attaching sub-tasks to current TodoWrite
+- Task agent execute **attaches analysis tasks** to orchestrator's TodoWrite
 - Phase 1: artifacts command attaches its internal tasks (Phase 1-5)
 - Phase 2: N conceptual-planning-agent tasks attached in parallel
 - Phase 3: synthesis command attaches its internal tasks
@@ -26,9 +30,9 @@ allowed-tools: SlashCommand(*), Task(*), TodoWrite(*), Read(*), Write(*), Bash(*
 This workflow runs **fully autonomously** once triggered. Phase 1 (artifacts) handles user interaction, Phase 2 (role agents) runs in parallel.
 
 1. **User triggers**: `/workflow:brainstorm:auto-parallel "topic" [--count N]`
-2. **Phase 1 executes** → artifacts command (tasks ATTACHED) → Auto-continues
-3. **Phase 2 executes** → Parallel role agents (N tasks ATTACHED concurrently) → Auto-continues
-4. **Phase 3 executes** → Synthesis command (tasks ATTACHED) → Reports final summary
+2. **Execute Phase 1** → artifacts command (tasks ATTACHED) → Auto-continues
+3. **Execute Phase 2** → Parallel role agents (N tasks ATTACHED concurrently) → Auto-continues
+4. **Execute Phase 3** → Synthesis command (tasks ATTACHED) → Reports final summary
 
 **Auto-Continue Mechanism**:
 - TodoList tracks current phase status and dynamically manages task attachment/collapse
@@ -38,12 +42,12 @@ This workflow runs **fully autonomously** once triggered. Phase 1 (artifacts) ha
 
 ## Core Rules
 
-1. **Start Immediately**: First action is TodoWrite initialization, second action is Phase 1 command execution
+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 invocations **attach** sub-tasks to current workflow. Orchestrator **executes** these attached tasks itself, then **collapses** them after completion
+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
 
@@ -67,7 +71,11 @@ This workflow runs **fully autonomously** once triggered. Phase 1 (artifacts) ha
 
 ### Phase 1: Interactive Framework Generation
 
-**Command**: `SlashCommand(command="/workflow:brainstorm:artifacts \"{topic}\" --count {N}")`
+**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
@@ -87,7 +95,7 @@ This workflow runs **fully autonomously** once triggered. Phase 1 (artifacts) ha
 - workflow-session.json contains selected_roles[] (metadata only, no content duplication)
 - Session directory `.workflow/active/WFS-{topic}/.brainstorming/` exists
 
-**TodoWrite Update (Phase 1 SlashCommand invoked - tasks attached)**:
+**TodoWrite Update (Phase 1 SlashCommand executed - tasks attached)**:
 ```json
 [
   {"content": "Phase 0: Parameter Parsing", "status": "completed", "activeForm": "Parsing count parameter"},
@@ -102,7 +110,7 @@ This workflow runs **fully autonomously** once triggered. Phase 1 (artifacts) ha
 ]
 ```
 
-**Note**: SlashCommand invocation **attaches** artifacts' 5 internal tasks. Orchestrator **executes** these tasks sequentially.
+**Note**: SlashCommand execute **attaches** artifacts' 5 internal tasks. Orchestrator **executes** these tasks sequentially.
 
 **Next Action**: Tasks attached → **Execute Phase 1.1-1.5** sequentially
 
@@ -124,84 +132,40 @@ This workflow runs **fully autonomously** once triggered. Phase 1 (artifacts) ha
 
 ### Phase 2: Parallel Role Analysis Execution
 
-**For Each Selected Role**:
+**For Each Selected Role** (unified role-analysis command):
 ```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**
-   - 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 {role-name} planning template
-   - Command: Read(~/.claude/workflows/cli-templates/planning-roles/{role}.md)
-   - Output: role_template_guidelines
-
-3. **load_session_metadata**
-   - Action: Load session metadata and original user intent
-   - Command: Read(.workflow/active/WFS-{session}/workflow-session.json)
-   - Output: session_context (contains original user prompt as PRIMARY reference)
-
-4. **load_style_skill** (ONLY for ui-designer role when style_skill_package exists)
-   - Action: Load style SKILL package for design system reference
-   - Command: Read(.claude/skills/style-{style_skill_package}/SKILL.md) AND Read(.workflow/reference_style/{style_skill_package}/design-tokens.json)
-   - Output: style_skill_content, design_tokens
-   - Usage: Apply design tokens in ui-designer analysis and artifacts
-
-## 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**: Comprehensive {role-name} analysis addressing all framework discussion points
-   - **File Naming**: MUST start with `analysis` prefix (e.g., `analysis.md`, `analysis-1.md`, `analysis-2.md`)
-   - **FORBIDDEN**: Never use `recommendations.md` or any filename not starting with `analysis`
-   - **Auto-split if large**: If content >800 lines, split to `analysis-1.md`, `analysis-2.md` (max 3 files: analysis.md, analysis-1.md, analysis-2.md)
-   - **Content**: Includes both analysis AND recommendations sections within analysis files
-2. **Framework Reference**: Include @../guidance-specification.md reference in analysis
-3. **User Intent Alignment**: Validate analysis aligns with original user objectives from 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
-"
+SlashCommand(command="/workflow:brainstorm:role-analysis {role-name} --session {session-id} --skip-questions")
 ```
 
+**What It Does**:
+- Unified command execution for each role
+- Loads topic framework from guidance-specification.md
+- Applies role-specific template and context
+- Generates analysis.md addressing framework discussion points
+- Supports optional interactive context gathering (via --include-questions flag)
+
 **Parallel Execution**:
-- 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
+- Launch N SlashCommand calls simultaneously (one message with multiple SlashCommand invokes)
+- Each role command **attached** to orchestrator's TodoWrite
+- All roles execute concurrently, each reading same guidance-specification.md
+- Each role operates independently
+- For ui-designer only: append `--style-skill {style_skill_package}` if provided
 
 **Input**:
 - `selected_roles[]` from Phase 1
 - `session_id` from Phase 1
-- guidance-specification.md path
+- `guidance-specification.md` (framework reference)
+- `style_skill_package` (for ui-designer only)
 
 **Validation**:
-- Each role creates `.workflow/active/WFS-{topic}/.brainstorming/{role}/analysis.md` (primary file)
-- If content is large (>800 lines), may split to `analysis-1.md`, `analysis-2.md` (max 3 files total)
-- **File naming pattern**: ALL files MUST start with `analysis` prefix (use `analysis*.md` for globbing)
-- **FORBIDDEN naming**: No `recommendations.md`, `recommendations-*.md`, or any non-`analysis` prefixed files
+- 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 invoked - tasks attached in parallel)**:
+
+**TodoWrite Update (Phase 2 agents executed - tasks attached in parallel)**:
 ```json
 [
   {"content": "Phase 0: Parameter Parsing", "status": "completed", "activeForm": "Parsing count parameter"},
@@ -214,7 +178,7 @@ TOPIC: {user-provided-topic}
 ]
 ```
 
-**Note**: Multiple Task invocations **attach** N role analysis tasks simultaneously. Orchestrator **executes** these tasks in parallel.
+**Note**: Multiple Task executes **attach** N role analysis tasks simultaneously. Orchestrator **executes** these tasks in parallel.
 
 **Next Action**: Tasks attached → **Execute Phase 2.1-2.N** concurrently
 
@@ -236,7 +200,11 @@ TOPIC: {user-provided-topic}
 
 ### Phase 3: Synthesis Generation
 
-**Command**: `SlashCommand(command="/workflow:brainstorm:synthesis --session {sessionId}")`
+**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
@@ -250,7 +218,7 @@ TOPIC: {user-provided-topic}
 - `.workflow/active/WFS-{topic}/.brainstorming/synthesis-specification.md` exists
 - Synthesis references all role analyses
 
-**TodoWrite Update (Phase 3 SlashCommand invoked - tasks attached)**:
+**TodoWrite Update (Phase 3 SlashCommand executed - tasks attached)**:
 ```json
 [
   {"content": "Phase 0: Parameter Parsing", "status": "completed", "activeForm": "Parsing count parameter"},
@@ -263,7 +231,7 @@ TOPIC: {user-provided-topic}
 ]
 ```
 
-**Note**: SlashCommand invocation **attaches** synthesis' internal tasks. Orchestrator **executes** these tasks sequentially.
+**Note**: SlashCommand execute **attaches** synthesis' internal tasks. Orchestrator **executes** these tasks sequentially.
 
 **Next Action**: Tasks attached → **Execute Phase 3.1-3.3** sequentially
 
@@ -296,7 +264,7 @@ Synthesis: .workflow/active/WFS-{topic}/.brainstorming/synthesis-specification.m
 
 ### Key Principles
 
-1. **Task Attachment** (when SlashCommand/Task invoked):
+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
@@ -317,7 +285,7 @@ Synthesis: .workflow/active/WFS-{topic}/.brainstorming/synthesis-specification.m
    - No user intervention required between phases
    - TodoWrite dynamically reflects current execution state
 
-**Lifecycle Summary**: Initial pending tasks → Phase 1 invoked (artifacts tasks ATTACHED) → Artifacts sub-tasks executed → Phase 1 completed (tasks COLLAPSED) → Phase 2 invoked (N role tasks ATTACHED in parallel) → Role analyses executed concurrently → Phase 2 completed (tasks COLLAPSED) → Phase 3 invoked (synthesis tasks ATTACHED) → Synthesis sub-tasks executed → Phase 3 completed (tasks COLLAPSED) → Workflow complete.
+**Lifecycle Summary**: Initial pending tasks → Phase 1 executed (artifacts tasks ATTACHED) → Artifacts sub-tasks executed → Phase 1 completed (tasks COLLAPSED) → Phase 2 executed (N role tasks ATTACHED in parallel) → Role analyses executed concurrently → Phase 2 completed (tasks COLLAPSED) → Phase 3 executed (synthesis tasks ATTACHED) → Synthesis sub-tasks executed → Phase 3 completed (tasks COLLAPSED) → Workflow complete.
 
 ### Brainstorming Workflow Specific Features
 
@@ -436,6 +404,17 @@ CONTEXT_VARS:
 - **Agent execution failure**: Agent-specific retry with minimal dependencies
 - **Template loading issues**: Agent handles graceful degradation
 - **Synthesis conflicts**: Synthesis highlights disagreements without resolution
+- **Context overflow protection**: See below for automatic context management
+
+## Context Overflow Protection
+
+**Per-role limits**: See `conceptual-planning-agent.md` (< 3000 words main, < 2000 words sub-docs, max 5 sub-docs)
+
+**Synthesis protection**: If total analysis > 100KB, synthesis reads only `analysis.md` files (not sub-documents)
+
+**Recovery**: Check logs → reduce scope (--count 2) → use --summary-only → manual synthesis
+
+**Prevention**: Start with --count 3, use structured topic format, review output sizes before synthesis
 
 ## Reference Information
 
@@ -445,14 +424,10 @@ CONTEXT_VARS:
 ├── workflow-session.json              # Session metadata ONLY
 └── .brainstorming/
     ├── guidance-specification.md      # Framework (Phase 1)
-    ├── {role-1}/
-    │   └── analysis.md                # Role analysis (Phase 2)
-    ├── {role-2}/
-    │   └── analysis.md
-    ├── {role-N}/
-    │   └── analysis.md
+    ├── {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/data-architect.md

@@ -1,220 +0,0 @@
----
-name: data-architect
-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(*)
----
-
-## 📊 **Data Architect Analysis Generator**
-
-### 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 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
-
-### 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
-
-### Role Boundaries & Responsibilities
-
-#### **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
-
-#### **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**
-
-#### **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 & 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 data-architect analysis for existing topic framework
-
-## Context Loading
-ASSIGNED_ROLE: data-architect
-OUTPUT_LOCATION: .workflow/active/WFS-{session}/.brainstorming/data-architect/
-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 data-architect planning template
-   - Command: bash($(cat ~/.claude/workflows/cli-templates/planning-roles/data-architect.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 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
-
-## Expected Deliverables
-1. **analysis.md**: Comprehensive data architecture 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 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
-"
-```
-
-## 📋 **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 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"
-    }
-  ]
-});
-```
-
-## 📊 **Output 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 from Framework]
-
-## Framework Reference
-**Topic Framework**: @../guidance-specification.md
-**Role Focus**: Data Architecture perspective
-
-## Discussion Points Analysis
-[Address each point from guidance-specification.md with data architecture expertise]
-
-### Core Requirements (from framework)
-[Data architecture perspective on requirements]
-
-### Technical Considerations (from framework)
-[Data model, pipeline, and storage considerations]
-
-### User Experience Factors (from framework)
-[Data access patterns and analytics user experience]
-
-### Implementation Challenges (from framework)
-[Data migration, quality, and governance challenges]
-
-### 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**
-
-### Completion Status Update
-```json
-{
-  "data_architect": {
-    "status": "completed",
-    "framework_addressed": true,
-    "output_location": ".workflow/active/WFS-{session}/.brainstorming/data-architect/analysis.md",
-    "framework_reference": "@../guidance-specification.md"
-  }
-}
-```
-
-### 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/product-manager.md

@@ -1,200 +0,0 @@
----
-name: product-manager
-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(*)
----
-
-## 🎯 **Product Manager Analysis Generator**
-
-### 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 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
-
-### 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 & 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-manager analysis for existing topic framework
-
-## Context Loading
-ASSIGNED_ROLE: product-manager
-OUTPUT_LOCATION: .workflow/active/WFS-{session}/.brainstorming/product-manager/
-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-manager planning template
-   - Command: bash($(cat ~/.claude/workflows/cli-templates/planning-roles/product-manager.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 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
-
-## Expected Deliverables
-1. **analysis.md**: Comprehensive product strategy 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 management expertise
-- Provide actionable business strategies and user value propositions
-- Include market analysis and competitive positioning 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 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"
-    }
-  ]
-});
-```
-
-## 📊 **Output 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 from Framework]
-
-## Framework Reference
-**Topic Framework**: @../guidance-specification.md
-**Role Focus**: Product Strategy perspective
-
-## Discussion Points Analysis
-[Address each point from guidance-specification.md with product management expertise]
-
-### Core Requirements (from framework)
-[Product strategy perspective on user needs and requirements]
-
-### Technical Considerations (from framework)
-[Business and technical feasibility considerations]
-
-### 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**
-
-### Completion Status Update
-```json
-{
-  "product_manager": {
-    "status": "completed",
-    "framework_addressed": true,
-    "output_location": ".workflow/active/WFS-{session}/.brainstorming/product-manager/analysis.md",
-    "framework_reference": "@../guidance-specification.md"
-  }
-}
-```
-
-### 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

@@ -1,200 +0,0 @@
----
-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/role-analysis.md

@@ -0,0 +1,705 @@
+---
+name: role-analysis
+description: Unified role-specific analysis generation with interactive context gathering and incremental updates
+argument-hint: "[role-name] [--session session-id] [--update] [--include-questions] [--skip-questions]"
+allowed-tools: Task(conceptual-planning-agent), AskUserQuestion(*), TodoWrite(*), Read(*), Write(*), Edit(*), Glob(*)
+---
+
+## 🎯 **Unified Role Analysis Generator**
+
+### Purpose
+**Unified command for generating and updating role-specific analysis** with interactive context gathering, framework alignment, and incremental update support. Replaces 9 individual role commands with single parameterized workflow.
+
+### Core Function
+- **Multi-Role Support**: Single command supports all 9 brainstorming roles
+- **Interactive Context**: Dynamic question generation based on role and framework
+- **Incremental Updates**: Merge new insights into existing analyses
+- **Framework Alignment**: Address guidance-specification.md discussion points
+- **Agent Delegation**: Use conceptual-planning-agent with role-specific templates
+
+### Supported Roles
+
+| Role ID | Title | Focus Area | Context Questions |
+|---------|-------|------------|-------------------|
+| `ux-expert` | UX专家 | User research, information architecture, user journey | 4 |
+| `ui-designer` | UI设计师 | Visual design, high-fidelity mockups, design systems | 4 |
+| `system-architect` | 系统架构师 | Technical architecture, scalability, integration patterns | 5 |
+| `product-manager` | 产品经理 | Product strategy, roadmap, prioritization | 4 |
+| `product-owner` | 产品负责人 | Backlog management, user stories, acceptance criteria | 4 |
+| `scrum-master` | 敏捷教练 | Process facilitation, impediment removal, team dynamics | 3 |
+| `subject-matter-expert` | 领域专家 | Domain knowledge, business rules, compliance | 4 |
+| `data-architect` | 数据架构师 | Data models, storage strategies, data flow | 5 |
+| `api-designer` | API设计师 | API contracts, versioning, integration patterns | 4 |
+
+---
+
+## 📋 **Usage**
+
+```bash
+# Generate new analysis with interactive context
+/workflow:brainstorm:role-analysis ux-expert
+
+# Generate with existing framework + context questions
+/workflow:brainstorm:role-analysis system-architect --session WFS-xxx --include-questions
+
+# Update existing analysis (incremental merge)
+/workflow:brainstorm:role-analysis ui-designer --session WFS-xxx --update
+
+# Quick generation (skip interactive context)
+/workflow:brainstorm:role-analysis product-manager --session WFS-xxx --skip-questions
+```
+
+---
+
+## ⚙️ **Execution Protocol**
+
+### Phase 1: Detection & Validation
+
+**Step 1.1: Role Validation**
+```bash
+VALIDATE role_name IN [
+  ux-expert, ui-designer, system-architect, product-manager,
+  product-owner, scrum-master, subject-matter-expert,
+  data-architect, api-designer
+]
+IF invalid:
+  ERROR: "Unknown role: {role_name}. Use one of: ux-expert, ui-designer, ..."
+  EXIT
+```
+
+**Step 1.2: Session Detection**
+```bash
+IF --session PROVIDED:
+  session_id = --session
+  brainstorm_dir = .workflow/active/{session_id}/.brainstorming/
+ELSE:
+  FIND .workflow/active/WFS-*/
+  IF multiple:
+    PROMPT user to select
+  ELSE IF single:
+    USE existing
+  ELSE:
+    ERROR: "No active session. Run /workflow:brainstorm:artifacts first"
+    EXIT
+
+VALIDATE brainstorm_dir EXISTS
+```
+
+**Step 1.3: Framework Detection**
+```bash
+framework_file = {brainstorm_dir}/guidance-specification.md
+IF framework_file EXISTS:
+  framework_mode = true
+  LOAD framework_content
+ELSE:
+  WARN: "No framework found - will create standalone analysis"
+  framework_mode = false
+```
+
+**Step 1.4: Update Mode Detection**
+```bash
+existing_analysis = {brainstorm_dir}/{role_name}/analysis*.md
+IF --update FLAG OR existing_analysis EXISTS:
+  update_mode = true
+  IF --update NOT PROVIDED:
+    ASK: "Analysis exists. Update or regenerate?"
+    OPTIONS: ["Incremental update", "Full regenerate", "Cancel"]
+ELSE:
+  update_mode = false
+```
+
+### Phase 2: Interactive Context Gathering
+
+**Trigger Conditions**:
+- Default: Always ask unless `--skip-questions` provided
+- `--include-questions`: Force context gathering even if analysis exists
+- `--skip-questions`: Skip all interactive questions
+
+**Step 2.1: Load Role Configuration**
+```javascript
+const roleConfig = {
+  'ux-expert': {
+    title: 'UX专家',
+    focus_area: 'User research, information architecture, user journey',
+    question_categories: ['User Intent', 'Requirements', 'UX'],
+    question_count: 4,
+    template: '~/.claude/workflows/cli-templates/planning-roles/ux-expert.md'
+  },
+  'ui-designer': {
+    title: 'UI设计师',
+    focus_area: 'Visual design, high-fidelity mockups, design systems',
+    question_categories: ['Requirements', 'UX', 'Feasibility'],
+    question_count: 4,
+    template: '~/.claude/workflows/cli-templates/planning-roles/ui-designer.md'
+  },
+  'system-architect': {
+    title: '系统架构师',
+    focus_area: 'Technical architecture, scalability, integration patterns',
+    question_categories: ['Scale & Performance', 'Technical Constraints', 'Architecture Complexity', 'Non-Functional Requirements'],
+    question_count: 5,
+    template: '~/.claude/workflows/cli-templates/planning-roles/system-architect.md'
+  },
+  'product-manager': {
+    title: '产品经理',
+    focus_area: 'Product strategy, roadmap, prioritization',
+    question_categories: ['User Intent', 'Requirements', 'Process'],
+    question_count: 4,
+    template: '~/.claude/workflows/cli-templates/planning-roles/product-manager.md'
+  },
+  'product-owner': {
+    title: '产品负责人',
+    focus_area: 'Backlog management, user stories, acceptance criteria',
+    question_categories: ['Requirements', 'Decisions', 'Process'],
+    question_count: 4,
+    template: '~/.claude/workflows/cli-templates/planning-roles/product-owner.md'
+  },
+  'scrum-master': {
+    title: '敏捷教练',
+    focus_area: 'Process facilitation, impediment removal, team dynamics',
+    question_categories: ['Process', 'Risk', 'Decisions'],
+    question_count: 3,
+    template: '~/.claude/workflows/cli-templates/planning-roles/scrum-master.md'
+  },
+  'subject-matter-expert': {
+    title: '领域专家',
+    focus_area: 'Domain knowledge, business rules, compliance',
+    question_categories: ['Requirements', 'Feasibility', 'Terminology'],
+    question_count: 4,
+    template: '~/.claude/workflows/cli-templates/planning-roles/subject-matter-expert.md'
+  },
+  'data-architect': {
+    title: '数据架构师',
+    focus_area: 'Data models, storage strategies, data flow',
+    question_categories: ['Architecture', 'Scale & Performance', 'Technical Constraints', 'Feasibility'],
+    question_count: 5,
+    template: '~/.claude/workflows/cli-templates/planning-roles/data-architect.md'
+  },
+  'api-designer': {
+    title: 'API设计师',
+    focus_area: 'API contracts, versioning, integration patterns',
+    question_categories: ['Architecture', 'Requirements', 'Feasibility', 'Decisions'],
+    question_count: 4,
+    template: '~/.claude/workflows/cli-templates/planning-roles/api-designer.md'
+  }
+};
+
+config = roleConfig[role_name];
+```
+
+**Step 2.2: Generate Role-Specific Questions**
+
+**9-Category Taxonomy** (from synthesis.md):
+
+| Category | Focus | Example Question Pattern |
+|----------|-------|--------------------------|
+| User Intent | 用户目标 | "该分析的核心目标是什么？" |
+| Requirements | 需求细化 | "需求的优先级如何排序？" |
+| Architecture | 架构决策 | "技术栈的选择考量？" |
+| UX | 用户体验 | "交互复杂度的取舍？" |
+| Feasibility | 可行性 | "资源约束下的实现范围？" |
+| Risk | 风险管理 | "风险容忍度是多少？" |
+| Process | 流程规范 | "开发迭代的节奏？" |
+| Decisions | 决策确认 | "冲突的解决方案？" |
+| Terminology | 术语统一 | "统一使用哪个术语？" |
+| Scale & Performance | 性能扩展 | "预期的负载和性能要求？" |
+| Technical Constraints | 技术约束 | "现有技术栈的限制？" |
+| Architecture Complexity | 架构复杂度 | "架构的复杂度权衡？" |
+| Non-Functional Requirements | 非功能需求 | "可用性和可维护性要求？" |
+
+**Question Generation Algorithm**:
+```javascript
+async function generateQuestions(role_name, framework_content) {
+  const config = roleConfig[role_name];
+  const questions = [];
+
+  // Parse framework for keywords
+  const keywords = extractKeywords(framework_content);
+
+  // Generate category-specific questions
+  for (const category of config.question_categories) {
+    const question = generateCategoryQuestion(category, keywords, role_name);
+    questions.push(question);
+  }
+
+  return questions.slice(0, config.question_count);
+}
+```
+
+**Step 2.3: Multi-Round Question Execution**
+
+```javascript
+const BATCH_SIZE = 4;
+const user_context = {};
+
+for (let i = 0; i < questions.length; i += BATCH_SIZE) {
+  const batch = questions.slice(i, i + BATCH_SIZE);
+  const currentRound = Math.floor(i / BATCH_SIZE) + 1;
+  const totalRounds = Math.ceil(questions.length / BATCH_SIZE);
+
+  console.log(`\n[Round ${currentRound}/${totalRounds}] ${config.title} 上下文询问\n`);
+
+  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 responses before next round
+  for (const answer of responses) {
+    user_context[answer.question] = {
+      answer: answer.selected,
+      category: answer.category,
+      timestamp: new Date().toISOString()
+    };
+  }
+}
+
+// Save context to file
+Write(
+  `${brainstorm_dir}/${role_name}/${role_name}-context.md`,
+  formatUserContext(user_context)
+);
+```
+
+**Question Quality Rules** (from artifacts.md):
+
+**MUST Include**:
+- ✅ All questions in Chinese (用中文提问)
+- ✅ 业务场景作为问题前提
+- ✅ 技术选项的业务影响说明
+- ✅ 量化指标和约束条件
+
+**MUST Avoid**:
+- ❌ 纯技术选型无业务上下文
+- ❌ 过度抽象的通用问题
+- ❌ 脱离框架的重复询问
+
+### Phase 3: Agent Execution
+
+**Step 3.1: Load Session Metadata**
+```bash
+session_metadata = Read(.workflow/active/{session_id}/workflow-session.json)
+original_topic = session_metadata.topic
+selected_roles = session_metadata.selected_roles
+```
+
+**Step 3.2: Prepare Agent Context**
+```javascript
+const agentContext = {
+  role_name: role_name,
+  role_config: roleConfig[role_name],
+  output_location: `${brainstorm_dir}/${role_name}/`,
+  framework_mode: framework_mode,
+  framework_path: framework_mode ? `${brainstorm_dir}/guidance-specification.md` : null,
+  update_mode: update_mode,
+  user_context: user_context,
+  original_topic: original_topic,
+  session_id: session_id
+};
+```
+
+**Step 3.3: Execute Conceptual Planning Agent**
+
+**Framework-Based Analysis** (when guidance-specification.md exists):
+```javascript
+Task(
+  subagent_type="conceptual-planning-agent",
+  run_in_background=false,
+  description=`Generate ${role_name} analysis`,
+  prompt=`
+[FLOW_CONTROL]
+
+Execute ${role_name} analysis for existing topic framework
+
+## Context Loading
+ASSIGNED_ROLE: ${role_name}
+OUTPUT_LOCATION: ${agentContext.output_location}
+ANALYSIS_MODE: ${framework_mode ? "framework_based" : "standalone"}
+UPDATE_MODE: ${update_mode}
+
+## Flow Control Steps
+1. **load_topic_framework**
+   - Action: Load structured topic discussion framework
+   - Command: Read(${agentContext.framework_path})
+   - Output: topic_framework_content
+
+2. **load_role_template**
+   - Action: Load ${role_name} planning template
+   - Command: Read(${roleConfig[role_name].template})
+   - Output: role_template_guidelines
+
+3. **load_session_metadata**
+   - Action: Load session metadata and user intent
+   - Command: Read(.workflow/active/${session_id}/workflow-session.json)
+   - Output: session_context
+
+4. **load_user_context** (if exists)
+   - Action: Load interactive context responses
+   - Command: Read(${brainstorm_dir}/${role_name}/${role_name}-context.md)
+   - Output: user_context_answers
+
+5. **${update_mode ? 'load_existing_analysis' : 'skip'}**
+   ${update_mode ? `
+   - Action: Load existing analysis for incremental update
+   - Command: Read(${brainstorm_dir}/${role_name}/analysis.md)
+   - Output: existing_analysis_content
+   ` : ''}
+
+## 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
+**User Context Integration**: Incorporate interactive Q&A responses into analysis
+**Role Focus**: ${roleConfig[role_name].focus_area}
+**Template Integration**: Apply role template guidelines within framework structure
+
+## Expected Deliverables
+1. **analysis.md** (main document, optionally with analysis-{slug}.md sub-documents)
+2. **Framework Reference**: @../guidance-specification.md (if framework_mode)
+3. **User Context Reference**: @./${role_name}-context.md (if user context exists)
+4. **User Intent Alignment**: Validate against session_context
+
+## Update Requirements (if UPDATE_MODE)
+- **Preserve Structure**: Maintain existing analysis structure
+- **Add "Clarifications" Section**: Document new user context with timestamp
+- **Merge Insights**: Integrate new perspectives without removing existing content
+- **Resolve Conflicts**: If new context contradicts existing analysis, document both and recommend resolution
+
+## 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
+`
+);
+```
+
+### Phase 4: Validation & Finalization
+
+**Step 4.1: Validate Output**
+```bash
+VERIFY EXISTS: ${brainstorm_dir}/${role_name}/analysis.md
+VERIFY CONTAINS: "@../guidance-specification.md" (if framework_mode)
+IF user_context EXISTS:
+  VERIFY CONTAINS: "@./${role_name}-context.md" OR "## Clarifications" section
+```
+
+**Step 4.2: Update Session Metadata**
+```json
+{
+  "phases": {
+    "BRAINSTORM": {
+      "${role_name}": {
+        "status": "${update_mode ? 'updated' : 'completed'}",
+        "completed_at": "timestamp",
+        "framework_addressed": true,
+        "context_gathered": user_context ? true : false,
+        "output_location": "${brainstorm_dir}/${role_name}/analysis.md",
+        "update_history": [
+          {
+            "timestamp": "ISO8601",
+            "mode": "${update_mode ? 'incremental' : 'initial'}",
+            "context_questions": question_count
+          }
+        ]
+      }
+    }
+  }
+}
+```
+
+**Step 4.3: Completion Report**
+```markdown
+✅ ${roleConfig[role_name].title} Analysis Complete
+
+**Output**: ${brainstorm_dir}/${role_name}/analysis.md
+**Mode**: ${update_mode ? 'Incremental Update' : 'New Generation'}
+**Framework**: ${framework_mode ? '✓ Aligned' : '✗ Standalone'}
+**Context Questions**: ${question_count} answered
+
+${update_mode ? '
+**Changes**:
+- Added "Clarifications" section with new user context
+- Merged new insights into existing sections
+- Resolved conflicts with framework alignment
+' : ''}
+
+**Next Steps**:
+${selected_roles.length > 1 ? `
+  - Continue with other roles: ${selected_roles.filter(r => r !== role_name).join(', ')}
+  - Run synthesis: /workflow:brainstorm:synthesis --session ${session_id}
+` : `
+  - Clarify insights: /workflow:brainstorm:synthesis --session ${session_id}
+  - Generate plan: /workflow:plan --session ${session_id}
+`}
+```
+
+---
+
+## 📋 **TodoWrite Integration**
+
+### Workflow Progress Tracking
+
+```javascript
+TodoWrite({
+  todos: [
+    {
+      content: "Phase 1: Detect session and validate role configuration",
+      status: "in_progress",
+      activeForm: "Detecting session and role"
+    },
+    {
+      content: "Phase 2: Interactive context gathering with AskUserQuestion",
+      status: "pending",
+      activeForm: "Gathering user context"
+    },
+    {
+      content: "Phase 3: Execute conceptual-planning-agent for role analysis",
+      status: "pending",
+      activeForm: "Executing agent analysis"
+    },
+    {
+      content: "Phase 4: Validate output and update session metadata",
+      status: "pending",
+      activeForm: "Finalizing and validating"
+    }
+  ]
+});
+```
+
+---
+
+## 📊 **Output Structure**
+
+### Directory Layout
+
+```
+.workflow/active/WFS-{session}/.brainstorming/
+├── guidance-specification.md          # Framework (if exists)
+└── {role-name}/
+    ├── {role-name}-context.md         # Interactive Q&A responses
+    ├── analysis.md                    # Main analysis (REQUIRED)
+    └── analysis-{slug}.md             # Section documents (optional, max 5)
+```
+
+### Analysis Document Structure (New Generation)
+
+```markdown
+# ${roleConfig[role_name].title} Analysis: [Topic from Framework]
+
+## Framework Reference
+**Topic Framework**: @../guidance-specification.md
+**Role Focus**: ${roleConfig[role_name].focus_area}
+**User Context**: @./${role_name}-context.md
+
+## User Context Summary
+**Context Gathered**: ${question_count} questions answered
+**Categories**: ${question_categories.join(', ')}
+
+${user_context ? formatContextSummary(user_context) : ''}
+
+## Discussion Points Analysis
+[Address each point from guidance-specification.md with ${role_name} expertise]
+
+### Core Requirements (from framework)
+[Role-specific perspective on requirements]
+
+### Technical Considerations (from framework)
+[Role-specific technical analysis]
+
+### User Experience Factors (from framework)
+[Role-specific UX considerations]
+
+### Implementation Challenges (from framework)
+[Role-specific challenges and solutions]
+
+### Success Metrics (from framework)
+[Role-specific metrics and KPIs]
+
+## ${roleConfig[role_name].title} Specific Recommendations
+[Role-specific actionable strategies]
+
+---
+*Generated by ${role_name} analysis addressing structured framework*
+*Context gathered: ${new Date().toISOString()}*
+```
+
+### Analysis Document Structure (Incremental Update)
+
+```markdown
+# ${roleConfig[role_name].title} Analysis: [Topic]
+
+## Framework Reference
+[Existing content preserved]
+
+## Clarifications
+### Session ${new Date().toISOString().split('T')[0]}
+${Object.entries(user_context).map(([q, a]) => `
+- **Q**: ${q} (Category: ${a.category})
+  **A**: ${a.answer}
+`).join('\n')}
+
+## User Context Summary
+[Updated with new context]
+
+## Discussion Points Analysis
+[Existing content enhanced with new insights]
+
+[Rest of sections updated based on clarifications]
+```
+
+---
+
+## 🔄 **Integration with Other Commands**
+
+### Called By
+- `/workflow:brainstorm:auto-parallel` (Phase 2 - parallel role execution)
+- Manual invocation for single-role analysis
+
+### Calls To
+- `conceptual-planning-agent` (agent execution)
+- `AskUserQuestion` (interactive context gathering)
+
+### Coordinates With
+- `/workflow:brainstorm:artifacts` (creates framework for role analysis)
+- `/workflow:brainstorm:synthesis` (reads role analyses for integration)
+
+---
+
+## ✅ **Quality Assurance**
+
+### Required Analysis Elements
+- [ ] Framework discussion points addressed (if framework_mode)
+- [ ] User context integrated (if context gathered)
+- [ ] Role template guidelines applied
+- [ ] Output files follow naming convention (analysis*.md only)
+- [ ] Framework reference using @ notation
+- [ ] Session metadata updated
+
+### Context Quality
+- [ ] Questions in Chinese with business context
+- [ ] Options include technical trade-offs
+- [ ] Categories aligned with role focus
+- [ ] No generic questions unrelated to framework
+
+### Update Quality (if update_mode)
+- [ ] "Clarifications" section added with timestamp
+- [ ] New insights merged without content loss
+- [ ] Conflicts documented and resolved
+- [ ] Framework alignment maintained
+
+---
+
+## 🎛️ **Command Parameters**
+
+### Required Parameters
+- `[role-name]`: Role identifier (ux-expert, ui-designer, system-architect, etc.)
+
+### Optional Parameters
+- `--session [session-id]`: Specify brainstorming session (auto-detect if omitted)
+- `--update`: Force incremental update mode (auto-detect if analysis exists)
+- `--include-questions`: Force context gathering even if analysis exists
+- `--skip-questions`: Skip all interactive context gathering
+- `--style-skill [package]`: For ui-designer only, load style SKILL package
+
+### Parameter Combinations
+
+| Scenario | Command | Behavior |
+|----------|---------|----------|
+| New analysis | `role-analysis ux-expert` | Generate + ask context questions |
+| Quick generation | `role-analysis ux-expert --skip-questions` | Generate without context |
+| Update existing | `role-analysis ux-expert --update` | Ask clarifications + merge |
+| Force questions | `role-analysis ux-expert --include-questions` | Ask even if exists |
+| Specific session | `role-analysis ux-expert --session WFS-xxx` | Target specific session |
+
+---
+
+## 🚫 **Error Handling**
+
+### Invalid Role Name
+```
+ERROR: Unknown role: "ui-expert"
+Valid roles: ux-expert, ui-designer, system-architect, product-manager,
+            product-owner, scrum-master, subject-matter-expert,
+            data-architect, api-designer
+```
+
+### No Active Session
+```
+ERROR: No active brainstorming session found
+Run: /workflow:brainstorm:artifacts "[topic]" to create session
+```
+
+### Missing Framework (with warning)
+```
+WARN: No guidance-specification.md found
+Generating standalone analysis without framework alignment
+Recommend: Run /workflow:brainstorm:artifacts first for better results
+```
+
+### Agent Execution Failure
+```
+ERROR: Conceptual planning agent failed
+Check: ${brainstorm_dir}/${role_name}/error.log
+Action: Retry with --skip-questions or check framework validity
+```
+
+---
+
+## 🔧 **Advanced Usage**
+
+### Batch Role Generation (via auto-parallel)
+```bash
+# This command handles multiple roles in parallel
+/workflow:brainstorm:auto-parallel "topic" --count 3
+# → Internally calls role-analysis for each selected role
+```
+
+### Manual Multi-Role Workflow
+```bash
+# 1. Create framework
+/workflow:brainstorm:artifacts "Build real-time collaboration platform" --count 3
+
+# 2. Generate each role with context
+/workflow:brainstorm:role-analysis system-architect --include-questions
+/workflow:brainstorm:role-analysis ui-designer --include-questions
+/workflow:brainstorm:role-analysis product-manager --include-questions
+
+# 3. Synthesize insights
+/workflow:brainstorm:synthesis --session WFS-xxx
+```
+
+### Iterative Refinement
+```bash
+# Initial generation
+/workflow:brainstorm:role-analysis ux-expert
+
+# User reviews and wants more depth
+/workflow:brainstorm:role-analysis ux-expert --update --include-questions
+# → Asks clarification questions, merges new insights
+```
+
+---
+
+## 📚 **Reference Information**
+
+### Role Template Locations
+- Templates: `~/.claude/workflows/cli-templates/planning-roles/`
+- Format: `{role-name}.md` (e.g., `ux-expert.md`, `system-architect.md`)
+
+### Related Commands
+- `/workflow:brainstorm:artifacts` - Create framework and select roles
+- `/workflow:brainstorm:auto-parallel` - Parallel multi-role execution
+- `/workflow:brainstorm:synthesis` - Integrate role analyses
+- `/workflow:plan` - Generate implementation plan from synthesis
+
+### Context Package
+- Location: `.workflow/active/WFS-{session}/.process/context-package.json`
+- Used by: `context-search-agent` (Phase 0 of artifacts)
+- Contains: Project context, tech stack, conflict risks

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

@@ -1,200 +0,0 @@
----
-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/subject-matter-expert.md

@@ -1,200 +0,0 @@
----
-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,326 +1,323 @@
 ---
 name: synthesis
 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(*)
+argument-hint: "[-y|--yes] [optional: --session session-id]"
+allowed-tools: Task(conceptual-planning-agent), TodoWrite(*), Read(*), Write(*), Edit(*), Glob(*), AskUserQuestion(*)
 ---
 
+## Auto Mode
+
+When `--yes` or `-y`: Auto-select all enhancements, skip clarification questions, use default answers.
+
 ## Overview
 
-Three-phase workflow to eliminate ambiguities and enhance conceptual depth in role analyses:
+Six-phase workflow to eliminate ambiguities and enhance conceptual depth in role analyses:
 
-**Phase 1-2 (Main Flow)**: Session detection → File discovery → Path preparation
+**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
 
-**Phase 3A (Analysis Agent)**: Cross-role analysis → Generate recommendations
-
-**Phase 4 (Main Flow)**: User selects enhancements → User answers clarifications → Build update plan
-
-**Phase 5 (Parallel Update Agents)**: Each agent updates ONE role document → Parallel execution
-
-**Phase 6 (Main Flow)**: Metadata update → Completion report
-
-**Key Features**:
-- Multi-agent architecture (analysis agent + parallel update agents)
-- Clear separation: Agent analysis vs Main flow interaction
-- Parallel document updates (one agent per role)
-- User intent alignment validation
+All user interactions use AskUserQuestion tool (max 4 questions per call, multi-round).
 
 **Document Flow**:
 - Input: `[role]/analysis*.md`, `guidance-specification.md`, session metadata
 - Output: Updated `[role]/analysis*.md` with Enhancements + Clarifications sections
 
+---
+
+## 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: "覆盖所有规划功能，延迟上线" }
+      ]
+    }
+  ]
+})
+```
+
+---
+
 ## Task Tracking
 
 ```json
 [
-  {"content": "Detect session and validate analyses", "status": "in_progress", "activeForm": "Detecting session"},
+  {"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 agent"},
-  {"content": "Present enhancements for user selection", "status": "pending", "activeForm": "Presenting enhancements"},
-  {"content": "Generate and present clarification questions", "status": "pending", "activeForm": "Clarifying with user"},
-  {"content": "Build update plan from user input", "status": "pending", "activeForm": "Building update plan"},
-  {"content": "Execute parallel update agents (one per role)", "status": "pending", "activeForm": "Updating documents in parallel"},
-  {"content": "Update session metadata and generate report", "status": "pending", "activeForm": "Finalizing session"}
+  {"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"}
 ]
 ```
 
+---
+
 ## Execution Phases
 
 ### Phase 1: Discovery & Validation
 
-1. **Detect Session**: Use `--session` parameter or find `.workflow/active/WFS-*` directories
+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` (project/description field)
+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-1.md, analysis-2.md, analysis-3.md
-   - Validate: At least one file exists (error if empty)
+   - 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 from brainstorm_dir
-   - `participating_roles`: Role names extracted from directory paths
+   - `role_analysis_paths`: Relative paths
+   - `participating_roles`: Role names from directories
 
-3. **Pass to Agent** (Phase 3):
-   - `session_id`
-   - `brainstorm_dir`: .workflow/active/WFS-{session}/.brainstorming/
-   - `role_analysis_paths`: ["product-manager/analysis.md", "system-architect/analysis-1.md", ...]
-   - `participating_roles`: ["product-manager", "system-architect", ...]
-
-**Main Flow Responsibility**: File discovery and path preparation only (NO file content reading)
+3. **Pass to Agent**: session_id, brainstorm_dir, role_analysis_paths, participating_roles
 
 ### Phase 3A: Analysis & Enhancement Agent
 
-**First agent call**: Cross-role analysis and generate enhancement recommendations
+**Agent executes cross-role analysis**:
 
-```bash
-Task(conceptual-planning-agent): "
+```javascript
+Task(conceptual-planning-agent, `
 ## Agent Mission
-Analyze role documents, identify conflicts/gaps, and generate enhancement recommendations
+Analyze role documents, identify conflicts/gaps, generate enhancement recommendations
 
-## Input from Main Flow
-- brainstorm_dir: {brainstorm_dir}
-- role_analysis_paths: {role_analysis_paths}
-- participating_roles: {participating_roles}
+## Input
+- brainstorm_dir: ${brainstorm_dir}
+- role_analysis_paths: ${role_analysis_paths}
+- participating_roles: ${participating_roles}
 
-## Execution Instructions
-[FLOW_CONTROL]
+## 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, ...
 
-### Flow Control Steps
-**AGENT RESPONSIBILITY**: Execute these analysis steps sequentially with context accumulation:
-
-1. **load_session_metadata**
-   - Action: Load original user intent as primary reference
-   - Command: Read({brainstorm_dir}/../workflow-session.json)
-   - Output: original_user_intent (from project/description field)
-
-2. **load_role_analyses**
-   - Action: Load all role analysis documents
-   - Command: For each path in role_analysis_paths: Read({brainstorm_dir}/{path})
-   - Output: role_analyses_content_map = {role_name: content}
-
-3. **cross_role_analysis**
-   - Action: Identify consensus themes, conflicts, gaps, underspecified areas
-   - Output: consensus_themes, conflicting_views, gaps_list, ambiguities
-
-4. **generate_recommendations**
-   - Action: Convert cross-role analysis findings into structured enhancement recommendations
-   - Format: EP-001, EP-002, ... (sequential numbering)
-   - Fields: id, title, affected_roles, category, current_state, enhancement, rationale, priority
-   - Taxonomy: Map to 9 categories (User Intent, Requirements, Architecture, UX, Feasibility, Risk, Process, Decisions, Terminology)
-   - Output: enhancement_recommendations (JSON array)
-
-### Output to Main Flow
-Return JSON array:
+## 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 with request/response schemas\",
-    \"rationale\": \"Enables precise implementation and testing\",
-    \"priority\": \"High\"
-  },
-  ...
+    "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"
+  }
 ]
-
-"
+`)
 ```
 
-### Phase 4: Main Flow User Interaction
+### Phase 4: User Interaction
 
-**Main flow handles all user interaction via text output**:
+**All interactions via AskUserQuestion (Chinese questions)**
 
-**⚠️ CRITICAL**: ALL questions MUST use Chinese (所有问题必须用中文) for better user understanding
+#### Step 1: Enhancement Selection
 
-1. **Present Enhancement Options** (multi-select):
-```markdown
-===== Enhancement 选择 =====
+```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);
 
-a) EP-001: API Contract Specification
-   影响角色：system-architect, api-designer
-   说明：添加详细的请求/响应 schema 定义
+  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}`
+      }))
+    }]
+  })
 
-b) EP-002: User Intent Validation
-   影响角色：product-manager, ux-expert
-   说明：明确用户需求优先级和验收标准
+  // Store selections before next round
+}
 
-c) EP-003: Error Handling Strategy
-   影响角色：system-architect
-   说明：统一异常处理和降级方案
-
-支持格式：1abc 或 1a 1b 1c 或 1a,b,c
-请输入选择（可跳过输入 skip）：
+// User can also skip: provide "跳过" option
 ```
 
-2. **Generate Clarification Questions** (based on analysis agent output):
-   - ✅ **ALL questions in Chinese (所有问题必须用中文)**
-   - Use 9-category taxonomy scan results
-   - Prioritize most critical questions (no hard limit)
-   - Each with 2-4 options + descriptions
+#### Step 2: Clarification Questions
 
-3. **Interactive Clarification Loop** (max 10 questions per round):
-```markdown
-===== Clarification 问题 (第 1/2 轮) =====
+```javascript
+// Generate questions based on 9-category taxonomy scan
+// Categories: User Intent, Requirements, Architecture, UX, Feasibility, Risk, Process, Decisions, Terminology
 
-【问题1 - 用户意图】MVP 阶段的核心目标是什么？
-a) 快速验证市场需求
-   说明：最小功能集，快速上线获取反馈
-b) 建立技术壁垒
-   说明：完善架构，为长期发展打基础
-c) 实现功能完整性
-   说明：覆盖所有规划功能，延迟上线
+const clarifications = [...]; // from analysis
+const BATCH_SIZE = 4;
 
-【问题2 - 架构决策】技术栈选择的优先考虑因素？
-a) 团队熟悉度
-   说明：使用现有技术栈，降低学习成本
-b) 技术先进性
-   说明：采用新技术，提升竞争力
-c) 生态成熟度
-   说明：选择成熟方案，保证稳定性
+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);
 
-...（最多10个问题）
+  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
+      }))
+    }))
+  })
 
-请回答 (格式: 1a 2b 3c...)：
+  // Store answers before next round
+}
 ```
 
-Wait for user input → Parse all answers in batch → Continue to next round if needed
+### Question Guidelines
 
-4. **Build Update Plan**:
-```
+**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],
+    "enhancements": ["EP-001", "EP-003"],
     "clarifications": [
-      {"question": "...", "answer": "...", "category": "..."},
-      ...
+      {"question": "...", "answer": "...", "category": "..."}
     ]
   },
   "role2": {
-    "enhancements": [EP-002],
+    "enhancements": ["EP-002"],
     "clarifications": [...]
-  },
-  ...
+  }
 }
 ```
 
 ### Phase 5: Parallel Document Update Agents
 
-**Parallel agent calls** (one per role needing updates):
+**Execute in parallel** (one agent per role):
 
-```bash
-# Execute in parallel using single message with multiple Task calls
-
-Task(conceptual-planning-agent): "
+```javascript
+// Single message with multiple Task calls for parallelism
+Task(conceptual-planning-agent, `
 ## Agent Mission
-Apply user-confirmed enhancements and clarifications to {role1} analysis document
+Apply enhancements and clarifications to ${role} analysis
 
-## Agent Intent
-- **Goal**: Integrate synthesis results into role-specific analysis
-- **Scope**: Update ONLY {role1}/analysis.md (isolated, no cross-role dependencies)
-- **Constraints**: Preserve original insights, add refinements without deletion
+## Input
+- role: ${role}
+- analysis_path: ${brainstorm_dir}/${role}/analysis.md
+- enhancements: ${role_enhancements}
+- clarifications: ${role_clarifications}
+- original_user_intent: ${intent}
 
-## Input from Main Flow
-- role: {role1}
-- analysis_path: {brainstorm_dir}/{role1}/analysis.md
-- enhancements: [EP-001, EP-003] (user-selected improvements)
-- clarifications: [{question, answer, category}, ...] (user-confirmed answers)
-- original_user_intent: {from session metadata}
+## 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
 
-## Execution Instructions
-[FLOW_CONTROL]
-
-### Flow Control Steps
-**AGENT RESPONSIBILITY**: Execute these update steps sequentially:
-
-1. **load_current_analysis**
-   - Action: Load existing role analysis document
-   - Command: Read({brainstorm_dir}/{role1}/analysis.md)
-   - Output: current_analysis_content
-
-2. **add_clarifications_section**
-   - Action: Insert Clarifications section with Q&A
-   - Format: \"## Clarifications\\n### Session {date}\\n- **Q**: {question} (Category: {category})\\n  **A**: {answer}\"
-   - Output: analysis_with_clarifications
-
-3. **apply_enhancements**
-   - Action: Integrate EP-001, EP-003 into relevant sections
-   - Strategy: Locate section by category (Architecture → Architecture section, UX → User Experience section)
-   - Output: analysis_with_enhancements
-
-4. **resolve_contradictions**
-   - Action: Remove conflicts between original content and clarifications/enhancements
-   - Output: contradiction_free_analysis
-
-5. **enforce_terminology_consistency**
-   - Action: Align all terminology with user-confirmed choices from clarifications
-   - Output: terminology_consistent_analysis
-
-6. **validate_user_intent_alignment**
-   - Action: Verify all updates support original_user_intent
-   - Output: validated_analysis
-
-7. **write_updated_file**
-   - Action: Save final analysis document
-   - Command: Write({brainstorm_dir}/{role1}/analysis.md, validated_analysis)
-   - Output: File update confirmation
-
-### Output
-Updated {role1}/analysis.md with Clarifications section + enhanced content
-")
-
-Task(conceptual-planning-agent): "
-## Agent Mission
-Apply user-confirmed enhancements and clarifications to {role2} analysis document
-
-## Agent Intent
-- **Goal**: Integrate synthesis results into role-specific analysis
-- **Scope**: Update ONLY {role2}/analysis.md (isolated, no cross-role dependencies)
-- **Constraints**: Preserve original insights, add refinements without deletion
-
-## Input from Main Flow
-- role: {role2}
-- analysis_path: {brainstorm_dir}/{role2}/analysis.md
-- enhancements: [EP-002] (user-selected improvements)
-- clarifications: [{question, answer, category}, ...] (user-confirmed answers)
-- original_user_intent: {from session metadata}
-
-## Execution Instructions
-[FLOW_CONTROL]
-
-### Flow Control Steps
-**AGENT RESPONSIBILITY**: Execute same 7 update steps as {role1} agent (load → clarifications → enhancements → contradictions → terminology → validation → write)
-
-### Output
-Updated {role2}/analysis.md with Clarifications section + enhanced content
-")
-
-# ... repeat for each role in update_plan
+## Output
+Updated ${role}/analysis.md
+`)
 ```
 
 **Agent Characteristics**:
-- **Intent**: Integrate user-confirmed synthesis results (NOT generate new analysis)
-- **Isolation**: Each agent updates exactly ONE role (parallel execution safe)
-- **Context**: Minimal - receives only role-specific enhancements + clarifications
-- **Dependencies**: Zero cross-agent dependencies (full parallelism)
+- **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: Completion & Metadata Update
+### Phase 6: Finalization
 
-**Main flow finalizes**:
+#### 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
 
-1. Wait for all parallel agents to complete
-2. Update workflow-session.json:
 ```json
 {
   "phases": {
@@ -330,15 +327,13 @@ Updated {role2}/analysis.md with Clarifications section + enhanced content
       "completed_at": "timestamp",
       "participating_roles": [...],
       "clarification_results": {
-        "enhancements_applied": ["EP-001", "EP-002", ...],
+        "enhancements_applied": ["EP-001", "EP-002"],
         "questions_asked": 3,
-        "categories_clarified": ["Architecture", "UX", ...],
-        "roles_updated": ["role1", "role2", ...],
-        "outstanding_items": []
+        "categories_clarified": ["Architecture", "UX"],
+        "roles_updated": ["role1", "role2"]
       },
       "quality_metrics": {
         "user_intent_alignment": "validated",
-        "requirement_coverage": "comprehensive",
         "ambiguity_resolution": "complete",
         "terminology_consistency": "enforced"
       }
@@ -347,7 +342,8 @@ Updated {role2}/analysis.md with Clarifications section + enhanced content
 }
 ```
 
-3. Generate completion report (show to user):
+#### Step 3: Completion Report
+
 ```markdown
 ## ✅ Clarification Complete
 
@@ -359,9 +355,11 @@ Updated {role2}/analysis.md with Clarifications section + enhanced content
 ✅ PROCEED: `/workflow:plan --session WFS-{session-id}`
 ```
 
+---
+
 ## Output
 
-**Location**: `.workflow/active/WFS-{session}/.brainstorming/[role]/analysis*.md` (in-place updates)
+**Location**: `.workflow/active/WFS-{session}/.brainstorming/[role]/analysis*.md`
 
 **Updated Structure**:
 ```markdown
@@ -381,116 +379,24 @@ Updated {role2}/analysis.md with Clarifications section + enhanced content
 - Ambiguities resolved, placeholders removed
 - Consistent terminology
 
-### Phase 6: Update Context Package
-
-**Purpose**: Sync updated role analyses to context-package.json to avoid stale cache
-
-**Operations**:
-```bash
-context_pkg_path = ".workflow/active/WFS-{session}/.process/context-package.json"
-
-# 1. Read existing package
-context_pkg = Read(context_pkg_path)
-
-# 2. Re-read brainstorm artifacts (now with synthesis enhancements)
-brainstorm_dir = ".workflow/active/WFS-{session}/.brainstorming"
-
-# 2.1 Update guidance-specification if exists
-IF exists({brainstorm_dir}/guidance-specification.md):
-    context_pkg.brainstorm_artifacts.guidance_specification.content = Read({brainstorm_dir}/guidance-specification.md)
-    context_pkg.brainstorm_artifacts.guidance_specification.updated_at = NOW()
-
-# 2.2 Update synthesis-specification if exists
-IF exists({brainstorm_dir}/synthesis-specification.md):
-    IF context_pkg.brainstorm_artifacts.synthesis_output:
-        context_pkg.brainstorm_artifacts.synthesis_output.content = Read({brainstorm_dir}/synthesis-specification.md)
-        context_pkg.brainstorm_artifacts.synthesis_output.updated_at = NOW()
-
-# 2.3 Re-read all role analysis files
-role_analysis_files = Glob({brainstorm_dir}/*/analysis*.md)
-context_pkg.brainstorm_artifacts.role_analyses = []
-
-FOR file IN role_analysis_files:
-    role_name = extract_role_from_path(file)  # e.g., "ui-designer"
-    relative_path = file.replace({brainstorm_dir}/, "")
-
-    context_pkg.brainstorm_artifacts.role_analyses.push({
-        "role": role_name,
-        "files": [{
-            "path": relative_path,
-            "type": "primary",
-            "content": Read(file),
-            "updated_at": NOW()
-        }]
-    })
-
-# 3. Update metadata
-context_pkg.metadata.updated_at = NOW()
-context_pkg.metadata.synthesis_timestamp = NOW()
-
-# 4. Write back
-Write(context_pkg_path, JSON.stringify(context_pkg, indent=2))
-
-REPORT: "✅ Updated context-package.json with synthesis results"
-```
-
-**TodoWrite Update**:
-```json
-{"content": "Update context package with synthesis results", "status": "completed", "activeForm": "Updating context package"}
-```
-
-## Session Metadata
-
-Update `workflow-session.json`:
-
-```json
-{
-  "phases": {
-    "BRAINSTORM": {
-      "status": "clarification_completed",
-      "clarification_completed": true,
-      "completed_at": "timestamp",
-      "participating_roles": ["product-manager", "system-architect", ...],
-      "clarification_results": {
-        "questions_asked": 3,
-        "categories_clarified": ["Architecture & Design", ...],
-        "roles_updated": ["system-architect", "ui-designer", ...],
-        "outstanding_items": []
-      },
-      "quality_metrics": {
-        "user_intent_alignment": "validated",
-        "requirement_coverage": "comprehensive",
-        "ambiguity_resolution": "complete",
-        "terminology_consistency": "enforced",
-        "decision_transparency": "documented"
-      }
-    }
-  }
-}
-```
+---
 
 ## Quality Checklist
 
 **Content**:
-- All role analyses loaded/analyzed
-- Cross-role analysis (consensus, conflicts, gaps)
-- 9-category ambiguity scan
-- Questions prioritized
-- Clarifications documented
+- ✅ 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
-- Correct roles updated
-- Terminology consistent
-- Contradictions removed
+- ✅ User intent validated
+- ✅ Cross-role synthesis complete
+- ✅ Ambiguities resolved
+- ✅ Terminology consistent
 
 **Documents**:
-- Clarifications section formatted
-- Sections reflect answers
-- No placeholders (TODO/TBD)
-- Valid Markdown
-- Cross-references maintained
-
-
+- ✅ Clarifications section formatted
+- ✅ Sections reflect answers
+- ✅ No placeholders (TODO/TBD)
+- ✅ Valid Markdown

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

@@ -1,387 +0,0 @@
----
-name: system-architect
-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(*)
----
-
-## 🏗️ **System Architect Analysis Generator**
-
-### 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 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
-
-### 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
-
-### Role Boundaries & Responsibilities
-
-#### **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)
-
-#### **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**
-
-#### **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
-
-## ⚙️ **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/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",
-     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",
-         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**
-- Where are the current system performance bottlenecks?
-- How should we handle traffic growth and scaling demands?
-- What database scaling and optimization strategies are needed?
-
-## ⚡ **Two-Step Execution Flow**
-
-### ⚠️ Session Management - FIRST STEP
-Session detection and selection:
-```bash
-# 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
-```
-
-### Step 1: Context Gathering Phase
-**System Architect Perspective Questioning**
-
-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**
-
-```bash
-Task(conceptual-planning-agent): "
-[FLOW_CONTROL]
-
-Execute dedicated system-architect conceptual analysis for: {topic}
-
-ASSIGNED_ROLE: system-architect
-OUTPUT_LOCATION: .brainstorming/system-architect/
-USER_CONTEXT: {validated_responses_from_context_gathering}
-
-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\"
-  }
-]
-
-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
-
-Deliverables:
-- analysis.md: Main system architecture analysis
-- recommendations.md: Architecture recommendations
-- deliverables/: Architecture-specific outputs as defined in role template
-
-Embody system-architect role expertise for comprehensive conceptual planning."
-```
-
-### 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/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
-└── integration-plan.md         # System integration and API strategies
-```
-
-### Document Templates
-
-#### analysis.md Structure
-```markdown
-# System Architecture Analysis: {Topic}
-*Generated: {timestamp}*
-
-## Executive Summary
-[Key architectural findings and recommendations overview]
-
-## Current State Assessment
-### Existing Architecture Overview
-### Technical Stack Analysis
-### Performance Bottlenecks
-### Technical Debt Assessment
-
-## Requirements Analysis
-### Functional Requirements
-### Non-Functional Requirements
-- Performance: [Response time, throughput requirements]
-- Scalability: [User growth, data volume expectations]
-- Availability: [Uptime requirements]
-- Security: [Security requirements]
-
-## Proposed Architecture
-### High-Level Architecture Design
-### Component Breakdown
-### Data Flow Diagrams
-### Technology Stack Recommendations
-
-## Implementation Strategy
-### Migration Planning
-### Risk Mitigation
-### Performance Optimization
-### Security Considerations
-
-## Scalability and Maintenance
-### Horizontal Scaling Strategy
-### Monitoring and Observability
-### Deployment Strategy
-### Long-term Maintenance Plan
-```
-
-## 🔄 **Session Integration**
-
-### Status Synchronization
-Upon completion, update `workflow-session.json`:
-```json
-{
-  "phases": {
-    "BRAINSTORM": {
-      "system_architect": {
-        "status": "completed",
-        "completed_at": "timestamp",
-        "output_directory": ".workflow/active/WFS-{topic}/.brainstorming/system-architect/",
-        "key_insights": ["scalability_bottleneck", "architecture_pattern", "technology_recommendation"]
-      }
-    }
-  }
-}
-```
-
-### Cross-Role Collaboration
-System architect perspective provides:
-- **Technical Constraints and Possibilities** → Product Manager
-- **Architecture Requirements and Limitations** → UI Designer
-- **Data Architecture Requirements** → Data Architect
-- **Security Architecture Framework** → Security Expert
-- **Technical Implementation Framework** → Feature Planner
-
-## ✅ **Quality Assurance**
-
-### Required Analysis Elements
-- [ ] Clear architecture diagrams and component designs
-- [ ] Detailed technology stack evaluation and recommendations
-- [ ] Scalability and performance analysis with metrics
-- [ ] System integration and API design specifications
-- [ ] Comprehensive risk assessment and mitigation strategies
-
-### Architecture Design Principles
-- [ ] **Scalability**: System can handle growth in users and data
-- [ ] **Maintainability**: Clear code structure, easy to modify and extend
-- [ ] **Reliability**: Built-in fault tolerance and recovery mechanisms
-- [ ] **Security**: Integrated security controls and protection measures
-- [ ] **Performance**: Meets response time and throughput requirements
-
-### Technical Decision Validation
-- [ ] Technology choices have thorough justification and comparison analysis
-- [ ] Architectural patterns align with business requirements and constraints
-- [ ] Integration solutions consider compatibility and maintenance costs
-- [ ] Deployment strategies are feasible with acceptable risk levels
-- [ ] Monitoring and operations strategies are comprehensive and actionable
-
-### Implementation Readiness
-- [ ] **Technical Feasibility**: All proposed solutions are technically achievable
-- [ ] **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

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

@@ -1,221 +0,0 @@
----
-name: ui-designer
-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(*)
----
-
-## 🎨 **UI Designer Analysis Generator**
-
-### 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 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
-
-### 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
-
-### Role Boundaries & Responsibilities
-
-#### **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
-
-#### **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**
-
-#### **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 & 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 ui-designer analysis for existing topic framework
-
-## Context Loading
-ASSIGNED_ROLE: ui-designer
-OUTPUT_LOCATION: .workflow/active/WFS-{session}/.brainstorming/ui-designer/
-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 ui-designer planning template
-   - Command: bash($(cat ~/.claude/workflows/cli-templates/planning-roles/ui-designer.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 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
-
-## Expected Deliverables
-1. **analysis.md**: Comprehensive UI/UX 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 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
-"
-```
-
-## 📋 **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 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"
-    }
-  ]
-});
-```
-
-## 📊 **Output 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 from Framework]
-
-## Framework Reference
-**Topic Framework**: @../guidance-specification.md
-**Role Focus**: UI/UX Design perspective
-
-## Discussion Points Analysis
-[Address each point from guidance-specification.md with UI/UX expertise]
-
-### Core Requirements (from framework)
-[UI/UX perspective on requirements]
-
-### Technical Considerations (from framework)
-[Interface and design system considerations]
-
-### User Experience Factors (from framework)
-[Detailed UX analysis and recommendations]
-
-### Implementation Challenges (from framework)
-[Design implementation and accessibility considerations]
-
-### 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**
-
-### Completion Status Update
-```json
-{
-  "ui_designer": {
-    "status": "completed",
-    "framework_addressed": true,
-    "output_location": ".workflow/active/WFS-{session}/.brainstorming/ui-designer/analysis.md",
-    "framework_reference": "@../guidance-specification.md"
-  }
-}
-```
-
-### 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/ux-expert.md

@@ -1,221 +0,0 @@
----
-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,548 @@
+---
+name: clean
+description: Intelligent code cleanup with mainline detection, stale artifact discovery, and safe execution
+argument-hint: "[-y|--yes] [--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 --yes                    # Auto mode (use safe defaults, no confirmation)
+/workflow:clean --dry-run                # Explore and analyze only, no execution
+/workflow:clean -y "auth module"         # Auto mode with focus area
+```
+
+## Auto Mode Defaults
+
+When `--yes` or `-y` flag is used:
+- **Categories to Clean**: Auto-selects `["Sessions"]` only (safest - only workflow sessions)
+- **Risk Level**: Auto-selects `"Low only"` (only low-risk items)
+- All confirmations skipped, proceeds directly to execution
+
+**Flag Parsing**:
+```javascript
+const autoYes = $ARGUMENTS.includes('--yes') || $ARGUMENTS.includes('-y')
+const dryRun = $ARGUMENTS.includes('--dry-run')
+```
+
+## 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
+// Parse --yes flag
+const autoYes = $ARGUMENTS.includes('--yes') || $ARGUMENTS.includes('-y')
+
+let userSelection
+
+if (autoYes) {
+  // Auto mode: Use safe defaults
+  console.log(`[--yes] Auto-selecting safe cleanup defaults:`)
+  console.log(`  - Categories: Sessions only`)
+  console.log(`  - Risk level: Low only`)
+
+  userSelection = {
+    categories: ["Sessions"],
+    risk: "Low only"
+  }
+} else {
+  // Interactive mode: Ask user
+  userSelection = 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,672 @@
+---
+name: debug-with-file
+description: Interactive hypothesis-driven debugging with documented exploration, understanding evolution, and Gemini-assisted correction
+argument-hint: "[-y|--yes] \"bug description or error message\""
+allowed-tools: TodoWrite(*), Task(*), AskUserQuestion(*), Read(*), Grep(*), Glob(*), Bash(*), Edit(*), Write(*)
+---
+
+## Auto Mode
+
+When `--yes` or `-y`: Auto-confirm all decisions (hypotheses, fixes, iteration), use recommended settings.
+
+# 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
+
+**Scope**: Adds temporary debug logging to observe program state; cleans up all instrumentation after resolution. Does NOT execute code injection, security testing, or modify program behavior.
+
+**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 debug logging statements
+   └─ 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 Debug Logging**
+
+For each hypothesis, add temporary logging statements to observe program state at key execution points. Use NDJSON format for structured log parsing. These are read-only observations that do not modify program behavior.
+
+**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 all temporary debug logging statements added during investigation. Verify no instrumentation code remains in production code.
+
+---
+
+## 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 debug 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/execute.md

@@ -1,7 +1,7 @@
 ---
 name: execute
 description: Coordinate agent execution for workflow tasks with automatic session discovery, parallel task processing, and status tracking
-argument-hint: "[--resume-session=\"session-id\"]"
+argument-hint: "[-y|--yes] [--resume-session=\"session-id\"]"
 ---
 
 # Workflow Execute Command
@@ -11,6 +11,30 @@ Orchestrates autonomous workflow execution through systematic task discovery, ag
 
 **Resume Mode**: When called with `--resume-session` flag, skips discovery phase and directly enters TodoWrite generation and agent execution for the specified session.
 
+## Usage
+
+```bash
+# Interactive mode (with confirmations)
+/workflow:execute
+/workflow:execute --resume-session="WFS-auth"
+
+# Auto mode (skip confirmations, use defaults)
+/workflow:execute --yes
+/workflow:execute -y
+/workflow:execute -y --resume-session="WFS-auth"
+```
+
+## Auto Mode Defaults
+
+When `--yes` or `-y` flag is used:
+- **Session Selection**: Automatically selects the first (most recent) active session
+- **Completion Choice**: Automatically completes session (runs `/workflow:session:complete --yes`)
+
+**Flag Parsing**:
+```javascript
+const autoYes = $ARGUMENTS.includes('--yes') || $ARGUMENTS.includes('-y')
+```
+
 ## Performance Optimization Strategy
 
 **Lazy Loading**: Task JSONs read **on-demand** during execution, not upfront. TODO_LIST.md + IMPL_PLAN.md provide metadata for planning.
@@ -23,7 +47,7 @@ Orchestrates autonomous workflow execution through systematic task discovery, ag
 ## Core Rules
 **Complete entire workflow autonomously without user interruption, using TodoWrite for comprehensive progress tracking.**
 **Execute all discovered pending tasks until workflow completion or blocking dependency.**
-**Auto-complete session when all tasks finished: Call `/workflow:session:complete` upon workflow completion.**
+**User-choice completion: When all tasks finished, ask user to choose review or complete.**
 **ONE AGENT = ONE TASK JSON: Each agent instance executes exactly one task JSON file - never batch multiple tasks into single agent execution.**
 
 ## Core Responsibilities
@@ -33,7 +57,7 @@ Orchestrates autonomous workflow execution through systematic task discovery, ag
 - **Agent Orchestration**: Coordinate specialized agents with complete context
 - **Status Synchronization**: Update task JSON files and workflow state
 - **Autonomous Completion**: Continue execution until all tasks complete or reach blocking state
-- **Session Auto-Complete**: Call `/workflow:session:complete` when all workflow tasks finished
+- **Session User-Choice Completion**: Ask user to choose review or complete when all tasks finished
 
 ## Execution Philosophy
 - **Progress tracking**: Continuous TodoWrite updates throughout entire workflow execution
@@ -56,6 +80,7 @@ Phase 2: Planning Document Validation
    └─ 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
@@ -67,17 +92,22 @@ Phase 4: Execution Strategy & Task Execution
          ├─ Get next in_progress task from TodoWrite
          ├─ Lazy load task JSON
          ├─ Launch agent with task context
-         ├─ Mark task completed
+         ├─ 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
-   └─ Auto-call /workflow:session:complete
+   └─ AskUserQuestion: Choose next step
+      ├─ "Enter Review" → /workflow:review
+      └─ "Complete Session" → /workflow:session:complete
 
 Resume Mode (--resume-session):
    ├─ Skip Phase 1 & Phase 2
    └─ Entry Point: Phase 3 (TodoWrite Generation)
+      ├─ Update session status to "active" (if not already)
       └─ Continue: Phase 4 → Phase 5
 ```
 
@@ -113,34 +143,41 @@ Auto-select and continue to Phase 2.
 
 List sessions with metadata and prompt user selection:
 ```bash
-bash(for dir in .workflow/active/WFS-*/; do
-  session=$(basename "$dir")
-  project=$(jq -r '.project // "Unknown"' "$dir/workflow-session.json" 2>/dev/null)
-  total=$(grep -c "^- \[" "$dir/TODO_LIST.md" 2>/dev/null || echo "0")
-  completed=$(grep -c "^- \[x\]" "$dir/TODO_LIST.md" 2>/dev/null || echo "0")
-  [ "$total" -gt 0 ] && progress=$((completed * 100 / total)) || progress=0
-  echo "${session} | ${project} | ${completed}/${total} tasks (${progress}%)"
-done)
+bash(for dir in .workflow/active/WFS-*/; do [ -d "$dir" ] || continue; session=$(basename "$dir"); project=$(jq -r '.project // "Unknown"' "${dir}workflow-session.json" 2>/dev/null || echo "Unknown"); total=$(grep -c '^\- \[' "${dir}TODO_LIST.md" 2>/dev/null || echo 0); completed=$(grep -c '^\- \[x\]' "${dir}TODO_LIST.md" 2>/dev/null || echo 0); if [ "$total" -gt 0 ]; then progress=$((completed * 100 / total)); else progress=0; fi; echo "$session | $project | $completed/$total tasks ($progress%)"; done)
 ```
 
-Use AskUserQuestion to present formatted options (max 4 options shown):
+**Parse --yes flag**:
 ```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)
+const autoYes = $ARGUMENTS.includes('--yes') || $ARGUMENTS.includes('-y')
+```
 
-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
-  }]
-})
+**Conditional Selection**:
+```javascript
+if (autoYes) {
+  // Auto mode: Select first session (most recent)
+  const firstSession = sessions[0]
+  console.log(`[--yes] Auto-selecting session: ${firstSession.id}`)
+  selectedSessionId = firstSession.id
+  // Continue to Phase 2
+} else {
+  // Interactive mode: Use AskUserQuestion to present formatted options (max 4 options shown)
+  // 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**:
@@ -177,6 +214,16 @@ bash(cat .workflow/active/${sessionId}/workflow-session.json)
 ### 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
@@ -240,7 +287,45 @@ while (TODO_LIST.md has pending tasks) {
 3. **Update TodoWrite**: Mark current task complete, advance to next
 4. **Synchronize State**: Update session state and workflow status
 5. **Check Workflow Complete**: Verify all tasks are completed
-6. **Auto-Complete Session**: Call `/workflow:session:complete` when all tasks finished
+6. **User Choice**: When all tasks finished, ask user to choose next step:
+
+```javascript
+// Parse --yes flag
+const autoYes = $ARGUMENTS.includes('--yes') || $ARGUMENTS.includes('-y')
+
+if (autoYes) {
+  // Auto mode: Complete session automatically
+  console.log(`[--yes] Auto-selecting: Complete Session`)
+  SlashCommand("/workflow:session:complete --yes")
+} else {
+  // Interactive mode: Ask user
+  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)
 
@@ -316,7 +401,7 @@ blocked → skip until dependencies clear
 - **Continuous Tracking**: Maintain TodoWrite throughout entire workflow execution until completion
 
 **Rule 4: Workflow Completion Check**
-- When all tasks marked `completed`, auto-call `/workflow:session:complete`
+- When all tasks marked `completed`, prompt user to choose review or complete session
 
 ### TodoWrite Tool Usage
 
@@ -374,39 +459,42 @@ TodoWrite({
 **Note**: Orchestrator does NOT execute flow control steps - Agent interprets and executes them autonomously.
 
 ### Agent Prompt Template
-**Dynamic Generation**: Before agent invocation, read task JSON and extract key requirements.
+**Path-Based Invocation**: Pass paths and trigger markers, let agent parse task JSON autonomously.
 
 ```bash
 Task(subagent_type="{meta.agent}",
-     prompt="Execute task: {task.title}
+     run_in_background=false,
+     prompt="Implement task {task.id}: {task.title}
 
-     {[FLOW_CONTROL]}
+     [FLOW_CONTROL]
 
-     **Task Objectives** (from task JSON):
-     {task.context.objective}
-
-     **Expected Deliverables** (from task JSON):
-     {task.context.deliverables}
-
-     **Quality Standards** (from task JSON):
-     {task.context.acceptance_criteria}
-
-     **MANDATORY FIRST STEPS**:
-     1. Read complete task JSON: {session.task_json_path}
-     2. Load context package: {session.context_package_path}
-
-     Follow complete execution guidelines in @.claude/agents/{meta.agent}.md
-
-     **Session Paths**:
-     - Workflow Dir: {session.workflow_dir}
-     - TODO List: {session.todo_list_path}
-     - Summaries Dir: {session.summaries_dir}
+     **Input**:
+     - Task JSON: {session.task_json_path}
      - Context Package: {session.context_package_path}
 
-     **Success Criteria**: Complete all objectives, meet all quality standards, deliver all outputs as specified above.",
-     description="Executing: {task.title}")
+     **Output Location**:
+     - Workflow: {session.workflow_dir}
+     - TODO List: {session.todo_list_path}
+     - Summaries: {session.summaries_dir}
+
+     **Execution**: Read task JSON → Execute pre_analysis → Check execution_config.method → (CLI: handoff to CLI tool | Agent: direct implementation) → Update TODO_LIST.md → Generate summary",
+     description="Implement: {task.id}")
 ```
 
+**Key Markers**:
+- `Implement` keyword: Triggers tech stack detection and guidelines loading
+- `[FLOW_CONTROL]`: Triggers flow_control.pre_analysis execution
+
+**Why Path-Based**: Agent (code-developer.md) autonomously:
+- Reads and parses task JSON (requirements, acceptance, flow_control, execution_config)
+- Executes pre_analysis steps (Phase 1: context gathering)
+- Checks execution_config.method (Phase 2: determine mode)
+- CLI mode: Builds handoff prompt and executes via ccw cli with resume strategy
+- Agent mode: Directly implements using modification_points and logic_flow
+- Generates structured summary with integration points
+
+Embedding task content in prompt creates duplication and conflicts with agent's parsing logic.
+
 ### Agent Assignment Rules
 ```
 meta.agent specified → Use specified agent

.claude/commands/workflow/init.md

@@ -10,7 +10,11 @@ examples:
 # Workflow Init Command (/workflow:init)
 
 ## Overview
-Initialize `.workflow/project.json` with comprehensive project understanding by delegating analysis to **cli-explore-agent**.
+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.
 
@@ -27,7 +31,7 @@ Input Parsing:
    └─ Parse --regenerate flag → regenerate = true | false
 
 Decision:
-   ├─ EXISTS + no --regenerate → Exit: "Already initialized"
+   ├─ BOTH_EXIST + no --regenerate → Exit: "Already initialized"
    ├─ EXISTS + --regenerate → Backup existing → Continue analysis
    └─ NOT_FOUND → Continue analysis
 
@@ -37,11 +41,14 @@ Analysis Flow:
    │   ├─ Structural scan (get_modules_by_depth.sh, find, wc)
    │   ├─ Semantic analysis (Gemini CLI)
    │   ├─ Synthesis and merge
-   │   └─ Write .workflow/project.json
+   │   └─ Write .workflow/project-tech.json
+   ├─ Create guidelines scaffold (if not exists)
+   │   └─ Write .workflow/project-guidelines.json (empty structure)
    └─ Display summary
 
 Output:
-   └─ .workflow/project.json (+ .backup if regenerate)
+   ├─ .workflow/project-tech.json (+ .backup if regenerate)
+   └─ .workflow/project-guidelines.json (scaffold if new)
 ```
 
 ## Implementation
@@ -56,13 +63,18 @@ const regenerate = $ARGUMENTS.includes('--regenerate')
 **Check existing state**:
 
 ```bash
-bash(test -f .workflow/project.json && echo "EXISTS" || echo "NOT_FOUND")
+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 EXISTS and no --regenerate**: Exit early
+**If BOTH_EXIST and no --regenerate**: Exit early
 ```
-Project already initialized at .workflow/project.json
-Use /workflow:init --regenerate to rebuild
+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
 ```
 
@@ -78,7 +90,7 @@ bash(mkdir -p .workflow)
 
 **For --regenerate**: Backup and preserve existing data
 ```bash
-bash(cp .workflow/project.json .workflow/project.json.backup)
+bash(cp .workflow/project-tech.json .workflow/project-tech.json.backup)
 ```
 
 **Delegate analysis to agent**:
@@ -86,23 +98,34 @@ bash(cp .workflow/project.json .workflow/project.json.backup)
 ```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.json.
+Analyze project for workflow initialization and generate .workflow/project-tech.json.
 
 ## MANDATORY FIRST STEPS
-1. Execute: cat ~/.claude/workflows/cli-templates/schemas/project-json-schema.json (get schema reference)
-2. Execute: ~/.claude/scripts/get_modules_by_depth.sh (get project structure)
+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.json with:
-- project_name: ${projectName}
-- initialized_at: current ISO timestamp
-- overview: {description, technology_stack, architecture, key_components, entry_points, metrics}
-- features: ${regenerate ? 'preserve from backup' : '[] (empty)'}
-- statistics: ${regenerate ? 'preserve from backup' : '{total_features: 0, total_sessions: 0, last_updated}'}
-- memory_resources: {skills, documentation, module_docs, gaps, last_scanned}
-- _metadata: {initialized_by: "cli-explore-agent", analysis_timestamp, analysis_mode}
+Generate complete project-tech.json following the schema structure:
+- project_name: "${projectName}"
+- initialized_at: ISO 8601 timestamp
+- overview: {
+    description: "Brief project description",
+    technology_stack: {
+      languages: [{name, file_count, primary}],
+      frameworks: ["string"],
+      build_tools: ["string"],
+      test_frameworks: ["string"]
+    },
+    architecture: {style, layers: [], patterns: []},
+    key_components: [{name, path, description, importance}]
+  }
+- features: []
+- development_index: ${regenerate ? 'preserve from backup' : '{feature: [], enhancement: [], bugfix: [], refactor: [], docs: []}'}
+- statistics: ${regenerate ? 'preserve from backup' : '{total_features: 0, total_sessions: 0, last_updated: ISO timestamp}'}
+- _metadata: {initialized_by: "cli-explore-agent", analysis_timestamp: ISO timestamp, analysis_mode: "deep-scan"}
 
 ## Analysis Requirements
 
@@ -118,29 +141,12 @@ Generate complete project.json with:
 - Patterns: singleton, factory, repository
 - Key components: 5-10 modules {name, path, description, importance}
 
-**Metrics**:
-- total_files: Source files (exclude tests/configs)
-- lines_of_code: Use find + wc -l
-- module_count: Use ~/.claude/scripts/get_modules_by_depth.sh
-- complexity: low | medium | high
-
-**Entry Points**:
-- main: index.ts, main.py, main.go
-- cli_commands: package.json scripts, Makefile targets
-- api_endpoints: HTTP/REST routes (if applicable)
-
-**Memory Resources**:
-- skills: Scan .claude/skills/ → [{name, type, path}]
-- documentation: Scan .workflow/docs/ → [{name, path, has_readme, has_architecture}]
-- module_docs: Find **/CLAUDE.md (exclude node_modules, .git)
-- gaps: Identify missing resources
-
 ## 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 features/statistics from .workflow/project.json.backup' : ''}
-5. Write JSON: Write('.workflow/project.json', jsonContent)
+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}
@@ -148,40 +154,66 @@ 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 projectJson = JSON.parse(Read('.workflow/project.json'));
+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: ${projectJson.project_name}
-Description: ${projectJson.overview.description}
+Name: ${projectTech.project_name}
+Description: ${projectTech.overview.description}
 
 ### Technology Stack
-Languages: ${projectJson.overview.technology_stack.languages.map(l => l.name).join(', ')}
-Frameworks: ${projectJson.overview.technology_stack.frameworks.join(', ')}
+Languages: ${projectTech.overview.technology_stack.languages.map(l => l.name).join(', ')}
+Frameworks: ${projectTech.overview.technology_stack.frameworks.join(', ')}
 
 ### Architecture
-Style: ${projectJson.overview.architecture.style}
-Components: ${projectJson.overview.key_components.length} core modules
-
-### Metrics
-Files: ${projectJson.overview.metrics.total_files}
-LOC: ${projectJson.overview.metrics.lines_of_code}
-Complexity: ${projectJson.overview.metrics.complexity}
-
-### Memory Resources
-SKILL Packages: ${projectJson.memory_resources.skills.length}
-Documentation: ${projectJson.memory_resources.documentation.length}
-Module Docs: ${projectJson.memory_resources.module_docs.length}
-Gaps: ${projectJson.memory_resources.gaps.join(', ') || 'none'}
+Style: ${projectTech.overview.architecture.style}
+Components: ${projectTech.overview.key_components.length} core modules
 
 ---
-Project state: .workflow/project.json
-${regenerate ? 'Backup: .workflow/project.json.backup' : ''}
+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
 `);
 ```
 

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

@@ -1,7 +1,7 @@
 ---
 name: lite-execute
 description: Execute tasks based on in-memory plan, prompt description, or file content
-argument-hint: "[--in-memory] [\"task description\"|file-path]"
+argument-hint: "[-y|--yes] [--in-memory] [\"task description\"|file-path]"
 allowed-tools: TodoWrite(*), Task(*), Bash(*)
 ---
 
@@ -62,30 +62,49 @@ Flexible task execution command supporting three input modes: in-memory plan (fr
 
 **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: "Agent Review", description: "Current agent review" }
-      ]
-    }
-  ]
-})
+// Parse --yes flag
+const autoYes = $ARGUMENTS.includes('--yes') || $ARGUMENTS.includes('-y')
+
+let userSelection
+
+if (autoYes) {
+  // Auto mode: Use defaults
+  console.log(`[--yes] Auto-confirming execution:`)
+  console.log(`  - Execution method: Auto`)
+  console.log(`  - Code review: Skip`)
+
+  userSelection = {
+    execution_method: "Auto",
+    code_review_tool: "Skip"
+  }
+} else {
+  // Interactive mode: Ask user
+  userSelection = 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
@@ -150,12 +169,13 @@ Input Parsing:
 Execution:
    ├─ Step 1: Initialize result tracking (previousExecutionResults = [])
    ├─ Step 2: Task grouping & batch creation
-   │   ├─ Infer dependencies (same file → sequential, keywords → sequential)
-   │   ├─ Group into batches (parallel: independent, sequential: dependent)
+   │   ├─ 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 parallel batches (⚡ concurrent via multiple tool calls)
-   │   └─ Phase 2: Sequential batches (→ one by one)
+   │   ├─ 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")
 
@@ -170,76 +190,91 @@ Output:
 **Operations**:
 - Initialize result tracking for multi-execution scenarios
 - Set up `previousExecutionResults` array for context continuity
+- **In-Memory Mode**: Echo execution strategy from lite-plan for transparency
 
 ```javascript
 // Initialize result tracking
 previousExecutionResults = []
+
+// In-Memory Mode: Echo execution strategy (transparency before execution)
+if (executionContext) {
+  console.log(`
+📋 Execution Strategy (from lite-plan):
+   Method: ${executionContext.executionMethod}
+   Review: ${executionContext.codeReviewTool}
+   Tasks: ${executionContext.planObject.tasks.length}
+   Complexity: ${executionContext.planObject.complexity}
+${executionContext.executorAssignments ? `   Assignments: ${JSON.stringify(executionContext.executorAssignments)}` : ''}
+  `)
+}
 ```
 
 ### Step 2: Task Grouping & Batch Creation
 
 **Dependency Analysis & Grouping Algorithm**:
 ```javascript
-// Infer dependencies: same file → sequential, keywords (use/integrate) → sequential
-function inferDependencies(tasks) {
-  return tasks.map((task, i) => {
-    const deps = []
-    const file = task.file || task.title.match(/in\s+([^\s:]+)/)?.[1]
-    const keywords = (task.description || task.title).toLowerCase()
+// 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 })
 
-    for (let j = 0; j < i; j++) {
-      const prevFile = tasks[j].file || tasks[j].title.match(/in\s+([^\s:]+)/)?.[1]
-      if (file && prevFile === file) deps.push(j)  // Same file
-      else if (/use|integrate|call|import/.test(keywords)) deps.push(j)  // Keyword dependency
-    }
+  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: independent → parallel [P1,P2...], dependent → sequential [S1,S2...]
+// Group into batches: maximize parallel execution
 function createExecutionCalls(tasks, executionMethod) {
-  const tasksWithDeps = inferDependencies(tasks)
-  const maxBatch = executionMethod === "Codex" ? 4 : 7
-  const calls = []
+  const tasksWithDeps = extractDependencies(tasks)
   const processed = new Set()
+  const calls = []
 
-  // Parallel: independent tasks, different files, max batch size
-  const parallelGroups = []
-  tasksWithDeps.forEach(t => {
-    if (t.dependencies.length === 0 && !processed.has(t.taskIndex)) {
-      const group = [t]
-      processed.add(t.taskIndex)
-      tasksWithDeps.forEach(o => {
-        if (!o.dependencies.length && !processed.has(o.taskIndex) &&
-            group.length < maxBatch && t.file !== o.file) {
-          group.push(o)
-          processed.add(o.taskIndex)
-        }
-      })
-      parallelGroups.push(group)
-    }
-  })
-
-  // Sequential: dependent tasks, batch when deps satisfied
-  const remaining = tasksWithDeps.filter(t => !processed.has(t.taskIndex))
-  while (remaining.length > 0) {
-    const batch = remaining.filter((t, i) =>
-      i < maxBatch && t.dependencies.every(d => processed.has(d))
-    )
-    if (!batch.length) break
-    batch.forEach(t => processed.add(t.taskIndex))
-    calls.push({ executionType: "sequential", groupId: `S${calls.length + 1}`, tasks: batch })
-    remaining.splice(0, remaining.length, ...remaining.filter(t => !processed.has(t.taskIndex)))
+  // 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
+    })
   }
 
-  // Combine results
-  return [
-    ...parallelGroups.map((g, i) => ({
-      method: executionMethod, executionType: "parallel", groupId: `P${i+1}`,
-      taskSummary: g.map(t => t.title).join(' | '), tasks: g
-    })),
-    ...calls.map(c => ({ ...c, method: executionMethod, taskSummary: c.tasks.map(t => t.title).join(' → ') }))
-  ]
+  // 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}]` }))
@@ -255,6 +290,33 @@ TodoWrite({
 
 ### 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")
@@ -277,90 +339,98 @@ for (const call of sequential) {
 }
 ```
 
+### Unified Task Prompt Builder
+
+**Task Formatting Principle**: Each task is a self-contained checklist. The executor only needs to know what THIS task requires. Same template for Agent and CLI.
+
+```javascript
+function buildExecutionPrompt(batch) {
+  // Task template (6 parts: Modification Points → Why → How → Reference → Risks → Done)
+  const formatTask = (t) => `
+## ${t.title}
+
+**Scope**: \`${t.scope}\`  |  **Action**: ${t.action}
+
+### Modification Points
+${t.modification_points.map(p => `- **${p.file}** → \`${p.target}\`: ${p.change}`).join('\n')}
+
+${t.rationale ? `
+### Why this approach (Medium/High)
+${t.rationale.chosen_approach}
+${t.rationale.decision_factors?.length > 0 ? `\nKey factors: ${t.rationale.decision_factors.join(', ')}` : ''}
+${t.rationale.tradeoffs ? `\nTradeoffs: ${t.rationale.tradeoffs}` : ''}
+` : ''}
+
+### How to do it
+${t.description}
+
+${t.implementation.map(step => `- ${step}`).join('\n')}
+
+${t.code_skeleton ? `
+### Code skeleton (High)
+${t.code_skeleton.interfaces?.length > 0 ? `**Interfaces**: ${t.code_skeleton.interfaces.map(i => `\`${i.name}\` - ${i.purpose}`).join(', ')}` : ''}
+${t.code_skeleton.key_functions?.length > 0 ? `\n**Functions**: ${t.code_skeleton.key_functions.map(f => `\`${f.signature}\` - ${f.purpose}`).join(', ')}` : ''}
+${t.code_skeleton.classes?.length > 0 ? `\n**Classes**: ${t.code_skeleton.classes.map(c => `\`${c.name}\` - ${c.purpose}`).join(', ')}` : ''}
+` : ''}
+
+### Reference
+- Pattern: ${t.reference?.pattern || 'N/A'}
+- Files: ${t.reference?.files?.join(', ') || 'N/A'}
+${t.reference?.examples ? `- Notes: ${t.reference.examples}` : ''}
+
+${t.risks?.length > 0 ? `
+### Risk mitigations (High)
+${t.risks.map(r => `- ${r.description} → **${r.mitigation}**`).join('\n')}
+` : ''}
+
+### Done when
+${t.acceptance.map(c => `- [ ] ${c}`).join('\n')}
+${t.verification?.success_metrics?.length > 0 ? `\n**Success metrics**: ${t.verification.success_metrics.join(', ')}` : ''}`
+
+  // Build prompt
+  const sections = []
+
+  if (originalUserInput) sections.push(`## Goal\n${originalUserInput}`)
+
+  sections.push(`## Tasks\n${batch.tasks.map(formatTask).join('\n\n---\n')}`)
+
+  // Context (reference only)
+  const context = []
+  if (previousExecutionResults.length > 0) {
+    context.push(`### Previous Work\n${previousExecutionResults.map(r => `- ${r.tasksSummary}: ${r.status}`).join('\n')}`)
+  }
+  if (clarificationContext) {
+    context.push(`### Clarifications\n${Object.entries(clarificationContext).map(([q, a]) => `- ${q}: ${a}`).join('\n')}`)
+  }
+  if (executionContext?.planObject?.data_flow?.diagram) {
+    context.push(`### Data Flow\n${executionContext.planObject.data_flow.diagram}`)
+  }
+  if (executionContext?.session?.artifacts?.plan) {
+    context.push(`### Artifacts\nPlan: ${executionContext.session.artifacts.plan}`)
+  }
+  // Project guidelines (user-defined constraints from /workflow:session:solidify)
+  context.push(`### Project Guidelines\n@.workflow/project-guidelines.json`)
+  if (context.length > 0) sections.push(`## Context\n${context.join('\n\n')}`)
+
+  sections.push(`Complete each task according to its "Done when" checklist.`)
+
+  return sections.join('\n\n')
+}
+```
+
 **Option A: Agent Execution**
 
 When to use:
-- `executionMethod = "Agent"`
-- `executionMethod = "Auto" AND complexity = "Low"`
+- `getTaskExecutor(task) === "agent"`
+- 或 `executionMethod = "Agent"` (全局 fallback)
+- 或 `executionMethod = "Auto" AND complexity = "Low"` (全局 fallback)
 
-Agent call format:
 ```javascript
-function formatTaskForAgent(task, index) {
-  return `
-### Task ${index + 1}: ${task.title}
-**File**: ${task.file}
-**Action**: ${task.action}
-**Description**: ${task.description}
-
-**Implementation Steps**:
-${task.implementation.map((step, i) => `${i + 1}. ${step}`).join('\n')}
-
-**Reference**:
-- Pattern: ${task.reference.pattern}
-- Example Files: ${task.reference.files.join(', ')}
-- Guidance: ${task.reference.examples}
-
-**Acceptance Criteria**:
-${task.acceptance.map((criterion, i) => `${i + 1}. ${criterion}`).join('\n')}
-`
-}
-
 Task(
   subagent_type="code-developer",
-  description="Implement planned tasks",
-  prompt=`
-  ${originalUserInput ? `## Original User Request\n${originalUserInput}\n\n` : ''}
-
-  ## Implementation Plan
-
-  **Summary**: ${planObject.summary}
-  **Approach**: ${planObject.approach}
-
-  ## Task Breakdown (${planObject.tasks.length} tasks)
-  ${planObject.tasks.map((task, i) => formatTaskForAgent(task, i)).join('\n')}
-
-  ${previousExecutionResults.length > 0 ? `\n## Previous Execution Results\n${previousExecutionResults.map(result => `
-[${result.executionId}] ${result.status}
-Tasks: ${result.tasksSummary}
-Completion: ${result.completionSummary}
-Outputs: ${result.keyOutputs || 'See git diff'}
-${result.notes ? `Notes: ${result.notes}` : ''}
-  `).join('\n---\n')}` : ''}
-
-  ## Multi-Angle Code Context
-
-  ${explorationsContext && Object.keys(explorationsContext).length > 0 ?
-    explorationAngles.map(angle => {
-      const exp = explorationsContext[angle]
-      return `### Exploration Angle: ${angle}
-
-**Project Structure**: ${exp.project_structure || 'N/A'}
-**Relevant Files**: ${exp.relevant_files?.join(', ') || 'None'}
-**Patterns**: ${exp.patterns || 'N/A'}
-**Dependencies**: ${exp.dependencies || 'N/A'}
-**Integration Points**: ${exp.integration_points || 'N/A'}
-**Constraints**: ${exp.constraints || 'N/A'}`
-    }).join('\n\n---\n\n')
-    : "No exploration performed"
-  }
-
-  ${clarificationContext ? `\n## Clarifications\n${JSON.stringify(clarificationContext, null, 2)}` : ''}
-
-  ${executionContext?.session?.artifacts ? `\n## Exploration Artifact Files
-
-  Detailed exploration context available in:
-  ${executionContext.session.artifacts.explorations?.map(exp =>
-    `- Angle: ${exp.angle} → ${exp.path}`
-  ).join('\n') || ''}
-  ${executionContext.session.artifacts.explorations_manifest ? `- Manifest: ${executionContext.session.artifacts.explorations_manifest}` : ''}
-  - Plan: ${executionContext.session.artifacts.plan}
-
-  Read exploration files for comprehensive context from multiple angles.` : ''}
-
-  ## Requirements
-  MUST complete ALL ${planObject.tasks.length} tasks listed above in this single execution.
-  Return only after all tasks are fully implemented and tested.
-  `
+  run_in_background=false,
+  description=batch.taskSummary,
+  prompt=buildExecutionPrompt(batch)
 )
 ```
 
@@ -369,109 +439,63 @@ ${result.notes ? `Notes: ${result.notes}` : ''}
 **Option B: CLI Execution (Codex)**
 
 When to use:
-- `executionMethod = "Codex"`
-- `executionMethod = "Auto" AND complexity = "Medium" or "High"`
+- `getTaskExecutor(task) === "codex"`
+- 或 `executionMethod = "Codex"` (全局 fallback)
+- 或 `executionMethod = "Auto" AND complexity = "Medium/High"` (全局 fallback)
 
-**Artifact Path Delegation**:
-- Include artifact file paths in CLI prompt for enhanced context
-- Codex can read artifact files for detailed planning information
-- Example: Reference exploration.json for architecture patterns
-
-Command format:
 ```bash
-function formatTaskForCodex(task, index) {
-  return `
-${index + 1}. ${task.title} (${task.file})
-   Action: ${task.action}
-   What: ${task.description}
-   How:
-${task.implementation.map((step, i) => `   ${i + 1}. ${step}`).join('\n')}
-   Reference: ${task.reference.pattern} (see ${task.reference.files.join(', ')})
-   Guidance: ${task.reference.examples}
-   Verify:
-${task.acceptance.map((criterion, i) => `   - ${criterion}`).join('\n')}
-`
-}
-
-codex --full-auto exec "
-${originalUserInput ? `## Original User Request\n${originalUserInput}\n\n` : ''}
-
-## Implementation Plan
-
-TASK: ${planObject.summary}
-APPROACH: ${planObject.approach}
-
-### Task Breakdown (${planObject.tasks.length} tasks)
-${planObject.tasks.map((task, i) => formatTaskForCodex(task, i)).join('\n')}
-
-${previousExecutionResults.length > 0 ? `\n### Previous Execution Results\n${previousExecutionResults.map(result => `
-[${result.executionId}] ${result.status}
-Tasks: ${result.tasksSummary}
-Status: ${result.completionSummary}
-Outputs: ${result.keyOutputs || 'See git diff'}
-${result.notes ? `Notes: ${result.notes}` : ''}
-`).join('\n---\n')}
-
-IMPORTANT: Review previous results. Build on completed work. Avoid duplication.
-` : ''}
-
-### Multi-Angle Code Context
-
-${explorationsContext && Object.keys(explorationsContext).length > 0 ?
-  `Exploration conducted from ${explorationAngles.length} angles:
-
-${explorationAngles.map(angle => {
-  const exp = explorationsContext[angle]
-  return `Angle: ${angle}
-- Structure: ${exp.project_structure || 'Standard structure'}
-- Files: ${exp.relevant_files?.slice(0, 5).join(', ') || 'TBD'}${exp.relevant_files?.length > 5 ? ` (+${exp.relevant_files.length - 5} more)` : ''}
-- Patterns: ${exp.patterns?.substring(0, 100) || 'Follow existing'}${exp.patterns?.length > 100 ? '...' : ''}
-- Constraints: ${exp.constraints || 'None'}`
-}).join('\n\n')}
-`
-  : 'No prior exploration - analyze codebase as needed'
-}
-
-${clarificationContext ? `\n### User Clarifications\n${Object.entries(clarificationContext).map(([q, a]) => `${q}: ${a}`).join('\n')}` : ''}
-
-${executionContext?.session?.artifacts ? `\n### Exploration Artifact Files
-Detailed context from multiple exploration angles available in:
-${executionContext.session.artifacts.explorations?.map(exp =>
-  `- Angle: ${exp.angle} → ${exp.path}`
-).join('\n') || ''}
-${executionContext.session.artifacts.explorations_manifest ? `- Manifest: ${executionContext.session.artifacts.explorations_manifest}` : ''}
-- Plan: ${executionContext.session.artifacts.plan}
-
-Read exploration files for comprehensive architectural, pattern, and constraint details from multiple angles.
-` : ''}
-
-## Requirements
-MUST complete ALL ${planObject.tasks.length} tasks listed above in this single execution.
-Return only after all tasks are fully implemented and tested.
-
-Complexity: ${planObject.complexity}
-" --skip-git-repo-check -s danger-full-access
+ccw cli -p "${buildExecutionPrompt(batch)}" --tool codex --mode write
 ```
 
-**Execution with tracking**:
+**Execution with fixed IDs** (predictable ID pattern):
 ```javascript
-// Launch CLI in foreground (NOT background)
-// Timeout based on complexity: Low=40min, Medium=60min, High=100min
-const timeoutByComplexity = {
-  "Low": 2400000,    // 40 minutes
-  "Medium": 3600000, // 60 minutes
-  "High": 6000000    // 100 minutes
-}
+// Launch CLI in background, wait for task hook callback
+// Generate fixed execution ID: ${sessionId}-${groupId}
+const sessionId = executionContext?.session?.id || 'standalone'
+const fixedExecutionId = `${sessionId}-${batch.groupId}`  // e.g., "implement-auth-2025-12-13-P1"
 
-bash_result = Bash(
+// 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,
-  timeout=timeoutByComplexity[planObject.complexity] || 3600000
+  run_in_background=true
 )
-
-// Update TodoWrite when execution completes
+// STOP HERE - CLI executes in background, task hook will notify on completion
 ```
 
-**Result Collection**: After completion, analyze output and collect result following `executionResult` structure
+**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
 
@@ -481,32 +505,41 @@ Progress tracked at batch level (not individual task level). Icons: ⚡ (paralle
 
 **Skip Condition**: Only run if `codeReviewTool ≠ "Skip"`
 
-**Review Focus**: Verify implementation against plan acceptance criteria
-- Read plan.json for task acceptance criteria
+**Review Focus**: Verify implementation against plan acceptance criteria and verification requirements
+- Read plan.json for task acceptance criteria and verification checklist
 - Check each acceptance criterion is fulfilled
+- Verify success metrics from verification field (Medium/High complexity)
+- Run unit/integration tests specified in verification field
 - Validate code quality and identify issues
-- Ensure alignment with planned approach
+- Ensure alignment with planned approach and risk mitigations
 
 **Operations**:
 - Agent Review: Current agent performs direct review
 - Gemini Review: Execute gemini CLI with review prompt
-- Custom tool: Execute specified CLI tool (qwen, codex, etc.)
+- Codex Review: Two options - (A) with prompt for complex reviews, (B) `--uncommitted` flag only for quick reviews
+- Custom tool: Execute specified CLI tool (qwen, etc.)
 
 **Unified Review Template** (All tools use same standard):
 
 **Review Criteria**:
 - **Acceptance Criteria**: Verify each criterion from plan.tasks[].acceptance
+- **Verification Checklist** (Medium/High): Check unit_tests, integration_tests, success_metrics from plan.tasks[].verification
 - **Code Quality**: Analyze quality, identify issues, suggest improvements
-- **Plan Alignment**: Validate implementation matches planned approach
+- **Plan Alignment**: Validate implementation matches planned approach and risk mitigations
 
 **Shared Prompt Template** (used by all CLI tools):
 ```
-PURPOSE: Code review for implemented changes against plan acceptance criteria
-TASK: • Verify plan acceptance criteria fulfillment • Analyze code quality • Identify issues • Suggest improvements • Validate plan adherence
+PURPOSE: Code review for implemented changes against plan acceptance criteria and verification requirements
+TASK: • Verify plan acceptance criteria fulfillment • Check verification requirements (unit tests, success metrics) • Analyze code quality • Identify issues • Suggest improvements • Validate plan adherence and risk mitigations
 MODE: analysis
-CONTEXT: @**/* @{plan.json} [@{exploration.json}] | Memory: Review lite-execute changes against plan requirements
-EXPECTED: Quality assessment with acceptance criteria verification, issue identification, and recommendations. Explicitly check each acceptance criterion from plan.json tasks.
-RULES: $(cat ~/.claude/workflows/cli-templates/prompts/analysis/02-review-code-quality.txt) | Focus on plan acceptance criteria and plan adherence | analysis=READ-ONLY
+CONTEXT: @**/* @{plan.json} [@{exploration.json}] | Memory: Review lite-execute changes against plan requirements including verification checklist
+EXPECTED: Quality assessment with:
+  - Acceptance criteria verification (all tasks)
+  - Verification checklist validation (Medium/High: unit_tests, integration_tests, success_metrics)
+  - Issue identification
+  - Recommendations
+  Explicitly check each acceptance criterion and verification item from plan.json tasks.
+CONSTRAINTS: Focus on plan acceptance criteria, verification requirements, and plan adherence | analysis=READ-ONLY
 ```
 
 **Tool-Specific Execution** (Apply shared prompt template above):
@@ -518,26 +551,102 @@ RULES: $(cat ~/.claude/workflows/cli-templates/prompts/analysis/02-review-code-q
 # - Report findings directly
 
 # Method 2: Gemini Review (recommended)
-gemini -p "[Shared Prompt Template with artifacts]"
+ccw cli -p "[Shared Prompt Template with artifacts]" --tool gemini --mode analysis
 # CONTEXT includes: @**/* @${plan.json} [@${exploration.json}]
 
 # Method 3: Qwen Review (alternative)
-qwen -p "[Shared Prompt Template with artifacts]"
+ccw cli -p "[Shared Prompt Template with artifacts]" --tool qwen --mode analysis
 # Same prompt as Gemini, different execution engine
 
-# Method 4: Codex Review (autonomous)
-codex --full-auto exec "[Verify plan acceptance criteria at ${plan.json}]" --skip-git-repo-check -s danger-full-access
+# 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)
-**Batch Limits**: Agent 7 tasks, CLI 4 tasks
-**Execution**: Parallel batches use single Claude message with multiple tool calls (no concurrency limit)
+**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
 
@@ -548,8 +657,10 @@ codex --full-auto exec "[Verify plan acceptance criteria at ${plan.json}]" --ski
 | 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, save partial progress, suggest retry |
+| 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
 
@@ -571,10 +682,15 @@ Passed from lite-plan via global variable:
   explorationAngles: string[],             // List of exploration angles
   explorationManifest: {...} | null,       // Exploration manifest
   clarificationContext: {...} | null,
-  executionMethod: "Agent" | "Codex" | "Auto",
+  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}
@@ -604,8 +720,24 @@ Collected after each execution call completes:
   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
+  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-lite-lite.md

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

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

@@ -1,7 +1,7 @@
 ---
 name: lite-plan
-description: Lightweight interactive planning workflow with in-memory planning, code exploration, and execution dispatch to lite-execute after user confirmation
-argument-hint: "[-e|--explore] \"task description\"|file.md"
+description: Lightweight interactive planning workflow with in-memory planning, code exploration, and execution execute to lite-execute after user confirmation
+argument-hint: "[-y|--yes] [-e|--explore] \"task description\"|file.md"
 allowed-tools: TodoWrite(*), Task(*), SlashCommand(*), AskUserQuestion(*)
 ---
 
@@ -15,9 +15,9 @@ Intelligent lightweight planning command with dynamic workflow adaptation based
 - 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 strategy (direct Claude vs cli-lite-planning-agent) based on complexity
+- Adaptive planning: Low complexity → Direct Claude; Medium/High → cli-lite-planning-agent
 - Two-step confirmation: plan display → multi-dimensional input collection
-- Execution dispatch with complete context handoff to lite-execute
+- Execution execute with complete context handoff to lite-execute
 
 ## Usage
 
@@ -25,10 +25,30 @@ Intelligent lightweight planning command with dynamic workflow adaptation based
 /workflow:lite-plan [FLAGS] <TASK_DESCRIPTION>
 
 # Flags
+-y, --yes                  Skip all confirmations (auto mode)
 -e, --explore              Force code exploration phase (overrides auto-detection)
 
 # Arguments
 <task-description>         Task description or path to .md file (required)
+
+# Examples
+/workflow:lite-plan "实现JWT认证"                    # Interactive mode
+/workflow:lite-plan --yes "实现JWT认证"              # Auto mode (no confirmations)
+/workflow:lite-plan -y -e "优化数据库查询性能"       # Auto mode + force exploration
+```
+
+## Auto Mode Defaults
+
+When `--yes` or `-y` flag is used:
+- **Clarification Questions**: Skipped (no clarification phase)
+- **Plan Confirmation**: Auto-selected "Allow"
+- **Execution Method**: Auto-selected "Auto"
+- **Code Review**: Auto-selected "Skip"
+
+**Flag Parsing**:
+```javascript
+const autoYes = $ARGUMENTS.includes('--yes') || $ARGUMENTS.includes('-y')
+const forceExplore = $ARGUMENTS.includes('--explore') || $ARGUMENTS.includes('-e')
 ```
 
 ## Execution Process
@@ -36,23 +56,24 @@ Intelligent lightweight planning command with dynamic workflow adaptation based
 ```
 Phase 1: Task Analysis & Exploration
    ├─ Parse input (description or .md file)
-   ├─ Claude intelligent complexity assessment (Low/Medium/High)
+   ├─ 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)
+Phase 2: Clarification (optional, multi-round)
    ├─ Aggregate clarification_needs from all exploration angles
    ├─ Deduplicate similar questions
    └─ Decision:
-      ├─ Has clarifications → AskUserQuestion (max 4 questions)
+      ├─ Has clarifications → AskUserQuestion (max 4 questions per round, multiple rounds allowed)
       └─ No clarifications → Skip to Phase 3
 
-Phase 3: Planning
+Phase 3: Planning (NO CODE EXECUTION - planning only)
    └─ Decision (based on Phase 1 complexity):
-      ├─ Low → Direct Claude planning → plan.json
-      └─ Medium/High → cli-lite-planning-agent → plan.json
+      ├─ Low → Load schema: cat ~/.claude/workflows/cli-templates/schemas/plan-json-schema.json → Direct Claude planning (following schema) → plan.json
+      └─ Medium/High → cli-lite-planning-agent → plan.json (agent internally executes quality check)
 
 Phase 4: Confirmation & Selection
    ├─ Display plan summary (tasks, complexity, estimated time)
@@ -61,7 +82,7 @@ Phase 4: Confirmation & Selection
       ├─ Execution: Agent / Codex / Auto
       └─ Review: Gemini / Agent / Skip
 
-Phase 5: Dispatch
+Phase 5: Execute
    ├─ Build executionContext (plan + explorations + clarifications + selections)
    └─ SlashCommand("/workflow:lite-execute --in-memory")
 ```
@@ -70,15 +91,18 @@ Phase 5: Dispatch
 
 ### Phase 1: Intelligent Multi-Angle Exploration
 
-**Session Setup**:
+**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 timestamp = new Date().toISOString().replace(/[:.]/g, '-')
-const shortTimestamp = timestamp.substring(0, 19).replace('T', '-')
-const sessionId = `${taskSlug}-${shortTimestamp}`
+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}`)
+bash(`mkdir -p ${sessionFolder} && test -d ${sessionFolder} && echo "SUCCESS: ${sessionFolder}" || echo "FAILED: ${sessionFolder}"`)
 ```
 
 **Exploration Decision Logic**:
@@ -97,9 +121,11 @@ if (!needsExploration) {
 }
 ```
 
-**Complexity Assessment** (Claude Intelligent Analysis):
+**⚠️ Context Protection**: File reading ≥50k chars → force `needsExploration=true` (delegate to cli-explore-agent)
+
+**Complexity Assessment** (Intelligent Analysis):
 ```javascript
-// Claude analyzes task complexity based on:
+// analyzes task complexity based on:
 // - Scope: How many systems/modules are affected?
 // - Depth: Surface change vs architectural impact?
 // - Risk: Potential for breaking existing functionality?
@@ -134,11 +160,17 @@ function selectAngles(taskDescription, 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...
 `)
@@ -146,11 +178,16 @@ 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
@@ -164,9 +201,11 @@ Execute **${angle}** exploration for task planning context. Analyze codebase fro
 
 ## MANDATORY FIRST STEPS (Execute by Agent)
 **You (cli-explore-agent) MUST execute these steps in order:**
-1. Run: ~/.claude/scripts/get_modules_by_depth.sh (project structure)
+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)
 
@@ -193,11 +232,14 @@ Execute **${angle}** exploration for task planning context. Analyze codebase fro
 **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
+- integration_points: Where to integrate from ${angle} viewpoint (include file:line locations)
 - constraints: ${angle}-specific limitations/conventions
-- clarification_needs: ${angle}-related ambiguities (with options array)
+- clarification_needs: ${angle}-related ambiguities (options array + recommended index)
 - _metadata.exploration_angle: "${angle}"
 
 ## Success Criteria
@@ -208,7 +250,7 @@ Execute **${angle}** exploration for task planning context. Analyze codebase fro
 - [ ] Integration points include file:line locations
 - [ ] Constraints are project-specific to ${angle}
 - [ ] JSON output follows schema exactly
-- [ ] clarification_needs includes options array
+- [ ] clarification_needs includes options + recommended
 
 ## Output
 Write: ${sessionFolder}/exploration-${angle}.json
@@ -231,7 +273,7 @@ const explorationFiles = bash(`find ${sessionFolder} -name "exploration-*.json"
 const explorationManifest = {
   session_id: sessionId,
   task_description: task_description,
-  timestamp: new Date().toISOString(),
+  timestamp: getUtc8ISOString(),
   complexity: complexity,
   exploration_count: explorationCount,
   explorations: explorationFiles.map(file => {
@@ -267,10 +309,12 @@ Angles explored: ${explorationManifest.explorations.map(e => e.angle).join(', ')
 
 ---
 
-### Phase 2: Clarification (Optional)
+### 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
@@ -293,32 +337,45 @@ explorations.forEach(exp => {
   }
 })
 
-// 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
-}
+// 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)
 
-const uniqueClarifications = deduplicateClarifications(allClarifications)
+// Parse --yes flag
+const autoYes = $ARGUMENTS.includes('--yes') || $ARGUMENTS.includes('-y')
 
-if (uniqueClarifications.length > 0) {
-  AskUserQuestion({
-    questions: uniqueClarifications.map(need => ({
-      question: `[${need.source_angle}] ${need.question}\n\nContext: ${need.context}`,
-      header: need.source_angle,
-      multiSelect: false,
-      options: need.options.map(opt => ({
-        label: opt,
-        description: `Use ${opt} approach`
+if (autoYes) {
+  // Auto mode: Skip clarification phase
+  console.log(`[--yes] Skipping ${dedupedClarifications.length} clarification questions`)
+  console.log(`Proceeding to planning with exploration results...`)
+  // Continue to Phase 3
+} else if (dedupedClarifications.length > 0) {
+  // Interactive mode: Multi-round clarification
+  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
+  }
 }
 ```
 
@@ -330,15 +387,58 @@ if (uniqueClarifications.length > 0) {
 
 **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:
-- Generate plan directly, write to `${sessionFolder}/plan.json`
-- No agent invocation
+```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.
@@ -346,6 +446,12 @@ 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}
 
@@ -368,24 +474,24 @@ ${JSON.stringify(clarificationContext) || "None"}
 ${complexity}
 
 ## Requirements
-Generate plan.json with:
-- summary: 2-3 sentence overview
-- approach: High-level implementation strategy (incorporating insights from all exploration angles)
-- tasks: 3-10 structured tasks with:
-  - title, file, action, description
-  - implementation (3-7 steps)
-  - reference (pattern, files, examples)
-  - acceptance (2-4 criteria)
-- estimated_time, recommended_execution, complexity
-- _metadata:
-  - timestamp, source, planning_mode
-  - exploration_angles: ${JSON.stringify(manifest.explorations.map(e => e.angle))}
+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 ALL exploration files for comprehensive context
+1. Read schema file (cat command above)
 2. Execute CLI planning using Gemini (Qwen fallback)
-3. Synthesize findings from multiple exploration angles
-4. Parse output and structure plan
+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
 `
@@ -419,45 +525,69 @@ ${plan.tasks.map((t, i) => `${i+1}. ${t.title} (${t.file})`).join('\n')}
 
 **Step 4.2: Collect Confirmation**
 ```javascript
-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" },
-        { label: "Agent Review", description: "@code-reviewer" },
-        { label: "Skip", description: "No review" }
-      ]
-    }
-  ]
-})
+// Parse --yes flag
+const autoYes = $ARGUMENTS.includes('--yes') || $ARGUMENTS.includes('-y')
+
+let userSelection
+
+if (autoYes) {
+  // Auto mode: Use defaults
+  console.log(`[--yes] Auto-confirming plan:`)
+  console.log(`  - Confirmation: Allow`)
+  console.log(`  - Execution: Auto`)
+  console.log(`  - Review: Skip`)
+
+  userSelection = {
+    confirmation: "Allow",
+    execution_method: "Auto",
+    code_review_tool: "Skip"
+  }
+} else {
+  // Interactive mode: Ask user
+  // Note: Execution "Other" option allows specifying CLI tools from ~/.claude/cli-tools.json
+  userSelection = AskUserQuestion({
+    questions: [
+      {
+        question: `Confirm plan? (${plan.tasks.length} tasks, ${plan.complexity})`,
+        header: "Confirm",
+        multiSelect: false,
+        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: Dispatch to Execution
+### Phase 5: Execute to Execution
+
+**CRITICAL**: lite-plan NEVER executes code directly. ALL execution MUST go through lite-execute.
 
 **Step 5.1: Build executionContext**
 
@@ -480,9 +610,13 @@ executionContext = {
   explorationAngles: manifest.explorations.map(e => e.angle),
   explorationManifest: manifest,
   clarificationContext: clarificationContext || null,
-  executionMethod: userSelection.execution_method,
+  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,
@@ -498,7 +632,7 @@ executionContext = {
 }
 ```
 
-**Step 5.2: Dispatch**
+**Step 5.2: Execute**
 
 ```javascript
 SlashCommand(command="/workflow:lite-execute --in-memory")
@@ -507,7 +641,7 @@ SlashCommand(command="/workflow:lite-execute --in-memory")
 ## Session Folder Structure
 
 ```
-.workflow/.lite-plan/{task-slug}-{timestamp}/
+.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)

.claude/commands/workflow/merge-plans-with-file.md

@@ -0,0 +1,807 @@
+---
+name: merge-plans-with-file
+description: Merge multiple planning/brainstorm/analysis outputs, resolve conflicts, and synthesize unified plan. Designed for multi-team input aggregation and final plan crystallization
+argument-hint: "[-y|--yes] [-r|--rule consensus|priority|hierarchy] \"plan or topic name\""
+allowed-tools: TodoWrite(*), Task(*), AskUserQuestion(*), Read(*), Grep(*), Glob(*), Bash(*), Edit(*), Write(*)
+---
+
+## Auto Mode
+
+When `--yes` or `-y`: Auto-resolve conflicts using specified rule (consensus/priority/hierarchy), minimal user prompts.
+
+# Workflow Merge-Plans-With-File Command (/workflow:merge-plans-with-file)
+
+## Overview
+
+Plan aggregation and conflict resolution workflow. Takes multiple planning artifacts (brainstorm conclusions, analysis recommendations, quick-plans, implementation plans) and synthesizes them into a unified, conflict-resolved execution plan.
+
+**Core workflow**: Load Sources → Parse Plans → Conflict Analysis → Arbitration → Unified Plan
+
+**Key features**:
+- **Multi-Source Support**: Brainstorm, analysis, quick-plan, IMPL_PLAN, task JSONs
+- **Parallel Conflict Detection**: Identify all contradictions across input plans
+- **Conflict Resolution**: Consensus, priority-based, or hierarchical resolution modes
+- **Unified Synthesis**: Single authoritative plan from multiple perspectives
+- **Decision Tracking**: Full audit trail of conflicts and resolutions
+- **Resumable**: Save intermediate states, refine resolutions
+
+## Usage
+
+```bash
+/workflow:merge-plans-with-file [FLAGS] <PLAN_NAME_OR_PATTERN>
+
+# Flags
+-y, --yes              Auto-resolve conflicts using rule, skip confirmations
+-r, --rule <rule>      Conflict resolution rule: consensus (default) | priority | hierarchy
+-o, --output <path>    Output directory (default: .workflow/.merged/{name})
+
+# Arguments
+<plan-name-or-pattern> Plan name or glob pattern to identify input files/sessions
+                       Examples: "auth-module", "*.analysis-*.json", "PLAN-*"
+
+# Examples
+/workflow:merge-plans-with-file "authentication"                      # Auto-detect all auth-related plans
+/workflow:merge-plans-with-file -y -r priority "payment-system"      # Auto-resolve with priority rule
+/workflow:merge-plans-with-file -r hierarchy "feature-complete"      # Use hierarchy rule (requires user ranking)
+```
+
+## Execution Process
+
+```
+Discovery & Loading:
+   ├─ Search for planning artifacts matching pattern
+   ├─ Load all synthesis.json, conclusions.json, IMPL_PLAN.md
+   ├─ Parse each into normalized task/plan structure
+   └─ Validate data completeness
+
+Session Initialization:
+   ├─ Create .workflow/.merged/{sessionId}/
+   ├─ Initialize merge.md with plan summary
+   ├─ Index all source plans
+   └─ Extract planning metadata and constraints
+
+Phase 1: Plan Normalization
+   ├─ Convert all formats to common task representation
+   ├─ Extract tasks, dependencies, effort, risks
+   ├─ Identify plan scope and boundaries
+   ├─ Validate no duplicate tasks
+   └─ Aggregate recommendations from each plan
+
+Phase 2: Conflict Detection (Parallel)
+   ├─ Architecture conflicts: different design approaches
+   ├─ Task conflicts: overlapping responsibilities or different priorities
+   ├─ Effort conflicts: vastly different estimates
+   ├─ Risk assessment conflicts: different risk levels
+   ├─ Scope conflicts: different feature inclusions
+   └─ Generate conflict matrix with severity levels
+
+Phase 3: Consensus Building / Arbitration
+   ├─ For each conflict, analyze source rationale
+   ├─ Apply resolution rule (consensus/priority/hierarchy)
+   ├─ Escalate unresolvable conflicts to user (unless --yes)
+   ├─ Document decision rationale
+   └─ Generate resolutions.json
+
+Phase 4: Plan Synthesis
+   ├─ Merge task lists (remove duplicates, combine insights)
+   ├─ Integrate dependencies from all sources
+   ├─ Consolidate effort and risk estimates
+   ├─ Generate unified execution sequence
+   ├─ Create final unified plan
+   └─ Output ready for execution
+
+Output:
+   ├─ .workflow/.merged/{sessionId}/merge.md (merge process & decisions)
+   ├─ .workflow/.merged/{sessionId}/source-index.json (input sources)
+   ├─ .workflow/.merged/{sessionId}/conflicts.json (conflict matrix)
+   ├─ .workflow/.merged/{sessionId}/resolutions.json (how conflicts were resolved)
+   ├─ .workflow/.merged/{sessionId}/unified-plan.json (final merged plan)
+   └─ .workflow/.merged/{sessionId}/unified-plan.md (execution-ready markdown)
+```
+
+## Implementation
+
+### Phase 1: Plan Discovery & Loading
+
+```javascript
+const getUtc8ISOString = () => new Date(Date.now() + 8 * 60 * 60 * 1000).toISOString()
+
+// Parse arguments
+const planPattern = "$PLAN_NAME_OR_PATTERN"
+const resolutionRule = $ARGUMENTS.match(/--rule\s+(\w+)/)?.[1] || 'consensus'
+const isAutoMode = $ARGUMENTS.includes('--yes') || $ARGUMENTS.includes('-y')
+
+// Generate session ID
+const mergeSlug = planPattern.toLowerCase()
+  .replace(/[*?]/g, '-')
+  .replace(/[^a-z0-9\u4e00-\u9fa5-]+/g, '-')
+  .substring(0, 30)
+const dateStr = getUtc8ISOString().substring(0, 10)
+const sessionId = `MERGE-${mergeSlug}-${dateStr}`
+const sessionFolder = `.workflow/.merged/${sessionId}`
+
+bash(`mkdir -p ${sessionFolder}`)
+
+// Discover all relevant planning artifacts
+const discoveryPaths = [
+  `.workflow/.brainstorm/*/${planPattern}*/synthesis.json`,
+  `.workflow/.analysis/*/${planPattern}*/conclusions.json`,
+  `.workflow/.planning/*/${planPattern}*/synthesis.json`,
+  `.workflow/.plan/${planPattern}*IMPL_PLAN.md`,
+  `.workflow/*/${planPattern}*.json`
+]
+
+const sourcePlans = []
+
+for (const pattern of discoveryPaths) {
+  const matches = glob(pattern)
+  for (const path of matches) {
+    try {
+      const content = Read(path)
+      const plan = parsePlanFile(path, content)
+      if (plan && plan.tasks?.length > 0) {
+        sourcePlans.push({
+          source_path: path,
+          source_type: identifySourceType(path),
+          plan: plan,
+          loaded_at: getUtc8ISOString()
+        })
+      }
+    } catch (e) {
+      console.warn(`Failed to load plan from ${path}: ${e.message}`)
+    }
+  }
+}
+
+if (sourcePlans.length === 0) {
+  console.error(`
+## Error: No Plans Found
+
+Pattern: ${planPattern}
+Searched locations:
+${discoveryPaths.join('\n')}
+
+Available plans in .workflow/:
+`)
+  bash(`find .workflow -name "*.json" -o -name "*PLAN.md" | head -20`)
+  return { status: 'error', message: 'No plans found' }
+}
+
+console.log(`
+## Plans Discovered
+
+Total: ${sourcePlans.length}
+${sourcePlans.map(sp => `- ${sp.source_type}: ${sp.source_path}`).join('\n')}
+`)
+```
+
+---
+
+### Phase 2: Plan Normalization
+
+```javascript
+// Normalize all plans to common format
+const normalizedPlans = sourcePlans.map((sourcePlan, idx) => {
+  const plan = sourcePlan.plan
+  const tasks = plan.tasks || []
+
+  return {
+    index: idx,
+    source: sourcePlan.source_path,
+    source_type: sourcePlan.source_type,
+
+    metadata: {
+      title: plan.title || `Plan ${idx + 1}`,
+      topic: plan.topic || plan.planning_topic || 'unknown',
+      timestamp: plan.completed || plan.timestamp || sourcePlan.loaded_at,
+      source_ideas: plan.top_ideas?.length || 0,
+      complexity: plan.complexity_level || 'unknown'
+    },
+
+    // Normalized tasks
+    tasks: tasks.map(task => ({
+      id: task.id || `T${idx}-${task.title?.substring(0, 20)}`,
+      title: task.title || task.content,
+      description: task.description || '',
+      type: task.type || inferType(task),
+      priority: task.priority || 'normal',
+
+      // Effort estimation
+      effort: {
+        estimated: task.estimated_duration || task.effort_estimate || 'unknown',
+        from_plan: idx
+      },
+
+      // Risk assessment
+      risk: {
+        level: task.risk_level || 'medium',
+        from_plan: idx
+      },
+
+      // Dependencies
+      dependencies: task.dependencies || [],
+
+      // Source tracking
+      source_plan_index: idx,
+      original_id: task.id,
+
+      // Quality tracking
+      success_criteria: task.success_criteria || [],
+      challenges: task.challenges || []
+    }))
+  }
+})
+
+// Save source index
+const sourceIndex = {
+  session_id: sessionId,
+  merge_timestamp: getUtc8ISOString(),
+  pattern: planPattern,
+  total_source_plans: sourcePlans.length,
+
+  sources: normalizedPlans.map(p => ({
+    index: p.index,
+    source_path: p.source,
+    source_type: p.source_type,
+    topic: p.metadata.topic,
+    task_count: p.tasks.length
+  }))
+}
+
+Write(`${sessionFolder}/source-index.json`, JSON.stringify(sourceIndex, null, 2))
+```
+
+---
+
+### Phase 3: Conflict Detection
+
+```javascript
+// Detect conflicts across plans
+const conflictDetector = {
+  // Architecture conflicts
+  architectureConflicts: [],
+
+  // Task conflicts (duplicates, different scope)
+  taskConflicts: [],
+
+  // Effort conflicts
+  effortConflicts: [],
+
+  // Risk assessment conflicts
+  riskConflicts: [],
+
+  // Scope conflicts
+  scopeConflicts: [],
+
+  // Priority conflicts
+  priorityConflicts: []
+}
+
+// Algorithm 1: Detect similar tasks across plans
+const allTasks = normalizedPlans.flatMap(p => p.tasks)
+const taskGroups = groupSimilarTasks(allTasks)
+
+for (const group of taskGroups) {
+  if (group.tasks.length > 1) {
+    // Same task appears in multiple plans
+    const efforts = group.tasks.map(t => t.effort.estimated)
+    const effortVariance = calculateVariance(efforts)
+
+    if (effortVariance > 0.5) {
+      // Significant difference in effort estimates
+      conflictDetector.effortConflicts.push({
+        task_group: group.title,
+        conflicting_tasks: group.tasks.map((t, i) => ({
+          id: t.id,
+          from_plan: t.source_plan_index,
+          effort: t.effort.estimated
+        })),
+        variance: effortVariance,
+        severity: 'high'
+      })
+    }
+
+    // Check for scope differences
+    const scopeDifferences = analyzeScopeDifferences(group.tasks)
+    if (scopeDifferences.length > 0) {
+      conflictDetector.taskConflicts.push({
+        task_group: group.title,
+        scope_differences: scopeDifferences,
+        severity: 'medium'
+      })
+    }
+  }
+}
+
+// Algorithm 2: Architecture conflicts
+const architectures = normalizedPlans.map(p => p.metadata.complexity)
+if (new Set(architectures).size > 1) {
+  conflictDetector.architectureConflicts.push({
+    different_approaches: true,
+    complexity_levels: architectures.map((a, i) => ({
+      plan: i,
+      complexity: a
+    })),
+    severity: 'high'
+  })
+}
+
+// Algorithm 3: Risk assessment conflicts
+const riskLevels = allTasks.map(t => ({ task: t.id, risk: t.risk.level }))
+const taskRisks = {}
+for (const tr of riskLevels) {
+  if (!taskRisks[tr.task]) taskRisks[tr.task] = []
+  taskRisks[tr.task].push(tr.risk)
+}
+
+for (const [task, risks] of Object.entries(taskRisks)) {
+  if (new Set(risks).size > 1) {
+    conflictDetector.riskConflicts.push({
+      task: task,
+      conflicting_risk_levels: risks,
+      severity: 'medium'
+    })
+  }
+}
+
+// Save conflicts
+Write(`${sessionFolder}/conflicts.json`, JSON.stringify(conflictDetector, null, 2))
+```
+
+---
+
+### Phase 4: Conflict Resolution
+
+```javascript
+// Resolve conflicts based on selected rule
+const resolutions = {
+  resolution_rule: resolutionRule,
+  timestamp: getUtc8ISOString(),
+
+  effort_resolutions: [],
+  architecture_resolutions: [],
+  risk_resolutions: [],
+  scope_resolutions: [],
+  priority_resolutions: []
+}
+
+// Resolution Strategy 1: Consensus
+if (resolutionRule === 'consensus') {
+  for (const conflict of conflictDetector.effortConflicts) {
+    // Use median or average
+    const efforts = conflict.conflicting_tasks.map(t => parseEffort(t.effort))
+    const resolved_effort = calculateMedian(efforts)
+
+    resolutions.effort_resolutions.push({
+      conflict: conflict.task_group,
+      original_estimates: efforts,
+      resolved_estimate: resolved_effort,
+      method: 'consensus-median',
+      rationale: 'Used median of all estimates'
+    })
+  }
+}
+
+// Resolution Strategy 2: Priority-Based
+else if (resolutionRule === 'priority') {
+  // Use the plan from highest priority source (first or most recent)
+  for (const conflict of conflictDetector.effortConflicts) {
+    const highestPriority = conflict.conflicting_tasks[0] // First plan has priority
+
+    resolutions.effort_resolutions.push({
+      conflict: conflict.task_group,
+      conflicting_estimates: conflict.conflicting_tasks.map(t => t.effort),
+      resolved_estimate: highestPriority.effort,
+      selected_from_plan: highestPriority.from_plan,
+      method: 'priority-based',
+      rationale: `Selected estimate from plan ${highestPriority.from_plan} (highest priority)`
+    })
+  }
+}
+
+// Resolution Strategy 3: Hierarchy (requires user ranking)
+else if (resolutionRule === 'hierarchy') {
+  if (!isAutoMode) {
+    // Ask user to rank plan importance
+    const planRanking = AskUserQuestion({
+      questions: [{
+        question: "请按重要性排序这些规划(从最重要到最不重要):",
+        header: "Plan Ranking",
+        multiSelect: false,
+        options: normalizedPlans.slice(0, 5).map(p => ({
+          label: `Plan ${p.index}: ${p.metadata.title.substring(0, 40)}`,
+          description: `${p.tasks.length} tasks, complexity: ${p.metadata.complexity}`
+        }))
+      }]
+    })
+
+    // Apply hierarchy
+    const hierarchy = extractHierarchy(planRanking)
+    for (const conflict of conflictDetector.effortConflicts) {
+      const topPriorityTask = conflict.conflicting_tasks
+        .sort((a, b) => hierarchy[a.from_plan] - hierarchy[b.from_plan])[0]
+
+      resolutions.effort_resolutions.push({
+        conflict: conflict.task_group,
+        resolved_estimate: topPriorityTask.effort,
+        selected_from_plan: topPriorityTask.from_plan,
+        method: 'hierarchy-based',
+        rationale: `Selected from highest-ranked plan`
+      })
+    }
+  }
+}
+
+Write(`${sessionFolder}/resolutions.json`, JSON.stringify(resolutions, null, 2))
+```
+
+---
+
+### Phase 5: Plan Synthesis
+
+```javascript
+// Merge all tasks into unified plan
+const unifiedTasks = []
+const processedTaskIds = new Set()
+
+for (const task of allTasks) {
+  const taskKey = generateTaskKey(task)
+
+  if (processedTaskIds.has(taskKey)) {
+    // Task already added, skip
+    continue
+  }
+
+  processedTaskIds.add(taskKey)
+
+  // Apply resolution if this task has conflicts
+  let resolvedTask = { ...task }
+
+  const effortResolution = resolutions.effort_resolutions
+    .find(r => r.conflict === taskKey)
+  if (effortResolution) {
+    resolvedTask.effort.estimated = effortResolution.resolved_estimate
+    resolvedTask.effort.resolution_method = effortResolution.method
+  }
+
+  unifiedTasks.push({
+    id: taskKey,
+    title: task.title,
+    description: task.description,
+    type: task.type,
+    priority: task.priority,
+
+    effort: resolvedTask.effort,
+    risk: task.risk,
+    dependencies: task.dependencies,
+
+    success_criteria: [...new Set([
+      ...task.success_criteria,
+      ...findRelatedTasks(task, allTasks)
+        .flatMap(t => t.success_criteria)
+    ])],
+
+    challenges: [...new Set([
+      ...task.challenges,
+      ...findRelatedTasks(task, allTasks)
+        .flatMap(t => t.challenges)
+    ])],
+
+    source_plans: [
+      ...new Set(allTasks
+        .filter(t => generateTaskKey(t) === taskKey)
+        .map(t => t.source_plan_index))
+    ]
+  })
+}
+
+// Generate execution sequence
+const executionSequence = topologicalSort(unifiedTasks)
+const criticalPath = identifyCriticalPath(unifiedTasks, executionSequence)
+
+// Final unified plan
+const unifiedPlan = {
+  session_id: sessionId,
+  merge_timestamp: getUtc8ISOString(),
+
+  summary: {
+    total_source_plans: normalizedPlans.length,
+    original_tasks_total: allTasks.length,
+    merged_tasks: unifiedTasks.length,
+    conflicts_resolved: Object.values(conflictDetector).flat().length,
+    resolution_rule: resolutionRule
+  },
+
+  merged_metadata: {
+    topics: [...new Set(normalizedPlans.map(p => p.metadata.topic))],
+    average_complexity: calculateAverage(normalizedPlans.map(p => parseComplexity(p.metadata.complexity))),
+    combined_scope: estimateScope(unifiedTasks)
+  },
+
+  tasks: unifiedTasks,
+
+  execution_sequence: executionSequence,
+  critical_path: criticalPath,
+
+  risks: aggregateRisks(unifiedTasks),
+  success_criteria: aggregateSuccessCriteria(unifiedTasks),
+
+  audit_trail: {
+    source_plans: normalizedPlans.length,
+    conflicts_detected: Object.values(conflictDetector).flat().length,
+    conflicts_resolved: Object.values(resolutions).flat().length,
+    resolution_method: resolutionRule
+  }
+}
+
+Write(`${sessionFolder}/unified-plan.json`, JSON.stringify(unifiedPlan, null, 2))
+```
+
+---
+
+### Phase 6: Generate Execution Plan
+
+```markdown
+# Merged Planning Session
+
+**Session ID**: ${sessionId}
+**Pattern**: ${planPattern}
+**Created**: ${getUtc8ISOString()}
+
+---
+
+## Merge Summary
+
+**Source Plans**: ${unifiedPlan.summary.total_source_plans}
+**Original Tasks**: ${unifiedPlan.summary.original_tasks_total}
+**Merged Tasks**: ${unifiedPlan.summary.merged_tasks}
+**Tasks Deduplicated**: ${unifiedPlan.summary.original_tasks_total - unifiedPlan.summary.merged_tasks}
+**Conflicts Resolved**: ${unifiedPlan.summary.conflicts_resolved}
+
+**Resolution Method**: ${unifiedPlan.summary.resolution_rule}
+
+---
+
+## Merged Plan Overview
+
+**Topics**: ${unifiedPlan.merged_metadata.topics.join(', ')}
+**Combined Complexity**: ${unifiedPlan.merged_metadata.average_complexity}
+**Total Scope**: ${unifiedPlan.merged_metadata.combined_scope}
+
+---
+
+## Unified Task List
+
+${unifiedPlan.tasks.map((task, i) => `
+${i+1}. **${task.id}: ${task.title}**
+   - Type: ${task.type}
+   - Effort: ${task.effort.estimated}
+   - Risk: ${task.risk.level}
+   - Source Plans: ${task.source_plans.join(', ')}
+   - ${task.description}
+`).join('\n')}
+
+---
+
+## Execution Sequence
+
+**Critical Path**: ${unifiedPlan.critical_path.join(' → ')}
+
+**Execution Order**:
+${unifiedPlan.execution_sequence.map((id, i) => `${i+1}. ${id}`).join('\n')}
+
+---
+
+## Conflict Resolution Report
+
+**Total Conflicts**: ${unifiedPlan.summary.conflicts_resolved}
+
+**Resolved Conflicts**:
+${Object.entries(resolutions).flatMap(([key, items]) =>
+  items.slice(0, 3).map((item, i) => `
+- ${key.replace('_', ' ')}: ${item.rationale || item.method}
+`)
+).join('\n')}
+
+**Full Report**: See \`conflicts.json\` and \`resolutions.json\`
+
+---
+
+## Risks & Considerations
+
+**Aggregated Risks**:
+${unifiedPlan.risks.slice(0, 5).map(r => `- **${r.title}**: ${r.mitigation}`).join('\n')}
+
+**Combined Success Criteria**:
+${unifiedPlan.success_criteria.slice(0, 5).map(c => `- ${c}`).join('\n')}
+
+---
+
+## Next Steps
+
+### Option 1: Direct Execution
+Execute merged plan with unified-execute-with-file:
+\`\`\`
+/workflow:unified-execute-with-file -p ${sessionFolder}/unified-plan.json
+\`\`\`
+
+### Option 2: Detailed Planning
+Create detailed IMPL_PLAN from merged plan:
+\`\`\`
+/workflow:plan "Based on merged plan from $(echo ${planPattern})"
+\`\`\`
+
+### Option 3: Review Conflicts
+Review detailed conflict analysis:
+\`\`\`
+cat ${sessionFolder}/resolutions.json
+\`\`\`
+
+---
+
+## Artifacts
+
+- **source-index.json** - All input plans and sources
+- **conflicts.json** - Conflict detection results
+- **resolutions.json** - How each conflict was resolved
+- **unified-plan.json** - Merged plan data structure (for execution)
+- **unified-plan.md** - This document (human-readable)
+```
+
+---
+
+## Session Folder Structure
+
+```
+.workflow/.merged/{sessionId}/
+├── merge.md              # Merge process and decisions
+├── source-index.json     # All input plan sources
+├── conflicts.json        # Detected conflicts
+├── resolutions.json      # Conflict resolutions applied
+├── unified-plan.json     # Merged plan (machine-parseable, for execution)
+└── unified-plan.md       # Execution-ready plan (human-readable)
+```
+
+---
+
+## Resolution Rules
+
+### Rule 1: Consensus (default)
+- Use median or average of conflicting estimates
+- Good for: Multiple similar perspectives
+- Tradeoff: May miss important minority viewpoints
+
+### Rule 2: Priority-Based
+- First plan has highest priority, subsequent plans are fallback
+- Good for: Clear ranking of plan sources
+- Tradeoff: Discards valuable alternative perspectives
+
+### Rule 3: Hierarchy
+- User explicitly ranks importance of each plan
+- Good for: Mixed-source plans (engineering + product + leadership)
+- Tradeoff: Requires user input
+
+---
+
+## Input Format Support
+
+| Source Type | Detection | Parsing | Notes |
+|-------------|-----------|---------|-------|
+| **Brainstorm** | `.brainstorm/*/synthesis.json` | Top ideas → tasks | Ideas converted to work items |
+| **Analysis** | `.analysis/*/conclusions.json` | Recommendations → tasks | Recommendations prioritized |
+| **Quick-Plan** | `.planning/*/synthesis.json` | Direct task list | Already normalized |
+| **IMPL_PLAN** | `*IMPL_PLAN.md` | Markdown → tasks | Parsed from markdown structure |
+| **Task JSON** | `.json` with `tasks` key | Direct mapping | Requires standard schema |
+
+---
+
+## Error Handling
+
+| Situation | Action |
+|-----------|--------|
+| No plans found | Suggest search terms, list available plans |
+| Incompatible formats | Skip unsupported format, continue with others |
+| Circular dependencies | Alert user, suggest manual review |
+| Unresolvable conflicts | Require user decision (unless --yes + conflict rule) |
+| Contradictory recommendations | Document both options for user consideration |
+
+---
+
+## Usage Patterns
+
+### Pattern 1: Merge Multiple Brainstorms
+
+```bash
+/workflow:merge-plans-with-file "authentication" -y -r consensus
+# → Finds all brainstorm sessions with "auth"
+# → Merges top ideas into unified task list
+# → Uses consensus method for conflicts
+```
+
+### Pattern 2: Synthesize Team Input
+
+```bash
+/workflow:merge-plans-with-file "payment-integration" -r hierarchy
+# → Loads plans from different team members
+# → Asks for ranking by importance
+# → Applies hierarchy-based conflict resolution
+```
+
+### Pattern 3: Bridge Planning Phases
+
+```bash
+/workflow:merge-plans-with-file "user-auth" -f analysis
+# → Takes analysis conclusions
+# → Merges with existing quick-plans
+# → Produces execution-ready plan
+```
+
+---
+
+## Advanced: Custom Conflict Resolution
+
+For complex conflict scenarios, create custom resolution script:
+
+```
+.workflow/.merged/{sessionId}/
+└── custom-resolutions.js  (optional)
+    - Define custom conflict resolution logic
+    - Applied after automatic resolution
+    - Override specific decisions
+```
+
+---
+
+## Best Practices
+
+1. **Before merging**:
+   - Ensure all source plans have same quality level
+   - Verify plans address same scope/topic
+   - Document any special considerations
+
+2. **During merging**:
+   - Review conflict matrix (conflicts.json)
+   - Understand resolution rationale (resolutions.json)
+   - Challenge assumptions if results seem odd
+
+3. **After merging**:
+   - Validate unified plan makes sense
+   - Review critical path
+   - Ensure no important details lost
+   - Execute or iterate if needed
+
+---
+
+## Integration with Other Workflows
+
+```
+Multiple Brainstorms / Analyses
+   │
+   ├─ brainstorm-with-file (session 1)
+   ├─ brainstorm-with-file (session 2)
+   ├─ analyze-with-file (session 3)
+   │
+   ▼
+merge-plans-with-file  ◄──── This workflow
+   │
+   ▼
+unified-plan.json
+   │
+   ├─ /workflow:unified-execute-with-file (direct execution)
+   ├─ /workflow:plan (detailed planning)
+   └─ /workflow:quick-plan-with-file (refinement)
+```
+
+---
+
+## Comparison: When to Use Which Merge Rule
+
+| Rule | Use When | Pros | Cons |
+|------|----------|------|------|
+| **Consensus** | Similar-quality inputs | Fair, balanced | May miss extremes |
+| **Priority** | Clear hierarchy | Simple, predictable | May bias to first input |
+| **Hierarchy** | Mixed stakeholders | Respects importance | Requires user ranking |
+
+---
+
+**Ready to execute**: Run `/workflow:merge-plans-with-file` to start merging plans!

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

@@ -0,0 +1,572 @@
+---
+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: "[-y|--yes] <task description> [--max-rounds=3] [--tools=gemini,codex] [--mode=parallel|serial]"
+allowed-tools: TodoWrite(*), Task(*), AskUserQuestion(*), Read(*), Bash(*), Write(*), mcp__ace-tool__search_context(*)
+---
+
+## Auto Mode
+
+When `--yes` or `-y`: Auto-approve plan, use recommended solution and execution method (Agent, Skip review).
+
+# 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-verify.md

@@ -0,0 +1,362 @@
+---
+name: plan-verify
+description: Perform READ-ONLY verification analysis between IMPL_PLAN.md, task JSONs, and brainstorming artifacts. Generates structured report with quality gate recommendation. Does NOT modify any files.
+argument-hint: "[optional: --session session-id]"
+allowed-tools: Read(*), Write(*), Glob(*), Bash(*)
+---
+
+## User Input
+
+```text
+$ARGUMENTS
+```
+
+You **MUST** consider the user input before proceeding (if not empty).
+
+## Goal
+
+Generate a comprehensive verification report that identifies inconsistencies, duplications, ambiguities, and underspecified items between action planning artifacts (`IMPL_PLAN.md`, `task.json`) and brainstorming artifacts (`role analysis documents`). This command MUST run only after `/workflow:plan` has successfully produced complete `IMPL_PLAN.md` and task JSON files.
+
+**Output**: A structured Markdown report saved to `.workflow/active/WFS-{session}/.process/PLAN_VERIFICATION.md` containing:
+- Executive summary with quality gate recommendation
+- Detailed findings by severity (CRITICAL/HIGH/MEDIUM/LOW)
+- Requirements coverage analysis
+- Dependency integrity check
+- Synthesis alignment validation
+- Actionable remediation recommendations
+
+## Operating Constraints
+
+**STRICTLY READ-ONLY FOR SOURCE ARTIFACTS**:
+- **MUST NOT** modify `IMPL_PLAN.md`, any `task.json` files, or brainstorming artifacts
+- **MUST NOT** create or delete task files
+- **MUST ONLY** write the verification report to `.process/PLAN_VERIFICATION.md`
+
+**Synthesis Authority**: The `role analysis documents` are **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.
+
+**Quality Gate Authority**: The verification report provides a binding recommendation (BLOCK_EXECUTION / PROCEED_WITH_FIXES / PROCEED_WITH_CAUTION / PROCEED) based on objective severity criteria. User MUST review critical/high issues before proceeding with implementation.
+
+## 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
+process_dir = session_dir/.process
+session_file = session_dir/workflow-session.json
+
+# Create .process directory if not exists (report output location)
+IF NOT EXISTS(process_dir):
+    bash(mkdir -p "{process_dir}")
+
+# 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 - in order of dependency
+SESSION_FILE_EXISTS = EXISTS(session_file)
+IF NOT SESSION_FILE_EXISTS:
+    WARNING: "workflow-session.json not found. User intent alignment verification will be skipped."
+    # Continue execution - this is optional context, not blocking
+
+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** (OPTIONAL - Primary Reference for User Intent):
+- **ONLY IF EXISTS**: Load user intent context
+- Original user prompt/intent (project or description field)
+- User's stated goals and objectives
+- User's scope definition
+- **IF MISSING**: Set user_intent_analysis = "SKIPPED: workflow-session.json not found"
+
+**From role analysis documents** (AUTHORITATIVE SOURCE):
+- 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 (Agent-Driven Multi-Dimensional Analysis)
+
+**Execution Strategy**:
+- Single `cli-explore-agent` invocation
+- Agent executes multiple CLI analyses internally (different dimensions: A-H)
+- Token Budget: 50 findings maximum (aggregate remainder in overflow summary)
+- Priority Allocation: CRITICAL (unlimited) → HIGH (15) → MEDIUM (20) → LOW (15)
+- Early Exit: If CRITICAL findings > 0 in User Intent/Requirements Coverage, skip LOW/MEDIUM checks
+
+**Execution Order** (Agent orchestrates internally):
+
+1. **Tier 1 (CRITICAL Path)**: A, B, C - User intent, coverage, consistency (full analysis)
+2. **Tier 2 (HIGH Priority)**: D, E - Dependencies, synthesis alignment (limit 15 findings)
+3. **Tier 3 (MEDIUM Priority)**: F - Specification quality (limit 20 findings)
+4. **Tier 4 (LOW Priority)**: G, H - Duplication, feasibility (limit 15 findings)
+
+---
+
+#### Phase 4.1: Launch Unified Verification Agent
+
+```javascript
+Task(
+  subagent_type="cli-explore-agent",
+  run_in_background=false,
+  description="Multi-dimensional plan verification",
+  prompt=`
+## Plan Verification Task
+
+### MANDATORY FIRST STEPS
+1. Read: ~/.claude/workflows/cli-templates/schemas/plan-verify-agent-schema.json (dimensions & rules)
+2. Read: ~/.claude/workflows/cli-templates/schemas/verify-json-schema.json (output schema)
+3. Read: ${session_file} (user intent)
+4. Read: ${IMPL_PLAN} (implementation plan)
+5. Glob: ${task_dir}/*.json (task files)
+6. Glob: ${SYNTHESIS_DIR}/*/analysis.md (role analyses)
+
+### Execution Flow
+
+**Load schema → Execute tiered CLI analysis → Aggregate findings → Write JSON**
+
+FOR each tier in [1, 2, 3, 4]:
+  - Load tier config from plan-verify-agent-schema.json
+  - Execute: ccw cli -p "PURPOSE: Verify dimensions {tier.dimensions}
+    TASK: {tier.checks from schema}
+    CONTEXT: @${session_dir}/**/*
+    EXPECTED: Findings JSON with dimension, severity, location, summary, recommendation
+    CONSTRAINTS: Limit {tier.limit} findings
+    " --tool gemini --mode analysis --rule {tier.rule}
+  - Parse findings, check early exit condition
+  - IF tier == 1 AND critical_count > 0: skip tier 3-4
+
+### Output
+Write: ${process_dir}/verification-findings.json (follow verify-json-schema.json)
+Return: Quality gate decision + 2-3 sentence summary
+`
+)
+```
+
+---
+
+#### Phase 4.2: Load and Organize Findings
+
+```javascript
+// Load findings (single parse for all subsequent use)
+const data = JSON.parse(Read(`${process_dir}/verification-findings.json`))
+const { session_id, timestamp, verification_tiers_completed, findings, summary } = data
+const { critical_count, high_count, medium_count, low_count, total_findings, coverage_percentage, recommendation } = summary
+
+// Group by severity and dimension
+const bySeverity = Object.groupBy(findings, f => f.severity)
+const byDimension = Object.groupBy(findings, f => f.dimension)
+
+// Dimension metadata (from schema)
+const DIMS = {
+  A: "User Intent Alignment", B: "Requirements Coverage", C: "Consistency Validation",
+  D: "Dependency Integrity", E: "Synthesis Alignment", F: "Task Specification Quality",
+  G: "Duplication Detection", H: "Feasibility Assessment"
+}
+```
+
+### 5. Generate Report
+
+```javascript
+// Helper: render dimension section
+const renderDimension = (dim) => {
+  const items = byDimension[dim] || []
+  return items.length > 0
+    ? items.map(f => `### ${f.id}: ${f.summary}\n- **Severity**: ${f.severity}\n- **Location**: ${f.location.join(', ')}\n- **Recommendation**: ${f.recommendation}`).join('\n\n')
+    : `> ✅ No ${DIMS[dim]} issues detected.`
+}
+
+// Helper: render severity section
+const renderSeverity = (severity, impact) => {
+  const items = bySeverity[severity] || []
+  return items.length > 0
+    ? items.map(f => `#### ${f.id}: ${f.summary}\n- **Dimension**: ${f.dimension_name}\n- **Location**: ${f.location.join(', ')}\n- **Impact**: ${impact}\n- **Recommendation**: ${f.recommendation}`).join('\n\n')
+    : `> ✅ No ${severity.toLowerCase()}-severity issues detected.`
+}
+
+// Build Markdown report
+const fullReport = `
+# Plan Verification Report
+
+**Session**: WFS-${session_id} | **Generated**: ${timestamp}
+**Tiers Completed**: ${verification_tiers_completed.join(', ')}
+
+---
+
+## Executive Summary
+
+| Metric | Value | Status |
+|--------|-------|--------|
+| Risk Level | ${critical_count > 0 ? 'CRITICAL' : high_count > 0 ? 'HIGH' : medium_count > 0 ? 'MEDIUM' : 'LOW'} | ${critical_count > 0 ? '🔴' : high_count > 0 ? '🟠' : medium_count > 0 ? '🟡' : '🟢'} |
+| Critical/High/Medium/Low | ${critical_count}/${high_count}/${medium_count}/${low_count} | |
+| Coverage | ${coverage_percentage}% | ${coverage_percentage >= 90 ? '🟢' : coverage_percentage >= 75 ? '🟡' : '🔴'} |
+
+**Recommendation**: **${recommendation}**
+
+---
+
+## Findings Summary
+
+| ID | Dimension | Severity | Location | Summary |
+|----|-----------|----------|----------|---------|
+${findings.map(f => `| ${f.id} | ${f.dimension_name} | ${f.severity} | ${f.location.join(', ')} | ${f.summary} |`).join('\n')}
+
+---
+
+## Analysis by Dimension
+
+${['A','B','C','D','E','F','G','H'].map(d => `### ${d}. ${DIMS[d]}\n\n${renderDimension(d)}`).join('\n\n---\n\n')}
+
+---
+
+## Findings by Severity
+
+### CRITICAL (${critical_count})
+${renderSeverity('CRITICAL', 'Blocks execution')}
+
+### HIGH (${high_count})
+${renderSeverity('HIGH', 'Fix before execution recommended')}
+
+### MEDIUM (${medium_count})
+${renderSeverity('MEDIUM', 'Address during/after implementation')}
+
+### LOW (${low_count})
+${renderSeverity('LOW', 'Optional improvement')}
+
+---
+
+## Next Steps
+
+${recommendation === 'BLOCK_EXECUTION' ? '🛑 **BLOCK**: Fix critical issues → Re-verify' :
+  recommendation === 'PROCEED_WITH_FIXES' ? '⚠️ **FIX RECOMMENDED**: Address high issues → Re-verify or Execute' :
+  '✅ **READY**: Proceed to /workflow:execute'}
+
+Re-verify: \`/workflow:plan-verify --session ${session_id}\`
+Execute: \`/workflow:execute --resume-session="${session_id}"\`
+`
+
+// Write report
+Write(`${process_dir}/PLAN_VERIFICATION.md`, fullReport)
+console.log(`✅ Report: ${process_dir}/PLAN_VERIFICATION.md\n📊 ${recommendation} | C:${critical_count} H:${high_count} M:${medium_count} L:${low_count} | Coverage:${coverage_percentage}%`)
+```
+
+### 6. Next Step Selection
+
+```javascript
+const autoYes = $ARGUMENTS.includes('--yes') || $ARGUMENTS.includes('-y')
+const canExecute = recommendation !== 'BLOCK_EXECUTION'
+
+// Auto mode
+if (autoYes) {
+  if (canExecute) {
+    SlashCommand("/workflow:execute --yes --resume-session=\"${session_id}\"")
+  } else {
+    console.log(`[--yes] BLOCK_EXECUTION - Fix ${critical_count} critical issues first.`)
+  }
+  return
+}
+
+// Interactive mode - build options based on quality gate
+const options = canExecute
+  ? [
+      { label: canExecute && recommendation === 'PROCEED_WITH_FIXES' ? "Execute Anyway" : "Execute (Recommended)",
+        description: "Proceed to /workflow:execute" },
+      { label: "Review Report", description: "Review findings before deciding" },
+      { label: "Re-verify", description: "Re-run after manual fixes" }
+    ]
+  : [
+      { label: "Review Report", description: "Review critical issues" },
+      { label: "Re-verify", description: "Re-run after fixing issues" }
+    ]
+
+const selection = AskUserQuestion({
+  questions: [{
+    question: `Quality gate: ${recommendation}. Next step?`,
+    header: "Action",
+    multiSelect: false,
+    options
+  }]
+})
+
+// Handle selection
+if (selection.includes("Execute")) {
+  SlashCommand("/workflow:execute --resume-session=\"${session_id}\"")
+} else if (selection === "Re-verify") {
+  SlashCommand("/workflow:plan-verify --session ${session_id}")
+}
+```

.claude/commands/workflow/plan.md

@@ -1,10 +1,15 @@
 ---
 name: plan
-description: 5-phase planning workflow with action-planning-agent task generation, outputs IMPL_PLAN.md and task JSONs with optional CLI auto-execution
-argument-hint: "[--cli-execute] \"text description\"|file.md"
+description: 5-phase planning workflow with action-planning-agent task generation, outputs IMPL_PLAN.md and task JSONs
+argument-hint: "[-y|--yes] \"text description\"|file.md"
 allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*)
+group: workflow
 ---
 
+## Auto Mode
+
+When `--yes` or `-y`: Auto-continue all phases (skip confirmations), use recommended conflict resolutions.
+
 # Workflow Plan Command (/workflow:plan)
 
 ## Coordinator Role
@@ -23,8 +28,8 @@ This workflow runs **fully autonomously** once triggered. Phase 3 (conflict reso
 5. **Phase 4 executes** → Task generation (task-generate-agent) → Reports final summary
 
 **Task Attachment Model**:
-- SlashCommand invocation **expands workflow** by attaching sub-tasks to current TodoWrite
-- When a sub-command is invoked (e.g., `/workflow:tools:context-gather`), its internal tasks are attached to the orchestrator's TodoWrite
+- SlashCommand execute **expands workflow** by attaching sub-tasks to current TodoWrite
+- When a sub-command is executed (e.g., `/workflow:tools:context-gather`), its internal tasks are attached to the orchestrator's TodoWrite
 - Orchestrator **executes these attached tasks** sequentially
 - After completion, attached tasks are **collapsed** back to high-level phase summary
 - This is **task expansion**, not external delegation
@@ -43,7 +48,7 @@ This workflow runs **fully autonomously** once triggered. Phase 3 (conflict reso
 3. **Parse Every Output**: Extract required data from each command/agent output for next phase
 4. **Auto-Continue via TodoList**: Check TodoList status to execute next pending phase automatically
 5. **Track Progress**: Update TodoWrite dynamically with task attachment/collapse pattern
-6. **Task Attachment Model**: SlashCommand invocation **attaches** sub-tasks to current workflow. Orchestrator **executes** these attached tasks itself, then **collapses** them after completion
+6. **Task Attachment Model**: SlashCommand execute **attaches** sub-tasks to current workflow. Orchestrator **executes** these attached tasks itself, then **collapses** them after completion
 7. **⚠️ CRITICAL: DO NOT STOP**: Continuous multi-phase workflow. After executing all attached tasks, immediately collapse them and execute next phase
 
 ## Execution Process
@@ -61,7 +66,7 @@ Phase 2: Context Gathering
       ├─ Tasks attached: Analyze structure → Identify integration → Generate package
       └─ Output: contextPath + conflict_risk
 
-Phase 3: Conflict Resolution (conditional)
+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
@@ -69,7 +74,7 @@ Phase 3: Conflict Resolution (conditional)
       └─ conflict_risk < medium → Skip to Phase 4
 
 Phase 4: Task Generation
-   └─ /workflow:tools:task-generate-agent --session sessionId [--cli-execute]
+   └─ /workflow:tools:task-generate-agent --session sessionId
       └─ Output: IMPL_PLAN.md, task JSONs, TODO_LIST.md
 
 Return:
@@ -79,7 +84,12 @@ Return:
 ## 5-Phase Execution
 
 ### Phase 1: Session Discovery
-**Command**: `SlashCommand(command="/workflow:session:start --auto \"[structured-task-description]\"")`
+
+**Step 1.1: Execute** - Create or discover workflow session
+
+```javascript
+SlashCommand(command="/workflow:session:start --auto \"[structured-task-description]\"")
+```
 
 **Task Description Structure**:
 ```
@@ -106,12 +116,48 @@ CONTEXT: Existing user database schema, REST API endpoints
 
 **TodoWrite**: Mark phase 1 completed, phase 2 in_progress
 
-**After Phase 1**: Return to user showing Phase 1 results, then auto-continue to Phase 2
+**After Phase 1**: Initialize planning-notes.md with user intent
+
+```javascript
+// Create minimal planning notes document
+const planningNotesPath = `.workflow/active/${sessionId}/planning-notes.md`
+const userGoal = structuredDescription.goal
+const userConstraints = structuredDescription.context || "None specified"
+
+Write(planningNotesPath, `# Planning Notes
+
+**Session**: ${sessionId}
+**Created**: ${new Date().toISOString()}
+
+## User Intent (Phase 1)
+
+- **GOAL**: ${userGoal}
+- **KEY_CONSTRAINTS**: ${userConstraints}
+
+---
+
+## Context Findings (Phase 2)
+(To be filled by context-gather)
+
+## Conflict Decisions (Phase 3)
+(To be filled if conflicts detected)
+
+## Consolidated Constraints (Phase 4 Input)
+1. ${userConstraints}
+`)
+```
+
+Return to user showing Phase 1 results, then auto-continue to Phase 2
 
 ---
 
 ### Phase 2: Context Gathering
-**Command**: `SlashCommand(command="/workflow:tools:context-gather --session [sessionId] \"[structured-task-description]\"")`
+
+**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
 
@@ -124,10 +170,11 @@ CONTEXT: Existing user database schema, REST API endpoints
 **Validation**:
 - Context package path extracted
 - File exists and is valid JSON
+- `prioritized_context` field exists
 
-<!-- TodoWrite: When context-gather invoked, INSERT 3 context-gather tasks, mark first as in_progress -->
+<!-- TodoWrite: When context-gather executed, INSERT 3 context-gather tasks, mark first as in_progress -->
 
-**TodoWrite Update (Phase 2 SlashCommand invoked - tasks attached)**:
+**TodoWrite Update (Phase 2 SlashCommand executed - tasks attached)**:
 ```json
 [
   {"content": "Phase 1: Session Discovery", "status": "completed", "activeForm": "Executing session discovery"},
@@ -139,7 +186,7 @@ CONTEXT: Existing user database schema, REST API endpoints
 ]
 ```
 
-**Note**: SlashCommand invocation **attaches** context-gather's 3 tasks. Orchestrator **executes** these tasks sequentially.
+**Note**: SlashCommand execute **attaches** context-gather's 3 tasks. Orchestrator **executes** these tasks sequentially.
 
 <!-- TodoWrite: After Phase 2 tasks complete, REMOVE Phase 2.1-2.3, restore to orchestrator view -->
 
@@ -154,15 +201,49 @@ CONTEXT: Existing user database schema, REST API endpoints
 
 **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)
+**After Phase 2**: Update planning-notes.md with context findings, then auto-continue
+
+```javascript
+// Read context-package to extract key findings
+const contextPackage = JSON.parse(Read(contextPath))
+const conflictRisk = contextPackage.conflict_detection?.risk_level || 'low'
+const criticalFiles = (contextPackage.exploration_results?.aggregated_insights?.critical_files || [])
+  .slice(0, 5).map(f => f.path)
+const archPatterns = contextPackage.project_context?.architecture_patterns || []
+const constraints = contextPackage.exploration_results?.aggregated_insights?.constraints || []
+
+// Append Phase 2 findings to planning-notes.md
+Edit(planningNotesPath, {
+  old: '## Context Findings (Phase 2)\n(To be filled by context-gather)',
+  new: `## Context Findings (Phase 2)
+
+- **CRITICAL_FILES**: ${criticalFiles.join(', ') || 'None identified'}
+- **ARCHITECTURE**: ${archPatterns.join(', ') || 'Not detected'}
+- **CONFLICT_RISK**: ${conflictRisk}
+- **CONSTRAINTS**: ${constraints.length > 0 ? constraints.join('; ') : 'None'}`
+})
+
+// Append Phase 2 constraints to consolidated list
+Edit(planningNotesPath, {
+  old: '## Consolidated Constraints (Phase 4 Input)',
+  new: `## Consolidated Constraints (Phase 4 Input)
+${constraints.map((c, i) => `${i + 2}. [Context] ${c}`).join('\n')}`
+})
+```
+
+Return to user showing Phase 2 results, then auto-continue to Phase 3/4 (depending on conflict_risk)
 
 ---
 
-### Phase 3: Conflict Resolution (Optional - auto-triggered by conflict risk)
+### Phase 3: Conflict Resolution
 
 **Trigger**: Only execute when context-package.json indicates conflict_risk is "medium" or "high"
 
-**Command**: `SlashCommand(command="/workflow:tools:conflict-resolution --session [sessionId] --context [contextPath]")`
+**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
@@ -171,10 +252,10 @@ CONTEXT: Existing user database schema, REST API endpoints
 
 **Parse Output**:
 - Extract: Execution status (success/skipped/failed)
-- Verify: CONFLICT_RESOLUTION.md file path (if executed)
+- Verify: conflict-resolution.json file path (if executed)
 
 **Validation**:
-- File `.workflow/active/[sessionId]/.process/CONFLICT_RESOLUTION.md` exists (if executed)
+- 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
@@ -182,7 +263,7 @@ CONTEXT: Existing user database schema, REST API endpoints
 
 <!-- TodoWrite: If conflict_risk ≥ medium, INSERT 3 conflict-resolution tasks -->
 
-**TodoWrite Update (Phase 3 SlashCommand invoked - tasks attached, if conflict_risk ≥ medium)**:
+**TodoWrite Update (Phase 3 SlashCommand executed - tasks attached, if conflict_risk ≥ medium)**:
 ```json
 [
   {"content": "Phase 1: Session Discovery", "status": "completed", "activeForm": "Executing session discovery"},
@@ -195,7 +276,7 @@ CONTEXT: Existing user database schema, REST API endpoints
 ]
 ```
 
-**Note**: SlashCommand invocation **attaches** conflict-resolution's 3 tasks. Orchestrator **executes** these tasks sequentially.
+**Note**: SlashCommand execute **attaches** conflict-resolution's 3 tasks. Orchestrator **executes** these tasks sequentially.
 
 <!-- TodoWrite: After Phase 3 tasks complete, REMOVE Phase 3.1-3.3, restore to orchestrator view -->
 
@@ -211,13 +292,56 @@ CONTEXT: Existing user database schema, REST API endpoints
 
 **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
+**After Phase 3**: Update planning-notes.md with conflict decisions (if executed), then auto-continue
+
+```javascript
+// If Phase 3 was executed, update planning-notes.md
+if (conflictRisk >= 'medium') {
+  const conflictResPath = `.workflow/active/${sessionId}/.process/conflict-resolution.json`
+
+  if (fs.existsSync(conflictResPath)) {
+    const conflictRes = JSON.parse(Read(conflictResPath))
+    const resolved = conflictRes.resolved_conflicts || []
+    const modifiedArtifacts = conflictRes.modified_artifacts || []
+    const planningConstraints = conflictRes.planning_constraints || []
+
+    // Update Phase 3 section
+    Edit(planningNotesPath, {
+      old: '## Conflict Decisions (Phase 3)\n(To be filled if conflicts detected)',
+      new: `## Conflict Decisions (Phase 3)
+
+- **RESOLVED**: ${resolved.map(r => `${r.type} → ${r.strategy}`).join('; ') || 'None'}
+- **MODIFIED_ARTIFACTS**: ${modifiedArtifacts.join(', ') || 'None'}
+- **CONSTRAINTS**: ${planningConstraints.join('; ') || 'None'}`
+    })
+
+    // Append Phase 3 constraints to consolidated list
+    if (planningConstraints.length > 0) {
+      const currentNotes = Read(planningNotesPath)
+      const constraintCount = (currentNotes.match(/^\d+\./gm) || []).length
+
+      Edit(planningNotesPath, {
+        old: '## Consolidated Constraints (Phase 4 Input)',
+        new: `## Consolidated Constraints (Phase 4 Input)
+${planningConstraints.map((c, i) => `${constraintCount + i + 1}. [Conflict] ${c}`).join('\n')}`
+      })
+    }
+  }
+}
+```
+
+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 (>110K tokens or approaching context limits):
-  - **Command**: `SlashCommand(command="/compact")`
-  - This optimizes memory before proceeding to Phase 3.5
+- 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
 
@@ -251,28 +375,29 @@ CONTEXT: Existing user database schema, REST API endpoints
 - Task generation translates high-level role analyses into concrete, actionable work items
 - **Intent priority**: Current user prompt > role analysis.md files > guidance-specification.md
 
-**Command**:
-```bash
-# Default (agent mode)
-SlashCommand(command="/workflow:tools:task-generate-agent --session [sessionId]")
+**Step 4.1: Execute** - Generate implementation plan and task JSONs
 
-# With CLI execution
-SlashCommand(command="/workflow:tools:task-generate-agent --session [sessionId] --cli-execute")
+```javascript
+SlashCommand(command="/workflow:tools:task-generate-agent --session [sessionId]")
 ```
 
-**Flag**:
-- `--cli-execute`: Generate tasks with Codex execution commands
+**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
+**Input**:
+- `sessionId` from Phase 1
+- **planning-notes.md**: Consolidated constraints from all phases (Phase 1-3)
+  - Path: `.workflow/active/[sessionId]/planning-notes.md`
+  - Contains: User intent, context findings, conflict decisions, consolidated constraints
+  - **Purpose**: Provides structured, minimal context summary to action-planning-agent
 
 **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 invoked, ATTACH 1 agent task -->
+<!-- TodoWrite: When task-generate-agent executed, ATTACH 1 agent task -->
 
-**TodoWrite Update (Phase 4 SlashCommand invoked - agent task attached)**:
+**TodoWrite Update (Phase 4 SlashCommand executed - agent task attached)**:
 ```json
 [
   {"content": "Phase 1: Session Discovery", "status": "completed", "activeForm": "Executing session discovery"},
@@ -296,27 +421,62 @@ SlashCommand(command="/workflow:tools:task-generate-agent --session [sessionId]
 
 **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
+**Step 4.2: User Decision** - Choose next action
 
-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)
+After Phase 4 completes, present user with action choices:
 
-Quality Gate: Consider running /workflow:action-plan-verify to catch issues early
+```javascript
+console.log(`
+✅ Planning complete for session: ${sessionId}
+📊 Tasks generated: ${taskCount}
+📋 Plan: .workflow/active/${sessionId}/IMPL_PLAN.md
+`);
+
+// Ask user for next action
+const userChoice = AskUserQuestion({
+  questions: [{
+    question: "Planning complete. What would you like to do next?",
+    header: "Next Action",
+    multiSelect: false,
+    options: [
+      {
+        label: "Verify Plan Quality (Recommended)",
+        description: "Run quality verification to catch issues before execution. Checks plan structure, task dependencies, and completeness."
+      },
+      {
+        label: "Start Execution",
+        description: "Begin implementing tasks immediately. Use this if you've already reviewed the plan or want to start quickly."
+      },
+      {
+        label: "Review Status Only",
+        description: "View task breakdown and session status without taking further action. You can decide what to do next manually."
+      }
+    ]
+  }]
+});
+
+// Execute based on user choice
+if (userChoice.answers["Next Action"] === "Verify Plan Quality (Recommended)") {
+  console.log("\n🔍 Starting plan verification...\n");
+  SlashCommand(command="/workflow:plan-verify --session " + sessionId);
+} else if (userChoice.answers["Next Action"] === "Start Execution") {
+  console.log("\n🚀 Starting task execution...\n");
+  SlashCommand(command="/workflow:execute --session " + sessionId);
+} else if (userChoice.answers["Next Action"] === "Review Status Only") {
+  console.log("\n📊 Displaying session status...\n");
+  SlashCommand(command="/workflow:status --session " + sessionId);
+}
 ```
 
+**Return to User**: Based on user's choice, execute the corresponding workflow command.
+
 ## TodoWrite Pattern
 
 **Core Concept**: Dynamic task attachment and collapse for real-time visibility into workflow execution.
 
 ### Key Principles
 
-1. **Task Attachment** (when SlashCommand invoked):
+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")
@@ -335,7 +495,7 @@ Quality Gate: Consider running /workflow:action-plan-verify to catch issues earl
    - No user intervention required between phases
    - TodoWrite dynamically reflects current execution state
 
-**Lifecycle Summary**: Initial pending tasks → Phase invoked (tasks ATTACHED) → Sub-tasks executed sequentially → Phase completed (tasks COLLAPSED to summary for Phase 2/3, or marked completed for Phase 4) → Next phase begins → Repeat until all phases complete.
+**Lifecycle Summary**: Initial pending tasks → Phase executed (tasks ATTACHED) → Sub-tasks executed sequentially → Phase completed (tasks COLLAPSED to summary for Phase 2/3, or marked completed for Phase 4) → Next phase begins → Repeat until all phases complete.
 
 
 
@@ -385,26 +545,21 @@ User Input (task description)
     ↓
 Phase 1: session:start --auto "structured-description"
     ↓ Output: sessionId
-    ↓ Session Memory: Previous tasks, context, artifacts
+    ↓ Write: planning-notes.md (User Intent section)
     ↓
 Phase 2: context-gather --session sessionId "structured-description"
-    ↓ Input: sessionId + session memory + structured description
-    ↓ Output: contextPath (context-package.json) + conflict_risk
+    ↓ Input: sessionId + structured description
+    ↓ Output: contextPath (context-package.json with prioritized_context) + conflict_risk
+    ↓ Update: planning-notes.md (Context Findings + Consolidated Constraints)
     ↓
 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)
+    ↓ Output: Modified brainstorm artifacts
+    ↓ Update: planning-notes.md (Conflict Decisions + Consolidated Constraints)
     ↓ Skip if conflict_risk is none/low → proceed directly to Phase 4
     ↓
-Phase 4: task-generate-agent --session sessionId [--cli-execute]
-    ↓ Input: sessionId + resolved brainstorm artifacts + session memory
+Phase 4: task-generate-agent --session sessionId
+    ↓ Input: sessionId + planning-notes.md + context-package.json + brainstorm artifacts
     ↓ Output: IMPL_PLAN.md, task JSONs, TODO_LIST.md
     ↓
 Return summary to user
@@ -427,7 +582,7 @@ User triggers: /workflow:plan "Build authentication system"
 Phase 1: Session Discovery
   → sessionId extracted
   ↓
-Phase 2: Context Gathering (SlashCommand invoked)
+Phase 2: Context Gathering (SlashCommand executed)
   → ATTACH 3 sub-tasks: ← ATTACHED
     - → Analyze codebase structure
     - → Identify integration points
@@ -438,7 +593,7 @@ Phase 2: Context Gathering (SlashCommand invoked)
   ↓
 Conditional Branch: Check conflict_risk
   ├─ IF conflict_risk ≥ medium:
-  │   Phase 3: Conflict Resolution (SlashCommand invoked)
+  │   Phase 3: Conflict Resolution (SlashCommand executed)
   │     → ATTACH 3 sub-tasks: ← ATTACHED
   │       - → Detect conflicts with CLI analysis
   │       - → Present conflicts to user
@@ -448,7 +603,7 @@ Conditional Branch: Check conflict_risk
   │
   └─ ELSE: Skip Phase 3, proceed to Phase 4
   ↓
-Phase 4: Task Generation (SlashCommand invoked)
+Phase 4: Task Generation (SlashCommand executed)
   → Single agent task (no sub-tasks)
   → Agent autonomously completes internally:
     (discovery → planning → output)
@@ -458,7 +613,7 @@ Return summary to user
 ```
 
 **Key Points**:
-- **← ATTACHED**: Tasks attached to TodoWrite when SlashCommand invoked
+- **← 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)
@@ -482,11 +637,9 @@ Return summary to user
 - 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.md created
+- 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**:
-  - Base command: `/workflow:tools:task-generate-agent --session [sessionId]`
-  - Add `--cli-execute` if flag present
+- **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)
@@ -533,6 +686,6 @@ CONSTRAINTS: [Limitations or boundaries]
 - `/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: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/quick-plan-with-file.md

@@ -0,0 +1,808 @@
+---
+name: quick-plan-with-file
+description: Multi-agent rapid planning with minimal documentation, conflict resolution, and actionable synthesis. Designed as a lightweight planning supplement between brainstorm and full implementation planning
+argument-hint: "[-y|--yes] [-c|--continue] [-f|--from <type>] \"planning topic or task description\""
+allowed-tools: TodoWrite(*), Task(*), AskUserQuestion(*), Read(*), Grep(*), Glob(*), Bash(*), Edit(*), Write(*)
+---
+
+## Auto Mode
+
+When `--yes` or `-y`: Auto-confirm planning decisions, use aggressive parallelization, minimal user interaction.
+
+# Workflow Quick-Plan-With-File Command (/workflow:quick-plan-with-file)
+
+## Overview
+
+Multi-agent rapid planning workflow with **minimal documentation overhead**. Coordinates parallel agent analysis, synthesizes conflicting perspectives into actionable decisions, and generates a lightweight implementation-ready plan.
+
+**Core workflow**: Parse Input → Parallel Analysis → Conflict Resolution → Plan Synthesis → Output
+
+**Key features**:
+- **Plan Format Agnostic**: Consumes brainstorm conclusions, analysis recommendations, or raw task descriptions
+- **Minimal Docs**: Single `plan.md` (no lengthy brainstorm.md or discussion.md)
+- **Parallel Multi-Agent**: 3-4 concurrent agent perspectives (architecture, implementation, validation, risk)
+- **Conflict Resolution**: Automatic conflict detection and resolution via synthesis agent
+- **Actionable Output**: Direct task breakdown ready for execution
+- **Session Resumable**: Continue if interrupted, checkpoint at each phase
+
+## Usage
+
+```bash
+/workflow:quick-plan-with-file [FLAGS] <PLANNING_TOPIC>
+
+# Flags
+-y, --yes              Auto-confirm decisions, use defaults
+-c, --continue         Continue existing session (auto-detected)
+-f, --from <type>      Input source type: brainstorm|analysis|task|raw
+
+# Arguments
+<planning-topic>       Planning topic, task, or reference to planning artifact
+
+# Examples
+/workflow:quick-plan-with-file "实现分布式缓存层，支持Redis和内存后端"
+/workflow:quick-plan-with-file --continue "缓存层规划"                           # Continue
+/workflow:quick-plan-with-file -y -f analysis "从分析结论生成实施规划"          # Auto mode
+/workflow:quick-plan-with-file --from brainstorm BS-rate-limiting-2025-01-28    # From artifact
+```
+
+## Execution Process
+
+```
+Input Validation & Loading:
+   ├─ Parse input (topic | artifact reference)
+   ├─ Load artifact if referenced (synthesis.json | conclusions.json | etc.)
+   ├─ Extract key constraints and requirements
+   └─ Initialize session folder and plan.md
+
+Session Initialization:
+   ├─ Create .workflow/.planning/{sessionId}/
+   ├─ Initialize plan.md with input summary
+   ├─ Parse existing output (if --from artifact)
+   └─ Define planning dimensions & focus areas
+
+Phase 1: Parallel Multi-Agent Analysis (concurrent)
+   ├─ Agent 1 (Architecture): High-level design & decomposition
+   ├─ Agent 2 (Implementation): Technical approach & feasibility
+   ├─ Agent 3 (Validation): Risk analysis & edge cases
+   ├─ Agent 4 (Decision): Recommendations & tradeoffs
+   └─ Aggregate findings into perspectives.json
+
+Phase 2: Conflict Detection & Resolution
+   ├─ Analyze agent perspectives for contradictions
+   ├─ Identify critical decision points
+   ├─ Generate synthesis via arbitration agent
+   ├─ Document conflicts and resolutions
+   └─ Update plan.md with decisive recommendations
+
+Phase 3: Plan Synthesis
+   ├─ Consolidate all insights
+   ├─ Generate actionable task breakdown
+   ├─ Create execution strategy
+   ├─ Document assumptions & risks
+   └─ Generate synthesis.md with ready-to-execute tasks
+
+Output:
+   ├─ .workflow/.planning/{sessionId}/plan.md (minimal, actionable)
+   ├─ .workflow/.planning/{sessionId}/perspectives.json (agent findings)
+   ├─ .workflow/.planning/{sessionId}/conflicts.json (decision points)
+   ├─ .workflow/.planning/{sessionId}/synthesis.md (task breakdown)
+   └─ Optional: Feed to /workflow:unified-execute-with-file
+```
+
+## Implementation
+
+### Session Setup & Input Loading
+
+```javascript
+const getUtc8ISOString = () => new Date(Date.now() + 8 * 60 * 60 * 1000).toISOString()
+
+// Parse arguments
+const planningTopic = "$PLANNING_TOPIC"
+const inputType = $ARGUMENTS.match(/--from\s+(\w+)/)?.[1] || 'raw'
+const isAutoMode = $ARGUMENTS.includes('--yes') || $ARGUMENTS.includes('-y')
+const isContinue = $ARGUMENTS.includes('--continue') || $ARGUMENTS.includes('-c')
+
+// Auto-detect artifact if referenced
+let artifact = null
+let artifactContent = null
+
+if (inputType === 'brainstorm' || planningTopic.startsWith('BS-')) {
+  const sessionId = planningTopic
+  const synthesisPath = `.workflow/.brainstorm/${sessionId}/synthesis.json`
+  if (fs.existsSync(synthesisPath)) {
+    artifact = { type: 'brainstorm', path: synthesisPath }
+    artifactContent = JSON.parse(Read(synthesisPath))
+  }
+} else if (inputType === 'analysis' || planningTopic.startsWith('ANL-')) {
+  const sessionId = planningTopic
+  const conclusionsPath = `.workflow/.analysis/${sessionId}/conclusions.json`
+  if (fs.existsSync(conclusionsPath)) {
+    artifact = { type: 'analysis', path: conclusionsPath }
+    artifactContent = JSON.parse(Read(conclusionsPath))
+  }
+}
+
+// Generate session ID
+const planSlug = planningTopic.toLowerCase()
+  .replace(/[^a-z0-9\u4e00-\u9fa5]+/g, '-')
+  .substring(0, 30)
+const dateStr = getUtc8ISOString().substring(0, 10)
+const sessionId = `PLAN-${planSlug}-${dateStr}`
+const sessionFolder = `.workflow/.planning/${sessionId}`
+
+// Session mode detection
+const sessionExists = fs.existsSync(sessionFolder)
+const hasPlan = sessionExists && fs.existsSync(`${sessionFolder}/plan.md`)
+const mode = (hasPlan || isContinue) ? 'continue' : 'new'
+
+if (!sessionExists) {
+  bash(`mkdir -p ${sessionFolder}`)
+}
+```
+
+---
+
+### Phase 1: Initialize plan.md (Minimal)
+
+```markdown
+# Quick Planning Session
+
+**Session ID**: ${sessionId}
+**Topic**: ${planningTopic}
+**Started**: ${getUtc8ISOString()}
+**Mode**: ${mode}
+
+---
+
+## Input Context
+
+${artifact ? `
+**Source**: ${artifact.type} artifact
+**Path**: ${artifact.path}
+
+**Artifact Summary**:
+${artifact.type === 'brainstorm' ? `
+- Topic: ${artifactContent.topic}
+- Top Ideas: ${artifactContent.top_ideas?.length || 0}
+- Key Insights: ${artifactContent.key_insights?.slice(0, 2).join(', ') || 'N/A'}
+` : artifact.type === 'analysis' ? `
+- Topic: ${artifactContent.topic}
+- Key Conclusions: ${artifactContent.key_conclusions?.length || 0}
+- Recommendations: ${artifactContent.recommendations?.length || 0}
+` : ''}
+` : `
+**User Input**: ${planningTopic}
+`}
+
+---
+
+## Planning Dimensions
+
+*To be populated after agent analysis*
+
+---
+
+## Key Decisions
+
+*Conflict resolution and recommendations - to be populated*
+
+---
+
+## Implementation Plan
+
+*Task breakdown - to be populated after synthesis*
+
+---
+
+## Progress
+
+- [ ] Multi-agent analysis
+- [ ] Conflict detection
+- [ ] Plan synthesis
+- [ ] Ready for execution
+```
+
+---
+
+### Phase 2: Parallel Multi-Agent Analysis
+
+```javascript
+const analysisPrompt = artifact
+  ? `Convert ${artifact.type} artifact to planning requirements and execute parallel analysis`
+  : `Create planning breakdown for: ${planningTopic}`
+
+// Prepare context for agents
+const agentContext = {
+  topic: planningTopic,
+  artifact: artifact ? {
+    type: artifact.type,
+    summary: extractArtifactSummary(artifactContent)
+  } : null,
+  planning_focus: determineFocusAreas(planningTopic),
+  constraints: extractConstraints(planningTopic, artifactContent)
+}
+
+// Agent 1: Architecture & Design
+const archPromise = Bash({
+  command: `ccw cli -p "
+PURPOSE: Architecture & high-level design planning for '${planningTopic}'
+Success: Clear component decomposition, interface design, and data flow
+
+TASK:
+• Decompose problem into major components/modules
+• Identify architectural patterns and integration points
+• Design interfaces and data models
+• Assess scalability and maintainability implications
+• Propose architectural approach with rationale
+
+MODE: analysis
+
+CONTEXT: @**/*
+${artifact ? `| Source artifact: ${artifact.type}` : ''}
+
+EXPECTED:
+- Component decomposition (box diagram in text)
+- Module interfaces and responsibilities
+- Data flow between components
+- Architectural patterns applied
+- Scalability assessment (1-5 rating)
+- Risks from architectural perspective
+
+CONSTRAINTS: Focus on long-term maintainability
+" --tool gemini --mode analysis`,
+  run_in_background: true
+})
+
+// Agent 2: Implementation & Feasibility
+const implPromise = Bash({
+  command: `ccw cli -p "
+PURPOSE: Implementation approach & technical feasibility for '${planningTopic}'
+Success: Concrete implementation strategy with realistic resource estimates
+
+TASK:
+• Evaluate technical feasibility of approach
+• Identify required technologies and dependencies
+• Estimate effort: high/medium/low + rationale
+• Suggest implementation phases and milestones
+• Highlight technical blockers or challenges
+
+MODE: analysis
+
+CONTEXT: @**/*
+${artifact ? `| Source artifact: ${artifact.type}` : ''}
+
+EXPECTED:
+- Technology stack recommendation
+- Implementation complexity: high|medium|low with justification
+- Estimated effort breakdown (analysis/design/coding/testing/deployment)
+- Key technical decisions with tradeoffs
+- Potential blockers and mitigations
+- Suggested implementation phases
+- Reusable components or libraries
+
+CONSTRAINTS: Realistic with current tech stack
+" --tool codex --mode analysis`,
+  run_in_background: true
+})
+
+// Agent 3: Risk & Validation
+const riskPromise = Bash({
+  command: `ccw cli -p "
+PURPOSE: Risk analysis and validation strategy for '${planningTopic}'
+Success: Comprehensive risk matrix with testing strategy
+
+TASK:
+• Identify technical risks and failure scenarios
+• Assess business/timeline risks
+• Define validation/testing strategy
+• Suggest monitoring and observability requirements
+• Rate overall risk level (low/medium/high)
+
+MODE: analysis
+
+CONTEXT: @**/*
+${artifact ? `| Source artifact: ${artifact.type}` : ''}
+
+EXPECTED:
+- Risk matrix (likelihood × impact, 1-5 each)
+- Top 3 technical risks with mitigations
+- Top 3 timeline/resource risks with mitigations
+- Testing strategy (unit/integration/e2e/performance)
+- Deployment strategy and rollback plan
+- Monitoring/observability requirements
+- Overall risk rating with confidence (low/medium/high)
+
+CONSTRAINTS: Be realistic, not pessimistic
+" --tool claude --mode analysis`,
+  run_in_background: true
+})
+
+// Agent 4: Decisions & Recommendations
+const decisionPromise = Bash({
+  command: `ccw cli -p "
+PURPOSE: Strategic decisions and execution recommendations for '${planningTopic}'
+Success: Clear recommended approach with tradeoff analysis
+
+TASK:
+• Synthesize all considerations into recommendations
+• Clearly identify critical decision points
+• Outline key tradeoffs (speed vs quality, scope vs timeline, etc.)
+• Propose go/no-go decision criteria
+• Suggest execution strategy and sequencing
+
+MODE: analysis
+
+CONTEXT: @**/*
+${artifact ? `| Source artifact: ${artifact.type}` : ''}
+
+EXPECTED:
+- Primary recommendation with strong rationale
+- Alternative approaches with pros/cons
+- 2-3 critical decision points with recommended choices
+- Key tradeoffs and what we're optimizing for
+- Success metrics and go/no-go criteria
+- Suggested execution sequencing
+- Resource requirements and dependencies
+
+CONSTRAINTS: Focus on actionable decisions, not analysis
+" --tool gemini --mode analysis`,
+  run_in_background: true
+})
+
+// Wait for all parallel analyses
+const [archResult, implResult, riskResult, decisionResult] = await Promise.all([
+  archPromise, implPromise, riskPromise, decisionPromise
+])
+```
+
+---
+
+### Phase 3: Aggregate Perspectives
+
+```javascript
+// Parse and structure agent findings
+const perspectives = {
+  session_id: sessionId,
+  timestamp: getUtc8ISOString(),
+  topic: planningTopic,
+  source_artifact: artifact?.type || 'raw',
+
+  architecture: {
+    source: 'gemini (design)',
+    components: extractComponents(archResult),
+    interfaces: extractInterfaces(archResult),
+    patterns: extractPatterns(archResult),
+    scalability_rating: extractRating(archResult, 'scalability'),
+    risks_from_design: extractRisks(archResult)
+  },
+
+  implementation: {
+    source: 'codex (pragmatic)',
+    technology_stack: extractStack(implResult),
+    complexity: extractComplexity(implResult),
+    effort_breakdown: extractEffort(implResult),
+    blockers: extractBlockers(implResult),
+    phases: extractPhases(implResult)
+  },
+
+  validation: {
+    source: 'claude (systematic)',
+    risk_matrix: extractRiskMatrix(riskResult),
+    top_risks: extractTopRisks(riskResult),
+    testing_strategy: extractTestingStrategy(riskResult),
+    deployment_strategy: extractDeploymentStrategy(riskResult),
+    monitoring_requirements: extractMonitoring(riskResult),
+    overall_risk_rating: extractRiskRating(riskResult)
+  },
+
+  recommendation: {
+    source: 'gemini (synthesis)',
+    primary_approach: extractPrimaryApproach(decisionResult),
+    alternatives: extractAlternatives(decisionResult),
+    critical_decisions: extractDecisions(decisionResult),
+    tradeoffs: extractTradeoffs(decisionResult),
+    success_criteria: extractCriteria(decisionResult),
+    execution_sequence: extractSequence(decisionResult)
+  },
+
+  analysis_timestamp: getUtc8ISOString()
+}
+
+Write(`${sessionFolder}/perspectives.json`, JSON.stringify(perspectives, null, 2))
+```
+
+---
+
+### Phase 4: Conflict Detection & Resolution
+
+```javascript
+// Analyze for conflicts and contradictions
+const conflicts = detectConflicts({
+  arch_vs_impl: compareArchitectureAndImplementation(perspectives),
+  design_vs_risk: compareDesignAndRisk(perspectives),
+  effort_vs_scope: compareEffortAndScope(perspectives),
+  timeline_implications: extractTimingConflicts(perspectives)
+})
+
+// If conflicts exist, invoke arbitration agent
+if (conflicts.critical.length > 0) {
+  const arbitrationResult = await Bash({
+    command: `ccw cli -p "
+PURPOSE: Resolve planning conflicts and generate unified recommendation
+Input: ${JSON.stringify(conflicts, null, 2)}
+
+TASK:
+• Review all conflicts presented
+• Recommend resolution for each critical conflict
+• Explain tradeoff choices
+• Identify what we're optimizing for (speed/quality/risk/resource)
+• Generate unified execution strategy
+
+MODE: analysis
+
+EXPECTED:
+- For each conflict: recommended resolution + rationale
+- Unified optimization criteria (what matters most?)
+- Final recommendation with confidence level
+- Any unresolved tensions that need user input
+
+CONSTRAINTS: Be decisive, not fence-sitting
+" --tool gemini --mode analysis`,
+    run_in_background: false
+  })
+
+  const conflictResolution = {
+    detected_conflicts: conflicts,
+    arbitration_result: arbitrationResult,
+    timestamp: getUtc8ISOString()
+  }
+
+  Write(`${sessionFolder}/conflicts.json`, JSON.stringify(conflictResolution, null, 2))
+}
+```
+
+---
+
+### Phase 5: Plan Synthesis & Task Breakdown
+
+```javascript
+const synthesisPrompt = `
+Given the planning context:
+- Topic: ${planningTopic}
+- Architecture: ${perspectives.architecture.components.map(c => c.name).join(', ')}
+- Implementation Complexity: ${perspectives.implementation.complexity}
+- Timeline Risk: ${perspectives.validation.overall_risk_rating}
+- Primary Recommendation: ${perspectives.recommendation.primary_approach.summary}
+
+Generate a minimal but complete implementation plan with:
+1. Task breakdown (5-8 major tasks)
+2. Dependencies between tasks
+3. For each task: what needs to be done, why, and key considerations
+4. Success criteria for the entire effort
+5. Known risks and mitigation strategies
+
+Output as structured task list ready for execution.
+`
+
+const synthesisResult = await Bash({
+  command: `ccw cli -p "${synthesisPrompt}" --tool gemini --mode analysis`,
+  run_in_background: false
+})
+
+// Parse synthesis and generate task breakdown
+const tasks = parseTaskBreakdown(synthesisResult)
+
+const synthesis = {
+  session_id: sessionId,
+  planning_topic: planningTopic,
+  completed: getUtc8ISOString(),
+
+  // Summary
+  executive_summary: perspectives.recommendation.primary_approach.summary,
+  optimization_focus: extractOptimizationFocus(perspectives),
+
+  // Architecture
+  architecture_approach: perspectives.architecture.patterns[0] || 'TBD',
+  key_components: perspectives.architecture.components.slice(0, 5),
+
+  // Implementation
+  technology_stack: perspectives.implementation.technology_stack,
+  complexity_level: perspectives.implementation.complexity,
+  estimated_effort: perspectives.implementation.effort_breakdown,
+
+  // Risks & Validation
+  top_risks: perspectives.validation.top_risks.slice(0, 3),
+  testing_approach: perspectives.validation.testing_strategy,
+
+  // Execution
+  phases: perspectives.implementation.phases,
+  critical_path_tasks: extractCriticalPath(tasks),
+  total_tasks: tasks.length,
+
+  // Task breakdown (ready for unified-execute-with-file)
+  tasks: tasks.map(task => ({
+    id: task.id,
+    title: task.title,
+    description: task.description,
+    type: task.type,
+    dependencies: task.dependencies,
+    effort_estimate: task.effort,
+    success_criteria: task.criteria
+  }))
+}
+
+Write(`${sessionFolder}/synthesis.md`, formatSynthesisMarkdown(synthesis))
+Write(`${sessionFolder}/synthesis.json`, JSON.stringify(synthesis, null, 2))
+```
+
+---
+
+### Phase 6: Update plan.md with Results
+
+```markdown
+# Quick Planning Session
+
+**Session ID**: ${sessionId}
+**Topic**: ${planningTopic}
+**Started**: ${startTime}
+**Completed**: ${completionTime}
+
+---
+
+## Executive Summary
+
+${synthesis.executive_summary}
+
+**Optimization Focus**: ${synthesis.optimization_focus}
+**Complexity**: ${synthesis.complexity_level}
+**Estimated Effort**: ${formatEffort(synthesis.estimated_effort)}
+
+---
+
+## Architecture
+
+**Primary Pattern**: ${synthesis.architecture_approach}
+
+**Key Components**:
+${synthesis.key_components.map((c, i) => `${i+1}. ${c.name}: ${c.responsibility}`).join('\n')}
+
+---
+
+## Implementation Strategy
+
+**Technology Stack**:
+${synthesis.technology_stack.map(t => `- ${t}`).join('\n')}
+
+**Phases**:
+${synthesis.phases.map((p, i) => `${i+1}. ${p.name} (${p.effort})`).join('\n')}
+
+---
+
+## Risk Assessment
+
+**Overall Risk Level**: ${synthesis.top_risks[0].risk_level}
+
+**Top 3 Risks**:
+${synthesis.top_risks.map((r, i) => `
+${i+1}. **${r.title}** (Impact: ${r.impact})
+   - Mitigation: ${r.mitigation}
+`).join('\n')}
+
+**Testing Approach**: ${synthesis.testing_approach}
+
+---
+
+## Execution Plan
+
+**Total Tasks**: ${synthesis.total_tasks}
+**Critical Path**: ${synthesis.critical_path_tasks.map(t => t.id).join(' → ')}
+
+### Task Breakdown
+
+${synthesis.tasks.map((task, i) => `
+${i+1}. **${task.id}: ${task.title}** (Effort: ${task.effort_estimate})
+   - ${task.description}
+   - Depends on: ${task.dependencies.join(', ') || 'none'}
+   - Success: ${task.success_criteria}
+`).join('\n')}
+
+---
+
+## Next Steps
+
+**Recommended**: Execute with \`/workflow:unified-execute-with-file\` using:
+\`\`\`
+/workflow:unified-execute-with-file -p ${sessionFolder}/synthesis.json
+\`\`\`
+
+---
+
+## Artifacts
+
+- **Perspectives**: ${sessionFolder}/perspectives.json (all agent findings)
+- **Conflicts**: ${sessionFolder}/conflicts.json (decision points and resolutions)
+- **Synthesis**: ${sessionFolder}/synthesis.json (task breakdown for execution)
+```
+
+---
+
+## Session Folder Structure
+
+```
+.workflow/.planning/{sessionId}/
+├── plan.md              # Minimal, actionable planning doc
+├── perspectives.json    # Multi-agent findings (architecture, impl, risk, decision)
+├── conflicts.json       # Detected conflicts and resolutions (if any)
+├── synthesis.json       # Task breakdown ready for execution
+└── synthesis.md         # Human-readable execution plan
+```
+
+---
+
+## Multi-Agent Roles
+
+| Agent | Focus | Input | Output |
+|-------|-------|-------|--------|
+| **Gemini (Design)** | Architecture & design patterns | Topic + constraints | Components, interfaces, patterns, scalability |
+| **Codex (Pragmatic)** | Implementation reality | Topic + architecture | Tech stack, effort, phases, blockers |
+| **Claude (Validation)** | Risk & testing | Architecture + impl | Risk matrix, test strategy, monitoring |
+| **Gemini (Decision)** | Synthesis & strategy | All findings | Recommendations, tradeoffs, execution plan |
+
+---
+
+## Conflict Resolution Strategy
+
+**Auto-Resolution for conflicts**:
+1. **Architecture vs Implementation**: Recommend design-for-feasibility approach
+2. **Scope vs Timeline**: Prioritize critical path, defer nice-to-haves
+3. **Quality vs Speed**: Suggest iterative approach (MVP + iterations)
+4. **Resource vs Effort**: Identify parallelizable tasks
+
+**Require User Input for**:
+- Strategic choices (which feature to prioritize?)
+- Tool/technology decisions with strong team preferences
+- Budget/resource constraints not stated in planning topic
+
+---
+
+## Continue & Resume
+
+```bash
+/workflow:quick-plan-with-file --continue "planning-topic"
+```
+
+When continuing:
+1. Load existing plan.md and perspectives.json
+2. Identify what's incomplete
+3. Re-run affected agents (if planning has changed)
+4. Update plan.md with new findings
+5. Generate updated synthesis.json
+
+---
+
+## Integration Flow
+
+```
+Input Source:
+  ├─ Raw task description
+  ├─ Brainstorm synthesis.json
+  └─ Analysis conclusions.json
+       ↓
+/workflow:quick-plan-with-file
+       ↓
+plan.md + synthesis.json
+       ↓
+/workflow:unified-execute-with-file
+       ↓
+Implementation
+```
+
+---
+
+## Usage Patterns
+
+### Pattern 1: Quick Planning from Task
+
+```bash
+# User has a task, needs rapid multi-perspective plan
+/workflow:quick-plan-with-file -y "实现实时通知系统，支持推送和WebSocket"
+# → Creates plan in ~5 minutes
+# → Ready for execution
+```
+
+### Pattern 2: Convert Brainstorm to Executable Plan
+
+```bash
+# User completed brainstorm, wants to convert top idea to executable plan
+/workflow:quick-plan-with-file --from brainstorm BS-notifications-2025-01-28
+# → Reads synthesis.json from brainstorm
+# → Generates implementation plan
+# → Ready for unified-execute-with-file
+```
+
+### Pattern 3: From Analysis to Implementation
+
+```bash
+# Analysis completed, now need execution plan
+/workflow:quick-plan-with-file --from analysis ANL-auth-architecture-2025-01-28
+# → Reads conclusions.json from analysis
+# → Generates planning with recommendations
+# → Output task breakdown
+```
+
+### Pattern 4: Planning with Interactive Conflict Resolution
+
+```bash
+# Full planning with user involvement in decision-making
+/workflow:quick-plan-with-file "新的支付流程集成"
+# → Without -y flag
+# → After conflict detection, asks user about tradeoffs
+# → Generates plan based on user preferences
+```
+
+---
+
+## Comparison with Other Workflows
+
+| Feature | brainstorm | analyze | quick-plan | plan |
+|---------|-----------|---------|-----------|------|
+| **Purpose** | Ideation | Investigation | Lightweight planning | Detailed planning |
+| **Multi-agent** | 3 perspectives | 2 CLI + explore | 4 concurrent agents | N/A (single) |
+| **Documentation** | Extensive | Extensive | Minimal | Standard |
+| **Output** | Ideas + synthesis | Conclusions | Executable tasks | IMPL_PLAN |
+| **Typical Duration** | 30-60 min | 20-30 min | 5-10 min | 15-20 min |
+| **User Interaction** | High (multi-round) | High (Q&A) | Low (decisions) | Medium |
+
+---
+
+## Error Handling
+
+| Situation | Action |
+|-----------|--------|
+| Agents conflict on approach | Arbitration agent decides, document in conflicts.json |
+| Missing critical files | Continue with available context, note limitations |
+| Insufficient task breakdown | Ask user for planning focus areas |
+| Effort estimate too high | Suggest MVP approach or phasing |
+| Unclear requirements | Ask clarifying questions via AskUserQuestion |
+| Agent timeout | Use last successful result, note partial analysis |
+
+---
+
+## Best Practices
+
+1. **Use when**:
+   - You have clarity on WHAT but not HOW
+   - Need rapid multi-perspective planning
+   - Converting brainstorm/analysis into execution
+   - Want minimal planning overhead
+
+2. **Avoid when**:
+   - Requirements are highly ambiguous (use brainstorm instead)
+   - Need deep investigation (use analyze instead)
+   - Want extensive planning document (use plan instead)
+   - No tech stack clarity (use analyze first)
+
+3. **For best results**:
+   - Provide complete task/requirement description
+   - Include constraints and success criteria
+   - Specify preferences (speed vs quality vs risk)
+   - Review conflicts.json and make conscious tradeoff decisions
+
+---
+
+## Next Steps After Planning
+
+### Feed to Execution
+```bash
+/workflow:unified-execute-with-file -p .workflow/.planning/{sessionId}/synthesis.json
+```
+
+### Detailed Planning if Needed
+```bash
+/workflow:plan "Based on quick-plan recommendations..."
+```
+
+### Continuous Refinement
+```bash
+/workflow:quick-plan-with-file --continue "{topic}"  # Update plan with new constraints
+```

.claude/commands/workflow/replan.md

@@ -1,7 +1,7 @@
 ---
 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]"
+argument-hint: "[-y|--yes] [--session session-id] [task-id] \"requirements\"|file.md [--interactive]"
 allowed-tools: Read(*), Write(*), Edit(*), TodoWrite(*), Glob(*), Bash(*)
 ---
 
@@ -113,7 +113,59 @@ const taskId = taskIdMatch?.[1]
    - List existing tasks
    - Read `IMPL_PLAN.md` and `TODO_LIST.md`
 
-**Output**: Session validated, context loaded, mode determined
+4. **Parse Execution Intent** (from requirements text):
+   ```javascript
+   // Dynamic tool detection from cli-tools.json
+   // Read enabled tools: ["gemini", "qwen", "codex", ...]
+   const enabledTools = loadEnabledToolsFromConfig();  // See ~/.claude/cli-tools.json
+
+   // Build dynamic patterns from enabled tools
+   function buildExecPatterns(tools) {
+     const patterns = {
+       agent: /改为\s*Agent\s*执行|使用\s*Agent\s*执行/i
+     };
+     tools.forEach(tool => {
+       // Pattern: "使用 {tool} 执行" or "改用 {tool}"
+       patterns[`cli_${tool}`] = new RegExp(
+         `使用\\s*(${tool})\\s*执行|改用\\s*(${tool})`, 'i'
+       );
+     });
+     return patterns;
+   }
+
+   const execPatterns = buildExecPatterns(enabledTools);
+
+   let executionIntent = null
+   for (const [key, pattern] of Object.entries(execPatterns)) {
+     if (pattern.test(requirements)) {
+       executionIntent = key.startsWith('cli_')
+         ? { method: 'cli', cli_tool: key.replace('cli_', '') }
+         : { method: 'agent', cli_tool: null }
+       break
+     }
+   }
+   ```
+
+**Output**: Session validated, context loaded, mode determined, **executionIntent parsed**
+
+---
+
+### Auto Mode Support
+
+When `--yes` or `-y` flag is used, the command skips interactive clarification and uses safe defaults:
+
+```javascript
+const autoYes = $ARGUMENTS.includes('--yes') || $ARGUMENTS.includes('-y')
+```
+
+**Auto Mode Defaults**:
+- **Modification Scope**: `tasks_only` (safest - only update task details)
+- **Affected Modules**: All modules related to the task
+- **Task Changes**: `update_only` (no structural changes)
+- **Dependency Changes**: `no` (preserve existing dependencies)
+- **User Confirmation**: Auto-confirm execution
+
+**Note**: `--interactive` flag overrides `--yes` flag (forces interactive mode).
 
 ---
 
@@ -121,6 +173,25 @@ const taskId = taskIdMatch?.[1]
 
 **Purpose**: Define modification scope through guided questioning
 
+**Auto Mode Check**:
+```javascript
+if (autoYes && !interactive) {
+  // Use defaults and skip to Phase 3
+  console.log(`[--yes] Using safe defaults for replan:`)
+  console.log(`  - Scope: tasks_only`)
+  console.log(`  - Changes: update_only`)
+  console.log(`  - Dependencies: preserve existing`)
+
+  userSelections = {
+    scope: 'tasks_only',
+    modules: 'all_affected',
+    task_changes: 'update_only',
+    dependency_changes: false
+  }
+  // Proceed to Phase 3
+}
+```
+
 #### Session Mode Questions
 
 **Q1: Modification Scope**
@@ -228,10 +299,29 @@ interface ImpactAnalysis {
 **Step 3.3: User Confirmation**
 
 ```javascript
-Options:
-- 确认执行: 开始应用所有修改
-- 调整计划: 重新回答问题调整范围
-- 取消操作: 放弃本次重规划
+// Parse --yes flag
+const autoYes = $ARGUMENTS.includes('--yes') || $ARGUMENTS.includes('-y')
+
+if (autoYes) {
+  // Auto mode: Auto-confirm execution
+  console.log(`[--yes] Auto-confirming replan execution`)
+  userConfirmation = '确认执行'
+  // Proceed to Phase 4
+} else {
+  // Interactive mode: Ask user
+  AskUserQuestion({
+    questions: [{
+      question: "修改计划已生成，请确认操作:",
+      header: "Confirm",
+      options: [
+        { label: "确认执行", description: "开始应用所有修改" },
+        { label: "调整计划", description: "重新回答问题调整范围" },
+        { label: "取消操作", description: "放弃本次重规划" }
+      ],
+      multiSelect: false
+    }]
+  })
+}
 ```
 
 **Output**: Modification plan confirmed or adjusted
@@ -299,7 +389,18 @@ const updated_task = {
   flow_control: {
     ...task.flow_control,
     implementation_approach: [...updated_steps]
-  }
+  },
+  // Update execution config if intent detected
+  ...(executionIntent && {
+    meta: {
+      ...task.meta,
+      execution_config: {
+        method: executionIntent.method,
+        cli_tool: executionIntent.cli_tool,
+        enable_resume: executionIntent.method !== 'agent'
+      }
+    }
+  })
 };
 
 Write({
@@ -308,6 +409,8 @@ Write({
 });
 ```
 
+**Note**: Implementation approach steps are NO LONGER modified. CLI execution is controlled by task-level `meta.execution_config` only.
+
 **Step 5.4: Create New Tasks** (if needed)
 
 Generate complete task JSON with all required fields:
@@ -513,3 +616,33 @@ A: 是,需要同步更新依赖任务
 
 任务重规划完成! 更新 2 个任务
 ```
+
+### Task Replan - Change Execution Method
+
+```bash
+/workflow:replan IMPL-001 "改用 Codex 执行"
+
+# Semantic parsing detects executionIntent:
+# { method: 'cli', cli_tool: 'codex' }
+
+# Execution (no interactive questions needed)
+✓ 创建备份
+✓ 更新 IMPL-001.json
+  - meta.execution_config = { method: 'cli', cli_tool: 'codex', enable_resume: true }
+
+任务执行方式已更新: Agent → CLI (codex)
+```
+
+```bash
+/workflow:replan IMPL-002 "改为 Agent 执行"
+
+# Semantic parsing detects executionIntent:
+# { method: 'agent', cli_tool: null }
+
+# Execution
+✓ 创建备份
+✓ 更新 IMPL-002.json
+  - meta.execution_config = { method: 'agent', cli_tool: null }
+
+任务执行方式已更新: CLI → Agent
+```

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

@@ -0,0 +1,608 @@
+---
+name: review-cycle-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-Cycle-Fix Command
+
+## Quick Start
+
+```bash
+# Fix from exported findings file (session-based path)
+/workflow:review-cycle-fix .workflow/active/WFS-123/.review/fix-export-1706184622000.json
+
+# Fix from review directory (auto-discovers latest export)
+/workflow:review-cycle-fix .workflow/active/WFS-123/.review/
+
+# Resume interrupted fix session
+/workflow:review-cycle-fix --resume
+
+# Custom max retry attempts per finding
+/workflow:review-cycle-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-fix.md

@@ -1,646 +0,0 @@
----
-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. **Real-time Visibility**: Dashboard shows planning progress, stage timeline, and active agents
-5. **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 → Generate fix-dashboard.html
-
-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 (dashboard auto-polls for status)
-
-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)
-- Dashboard generation: Create fix-dashboard.html from template (see Dashboard Generation below)
-- TodoWrite initialization: Set up 4-phase tracking
-
-**Phase 2: Planning Coordination**
-- Launch @cli-planning-agent with findings data and project context
-- Monitor planning progress (dashboard shows "Planning fixes..." indicator)
-- 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
-- Dashboard polls and aggregates fix-progress-{N}.json files for display
-
-**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 with dashboard link
-
-**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
-
-### Dashboard Generation
-
-**MANDATORY**: Dashboard MUST be generated from template during Phase 1 initialization
-
-**Template Location**: `~/.claude/templates/fix-dashboard.html`
-
-**⚠️ POST-GENERATION**: Orchestrator and agents MUST NOT read/write/modify fix-dashboard.html after creation
-
-**Generation Steps**:
-
-```bash
-# 1. Copy template to fix session directory
-cp ~/.claude/templates/fix-dashboard.html ${sessionDir}/fixes/${fixSessionId}/fix-dashboard.html
-
-# 2. Replace SESSION_ID placeholder
-sed -i "s|{{SESSION_ID}}|${sessionId}|g" ${sessionDir}/fixes/${fixSessionId}/fix-dashboard.html
-
-# 3. Replace REVIEW_DIR placeholder
-sed -i "s|{{REVIEW_DIR}}|${reviewDir}|g" ${sessionDir}/fixes/${fixSessionId}/fix-dashboard.html
-
-# 4. Start local server and output dashboard URL
-cd ${sessionDir}/fixes/${fixSessionId} && python -m http.server 8766 --bind 127.0.0.1 &
-echo "🔧 Fix Dashboard: http://127.0.0.1:8766/fix-dashboard.html"
-echo "   (Press Ctrl+C to stop server when done)"
-```
-
-**Dashboard Features**:
-- Real-time progress tracking via JSON polling (3-second interval)
-- Stage timeline visualization with parallel/serial execution modes
-- Active groups and agents monitoring
-- Flow control steps tracking for each agent
-- Fix history drawer with session summaries
-- Consumes new JSON structure (fix-plan.json with metadata + fix-progress-{N}.json)
-
-**JSON Consumption**:
-- `fix-plan.json`: Reads metadata field for session info, timeline stages, groups configuration
-- `fix-progress-{N}.json`: Polls all progress files to aggregate real-time status
-- `active-fix-session.json`: Detects active session on load
-- `fix-history.json`: Loads historical fix sessions
-
-### Output File Structure
-
-```
-.workflow/active/WFS-{session-id}/.review/
-├── fix-export-{timestamp}.json     # Exported findings (input)
-└── fixes/{fix-session-id}/
-    ├── fix-dashboard.html          # Interactive dashboard (generated once, auto-polls JSON)
-    ├── 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**:
-- **Orchestrator**: `fix-dashboard.html` (generated once from template during Phase 1)
-- **Planning Agent**: `fix-plan.json` (with metadata), all `fix-progress-*.json` (initial state)
-- **Execution Agents**: Update assigned `fix-progress-{N}.json` in real-time
-- **Dashboard (Browser)**: Reads `fix-plan.json` + all `fix-progress-*.json`, aggregates in-memory every 3 seconds via JavaScript polling
-
-
-### 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 for Dashboard consumption - 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 for dashboard visibility.
-
-## 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)
-- **Dashboard polls every 3 seconds** - ensure writes are atomic
-- **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
-
-## 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. **Monitor Dashboard**: Real-time stage timeline and agent status provide execution visibility
-5. **Resume Support**: Fix sessions can resume from checkpoints after interruption
-6. **Manual Review**: Always review failed fixes manually - may require architectural changes
-7. **Incremental Fixing**: Start with small batches (5-10 findings) before large-scale fixes
-
-

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

@@ -51,14 +51,12 @@ Independent multi-dimensional code review orchestrator with **hybrid parallel-it
 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. **Real-time Visibility**: JSON-based progress tracking with interactive HTML dashboard
-6. **Unified Archive**: Review results archived with session for historical reference
+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
-- **⚠️ DASHBOARD CONSTRAINT**: Dashboard is generated ONCE during Phase 1 initialization. After initialization, orchestrator and agents MUST NOT read, write, or modify dashboard.html - it remains static for user interaction only.
 
 ## How It Works
 
@@ -66,7 +64,7 @@ Independent multi-dimensional code review orchestrator with **hybrid parallel-it
 
 ```
 Phase 1: Discovery & Initialization
-   └─ Resolve file patterns, validate paths, initialize state, create output structure → Generate dashboard.html
+   └─ Resolve file patterns, validate paths, initialize state, create output structure
 
 Phase 2: Parallel Reviews (for each dimension)
    ├─ Launch 7 review agents simultaneously
@@ -90,7 +88,7 @@ Phase 4: Iterative Deep-Dive (optional)
    └─ Loop until no critical findings OR max iterations
 
 Phase 5: Completion
-   └─ Finalize review-progress.json → Output dashboard path
+   └─ Finalize review-progress.json
 ```
 
 ### Agent Roles
@@ -188,8 +186,8 @@ const CATEGORIES = {
 
 **Step 1: Session Creation**
 ```javascript
-// Create workflow session for this review
-SlashCommand(command="/workflow:session:start \"Code review for [target_pattern]\"")
+// 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];
@@ -219,37 +217,9 @@ done
 
 **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 dashboard polling
+- Progress tracking: Create `review-progress.json` for progress tracking
 
-**Step 5: Dashboard Generation**
-
-**Constraints**:
-- **MANDATORY**: Dashboard MUST be generated from template: `~/.claude/templates/review-cycle-dashboard.html`
-- **PROHIBITED**: Direct creation or custom generation without template
-- **POST-GENERATION**: Orchestrator and agents MUST NOT read/write/modify dashboard.html after creation
-
-**Generation Commands** (3 independent steps):
-```bash
-# Step 1: Copy template to output location
-cp ~/.claude/templates/review-cycle-dashboard.html ${sessionDir}/.review/dashboard.html
-
-# Step 2: Replace SESSION_ID placeholder
-sed -i "s|{{SESSION_ID}}|${sessionId}|g" ${sessionDir}/.review/dashboard.html
-
-# Step 3: Replace REVIEW_TYPE placeholder
-sed -i "s|{{REVIEW_TYPE}}|module|g" ${sessionDir}/.review/dashboard.html
-
-# Step 4: Replace REVIEW_DIR placeholder
-sed -i "s|{{REVIEW_DIR}}|${reviewDir}|g" ${sessionDir}/.review/dashboard.html
-
-# Output: Start local server and output dashboard URL
-# Use Python HTTP server (available on most systems)
-cd ${sessionDir}/.review && python -m http.server 8765 --bind 127.0.0.1 &
-echo "📊 Dashboard: http://127.0.0.1:8765/dashboard.html"
-echo "   (Press Ctrl+C to stop server when done)"
-```
-
-**Step 6: TodoWrite Initialization**
+**Step 5: TodoWrite Initialization**
 - Set up progress tracking with hierarchical structure
 - Mark Phase 1 completed, Phase 2 in_progress
 
@@ -280,7 +250,6 @@ echo "   (Press Ctrl+C to stop server when done)"
 - Finalize review-progress.json with completion statistics
 - Update review-state.json with completion_time and phase=complete
 - TodoWrite completion: Mark all tasks done
-- Output: Dashboard path to user
 
 
 
@@ -301,12 +270,11 @@ echo "   (Press Ctrl+C to stop server when done)"
 ├── 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
-│   └── ...
-└── dashboard.html                       # Interactive dashboard (primary output)
+└── reports/                             # Human-readable reports
+    ├── security-analysis.md
+    ├── security-cli-output.txt
+    ├── deep-dive-1-{uuid}.md
+    └── ...
 ```
 
 **Session Context**:
@@ -423,6 +391,7 @@ echo "   (Press Ctrl+C to stop server when done)"
 ```javascript
 Task(
   subagent_type="cli-explore-agent",
+  run_in_background=false,
   description=`Execute ${dimension} review analysis via Deep Scan`,
   prompt=`
     ## Task Objective
@@ -440,6 +409,8 @@ Task(
     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)
@@ -508,6 +479,7 @@ Task(
 ```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
@@ -541,6 +513,8 @@ Task(
     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
@@ -772,24 +746,26 @@ TodoWrite({
 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
-6. **Dashboard Polling**: Refresh every 5 seconds for real-time updates
-7. **Export Results**: Use dashboard export for external tracking tools
 
 ## 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 dashboard to select findings and export them for automated fixing:
+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: Open dashboard, select findings, and export
-# Dashboard generates: fix-export-{timestamp}.json
-
-# Step 3: Run automated fixes
-/workflow:review-fix .workflow/active/WFS-{session-id}/.review/fix-export-{timestamp}.json
+# Step 2: Run automated fixes using dimension findings
+/workflow:review-cycle-fix .workflow/active/WFS-{session-id}/.review/
 ```
 
-See `/workflow:review-fix` for automated fixing with smart grouping, parallel execution, and test verification.
+See `/workflow:review-cycle-fix` for automated fixing with smart grouping, parallel execution, and test verification.
 

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

@@ -45,13 +45,11 @@ Session-based multi-dimensional code review orchestrator with **hybrid parallel-
 1. **Comprehensive Coverage**: 7 specialized dimensions analyze all quality aspects simultaneously
 2. **Intelligent Prioritization**: Automatic identification of critical issues and cross-cutting concerns
 3. **Actionable Insights**: Deep-dive iterations provide step-by-step remediation plans
-4. **Real-time Visibility**: JSON-based progress tracking with interactive HTML dashboard
 
 ### Orchestrator Boundary (CRITICAL)
 - **ONLY command** for comprehensive multi-dimensional 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
-- **⚠️ DASHBOARD CONSTRAINT**: Dashboard is generated ONCE during Phase 1 initialization. After initialization, orchestrator and agents MUST NOT read, write, or modify dashboard.html - it remains static for user interaction only.
 
 ## How It Works
 
@@ -59,7 +57,7 @@ Session-based multi-dimensional code review orchestrator with **hybrid parallel-
 
 ```
 Phase 1: Discovery & Initialization
-   └─ Validate session, initialize state, create output structure → Generate dashboard.html
+   └─ Validate session, initialize state, create output structure
 
 Phase 2: Parallel Reviews (for each dimension)
    ├─ Launch 7 review agents simultaneously
@@ -83,7 +81,7 @@ Phase 4: Iterative Deep-Dive (optional)
    └─ Loop until no critical findings OR max iterations
 
 Phase 5: Completion
-   └─ Finalize review-progress.json → Output dashboard path
+   └─ Finalize review-progress.json
 ```
 
 ### Agent Roles
@@ -199,36 +197,9 @@ git log --since="${sessionCreatedAt}" --name-only --pretty=format: | sort -u
 
 **Step 5: Initialize Review State**
 - State initialization: Create `review-state.json` with metadata, dimensions, max_iterations (merged metadata + state)
-- Progress tracking: Create `review-progress.json` for dashboard polling
+- Progress tracking: Create `review-progress.json` for progress tracking
 
-**Step 6: Dashboard Generation**
-
-**Constraints**:
-- **MANDATORY**: Dashboard MUST be generated from template: `~/.claude/templates/review-cycle-dashboard.html`
-- **PROHIBITED**: Direct creation or custom generation without template
-- **POST-GENERATION**: Orchestrator and agents MUST NOT read/write/modify dashboard.html after creation
-
-**Generation Commands** (3 independent steps):
-```bash
-# Step 1: Copy template to output location
-cp ~/.claude/templates/review-cycle-dashboard.html ${sessionDir}/.review/dashboard.html
-
-# Step 2: Replace SESSION_ID placeholder
-sed -i "s|{{SESSION_ID}}|${sessionId}|g" ${sessionDir}/.review/dashboard.html
-
-# Step 3: Replace REVIEW_TYPE placeholder
-sed -i "s|{{REVIEW_TYPE}}|session|g" ${sessionDir}/.review/dashboard.html
-
-# Step 4: Replace REVIEW_DIR placeholder
-sed -i "s|{{REVIEW_DIR}}|${reviewDir}|g" ${sessionDir}/.review/dashboard.html
-
-# Output: Start local server and output dashboard URL
-cd ${sessionDir}/.review && python -m http.server 8765 --bind 127.0.0.1 &
-echo "📊 Dashboard: http://127.0.0.1:8765/dashboard.html"
-echo "   (Press Ctrl+C to stop server when done)"
-```
-
-**Step 7: TodoWrite Initialization**
+**Step 6: TodoWrite Initialization**
 - Set up progress tracking with hierarchical structure
 - Mark Phase 1 completed, Phase 2 in_progress
 
@@ -259,7 +230,6 @@ echo "   (Press Ctrl+C to stop server when done)"
 - Finalize review-progress.json with completion statistics
 - Update review-state.json with completion_time and phase=complete
 - TodoWrite completion: Mark all tasks done
-- Output: Dashboard path to user
 
 
 
@@ -280,12 +250,11 @@ echo "   (Press Ctrl+C to stop server when done)"
 ├── 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
-│   └── ...
-└── dashboard.html                       # Interactive dashboard (primary output)
+└── reports/                             # Human-readable reports
+    ├── security-analysis.md
+    ├── security-cli-output.txt
+    ├── deep-dive-1-{uuid}.md
+    └── ...
 ```
 
 **Session Context**:
@@ -432,6 +401,7 @@ echo "   (Press Ctrl+C to stop server when done)"
 ```javascript
 Task(
   subagent_type="cli-explore-agent",
+  run_in_background=false,
   description=`Execute ${dimension} review analysis via Deep Scan`,
   prompt=`
     ## Task Objective
@@ -450,6 +420,8 @@ Task(
     3. Get changed files: bash(cd ${workflowDir} && git log --since="${sessionCreatedAt}" --name-only --pretty=format: | sort -u)
     4. Read review state: ${reviewStateJsonPath}
     5. Execute: cat ~/.claude/workflows/cli-templates/schemas/review-dimension-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 and conventions to validate against)
 
     ## Session Context
     - Session ID: ${sessionId}
@@ -518,6 +490,7 @@ Task(
 ```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
@@ -551,6 +524,8 @@ Task(
     3. Identify related code: bash(grep -r "import.*${basename(file)}" ${workflowDir}/src --include="*.ts")
     4. Read test files: bash(find ${workflowDir}/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
@@ -782,24 +757,26 @@ TodoWrite({
 2. **Parallel Execution**: ~60 minutes for full initial review (7 dimensions)
 3. **Trust Aggregation Logic**: Auto-selection based on proven heuristics
 4. **Monitor Logs**: Check reports/ directory for CLI analysis insights
-5. **Dashboard Polling**: Refresh every 5 seconds for real-time updates
-6. **Export Results**: Use dashboard export for external tracking tools
 
 ## Related Commands
 
+### View Review Progress
+Use `ccw view` to open the review dashboard in browser:
+
+```bash
+ccw view
+```
+
 ### Automated Fix Workflow
-After completing a review, use the dashboard to select findings and export them for automated fixing:
+After completing a review, use the generated findings JSON for automated fixing:
 
 ```bash
 # Step 1: Complete review (this command)
 /workflow:review-session-cycle
 
-# Step 2: Open dashboard, select findings, and export
-# Dashboard generates: fix-export-{timestamp}.json
-
-# Step 3: Run automated fixes
-/workflow:review-fix .workflow/active/WFS-{session-id}/.review/fix-export-{timestamp}.json
+# Step 2: Run automated fixes using dimension findings
+/workflow:review-cycle-fix .workflow/active/WFS-{session-id}/.review/
 ```
 
-See `/workflow:review-fix` for automated fixing with smart grouping, parallel execution, and test verification.
+See `/workflow:review-cycle-fix` for automated fixing with smart grouping, parallel execution, and test verification.
 

.claude/commands/workflow/review.md

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

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

@@ -1,500 +1,203 @@
 ---
 name: complete
 description: Mark active workflow session as complete, archive with lessons learned, update manifest, remove active flag
+argument-hint: "[-y|--yes] [--detailed]"
 examples:
   - /workflow:session:complete
+  - /workflow:session:complete --yes
   - /workflow:session:complete --detailed
 ---
 
 # Complete Workflow Session (/workflow:session:complete)
 
-## Overview
-Mark the currently active workflow session as complete, analyze it for lessons learned, move it to the archive directory, and remove the active flag marker.
+Mark the currently active workflow session as complete, archive it, and update manifests.
 
-## Usage
-```bash
-/workflow:session:complete           # Complete current active session
-/workflow:session:complete --detailed # Show detailed completion summary
-```
-
-## Implementation Flow
-
-### Phase 1: Pre-Archival Preparation (Transactional Setup)
-
-**Purpose**: Find active session, create archiving marker to prevent concurrent operations. Session remains in active location for agent processing.
-
-#### Step 1.1: Find Active Session and Get Name
-```bash
-# Find active session directory
-bash(find .workflow/active/ -name "WFS-*" -type d | head -1)
-
-# Extract session name from directory path
-bash(basename .workflow/active/WFS-session-name)
-```
-**Output**: Session name `WFS-session-name`
-
-#### Step 1.2: Check for Existing Archiving Marker (Resume Detection)
-```bash
-# Check if session is already being archived
-bash(test -f .workflow/active/WFS-session-name/.archiving && echo "RESUMING" || echo "NEW")
-```
-
-**If RESUMING**:
-- Previous archival attempt was interrupted
-- Skip to Phase 2 to resume agent analysis
-
-**If NEW**:
-- Continue to Step 1.3
-
-#### Step 1.3: Create Archiving Marker
-```bash
-# Mark session as "archiving in progress"
-bash(touch .workflow/active/WFS-session-name/.archiving)
-```
-**Purpose**:
-- Prevents concurrent operations on this session
-- Enables recovery if archival fails
-- Session remains in `.workflow/active/` for agent analysis
-
-**Result**: Session still at `.workflow/active/WFS-session-name/` with `.archiving` marker
-
-### Phase 2: Agent Analysis (In-Place Processing)
-
-**Purpose**: Agent analyzes session WHILE STILL IN ACTIVE LOCATION. Generates metadata but does NOT move files or update manifest.
-
-#### Agent Invocation
-
-Invoke `universal-executor` agent to analyze session and prepare archive metadata.
-
-**Agent Task**:
-```
-Task(
-  subagent_type="universal-executor",
-  description="Analyze session for archival",
-  prompt=`
-Analyze workflow session for archival preparation. Session is STILL in active location.
-
-## Context
-- Session: .workflow/active/WFS-session-name/
-- Status: Marked as archiving (.archiving marker present)
-- Location: Active sessions directory (NOT archived yet)
-
-## Tasks
-
-1. **Extract session data** from workflow-session.json
-   - session_id, description/topic, started_at, completed_at, status
-   - If status != "completed", update it with timestamp
-
-2. **Count files**: tasks (.task/*.json) and summaries (.summaries/*.md)
-
-3. **Extract review data** (if .review/ exists):
-   - Count dimension results: .review/dimensions/*.json
-   - Count deep-dive results: .review/iterations/*.json
-   - Extract findings summary from dimension JSONs (total, critical, high, medium, low)
-   - Check fix results if .review/fixes/ exists (fixed_count, failed_count)
-   - Build review_metrics: {dimensions_analyzed, total_findings, severity_distribution, fix_success_rate}
-
-4. **Generate lessons**: Use gemini with ~/.claude/workflows/cli-templates/prompts/archive/analysis-simple.txt
-   - Return: {successes, challenges, watch_patterns}
-   - If review data exists, include review-specific lessons (common issue patterns, effective fixes)
-
-5. **Build archive entry**:
-   - Calculate: duration_hours, success_rate, tags (3-5 keywords)
-   - Construct complete JSON with session_id, description, archived_at, metrics, tags, lessons
-   - Include archive_path: ".workflow/archives/WFS-session-name" (future location)
-   - If review data exists, include review_metrics in metrics object
-
-6. **Extract feature metadata** (for Phase 4):
-   - Parse IMPL_PLAN.md for title (first # heading)
-   - Extract description (first paragraph, max 200 chars)
-   - Generate feature tags (3-5 keywords from content)
-
-7. **Return result**: Complete metadata package for atomic commit
-   {
-     "status": "success",
-     "session_id": "WFS-session-name",
-     "archive_entry": {
-       "session_id": "...",
-       "description": "...",
-       "archived_at": "...",
-       "archive_path": ".workflow/archives/WFS-session-name",
-       "metrics": {
-         "duration_hours": 2.5,
-         "tasks_completed": 5,
-         "summaries_generated": 3,
-         "review_metrics": {                    // Optional, only if .review/ exists
-           "dimensions_analyzed": 4,
-           "total_findings": 15,
-           "severity_distribution": {"critical": 1, "high": 3, "medium": 8, "low": 3},
-           "fix_success_rate": 0.87             // Optional, only if .review/fixes/ exists
-         }
-       },
-       "tags": [...],
-       "lessons": {...}
-     },
-     "feature_metadata": {
-       "title": "...",
-       "description": "...",
-       "tags": [...]
-     }
-   }
-
-## Important Constraints
-- DO NOT move or delete any files
-- DO NOT update manifest.json yet
-- Session remains in .workflow/active/ during analysis
-- Return complete metadata package for orchestrator to commit atomically
-
-## Error Handling
-- On failure: return {"status": "error", "task": "...", "message": "..."}
-- Do NOT modify any files on error
-  `
-)
-```
-
-**Expected Output**:
-- Agent returns complete metadata package
-- Session remains in `.workflow/active/` with `.archiving` marker
-- No files moved or manifests updated yet
-
-### Phase 3: Atomic Commit (Transactional File Operations)
-
-**Purpose**: Atomically commit all changes. Only execute if Phase 2 succeeds.
-
-#### Step 3.1: Create Archive Directory
-```bash
-bash(mkdir -p .workflow/archives/)
-```
-
-#### Step 3.2: Move Session to Archive
-```bash
-bash(mv .workflow/active/WFS-session-name .workflow/archives/WFS-session-name)
-```
-**Result**: Session now at `.workflow/archives/WFS-session-name/`
-
-#### Step 3.3: Update Manifest
-```bash
-# Read current manifest (or create empty array if not exists)
-bash(test -f .workflow/archives/manifest.json && cat .workflow/archives/manifest.json || echo "[]")
-```
-
-**JSON Update Logic**:
-```javascript
-// Read agent result from Phase 2
-const agentResult = JSON.parse(agentOutput);
-const archiveEntry = agentResult.archive_entry;
-
-// Read existing manifest
-let manifest = [];
-try {
-  const manifestContent = Read('.workflow/archives/manifest.json');
-  manifest = JSON.parse(manifestContent);
-} catch {
-  manifest = []; // Initialize if not exists
-}
-
-// Append new entry
-manifest.push(archiveEntry);
-
-// Write back
-Write('.workflow/archives/manifest.json', JSON.stringify(manifest, null, 2));
-```
-
-#### Step 3.4: Remove Archiving Marker
-```bash
-bash(rm .workflow/archives/WFS-session-name/.archiving)
-```
-**Result**: Clean archived session without temporary markers
-
-**Output Confirmation**:
-```
-✓ Session "${sessionId}" archived successfully
-  Location: .workflow/archives/WFS-session-name/
-  Lessons: ${archiveEntry.lessons.successes.length} successes, ${archiveEntry.lessons.challenges.length} challenges
-  Manifest: Updated with ${manifest.length} total sessions
-  ${reviewMetrics ? `Review: ${reviewMetrics.total_findings} findings across ${reviewMetrics.dimensions_analyzed} dimensions, ${Math.round(reviewMetrics.fix_success_rate * 100)}% fixed` : ''}
-```
-
-### Phase 4: Update Project Feature Registry
-
-**Purpose**: Record completed session as a project feature in `.workflow/project.json`.
-
-**Execution**: Uses feature metadata from Phase 2 agent result to update project registry.
-
-#### Step 4.1: Check Project State Exists
-```bash
-bash(test -f .workflow/project.json && echo "EXISTS" || echo "SKIP")
-```
-
-**If SKIP**: Output warning and skip Phase 4
-```
-WARNING: No project.json found. Run /workflow:session:start to initialize.
-```
-
-#### Step 4.2: Extract Feature Information from Agent Result
-
-**Data Processing** (Uses Phase 2 agent output):
-```javascript
-// Extract feature metadata from agent result
-const agentResult = JSON.parse(agentOutput);
-const featureMeta = agentResult.feature_metadata;
-
-// Data already prepared by agent:
-const title = featureMeta.title;
-const description = featureMeta.description;
-const tags = featureMeta.tags;
-
-// Create feature ID (lowercase slug)
-const featureId = title.toLowerCase().replace(/[^a-z0-9]+/g, '-').substring(0, 50);
-```
-
-#### Step 4.3: Update project.json
+## Pre-defined Commands
 
 ```bash
-# Read current project state
-bash(cat .workflow/project.json)
+# Phase 1: Find active session
+SESSION_PATH=$(find .workflow/active/ -maxdepth 1 -name "WFS-*" -type d | head -1)
+SESSION_ID=$(basename "$SESSION_PATH")
+
+# Phase 3: Move to archive
+mkdir -p .workflow/archives/
+mv .workflow/active/$SESSION_ID .workflow/archives/$SESSION_ID
+
+# Cleanup marker
+rm -f .workflow/archives/$SESSION_ID/.archiving
 ```
 
-**JSON Update Logic**:
-```javascript
-// Read existing project.json (created by /workflow:init)
-// Note: overview field is managed by /workflow:init, not modified here
-const projectMeta = JSON.parse(Read('.workflow/project.json'));
-const currentTimestamp = new Date().toISOString();
-const currentDate = currentTimestamp.split('T')[0]; // YYYY-MM-DD
+## Key Files to Read
 
-// Extract tags from IMPL_PLAN.md (simple keyword extraction)
-const tags = extractTags(planContent); // e.g., ["auth", "security"]
+**For manifest.json generation**, read ONLY these files:
 
-// Build feature object with complete metadata
-const newFeature = {
-  id: featureId,
-  title: title,
-  description: description,
-  status: "completed",
-  tags: tags,
-  timeline: {
-    created_at: currentTimestamp,
-    implemented_at: currentDate,
-    updated_at: currentTimestamp
-  },
-  traceability: {
-    session_id: sessionId,
-    archive_path: archivePath, // e.g., ".workflow/archives/WFS-auth-system"
-    commit_hash: getLatestCommitHash() || "" // Optional: git rev-parse HEAD
-  },
-  docs: [],      // Placeholder for future doc links
-  relations: []  // Placeholder for feature dependencies
-};
+| File | Extract |
+|------|---------|
+| `$SESSION_PATH/workflow-session.json` | session_id, description, started_at, status |
+| `$SESSION_PATH/IMPL_PLAN.md` | title (first # heading), description (first paragraph) |
+| `$SESSION_PATH/.tasks/*.json` | count files |
+| `$SESSION_PATH/.summaries/*.md` | count files |
+| `$SESSION_PATH/.review/dimensions/*.json` | count + findings summary (optional) |
 
-// Add new feature to array
-projectMeta.features.push(newFeature);
+## Execution Flow
 
-// Update statistics
-projectMeta.statistics.total_features = projectMeta.features.length;
-projectMeta.statistics.total_sessions += 1;
-projectMeta.statistics.last_updated = currentTimestamp;
+### Phase 1: Find Session (2 commands)
 
-// Write back
-Write('.workflow/project.json', JSON.stringify(projectMeta, null, 2));
+```bash
+# 1. Find and extract session
+SESSION_PATH=$(find .workflow/active/ -maxdepth 1 -name "WFS-*" -type d | head -1)
+SESSION_ID=$(basename "$SESSION_PATH")
+
+# 2. Check/create archiving marker
+test -f "$SESSION_PATH/.archiving" && echo "RESUMING" || touch "$SESSION_PATH/.archiving"
 ```
 
-**Helper Functions**:
-```javascript
-// Extract tags from IMPL_PLAN.md content
-function extractTags(planContent) {
-  const tags = [];
+**Output**: `SESSION_ID` = e.g., `WFS-auth-feature`
 
-  // Look for common keywords
-  const keywords = {
-    'auth': /authentication|login|oauth|jwt/i,
-    'security': /security|encrypt|hash|token/i,
-    'api': /api|endpoint|rest|graphql/i,
-    'ui': /component|page|interface|frontend/i,
-    'database': /database|schema|migration|sql/i,
-    'test': /test|testing|spec|coverage/i
-  };
+### Phase 2: Generate Manifest Entry (Read-only)
 
-  for (const [tag, pattern] of Object.entries(keywords)) {
-    if (pattern.test(planContent)) {
-      tags.push(tag);
+Read the key files above, then build this structure:
+
+```json
+{
+  "session_id": "<from workflow-session.json>",
+  "description": "<from workflow-session.json>",
+  "archived_at": "<current ISO timestamp>",
+  "archive_path": ".workflow/archives/<SESSION_ID>",
+  "metrics": {
+    "duration_hours": "<(completed_at - started_at) / 3600000>",
+    "tasks_completed": "<count .tasks/*.json>",
+    "summaries_generated": "<count .summaries/*.md>",
+    "review_metrics": {
+      "dimensions_analyzed": "<count .review/dimensions/*.json>",
+      "total_findings": "<sum from dimension JSONs>"
     }
-  }
-
-  return tags.slice(0, 5); // Max 5 tags
-}
-
-// Get latest git commit hash (optional)
-function getLatestCommitHash() {
-  try {
-    const result = Bash({
-      command: "git rev-parse --short HEAD 2>/dev/null",
-      description: "Get latest commit hash"
-    });
-    return result.trim();
-  } catch {
-    return "";
+  },
+  "tags": ["<3-5 keywords from IMPL_PLAN.md>"],
+  "lessons": {
+    "successes": ["<key wins>"],
+    "challenges": ["<difficulties>"],
+    "watch_patterns": ["<patterns to monitor>"]
   }
 }
 ```
 
-#### Step 4.4: Output Confirmation
+**Lessons Generation**: Use gemini with `~/.claude/workflows/cli-templates/prompts/archive/analysis-simple.txt`
 
-```
-✓ Feature "${title}" added to project registry
-  ID: ${featureId}
-  Session: ${sessionId}
-  Location: .workflow/project.json
+### Phase 3: Atomic Commit (4 commands)
+
+```bash
+# 1. Create archive directory
+mkdir -p .workflow/archives/
+
+# 2. Move session
+mv .workflow/active/$SESSION_ID .workflow/archives/$SESSION_ID
+
+# 3. Update manifest.json (Read → Append → Write)
+# Read: .workflow/archives/manifest.json (or [])
+# Append: archive_entry from Phase 2
+# Write: updated JSON
+
+# 4. Remove marker
+rm -f .workflow/archives/$SESSION_ID/.archiving
 ```
 
-**Error Handling**:
-- If project.json malformed: Output error, skip update
-- If feature_metadata missing from agent result: Skip Phase 4
-- If extraction fails: Use minimal defaults
+**Output**:
+```
+✓ Session "$SESSION_ID" archived successfully
+  Location: .workflow/archives/$SESSION_ID/
+  Manifest: Updated with N total sessions
+```
 
-**Phase 4 Total Commands**: 1 bash read + JSON manipulation
+### Phase 4: Update project-tech.json (Optional)
+
+**Skip if**: `.workflow/project-tech.json` doesn't exist
+
+```bash
+# Check
+test -f .workflow/project-tech.json || echo "SKIP"
+```
+
+**If exists**, add feature entry:
+
+```json
+{
+  "id": "<slugified title>",
+  "title": "<from IMPL_PLAN.md>",
+  "status": "completed",
+  "tags": ["<from Phase 2>"],
+  "timeline": { "implemented_at": "<date>" },
+  "traceability": { "session_id": "<SESSION_ID>", "archive_path": "<path>" }
+}
+```
+
+**Output**:
+```
+✓ Feature added to project registry
+```
+
+### Phase 5: Ask About Solidify (Always)
+
+After successful archival, prompt user to capture learnings:
+
+```javascript
+// Parse --yes flag
+const autoYes = $ARGUMENTS.includes('--yes') || $ARGUMENTS.includes('-y')
+
+if (autoYes) {
+  // Auto mode: Skip solidify
+  console.log(`[--yes] Auto-selecting: Skip solidify`)
+  console.log(`Session archived successfully.`)
+  // Done - no solidify
+} else {
+  // Interactive mode: Ask user
+  AskUserQuestion({
+    questions: [{
+      question: "Would you like to solidify learnings from this session into project guidelines?",
+      header: "Solidify",
+      options: [
+        { label: "Yes, solidify now", description: "Extract learnings and update project-guidelines.json" },
+        { label: "Skip", description: "Archive complete, no learnings to capture" }
+      ],
+      multiSelect: false
+    }]
+  })
+
+  // **If "Yes, solidify now"**: Execute `/workflow:session:solidify` with the archived session ID.
+}
+```
+
+## Auto Mode Defaults
+
+When `--yes` or `-y` flag is used:
+- **Solidify Learnings**: Auto-selected "Skip" (archive only, no solidify)
+
+**Flag Parsing**:
+```javascript
+const autoYes = $ARGUMENTS.includes('--yes') || $ARGUMENTS.includes('-y')
+```
+
+**Output**:
+```
+Session archived successfully.
+→ Run /workflow:session:solidify to capture learnings (recommended)
+```
 
 ## Error Recovery
 
-### If Agent Fails (Phase 2)
+| Phase | Symptom | Recovery |
+|-------|---------|----------|
+| 1 | No active session | `No active session found` |
+| 2 | Analysis fails | Remove marker: `rm $SESSION_PATH/.archiving`, retry |
+| 3 | Move fails | Session safe in active/, fix issue, retry |
+| 3 | Manifest fails | Session in archives/, manually add entry, remove marker |
 
-**Symptoms**:
-- Agent returns `{"status": "error", ...}`
-- Agent crashes or times out
-- Analysis incomplete
+## Quick Reference
 
-**Recovery Steps**:
-```bash
-# Session still in .workflow/active/WFS-session-name
-# Remove archiving marker
-bash(rm .workflow/active/WFS-session-name/.archiving)
 ```
-
-**User Notification**:
+Phase 1: find session → create .archiving marker
+Phase 2: read key files → build manifest entry (no writes)
+Phase 3: mkdir → mv → update manifest.json → rm marker
+Phase 4: update project-tech.json features array (optional)
+Phase 5: ask user → solidify learnings (optional)
 ```
-ERROR: Session archival failed during analysis phase
-Reason: [error message from agent]
-Session remains active in: .workflow/active/WFS-session-name
-
-Recovery:
-1. Fix any issues identified in error message
-2. Retry: /workflow:session:complete
-
-Session state: SAFE (no changes committed)
-```
-
-### If Move Fails (Phase 3)
-
-**Symptoms**:
-- `mv` command fails
-- Permission denied
-- Disk full
-
-**Recovery Steps**:
-```bash
-# Archiving marker still present
-# Session still in .workflow/active/ (move failed)
-# No manifest updated yet
-```
-
-**User Notification**:
-```
-ERROR: Session archival failed during move operation
-Reason: [mv error message]
-Session remains in: .workflow/active/WFS-session-name
-
-Recovery:
-1. Fix filesystem issues (permissions, disk space)
-2. Retry: /workflow:session:complete
-   - System will detect .archiving marker
-   - Will resume from Phase 2 (agent analysis)
-
-Session state: SAFE (analysis complete, ready to retry move)
-```
-
-### If Manifest Update Fails (Phase 3)
-
-**Symptoms**:
-- JSON parsing error
-- Write permission denied
-- Session moved but manifest not updated
-
-**Recovery Steps**:
-```bash
-# Session moved to .workflow/archives/WFS-session-name
-# Manifest NOT updated
-# Archiving marker still present in archived location
-```
-
-**User Notification**:
-```
-ERROR: Session archived but manifest update failed
-Reason: [error message]
-Session location: .workflow/archives/WFS-session-name
-
-Recovery:
-1. Fix manifest.json issues (syntax, permissions)
-2. Manual manifest update:
-   - Add archive entry from agent output
-   - Remove .archiving marker: rm .workflow/archives/WFS-session-name/.archiving
-
-Session state: PARTIALLY COMPLETE (session archived, manifest needs update)
-```
-
-## Workflow Execution Strategy
-
-### Transactional Four-Phase Approach
-
-**Phase 1: Pre-Archival Preparation** (Marker creation)
-- Find active session and extract name
-- Check for existing `.archiving` marker (resume detection)
-- Create `.archiving` marker if new
-- **No data processing** - just state tracking
-- **Total**: 2-3 bash commands (find + marker check/create)
-
-**Phase 2: Agent Analysis** (Read-only data processing)
-- Extract all session data from active location
-- Count tasks and summaries
-- Extract review data if .review/ exists (dimension results, findings, fix results)
-- Generate lessons learned analysis (including review-specific lessons if applicable)
-- Extract feature metadata from IMPL_PLAN.md
-- Build complete archive + feature metadata package (with review_metrics if applicable)
-- **No file modifications** - pure analysis
-- **Total**: 1 agent invocation
-
-**Phase 3: Atomic Commit** (Transactional file operations)
-- Create archive directory
-- Move session to archive location
-- Update manifest.json with archive entry
-- Remove `.archiving` marker
-- **All-or-nothing**: Either all succeed or session remains in safe state
-- **Total**: 4 bash commands + JSON manipulation
-
-**Phase 4: Project Registry Update** (Optional feature tracking)
-- Check project.json exists
-- Use feature metadata from Phase 2 agent result
-- Build feature object with complete traceability
-- Update project statistics
-- **Independent**: Can fail without affecting archival
-- **Total**: 1 bash read + JSON manipulation
-
-### Transactional Guarantees
-
-**State Consistency**:
-- Session NEVER in inconsistent state
-- `.archiving` marker enables safe resume
-- Agent failure leaves session in recoverable state
-- Move/manifest operations grouped in Phase 3
-
-**Failure Isolation**:
-- Phase 1 failure: No changes made
-- Phase 2 failure: Session still active, can retry
-- Phase 3 failure: Clear error state, manual recovery documented
-- Phase 4 failure: Does not affect archival success
-
-**Resume Capability**:
-- Detect interrupted archival via `.archiving` marker
-- Resume from Phase 2 (skip marker creation)
-- Idempotent operations (safe to retry)
-
-

.claude/commands/workflow/session/solidify.md

@@ -0,0 +1,303 @@
+---
+name: solidify
+description: Crystallize session learnings and user-defined constraints into permanent project guidelines
+argument-hint: "[-y|--yes] [--type <convention|constraint|learning>] [--category <category>] \"rule or insight\""
+examples:
+  - /workflow:session:solidify "Use functional components for all React code" --type convention
+  - /workflow:session:solidify -y "No direct DB access from controllers" --type constraint --category architecture
+  - /workflow:session:solidify "Cache invalidation requires event sourcing" --type learning --category architecture
+  - /workflow:session:solidify --interactive
+---
+
+## Auto Mode
+
+When `--yes` or `-y`: Auto-categorize and add guideline without confirmation.
+
+# Session Solidify Command (/workflow:session:solidify)
+
+## Overview
+
+Crystallizes ephemeral session context (insights, decisions, constraints) into permanent project guidelines stored in `.workflow/project-guidelines.json`. This ensures valuable learnings persist across sessions and inform future planning.
+
+## Use Cases
+
+1. **During Session**: Capture important decisions as they're made
+2. **After Session**: Reflect on lessons learned before archiving
+3. **Proactive**: Add team conventions or architectural rules
+
+## Parameters
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `rule` | string | ✅ (unless --interactive) | The rule, convention, or insight to solidify |
+| `--type` | enum | ❌ | Type: `convention`, `constraint`, `learning` (default: auto-detect) |
+| `--category` | string | ❌ | Category for organization (see categories below) |
+| `--interactive` | flag | ❌ | Launch guided wizard for adding rules |
+
+### Type Categories
+
+**convention** → Coding style preferences (goes to `conventions` section)
+- Subcategories: `coding_style`, `naming_patterns`, `file_structure`, `documentation`
+
+**constraint** → Hard rules that must not be violated (goes to `constraints` section)
+- Subcategories: `architecture`, `tech_stack`, `performance`, `security`
+
+**learning** → Session-specific insights (goes to `learnings` array)
+- Subcategories: `architecture`, `performance`, `security`, `testing`, `process`, `other`
+
+## Execution Process
+
+```
+Input Parsing:
+   ├─ Parse: rule text (required unless --interactive)
+   ├─ Parse: --type (convention|constraint|learning)
+   ├─ Parse: --category (subcategory)
+   └─ Parse: --interactive (flag)
+
+Step 1: Ensure Guidelines File Exists
+   └─ If not exists → Create with empty structure
+
+Step 2: Auto-detect Type (if not specified)
+   └─ Analyze rule text for keywords
+
+Step 3: Validate and Format Entry
+   └─ Build entry object based on type
+
+Step 4: Update Guidelines File
+   └─ Add entry to appropriate section
+
+Step 5: Display Confirmation
+   └─ Show what was added and where
+```
+
+## Implementation
+
+### Step 1: Ensure Guidelines File Exists
+
+```bash
+bash(test -f .workflow/project-guidelines.json && echo "EXISTS" || echo "NOT_FOUND")
+```
+
+**If NOT_FOUND**, create scaffold:
+
+```javascript
+const scaffold = {
+  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(scaffold, null, 2));
+```
+
+### Step 2: Auto-detect Type (if not specified)
+
+```javascript
+function detectType(ruleText) {
+  const text = ruleText.toLowerCase();
+
+  // Constraint indicators
+  if (/\b(no|never|must not|forbidden|prohibited|always must)\b/.test(text)) {
+    return 'constraint';
+  }
+
+  // Learning indicators
+  if (/\b(learned|discovered|realized|found that|turns out)\b/.test(text)) {
+    return 'learning';
+  }
+
+  // Default to convention
+  return 'convention';
+}
+
+function detectCategory(ruleText, type) {
+  const text = ruleText.toLowerCase();
+
+  if (type === 'constraint' || type === 'learning') {
+    if (/\b(architecture|layer|module|dependency|circular)\b/.test(text)) return 'architecture';
+    if (/\b(security|auth|permission|sanitize|xss|sql)\b/.test(text)) return 'security';
+    if (/\b(performance|cache|lazy|async|sync|slow)\b/.test(text)) return 'performance';
+    if (/\b(test|coverage|mock|stub)\b/.test(text)) return 'testing';
+  }
+
+  if (type === 'convention') {
+    if (/\b(name|naming|prefix|suffix|camel|pascal)\b/.test(text)) return 'naming_patterns';
+    if (/\b(file|folder|directory|structure|organize)\b/.test(text)) return 'file_structure';
+    if (/\b(doc|comment|jsdoc|readme)\b/.test(text)) return 'documentation';
+    return 'coding_style';
+  }
+
+  return type === 'constraint' ? 'tech_stack' : 'other';
+}
+```
+
+### Step 3: Build Entry
+
+```javascript
+function buildEntry(rule, type, category, sessionId) {
+  if (type === 'learning') {
+    return {
+      date: new Date().toISOString().split('T')[0],
+      session_id: sessionId || null,
+      insight: rule,
+      category: category,
+      context: null
+    };
+  }
+
+  // For conventions and constraints, just return the rule string
+  return rule;
+}
+```
+
+### Step 4: Update Guidelines File
+
+```javascript
+const guidelines = JSON.parse(Read('.workflow/project-guidelines.json'));
+
+if (type === 'convention') {
+  if (!guidelines.conventions[category]) {
+    guidelines.conventions[category] = [];
+  }
+  if (!guidelines.conventions[category].includes(rule)) {
+    guidelines.conventions[category].push(rule);
+  }
+} else if (type === 'constraint') {
+  if (!guidelines.constraints[category]) {
+    guidelines.constraints[category] = [];
+  }
+  if (!guidelines.constraints[category].includes(rule)) {
+    guidelines.constraints[category].push(rule);
+  }
+} else if (type === 'learning') {
+  guidelines.learnings.push(buildEntry(rule, type, category, sessionId));
+}
+
+guidelines._metadata.updated_at = new Date().toISOString();
+guidelines._metadata.last_solidified_by = sessionId;
+
+Write('.workflow/project-guidelines.json', JSON.stringify(guidelines, null, 2));
+```
+
+### Step 5: Display Confirmation
+
+```
+✓ Guideline solidified
+
+Type: ${type}
+Category: ${category}
+Rule: "${rule}"
+
+Location: .workflow/project-guidelines.json → ${type}s.${category}
+
+Total ${type}s in ${category}: ${count}
+```
+
+## Interactive Mode
+
+When `--interactive` flag is provided:
+
+```javascript
+AskUserQuestion({
+  questions: [
+    {
+      question: "What type of guideline are you adding?",
+      header: "Type",
+      multiSelect: false,
+      options: [
+        { label: "Convention", description: "Coding style preference (e.g., use functional components)" },
+        { label: "Constraint", description: "Hard rule that must not be violated (e.g., no direct DB access)" },
+        { label: "Learning", description: "Insight from this session (e.g., cache invalidation needs events)" }
+      ]
+    }
+  ]
+});
+
+// Follow-up based on type selection...
+```
+
+## Examples
+
+### Add a Convention
+```bash
+/workflow:session:solidify "Use async/await instead of callbacks" --type convention --category coding_style
+```
+
+Result in `project-guidelines.json`:
+```json
+{
+  "conventions": {
+    "coding_style": ["Use async/await instead of callbacks"]
+  }
+}
+```
+
+### Add an Architectural Constraint
+```bash
+/workflow:session:solidify "No direct DB access from controllers" --type constraint --category architecture
+```
+
+Result:
+```json
+{
+  "constraints": {
+    "architecture": ["No direct DB access from controllers"]
+  }
+}
+```
+
+### Capture a Session Learning
+```bash
+/workflow:session:solidify "Cache invalidation requires event sourcing for consistency" --type learning
+```
+
+Result:
+```json
+{
+  "learnings": [
+    {
+      "date": "2024-12-28",
+      "session_id": "WFS-auth-feature",
+      "insight": "Cache invalidation requires event sourcing for consistency",
+      "category": "architecture"
+    }
+  ]
+}
+```
+
+## Integration with Planning
+
+The `project-guidelines.json` is consumed by:
+
+1. **`/workflow:tools:context-gather`**: Loads guidelines into context-package.json
+2. **`/workflow:plan`**: Passes guidelines to task generation agent
+3. **`task-generate-agent`**: Includes guidelines as "CRITICAL CONSTRAINTS" in system prompt
+
+This ensures all future planning respects solidified rules without users needing to re-state them.
+
+## Error Handling
+
+- **Duplicate Rule**: Warn and skip if exact rule already exists
+- **Invalid Category**: Suggest valid categories for the type
+- **File Corruption**: Backup existing file before modification
+
+## Related Commands
+
+- `/workflow:session:start` - Start a session (may prompt for solidify at end)
+- `/workflow:session:complete` - Complete session (prompts for learnings to solidify)
+- `/workflow:init` - Creates project-guidelines.json scaffold if missing

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

@@ -1,11 +1,13 @@
 ---
 name: start
 description: Discover existing sessions or start new workflow session with intelligent session management and conflict detection
-argument-hint: [--auto|--new] [optional: task description for new session]
+argument-hint: [--type <workflow|review|tdd|test|docs>] [--auto|--new] [optional: task description for new session]
 examples:
   - /workflow:session:start
   - /workflow:session:start --auto "implement OAuth2 authentication"
-  - /workflow:session:start --new "fix login bug"
+  - /workflow:session:start --type review "Code review for auth module"
+  - /workflow:session:start --type tdd --auto "implement user authentication"
+  - /workflow:session:start --type test --new "test payment flow"
 ---
 
 # Start Workflow Session (/workflow:session:start)
@@ -14,31 +16,51 @@ examples:
 Manages workflow sessions with three operation modes: discovery (manual), auto (intelligent), and force-new.
 
 **Dual Responsibility**:
-1. **Project-level initialization** (first-time only): Creates `.workflow/project.json` for feature registry
+1. **Project-level initialization** (first-time only): Creates `.workflow/project-tech.json` for feature registry
 2. **Session-level initialization** (always): Creates session directory structure
 
+## Session Types
+
+The `--type` parameter classifies sessions for CCW dashboard organization:
+
+| Type | Description | Default For |
+|------|-------------|-------------|
+| `workflow` | Standard implementation (default) | `/workflow:plan` |
+| `review` | Code review sessions | `/workflow:review-module-cycle` |
+| `tdd` | TDD-based development | `/workflow:tdd-plan` |
+| `test` | Test generation/fix sessions | `/workflow:test-fix-gen` |
+| `docs` | Documentation sessions | `/memory:docs` |
+
+**Validation**: If `--type` is provided with invalid value, return error:
+```
+ERROR: Invalid session type. Valid types: workflow, review, tdd, test, docs
+```
+
 ## Step 0: Initialize Project State (First-time Only)
 
-**Executed before all modes** - Ensures project-level state file exists by calling `/workflow:init`.
+**Executed before all modes** - Ensures project-level state files exist by calling `/workflow:init`.
 
 ### Check and Initialize
 ```bash
-# Check if project state exists
-bash(test -f .workflow/project.json && echo "EXISTS" || echo "NOT_FOUND")
+# Check if project state exists (both files required)
+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 NOT_FOUND**, delegate to `/workflow:init`:
+**If either NOT_FOUND**, delegate to `/workflow:init`:
 ```javascript
 // Call workflow:init for intelligent project analysis
 SlashCommand({command: "/workflow:init"});
 
 // Wait for init completion
-// project.json will be created with comprehensive project overview
+// project-tech.json and project-guidelines.json will be created
 ```
 
 **Output**:
-- If EXISTS: `PROJECT_STATE: initialized`
-- If NOT_FOUND: Calls `/workflow:init` → creates `.workflow/project.json` with full project analysis
+- If BOTH_EXIST: `PROJECT_STATE: initialized`
+- If NOT_FOUND: Calls `/workflow:init` → creates:
+  - `.workflow/project-tech.json` with full technical analysis
+  - `.workflow/project-guidelines.json` with empty scaffold
 
 **Note**: `/workflow:init` uses cli-explore-agent to build comprehensive project understanding (technology stack, architecture, key components). This step runs once per project. Subsequent executions skip initialization.
 
@@ -86,8 +108,8 @@ bash(mkdir -p .workflow/active/WFS-implement-oauth2-auth/.process)
 bash(mkdir -p .workflow/active/WFS-implement-oauth2-auth/.task)
 bash(mkdir -p .workflow/active/WFS-implement-oauth2-auth/.summaries)
 
-# Create metadata
-bash(echo '{"session_id":"WFS-implement-oauth2-auth","project":"implement OAuth2 auth","status":"planning"}' > .workflow/active/WFS-implement-oauth2-auth/workflow-session.json)
+# Create metadata (include type field, default to "workflow" if not specified)
+bash(echo '{"session_id":"WFS-implement-oauth2-auth","project":"implement OAuth2 auth","status":"planning","type":"workflow","created_at":"2024-12-04T08:00:00Z"}' > .workflow/active/WFS-implement-oauth2-auth/workflow-session.json)
 ```
 
 **Output**: `SESSION_ID: WFS-implement-oauth2-auth`
@@ -143,7 +165,8 @@ bash(mkdir -p .workflow/active/WFS-fix-login-bug/.summaries)
 
 ### Step 3: Create Metadata
 ```bash
-bash(echo '{"session_id":"WFS-fix-login-bug","project":"fix login bug","status":"planning"}' > .workflow/active/WFS-fix-login-bug/workflow-session.json)
+# Include type field from --type parameter (default: "workflow")
+bash(echo '{"session_id":"WFS-fix-login-bug","project":"fix login bug","status":"planning","type":"workflow","created_at":"2024-12-04T08:00:00Z"}' > .workflow/active/WFS-fix-login-bug/workflow-session.json)
 ```
 
 **Output**: `SESSION_ID: WFS-fix-login-bug`

.claude/commands/workflow/status.md

@@ -1,357 +0,0 @@
----
-name: workflow:status
-description: Generate on-demand views for project overview and workflow tasks with optional task-id filtering for detailed view
-argument-hint: "[optional: --project|task-id|--validate|--dashboard]"
----
-
-# Workflow Status Command (/workflow:status)
-
-## Overview
-Generates on-demand views from project and session data. Supports multiple modes:
-1. **Project Overview** (`--project`): Shows completed features and project statistics
-2. **Workflow Tasks** (default): Shows current session task progress
-3. **HTML Dashboard** (`--dashboard`): Generates interactive HTML task board with active and archived sessions
-
-No synchronization needed - all views are calculated from current JSON state.
-
-## Usage
-```bash
-/workflow:status                    # Show current workflow session overview
-/workflow:status --project          # Show project-level feature registry
-/workflow:status impl-1             # Show specific task details
-/workflow:status --validate         # Validate workflow integrity
-/workflow:status --dashboard        # Generate HTML dashboard board
-```
-
-## Execution Process
-
-```
-Input Parsing:
-   └─ Decision (mode detection):
-      ├─ --project flag → Project Overview Mode
-      ├─ --dashboard flag → Dashboard Mode
-      ├─ task-id argument → Task Details Mode
-      └─ No flags → Workflow Session Mode (default)
-
-Project Overview Mode:
-   ├─ Check project.json exists
-   ├─ Read project data
-   ├─ Parse and display overview + features
-   └─ Show recent archived sessions
-
-Workflow Session Mode (default):
-   ├─ Find active session
-   ├─ Load session data
-   ├─ Scan task files
-   └─ Display task progress
-
-Dashboard Mode:
-   ├─ Collect active sessions
-   ├─ Collect archived sessions
-   ├─ Generate HTML from template
-   └─ Write dashboard.html
-```
-
-## Implementation Flow
-
-### Mode Selection
-
-**Check for --project flag**:
-- If `--project` flag present → Execute **Project Overview Mode**
-- Otherwise → Execute **Workflow Session Mode** (default)
-
-## Project Overview Mode
-
-### Step 1: Check Project State
-```bash
-bash(test -f .workflow/project.json && echo "EXISTS" || echo "NOT_FOUND")
-```
-
-**If NOT_FOUND**:
-```
-No project state found.
-Run /workflow:session:start to initialize project.
-```
-
-### Step 2: Read Project Data
-```bash
-bash(cat .workflow/project.json)
-```
-
-### Step 3: Parse and Display
-
-**Data Processing**:
-```javascript
-const projectData = JSON.parse(Read('.workflow/project.json'));
-const features = projectData.features || [];
-const stats = projectData.statistics || {};
-const overview = projectData.overview || null;
-
-// Sort features by implementation date (newest first)
-const sortedFeatures = features.sort((a, b) =>
-  new Date(b.implemented_at) - new Date(a.implemented_at)
-);
-```
-
-**Output Format** (with extended overview):
-```
-## Project: ${projectData.project_name}
-Initialized: ${projectData.initialized_at}
-
-${overview ? `
-### Overview
-${overview.description}
-
-**Technology Stack**:
-${overview.technology_stack.languages.map(l => `- ${l.name}${l.primary ? ' (primary)' : ''}: ${l.file_count} files`).join('\n')}
-Frameworks: ${overview.technology_stack.frameworks.join(', ')}
-
-**Architecture**:
-Style: ${overview.architecture.style}
-Patterns: ${overview.architecture.patterns.join(', ')}
-
-**Key Components** (${overview.key_components.length}):
-${overview.key_components.map(c => `- ${c.name} (${c.path})\n  ${c.description}`).join('\n')}
-
-**Metrics**:
-- Files: ${overview.metrics.total_files}
-- Lines of Code: ${overview.metrics.lines_of_code}
-- Complexity: ${overview.metrics.complexity}
-
----
-` : ''}
-
-### Completed Features (${stats.total_features})
-
-${sortedFeatures.map(f => `
-- ${f.title} (${f.timeline?.implemented_at || f.implemented_at})
-  ${f.description}
-  Tags: ${f.tags?.join(', ') || 'none'}
-  Session: ${f.traceability?.session_id || f.session_id}
-  Archive: ${f.traceability?.archive_path || 'unknown'}
-  ${f.traceability?.commit_hash ? `Commit: ${f.traceability.commit_hash}` : ''}
-`).join('\n')}
-
-### Project Statistics
-- Total Features: ${stats.total_features}
-- Total Sessions: ${stats.total_sessions}
-- Last Updated: ${stats.last_updated}
-
-### Quick Access
-- View session details: /workflow:status
-- Archive query: jq '.archives[] | select(.session_id == "SESSION_ID")' .workflow/archives/manifest.json
-- Documentation: .workflow/docs/${projectData.project_name}/
-
-### Query Commands
-# Find by tag
-cat .workflow/project.json | jq '.features[] | select(.tags[] == "auth")'
-
-# View archive
-cat ${feature.traceability.archive_path}/IMPL_PLAN.md
-
-# List all tags
-cat .workflow/project.json | jq -r '.features[].tags[]' | sort -u
-```
-
-**Empty State**:
-```
-## Project: ${projectData.project_name}
-Initialized: ${projectData.initialized_at}
-
-No features completed yet.
-
-Complete your first workflow session to add features:
-1. /workflow:plan "feature description"
-2. /workflow:execute
-3. /workflow:session:complete
-```
-
-### Step 4: Show Recent Sessions (Optional)
-
-```bash
-# List 5 most recent archived sessions
-bash(ls -1t .workflow/archives/WFS-* 2>/dev/null | head -5 | xargs -I {} basename {})
-```
-
-**Output**:
-```
-### Recent Sessions
-- WFS-auth-system (archived)
-- WFS-payment-flow (archived)
-- WFS-user-dashboard (archived)
-
-Use /workflow:session:complete to archive current session.
-```
-
-## Workflow Session Mode (Default)
-
-### Step 1: Find Active Session
-```bash
-find .workflow/active/ -name "WFS-*" -type d 2>/dev/null | head -1
-```
-
-### Step 2: Load Session Data
-```bash
-cat .workflow/active/WFS-session/workflow-session.json
-```
-
-### Step 3: Scan Task Files
-```bash
-find .workflow/active/WFS-session/.task/ -name "*.json" -type f 2>/dev/null
-```
-
-### Step 4: Generate Task Status
-```bash
-cat .workflow/active/WFS-session/.task/impl-1.json | jq -r '.status'
-```
-
-### Step 5: Count Task Progress
-```bash
-find .workflow/active/WFS-session/.task/ -name "*.json" -type f | wc -l
-find .workflow/active/WFS-session/.summaries/ -name "*.md" -type f 2>/dev/null | wc -l
-```
-
-### Step 6: Display Overview
-```markdown
-# Workflow Overview
-**Session**: WFS-session-name
-**Progress**: 3/8 tasks completed
-
-## Active Tasks
-- [IN PROGRESS] impl-1: Current task in progress
-- [ ] impl-2: Next pending task
-
-## Completed Tasks
-- [COMPLETED] impl-0: Setup completed
-```
-
-## Dashboard Mode (HTML Board)
-
-### Step 1: Check for --dashboard flag
-```bash
-# If --dashboard flag present → Execute Dashboard Mode
-```
-
-### Step 2: Collect Workflow Data
-
-**Collect Active Sessions**:
-```bash
-# Find all active sessions
-find .workflow/active/ -name "WFS-*" -type d 2>/dev/null
-
-# For each active session, read metadata and tasks
-for session in $(find .workflow/active/ -name "WFS-*" -type d 2>/dev/null); do
-  cat "$session/workflow-session.json"
-  find "$session/.task/" -name "*.json" -type f 2>/dev/null
-done
-```
-
-**Collect Archived Sessions**:
-```bash
-# Find all archived sessions
-find .workflow/archives/ -name "WFS-*" -type d 2>/dev/null
-
-# Read manifest if exists
-cat .workflow/archives/manifest.json 2>/dev/null
-
-# For each archived session, read metadata
-for archive in $(find .workflow/archives/ -name "WFS-*" -type d 2>/dev/null); do
-  cat "$archive/workflow-session.json" 2>/dev/null
-  # Count completed tasks
-  find "$archive/.task/" -name "*.json" -type f 2>/dev/null | wc -l
-done
-```
-
-### Step 3: Process and Structure Data
-
-**Build data structure for dashboard**:
-```javascript
-const dashboardData = {
-  activeSessions: [],
-  archivedSessions: [],
-  generatedAt: new Date().toISOString()
-};
-
-// Process active sessions
-for each active_session in active_sessions:
-  const sessionData = JSON.parse(Read(active_session/workflow-session.json));
-  const tasks = [];
-
-  // Load all tasks for this session
-  for each task_file in find(active_session/.task/*.json):
-    const taskData = JSON.parse(Read(task_file));
-    tasks.push({
-      task_id: taskData.task_id,
-      title: taskData.title,
-      status: taskData.status,
-      type: taskData.type
-    });
-
-  dashboardData.activeSessions.push({
-    session_id: sessionData.session_id,
-    project: sessionData.project,
-    status: sessionData.status,
-    created_at: sessionData.created_at || sessionData.initialized_at,
-    tasks: tasks
-  });
-
-// Process archived sessions
-for each archived_session in archived_sessions:
-  const sessionData = JSON.parse(Read(archived_session/workflow-session.json));
-  const taskCount = bash(find archived_session/.task/*.json | wc -l);
-
-  dashboardData.archivedSessions.push({
-    session_id: sessionData.session_id,
-    project: sessionData.project,
-    archived_at: sessionData.completed_at || sessionData.archived_at,
-    taskCount: parseInt(taskCount),
-    archive_path: archived_session
-  });
-```
-
-### Step 4: Generate HTML from Template
-
-**Load template and inject data**:
-```javascript
-// Read the HTML template
-const template = Read("~/.claude/templates/workflow-dashboard.html");
-
-// Prepare data for injection
-const dataJson = JSON.stringify(dashboardData, null, 2);
-
-// Replace placeholder with actual data
-const htmlContent = template.replace('{{WORKFLOW_DATA}}', dataJson);
-
-// Ensure .workflow directory exists
-bash(mkdir -p .workflow);
-```
-
-### Step 5: Write HTML File
-
-```bash
-# Write the generated HTML to .workflow/dashboard.html
-Write({
-  file_path: ".workflow/dashboard.html",
-  content: htmlContent
-})
-```
-
-### Step 6: Display Success Message
-
-```markdown
-Dashboard generated successfully!
-
-Location: .workflow/dashboard.html
-
-Open in browser:
-  file://$(pwd)/.workflow/dashboard.html
-
-Features:
-- 📊 Active sessions overview
-- 📦 Archived sessions history
-- 🔍 Search and filter
-- 📈 Progress tracking
-- 🎨 Dark/light theme
-
-Refresh data: Re-run /workflow:status --dashboard
-```

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

@@ -1,7 +1,7 @@
 ---
 name: tdd-plan
 description: TDD workflow planning with Red-Green-Refactor task chain generation, test-first development structure, and cycle tracking
-argument-hint: "[--cli-execute] \"feature description\"|file.md"
+argument-hint: "\"feature description\"|file.md"
 allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*)
 ---
 
@@ -9,15 +9,13 @@ allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*)
 
 ## Coordinator Role
 
-**This command is a pure orchestrator**: Execute 6 slash commands in sequence, parse outputs, pass context, and ensure complete TDD workflow creation with Red-Green-Refactor task generation.
+**This command is a pure orchestrator**: Executes 6 slash commands in sequence, parse outputs, pass context, and ensure complete TDD workflow creation with Red-Green-Refactor task generation.
 
-**Execution Modes**:
-- **Agent Mode** (default): Use `/workflow:tools:task-generate-tdd` (autonomous agent-driven)
-- **CLI Mode** (`--cli-execute`): Use `/workflow:tools:task-generate-tdd --cli-execute` (Gemini/Qwen)
+**CLI Tool Selection**: CLI tool usage is determined semantically from user's task description. Include "use Codex/Gemini/Qwen" in your request for CLI execution.
 
 **Task Attachment Model**:
-- SlashCommand invocation **expands workflow** by attaching sub-tasks to current TodoWrite
-- When a sub-command is invoked (e.g., `/workflow:tools:test-context-gather`), its internal tasks are attached to the orchestrator's TodoWrite
+- SlashCommand execute **expands workflow** by attaching sub-tasks to current TodoWrite
+- When executing a sub-command (e.g., `/workflow:tools:test-context-gather`), its internal tasks are attached to the orchestrator's TodoWrite
 - Orchestrator **executes these attached tasks** sequentially
 - After completion, attached tasks are **collapsed** back to high-level phase summary
 - This is **task expansion**, not external delegation
@@ -30,19 +28,62 @@ allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*)
 
 ## Core Rules
 
-1. **Start Immediately**: First action is TodoWrite initialization, second action is Phase 1 execution
+1. **Start Immediately**: First action is TodoWrite initialization, second action is execute Phase 1
 2. **No Preliminary Analysis**: Do not read files before Phase 1
 3. **Parse Every Output**: Extract required data for next phase
 4. **Auto-Continue via TodoList**: Check TodoList status to execute next pending phase automatically
 5. **Track Progress**: Update TodoWrite dynamically with task attachment/collapse pattern
 6. **TDD Context**: All descriptions include "TDD:" prefix
-7. **Task Attachment Model**: SlashCommand invocation **attaches** sub-tasks to current workflow. Orchestrator **executes** these attached tasks itself, then **collapses** them after completion
+7. **Task Attachment Model**: SlashCommand execute **attaches** sub-tasks to current workflow. Orchestrator **executes** these attached tasks itself, then **collapses** them after completion
 8. **⚠️ CRITICAL: DO NOT STOP**: Continuous multi-phase workflow. After executing all attached tasks, immediately collapse them and execute next phase
 
+## TDD Compliance Requirements
+
+### The Iron Law
+
+```
+NO PRODUCTION CODE WITHOUT A FAILING TEST FIRST
+```
+
+**Enforcement Method**:
+- Phase 5: `implementation_approach` includes test-first steps (Red → Green → Refactor)
+- Green phase: Includes test-fix-cycle configuration (max 3 iterations)
+- Auto-revert: Triggered when max iterations reached without passing tests
+
+**Verification**: Phase 6 validates Red-Green-Refactor structure in all generated tasks
+
+### TDD Compliance Checkpoint
+
+| Checkpoint | Validation Phase | Evidence Required |
+|------------|------------------|-------------------|
+| Test-first structure | Phase 5 | `implementation_approach` has 3 steps |
+| Red phase exists | Phase 6 | Step 1: `tdd_phase: "red"` |
+| Green phase with test-fix | Phase 6 | Step 2: `tdd_phase: "green"` + test-fix-cycle |
+| Refactor phase exists | Phase 6 | Step 3: `tdd_phase: "refactor"` |
+
+### Core TDD Principles (from ref skills)
+
+**Red Flags - STOP and Reassess**:
+- Code written before test
+- Test passes immediately (no Red phase witnessed)
+- Cannot explain why test should fail
+- "Just this once" rationalization
+- "Tests after achieve same goals" thinking
+
+**Why Order Matters**:
+- Tests written after code pass immediately → proves nothing
+- Test-first forces edge case discovery before implementation
+- Tests-after verify what was built, not what's required
+
 ## 6-Phase Execution (with Conflict Resolution)
 
 ### Phase 1: Session Discovery
-**Command**: `/workflow:session:start --auto "TDD: [structured-description]"`
+
+**Step 1.1: Execute** - Session discovery and initialization
+
+```javascript
+SlashCommand(command="/workflow:session:start --type tdd --auto \"TDD: [structured-description]\"")
+```
 
 **TDD Structured Format**:
 ```
@@ -62,7 +103,12 @@ TEST_FOCUS: [Test scenarios]
 ---
 
 ### Phase 2: Context Gathering
-**Command**: `/workflow:tools:context-gather --session [sessionId] "TDD: [structured-description]"`
+
+**Step 2.1: Execute** - Context gathering and analysis
+
+```javascript
+SlashCommand(command="/workflow:tools:context-gather --session [sessionId] \"TDD: [structured-description]\"")
+```
 
 **Use Same Structured Description**: Pass the same structured format from Phase 1
 
@@ -83,7 +129,12 @@ TEST_FOCUS: [Test scenarios]
 ---
 
 ### Phase 3: Test Coverage Analysis
-**Command**: `/workflow:tools:test-context-gather --session [sessionId]`
+
+**Step 3.1: Execute** - Test coverage analysis and framework detection
+
+```javascript
+SlashCommand(command="/workflow:tools:test-context-gather --session [sessionId]")
+```
 
 **Purpose**: Analyze existing codebase for:
 - Existing test patterns and conventions
@@ -95,9 +146,9 @@ TEST_FOCUS: [Test scenarios]
 
 
 
-<!-- TodoWrite: When test-context-gather invoked, INSERT 3 test-context-gather tasks -->
+<!-- TodoWrite: When test-context-gather executed, INSERT 3 test-context-gather tasks -->
 
-**TodoWrite Update (Phase 3 SlashCommand invoked - tasks attached)**:
+**TodoWrite Update (Phase 3 SlashCommand executed - tasks attached)**:
 ```json
 [
   {"content": "Phase 1: Session Discovery", "status": "completed", "activeForm": "Executing session discovery"},
@@ -111,7 +162,7 @@ TEST_FOCUS: [Test scenarios]
 ]
 ```
 
-**Note**: SlashCommand invocation **attaches** test-context-gather's 3 tasks. Orchestrator **executes** these tasks.
+**Note**: SlashCommand execute **attaches** test-context-gather's 3 tasks. Orchestrator **executes** these tasks.
 
 **Next Action**: Tasks attached → **Execute Phase 3.1-3.3** sequentially
 
@@ -138,7 +189,11 @@ TEST_FOCUS: [Test scenarios]
 
 **Trigger**: Only execute when context-package.json indicates conflict_risk is "medium" or "high"
 
-**Command**: `SlashCommand(command="/workflow:tools:conflict-resolution --session [sessionId] --context [contextPath]")`
+**Step 4.1: Execute** - Conflict detection and resolution
+
+```javascript
+SlashCommand(command="/workflow:tools:conflict-resolution --session [sessionId] --context [contextPath]")
+```
 
 **Input**:
 - sessionId from Phase 1
@@ -147,18 +202,18 @@ TEST_FOCUS: [Test scenarios]
 
 **Parse Output**:
 - Extract: Execution status (success/skipped/failed)
-- Verify: CONFLICT_RESOLUTION.md file path (if executed)
+- Verify: conflict-resolution.json file path (if executed)
 
 **Validation**:
-- File `.workflow/active/[sessionId]/.process/CONFLICT_RESOLUTION.md` exists (if executed)
+- File `.workflow/active/[sessionId]/.process/conflict-resolution.json` exists (if executed)
 
 **Skip Behavior**:
 - If conflict_risk is "none" or "low", skip directly to Phase 5
 - Display: "No significant conflicts detected, proceeding to TDD task generation"
 
-<!-- TodoWrite: If conflict_risk ≥ medium, INSERT 3 conflict-resolution tasks -->
+<!-- TodoWrite: If conflict_risk ≥ medium, INSERT 3 conflict-resolution tasks when executed -->
 
-**TodoWrite Update (Phase 4 SlashCommand invoked - tasks attached, if conflict_risk ≥ medium)**:
+**TodoWrite Update (Phase 4 SlashCommand executed - tasks attached, if conflict_risk ≥ medium)**:
 ```json
 [
   {"content": "Phase 1: Session Discovery", "status": "completed", "activeForm": "Executing session discovery"},
@@ -166,14 +221,14 @@ TEST_FOCUS: [Test scenarios]
   {"content": "Phase 3: Test Coverage Analysis", "status": "completed", "activeForm": "Executing test coverage analysis"},
   {"content": "Phase 4: Conflict Resolution", "status": "in_progress", "activeForm": "Executing conflict resolution"},
   {"content": "  → Detect conflicts with CLI analysis", "status": "in_progress", "activeForm": "Detecting conflicts"},
-  {"content": "  → Present conflicts to user", "status": "pending", "activeForm": "Presenting conflicts"},
+  {"content": "  → Log and analyze detected conflicts", "status": "pending", "activeForm": "Analyzing conflicts"},
   {"content": "  → Apply resolution strategies", "status": "pending", "activeForm": "Applying resolution strategies"},
   {"content": "Phase 5: TDD Task Generation", "status": "pending", "activeForm": "Executing TDD task generation"},
   {"content": "Phase 6: TDD Structure Validation", "status": "pending", "activeForm": "Validating TDD structure"}
 ]
 ```
 
-**Note**: SlashCommand invocation **attaches** conflict-resolution's 3 tasks. Orchestrator **executes** these tasks.
+**Note**: SlashCommand execute **attaches** conflict-resolution's 3 tasks. Orchestrator **executes** these tasks.
 
 **Next Action**: Tasks attached → **Execute Phase 4.1-4.3** sequentially
 
@@ -198,7 +253,13 @@ TEST_FOCUS: [Test scenarios]
 **Memory State Check**:
 - Evaluate current context window usage and memory state
 - If memory usage is high (>110K tokens or approaching context limits):
-  - **Command**: `SlashCommand(command="/compact")`
+
+  **Step 4.5: Execute** - Memory compaction
+
+  ```javascript
+  SlashCommand(command="/compact")
+  ```
+
   - This optimizes memory before proceeding to Phase 5
 - Memory compaction is particularly important after analysis phase which may generate extensive documentation
 - Ensures optimal performance and prevents context overflow
@@ -206,11 +267,20 @@ TEST_FOCUS: [Test scenarios]
 ---
 
 ### Phase 5: TDD Task Generation
-**Command**:
-- Agent Mode (default): `/workflow:tools:task-generate-tdd --session [sessionId]`
-- CLI Mode (`--cli-execute`): `/workflow:tools:task-generate-tdd --session [sessionId] --cli-execute`
 
-**Parse**: Extract feature count, task count (not chain count - tasks now contain internal TDD cycles)
+**Step 5.1: Execute** - TDD task generation via action-planning-agent with Phase 0 user configuration
+
+```javascript
+SlashCommand(command="/workflow:tools:task-generate-tdd --session [sessionId]")
+```
+
+**Note**: Phase 0 now includes:
+- Supplementary materials collection (file paths or inline content)
+- Execution method preference (Agent/Hybrid/CLI)
+- CLI tool preference (Codex/Gemini/Qwen/Auto)
+- These preferences are passed to agent for task generation
+
+**Parse**: Extract feature count, task count (not chain count - tasks now contain internal TDD cycles), CLI execution IDs assigned
 
 **Validate**:
 - IMPL_PLAN.md exists (unified plan with TDD Implementation Tasks section)
@@ -218,14 +288,30 @@ TEST_FOCUS: [Test scenarios]
 - TODO_LIST.md exists with internal TDD phase indicators
 - Each IMPL task includes:
   - `meta.tdd_workflow: true`
-  - `flow_control.implementation_approach` with 3 steps (red/green/refactor)
+  - `meta.cli_execution_id: {session_id}-{task_id}`
+  - `meta.cli_execution: { "strategy": "new|resume|fork|merge_fork", ... }`
+  - `flow_control.implementation_approach` with exactly 3 steps (red/green/refactor)
   - Green phase includes test-fix-cycle configuration
+  - `context.focus_paths`: absolute or clear relative paths (enhanced with exploration critical_files)
+  - `flow_control.pre_analysis`: includes exploration integration_points analysis
 - IMPL_PLAN.md contains workflow_type: "tdd" in frontmatter
-- Task count ≤10 (compliance with task limit)
+- User configuration applied:
+  - If executionMethod == "cli" or "hybrid": command field added to steps
+  - CLI tool preference reflected in execution guidance
+- Task count ≤18 (compliance with hard limit)
 
-<!-- TodoWrite: When task-generate-tdd invoked, INSERT 3 task-generate-tdd tasks -->
+**Red Flag Detection** (Non-Blocking Warnings):
+- Task count >18: `⚠️ Task count exceeds hard limit - request re-scope`
+- Missing cli_execution_id: `⚠️ Task lacks CLI execution ID for resume support`
+- Missing test-fix-cycle: `⚠️ Green phase lacks auto-revert configuration`
+- Generic task names: `⚠️ Vague task names suggest unclear TDD cycles`
+- Missing focus_paths: `⚠️ Task lacks clear file scope for implementation`
 
-**TodoWrite Update (Phase 5 SlashCommand invoked - tasks attached)**:
+**Action**: Log warnings to `.workflow/active/[sessionId]/.process/tdd-warnings.log` (non-blocking)
+
+<!-- TodoWrite: When task-generate-tdd executed, INSERT 3 task-generate-tdd tasks -->
+
+**TodoWrite Update (Phase 5 SlashCommand executed - tasks attached)**:
 ```json
 [
   {"content": "Phase 1: Session Discovery", "status": "completed", "activeForm": "Executing session discovery"},
@@ -239,7 +325,7 @@ TEST_FOCUS: [Test scenarios]
 ]
 ```
 
-**Note**: SlashCommand invocation **attaches** task-generate-tdd's 3 tasks. Orchestrator **executes** these tasks. Each generated IMPL task will contain internal Red-Green-Refactor cycle.
+**Note**: SlashCommand execute **attaches** task-generate-tdd's 3 tasks. Orchestrator **executes** these tasks. Each generated IMPL task will contain internal Red-Green-Refactor cycle.
 
 **Next Action**: Tasks attached → **Execute Phase 5.1-5.3** sequentially
 
@@ -265,14 +351,59 @@ TEST_FOCUS: [Test scenarios]
 1. Each task contains complete TDD workflow (Red-Green-Refactor internally)
 2. Task structure validation:
    - `meta.tdd_workflow: true` in all IMPL tasks
+   - `meta.cli_execution_id` present (format: {session_id}-{task_id})
+   - `meta.cli_execution` strategy assigned (new/resume/fork/merge_fork)
    - `flow_control.implementation_approach` has exactly 3 steps
    - Each step has correct `tdd_phase`: "red", "green", "refactor"
+   - `context.focus_paths` are absolute or clear relative paths
+   - `flow_control.pre_analysis` includes exploration integration analysis
 3. Dependency validation:
    - Sequential features: IMPL-N depends_on ["IMPL-(N-1)"] if needed
    - Complex features: IMPL-N.M depends_on ["IMPL-N.(M-1)"] for subtasks
+   - CLI execution strategies correctly assigned based on dependency graph
 4. Agent assignment: All IMPL tasks use @code-developer
 5. Test-fix cycle: Green phase step includes test-fix-cycle logic with max_iterations
-6. Task count: Total tasks ≤10 (simple + subtasks)
+6. Task count: Total tasks ≤18 (simple + subtasks hard limit)
+7. User configuration:
+   - Execution method choice reflected in task structure
+   - CLI tool preference documented in implementation guidance (if CLI selected)
+
+**Red Flag Checklist** (from TDD best practices):
+- [ ] No tasks skip Red phase (`tdd_phase: "red"` exists in step 1)
+- [ ] Test files referenced in Red phase (explicit paths, not placeholders)
+- [ ] Green phase has test-fix-cycle with `max_iterations` configured
+- [ ] Refactor phase has clear completion criteria
+
+**Non-Compliance Warning Format**:
+```
+⚠️ TDD Red Flag: [issue description]
+   Task: [IMPL-N]
+   Recommendation: [action to fix]
+```
+
+**Evidence Gathering** (Before Completion Claims):
+
+```bash
+# Verify session artifacts exist
+ls -la .workflow/active/[sessionId]/{IMPL_PLAN.md,TODO_LIST.md}
+ls -la .workflow/active/[sessionId]/.task/IMPL-*.json
+
+# Count generated artifacts
+echo "IMPL tasks: $(ls .workflow/active/[sessionId]/.task/IMPL-*.json 2>/dev/null | wc -l)"
+
+# Sample task structure verification (first task)
+jq '{id, tdd: .meta.tdd_workflow, cli_id: .meta.cli_execution_id, phases: [.flow_control.implementation_approach[].tdd_phase]}' \
+  "$(ls .workflow/active/[sessionId]/.task/IMPL-*.json | head -1)"
+```
+
+**Evidence Required Before Summary**:
+| Evidence Type | Verification Method | Pass Criteria |
+|---------------|---------------------|---------------|
+| File existence | `ls -la` artifacts | All files present |
+| Task count | Count IMPL-*.json | Count matches claims (≤18) |
+| TDD structure | jq sample extraction | Shows red/green/refactor + cli_execution_id |
+| CLI execution IDs | jq extraction | All tasks have cli_execution_id assigned |
+| Warning log | Check tdd-warnings.log | Logged (may be empty) |
 
 **Return Summary**:
 ```
@@ -284,7 +415,7 @@ Total tasks: [M] (1 task per simple feature + subtasks for complex features)
 Task breakdown:
 - Simple features: [K] tasks (IMPL-1 to IMPL-K)
 - Complex features: [L] features with [P] subtasks
-- Total task count: [M] (within 10-task limit)
+- Total task count: [M] (within 18-task hard limit)
 
 Structure:
 - IMPL-1: {Feature 1 Name} (Internal: Red → Green → Refactor)
@@ -298,19 +429,31 @@ Plans generated:
 - Unified Implementation Plan: .workflow/active/[sessionId]/IMPL_PLAN.md
   (includes TDD Implementation Tasks section with workflow_type: "tdd")
 - Task List: .workflow/active/[sessionId]/TODO_LIST.md
-  (with internal TDD phase indicators)
+  (with internal TDD phase indicators and CLI execution strategies)
+- Task JSONs: .workflow/active/[sessionId]/.task/IMPL-*.json
+  (with cli_execution_id and execution strategies for resume support)
 
 TDD Configuration:
 - Each task contains complete Red-Green-Refactor cycle
 - Green phase includes test-fix cycle (max 3 iterations)
 - Auto-revert on max iterations reached
+- CLI execution strategies: new/resume/fork/merge_fork based on dependency graph
+
+User Configuration Applied:
+- Execution Method: [agent|hybrid|cli]
+- CLI Tool Preference: [codex|gemini|qwen|auto]
+- Supplementary Materials: [included|none]
+- Task generation follows cli-tools-usage.md guidelines
+
+⚠️ ACTION REQUIRED: Before execution, ensure you understand WHY each Red phase test is expected to fail.
+   This is crucial for valid TDD - if you don't know why the test fails, you can't verify it tests the right thing.
 
 Recommended Next Steps:
-1. /workflow:action-plan-verify --session [sessionId]  # Verify TDD plan quality and dependencies
-2. /workflow:execute --session [sessionId]  # Start TDD execution
+1. /workflow:plan-verify --session [sessionId]  # Verify TDD plan quality and dependencies
+2. /workflow:execute --session [sessionId]  # Start TDD execution with CLI strategies
 3. /workflow:tdd-verify [sessionId]  # Post-execution TDD compliance check
 
-Quality Gate: Consider running /workflow:action-plan-verify to validate TDD task structure and dependencies
+Quality Gate: Consider running /workflow:plan-verify to validate TDD task structure, dependencies, and CLI execution strategies
 ```
 
 ## TodoWrite Pattern
@@ -319,7 +462,7 @@ Quality Gate: Consider running /workflow:action-plan-verify to validate TDD task
 
 ### Key Principles
 
-1. **Task Attachment** (when SlashCommand invoked):
+1. **Task Attachment** (when SlashCommand executed):
    - Sub-command's internal tasks are **attached** to orchestrator's TodoWrite
    - Example: `/workflow:tools:test-context-gather` attaches 3 sub-tasks (Phase 3.1, 3.2, 3.3)
    - First attached task marked as `in_progress`, others as `pending`
@@ -336,7 +479,7 @@ Quality Gate: Consider running /workflow:action-plan-verify to validate TDD task
    - No user intervention required between phases
    - TodoWrite dynamically reflects current execution state
 
-**Lifecycle Summary**: Initial pending tasks → Phase invoked (tasks ATTACHED) → Sub-tasks executed sequentially → Phase completed (tasks COLLAPSED to summary) → Next phase begins (conditional Phase 4 if conflict_risk ≥ medium) → Repeat until all phases complete.
+**Lifecycle Summary**: Initial pending tasks → Phase executed (tasks ATTACHED) → Sub-tasks executed sequentially → Phase completed (tasks COLLAPSED to summary) → Next phase begins (conditional Phase 4 if conflict_risk ≥ medium) → Repeat until all phases complete.
 
 ### TDD-Specific Features
 
@@ -372,9 +515,9 @@ TDD Workflow Orchestrator
 │  IF conflict_risk ≥ medium:
 │  └─ /workflow:tools:conflict-resolution             ← ATTACHED (3 tasks)
 │     ├─ Phase 4.1: Detect conflicts with CLI
-│     ├─ Phase 4.2: Present conflicts to user
+│     ├─ Phase 4.2: Log and analyze detected conflicts
 │     └─ Phase 4.3: Apply resolution strategies
-│     └─ Returns: CONFLICT_RESOLUTION.md              ← COLLAPSED
+│     └─ Returns: conflict-resolution.json            ← COLLAPSED
 │  ELSE:
 │  └─ Skip to Phase 5
 │
@@ -388,7 +531,7 @@ TDD Workflow Orchestrator
 │
 └─ Phase 6: TDD Structure Validation
    └─ Internal validation + summary returned
-   └─ Recommend: /workflow:action-plan-verify
+   └─ Recommend: /workflow:plan-verify
 
 Key Points:
 • ← ATTACHED: SlashCommand attaches sub-tasks to orchestrator TodoWrite
@@ -411,6 +554,36 @@ Convert user input to TDD-structured format:
 - **Command failure**: Keep phase in_progress, report error
 - **TDD validation failure**: Report incomplete chains or wrong dependencies
 
+### TDD Warning Patterns
+
+| Pattern | Warning Message | Recommended Action |
+|---------|----------------|-------------------|
+| Task count >10 | High task count detected | Consider splitting into multiple sessions |
+| Missing test-fix-cycle | Green phase lacks auto-revert | Add `max_iterations: 3` to task config |
+| Red phase missing test path | Test file path not specified | Add explicit test file paths |
+| Generic task names | Vague names like "Add feature" | Use specific behavior descriptions |
+| No refactor criteria | Refactor phase lacks completion criteria | Define clear refactor scope |
+
+### Non-Blocking Warning Policy
+
+**All warnings are advisory** - they do not halt execution:
+1. Warnings logged to `.process/tdd-warnings.log`
+2. Summary displayed in Phase 6 output
+3. User decides whether to address before `/workflow:execute`
+
+### Error Handling Quick Reference
+
+| Error Type | Detection | Recovery Action |
+|------------|-----------|-----------------|
+| Parsing failure | Empty/malformed output | Retry once, then report |
+| Missing context-package | File read error | Re-run `/workflow:tools:context-gather` |
+| Invalid task JSON | jq parse error | Report malformed file path |
+| Task count exceeds 18 | Count validation ≥19 | Request re-scope, split into multiple sessions |
+| Missing cli_execution_id | All tasks lack ID | Regenerate tasks with phase 0 user config |
+| Test-context missing | File not found | Re-run `/workflow:tools:test-context-gather` |
+| Phase timeout | No response | Retry phase, check CLI connectivity |
+| CLI tool not available | Tool not in cli-tools.json | Fall back to alternative preferred tool |
+
 ## Related Commands
 
 **Prerequisite Commands**:
@@ -422,12 +595,36 @@ Convert user input to TDD-structured format:
 - `/workflow:tools:test-context-gather` - Phase 3: Analyze existing test patterns and coverage
 - `/workflow:tools:conflict-resolution` - Phase 4: Detect and resolve conflicts (auto-triggered if conflict_risk ≥ medium)
 - `/compact` - Phase 4: Memory optimization (if context approaching limits)
-- `/workflow:tools:task-generate-tdd` - Phase 5: Generate TDD tasks with agent-driven approach (default, autonomous)
-- `/workflow:tools:task-generate-tdd --cli-execute` - Phase 5: Generate TDD tasks with CLI tools (Gemini/Qwen, when `--cli-execute` flag used)
+- `/workflow:tools:task-generate-tdd` - Phase 5: Generate TDD tasks (CLI tool usage determined semantically)
 
 **Follow-up Commands**:
-- `/workflow:action-plan-verify` - Recommended: Verify TDD plan quality and structure before execution
+- `/workflow:plan-verify` - Recommended: Verify TDD plan quality and structure before execution
 - `/workflow:status` - Review TDD task breakdown
 - `/workflow:execute` - Begin TDD implementation
 - `/workflow:tdd-verify` - Post-execution: Verify TDD compliance and generate quality report
 
+## Next Steps Decision Table
+
+| Situation | Recommended Command | Purpose |
+|-----------|---------------------|---------|
+| First time planning | `/workflow:plan-verify` | Validate task structure before execution |
+| Warnings in tdd-warnings.log | Review log, refine tasks | Address Red Flags before proceeding |
+| High task count warning | Consider `/workflow:session:start` | Split into focused sub-sessions |
+| Ready to implement | `/workflow:execute` | Begin TDD Red-Green-Refactor cycles |
+| After implementation | `/workflow:tdd-verify` | Generate TDD compliance report |
+| Need to review tasks | `/workflow:status --session [id]` | Inspect current task breakdown |
+| Plan needs changes | `/task:replan` | Update task JSON with new requirements |
+
+### TDD Workflow State Transitions
+
+```
+/workflow:tdd-plan
+        ↓
+[Planning Complete] ──→ /workflow:plan-verify (recommended)
+        ↓
+[Verified/Ready] ─────→ /workflow:execute
+        ↓
+[Implementation] ─────→ /workflow:tdd-verify (post-execution)
+        ↓
+[Quality Report] ─────→ Done or iterate
+```

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

@@ -1,200 +1,301 @@
 ---
 name: tdd-verify
-description: Verify TDD workflow compliance against Red-Green-Refactor cycles, generate quality report with coverage analysis
-
-argument-hint: "[optional: WFS-session-id]"
-allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(gemini:*)
+description: Verify TDD workflow compliance against Red-Green-Refactor cycles. Generates quality report with coverage analysis and quality gate recommendation. Orchestrates sub-commands for comprehensive validation.
+argument-hint: "[optional: --session WFS-session-id]"
+allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Write(*), Bash(*), Glob(*)
 ---
 
 # TDD Verification Command (/workflow:tdd-verify)
 
+## Goal
+
+Verify TDD workflow execution quality by validating Red-Green-Refactor cycle compliance, test coverage completeness, and task chain structure integrity. This command orchestrates multiple analysis phases and generates a comprehensive compliance report with quality gate recommendation.
+
+**Output**: A structured Markdown report saved to `.workflow/active/WFS-{session}/TDD_COMPLIANCE_REPORT.md` containing:
+- Executive summary with compliance score and quality gate recommendation
+- Task chain validation (TEST → IMPL → REFACTOR structure)
+- Test coverage metrics (line, branch, function)
+- Red-Green-Refactor cycle verification
+- Best practices adherence assessment
+- Actionable improvement recommendations
+
+## Operating Constraints
+
+**ORCHESTRATOR MODE**:
+- This command coordinates multiple sub-commands (`/workflow:tools:tdd-coverage-analysis`, `ccw cli`)
+- MAY write output files: TDD_COMPLIANCE_REPORT.md (primary report), .process/*.json (intermediate artifacts)
+- MUST NOT modify source task files or implementation code
+- MUST NOT create or delete tasks in the workflow
+
+**Quality Gate Authority**: The compliance report provides a binding recommendation (BLOCK_MERGE / REQUIRE_FIXES / PROCEED_WITH_CAVEATS / APPROVED) based on objective compliance criteria.
+
 ## Coordinator Role
 
 **This command is a pure orchestrator**: Execute 4 phases to verify TDD workflow compliance, test coverage, and Red-Green-Refactor cycle execution.
 
 ## Core Responsibilities
-- Verify TDD task chain structure
-- Analyze test coverage
-- Validate TDD cycle execution
-- Generate compliance report
+- Verify TDD task chain structure (TEST → IMPL → REFACTOR)
+- Analyze test coverage metrics
+- Validate TDD cycle execution quality
+- Generate compliance report with quality gate recommendation
 
 ## Execution Process
 
 ```
 Input Parsing:
    └─ Decision (session argument):
-      ├─ session-id provided → Use provided session
-      └─ No session-id → Auto-detect active session
+      ├─ --session provided → Use provided session
+      └─ No session → Auto-detect active session
 
-Phase 1: Session Discovery
-   ├─ Validate session directory exists
-   └─ TodoWrite: Mark phase 1 completed
+Phase 1: Session Discovery & Validation
+   ├─ Detect or validate session directory
+   ├─ Check required artifacts exist (.task/*.json, .summaries/*)
+   └─ ERROR if invalid or incomplete
 
-Phase 2: Task Chain Validation
+Phase 2: Task Chain Structure Validation
    ├─ Load all task JSONs from .task/
-   ├─ Extract task IDs and group by feature
-   ├─ Validate TDD structure:
-   │  ├─ TEST-N.M → IMPL-N.M → REFACTOR-N.M chain
-   │  ├─ Dependency verification
-   │  └─ Meta field validation (tdd_phase, agent)
-   └─ TodoWrite: Mark phase 2 completed
+   ├─ Validate TDD structure: TEST-N.M → IMPL-N.M → REFACTOR-N.M
+   ├─ Verify dependencies (depends_on)
+   ├─ Validate meta fields (tdd_phase, agent)
+   └─ Extract chain validation data
 
-Phase 3: Test Execution Analysis
-   └─ /workflow:tools:tdd-coverage-analysis
-      ├─ Coverage metrics extraction
-      ├─ TDD cycle verification
-      └─ Compliance score calculation
+Phase 3: Coverage & Cycle Analysis
+   ├─ Call: /workflow:tools:tdd-coverage-analysis
+   ├─ Parse: test-results.json, coverage-report.json, tdd-cycle-report.md
+   └─ Extract coverage metrics and TDD cycle verification
 
 Phase 4: Compliance Report Generation
-   ├─ Gemini analysis for comprehensive report
+   ├─ Aggregate findings from Phases 1-3
+   ├─ Calculate compliance score (0-100)
+   ├─ Determine quality gate recommendation
    ├─ Generate TDD_COMPLIANCE_REPORT.md
-   └─ Return summary to user
+   └─ Display summary to user
 ```
 
 ## 4-Phase Execution
 
-### Phase 1: Session Discovery
-**Auto-detect or use provided session**
+### Phase 1: Session Discovery & Validation
 
+**Step 1.1: Detect Session**
 ```bash
-# If session-id provided
-sessionId = argument
+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])
 
-# Else auto-detect active session
-find .workflow/active/ -name "WFS-*" -type d | head -1 | sed 's/.*\///'
+# Derive paths
+session_dir = .workflow/active/WFS-{session_id}
+task_dir = session_dir/.task
+summaries_dir = session_dir/.summaries
+process_dir = session_dir/.process
 ```
 
-**Extract**: sessionId
+**Step 1.2: Validate Required Artifacts**
+```bash
+# Check task files exist
+task_files = Glob(task_dir/*.json)
+IF task_files.count == 0:
+    ERROR: "No task JSON files found. Run /workflow:tdd-plan first"
+    EXIT
 
-**Validation**: Session directory exists
+# Check summaries exist (optional but recommended for full analysis)
+summaries_exist = EXISTS(summaries_dir)
+IF NOT summaries_exist:
+    WARNING: "No .summaries/ directory found. Some analysis may be limited."
+```
 
-**TodoWrite**: Mark phase 1 completed, phase 2 in_progress
+**Output**: session_id, session_dir, task_files list
 
 ---
 
-### Phase 2: Task Chain Validation
-**Validate TDD structure using bash commands**
+### Phase 2: Task Chain Structure Validation
 
+**Step 2.1: Load and Parse Task JSONs**
 ```bash
-# Load all task JSONs
-find .workflow/active/{sessionId}/.task/ -name '*.json'
+# Single-pass JSON extraction using jq
+validation_data = bash("""
+# Load all tasks and extract structured data
+cd '{session_dir}/.task'
 
-# Extract task IDs
-find .workflow/active/{sessionId}/.task/ -name '*.json' -exec jq -r '.id' {} \;
+# Extract all task IDs
+task_ids=$(jq -r '.id' *.json 2>/dev/null | sort)
 
-# Check dependencies
-find .workflow/active/{sessionId}/.task/ -name 'IMPL-*.json' -exec jq -r '.context.depends_on[]?' {} \;
-find .workflow/active/{sessionId}/.task/ -name 'REFACTOR-*.json' -exec jq -r '.context.depends_on[]?' {} \;
+# Extract dependencies for IMPL tasks
+impl_deps=$(jq -r 'select(.id | startswith("IMPL")) | .id + ":" + (.context.depends_on[]? // "none")' *.json 2>/dev/null)
 
-# Check meta fields
-find .workflow/active/{sessionId}/.task/ -name '*.json' -exec jq -r '.meta.tdd_phase' {} \;
-find .workflow/active/{sessionId}/.task/ -name '*.json' -exec jq -r '.meta.agent' {} \;
+# Extract dependencies for REFACTOR tasks
+refactor_deps=$(jq -r 'select(.id | startswith("REFACTOR")) | .id + ":" + (.context.depends_on[]? // "none")' *.json 2>/dev/null)
+
+# Extract meta fields
+meta_tdd=$(jq -r '.id + ":" + (.meta.tdd_phase // "missing")' *.json 2>/dev/null)
+meta_agent=$(jq -r '.id + ":" + (.meta.agent // "missing")' *.json 2>/dev/null)
+
+# Output as JSON
+jq -n --arg ids "$task_ids" \\
+       --arg impl "$impl_deps" \\
+       --arg refactor "$refactor_deps" \\
+       --arg tdd "$meta_tdd" \\
+       --arg agent "$meta_agent" \\
+       '{ids: $ids, impl_deps: $impl, refactor_deps: $refactor, tdd: $tdd, agent: $agent}'
+""")
 ```
 
-**Validation**:
-- For each feature N, verify TEST-N.M → IMPL-N.M → REFACTOR-N.M exists
-- IMPL-N.M.context.depends_on includes TEST-N.M
-- REFACTOR-N.M.context.depends_on includes IMPL-N.M
-- TEST tasks have tdd_phase="red" and agent="@code-review-test-agent"
-- IMPL/REFACTOR tasks have tdd_phase="green"/"refactor" and agent="@code-developer"
+**Step 2.2: Validate TDD Chain Structure**
+```
+Parse validation_data JSON and validate:
 
-**Extract**: Chain validation report
+For each feature N (extracted from task IDs):
+   1. TEST-N.M exists?
+   2. IMPL-N.M exists?
+   3. REFACTOR-N.M exists? (optional but recommended)
+   4. IMPL-N.M.context.depends_on contains TEST-N.M?
+   5. REFACTOR-N.M.context.depends_on contains IMPL-N.M?
+   6. TEST-N.M.meta.tdd_phase == "red"?
+   7. TEST-N.M.meta.agent == "@code-review-test-agent"?
+   8. IMPL-N.M.meta.tdd_phase == "green"?
+   9. IMPL-N.M.meta.agent == "@code-developer"?
+   10. REFACTOR-N.M.meta.tdd_phase == "refactor"?
 
-**TodoWrite**: Mark phase 2 completed, phase 3 in_progress
+Calculate:
+- chain_completeness_score = (complete_chains / total_chains) * 100
+- dependency_accuracy = (correct_deps / total_deps) * 100
+- meta_field_accuracy = (correct_meta / total_meta) * 100
+```
+
+**Output**: chain_validation_report (JSON structure with validation results)
 
 ---
 
-### Phase 3: Test Execution Analysis
-**Command**: `SlashCommand(command="/workflow:tools:tdd-coverage-analysis --session [sessionId]")`
+### Phase 3: Coverage & Cycle Analysis
 
-**Input**: sessionId from Phase 1
+**Step 3.1: Call Coverage Analysis Sub-command**
+```bash
+SlashCommand(command="/workflow:tools:tdd-coverage-analysis --session {session_id}")
+```
 
-**Parse Output**:
-- Coverage metrics (line, branch, function percentages)
-- TDD cycle verification results
-- Compliance score
+**Step 3.2: Parse Output Files**
+```bash
+# Check required outputs exist
+IF NOT EXISTS(process_dir/test-results.json):
+    WARNING: "test-results.json not found. Coverage analysis incomplete."
+    coverage_data = null
+ELSE:
+    coverage_data = Read(process_dir/test-results.json)
 
-**Validation**:
-- `.workflow/active/{sessionId}/.process/test-results.json` exists
-- `.workflow/active/{sessionId}/.process/coverage-report.json` exists
-- `.workflow/active/{sessionId}/.process/tdd-cycle-report.md` exists
+IF NOT EXISTS(process_dir/coverage-report.json):
+    WARNING: "coverage-report.json not found. Coverage metrics incomplete."
+    metrics = null
+ELSE:
+    metrics = Read(process_dir/coverage-report.json)
 
-**TodoWrite**: Mark phase 3 completed, phase 4 in_progress
+IF NOT EXISTS(process_dir/tdd-cycle-report.md):
+    WARNING: "tdd-cycle-report.md not found. Cycle validation incomplete."
+    cycle_data = null
+ELSE:
+    cycle_data = Read(process_dir/tdd-cycle-report.md)
+```
+
+**Step 3.3: Extract Coverage Metrics**
+```
+If coverage_data exists:
+   - line_coverage_percent
+   - branch_coverage_percent
+   - function_coverage_percent
+   - uncovered_files (list)
+   - uncovered_lines (map: file -> line ranges)
+
+If cycle_data exists:
+   - red_phase_compliance (tests failed initially?)
+   - green_phase_compliance (tests pass after impl?)
+   - refactor_phase_compliance (tests stay green during refactor?)
+   - minimal_implementation_score (was impl minimal?)
+```
+
+**Output**: coverage_analysis, cycle_analysis
 
 ---
 
 ### Phase 4: Compliance Report Generation
-**Gemini analysis for comprehensive TDD compliance report**
 
+**Step 4.1: Calculate Compliance Score**
+```
+Base Score: 100 points
+
+Deductions:
+Chain Structure:
+   - Missing TEST task: -30 points per feature
+   - Missing IMPL task: -30 points per feature
+   - Missing REFACTOR task: -10 points per feature
+   - Wrong dependency: -15 points per error
+   - Wrong agent: -5 points per error
+   - Wrong tdd_phase: -5 points per error
+
+TDD Cycle Compliance:
+   - Test didn't fail initially: -10 points per feature
+   - Tests didn't pass after IMPL: -20 points per feature
+   - Tests broke during REFACTOR: -15 points per feature
+   - Over-engineered IMPL: -10 points per feature
+
+Coverage Quality:
+   - Line coverage < 80%: -5 points
+   - Branch coverage < 70%: -5 points
+   - Function coverage < 80%: -5 points
+   - Critical paths uncovered: -10 points
+
+Final Score: Max(0, Base Score - Total Deductions)
+```
+
+**Step 4.2: Determine Quality Gate**
+```
+IF score >= 90 AND no_critical_violations:
+    recommendation = "APPROVED"
+ELSE IF score >= 70 AND critical_violations == 0:
+    recommendation = "PROCEED_WITH_CAVEATS"
+ELSE IF score >= 50:
+    recommendation = "REQUIRE_FIXES"
+ELSE:
+    recommendation = "BLOCK_MERGE"
+```
+
+**Step 4.3: Generate Report**
 ```bash
-cd project-root && gemini -p "
-PURPOSE: Generate TDD compliance report
-TASK: Analyze TDD workflow execution and generate quality report
-CONTEXT: @{.workflow/active/{sessionId}/.task/*.json,.workflow/active/{sessionId}/.summaries/*,.workflow/active/{sessionId}/.process/tdd-cycle-report.md}
-EXPECTED:
-- TDD compliance score (0-100)
-- Chain completeness verification
-- Test coverage analysis summary
-- Quality recommendations
-- Red-Green-Refactor cycle validation
-- Best practices adherence assessment
-RULES: Focus on TDD best practices and workflow adherence. Be specific about violations and improvements.
-" > .workflow/active/{sessionId}/TDD_COMPLIANCE_REPORT.md
+report_content = Generate markdown report (see structure below)
+report_path = "{session_dir}/TDD_COMPLIANCE_REPORT.md"
+Write(report_path, report_content)
 ```
 
-**Output**: TDD_COMPLIANCE_REPORT.md
-
-**TodoWrite**: Mark phase 4 completed
-
-**Return to User**:
-```
-TDD Verification Report - Session: {sessionId}
-
-## Chain Validation
-[COMPLETE] Feature 1: TEST-1.1 → IMPL-1.1 → REFACTOR-1.1 (Complete)
-[COMPLETE] Feature 2: TEST-2.1 → IMPL-2.1 → REFACTOR-2.1 (Complete)
-[INCOMPLETE] Feature 3: TEST-3.1 → IMPL-3.1 (Missing REFACTOR phase)
-
-## Test Execution
-All TEST tasks produced failing tests
-All IMPL tasks made tests pass
-All REFACTOR tasks maintained green tests
-
-## Coverage Metrics
-Line Coverage: {percentage}%
-Branch Coverage: {percentage}%
-Function Coverage: {percentage}%
-
-## Compliance Score: {score}/100
-
-Detailed report: .workflow/active/{sessionId}/TDD_COMPLIANCE_REPORT.md
-
-Recommendations:
-- Complete missing REFACTOR-3.1 task
-- Consider additional edge case tests for Feature 2
-- Improve test failure message clarity in Feature 1
+**Step 4.4: Display Summary to User**
+```bash
+echo "=== TDD Verification Complete ==="
+echo "Session: {session_id}"
+echo "Report: {report_path}"
+echo ""
+echo "Quality Gate: {recommendation}"
+echo "Compliance Score: {score}/100"
+echo ""
+echo "Chain Validation: {chain_completeness_score}%"
+echo "Line Coverage: {line_coverage}%"
+echo "Branch Coverage: {branch_coverage}%"
+echo ""
+echo "Next: Review full report for detailed findings"
 ```
 
-## TodoWrite Pattern
+## TodoWrite Pattern (Optional)
+
+**Note**: As an orchestrator command, TodoWrite tracking is optional and primarily useful for long-running verification processes. For most cases, the 4-phase execution is fast enough that progress tracking adds noise without value.
 
 ```javascript
-// Initialize (before Phase 1)
-TodoWrite({todos: [
-  {"content": "Identify target session", "status": "in_progress", "activeForm": "Identifying target session"},
-  {"content": "Validate task chain structure", "status": "pending", "activeForm": "Validating task chain structure"},
-  {"content": "Analyze test execution", "status": "pending", "activeForm": "Analyzing test execution"},
-  {"content": "Generate compliance report", "status": "pending", "activeForm": "Generating compliance report"}
-]})
-
-// After Phase 1
-TodoWrite({todos: [
-  {"content": "Identify target session", "status": "completed", "activeForm": "Identifying target session"},
-  {"content": "Validate task chain structure", "status": "in_progress", "activeForm": "Validating task chain structure"},
-  {"content": "Analyze test execution", "status": "pending", "activeForm": "Analyzing test execution"},
-  {"content": "Generate compliance report", "status": "pending", "activeForm": "Generating compliance report"}
-]})
-
-// Continue pattern for Phase 2, 3, 4...
+// Only use TodoWrite for complex multi-session verification
+// Skip for single-session verification
 ```
 
 ## Validation Logic
@@ -215,27 +316,24 @@ TodoWrite({todos: [
 5. Report incomplete or invalid chains
 ```
 
-### Compliance Scoring
-```
-Base Score: 100 points
+### Quality Gate Criteria
 
-Deductions:
-- Missing TEST task: -30 points per feature
-- Missing IMPL task: -30 points per feature
-- Missing REFACTOR task: -10 points per feature
-- Wrong dependency: -15 points per error
-- Wrong agent: -5 points per error
-- Wrong tdd_phase: -5 points per error
-- Test didn't fail initially: -10 points per feature
-- Tests didn't pass after IMPL: -20 points per feature
-- Tests broke during REFACTOR: -15 points per feature
+| Recommendation | Score Range | Critical Violations | Action |
+|----------------|-------------|---------------------|--------|
+| **APPROVED** | ≥90 | 0 | Safe to merge |
+| **PROCEED_WITH_CAVEATS** | ≥70 | 0 | Can proceed, address minor issues |
+| **REQUIRE_FIXES** | ≥50 | Any | Must fix before merge |
+| **BLOCK_MERGE** | <50 | Any | Block merge until resolved |
 
-Final Score: Max(0, Base Score - Deductions)
-```
+**Critical Violations**:
+- Missing TEST or IMPL task for any feature
+- Tests didn't fail initially (Red phase violation)
+- Tests didn't pass after IMPL (Green phase violation)
+- Tests broke during REFACTOR (Refactor phase violation)
 
 ## Output Files
 ```
-.workflow/active/{session-id}/
+.workflow/active/WFS-{session-id}/
 ├── TDD_COMPLIANCE_REPORT.md     # Comprehensive compliance report ⭐
 └── .process/
     ├── test-results.json         # From tdd-coverage-analysis
@@ -248,14 +346,14 @@ Final Score: Max(0, Base Score - Deductions)
 ### Session Discovery Errors
 | Error | Cause | Resolution |
 |-------|-------|------------|
-| No active session | No WFS-* directories | Provide session-id explicitly |
-| Multiple active sessions | Multiple WFS-* directories | Provide session-id explicitly |
+| No active session | No WFS-* directories | Provide --session explicitly |
+| Multiple active sessions | Multiple WFS-* directories | Provide --session explicitly |
 | Session not found | Invalid session-id | Check available sessions |
 
 ### Validation Errors
 | Error | Cause | Resolution |
 |-------|-------|------------|
-| Task files missing | Incomplete planning | Run tdd-plan first |
+| Task files missing | Incomplete planning | Run /workflow:tdd-plan first |
 | Invalid JSON | Corrupted task files | Regenerate tasks |
 | Missing summaries | Tasks not executed | Execute tasks before verify |
 
@@ -264,13 +362,13 @@ Final Score: Max(0, Base Score - Deductions)
 |-------|-------|------------|
 | Coverage tool missing | No test framework | Configure testing first |
 | Tests fail to run | Code errors | Fix errors before verify |
-| Gemini analysis fails | Token limit / API error | Retry or reduce context |
+| Sub-command fails | tdd-coverage-analysis error | Check sub-command logs |
 
 ## Integration & Usage
 
 ### Command Chain
 - **Called After**: `/workflow:execute` (when TDD tasks completed)
-- **Calls**: `/workflow:tools:tdd-coverage-analysis`, Gemini CLI
+- **Calls**: `/workflow:tools:tdd-coverage-analysis`
 - **Related**: `/workflow:tdd-plan`, `/workflow:status`
 
 ### Basic Usage
@@ -279,7 +377,7 @@ Final Score: Max(0, Base Score - Deductions)
 /workflow:tdd-verify
 
 # Specify session
-/workflow:tdd-verify WFS-auth
+/workflow:tdd-verify --session WFS-auth
 ```
 
 ### When to Use
@@ -294,61 +392,125 @@ Final Score: Max(0, Base Score - Deductions)
 # TDD Compliance Report - {Session ID}
 
 **Generated**: {timestamp}
-**Session**: {sessionId}
+**Session**: WFS-{sessionId}
 **Workflow Type**: TDD
 
+---
+
 ## Executive Summary
-Overall Compliance Score: {score}/100
-Status: {EXCELLENT | GOOD | NEEDS IMPROVEMENT | FAILED}
+
+### Quality Gate Decision
+
+| Metric | Value | Status |
+|--------|-------|--------|
+| Compliance Score | {score}/100 | {status_emoji} |
+| Chain Completeness | {percentage}% | {status} |
+| Line Coverage | {percentage}% | {status} |
+| Branch Coverage | {percentage}% | {status} |
+| Function Coverage | {percentage}% | {status} |
+
+### Recommendation
+
+**{RECOMMENDATION}**
+
+**Decision Rationale**:
+{brief explanation based on score and violations}
+
+**Quality Gate Criteria**:
+- **APPROVED**: Score ≥90, no critical violations
+- **PROCEED_WITH_CAVEATS**: Score ≥70, no critical violations
+- **REQUIRE_FIXES**: Score ≥50 or critical violations exist
+- **BLOCK_MERGE**: Score <50
+
+---
 
 ## Chain Analysis
 
 ### Feature 1: {Feature Name}
-**Status**: Complete
+**Status**: ✅ Complete
 **Chain**: TEST-1.1 → IMPL-1.1 → REFACTOR-1.1
 
-- **Red Phase**: Test created and failed with clear message
-- **Green Phase**: Minimal implementation made test pass
-- **Refactor Phase**: Code improved, tests remained green
+| Phase | Task | Status | Details |
+|-------|------|--------|---------|
+| Red | TEST-1.1 | ✅ Pass | Test created and failed with clear message |
+| Green | IMPL-1.1 | ✅ Pass | Minimal implementation made test pass |
+| Refactor | REFACTOR-1.1 | ✅ Pass | Code improved, tests remained green |
 
 ### Feature 2: {Feature Name}
-**Status**: Incomplete
+**Status**: ⚠️ Incomplete
 **Chain**: TEST-2.1 → IMPL-2.1 (Missing REFACTOR-2.1)
 
-- **Red Phase**: Test created and failed
-- **Green Phase**: Implementation seems over-engineered
-- **Refactor Phase**: Missing
+| Phase | Task | Status | Details |
+|-------|------|--------|---------|
+| Red | TEST-2.1 | ✅ Pass | Test created and failed |
+| Green | IMPL-2.1 | ⚠️ Warning | Implementation seems over-engineered |
+| Refactor | REFACTOR-2.1 | ❌ Missing | Task not completed |
 
 **Issues**:
-- REFACTOR-2.1 task not completed
-- IMPL-2.1 implementation exceeded minimal scope
+- REFACTOR-2.1 task not completed (-10 points)
+- IMPL-2.1 implementation exceeded minimal scope (-10 points)
 
-[Repeat for all features]
+### Chain Validation Summary
+
+| Metric | Value |
+|--------|-------|
+| Total Features | {count} |
+| Complete Chains | {count} ({percent}%) |
+| Incomplete Chains | {count} |
+| Missing TEST | {count} |
+| Missing IMPL | {count} |
+| Missing REFACTOR | {count} |
+| Dependency Errors | {count} |
+| Meta Field Errors | {count} |
+
+---
 
 ## Test Coverage Analysis
 
 ### Coverage Metrics
-- Line Coverage: {percentage}% {status}
-- Branch Coverage: {percentage}% {status}
-- Function Coverage: {percentage}% {status}
+
+| Metric | Coverage | Target | Status |
+|--------|----------|--------|--------|
+| Line Coverage | {percentage}% | ≥80% | {status} |
+| Branch Coverage | {percentage}% | ≥70% | {status} |
+| Function Coverage | {percentage}% | ≥80% | {status} |
 
 ### Coverage Gaps
-- {file}:{lines} - Uncovered error handling
-- {file}:{lines} - Uncovered edge case
+
+| File | Lines | Issue | Priority |
+|------|-------|-------|----------|
+| src/auth/service.ts | 45-52 | Uncovered error handling | HIGH |
+| src/utils/parser.ts | 78-85 | Uncovered edge case | MEDIUM |
+
+---
 
 ## TDD Cycle Validation
 
 ### Red Phase (Write Failing Test)
-- {N}/{total} features had failing tests initially
-- Feature 3: No evidence of initial test failure
+- {N}/{total} features had failing tests initially ({percent}%)
+- ✅ Compliant features: {list}
+- ❌ Non-compliant features: {list}
+
+**Violations**:
+- Feature 3: No evidence of initial test failure (-10 points)
 
 ### Green Phase (Make Test Pass)
-- {N}/{total} implementations made tests pass
-- All implementations minimal and focused
+- {N}/{total} implementations made tests pass ({percent}%)
+- ✅ Compliant features: {list}
+- ❌ Non-compliant features: {list}
+
+**Violations**:
+- Feature 2: Implementation over-engineered (-10 points)
 
 ### Refactor Phase (Improve Quality)
-- {N}/{total} features completed refactoring
-- Feature 2, 4: Refactoring step skipped
+- {N}/{total} features completed refactoring ({percent}%)
+- ✅ Compliant features: {list}
+- ❌ Non-compliant features: {list}
+
+**Violations**:
+- Feature 2, 4: Refactoring step skipped (-20 points total)
+
+---
 
 ## Best Practices Assessment
 
@@ -363,24 +525,61 @@ Status: {EXCELLENT | GOOD | NEEDS IMPROVEMENT | FAILED}
 - Missing refactoring steps
 - Test failure messages could be more descriptive
 
+---
+
+## Detailed Findings by Severity
+
+### Critical Issues ({count})
+{List of critical issues with impact and remediation}
+
+### High Priority Issues ({count})
+{List of high priority issues with impact and remediation}
+
+### Medium Priority Issues ({count})
+{List of medium priority issues with impact and remediation}
+
+### Low Priority Issues ({count})
+{List of low priority issues with impact and remediation}
+
+---
+
 ## Recommendations
 
-### High Priority
+### Required Fixes (Before Merge)
 1. Complete missing REFACTOR tasks (Features 2, 4)
 2. Verify initial test failures for Feature 3
-3. Simplify over-engineered implementations
+3. Fix tests that broke during refactoring
 
-### Medium Priority
-1. Add edge case tests for Features 1, 3
-2. Improve test failure message clarity
-3. Increase branch coverage to >85%
+### Recommended Improvements
+1. Simplify over-engineered implementations
+2. Add edge case tests for Features 1, 3
+3. Improve test failure message clarity
+4. Increase branch coverage to >85%
 
-### Low Priority
+### Optional Enhancements
 1. Add more descriptive test names
 2. Consider parameterized tests for similar scenarios
 3. Document TDD process learnings
 
-## Conclusion
-{Summary of compliance status and next steps}
+---
+
+## Metrics Summary
+
+| Metric | Value |
+|--------|-------|
+| Total Features | {count} |
+| Complete Chains | {count} ({percent}%) |
+| Compliance Score | {score}/100 |
+| Critical Issues | {count} |
+| High Issues | {count} |
+| Medium Issues | {count} |
+| Low Issues | {count} |
+| Line Coverage | {percent}% |
+| Branch Coverage | {percent}% |
+| Function Coverage | {percent}% |
+
+---
+
+**Report End**
 ```
 

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

@@ -221,6 +221,7 @@ return "conservative";
 ```javascript
 Task(
   subagent_type="cli-planning-agent",
+  run_in_background=false,
   description=`Analyze test failures (iteration ${N}) - ${strategy} strategy`,
   prompt=`
     ## Task Objective
@@ -271,6 +272,7 @@ Task(
 ```javascript
 Task(
   subagent_type="test-fix-agent",
+  run_in_background=false,
   description=`Execute ${task.meta.type}: ${task.title}`,
   prompt=`
     ## Task Objective
@@ -489,6 +491,10 @@ The orchestrator automatically creates git commits at key checkpoints to enable
 
 **Note**: Final session completion creates additional commit with full summary.
 
+## Post-Completion Expansion
+
+完成后询问用户是否扩展为issue(test/enhance/refactor/doc)，选中项调用 `/issue:new "{summary} - {dimension}"`
+
 ## Best Practices
 
 1. **Default Settings Work**: 10 iterations sufficient for most cases

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

@@ -1,7 +1,7 @@
 ---
 name: test-fix-gen
 description: Create test-fix workflow session from session ID, description, or file path with test strategy generation and task planning
-argument-hint: "[--use-codex] [--cli-execute] (source-session-id | \"feature description\" | /path/to/file.md)"
+argument-hint: "(source-session-id | \"feature description\" | /path/to/file.md)"
 allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*)
 ---
 
@@ -43,7 +43,7 @@ fi
 - **Session Isolation**: Creates independent `WFS-test-[slug]` session
 - **Context-First**: Gathers implementation context via appropriate method
 - **Format Reuse**: Creates standard `IMPL-*.json` tasks with `meta.type: "test-fix"`
-- **Manual First**: Default to manual fixes, use `--use-codex` for automation
+- **Semantic CLI Selection**: CLI tool usage determined from user's task description
 - **Automatic Detection**: Input pattern determines execution mode
 
 ### Coordinator Role
@@ -59,8 +59,8 @@ This command is a **pure planning coordinator**:
 - **All execution delegated to `/workflow:test-cycle-execute`**
 
 **Task Attachment Model**:
-- SlashCommand invocation **expands workflow** by attaching sub-tasks to current TodoWrite
-- When a sub-command is invoked (e.g., `/workflow:tools:test-context-gather`), its internal tasks are attached to the orchestrator's TodoWrite
+- SlashCommand execute **expands workflow** by attaching sub-tasks to current TodoWrite
+- When executing a sub-command (e.g., `/workflow:tools:test-context-gather`), its internal tasks are attached to the orchestrator's TodoWrite
 - Orchestrator **executes these attached tasks** sequentially
 - After completion, attached tasks are **collapsed** back to high-level phase summary
 - This is **task expansion**, not external delegation
@@ -79,16 +79,14 @@ This command is a **pure planning coordinator**:
 
 ```bash
 # Basic syntax
-/workflow:test-fix-gen [FLAGS] <INPUT>
-
-# Flags (optional)
---use-codex        # Enable Codex automated fixes in IMPL-002
---cli-execute      # Enable CLI execution in IMPL-001
+/workflow:test-fix-gen <INPUT>
 
 # Input
 <INPUT>            # Session ID, description, or file path
 ```
 
+**Note**: CLI tool usage is determined semantically from the task description. To request CLI execution, include it in your description (e.g., "use Codex for automated fixes").
+
 ### Usage Examples
 
 #### Session Mode
@@ -96,11 +94,8 @@ This command is a **pure planning coordinator**:
 # Test validation for completed implementation
 /workflow:test-fix-gen WFS-user-auth-v2
 
-# With automated fixes
-/workflow:test-fix-gen --use-codex WFS-api-endpoints
-
-# With CLI execution
-/workflow:test-fix-gen --cli-execute --use-codex WFS-payment-flow
+# With semantic CLI request
+/workflow:test-fix-gen WFS-api-endpoints  # Add "use Codex" in description for automated fixes
 ```
 
 #### Prompt Mode - Text Description
@@ -108,17 +103,14 @@ This command is a **pure planning coordinator**:
 # Generate tests from feature description
 /workflow:test-fix-gen "Test the user authentication API endpoints in src/auth/api.ts"
 
-# With automated fixes
-/workflow:test-fix-gen --use-codex "Test user registration and login flows"
+# With CLI execution (semantic)
+/workflow:test-fix-gen "Test user registration and login flows, use Codex for automated fixes"
 ```
 
 #### Prompt Mode - File Reference
 ```bash
 # Generate tests from requirements file
 /workflow:test-fix-gen ./docs/api-requirements.md
-
-# With flags
-/workflow:test-fix-gen --use-codex --cli-execute ./specs/feature.md
 ```
 
 ### Mode Comparison
@@ -136,32 +128,50 @@ This command is a **pure planning coordinator**:
 
 ### Core Execution Rules
 
-1. **Start Immediately**: First action is TodoWrite, second is Phase 1 session creation
+1. **Start Immediately**: First action is TodoWrite, second is execute Phase 1 session creation
 2. **No Preliminary Analysis**: Do not read files before Phase 1
 3. **Parse Every Output**: Extract required data from each phase for next phase
 4. **Sequential Execution**: Each phase depends on previous phase's output
 5. **Complete All Phases**: Do not return until Phase 5 completes
 6. **Track Progress**: Update TodoWrite dynamically with task attachment/collapse pattern
 7. **Automatic Detection**: Mode auto-detected from input pattern
-8. **Parse Flags**: Extract `--use-codex` and `--cli-execute` flags for Phase 4
-9. **Task Attachment Model**: SlashCommand invocation **attaches** sub-tasks to current workflow. Orchestrator **executes** these attached tasks itself, then **collapses** them after completion
+8. **Semantic CLI Detection**: CLI tool usage determined from user's task description for Phase 4
+9. **Task Attachment Model**: SlashCommand execute **attaches** sub-tasks to current workflow. Orchestrator **executes** these attached tasks itself, then **collapses** them after completion
 10. **⚠️ CRITICAL: DO NOT STOP**: Continuous multi-phase workflow. After executing all attached tasks, immediately collapse them and execute next phase
 
 ### 5-Phase Execution
 
 #### Phase 1: Create Test Session
 
-**Command**:
-- **Session Mode**: `SlashCommand("/workflow:session:start --new \"Test validation for [sourceSessionId]\"")`
-- **Prompt Mode**: `SlashCommand("/workflow:session:start --new \"Test generation for: [description]\"")`
+**Step 1.0: Load Source Session Intent (Session Mode Only)** - Preserve user's original task description for semantic CLI selection
+
+```javascript
+// Session Mode: Read source session metadata to get original task description
+Read(".workflow/active/[sourceSessionId]/workflow-session.json")
+// OR if context-package exists:
+Read(".workflow/active/[sourceSessionId]/.process/context-package.json")
+
+// Extract: metadata.task_description or project/description field
+// This preserves user's CLI tool preferences (e.g., "use Codex for fixes")
+```
+
+**Step 1.1: Execute** - Create test workflow session with preserved intent
+
+```javascript
+// Session Mode - Include original task description to enable semantic CLI selection
+SlashCommand(command="/workflow:session:start --type test --new \"Test validation for [sourceSessionId]: [originalTaskDescription]\"")
+
+// Prompt Mode - User's description already contains their intent
+SlashCommand(command="/workflow:session:start --type test --new \"Test generation for: [description]\"")
+```
 
 **Input**: User argument (session ID, description, or file path)
 
 **Expected Behavior**:
 - Creates new session: `WFS-test-[slug]`
-- Writes `workflow-session.json` metadata:
-  - **Session Mode**: Includes `workflow_type: "test_session"`, `source_session_id: "[sourceId]"`
-  - **Prompt Mode**: Includes `workflow_type: "test_session"` only
+- Writes `workflow-session.json` metadata with `type: "test"`
+  - **Session Mode**: Additionally includes `source_session_id: "[sourceId]"`, description with original user intent
+  - **Prompt Mode**: Uses user's description (already contains intent)
 - Returns new session ID
 
 **Parse Output**:
@@ -177,9 +187,15 @@ This command is a **pure planning coordinator**:
 
 #### Phase 2: Gather Test Context
 
-**Command**:
-- **Session Mode**: `SlashCommand("/workflow:tools:test-context-gather --session [testSessionId]")`
-- **Prompt Mode**: `SlashCommand("/workflow:tools:context-gather --session [testSessionId] \"[task_description]\"")`
+**Step 2.1: Execute** - Gather test context via appropriate method
+
+```javascript
+// Session Mode
+SlashCommand(command="/workflow:tools:test-context-gather --session [testSessionId]")
+
+// Prompt Mode
+SlashCommand(command="/workflow:tools:context-gather --session [testSessionId] \"[task_description]\"")
+```
 
 **Input**: `testSessionId` from Phase 1
 
@@ -208,7 +224,11 @@ This command is a **pure planning coordinator**:
 
 #### Phase 3: Test Generation Analysis
 
-**Command**: `SlashCommand("/workflow:tools:test-concept-enhanced --session [testSessionId] --context [contextPath]")`
+**Step 3.1: Execute** - Generate test requirements using Gemini
+
+```javascript
+SlashCommand(command="/workflow:tools:test-concept-enhanced --session [testSessionId] --context [contextPath]")
+```
 
 **Input**:
 - `testSessionId` from Phase 1
@@ -264,12 +284,16 @@ For each targeted file/function, Gemini MUST generate:
 
 #### Phase 4: Generate Test Tasks
 
-**Command**: `SlashCommand("/workflow:tools:test-task-generate [--use-codex] [--cli-execute] --session [testSessionId]")`
+**Step 4.1: Execute** - Generate test task JSONs
+
+```javascript
+SlashCommand(command="/workflow:tools:test-task-generate --session [testSessionId]")
+```
 
 **Input**:
 - `testSessionId` from Phase 1
-- `--use-codex` flag (if present) - Controls IMPL-002 fix mode
-- `--cli-execute` flag (if present) - Controls IMPL-001 generation mode
+
+**Note**: CLI tool usage is determined semantically from user's task description.
 
 **Expected Behavior**:
 - Parse TEST_ANALYSIS_RESULTS.md from Phase 3 (multi-layered test plan)
@@ -357,7 +381,7 @@ CRITICAL - Next Steps:
 
 #### Key Principles
 
-1. **Task Attachment** (when SlashCommand invoked):
+1. **Task Attachment** (when SlashCommand executed):
    - Sub-command's internal tasks are **attached** to orchestrator's TodoWrite
    - Example - Phase 2 with sub-tasks:
    ```json
@@ -392,7 +416,7 @@ CRITICAL - Next Steps:
    - No user intervention required between phases
    - TodoWrite dynamically reflects current execution state
 
-**Lifecycle Summary**: Initial pending tasks → Phase invoked (tasks ATTACHED with mode-specific context gathering) → Sub-tasks executed sequentially → Phase completed (tasks COLLAPSED to summary) → Next phase begins → Repeat until all phases complete.
+**Lifecycle Summary**: Initial pending tasks → Phase executed (tasks ATTACHED with mode-specific context gathering) → Sub-tasks executed sequentially → Phase completed (tasks COLLAPSED to summary) → Next phase begins → Repeat until all phases complete.
 
 #### Test-Fix-Gen Specific Features
 
@@ -402,7 +426,7 @@ CRITICAL - Next Steps:
 - **Phase 2**: Mode-specific context gathering (session summaries vs codebase analysis)
 - **Phase 3**: Multi-layered test requirements analysis (L0: Static, L1: Unit, L2: Integration, L3: E2E)
 - **Phase 4**: Multi-task generation with quality gate (IMPL-001, IMPL-001.5-review, IMPL-002)
-- **Fix Mode Configuration**: `--use-codex` flag controls IMPL-002 fix mode (manual vs automated)
+- **Fix Mode Configuration**: CLI tool usage determined semantically from user's task description
 
 
 ---
@@ -501,16 +525,15 @@ If quality gate fails:
 - Task ID: `IMPL-002`
 - `meta.type: "test-fix"`
 - `meta.agent: "@test-fix-agent"`
-- `meta.use_codex: true|false` (based on `--use-codex` flag)
 - `context.depends_on: ["IMPL-001"]`
 - `context.requirements`: Execute and fix tests
 
 **Test-Fix Cycle Specification**:
 **Note**: This specification describes what test-cycle-execute orchestrator will do. The agent only executes single tasks.
-- **Cycle Pattern** (orchestrator-managed): test → gemini_diagnose → manual_fix (or codex) → retest
+- **Cycle Pattern** (orchestrator-managed): test → gemini_diagnose → fix (agent or CLI) → retest
 - **Tools Configuration** (orchestrator-controlled):
   - Gemini for analysis with bug-fix template → surgical fix suggestions
-  - Manual fix application (default) OR Codex if `--use-codex` flag (resume mechanism)
+  - Agent fix application (default) OR CLI if `command` field present in implementation_approach
 - **Exit Conditions** (orchestrator-enforced):
   - Success: All tests pass
   - Failure: Max iterations reached (5)
@@ -556,11 +579,11 @@ WFS-test-[session]/
 **File**: `workflow-session.json`
 
 **Session Mode** includes:
-- `workflow_type: "test_session"`
+- `type: "test"` (set by session:start --type test)
 - `source_session_id: "[sourceSessionId]"` (enables automatic cross-session context)
 
 **Prompt Mode** includes:
-- `workflow_type: "test_session"`
+- `type: "test"` (set by session:start --type test)
 - No `source_session_id` field
 
 ### Execution Flow Diagram
@@ -654,8 +677,7 @@ Key Points:
 4. **Mode Selection**:
    - Use **Session Mode** for completed workflow validation
    - Use **Prompt Mode** for ad-hoc test generation
-   - Use `--use-codex` for autonomous fix application
-   - Use `--cli-execute` for enhanced generation capabilities
+   - Include "use Codex" in description for autonomous fix application
 
 ## Related Commands
 
@@ -668,9 +690,7 @@ Key Points:
 - `/workflow:tools:test-context-gather` - Phase 2 (Session Mode): Gather source session context
 - `/workflow:tools:context-gather` - Phase 2 (Prompt Mode): Analyze codebase directly
 - `/workflow:tools:test-concept-enhanced` - Phase 3: Generate test requirements using Gemini
-- `/workflow:tools:test-task-generate` - Phase 4: Generate test task JSONs using action-planning-agent (autonomous, default)
-- `/workflow:tools:test-task-generate --use-codex` - Phase 4: With automated Codex fixes for IMPL-002 (when `--use-codex` flag used)
-- `/workflow:tools:test-task-generate --cli-execute` - Phase 4: With CLI execution mode for IMPL-001 test generation (when `--cli-execute` flag used)
+- `/workflow:tools:test-task-generate` - Phase 4: Generate test task JSONs (CLI tool usage determined semantically)
 
 **Follow-up Commands**:
 - `/workflow:status` - Review generated test tasks

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

@@ -1,7 +1,7 @@
 ---
 name: test-gen
 description: Create independent test-fix workflow session from completed implementation session, analyzes code to generate test tasks
-argument-hint: "[--use-codex] [--cli-execute] source-session-id"
+argument-hint: "source-session-id"
 allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*)
 ---
 
@@ -16,11 +16,11 @@ allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*)
 - **Context-First**: Prioritizes gathering code changes and summaries from source session
 - **Format Reuse**: Creates standard `IMPL-*.json` task, using `meta.type: "test-fix"` for agent assignment
 - **Parameter Simplification**: Tools auto-detect test session type via metadata, no manual cross-session parameters needed
-- **Manual First**: Default to manual fixes, use `--use-codex` flag for automated Codex fix application
+- **Semantic CLI Selection**: CLI tool usage is determined by user's task description (e.g., "use Codex for fixes")
 
 **Task Attachment Model**:
-- SlashCommand invocation **expands workflow** by attaching sub-tasks to current TodoWrite
-- When a sub-command is invoked (e.g., `/workflow:tools:test-context-gather`), its internal tasks are attached to the orchestrator's TodoWrite
+- SlashCommand dispatch **expands workflow** by attaching sub-tasks to current TodoWrite
+- When a sub-command is executed (e.g., `/workflow:tools:test-context-gather`), its internal tasks are attached to the orchestrator's TodoWrite
 - Orchestrator **executes these attached tasks** sequentially
 - After completion, attached tasks are **collapsed** back to high-level phase summary
 - This is **task expansion**, not external delegation
@@ -48,23 +48,44 @@ allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*)
 5. **Complete All Phases**: Do not return to user until Phase 5 completes (summary returned)
 6. **Track Progress**: Update TodoWrite dynamically with task attachment/collapse pattern
 7. **Automatic Detection**: context-gather auto-detects test session and gathers source session context
-8. **Parse --use-codex Flag**: Extract flag from arguments and pass to Phase 4 (test-task-generate)
+8. **Semantic CLI Selection**: CLI tool usage determined from user's task description, passed to Phase 4
 9. **Command Boundary**: This command ends at Phase 5 summary. Test execution is NOT part of this command.
-10. **Task Attachment Model**: SlashCommand invocation **attaches** sub-tasks to current workflow. Orchestrator **executes** these attached tasks itself, then **collapses** them after completion
+10. **Task Attachment Model**: SlashCommand dispatch **attaches** sub-tasks to current workflow. Orchestrator **executes** these attached tasks itself, then **collapses** them after completion
 11. **⚠️ CRITICAL: DO NOT STOP**: Continuous multi-phase workflow. After executing all attached tasks, immediately collapse them and execute next phase
 
 ## 5-Phase Execution
 
 ### Phase 1: Create Test Session
-**Command**: `SlashCommand(command="/workflow:session:start --new \"Test validation for [sourceSessionId]\"")`
 
-**Input**: `sourceSessionId` from user argument (e.g., `WFS-user-auth`)
+**Step 1.0: Load Source Session Intent** - Preserve user's original task description for semantic CLI selection
+
+```javascript
+// Read source session metadata to get original task description
+Read(".workflow/active/[sourceSessionId]/workflow-session.json")
+// OR if context-package exists:
+Read(".workflow/active/[sourceSessionId]/.process/context-package.json")
+
+// Extract: metadata.task_description or project/description field
+// This preserves user's CLI tool preferences (e.g., "use Codex for fixes")
+```
+
+**Step 1.1: Execute** - Create new test workflow session with preserved intent
+
+```javascript
+// Include original task description to enable semantic CLI selection
+SlashCommand(command="/workflow:session:start --new \"Test validation for [sourceSessionId]: [originalTaskDescription]\"")
+```
+
+**Input**:
+- `sourceSessionId` from user argument (e.g., `WFS-user-auth`)
+- `originalTaskDescription` from source session metadata (preserves CLI tool preferences)
 
 **Expected Behavior**:
 - Creates new session with pattern `WFS-test-[source-slug]` (e.g., `WFS-test-user-auth`)
 - Writes metadata to `workflow-session.json`:
   - `workflow_type: "test_session"`
   - `source_session_id: "[sourceSessionId]"`
+  - Description includes original user intent for semantic CLI selection
 - Returns new session ID for subsequent phases
 
 **Parse Output**:
@@ -82,7 +103,12 @@ allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*)
 ---
 
 ### Phase 2: Gather Test Context
-**Command**: `SlashCommand(command="/workflow:tools:test-context-gather --session [testSessionId]")`
+
+**Step 2.1: Execute** - Gather test coverage context from source session
+
+```javascript
+SlashCommand(command="/workflow:tools:test-context-gather --session [testSessionId]")
+```
 
 **Input**: `testSessionId` from Phase 1 (e.g., `WFS-test-user-auth`)
 
@@ -104,9 +130,9 @@ allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*)
 - Test framework detected
 - Test conventions documented
 
-<!-- TodoWrite: When test-context-gather invoked, INSERT 3 test-context-gather tasks -->
+<!-- TodoWrite: When test-context-gather executed, INSERT 3 test-context-gather tasks -->
 
-**TodoWrite Update (Phase 2 SlashCommand invoked - tasks attached)**:
+**TodoWrite Update (Phase 2 SlashCommand executed - tasks attached)**:
 ```json
 [
   {"content": "Create independent test session", "status": "completed", "activeForm": "Creating test session"},
@@ -119,7 +145,7 @@ allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*)
 ]
 ```
 
-**Note**: SlashCommand invocation **attaches** test-context-gather's 3 tasks. Orchestrator **executes** these tasks.
+**Note**: SlashCommand dispatch **attaches** test-context-gather's 3 tasks. Orchestrator **executes** these tasks.
 
 **Next Action**: Tasks attached → **Execute Phase 2.1-2.3** sequentially
 
@@ -141,7 +167,12 @@ allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*)
 ---
 
 ### Phase 3: Test Generation Analysis
-**Command**: `SlashCommand(command="/workflow:tools:test-concept-enhanced --session [testSessionId] --context [testContextPath]")`
+
+**Step 3.1: Execute** - Analyze test requirements with Gemini
+
+```javascript
+SlashCommand(command="/workflow:tools:test-concept-enhanced --session [testSessionId] --context [testContextPath]")
+```
 
 **Input**:
 - `testSessionId` from Phase 1
@@ -168,9 +199,9 @@ allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*)
   - Implementation Targets (test files to create)
   - Success Criteria
 
-<!-- TodoWrite: When test-concept-enhanced invoked, INSERT 3 concept-enhanced tasks -->
+<!-- TodoWrite: When test-concept-enhanced executed, INSERT 3 concept-enhanced tasks -->
 
-**TodoWrite Update (Phase 3 SlashCommand invoked - tasks attached)**:
+**TodoWrite Update (Phase 3 SlashCommand executed - tasks attached)**:
 ```json
 [
   {"content": "Create independent test session", "status": "completed", "activeForm": "Creating test session"},
@@ -183,7 +214,7 @@ allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*)
 ]
 ```
 
-**Note**: SlashCommand invocation **attaches** test-concept-enhanced's 3 tasks. Orchestrator **executes** these tasks.
+**Note**: SlashCommand dispatch **attaches** test-concept-enhanced's 3 tasks. Orchestrator **executes** these tasks.
 
 **Next Action**: Tasks attached → **Execute Phase 3.1-3.3** sequentially
 
@@ -205,12 +236,17 @@ allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*)
 ---
 
 ### Phase 4: Generate Test Tasks
-**Command**: `SlashCommand(command="/workflow:tools:test-task-generate [--use-codex] [--cli-execute] --session [testSessionId]")`
+
+**Step 4.1: Execute** - Generate test task JSON files and planning documents
+
+```javascript
+SlashCommand(command="/workflow:tools:test-task-generate --session [testSessionId]")
+```
 
 **Input**:
 - `testSessionId` from Phase 1
-- `--use-codex` flag (if present in original command) - Controls IMPL-002 fix mode
-- `--cli-execute` flag (if present in original command) - Controls IMPL-001 generation mode
+
+**Note**: CLI tool usage for fixes is determined semantically from user's task description (e.g., "use Codex for automated fixes").
 
 **Expected Behavior**:
 - Parse TEST_ANALYSIS_RESULTS.md from Phase 3
@@ -240,21 +276,20 @@ allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*)
 - Task ID: `IMPL-002`
 - `meta.type: "test-fix"`
 - `meta.agent: "@test-fix-agent"`
-- `meta.use_codex: true|false` (based on --use-codex flag)
 - `context.depends_on: ["IMPL-001"]`
 - `context.requirements`: Execute and fix tests
 - `flow_control.implementation_approach.test_fix_cycle`: Complete cycle specification
-  - **Cycle pattern**: test → gemini_diagnose → manual_fix (or codex if --use-codex) → retest
-  - **Tools configuration**: Gemini for analysis with bug-fix template, manual or Codex for fixes
+  - **Cycle pattern**: test → gemini_diagnose → fix (agent or CLI based on `command` field) → retest
+  - **Tools configuration**: Gemini for analysis with bug-fix template, agent or CLI for fixes
   - **Exit conditions**: Success (all pass) or failure (max iterations)
 - `flow_control.implementation_approach.modification_points`: 3-phase execution flow
   - Phase 1: Initial test execution
-  - Phase 2: Iterative Gemini diagnosis + manual/Codex fixes (based on flag)
+  - Phase 2: Iterative Gemini diagnosis + fixes (agent or CLI based on step's `command` field)
   - Phase 3: Final validation and certification
 
-<!-- TodoWrite: When test-task-generate invoked, INSERT 3 test-task-generate tasks -->
+<!-- TodoWrite: When test-task-generate executed, INSERT 3 test-task-generate tasks -->
 
-**TodoWrite Update (Phase 4 SlashCommand invoked - tasks attached)**:
+**TodoWrite Update (Phase 4 SlashCommand executed - tasks attached)**:
 ```json
 [
   {"content": "Create independent test session", "status": "completed", "activeForm": "Creating test session"},
@@ -267,7 +302,7 @@ allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*)
 ]
 ```
 
-**Note**: SlashCommand invocation **attaches** test-task-generate's 3 tasks. Orchestrator **executes** these tasks.
+**Note**: SlashCommand dispatch **attaches** test-task-generate's 3 tasks. Orchestrator **executes** these tasks.
 
 **Next Action**: Tasks attached → **Execute Phase 4.1-4.3** sequentially
 
@@ -307,7 +342,7 @@ Artifacts Created:
 
 Test Framework: [detected framework]
 Test Files to Generate: [count]
-Fix Mode: [Manual|Codex Automated] (based on --use-codex flag)
+Fix Mode: [Agent|CLI] (based on `command` field in implementation_approach steps)
 
 Review Generated Artifacts:
 - Test plan: .workflow/[testSessionId]/IMPL_PLAN.md
@@ -329,7 +364,7 @@ Ready for execution. Use appropriate workflow commands to proceed.
 
 ### Key Principles
 
-1. **Task Attachment** (when SlashCommand invoked):
+1. **Task Attachment** (when SlashCommand executed):
    - Sub-command's internal tasks are **attached** to orchestrator's TodoWrite
    - Example: `/workflow:tools:test-context-gather` attaches 3 sub-tasks (Phase 2.1, 2.2, 2.3)
    - First attached task marked as `in_progress`, others as `pending`
@@ -346,14 +381,14 @@ Ready for execution. Use appropriate workflow commands to proceed.
    - No user intervention required between phases
    - TodoWrite dynamically reflects current execution state
 
-**Lifecycle Summary**: Initial pending tasks → Phase invoked (tasks ATTACHED) → Sub-tasks executed sequentially → Phase completed (tasks COLLAPSED to summary) → Next phase begins → Repeat until all phases complete.
+**Lifecycle Summary**: Initial pending tasks → Phase executed (tasks ATTACHED) → Sub-tasks executed sequentially → Phase completed (tasks COLLAPSED to summary) → Next phase begins → Repeat until all phases complete.
 
 ### Test-Gen Specific Features
 
 - **Phase 2**: Cross-session context gathering from source implementation session
 - **Phase 3**: Test requirements analysis with Gemini for generation strategy
 - **Phase 4**: Dual-task generation (IMPL-001 for test generation, IMPL-002 for test execution)
-- **Fix Mode Configuration**: `--use-codex` flag controls IMPL-002 fix mode (manual vs automated)
+- **Fix Mode Configuration**: CLI tool usage determined semantically from user's task description
 
 
 
@@ -424,7 +459,7 @@ Generates two task definition files:
   - Agent: @test-fix-agent
   - Dependency: IMPL-001 must complete first
   - Max iterations: 5
-  - Fix mode: Manual or Codex (based on --use-codex flag)
+  - Fix mode: Agent or CLI (based on `command` field in implementation_approach)
 
 See `/workflow:tools:test-task-generate` for complete task JSON schemas.
 
@@ -461,11 +496,10 @@ Created in `.workflow/active/WFS-test-[session]/`:
 **IMPL-002.json Structure**:
 - `meta.type: "test-fix"`
 - `meta.agent: "@test-fix-agent"`
-- `meta.use_codex`: true/false (based on --use-codex flag)
 - `context.depends_on: ["IMPL-001"]`
 - `flow_control.implementation_approach.test_fix_cycle`: Complete cycle specification
   - Gemini diagnosis template
-  - Fix application mode (manual/codex)
+  - Fix application mode (agent or CLI based on `command` field)
   - Max iterations: 5
 - `flow_control.implementation_approach.modification_points`: 3-phase flow
 
@@ -483,13 +517,11 @@ See `/workflow:tools:test-task-generate` for complete JSON schemas.
 **Prerequisite Commands**:
 - `/workflow:plan` or `/workflow:execute` - Complete implementation session that needs test validation
 
-**Called by This Command** (5 phases):
+**Executed by This Command** (4 phases):
 - `/workflow:session:start` - Phase 1: Create independent test workflow session
 - `/workflow:tools:test-context-gather` - Phase 2: Analyze test coverage and gather source session context
 - `/workflow:tools:test-concept-enhanced` - Phase 3: Generate test requirements and strategy using Gemini
-- `/workflow:tools:test-task-generate` - Phase 4: Generate test task JSONs using action-planning-agent (autonomous, default)
-- `/workflow:tools:test-task-generate --use-codex` - Phase 4: With automated Codex fixes for IMPL-002 (when `--use-codex` flag used)
-- `/workflow:tools:test-task-generate --cli-execute` - Phase 4: With CLI execution mode for IMPL-001 test generation (when `--cli-execute` flag used)
+- `/workflow:tools:test-task-generate` - Phase 4: Generate test task JSONs (CLI tool usage determined semantically)
 
 **Follow-up Commands**:
 - `/workflow:status` - Review generated test tasks

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

@@ -1,12 +1,16 @@
 ---
 name: conflict-resolution
 description: Detect and resolve conflicts between plan and existing codebase using CLI-powered analysis with Gemini/Qwen
-argument-hint: "--session WFS-session-id --context path/to/context-package.json"
+argument-hint: "[-y|--yes] --session WFS-session-id --context path/to/context-package.json"
 examples:
   - /workflow:tools:conflict-resolution --session WFS-auth --context .workflow/active/WFS-auth/.process/context-package.json
-  - /workflow:tools:conflict-resolution --session WFS-payment --context .workflow/active/WFS-payment/.process/context-package.json
+  - /workflow:tools:conflict-resolution -y --session WFS-payment --context .workflow/active/WFS-payment/.process/context-package.json
 ---
 
+## Auto Mode
+
+When `--yes` or `-y`: Auto-select recommended strategy for each conflict, skip clarification questions.
+
 # Conflict Resolution Command
 
 ## Purpose
@@ -21,10 +25,10 @@ Analyzes conflicts between implementation plans and existing codebase, **includi
 | Responsibility | Description |
 |---------------|-------------|
 | **Detect Conflicts** | Analyze plan vs existing code inconsistencies |
-| **Scenario Uniqueness** | **NEW**: Search and compare new modules with existing modules for functional overlaps |
+| **Scenario Uniqueness** | Search and compare new modules with existing modules for functional overlaps |
 | **Generate Strategies** | Provide 2-4 resolution options per conflict |
-| **Iterative Clarification** | **NEW**: Ask unlimited questions until scenario boundaries are clear and unique |
-| **Agent Re-analysis** | **NEW**: Dynamically update strategies based on user clarifications |
+| **Iterative Clarification** | Ask unlimited questions until scenario boundaries are clear and unique |
+| **Agent Re-analysis** | Dynamically update strategies based on user clarifications |
 | **CLI Analysis** | Use Gemini/Qwen (Claude fallback) |
 | **User Decision** | Present options ONE BY ONE, never auto-apply |
 | **Direct Text Output** | Output questions via text directly, NEVER use bash echo/printf |
@@ -53,7 +57,7 @@ Analyzes conflicts between implementation plans and existing codebase, **includi
 - Breaking updates
 
 ### 5. Module Scenario Overlap
-- **NEW**: Functional overlap between new and existing modules
+- Functional overlap between new and existing modules
 - Scenario boundary ambiguity
 - Duplicate responsibility detection
 - Module merge/split decisions
@@ -108,42 +112,54 @@ Phase 4: Apply Modifications
 
 **Agent Delegation**:
 ```javascript
-Task(subagent_type="cli-execution-agent", prompt=`
+Task(subagent_type="cli-execution-agent", run_in_background=false, prompt=`
   ## Context
   - Session: {session_id}
   - Risk: {conflict_risk}
   - Files: {existing_files_list}
 
+  ## Exploration Context (from context-package.exploration_results)
+  - Exploration Count: ${contextPackage.exploration_results?.exploration_count || 0}
+  - Angles Analyzed: ${JSON.stringify(contextPackage.exploration_results?.angles || [])}
+  - Pre-identified Conflict Indicators: ${JSON.stringify(contextPackage.exploration_results?.aggregated_insights?.conflict_indicators || [])}
+  - Critical Files: ${JSON.stringify(contextPackage.exploration_results?.aggregated_insights?.critical_files?.map(f => f.path) || [])}
+  - All Patterns: ${JSON.stringify(contextPackage.exploration_results?.aggregated_insights?.all_patterns || [])}
+  - All Integration Points: ${JSON.stringify(contextPackage.exploration_results?.aggregated_insights?.all_integration_points || [])}
+
   ## Analysis Steps
 
+  ### 0. Load Output Schema (MANDATORY)
+  Execute: cat ~/.claude/workflows/cli-templates/schemas/conflict-resolution-schema.json
+
   ### 1. Load Context
   - Read existing files from conflict_detection.existing_files
   - Load plan from .workflow/active/{session_id}/.process/context-package.json
+  - Load exploration_results and use aggregated_insights for enhanced analysis
   - Extract role analyses and requirements
 
-  ### 2. Execute CLI Analysis (Enhanced with Scenario Uniqueness Detection)
+  ### 2. Execute CLI Analysis (Enhanced with Exploration + Scenario Uniqueness)
 
   Primary (Gemini):
-  cd {project_root} && gemini -p "
-  PURPOSE: Detect conflicts between plan and codebase, including module scenario overlaps
+  ccw cli -p "
+  PURPOSE: Detect conflicts between plan and codebase, using exploration insights
   TASK:
-  • Compare architectures
+  • **Review pre-identified conflict_indicators from exploration results**
+  • Compare architectures (use exploration key_patterns)
   • Identify breaking API changes
   • Detect data model incompatibilities
   • Assess dependency conflicts
-  • **NEW: Analyze module scenario uniqueness**
-    - Extract new module functionality from plan
-    - Search all existing modules with similar functionality
-    - Compare scenario coverage and identify overlaps
+  • **Analyze module scenario uniqueness**
+    - Use exploration integration_points for precise locations
+    - Cross-validate with exploration critical_files
     - Generate clarification questions for boundary definition
   MODE: analysis
   CONTEXT: @**/*.ts @**/*.js @**/*.tsx @**/*.jsx @.workflow/active/{session_id}/**/*
-  EXPECTED: Conflict list with severity ratings, including ModuleOverlap conflicts with:
-    - Existing module list with scenarios
-    - Overlap analysis matrix
+  EXPECTED: Conflict list with severity ratings, including:
+    - Validation of exploration conflict_indicators
+    - ModuleOverlap conflicts with overlap_analysis
     - Targeted clarification questions
-  RULES: $(cat ~/.claude/workflows/cli-templates/prompts/analysis/02-analyze-code-patterns.txt) | Focus on breaking changes, migration needs, and functional overlaps | analysis=READ-ONLY
-  "
+  CONSTRAINTS: Focus on breaking changes, migration needs, and functional overlaps | Prioritize exploration-identified conflicts | analysis=READ-ONLY
+  " --tool gemini --mode analysis --rule analysis-code-patterns --cd {project_root}
 
   Fallback: Qwen (same prompt) → Claude (manual analysis)
 
@@ -160,286 +176,117 @@ Task(subagent_type="cli-execution-agent", prompt=`
 
   ### 4. Return Structured Conflict Data
 
-  ⚠️ DO NOT generate CONFLICT_RESOLUTION.md file
+  ⚠️ Output to conflict-resolution.json (generated in Phase 4)
 
-  Return JSON format for programmatic processing:
+  **Schema Reference**: Execute \`cat ~/.claude/workflows/cli-templates/schemas/conflict-resolution-schema.json\` to get full schema
 
-  \`\`\`json
-  {
-    "conflicts": [
-      {
-        "id": "CON-001",
-        "brief": "一行中文冲突摘要",
-        "severity": "Critical|High|Medium",
-        "category": "Architecture|API|Data|Dependency|ModuleOverlap",
-        "affected_files": [
-          ".workflow/active/{session}/.brainstorm/guidance-specification.md",
-          ".workflow/active/{session}/.brainstorm/system-architect/analysis.md"
-        ],
-        "description": "详细描述冲突 - 什么不兼容",
-        "impact": {
-          "scope": "影响的模块/组件",
-          "compatibility": "Yes|No|Partial",
-          "migration_required": true|false,
-          "estimated_effort": "人天估计"
-        },
-        "overlap_analysis": {
-          "// NOTE": "仅当 category=ModuleOverlap 时需要此字段",
-          "new_module": {
-            "name": "新模块名称",
-            "scenarios": ["场景1", "场景2", "场景3"],
-            "responsibilities": "职责描述"
-          },
-          "existing_modules": [
-            {
-              "file": "src/existing/module.ts",
-              "name": "现有模块名称",
-              "scenarios": ["场景A", "场景B"],
-              "overlap_scenarios": ["重叠场景1", "重叠场景2"],
-              "responsibilities": "现有模块职责"
-            }
-          ]
-        },
-        "strategies": [
-          {
-            "name": "策略名称（中文）",
-            "approach": "实现方法简述",
-            "complexity": "Low|Medium|High",
-            "risk": "Low|Medium|High",
-            "effort": "时间估计",
-            "pros": ["优点1", "优点2"],
-            "cons": ["缺点1", "缺点2"],
-            "clarification_needed": [
-              "// NOTE: 仅当需要用户进一步澄清时需要此字段（尤其是 ModuleOverlap）",
-              "新模块的核心职责边界是什么？",
-              "如何与现有模块 X 协作？",
-              "哪些场景应该由新模块处理？"
-            ],
-            "modifications": [
-              {
-                "file": ".workflow/active/{session}/.brainstorm/guidance-specification.md",
-                "section": "## 2. System Architect Decisions",
-                "change_type": "update",
-                "old_content": "原始内容片段（用于定位）",
-                "new_content": "修改后的内容",
-                "rationale": "为什么这样改"
-              },
-              {
-                "file": ".workflow/active/{session}/.brainstorm/system-architect/analysis.md",
-                "section": "## Design Decisions",
-                "change_type": "update",
-                "old_content": "原始内容片段",
-                "new_content": "修改后的内容",
-                "rationale": "修改理由"
-              }
-            ]
-          },
-          {
-            "name": "策略2名称",
-            "approach": "...",
-            "complexity": "Medium",
-            "risk": "Low",
-            "effort": "1-2天",
-            "pros": ["优点"],
-            "cons": ["缺点"],
-            "modifications": [...]
-          }
-        ],
-        "recommended": 0,
-        "modification_suggestions": [
-          "建议1：具体的修改方向或注意事项",
-          "建议2：可能需要考虑的边界情况",
-          "建议3：相关的最佳实践或模式"
-        ]
-      }
-    ],
-    "summary": {
-      "total": 2,
-      "critical": 1,
-      "high": 1,
-      "medium": 0
-    }
-  }
-  \`\`\`
-
-  ⚠️ CRITICAL Requirements for modifications field:
-  - old_content: Must be exact text from target file (20-100 chars for unique match)
-  - new_content: Complete replacement text (maintains formatting)
-  - change_type: "update" (replace), "add" (insert), "remove" (delete)
-  - file: Full path relative to project root
-  - section: Markdown heading for context (helps locate position)
+  Return JSON following the schema above. Key requirements:
   - Minimum 2 strategies per conflict, max 4
-  - All text in Chinese for user-facing fields (brief, name, pros, cons)
-  - modification_suggestions: 2-5 actionable suggestions for custom handling (Chinese)
+  - All text in Chinese for user-facing fields (brief, name, pros, cons, modification_suggestions)
+  - modifications.old_content: 20-100 chars for unique Edit tool matching
+  - modifications.new_content: preserves markdown formatting
+  - modification_suggestions: 2-5 actionable suggestions for custom handling
 
-  Quality Standards:
-  - Each strategy must have actionable modifications
-  - old_content must be precise enough for Edit tool matching
-  - new_content preserves markdown formatting and structure
-  - Recommended strategy (index) based on lowest complexity + risk
-  - modification_suggestions must be specific, actionable, and context-aware
-  - Each suggestion should address a specific aspect (compatibility, migration, testing, etc.)
+  ### 5. Planning Notes Record (REQUIRED)
+  After analysis complete, append a brief execution record to planning-notes.md:
+
+  **File**: .workflow/active/{session_id}/planning-notes.md
+  **Location**: Under "## Conflict Decisions (Phase 3)" section
+  **Format**:
+  \`\`\`
+  ### [Conflict-Resolution Agent] YYYY-MM-DD
+  - **Note**: [智能补充：简短总结冲突类型、解决策略、关键决策等]
+  \`\`\`
 `)
 ```
 
-**Agent Internal Flow** (Enhanced):
-```
-1. Load context package
-2. Check conflict_risk (exit if none/low)
-3. Read existing files + plan artifacts
-4. Run CLI analysis (Gemini→Qwen→Claude) with enhanced tasks:
-   - Standard conflict detection (Architecture/API/Data/Dependency)
-   - **NEW: Module scenario uniqueness detection**
-     * Extract new module functionality from plan
-     * Search all existing modules with similar keywords/functionality
-     * Compare scenario coverage and responsibilities
-     * Identify functional overlaps and boundary ambiguities
-     * Generate ModuleOverlap conflicts with overlap_analysis
-5. Parse conflict findings (including ModuleOverlap category)
-6. Generate 2-4 strategies per conflict:
-   - Include modifications for each strategy
-   - **For ModuleOverlap**: Add clarification_needed questions for boundary definition
-7. Return JSON to stdout (NOT file write)
-8. Return execution log path
-```
+### Phase 3: User Interaction Loop
 
-### Phase 3: Iterative User Interaction with Clarification Loop
+```javascript
+const autoYes = $ARGUMENTS.includes('--yes') || $ARGUMENTS.includes('-y')
 
-**Execution Flow**:
-```
-FOR each conflict (逐个处理，无数量限制):
-  clarified = false
-  round = 0
-  userClarifications = []
+FOR each conflict:
+  round = 0, clarified = false, userClarifications = []
 
-  WHILE (!clarified && round < 10):
-    round++
+  WHILE (!clarified && round++ < 10):
+    // 1. Display conflict info (text output for context)
+    displayConflictSummary(conflict)  // id, brief, severity, overlap_analysis if ModuleOverlap
 
-    // 1. Display conflict (包含所有关键字段)
-    - category, id, brief, severity, description
-    - IF ModuleOverlap: 展示 overlap_analysis
-      * new_module: {name, scenarios, responsibilities}
-      * existing_modules[]: {file, name, scenarios, overlap_scenarios, responsibilities}
-
-    // 2. Display strategies (2-4个策略 + 自定义选项)
-    - FOR each strategy: {name, approach, complexity, risk, effort, pros, cons}
-      * IF clarification_needed: 展示待澄清问题列表
-    - 自定义选项: {suggestions: modification_suggestions[]}
-
-    // 3. User selects strategy
-    userChoice = readInput()
-
-    IF userChoice == "自定义":
-      customConflicts.push({id, brief, category, suggestions, overlap_analysis})
-      clarified = true
-      BREAK
-
-    selectedStrategy = strategies[userChoice]
-
-    // 4. Clarification loop
-    IF selectedStrategy.clarification_needed.length > 0:
-      // 收集澄清答案
-      FOR each question:
-        answer = readInput()
-        userClarifications.push({question, answer})
-
-      // Agent 重新分析
-      reanalysisResult = Task(cli-execution-agent, prompt={
-        冲突信息: {id, brief, category, 策略}
-        用户澄清: userClarifications[]
-        场景分析: overlap_analysis (if ModuleOverlap)
-
-        输出: {
-          uniqueness_confirmed: bool,
-          rationale: string,
-          updated_strategy: {name, approach, complexity, risk, effort, modifications[]},
-          remaining_questions: [] (如果仍有歧义)
-        }
+    // 2. Strategy selection
+    if (autoYes) {
+      console.log(`[--yes] Auto-selecting recommended strategy`)
+      selectedStrategy = conflict.strategies[conflict.recommended || 0]
+      clarified = true  // Skip clarification loop
+    } else {
+      AskUserQuestion({
+      questions: [{
+        question: formatStrategiesForDisplay(conflict.strategies),
+        header: "策略选择",
+        multiSelect: false,
+        options: [
+          ...conflict.strategies.map((s, i) => ({
+            label: `${s.name}${i === conflict.recommended ? ' (推荐)' : ''}`,
+            description: `${s.complexity}复杂度 | ${s.risk}风险${s.clarification_needed?.length ? ' | ⚠️需澄清' : ''}`
+          })),
+          { label: "自定义修改", description: `建议: ${conflict.modification_suggestions?.slice(0,2).join('; ')}` }
+        ]
+      }]
       })
 
-      IF reanalysisResult.uniqueness_confirmed:
-        selectedStrategy = updated_strategy
-        selectedStrategy.clarifications = userClarifications
-        clarified = true
-      ELSE:
-        // 更新澄清问题，继续下一轮
-        selectedStrategy.clarification_needed = remaining_questions
-    ELSE:
-      clarified = true
+      // 3. Handle selection
+      if (userChoice === "自定义修改") {
+        customConflicts.push({ id, brief, category, suggestions, overlap_analysis })
+        break
+      }
 
-    resolvedConflicts.push({conflict, strategy: selectedStrategy})
+      selectedStrategy = findStrategyByName(userChoice)
+    }
+
+    // 4. Clarification (if needed) - batched max 4 per call
+    if (!autoYes && selectedStrategy.clarification_needed?.length > 0) {
+      for (batch of chunk(selectedStrategy.clarification_needed, 4)) {
+        AskUserQuestion({
+          questions: batch.map((q, i) => ({
+            question: q, header: `澄清${i+1}`, multiSelect: false,
+            options: [{ label: "详细说明", description: "提供答案" }]
+          }))
+        })
+        userClarifications.push(...collectAnswers(batch))
+      }
+
+      // 5. Agent re-analysis
+      reanalysisResult = Task({
+        subagent_type: "cli-execution-agent",
+        run_in_background: false,
+        prompt: `Conflict: ${conflict.id}, Strategy: ${selectedStrategy.name}
+User Clarifications: ${JSON.stringify(userClarifications)}
+Output: { uniqueness_confirmed, rationale, updated_strategy, remaining_questions }`
+      })
+
+      if (reanalysisResult.uniqueness_confirmed) {
+        selectedStrategy = { ...reanalysisResult.updated_strategy, clarifications: userClarifications }
+        clarified = true
+      } else {
+        selectedStrategy.clarification_needed = reanalysisResult.remaining_questions
+      }
+    } else {
+      clarified = true
+    }
+
+    if (clarified) resolvedConflicts.push({ conflict, strategy: selectedStrategy })
   END WHILE
 END FOR
 
-// Build output
 selectedStrategies = resolvedConflicts.map(r => ({
-  conflict_id, strategy, clarifications[]
+  conflict_id: r.conflict.id, strategy: r.strategy, clarifications: r.strategy.clarifications || []
 }))
 ```
 
-**Key Data Structures**:
-
-```javascript
-// Custom conflict tracking
-customConflicts[] = {
-  id, brief, category,
-  suggestions: modification_suggestions[],
-  overlap_analysis: { new_module{}, existing_modules[] }  // ModuleOverlap only
-}
-
-// Agent re-analysis prompt output
-{
-  uniqueness_confirmed: bool,
-  rationale: string,
-  updated_strategy: {
-    name, approach, complexity, risk, effort,
-    modifications: [{file, section, change_type, old_content, new_content, rationale}]
-  },
-  remaining_questions: string[]
-}
-```
-
-**Text Output Example** (展示关键字段):
-
-```markdown
-============================================================
-冲突 1/3 - 第 1 轮
-============================================================
-【ModuleOverlap】CON-001: 新增用户认证服务与现有模块功能重叠
-严重程度: High | 描述: 计划中的 UserAuthService 与现有 AuthManager 场景重叠
-
---- 场景重叠分析 ---
-新模块: UserAuthService | 场景: 登录, Token验证, 权限, MFA
-现有模块: AuthManager (src/auth/AuthManager.ts) | 重叠: 登录, Token验证
-
---- 解决策略 ---
-1) 合并 (Low复杂度 | Low风险 | 2-3天)
-   ⚠️ 需澄清: AuthManager是否能承担MFA？
-
-2) 拆分边界 (Medium复杂度 | Medium风险 | 4-5天)
-   ⚠️ 需澄清: 基础/高级认证边界? Token验证归谁?
-
-3) 自定义修改
-   建议: 评估扩展性; 策略模式分离; 定义接口边界
-
-请选择 (1-3): > 2
-
---- 澄清问答 (第1轮) ---
-Q: 基础/高级认证边界?
-A: 基础=密码登录+token验证, 高级=MFA+OAuth+SSO
-
-Q: Token验证归谁?
-A: 统一由 AuthManager 负责
-
-🔄 重新分析...
-✅ 唯一性已确认 | 理由: 边界清晰 - AuthManager(基础+token), UserAuthService(MFA+OAuth+SSO)
-
-============================================================
-冲突 2/3 - 第 1 轮 [下一个冲突]
-============================================================
-```
-
-**Loop Characteristics**: 逐个处理 | 无限轮次(max 10) | 动态问题生成 | Agent重新分析判断唯一性 | ModuleOverlap场景边界澄清
+**Key Points**:
+- AskUserQuestion: max 4 questions/call, batch if more
+- Strategy options: 2-4 strategies + "自定义修改"
+- Clarification loop: max 10 rounds, agent判断 uniqueness_confirmed
+- Custom conflicts: 记录 overlap_analysis 供后续手动处理
 
 ### Phase 4: Apply Modifications
 
@@ -458,14 +305,30 @@ selectedStrategies.forEach(item => {
 
 console.log(`\n正在应用 ${modifications.length} 个修改...`);
 
-// 2. Apply each modification using Edit tool
+// 2. Apply each modification using Edit tool (with fallback to context-package.json)
 const appliedModifications = [];
 const failedModifications = [];
+const fallbackConstraints = [];  // For files that don't exist
 
 modifications.forEach((mod, idx) => {
   try {
     console.log(`[${idx + 1}/${modifications.length}] 修改 ${mod.file}...`);
 
+    // Check if target file exists (brainstorm files may not exist in lite workflow)
+    if (!file_exists(mod.file)) {
+      console.log(`  ⚠️ 文件不存在，写入 context-package.json 作为约束`);
+      fallbackConstraints.push({
+        source: "conflict-resolution",
+        conflict_id: mod.conflict_id,
+        target_file: mod.file,
+        section: mod.section,
+        change_type: mod.change_type,
+        content: mod.new_content,
+        rationale: mod.rationale
+      });
+      return;  // Skip to next modification
+    }
+
     if (mod.change_type === "update") {
       Edit({
         file_path: mod.file,
@@ -493,14 +356,45 @@ modifications.forEach((mod, idx) => {
   }
 });
 
-// 3. Update context-package.json with resolution details
+// 2b. Generate conflict-resolution.json output file
+const resolutionOutput = {
+  session_id: sessionId,
+  resolved_at: new Date().toISOString(),
+  summary: {
+    total_conflicts: conflicts.length,
+    resolved_with_strategy: selectedStrategies.length,
+    custom_handling: customConflicts.length,
+    fallback_constraints: fallbackConstraints.length
+  },
+  resolved_conflicts: selectedStrategies.map(s => ({
+    conflict_id: s.conflict_id,
+    strategy_name: s.strategy.name,
+    strategy_approach: s.strategy.approach,
+    clarifications: s.clarifications || [],
+    modifications_applied: s.strategy.modifications?.filter(m =>
+      appliedModifications.some(am => am.conflict_id === s.conflict_id)
+    ) || []
+  })),
+  custom_conflicts: customConflicts.map(c => ({
+    id: c.id,
+    brief: c.brief,
+    category: c.category,
+    suggestions: c.suggestions,
+    overlap_analysis: c.overlap_analysis || null
+  })),
+  planning_constraints: fallbackConstraints,  // Constraints for files that don't exist
+  failed_modifications: failedModifications
+};
+
+const resolutionPath = `.workflow/active/${sessionId}/.process/conflict-resolution.json`;
+Write(resolutionPath, JSON.stringify(resolutionOutput, null, 2));
+console.log(`\n📄 冲突解决结果已保存: ${resolutionPath}`);
+
+// 3. Update context-package.json with resolution details (reference to JSON file)
 const contextPackage = JSON.parse(Read(contextPath));
 contextPackage.conflict_detection.conflict_risk = "resolved";
-contextPackage.conflict_detection.resolved_conflicts = selectedStrategies.map(s => ({
-  conflict_id: s.conflict_id,
-  strategy_name: s.strategy.name,
-  clarifications: s.clarifications
-}));
+contextPackage.conflict_detection.resolution_file = resolutionPath;  // Reference to detailed JSON
+contextPackage.conflict_detection.resolved_conflicts = selectedStrategies.map(s => s.conflict_id);
 contextPackage.conflict_detection.custom_conflicts = customConflicts.map(c => c.id);
 contextPackage.conflict_detection.resolved_at = new Date().toISOString();
 Write(contextPath, JSON.stringify(contextPackage, null, 2));
@@ -573,12 +467,50 @@ return {
 ✓ Agent log saved to .workflow/active/{session_id}/.chat/
 ```
 
-## Output Format: Agent JSON Response
+## Output Format
+
+### Primary Output: conflict-resolution.json
+
+**Path**: `.workflow/active/{session_id}/.process/conflict-resolution.json`
+
+**Schema**:
+```json
+{
+  "session_id": "WFS-xxx",
+  "resolved_at": "ISO timestamp",
+  "summary": {
+    "total_conflicts": 3,
+    "resolved_with_strategy": 2,
+    "custom_handling": 1,
+    "fallback_constraints": 0
+  },
+  "resolved_conflicts": [
+    {
+      "conflict_id": "CON-001",
+      "strategy_name": "策略名称",
+      "strategy_approach": "实现方法",
+      "clarifications": [],
+      "modifications_applied": []
+    }
+  ],
+  "custom_conflicts": [
+    {
+      "id": "CON-002",
+      "brief": "冲突摘要",
+      "category": "ModuleOverlap",
+      "suggestions": ["建议1", "建议2"],
+      "overlap_analysis": null
+    }
+  ],
+  "planning_constraints": [],
+  "failed_modifications": []
+}
+```
+
+### Secondary: Agent JSON Response (stdout)
 
 **Focus**: Structured conflict data with actionable modifications for programmatic processing.
 
-**Format**: JSON to stdout (NO file generation)
-
 **Structure**: Defined in Phase 2, Step 4 (agent prompt)
 
 ### Key Requirements
@@ -626,11 +558,12 @@ If Edit tool fails mid-application:
 - Requires: `conflict_risk ≥ medium`
 
 **Output**:
-- Modified files:
+- Generated file:
+  - `.workflow/active/{session_id}/.process/conflict-resolution.json` (primary output)
+- Modified files (if exist):
   - `.workflow/active/{session_id}/.brainstorm/guidance-specification.md`
   - `.workflow/active/{session_id}/.brainstorm/{role}/analysis.md`
-  - `.workflow/active/{session_id}/.process/context-package.json` (conflict_risk → resolved)
-- NO report file generation
+  - `.workflow/active/{session_id}/.process/context-package.json` (conflict_risk → resolved, resolution_file reference)
 
 **User Interaction**:
 - **Iterative conflict processing**: One conflict at a time, not in batches
@@ -658,7 +591,7 @@ If Edit tool fails mid-application:
 ✓ guidance-specification.md updated with resolved conflicts
 ✓ Role analyses (*.md) updated with resolved conflicts
 ✓ context-package.json marked as "resolved" with clarification records
-✓ No CONFLICT_RESOLUTION.md file generated
+✓ conflict-resolution.json generated with full resolution details
 ✓ Modification summary includes:
   - Total conflicts
   - Resolved with strategy (count)