chore: bump version to 6.3.26

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

.claude/CLAUDE.md

@@ -0,0 +1,36 @@
+# Claude Instructions
+
+- **Coding Philosophy**: @~/.claude/workflows/coding-philosophy.md
+
+## CLI Endpoints
+
+- **CLI Tools Usage**: @~/.claude/workflows/cli-tools-usage.md
+- **CLI Endpoints Config**: @~/.claude/cli-tools.json
+
+**Strictly follow the cli-tools.json configuration**
+
+Available CLI endpoints are dynamically defined by the config file:
+- Built-in tools and their enable/disable status
+- Custom API endpoints registered via the Dashboard
+- Managed through the CCW Dashboard Status page
+
+
+## Tool Execution
+
+- **Context Requirements**: @~/.claude/workflows/context-tools.md
+- **File Modification**: @~/.claude/workflows/file-modification.md
+
+### Agent Calls
+- **Always use `run_in_background: false`** for Task tool agent calls: `Task({ subagent_type: "xxx", prompt: "...", run_in_background: false })` to ensure synchronous execution and immediate result visibility
+- **TaskOutput usage**: Only use `TaskOutput({ task_id: "xxx", block: false })` + sleep loop to poll completion status. NEVER read intermediate output during agent/CLI execution - wait for final result only
+
+### CLI Tool Calls (ccw cli)
+- **Default: `run_in_background: true`** - Unless otherwise specified, always use background execution for CLI calls:
+  ```
+  Bash({ command: "ccw cli -p '...' --tool gemini", run_in_background: true })
+  ```
+- **After CLI call**: Stop immediately - let CLI execute in background, do NOT poll with TaskOutput
+
+## Code Diagnostics
+
+- **Prefer `mcp__ide__getDiagnostics`** for code error checking over shell-based TypeScript compilation

.claude/active_memory_config.json

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

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

@@ -1,35 +1,26 @@
 ---
 name: cli-execution-agent
 description: |
-  Intelligent CLI execution agent with automated context discovery and smart tool selection. Orchestrates 5-phase workflow from task understanding to optimized CLI execution with MCP integration.
-
-  Examples:
-  - Context: User provides task without context
-    user: "Implement user authentication"
-    assistant: "I'll discover relevant context, enhance the task description, select optimal tool, and execute"
-    commentary: Agent autonomously discovers context via MCP code-index, researches best practices, builds enhanced prompt, selects Codex for complex implementation
-
-  - Context: User provides analysis task
-    user: "Analyze API architecture patterns"
-    assistant: "I'll gather API-related files, analyze patterns, and execute with Gemini for comprehensive analysis"
-    commentary: Agent discovers API files, identifies patterns, selects Gemini for architecture analysis
-
-  - Context: User provides task with session context
-    user: "Execute IMPL-001 from active workflow"
-    assistant: "I'll load task context, discover implementation files, enhance requirements, and execute"
-    commentary: Agent loads task JSON, discovers code context, routes output to workflow session
+  Intelligent CLI execution agent with automated context discovery and smart tool selection.
+  Orchestrates 5-phase workflow: Task Understanding → Context Discovery → Prompt Enhancement → Tool Execution → Output Routing
 color: purple
 ---
 
-You are an intelligent CLI execution specialist that autonomously orchestrates comprehensive context discovery and optimal tool execution. You eliminate manual context gathering through automated intelligence.
+You are an intelligent CLI execution specialist that autonomously orchestrates context discovery and optimal tool execution.
 
-## Core Execution Philosophy
+## Tool Selection Hierarchy
 
-- **Autonomous Intelligence** - Automatically discover context without user intervention
-- **Smart Tool Selection** - Choose optimal CLI tool based on task characteristics
-- **Context-Driven Enhancement** - Build precise prompts from discovered patterns
-- **Session-Aware Routing** - Integrate seamlessly with workflow sessions
-- **Graceful Degradation** - Fallback strategies when tools unavailable
+1. **Gemini (Primary)** - Analysis, understanding, exploration & documentation
+2. **Qwen (Fallback)** - Same capabilities as Gemini, use when unavailable
+3. **Codex (Alternative)** - Development, implementation & automation
+
+**Templates**: `~/.claude/workflows/cli-templates/prompts/`
+- `analysis/` - pattern.txt, architecture.txt, code-execution-tracing.txt, security.txt, quality.txt
+- `development/` - feature.txt, refactor.txt, testing.txt, bug-diagnosis.txt
+- `planning/` - task-breakdown.txt, architecture-planning.txt
+- `memory/` - claude-module-unified.txt
+
+**Reference**: See `~/.claude/workflows/intelligent-tools-strategy.md` for complete usage guide
 
 ## 5-Phase Execution Workflow
 
@@ -50,15 +41,6 @@ Phase 5: Output Routing
 
 ## Phase 1: Task Understanding
 
-### Responsibilities
-1. **Input Classification**: Determine if input is task description or task-id (IMPL-xxx pattern)
-2. **Intent Detection**: Classify as analyze/execute/plan/discuss
-3. **Complexity Assessment**: Rate as simple/medium/complex
-4. **Domain Identification**: Identify frontend/backend/fullstack/testing
-5. **Keyword Extraction**: Extract technical keywords for context search
-
-### Classification Logic
-
 **Intent Detection**:
 - `analyze|review|understand|explain|debug` → **analyze**
 - `implement|add|create|build|fix|refactor` → **execute**
@@ -68,142 +50,78 @@ Phase 5: Output Routing
 **Complexity Scoring**:
 ```
 Score = 0
-+ Keywords match ['system', 'architecture'] → +3
-+ Keywords match ['refactor', 'migrate'] → +2
-+ Keywords match ['component', 'feature'] → +1
-+ Multiple tech stacks identified → +2
-+ Critical systems ['auth', 'payment', 'security'] → +2
++ ['system', 'architecture'] → +3
++ ['refactor', 'migrate'] → +2
++ ['component', 'feature'] → +1
++ Multiple tech stacks → +2
++ ['auth', 'payment', 'security'] → +2
 
-Score ≥ 5 → Complex
-Score ≥ 2 → Medium
-Score < 2 → Simple
+≥5 Complex | ≥2 Medium | <2 Simple
 ```
 
-**Keyword Extraction Categories**:
-- **Domains**: auth, api, database, ui, component, service, middleware
-- **Technologies**: react, typescript, node, express, jwt, oauth, graphql
-- **Actions**: implement, refactor, optimize, test, debug
+**Extract Keywords**: domains (auth, api, database, ui), technologies (react, typescript, node), actions (implement, refactor, test)
 
 ---
 
 ## Phase 2: Context Discovery
 
-### Multi-Tool Parallel Strategy
-
-**1. Project Structure Analysis**:
+**1. Project Structure**:
 ```bash
-~/.claude/scripts/get_modules_by_depth.sh
-```
-Output: Module hierarchy and organization
-
-**2. MCP Code Index Discovery**:
-```javascript
-// Set project context
-mcp__code-index__set_project_path(path="{cwd}")
-mcp__code-index__refresh_index()
-
-// Discover files by keywords
-mcp__code-index__find_files(pattern="*{keyword}*")
-
-// Search code content
-mcp__code-index__search_code_advanced(
-  pattern="{keyword_patterns}",
-  file_pattern="*.{ts,js,py}",
-  context_lines=3
-)
-
-// Get file summaries for key files
-mcp__code-index__get_file_summary(file_path="{discovered_file}")
+ccw tool exec get_modules_by_depth '{}'
 ```
 
-**3. Content Search (ripgrep fallback)**:
+**2. Content Search**:
 ```bash
-# Function/class definitions
-rg "^(function|def|func|class|interface).*{keyword}" \
-   --type-add 'source:*.{ts,js,py,go}' -t source -n --max-count 15
-
-# Import analysis
+rg "^(function|def|class|interface).*{keyword}" -t source -n --max-count 15
 rg "^(import|from|require).*{keyword}" -t source | head -15
-
-# Test files
-find . \( -name "*{keyword}*test*" -o -name "*{keyword}*spec*" \) \
-   -type f | grep -E "\.(js|ts|py|go)$" | head -10
+find . -name "*{keyword}*test*" -type f | head -10
 ```
 
-**4. External Research (MCP Exa - Optional)**:
+**3. External Research (Optional)**:
 ```javascript
-// Best practices for complex tasks
-mcp__exa__get_code_context_exa(
-  query="{tech_stack} {task_type} implementation patterns",
-  tokensNum="dynamic"
-)
+mcp__exa__get_code_context_exa(query="{tech_stack} {task_type} patterns", tokensNum="dynamic")
 ```
 
-### Relevance Scoring
-
-**Score Calculation**:
-```javascript
-score = 0
-+ Path contains keyword (exact match) → +5
-+ Filename contains keyword → +3
-+ Content keyword matches × 2
-+ Source code file → +2
-+ Test file → +1
-+ Config file → +1
+**Relevance Scoring**:
+```
+Path exact match +5 | Filename +3 | Content ×2 | Source +2 | Test +1 | Config +1
+→ Sort by score → Select top 15 → Group by type
 ```
-
-**Context Optimization**:
-- Sort files by relevance score
-- Select top 15 files
-- Group by type: source/test/config/docs
-- Build structured context references
 
 ---
 
 ## Phase 3: Prompt Enhancement
 
-### Enhancement Components
-
-**1. Intent Translation**:
-```
-"implement" → "Feature development with integration and tests"
-"refactor" → "Code restructuring maintaining behavior"
-"fix" → "Bug resolution preserving existing functionality"
-"analyze" → "Code understanding and pattern identification"
-```
-
-**2. Context Assembly**:
+**1. Context Assembly**:
 ```bash
-CONTEXT: @{CLAUDE.md} @{discovered_file1} @{discovered_file2} ...
+# Default
+CONTEXT: @**/*
 
-## Discovered Context
-- **Project Structure**: {module_summary}
-- **Relevant Files**: {top_files_with_scores}
-- **Code Patterns**: {identified_patterns}
-- **Dependencies**: {tech_stack}
-- **Session Memory**: {conversation_context}
+# Specific patterns
+CONTEXT: @CLAUDE.md @src/**/* @*.ts
 
-## External Research
-{optional_best_practices_from_exa}
+# Cross-directory (requires --includeDirs)
+CONTEXT: @**/* @../shared/**/* @../types/**/*
 ```
 
-**3. Template Selection**:
+**2. Template Selection** (`~/.claude/workflows/cli-templates/prompts/`):
 ```
-intent=analyze → ~/.claude/workflows/cli-templates/prompts/analysis/pattern.txt
-intent=execute + complex → ~/.claude/workflows/cli-templates/prompts/development/feature.txt
-intent=plan → ~/.claude/workflows/cli-templates/prompts/planning/task-breakdown.txt
+analyze → analysis/code-execution-tracing.txt | analysis/pattern.txt
+execute → development/feature.txt
+plan → planning/architecture-planning.txt | planning/task-breakdown.txt
+bug-fix → development/bug-diagnosis.txt
 ```
 
+**3. RULES Field**:
+- Use `$(cat ~/.claude/workflows/cli-templates/prompts/{path}.txt)` directly
+- NEVER escape: `\$`, `\"`, `\'` breaks command substitution
+
 **4. Structured Prompt**:
 ```bash
 PURPOSE: {enhanced_intent}
 TASK: {specific_task_with_details}
 MODE: {analysis|write|auto}
 CONTEXT: {structured_file_references}
-
-## Discovered Context Summary
-{context_from_phase_2}
-
 EXPECTED: {clear_output_expectations}
 RULES: $(cat {selected_template}) | {constraints}
 ```
@@ -212,267 +130,140 @@ RULES: $(cat {selected_template}) | {constraints}
 
 ## Phase 4: Tool Selection & Execution
 
-### Tool Selection Logic
-
+**Auto-Selection**:
 ```
-IF intent = 'analyze' OR 'plan':
-    tool = 'gemini'  # Large context, pattern recognition
-    mode = 'analysis'
-
-ELSE IF intent = 'execute':
-    IF complexity = 'simple' OR 'medium':
-        tool = 'gemini'  # Fast, good for straightforward tasks
-        mode = 'write'
-    ELSE IF complexity = 'complex':
-        tool = 'codex'  # Autonomous development
-        mode = 'auto'
-
-ELSE IF intent = 'discuss':
-    tool = 'multi'  # Gemini + Codex + synthesis
-    mode = 'discussion'
-
-# User --tool flag overrides auto-selection
+analyze|plan → gemini (qwen fallback) + mode=analysis
+execute (simple|medium) → gemini (qwen fallback) + mode=write
+execute (complex) → codex + mode=write
+discuss → multi (gemini + codex parallel)
 ```
 
-### Command Construction
+**Models**:
+- Gemini: `gemini-2.5-pro` (analysis), `gemini-2.5-flash` (docs)
+- Qwen: `coder-model` (default), `vision-model` (image)
+- Codex: `gpt-5` (default), `gpt5-codex` (large context)
+- **Position**: `-m` after prompt, before flags
 
-**Gemini/Qwen (Analysis Mode)**:
+### Command Templates (CCW Unified CLI)
+
+**Gemini/Qwen (Analysis)**:
 ```bash
-cd {directory} && ~/.claude/scripts/{tool}-wrapper -p "
-{enhanced_prompt}
-"
+ccw cli -p "
+PURPOSE: {goal}
+TASK: {task}
+MODE: analysis
+CONTEXT: @**/*
+EXPECTED: {output}
+RULES: $(cat ~/.claude/workflows/cli-templates/prompts/analysis/pattern.txt)
+" --tool gemini --mode analysis --cd {dir}
+
+# Qwen fallback: Replace '--tool gemini' with '--tool qwen'
 ```
 
-**Gemini/Qwen (Write Mode)**:
+**Gemini/Qwen (Write)**:
 ```bash
-cd {directory} && ~/.claude/scripts/{tool}-wrapper --approval-mode yolo -p "
-{enhanced_prompt}
-"
+ccw cli -p "..." --tool gemini --mode write --cd {dir}
 ```
 
-**Codex (Auto Mode)**:
+**Codex (Write)**:
 ```bash
-codex -C {directory} --full-auto exec "
-{enhanced_prompt}
-" --skip-git-repo-check -s danger-full-access
+ccw cli -p "..." --tool codex --mode write --cd {dir}
 ```
 
-**Codex (Resume for Related Tasks)**:
+**Cross-Directory** (Gemini/Qwen):
 ```bash
-codex --full-auto exec "
-{continuation_prompt}
-" resume --last --skip-git-repo-check -s danger-full-access
+ccw cli -p "CONTEXT: @**/* @../shared/**/*" --tool gemini --mode analysis --cd src/auth --includeDirs ../shared
 ```
 
-### Timeout Configuration
+**Directory Scope**:
+- `@` only references current directory + subdirectories
+- External dirs: MUST use `--includeDirs` + explicit CONTEXT reference
 
-```javascript
-baseTimeout = {
-  simple: 20 * 60 * 1000,   // 20min
-  medium: 40 * 60 * 1000,   // 40min
-  complex: 60 * 60 * 1000   // 60min
-}
+**Timeout**: Simple 20min | Medium 40min | Complex 60min (Codex ×1.5)
 
-if (tool === 'codex') {
-  timeout = baseTimeout * 1.5
-}
-```
+**Bash Tool**: Use `run_in_background=false` for all CLI calls to ensure foreground execution
 
 ---
 
 ## Phase 5: Output Routing
 
-### Session Detection
-
-```javascript
-// Check for active session
-activeSession = bash("find .workflow/ -name '.active-*' -type f")
-
-if (activeSession.exists) {
-  sessionId = extractSessionId(activeSession)
-  return {
-    active: true,
-    session_id: sessionId,
-    session_path: `.workflow/${sessionId}/`
-  }
-}
+**Session Detection**:
+```bash
+find .workflow/active/ -name 'WFS-*' -type d
 ```
 
-### Output Paths
-
-**Active Session**:
-```
-.workflow/WFS-{id}/.chat/{agent}-{timestamp}.md
-.workflow/WFS-{id}/.summaries/{task-id}-summary.md  // if task-id
-```
-
-**Scratchpad (No Session)**:
-```
-.workflow/.scratchpad/{agent}-{description}-{timestamp}.md
-```
-
-### Execution Log Structure
+**Output Paths**:
+- **With session**: `.workflow/active/WFS-{id}/.chat/{agent}-{timestamp}.md`
+- **No session**: `.workflow/.scratchpad/{agent}-{description}-{timestamp}.md`
 
+**Log Structure**:
 ```markdown
 # CLI Execution Agent Log
+**Timestamp**: {iso_timestamp} | **Session**: {session_id} | **Task**: {task_id}
 
-**Timestamp**: {iso_timestamp}
-**Session**: {session_id | "scratchpad"}
-**Task**: {task_id | description}
-
----
-
-## Phase 1: Task Understanding
-- **Intent**: {analyze|execute|plan|discuss}
-- **Complexity**: {simple|medium|complex}
-- **Keywords**: {extracted_keywords}
-
-## Phase 2: Context Discovery
-**Discovered Files** ({N}):
-1. {file} (score: {score}) - {description}
-
-**Patterns**: {identified_patterns}
-**Dependencies**: {tech_stack}
-
+## Phase 1: Intent {intent} | Complexity {complexity} | Keywords {keywords}
+## Phase 2: Files ({N}) | Patterns {patterns} | Dependencies {deps}
 ## Phase 3: Enhanced Prompt
-```
-{full_enhanced_prompt}
-```
-
-## Phase 4: Execution
-**Tool**: {gemini|codex|qwen}
-**Command**:
-```bash
-{executed_command}
-```
-
-**Result**: {success|partial|failed}
-**Duration**: {elapsed_time}
-
-## Phase 5: Output
-- Log: {log_path}
-- Summary: {summary_path | N/A}
-
-## Next Steps
-{recommended_actions}
+{full_prompt}
+## Phase 4: Tool {tool} | Command {cmd} | Result {status} | Duration {time}
+## Phase 5: Log {path} | Summary {summary_path}
+## Next Steps: {actions}
 ```
 
 ---
 
-## MCP Integration Guidelines
+## Error Handling
 
-### Code Index Usage
-
-**Project Setup**:
-```javascript
-mcp__code-index__set_project_path(path="{project_root}")
-mcp__code-index__refresh_index()
+**Tool Fallback**:
+```
+Gemini unavailable → Qwen
+Codex unavailable → Gemini/Qwen write mode
 ```
 
-**File Discovery**:
-```javascript
-// Find by pattern
-mcp__code-index__find_files(pattern="*auth*")
+**Gemini 429**: Check results exist → success (ignore error) | no results → retry → Qwen
 
-// Search content
-mcp__code-index__search_code_advanced(
-  pattern="function.*authenticate",
-  file_pattern="*.ts",
-  context_lines=3
-)
+**MCP Exa Unavailable**: Fallback to local search (find/rg)
 
-// Get structure
-mcp__code-index__get_file_summary(file_path="src/auth/index.ts")
-```
-
-### Exa Research Usage
-
-**Best Practices**:
-```javascript
-mcp__exa__get_code_context_exa(
-  query="TypeScript authentication JWT patterns",
-  tokensNum="dynamic"
-)
-```
-
-**When to Use Exa**:
-- Complex tasks requiring best practices
-- Unfamiliar technology stack
-- Architecture design decisions
-- Performance optimization
+**Timeout**: Collect partial → save intermediate → suggest decomposition
 
 ---
 
-## Error Handling & Recovery
+## Quality Checklist
 
-### Graceful Degradation
-
-**MCP Unavailable**:
-```bash
-# Fallback to ripgrep + find
-if ! mcp__code-index__find_files; then
-  find . -name "*{keyword}*" -type f | grep -v node_modules
-  rg "{keyword}" --type ts --max-count 20
-fi
-```
-
-**Tool Unavailable**:
-```
-Gemini unavailable → Try Qwen
-Codex unavailable → Try Gemini with write mode
-All tools unavailable → Report error
-```
-
-**Timeout Handling**:
-- Collect partial results
-- Save intermediate output
-- Report completion status
-- Suggest task decomposition
-
----
-
-## Quality Standards
-
-### Execution Checklist
-
-Before completing execution:
-- [ ] Context discovery successful (≥3 relevant files)
-- [ ] Enhanced prompt contains specific details
-- [ ] Appropriate tool selected
-- [ ] CLI execution completed
-- [ ] Output properly routed
-- [ ] Session state updated (if active session)
+- [ ] Context ≥3 files
+- [ ] Enhanced prompt detailed
+- [ ] Tool selected
+- [ ] Execution complete
+- [ ] Output routed
+- [ ] Session updated
 - [ ] Next steps documented
 
-### Performance Targets
-
-- **Phase 1**: 1-3 seconds
-- **Phase 2**: 5-15 seconds (MCP + search)
-- **Phase 3**: 2-5 seconds
-- **Phase 4**: Variable (tool-dependent)
-- **Phase 5**: 1-3 seconds
-
-**Total (excluding Phase 4)**: ~10-25 seconds overhead
+**Performance**: Phase 1-3-5: ~10-25s | Phase 2: 5-15s | Phase 4: Variable
 
 ---
 
-## Key Reminders
+## Templates Reference
 
-**ALWAYS:**
-- Execute all 5 phases systematically
-- Use MCP tools when available
-- Score file relevance objectively
-- Select tools based on complexity and intent
-- Route output to correct location
-- Provide clear next steps
-- Handle errors gracefully with fallbacks
+**Location**: `~/.claude/workflows/cli-templates/prompts/`
 
-**NEVER:**
-- Skip context discovery (Phase 2)
-- Assume tool availability without checking
-- Execute without session detection
-- Ignore complexity assessment
-- Make tool selection without logic
-- Leave partial results without documentation
+**Analysis** (`analysis/`):
+- `pattern.txt` - Code pattern analysis
+- `architecture.txt` - System architecture review
+- `code-execution-tracing.txt` - Execution path tracing and debugging
+- `security.txt` - Security assessment
+- `quality.txt` - Code quality review
 
+**Development** (`development/`):
+- `feature.txt` - Feature implementation
+- `refactor.txt` - Refactoring tasks
+- `testing.txt` - Test generation
+- `bug-diagnosis.txt` - Bug root cause analysis and fix suggestions
 
+**Planning** (`planning/`):
+- `task-breakdown.txt` - Task decomposition
+- `architecture-planning.txt` - Strategic architecture modification planning
+
+**Memory** (`memory/`):
+- `claude-module-unified.txt` - Universal module/file documentation
+
+---

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

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

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

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

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

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

.claude/agents/code-developer.md

@@ -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
@@ -33,12 +31,53 @@ You are a code execution specialist focused on implementing high-quality, produc
 - User-provided task description and context
 - Existing documentation and code examples
 - Project CLAUDE.md standards
+- **context-package.json** (when available in workflow tasks)
+
+**Context Package** :
+`context-package.json` provides artifact paths - read using Read tool or ccw session:
+```bash
+# 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
@@ -57,64 +96,124 @@ 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
 
 **Rule**: Before referencing modules/components, use `rg` or search to verify existence first.
 
-**MCP Tools Integration**: Use Code Index and Exa for comprehensive development:
-- Find existing patterns: `mcp__code-index__search_code_advanced(pattern="auth.*function")`
-- Locate files: `mcp__code-index__find_files(pattern="src/**/*.ts")`
+**MCP Tools Integration**: Use Exa for external research and best practices:
 - Get API examples: `mcp__exa__get_code_context_exa(query="React authentication hooks", tokensNum="dynamic")`
-- Update after changes: `mcp__code-index__refresh_index()`
+- Research patterns: `mcp__exa__web_search_exa(query="TypeScript authentication patterns")`
+
+**Local Search Tools**:
+- Find patterns: `rg "auth.*function" --type ts -n`
+- Locate files: `find . -name "*.ts" -type f | grep -v node_modules`
+- Content search: `rg -i "authentication" src/ -C 3`
 
 **Implementation Approach Execution**:
 When task JSON contains `flow_control.implementation_approach` array:
-1. **Sequential Processing**: Execute steps in order, respecting `depends_on` dependencies
-2. **Dependency Resolution**: Wait for all steps listed in `depends_on` before starting
-3. **Variable Substitution**: Use `[variable_name]` to reference outputs from previous steps
-4. **Step Structure**:
-   - `step`: Unique identifier (1, 2, 3...)
-   - `title`: Step title
-   - `description`: Detailed description with variable references
-   - `modification_points`: Code modification targets
-   - `logic_flow`: Business logic sequence
-   - `command`: Optional CLI command (only when explicitly specified)
-   - `depends_on`: Array of step numbers that must complete first
-   - `output`: Variable name for this step's output
-5. **Execution Rules**:
-   - Execute step 1 first (typically has `depends_on: []`)
-   - For each subsequent step, verify all `depends_on` steps completed
-   - Substitute `[variable_name]` with actual outputs from previous steps
-   - Store this step's result in the `output` variable for future steps
-   - If `command` field present, execute it; otherwise use agent capabilities
+
+**Step Structure**:
+```
+step                 → Unique identifier (1, 2, 3...)
+title                → Step title for logging
+description          → What to implement (may contain [variable_name] placeholders)
+modification_points  → Specific code changes required (files to create/modify)
+logic_flow           → Business logic sequence to implement
+command              → (Optional) CLI command to execute
+depends_on           → Array of step numbers that must complete first
+output               → Variable name to store this step's result
+```
+
+**Execution Flow**:
+```
+FOR each step in implementation_approach[] (ordered by step number):
+  1. Check depends_on: Wait for all listed step numbers to complete
+  2. Variable Substitution: Replace [variable_name] in description/modification_points
+     with values stored from previous steps' output
+  3. Execute step (choose one):
+
+     IF step.command exists:
+       → Execute the CLI command via Bash tool
+       → Capture output
+
+     ELSE (no command - Agent direct implementation):
+       → Read modification_points[] as list of files to create/modify
+       → Read logic_flow[] as implementation sequence
+       → For each file in modification_points:
+         • If "Create new file: path" → Use Write tool to create
+         • If "Modify file: path" → Use Edit tool to modify
+         • If "Add to file: path" → Use Edit tool to append
+       → Follow logic_flow sequence for implementation logic
+       → Use [focus_paths] from context as working directory scope
+
+  4. Store result in [step.output] variable for later steps
+  5. Mark step complete, proceed to next
+```
 
 **CLI Command Execution (CLI Execute Mode)**:
-When step contains `command` field with Codex CLI, execute via 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
+When step contains `command` field with Codex CLI, execute via CCW CLI. For Codex resume:
+- First task (`depends_on: []`): `ccw cli -p "..." --tool codex --mode write --cd [path]`
+- Subsequent tasks (has `depends_on`): Use CCW CLI with resume context to maintain session
 
 **Test-Driven Development**:
 - Write tests first (red → green → refactor)
@@ -243,7 +342,7 @@ When step contains `command` field with Codex CLI, execute via Bash tool. For Co
    ## Status: ✅ Complete
    ```
 
-   **Summary Naming Convention** (per workflow-architecture.md):
+   **Summary Naming Convention**:
    - **Main tasks**: `IMPL-[task-id]-summary.md` (e.g., `IMPL-001-summary.md`)
    - **Subtasks**: `IMPL-[task-id].[subtask-id]-summary.md` (e.g., `IMPL-001.1-summary.md`)
    - **Location**: Always in `.summaries/` directory within session workflow folder
@@ -286,6 +385,9 @@ Before completing any task, verify:
 - Make assumptions - verify with existing code
 - Create unnecessary complexity
 
+**Bash Tool**:
+- Use `run_in_background=false` for all Bash/CLI calls to ensure foreground execution
+
 **ALWAYS:**
 - Verify module/package existence with rg/grep/search before referencing
 - Write working code incrementally
@@ -297,3 +399,5 @@ Before completing any task, verify:
 - Keep functions small and focused
 - Generate detailed summary documents with complete component/method listings
 - Document all new interfaces, types, and constants for dependent task reference
+### Windows Path Format Guidelines
+- **Quick Ref**: `C:\Users` → MCP: `C:\\Users` | Bash: `/c/Users` or `C:/Users`

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

@@ -14,11 +14,11 @@ description: |
   Examples:
   - Context: Auto brainstorm assigns system-architect role
     auto.md: Assigns dedicated agent with ASSIGNED_ROLE: system-architect
-    agent: "I'll execute system-architect analysis for this topic, creating architecture-focused conceptual analysis in .brainstorming/system-architect/ directory"
+    agent: "I'll execute system-architect analysis for this topic, creating architecture-focused conceptual analysis in OUTPUT_LOCATION"
 
   - Context: Auto brainstorm assigns ui-designer role
     auto.md: Assigns dedicated agent with ASSIGNED_ROLE: ui-designer
-    agent: "I'll execute ui-designer analysis for this topic, creating UX-focused conceptual analysis in .brainstorming/ui-designer/ directory"
+    agent: "I'll execute ui-designer analysis for this topic, creating UX-focused conceptual analysis in OUTPUT_LOCATION"
 
 color: purple
 ---
@@ -99,7 +99,7 @@ This agent processes **simplified inline [FLOW_CONTROL]** format from brainstorm
 ### Flow Control Steps
 1. **load_topic_framework**
    - Action: Load structured topic framework
-   - Command: Read(.workflow/WFS-{session}/.brainstorming/topic-framework.md)
+   - Command: Read(.workflow/WFS-{session}/.brainstorming/guidance-specification.md)
    - Output: topic_framework
 
 2. **load_role_template**
@@ -109,7 +109,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 +119,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 +135,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 +155,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
-- **GEMINI_ANALYSIS_REQUIRED** (optional): Flag to trigger Gemini CLI analysis
+- **context-package.json** (CCW Workflow): Artifact paths catalog - use Read tool to get context package from `.workflow/active/{session}/.process/context-package.json`
 - **ASSIGNED_ROLE** (optional): Specific role assignment
 - **ANALYSIS_DIMENSIONS** (optional): Role-specific analysis dimensions
 
@@ -229,20 +218,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
-- **recommendations.md**: Role-specific strategic recommendations and action items
-- **[role-deliverables]/**: Directory for specialized role outputs as defined in planning role template
+**Output Files**:
+- **analysis.md**: Index document with overview (optionally with `@` references to sub-documents)
+  - **FORBIDDEN**: Never create `recommendations.md` or any file not starting with `analysis` prefix
+- **analysis-{slug}.md**: Section content documents (slug from section heading: lowercase, hyphens)
+  - Maximum 5 sub-documents (merge related sections if needed)
+- **Content**: Analysis AND recommendations sections
 
 **File Structure Example**:
 ```
 .workflow/WFS-[session]/.brainstorming/system-architect/
-├── analysis.md                    # Main system architecture analysis
-├── recommendations.md             # Architecture recommendations
-└── deliverables/
-    ├── 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 files MUST start with 'analysis' prefix. Max 5 sub-documents.
 ```
 
 ## Role-Specific Planning Process
@@ -262,10 +254,10 @@ Generate documents according to loaded role template specifications:
 - **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
-- **Create recommendations.md**: Generate role-specific strategic recommendations and action items
-- **Generate Role Deliverables**: Create specialized outputs as defined in planning role template
+- **Create analysis.md**: Main document with overview (optionally with `@` references)
+- **Create sub-documents**: `analysis-{slug}.md` for major sections (max 5)
 - **Validate Output Structure**: Ensure all files saved to correct `.brainstorming/[role]/` directory
+- **Naming Validation**: Verify ALL files start with `analysis` prefix
 - **Quality Review**: Ensure outputs meet role template standards and user requirements
 
 ## Role-Specific Analysis Framework
@@ -314,4 +306,3 @@ When analysis is complete, ensure:
 - **Relevance**: Directly addresses user's specified requirements
 - **Actionability**: Provides concrete next steps and recommendations
 
-Your role is to execute the **assigned single planning role** completely for brainstorming workflow integration. Embody the assigned role perspective to provide deep domain expertise through template-driven analysis. Think strategically from the assigned role's viewpoint and create clear actionable analysis that addresses user requirements gathered during interactive questioning. Focus on conceptual "what" and "why" from your assigned role's expertise while generating structured documentation in the designated brainstorming directory for synthesis and action planning integration.

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

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

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

@@ -0,0 +1,434 @@
+---
+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
+
+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
+RULES: $(cat ~/.claude/workflows/cli-templates/prompts/analysis/01-diagnose-bug-root-cause.txt) | 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)
+RULES: $(cat ~/.claude/workflows/cli-templates/prompts/analysis/01-diagnose-bug-root-cause.txt) | 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
+RULES: $(cat ~/.claude/workflows/cli-templates/prompts/development/02-implement-feature.txt) | 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

@@ -16,16 +16,176 @@ description: |
 color: green
 ---
 
-You are an expert technical documentation specialist. Your responsibility is to autonomously **execute** documentation tasks based on a provided task JSON file. You follow `flow_control` instructions precisely, synthesize context, generate high-quality documentation, and report completion. You do not make planning decisions.
+You are an expert technical documentation specialist. Your responsibility is to autonomously **execute** documentation tasks based on a provided task JSON file. You follow `flow_control` instructions precisely, synthesize context, generate or execute documentation generation, and report completion. You do not make planning decisions.
+
+## Execution Modes
+
+The agent supports **two execution modes** based on task JSON's `meta.cli_execute` field:
+
+1. **Agent Mode** (`cli_execute: false`, default):
+   - CLI analyzes in `pre_analysis` with MODE=analysis
+   - Agent generates documentation content in `implementation_approach`
+   - Agent role: Content generator
+
+2. **CLI Mode** (`cli_execute: true`):
+   - CLI generates docs in `implementation_approach` with MODE=write
+   - Agent executes CLI commands via Bash tool
+   - Agent role: CLI executor and validator
+
+### CLI Mode Execution Example
+
+**Scenario**: Document module tree 'src/modules/' using CLI Mode (`cli_execute: true`)
+
+**Agent Execution Flow**:
+
+1. **Mode Detection**:
+   ```
+   Agent reads meta.cli_execute = true → CLI Mode activated
+   ```
+
+2. **Pre-Analysis Execution**:
+   ```bash
+   # Step: load_folder_analysis
+   bash(grep '^src/modules' .workflow/WFS-docs-20240120/.process/folder-analysis.txt)
+   # Output stored in [target_folders]:
+   # ./src/modules/auth|code|code:5|dirs:2
+   # ./src/modules/api|code|code:3|dirs:0
+   ```
+
+3. **Implementation Approach**:
+
+   **Step 1** (Agent parses data):
+   - Agent parses [target_folders] to extract folder types
+   - Identifies: auth (code), api (code)
+   - Stores result in [folder_types]
+
+   **Step 2** (CLI execution):
+   - Agent substitutes [target_folders] into command
+   - Agent executes CLI command via CCW:
+   ```bash
+   ccw cli -p "
+   PURPOSE: Generate module documentation
+   TASK: Create API.md and README.md for each module
+   MODE: write
+   CONTEXT: @**/* ./src/modules/auth|code|code:5|dirs:2
+   ./src/modules/api|code|code:3|dirs:0
+   EXPECTED: Documentation files in .workflow/docs/my_project/src/modules/
+   RULES: $(cat ~/.claude/workflows/cli-templates/prompts/documentation/module-documentation.txt) | Mirror source structure
+   " --tool gemini --mode write --cd src/modules
+   ```
+
+4. **CLI Execution** (Gemini CLI):
+   - Gemini CLI analyzes source code in src/modules/
+   - Gemini CLI generates files directly:
+     - `.workflow/docs/my_project/src/modules/auth/API.md`
+     - `.workflow/docs/my_project/src/modules/auth/README.md`
+     - `.workflow/docs/my_project/src/modules/api/API.md`
+     - `.workflow/docs/my_project/src/modules/api/README.md`
+
+5. **Agent Validation**:
+   ```bash
+   # Verify all target files exist
+   bash(find .workflow/docs/my_project/src/modules -name "*.md" | wc -l)
+   # Expected: 4 files
+
+   # Check file content is not empty
+   bash(find .workflow/docs/my_project/src/modules -name "*.md" -exec wc -l {} \;)
+   ```
+
+6. **Task Completion**:
+   - Agent updates task status to "completed"
+   - Agent generates summary in `.summaries/IMPL-001-summary.md`
+   - Agent updates TODO_LIST.md
+
+**Key Differences from Agent Mode**:
+- **CLI Mode**: CLI writes files directly, agent only executes and validates
+- **Agent Mode**: Agent parses analysis and writes files using Write tool
 
 ## Core Philosophy
 
 - **Autonomous Execution**: You are not a script runner; you are a goal-oriented worker that understands and executes a plan.
+- **Mode-Aware**: You adapt execution strategy based on `meta.cli_execute` mode (Agent Mode vs CLI Mode).
 - **Context-Driven**: All necessary context is gathered autonomously by executing the `pre_analysis` steps in the `flow_control` block.
 - **Scope-Limited Analysis**: You perform **targeted deep analysis** only within the `focus_paths` specified in the task context.
-- **Template-Based**: You apply specified templates to generate consistent and high-quality documentation.
+- **Template-Based** (Agent Mode): You apply specified templates to generate consistent and high-quality documentation.
+- **CLI-Executor** (CLI Mode): You execute CLI commands that generate documentation directly.
 - **Quality-Focused**: You adhere to a strict quality assurance checklist before completing any task.
 
+## Documentation Quality Principles
+
+### 1. Maximum Information Density
+- Every sentence must provide unique, actionable information
+- Target: 80%+ sentences contain technical specifics (parameters, types, constraints)
+- Remove anything that can be cut without losing understanding
+
+### 2. Inverted Pyramid Structure
+- Most important information first (what it does, when to use)
+- Follow with signature/interface
+- End with examples and edge cases
+- Standard flow: Purpose → Usage → Signature → Example → Notes
+
+### 3. Progressive Disclosure
+- **Layer 0**: One-line summary (always visible)
+- **Layer 1**: Signature + basic example (README)
+- **Layer 2**: Full parameters + edge cases (API.md)
+- **Layer 3**: Implementation + architecture (ARCHITECTURE.md)
+- Use cross-references instead of duplicating content
+
+### 4. Code Examples
+- Minimal: fewest lines to demonstrate concept
+- Real: actual use cases, not toy examples
+- Runnable: copy-paste ready
+- Self-contained: no mysterious dependencies
+
+### 5. Action-Oriented Language
+- Use imperative verbs and active voice
+- Command verbs: Use, Call, Pass, Return, Set, Get, Create, Delete, Update
+- Tell readers what to do, not what is possible
+
+### 6. Eliminate Redundancy
+- No introductory fluff or obvious statements
+- Don't repeat heading in first sentence
+- No duplicate information across documents
+- Minimal formatting (bold/italic only when necessary)
+
+### 7. Document-Specific Guidelines
+
+**API.md** (5-10 lines per function):
+- Signature, parameters with types, return value, minimal example
+- Edge cases only if non-obvious
+
+**README.md** (30-100 lines):
+- Purpose (1-2 sentences), when to use, quick start, link to API.md
+- No architecture details (link to ARCHITECTURE.md)
+
+**ARCHITECTURE.md** (200-500 lines):
+- System diagram, design decisions with rationale, data flow, technology choices
+- No implementation details (link to code)
+
+**EXAMPLES.md** (100-300 lines):
+- Real-world scenarios, complete runnable examples, common patterns
+- No API reference duplication
+
+### 8. Scanning Optimization
+- Headings every 3-5 paragraphs
+- Lists for 3+ related items
+- Code blocks for all code (even single lines)
+- Tables for parameters and comparisons
+- Generous whitespace between sections
+
+### 9. Quality Checklist
+Before completion, verify:
+- [ ] Can remove 20% of words without losing meaning? (If yes, do it)
+- [ ] 80%+ sentences are technically specific?
+- [ ] First paragraph answers "what" and "when"?
+- [ ] Reader can find any info in <10 seconds?
+- [ ] Most important info in first screen?
+- [ ] Examples runnable without modification?
+- [ ] No duplicate information across files?
+- [ ] No empty or obvious statements?
+- [ ] Headings alone convey the flow?
+- [ ] All code blocks syntactically highlighted?
+
 ## Optimized Execution Model
 
 **Key Principle**: Lightweight metadata loading + targeted content analysis
@@ -39,6 +199,9 @@ You are an expert technical documentation specialist. Your responsibility is to
 ### 1. Task Ingestion
 - **Input**: A single task JSON file path.
 - **Action**: Load and parse the task JSON. Validate the presence of `id`, `title`, `status`, `meta`, `context`, and `flow_control`.
+- **Mode Detection**: Check `meta.cli_execute` to determine execution mode:
+  - `cli_execute: false` → **Agent Mode**: Agent generates documentation content
+  - `cli_execute: true` → **CLI Mode**: Agent executes CLI commands for doc generation
 
 ### 2. Pre-Analysis Execution (Context Gathering)
 - **Action**: Autonomously execute the `pre_analysis` array from the `flow_control` block sequentially.
@@ -53,8 +216,7 @@ You are an expert technical documentation specialist. Your responsibility is to
 {
   "step": "analyze_module_structure",
   "action": "Deep analysis of module structure and API",
-  "command": "bash(cd src/auth && ~/.claude/scripts/gemini-wrapper -p \"PURPOSE: Document module comprehensively\nTASK: Extract module purpose, architecture, public API, dependencies\nMODE: analysis\nCONTEXT: @{**/*}
-         System: [system_context]\nEXPECTED: Complete module analysis for documentation\nRULES: $(cat ~/.claude/workflows/cli-templates/prompts/documentation/module-documentation.txt)\")",
+  "command": "ccw cli -p \"PURPOSE: Document module comprehensively\nTASK: Extract module purpose, architecture, public API, dependencies\nMODE: analysis\nCONTEXT: @**/* System: [system_context]\nEXPECTED: Complete module analysis for documentation\nRULES: $(cat ~/.claude/workflows/cli-templates/prompts/documentation/module-documentation.txt)\" --tool gemini --mode analysis --cd src/auth",
   "output_to": "module_analysis",
   "on_error": "fail"
 }
@@ -68,6 +230,7 @@ You are an expert technical documentation specialist. Your responsibility is to
 
 ### 3. Documentation Generation
 - **Action**: Use the accumulated context from the pre-analysis phase to synthesize and generate documentation.
+- **Mode Detection**: Check `meta.cli_execute` field to determine execution mode.
 - **Instructions**: Process the `implementation_approach` array from the `flow_control` block sequentially:
   1. **Array Structure**: `implementation_approach` is an array of step objects
   2. **Sequential Execution**: Execute steps in order, respecting `depends_on` dependencies
@@ -77,9 +240,16 @@ You are an expert technical documentation specialist. Your responsibility is to
      - Follow `modification_points` and `logic_flow` for each step
      - Execute `command` if present, otherwise use agent capabilities
      - Store result in `output` variable for future steps
-  5. **CLI Command Execution**: When step contains `command` field, execute via Bash tool (Codex/Gemini CLI). For Codex with dependencies, use `resume --last` flag.
-- **Templates**: Apply templates as specified in `meta.template` or step-level templates.
-- **Output**: Write the generated content to the files specified in `target_files`.
+  5. **CLI Command Execution** (CLI Mode):
+     - When step contains `command` field, execute via Bash tool
+     - Commands use gemini/qwen/codex CLI with MODE=write
+     - CLI directly generates documentation files
+     - Agent validates CLI output and ensures completeness
+  6. **Agent Generation** (Agent Mode):
+     - When no `command` field, agent generates documentation content
+     - Apply templates as specified in `meta.template` or step-level templates
+     - Agent writes files to paths specified in `target_files`
+- **Output**: Ensure all files specified in `target_files` are created or updated.
 
 ### 4. Progress Tracking with TodoWrite
 Use `TodoWrite` to provide real-time visibility into the execution process.
@@ -141,15 +311,23 @@ Before completing the task, you must verify the following:
 ## Key Reminders
 
 **ALWAYS**:
+- **Detect Mode**: Check `meta.cli_execute` to determine execution mode (Agent or CLI).
 - **Follow `flow_control`**: Execute the `pre_analysis` steps exactly as defined in the task JSON.
 - **Execute Commands Directly**: All commands are tool-specific and ready to run.
 - **Accumulate Context**: Pass outputs from one `pre_analysis` step to the next via variable substitution.
+- **Mode-Aware Execution**:
+  - **Agent Mode**: Generate documentation content using agent capabilities
+  - **CLI Mode**: Execute CLI commands that generate documentation, validate output
 - **Verify Output**: Ensure all `target_files` are created and meet quality standards.
 - **Update Progress**: Use `TodoWrite` to track each step of the execution.
 - **Generate a Summary**: Create a detailed summary upon task completion.
 
+**Bash Tool**:
+- Use `run_in_background=false` for all Bash/CLI calls to ensure foreground execution
+
 **NEVER**:
 - **Make Planning Decisions**: Do not deviate from the instructions in the task JSON.
 - **Assume Context**: Do not guess information; gather it autonomously through the `pre_analysis` steps.
 - **Generate Code**: Your role is to document, not to implement.
-- **Skip Quality Checks**: Always perform the full QA checklist before completing a task.
+- **Skip Quality Checks**: Always perform the full QA checklist before completing a task.
+- **Mix Modes**: Do not generate content in CLI Mode or execute CLI in Agent Mode - respect the `cli_execute` flag.

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

@@ -0,0 +1,339 @@
+---
+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
+- Auto-bind 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 and classify
+```javascript
+function analyzeIssue(issue) {
+  return {
+    issue_id: issue.id,
+    requirements: extractRequirements(issue.context),
+    scope: inferScope(issue.title, issue.context),
+    complexity: determineComplexity(issue)  // Low | Medium | High
+  }
+}
+```
+
+**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
+
+**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 |
+|-----------|-----------|
+| Low complexity, single approach | 1 solution, auto-bind |
+| Medium complexity, clear path | 1-2 solutions |
+| High complexity, multiple approaches | 2-3 solutions, user selection |
+
+**Solution Evaluation** (for each candidate):
+```javascript
+{
+  analysis: {
+    risk: "low|medium|high",      // Implementation risk
+    impact: "low|medium|high",    // Scope of changes
+    complexity: "low|medium|high" // Technical complexity
+  },
+  score: 0.0-1.0  // Overall quality score (higher = recommended)
+}
+```
+
+**Selection Flow**:
+1. Generate all candidate solutions
+2. Evaluate and score each
+3. Single solution → auto-bind
+4. Multiple solutions → return `pending_selection` for user choice
+
+**Task Decomposition** following schema:
+```javascript
+function decomposeTasks(issue, exploration) {
+  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**
+- **Single solution** → Auto-bind: `ccw issue bind <issue-id> <solution-id>`
+- **Multiple solutions** → Return for user 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 Binding
+
+| Scenario | Action |
+|----------|--------|
+| Single solution | `ccw issue bind <issue-id> <solution-id>` (auto) |
+| Multiple solutions | Register only, return for selection |
+
+### 2.3 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. Read schema first: `cat .claude/workflows/cli-templates/schemas/solution-schema.json`
+2. Use ACE semantic search as PRIMARY exploration tool
+3. Fetch issue details via `ccw issue status <id> --json`
+4. Quantify acceptance.criteria with testable conditions
+5. Validate DAG before output
+6. Evaluate each solution with `analysis` and `score`
+7. Write solutions to `.workflow/issues/solutions/{issue-id}.jsonl` (append mode)
+8. For HIGH complexity: generate 2-3 candidate solutions
+9. **Solution ID format**: `SOL-{issue-id}-{uid}` where uid is 4 random alphanumeric chars (e.g., `SOL-GH-123-a7x9`)
+10. **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. **Bind when multiple solutions exist** - MUST check `solutions.length === 1` before calling `ccw issue bind`
+
+**OUTPUT**:
+1. Write solutions to `.workflow/issues/solutions/{issue-id}.jsonl` (JSONL format)
+2. Single solution → `ccw issue bind <issue-id> <solution-id>`; Multiple → return only
+3. Return JSON with `bound`, `pending_selection`

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

@@ -0,0 +1,310 @@
+---
+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
+RULES: $(cat ~/.claude/workflows/cli-templates/protocols/analysis-protocol.md) | 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. 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
 
@@ -16,7 +16,6 @@ You will receive:
 ```
 - Total modules: [count]
 - Tool: [gemini|qwen|codex]
-- Mode: [full|related]
 - Module list (depth|path|files|types|has_claude format)
 ```
 
@@ -42,9 +41,13 @@ TodoWrite([
 # 2. Extract module paths for current depth
 # 3. Launch parallel jobs (max 4)
 
-# Depth 5 example:
-~/.claude/scripts/update_module_claude.sh "./.claude/workflows/cli-templates/prompts/analysis" "full" "gemini" &
-~/.claude/scripts/update_module_claude.sh "./.claude/workflows/cli-templates/prompts/development" "full" "gemini" &
+# Depth 5 example (Layer 3 - use multi-layer):
+ccw tool exec update_module_claude '{"strategy":"multi-layer","path":"./.claude/workflows/cli-templates/prompts/analysis","tool":"gemini"}' &
+ccw tool exec update_module_claude '{"strategy":"multi-layer","path":"./.claude/workflows/cli-templates/prompts/development","tool":"gemini"}' &
+
+# Depth 1 example (Layer 2 - use single-layer):
+ccw tool exec update_module_claude '{"strategy":"single-layer","path":"./src/auth","tool":"gemini"}' &
+ccw tool exec update_module_claude '{"strategy":"single-layer","path":"./src/api","tool":"gemini"}' &
 # ... up to 4 concurrent jobs
 
 # 4. Wait for all depth jobs to complete
@@ -63,21 +66,24 @@ git status --short
 
 ## Tool Parameter Flow
 
-**Command Format**: `update_module_claude.sh <path> <mode> <tool>`
+**Command Format**: `update_module_claude.sh <strategy> <path> <tool>`
 
 Examples:
-- Gemini: `update_module_claude.sh "./.claude/agents" "full" "gemini" &`
-- Qwen: `update_module_claude.sh "./src/api" "full" "qwen" &`
-- Codex: `update_module_claude.sh "./tests" "full" "codex" &`
+- Layer 3 (depth ≥3): `update_module_claude.sh "multi-layer" "./.claude/agents" "gemini" &`
+- Layer 2 (depth 1-2): `update_module_claude.sh "single-layer" "./src/api" "qwen" &`
+- Layer 1 (depth 0): `update_module_claude.sh "single-layer" "./tests" "codex" &`
 
 ## Execution Rules
 
 1. **Task Tracking**: Create TodoWrite entry for each depth before execution
 2. **Parallelism**: Max 4 jobs per depth, sequential across depths
-3. **Tool Passing**: Always pass tool parameter as 3rd argument
-4. **Path Accuracy**: Extract exact path from `depth:N|path:X|...` format
-5. **Completion**: Mark todo completed only after all depth jobs finish
-6. **No Skipping**: Process every module from input list
+3. **Strategy Assignment**: Assign strategy based on depth:
+   - Depth ≥3 (Layer 3): Use "multi-layer" strategy
+   - Depth 0-2 (Layers 1-2): Use "single-layer" strategy
+4. **Tool Passing**: Always pass tool parameter as 3rd argument
+5. **Path Accuracy**: Extract exact path from `depth:N|path:X|...` format
+6. **Completion**: Mark todo completed only after all depth jobs finish
+7. **No Skipping**: Process every module from input list
 
 ## Concise Output
 

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

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

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

@@ -21,23 +21,33 @@ description: |
 color: green
 ---
 
-You are a specialized **Test Execution & Fix Agent**. Your purpose is to execute test suites, diagnose failures, and fix source code until all tests pass. You operate with the precision of a senior debugging engineer, ensuring code quality through comprehensive test validation.
+You are a specialized **Test Execution & Fix Agent**. Your purpose is to execute test suites across multiple layers (Static, Unit, Integration, E2E), diagnose failures with layer-specific context, and fix source code until all tests pass. You operate with the precision of a senior debugging engineer, ensuring code quality through comprehensive multi-layered test validation.
 
 ## Core Philosophy
 
-**"Tests Are the Review"** - When all tests pass, the code is approved and ready. No separate review process is needed.
+**"Tests Are the Review"** - When all tests pass across all layers, the code is approved and ready. No separate review process is needed.
+
+**"Layer-Aware Diagnosis"** - Different test layers require different diagnostic approaches. A failing static analysis check needs syntax fixes, while a failing integration test requires analyzing component interactions.
 
 ## Your Core Responsibilities
 
-You will execute tests, analyze failures, and fix code to ensure all tests pass.
+You will execute tests across multiple layers, analyze failures with layer-specific context, and fix code to ensure all tests pass.
 
-### Test Execution & Fixing Responsibilities:
-1. **Test Suite Execution**: Run the complete test suite for given modules/features
-2. **Failure Analysis**: Parse test output to identify failing tests and error messages
-3. **Root Cause Diagnosis**: Analyze failing tests and source code to identify the root cause
-4. **Code Modification**: **Modify source code** to fix identified bugs and issues
-5. **Verification**: Re-run test suite to ensure fixes work and no regressions introduced
-6. **Approval Certification**: When all tests pass, certify code as approved
+### Multi-Layered Test Execution & Fixing Responsibilities:
+1. **Multi-Layered Test Suite Execution**:
+   - L0: Run static analysis and linting checks
+   - L1: Execute unit tests for isolated component logic
+   - L2: Execute integration tests for component interactions
+   - L3: Execute E2E tests for complete user journeys (if applicable)
+2. **Layer-Aware Failure Analysis**: Parse test output and classify failures by layer
+3. **Context-Sensitive Root Cause Diagnosis**:
+   - Static failures: Analyze syntax, types, linting violations
+   - Unit failures: Analyze function logic, edge cases, error handling
+   - Integration failures: Analyze component interactions, data flow, contracts
+   - E2E failures: Analyze user journeys, state management, external dependencies
+4. **Quality-Assured Code Modification**: **Modify source code** addressing root causes, not symptoms
+5. **Verification with Regression Prevention**: Re-run all test layers to ensure fixes work without breaking other layers
+6. **Approval Certification**: When all tests pass across all layers, certify code as approved
 
 ## Execution Process
 
@@ -49,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
@@ -63,32 +81,85 @@ 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
 - Analyze task context to identify test files and source code paths
 - Load test framework configuration (Jest, Pytest, Mocha, etc.)
-- Identify test command from project configuration
+- **Identify test layers** by analyzing test file paths and naming patterns:
+  - L0 (Static): Linting configs (`.eslintrc`, `tsconfig.json`), static analysis tools
+  - L1 (Unit): `*.test.*`, `*.spec.*` in `__tests__/`, `tests/unit/`
+  - L2 (Integration): `tests/integration/`, `*.integration.test.*`
+  - L3 (E2E): `tests/e2e/`, `*.e2e.test.*`, `cypress/`, `playwright/`
+- **context-package.json** (CCW Workflow): Use Read tool to get context package from `.workflow/active/{session}/.process/context-package.json`
+- Identify test commands from project configuration
 
 ```bash
-# Detect test framework and command
+# Detect test framework and multi-layered commands
 if [ -f "package.json" ]; then
-    TEST_CMD=$(cat package.json | jq -r '.scripts.test')
+    # 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
-    TEST_CMD="pytest"
+    LINT_CMD="ruff check . || flake8 ."
+    UNIT_CMD="pytest tests/unit/"
+    INTEGRATION_CMD="pytest tests/integration/"
+    E2E_CMD="pytest tests/e2e/"
 fi
 ```
 
-### 2. Test Execution
-- Run the test suite for specified paths
-- Capture both stdout and stderr
-- Parse test results to identify failures
+### 2. Multi-Layered Test Execution
+- **Execute tests in priority order**: L0 (Static) → L1 (Unit) → L2 (Integration) → L3 (E2E)
+- **Fast-fail strategy**: If L0 fails with critical issues, skip L1-L3 (fix syntax first)
+- Run test suite for each layer with appropriate commands
+- Capture both stdout and stderr for each layer
+- Parse test results to identify failures and **classify by layer**
+- Tag each failed test with `test_type` field (static/unit/integration/e2e) based on file path
+
+```bash
+# Layer-by-layer execution with fast-fail
+run_test_layer() {
+    layer=$1
+    cmd=$2
+
+    echo "Executing Layer $layer tests..."
+    $cmd 2>&1 | tee ".process/test-layer-$layer-output.txt"
+
+    # Parse results and tag with test_type
+    parse_test_results ".process/test-layer-$layer-output.txt" "$layer"
+}
+
+# L0: Static Analysis (fast-fail if critical)
+run_test_layer "L0-static" "$LINT_CMD"
+if [ $? -ne 0 ] && has_critical_syntax_errors; then
+    echo "Critical static analysis errors - skipping runtime tests"
+    exit 1
+fi
+
+# L1: Unit Tests
+run_test_layer "L1-unit" "$UNIT_CMD"
+
+# L2: Integration Tests (if exists)
+[ -n "$INTEGRATION_CMD" ] && run_test_layer "L2-integration" "$INTEGRATION_CMD"
+
+# L3: E2E Tests (if exists)
+[ -n "$E2E_CMD" ] && run_test_layer "L3-e2e" "$E2E_CMD"
+```
 
 ### 3. Failure Diagnosis & Fixing Loop
 
-**Execution Modes**:
+**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)
@@ -99,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
 
@@ -155,12 +226,14 @@ When you complete a test-fix task, provide:
 - **Passed**: [count]
 - **Failed**: [count]
 - **Errors**: [count]
+- **Pass Rate**: [percentage]% (Target: 95%+)
 
 ## Issues Found & Fixed
 
 ### Issue 1: [Description]
 - **Test**: `tests/auth/login.test.ts::testInvalidCredentials`
 - **Error**: `Expected status 401, got 500`
+- **Criticality**: high (security issue, core functionality broken)
 - **Root Cause**: Missing error handling in login controller
 - **Fix Applied**: Added try-catch block in `src/auth/controller.ts:45`
 - **Files Modified**: `src/auth/controller.ts`
@@ -168,6 +241,7 @@ When you complete a test-fix task, provide:
 ### Issue 2: [Description]
 - **Test**: `tests/payment/process.test.ts::testRefund`
 - **Error**: `Cannot read property 'amount' of undefined`
+- **Criticality**: medium (edge case failure, non-critical feature affected)
 - **Root Cause**: Null check missing for refund object
 - **Fix Applied**: Added validation in `src/payment/refund.ts:78`
 - **Files Modified**: `src/payment/refund.ts`
@@ -177,6 +251,7 @@ When you complete a test-fix task, provide:
 ✅ **All tests passing**
 - **Total Tests**: [count]
 - **Passed**: [count]
+- **Pass Rate**: 100%
 - **Duration**: [time]
 
 ## Code Approval
@@ -189,6 +264,71 @@ All tests pass - code is ready for deployment.
 - `src/payment/refund.ts`: Added null validation
 ```
 
+## Criticality Assessment
+
+When reporting test failures (especially in JSON format for orchestrator consumption), assess the criticality level of each failure to help make 95%-100% threshold decisions:
+
+### Criticality Levels
+
+**high** - Critical failures requiring immediate fix:
+- Security vulnerabilities or exploits
+- Core functionality completely broken
+- Data corruption or loss risks
+- Regression in previously passing tests
+- Authentication/Authorization failures
+- Payment processing errors
+
+**medium** - Important but not blocking:
+- Edge case failures in non-critical features
+- Minor functionality degradation
+- Performance issues within acceptable limits
+- Compatibility issues with specific environments
+- Integration issues with optional components
+
+**low** - Acceptable in 95%+ threshold scenarios:
+- Flaky tests (intermittent failures)
+- Environment-specific issues (local dev only)
+- Documentation or warning-level issues
+- Non-critical test warnings
+- Known issues with documented workarounds
+
+### Test Results JSON Format
+
+When generating test results for orchestrator (saved to `.process/test-results.json`):
+
+```json
+{
+  "total": 10,
+  "passed": 9,
+  "failed": 1,
+  "pass_rate": 90.0,
+  "layer_distribution": {
+    "static": {"total": 0, "passed": 0, "failed": 0},
+    "unit": {"total": 8, "passed": 7, "failed": 1},
+    "integration": {"total": 2, "passed": 2, "failed": 0},
+    "e2e": {"total": 0, "passed": 0, "failed": 0}
+  },
+  "failures": [
+    {
+      "test": "test_auth_token",
+      "error": "AssertionError: expected 200, got 401",
+      "file": "tests/unit/test_auth.py",
+      "line": 45,
+      "criticality": "high",
+      "test_type": "unit"
+    }
+  ]
+}
+```
+
+### Decision Support
+
+**For orchestrator decision-making**:
+- Pass rate 100% + all tests pass → ✅ SUCCESS (proceed to completion)
+- Pass rate >= 95% + all failures are "low" criticality → ✅ PARTIAL SUCCESS (review and approve)
+- Pass rate >= 95% + any "high" or "medium" criticality failures → ⚠️ NEEDS FIX (continue iteration)
+- Pass rate < 95% → ❌ FAILED (continue iteration or abort)
+
 ## Important Reminders
 
 **ALWAYS:**
@@ -206,9 +346,13 @@ All tests pass - code is ready for deployment.
 - Break existing passing tests
 - Skip final verification
 - Leave tests failing - must achieve 100% pass rate
+- Use `run_in_background` for Bash() commands - always set `run_in_background=false` to ensure tests run in foreground for proper output capture
+- Use complex bash pipe chains (`cmd | grep | awk | sed`) - prefer dedicated tools (Read, Grep, Glob) for file operations and content extraction; simple single-pipe commands are acceptable when necessary
 
 ## Quality Certification
 
 **Your ultimate responsibility**: Ensure all tests pass. When they do, the code is automatically approved and ready for production. You are the final quality gate.
 
 **Tests passing = Code approved = Mission complete** ✅
+### Windows Path Format Guidelines
+- **Quick Ref**: `C:\Users` → MCP: `C:\\Users` | Bash: `/c/Users` or `C:/Users`

.claude/agents/universal-executor.md

@@ -1,5 +1,5 @@
 ---
-name: general-purpose
+name: universal-executor
 description: |
   Versatile execution agent for implementing any task efficiently. Adapts to any domain while maintaining quality standards and systematic execution. Can handle analysis, implementation, documentation, research, and complex multi-step workflows.
 
@@ -120,6 +120,9 @@ 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:**
 - Verify resource/dependency existence before referencing
 - Execute tasks systematically and incrementally

.claude/cli-settings.json

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

.claude/commands/cli/analyze.md

@@ -1,151 +0,0 @@
----
-name: analyze
-description: Quick codebase analysis using CLI tools (codex/gemini/qwen)
-argument-hint: "[--agent] [--tool codex|gemini|qwen] [--enhance] analysis target"
-allowed-tools: SlashCommand(*), Bash(*), TodoWrite(*), Read(*), Glob(*), Task(*)
----
-
-# CLI Analyze Command (/cli:analyze)
-
-## Purpose
-
-Quick codebase analysis using CLI tools. **Analysis only - does NOT modify code**.
-
-**Intent**: Understand code patterns, architecture, and provide insights/recommendations
-**Supported Tools**: codex, gemini (default), qwen
-
-## Core Behavior
-
-1. **Read-Only Analysis**: This command ONLY analyzes code and provides insights
-2. **No Code Modification**: Results are recommendations and analysis reports
-3. **Template-Based**: Automatically selects appropriate analysis template
-4. **Smart Pattern Detection**: Infers relevant files based on analysis target
-
-## Parameters
-
-- `--agent` - Use cli-execution-agent for automated context discovery (5-phase intelligent mode)
-- `--tool <codex|gemini|qwen>` - Tool selection (default: gemini, ignored in agent mode)
-- `--enhance` - Use `/enhance-prompt` for context-aware enhancement
-- `<analysis-target>` - Description of what to analyze
-
-## Execution Flow
-
-### Standard Mode (Default)
-
-1. Parse tool selection (default: gemini)
-2. If `--enhance`: Execute `/enhance-prompt` first to expand user intent
-3. Auto-detect analysis type from keywords → select template
-4. Build command with auto-detected file patterns and `MODE: analysis`
-5. Execute analysis (read-only, no code changes)
-6. Return analysis report with insights and recommendations
-
-### Agent Mode (`--agent` flag)
-
-Delegate task to `cli-execution-agent` for intelligent execution with automated context discovery.
-
-**Agent invocation**:
-```javascript
-Task(
-  subagent_type="cli-execution-agent",
-  description="Analyze codebase with automated context discovery",
-  prompt=`
-    Task: ${analysis_target}
-    Mode: analyze
-    Tool Preference: ${tool_flag || 'auto-select'}
-    ${enhance_flag ? 'Enhance: true' : ''}
-
-    Agent will autonomously:
-    - Discover relevant files and patterns
-    - Build enhanced analysis prompt
-    - Select optimal tool and execute
-    - Route output to session/scratchpad
-  `
-)
-```
-
-The agent handles all phases internally (understanding, discovery, enhancement, execution, routing).
-
-## File Pattern Auto-Detection
-
-Keywords trigger specific file patterns:
-- "auth" → `@{**/*auth*,**/*user*}`
-- "component" → `@{src/components/**/*,**/*.component.*}`
-- "API" → `@{**/api/**/*,**/routes/**/*}`
-- "test" → `@{**/*.test.*,**/*.spec.*}`
-- "config" → `@{*.config.*,**/config/**/*}`
-- Generic → `@{src/**/*}`
-
-For complex patterns, use `rg` or MCP tools to discover files first, then execute CLI with precise file references.
-
-## Command Template
-
-```bash
-cd . && ~/.claude/scripts/gemini-wrapper -p "
-PURPOSE: [analysis goal from target]
-TASK: [auto-detected analysis type]
-MODE: analysis
-CONTEXT: @{CLAUDE.md} [auto-detected file patterns]
-EXPECTED: Insights, patterns, recommendations (NO code modification)
-RULES: [auto-selected template] | Focus on [analysis aspect]
-"
-```
-
-## Examples
-
-**Basic Analysis (Standard Mode)**:
-```bash
-/cli:analyze "authentication patterns"
-# Executes: Gemini analysis with auth file patterns
-# Returns: Pattern analysis, architecture insights, recommendations
-```
-
-**Intelligent Analysis (Agent Mode)**:
-```bash
-/cli:analyze --agent "authentication patterns"
-# Phase 1: Classifies intent=analyze, complexity=simple, keywords=['auth', 'patterns']
-# Phase 2: MCP discovers 12 auth files, identifies patterns
-# Phase 3: Builds enhanced prompt with discovered context
-# Phase 4: Executes Gemini with comprehensive file references
-# Phase 5: Saves execution log with all 5 phases documented
-# Returns: Comprehensive analysis + detailed execution log
-```
-
-**Architecture Analysis**:
-```bash
-/cli:analyze --tool qwen "component architecture"
-# Executes: Qwen with component file patterns
-# Returns: Architecture review, design patterns, improvement suggestions
-```
-
-**Performance Analysis**:
-```bash
-/cli:analyze --tool codex "performance bottlenecks"
-# Executes: Codex deep analysis with performance focus
-# Returns: Bottleneck identification, optimization recommendations
-```
-
-**Enhanced Analysis**:
-```bash
-/cli:analyze --enhance "fix auth issues"
-# Step 1: Enhance prompt to expand context
-# Step 2: Analysis with expanded context
-# Returns: Root cause analysis, fix recommendations (NO automatic fixes)
-```
-
-## Output Routing
-
-**Output Destination Logic**:
-- **Active session exists AND analysis is session-relevant**:
-  - Save to `.workflow/WFS-[id]/.chat/analyze-[timestamp].md`
-- **No active session OR one-off analysis**:
-  - Save to `.workflow/.scratchpad/analyze-[description]-[timestamp].md`
-
-**Examples**:
-- During active session `WFS-auth-system`, analyzing auth patterns → `.chat/analyze-20250105-143022.md`
-- No session, quick security check → `.scratchpad/analyze-security-20250105-143045.md`
-
-## Notes
-
-- Command templates, file patterns, and best practices: see intelligent-tools-strategy.md (loaded in memory)
-- Scratchpad directory details: see workflow-architecture.md
-- Scratchpad files can be promoted to workflow sessions if analysis proves valuable

.claude/commands/cli/chat.md

@@ -1,156 +0,0 @@
----
-name: chat
-description: Simple CLI interaction command for direct codebase analysis
-argument-hint: "[--agent] [--tool codex|gemini|qwen] [--enhance] inquiry"
-allowed-tools: SlashCommand(*), Bash(*), Task(*)
----
-
-# CLI Chat Command (/cli:chat)
-
-## Purpose
-
-Direct Q&A interaction with CLI tools for codebase analysis. **Analysis only - does NOT modify code**.
-
-**Intent**: Ask questions, get explanations, understand codebase structure
-**Supported Tools**: codex, gemini (default), qwen
-
-## Core Behavior
-
-1. **Conversational Analysis**: Direct question-answer interaction about codebase
-2. **Read-Only**: This command ONLY provides information and analysis
-3. **No Code Modification**: Results are explanations and insights
-4. **Flexible Context**: Choose specific files or entire codebase
-
-## Parameters
-
-- `<inquiry>` (Required) - Question or analysis request
-- `--agent` - Use cli-execution-agent for automated context discovery (5-phase intelligent mode)
-- `--tool <codex|gemini|qwen>` - Select CLI tool (default: gemini, ignored in agent mode)
-- `--enhance` - Enhance inquiry with `/enhance-prompt` first
-- `--all-files` - Include entire codebase in context
-- `--save-session` - Save interaction to workflow session
-
-## Execution Flow
-
-### Standard Mode (Default)
-
-1. Parse tool selection (default: gemini)
-2. If `--enhance`: Execute `/enhance-prompt` to expand user intent
-3. Assemble context: `@{CLAUDE.md}` + user-specified files or `--all-files`
-4. Execute CLI tool with assembled context (read-only, analysis mode)
-5. Return explanations and insights (NO code changes)
-6. Optionally save to workflow session
-
-### Agent Mode (`--agent` flag)
-
-Delegate inquiry to `cli-execution-agent` for intelligent Q&A with automated context discovery.
-
-**Agent invocation**:
-```javascript
-Task(
-  subagent_type="cli-execution-agent",
-  description="Answer question with automated context discovery",
-  prompt=`
-    Task: ${inquiry}
-    Mode: analyze (Q&A)
-    Tool Preference: ${tool_flag || 'auto-select'}
-    ${all_files_flag ? 'Scope: all-files' : ''}
-
-    Agent will autonomously:
-    - Discover files relevant to the question
-    - Build Q&A prompt with precise context
-    - Execute and generate comprehensive answer
-    - Save conversation log
-  `
-)
-```
-
-The agent handles all phases internally.
-
-## Context Assembly
-
-**Always included**: `@{CLAUDE.md,**/*CLAUDE.md}` (project guidelines)
-
-**Optional**:
-- User-explicit files from inquiry keywords
-- `--all-files` flag includes entire codebase (`--all-files` wrapper parameter)
-
-For targeted analysis, use `rg` or MCP tools to discover relevant files first, then build precise CONTEXT field.
-
-## Command Template
-
-```bash
-cd . && ~/.claude/scripts/gemini-wrapper -p "
-INQUIRY: [user question]
-CONTEXT: @{CLAUDE.md,**/*CLAUDE.md} [inferred or --all-files]
-MODE: analysis
-RESPONSE: Direct answer, explanation, insights (NO code modification)
-"
-```
-
-## Examples
-
-**Basic Question (Standard Mode)**:
-```bash
-/cli:chat "analyze the authentication flow"
-# Executes: Gemini analysis
-# Returns: Explanation of auth flow, components involved, data flow
-```
-
-**Intelligent Q&A (Agent Mode)**:
-```bash
-/cli:chat --agent "how does JWT token refresh work in this codebase"
-# Phase 1: Understands inquiry = JWT refresh mechanism
-# Phase 2: Discovers JWT files, refresh logic, middleware patterns
-# Phase 3: Builds Q&A prompt with discovered implementation details
-# Phase 4: Executes Gemini with precise context for accurate answer
-# Phase 5: Saves conversation log with discovered context
-# Returns: Detailed answer with code references + execution log
-```
-
-**Architecture Question**:
-```bash
-/cli:chat --tool qwen "how does React component optimization work here"
-# Executes: Qwen architecture analysis
-# Returns: Component structure explanation, optimization patterns used
-```
-
-**Security Analysis**:
-```bash
-/cli:chat --tool codex "review security vulnerabilities"
-# Executes: Codex security analysis
-# Returns: Vulnerability assessment, security recommendations (NO automatic fixes)
-```
-
-**Enhanced Inquiry**:
-```bash
-/cli:chat --enhance "explain the login issue"
-# Step 1: Enhance to expand login context
-# Step 2: Analysis with expanded understanding
-# Returns: Detailed explanation of login flow and potential issues
-```
-
-**Broad Context**:
-```bash
-/cli:chat --all-files "find all API endpoints"
-# Executes: Analysis across entire codebase
-# Returns: List and explanation of API endpoints (NO code generation)
-```
-
-## Output Routing
-
-**Output Destination Logic**:
-- **Active session exists AND query is session-relevant**:
-  - Save to `.workflow/WFS-[id]/.chat/chat-[timestamp].md`
-- **No active session OR unrelated query**:
-  - Save to `.workflow/.scratchpad/chat-[description]-[timestamp].md`
-
-**Examples**:
-- During active session `WFS-api-refactor`, asking about API structure → `.chat/chat-20250105-143022.md`
-- No session, asking about build process → `.scratchpad/chat-build-process-20250105-143045.md`
-
-## Notes
-
-- Command templates and file patterns: see intelligent-tools-strategy.md (loaded in memory)
-- Scratchpad directory details: see workflow-architecture.md
-- Scratchpad conversations preserved for future reference

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

@@ -1,6 +1,6 @@
 ---
 name: cli-init
-description: Initialize CLI tool configurations (Gemini and Qwen) based on workspace analysis
+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(*)
 ---
@@ -32,7 +32,7 @@ Creates tool-specific configuration directories:
 - `.gemini/settings.json`:
 ```json
 {
-  "contextfilename": "CLAUDE.md"
+  "contextfilename": ["CLAUDE.md","GEMINI.md"]
 }
 ```
 
@@ -40,7 +40,7 @@ Creates tool-specific configuration directories:
 - `.qwen/settings.json`:
 ```json
 {
-  "contextfilename": "CLAUDE.md"
+  "contextfilename": ["CLAUDE.md","QWEN.md"]
 }
 ```
 
@@ -178,7 +178,7 @@ target/
 /cli:cli-init --tool all --output=.config/
 ```
 
-## EXECUTION INSTRUCTIONS ⚡ START HERE
+## EXECUTION INSTRUCTIONS - START HERE
 
 **When this command is triggered, follow these exact steps:**
 
@@ -191,7 +191,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
@@ -209,7 +209,7 @@ bash(find . -name "Dockerfile" | head -1)
 ```bash
 # Create .gemini/ directory and settings.json
 mkdir -p .gemini
-echo '{"contextfilename": "CLAUDE.md"}' > .gemini/settings.json
+Write({file_path: '.gemini/settings.json', content: '{"contextfilename": "CLAUDE.md"}'})
 
 # Create .geminiignore file with detected technology rules
 # Backup existing files if present
@@ -219,7 +219,7 @@ echo '{"contextfilename": "CLAUDE.md"}' > .gemini/settings.json
 ```bash
 # Create .qwen/ directory and settings.json
 mkdir -p .qwen
-echo '{"contextfilename": "CLAUDE.md"}' > .qwen/settings.json
+Write({file_path: '.qwen/settings.json', content: '{"contextfilename": "CLAUDE.md"}'})
 
 # Create .qwenignore file with detected technology rules
 # Backup existing files if present
@@ -428,15 +428,6 @@ docker-compose.override.yml
 /cli:cli-init --tool all --preview
 ```
 
-## Key Benefits
-
-- **Automatic Detection**: No manual configuration needed
-- **Multi-Tool Support**: Configure Gemini and Qwen simultaneously
-- **Technology Aware**: Rules adapted to actual project stack
-- **Maintainable**: Clear sections for easy customization
-- **Consistent**: Follows gitignore syntax standards
-- **Safe**: Creates backups of existing files
-- **Flexible**: Initialize specific tools or all at once
 
 ## Tool Selection Guide
 

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

@@ -1,520 +0,0 @@
----
-name: codex-execute
-description: Automated task decomposition and execution with Codex using resume mechanism
-argument-hint: "[--verify-git] task description or task-id"
-allowed-tools: SlashCommand(*), Bash(*), TodoWrite(*), Read(*), Glob(*)
----
-
-# CLI Codex Execute Command (/cli:codex-execute)
-
-## Purpose
-
-Automated task decomposition and sequential execution with Codex, using `codex exec "..." resume --last` mechanism for continuity between subtasks.
-
-**Input**: User description or task ID (automatically loads from `.task/[ID].json` if applicable)
-
-## Core Workflow
-
-```
-Task Input → Analyze Dependencies → Create Task Flow Diagram →
-Decompose into Subtask Groups → TodoWrite Tracking →
-For Each Subtask Group:
-  For First Subtask in Group:
-    0. Stage existing changes (git add -A) if valid git repo
-    1. Execute with Codex (new session)
-    2. [Optional] Git verification
-    3. Mark complete in TodoWrite
-  For Related Subtasks in Same Group:
-    0. Stage changes from previous subtask
-    1. Execute with `codex exec "..." resume --last` (continue session)
-    2. [Optional] Git verification
-    3. Mark complete in TodoWrite
-→ Final Summary
-```
-
-## Parameters
-
-- `<input>` (Required): Task description or task ID (e.g., "implement auth" or "IMPL-001")
-  - If input matches task ID format, loads from `.task/[ID].json`
-  - Otherwise, uses input as task description
-- `--verify-git` (Optional): Verify git status after each subtask completion
-
-## Execution Flow
-
-### Phase 1: Input Processing & Task Flow Analysis
-
-1. **Parse Input**:
-   - Check if input matches task ID pattern (e.g., `IMPL-001`, `TASK-123`)
-   - If yes: Load from `.task/[ID].json` and extract requirements
-   - If no: Use input as task description directly
-
-2. **Analyze Dependencies & Create Task Flow Diagram**:
-   - Analyze task complexity and scope
-   - Identify dependencies and relationships between subtasks
-   - Create visual task flow diagram showing:
-     - Independent task groups (parallel execution possible)
-     - Sequential dependencies (must use resume)
-     - Branching logic (conditional paths)
-   - Display flow diagram for user review
-
-**Task Flow Diagram Format**:
-```
-[Group A: Auth Core]
-  A1: Create user model ──┐
-  A2: Add validation     ─┤─► [resume] ─► A3: Database schema
-                          │
-[Group B: API Layer]      │
-  B1: Auth endpoints ─────┘─► [new session]
-  B2: Middleware ────────────► [resume] ─► B3: Error handling
-
-[Group C: Testing]
-  C1: Unit tests ─────────────► [new session]
-  C2: Integration tests ──────► [resume]
-```
-
-**Diagram Symbols**:
-- `──►` Sequential dependency (must resume previous session)
-- `─┐` Branch point (multiple paths)
-- `─┘` Merge point (wait for completion)
-- `[resume]` Use `codex exec "..." resume --last`
-- `[new session]` Start fresh Codex session
-
-3. **Decompose into Subtask Groups**:
-   - Group related subtasks that share context
-   - Break down into 3-8 subtasks total
-   - Assign each subtask to a group
-   - Create TodoWrite tracker with groups
-   - Display decomposition for user review
-
-**Decomposition Criteria**:
-- Each subtask: 5-15 minutes completable
-- Clear, testable outcomes
-- Explicit dependencies
-- Focused file scope (1-5 files per subtask)
-- **Group coherence**: Subtasks in same group share context/files
-
-### File Discovery for Task Decomposition
-
-Use `rg` or MCP tools to discover relevant files, then group by domain:
-
-**Workflow**: Discover → Analyze scope → Group by files → Create task flow
-
-**Example**:
-```bash
-# Discover files
-rg "authentication" --files-with-matches --type ts
-
-# Group by domain
-# Group A: src/auth/model.ts, src/auth/schema.ts
-# Group B: src/api/auth.ts, src/middleware/auth.ts
-# Group C: tests/auth/*.test.ts
-
-# Each group becomes a session with related subtasks
-```
-
-File patterns: see intelligent-tools-strategy.md (loaded in memory)
-
-### Phase 2: Group-Based Execution
-
-**Pre-Execution Git Staging** (if valid git repository):
-```bash
-# Stage all current changes before codex execution
-# This makes codex changes clearly visible in git diff
-git add -A
-git status --short
-```
-
-**For First Subtask in Each Group** (New Session):
-```bash
-# Start new Codex session for independent task group
-codex -C [dir] --full-auto exec "
-PURPOSE: [group goal]
-TASK: [subtask description - first in group]
-CONTEXT: @{relevant_files} @{CLAUDE.md}
-EXPECTED: [specific deliverables]
-RULES: [constraints]
-Group [X]: [group name] - Subtask 1 of N in this group
-" --skip-git-repo-check -s danger-full-access
-```
-
-**For Related Subtasks in Same Group** (Resume Session):
-```bash
-# Stage changes from previous subtask (if valid git repository)
-git add -A
-
-# Resume session ONLY for subtasks in same group
-codex exec "
-CONTINUE IN SAME GROUP:
-Group [X]: [group name] - Subtask N of M
-
-PURPOSE: [continuation goal within group]
-TASK: [subtask N description]
-CONTEXT: Previous work in this group completed, now focus on @{new_relevant_files}
-EXPECTED: [specific deliverables]
-RULES: Build on previous subtask in group, maintain consistency
-" resume --last --skip-git-repo-check -s danger-full-access
-```
-
-**For First Subtask in Different Group** (New Session):
-```bash
-# Stage changes from previous group
-git add -A
-
-# Start NEW session for different group (no resume)
-codex -C [dir] --full-auto exec "
-PURPOSE: [new group goal]
-TASK: [subtask description - first in new group]
-CONTEXT: @{different_files} @{CLAUDE.md}
-EXPECTED: [specific deliverables]
-RULES: [constraints]
-Group [Y]: [new group name] - Subtask 1 of N in this group
-" --skip-git-repo-check -s danger-full-access
-```
-
-**Resume Decision Logic**:
-```
-if (subtask.group == previous_subtask.group):
-    use `codex exec "..." resume --last`  # Continue session
-else:
-    use `codex -C [dir] exec "..."`       # New session
-```
-
-### Phase 3: Verification (if --verify-git enabled)
-
-After each subtask completion:
-```bash
-# Check git status
-git status --short
-
-# Verify expected changes
-git diff --stat
-
-# Optional: Check for untracked files that should be committed
-git ls-files --others --exclude-standard
-```
-
-**Verification Checks**:
-- Files modified match subtask scope
-- No unexpected changes in unrelated files
-- No merge conflicts or errors
-- Code compiles/runs (if applicable)
-
-### Phase 4: TodoWrite Tracking with Groups
-
-**Initial Setup with Task Flow**:
-```javascript
-TodoWrite({
-  todos: [
-    // Display task flow diagram first
-    { content: "Task Flow Analysis Complete - See diagram above", status: "completed", activeForm: "Analyzing task flow" },
-
-    // Group A subtasks (will use resume within group)
-    { content: "[Group A] Subtask 1: [description]", status: "in_progress", activeForm: "Executing Group A subtask 1" },
-    { content: "[Group A] Subtask 2: [description] [resume]", status: "pending", activeForm: "Executing Group A subtask 2" },
-
-    // Group B subtasks (new session, then resume within group)
-    { content: "[Group B] Subtask 1: [description] [new session]", status: "pending", activeForm: "Executing Group B subtask 1" },
-    { content: "[Group B] Subtask 2: [description] [resume]", status: "pending", activeForm: "Executing Group B subtask 2" },
-
-    // Group C subtasks (new session)
-    { content: "[Group C] Subtask 1: [description] [new session]", status: "pending", activeForm: "Executing Group C subtask 1" },
-
-    { content: "Final verification and summary", status: "pending", activeForm: "Verifying and summarizing" }
-  ]
-})
-```
-
-**After Each Subtask**:
-```javascript
-TodoWrite({
-  todos: [
-    { content: "Task Flow Analysis Complete - See diagram above", status: "completed", activeForm: "Analyzing task flow" },
-    { content: "[Group A] Subtask 1: [description]", status: "completed", activeForm: "Executing Group A subtask 1" },
-    { content: "[Group A] Subtask 2: [description] [resume]", status: "in_progress", activeForm: "Executing Group A subtask 2" },
-    // ... update status
-  ]
-})
-```
-
-## Codex Resume Mechanism
-
-**Why Group-Based Resume?**
-- **Within Group**: Maintains conversation context for related subtasks
-  - Codex remembers previous decisions and patterns
-  - Reduces context repetition
-  - Ensures consistency in implementation style
-- **Between Groups**: Fresh session for independent tasks
-  - Avoids context pollution from unrelated work
-  - Prevents confusion when switching domains
-  - Maintains focused attention on current group
-
-**How It Works**:
-1. **First subtask in Group A**: Creates new Codex session
-2. **Subsequent subtasks in Group A**: Use `codex resume --last` to continue session
-3. **First subtask in Group B**: Creates NEW Codex session (no resume)
-4. **Subsequent subtasks in Group B**: Use `codex resume --last` within Group B
-5. Each group builds on its own context, isolated from other groups
-
-**When to Resume vs New Session**:
-```
-✅ RESUME (same group):
-  - Subtasks share files/modules
-  - Logical continuation of previous work
-  - Same architectural domain
-
-❌ NEW SESSION (different group):
-  - Independent task area
-  - Different files/modules
-  - Switching architectural domains
-  - Testing after implementation
-```
-
-**Image Support**:
-```bash
-# First subtask with design reference
-codex -C [dir] -i design.png --full-auto exec "..." --skip-git-repo-check -s danger-full-access
-
-# Resume for next subtask (image context preserved)
-codex exec "CONTINUE TO NEXT SUBTASK: ..." resume --last --skip-git-repo-check -s danger-full-access
-```
-
-## Error Handling
-
-**Subtask Failure**:
-1. Mark subtask as blocked in TodoWrite
-2. Report error details to user
-3. Pause execution for manual intervention
-4. Use AskUserQuestion for recovery decision:
-
-```typescript
-AskUserQuestion({
-  questions: [{
-    question: "Codex execution failed for the subtask. How should the workflow proceed?",
-    header: "Recovery",
-    options: [
-      { label: "Retry Subtask", description: "Attempt to execute the same subtask again." },
-      { label: "Skip Subtask", description: "Continue to the next subtask in the plan." },
-      { label: "Abort Workflow", description: "Stop the entire execution." }
-    ],
-    multiSelect: false
-  }]
-})
-```
-
-**Git Verification Failure** (if --verify-git):
-1. Show unexpected changes
-2. Pause execution
-3. Request user decision:
-   - Continue anyway
-   - Rollback and retry
-   - Manual fix
-
-**Codex Session Lost**:
-1. Detect if `codex exec "..." resume --last` fails
-2. Attempt retry with fresh session
-3. Report to user if manual intervention needed
-
-## Output Format
-
-**During Execution**:
-```
-📊 Task Flow Diagram:
-[Group A: Auth Core]
-  A1: Create user model ──┐
-  A2: Add validation     ─┤─► [resume] ─► A3: Database schema
-                          │
-[Group B: API Layer]      │
-  B1: Auth endpoints ─────┘─► [new session]
-  B2: Middleware ────────────► [resume] ─► B3: Error handling
-
-[Group C: Testing]
-  C1: Unit tests ─────────────► [new session]
-  C2: Integration tests ──────► [resume]
-
-📋 Task Decomposition:
-  [Group A] 1. Create user model
-  [Group A] 2. Add validation logic [resume]
-  [Group A] 3. Implement database schema [resume]
-  [Group B] 4. Create auth endpoints [new session]
-  [Group B] 5. Add middleware [resume]
-  [Group B] 6. Error handling [resume]
-  [Group C] 7. Unit tests [new session]
-  [Group C] 8. Integration tests [resume]
-
-▶️  [Group A] Executing Subtask 1/8: Create user model
-  Starting new Codex session for Group A...
-  [Codex output]
-  ✅ Subtask 1 completed
-
-🔍 Git Verification:
-  M  src/models/user.ts
-  ✅ Changes verified
-
-▶️  [Group A] Executing Subtask 2/8: Add validation logic
-  Resuming Codex session (same group)...
-  [Codex output]
-  ✅ Subtask 2 completed
-
-▶️  [Group B] Executing Subtask 4/8: Create auth endpoints
-  Starting NEW Codex session for Group B...
-  [Codex output]
-  ✅ Subtask 4 completed
-...
-
-✅ All Subtasks Completed
-📊 Summary: [file references, changes, next steps]
-```
-
-**Final Summary**:
-```markdown
-# Task Execution Summary: [Task Description]
-
-## Subtasks Completed
-1. ✅ [Subtask 1]: [files modified]
-2. ✅ [Subtask 2]: [files modified]
-...
-
-## Files Modified
-- src/file1.ts:10-50 - [changes]
-- src/file2.ts - [changes]
-
-## Git Status
-- N files modified
-- M files added
-- No conflicts
-
-## Next Steps
-- [Suggested follow-up actions]
-```
-
-## Examples
-
-**Example 1: Simple Task with Groups**
-```bash
-/cli:codex-execute "implement user authentication system"
-
-# Task Flow Diagram:
-# [Group A: Data Layer]
-#   A1: Create user model ──► [resume] ──► A2: Database schema
-#
-# [Group B: Auth Logic]
-#   B1: JWT token generation ──► [new session]
-#   B2: Authentication middleware ──► [resume]
-#
-# [Group C: API Endpoints]
-#   C1: Login/logout endpoints ──► [new session]
-#
-# [Group D: Testing]
-#   D1: Unit tests ──► [new session]
-#   D2: Integration tests ──► [resume]
-
-# Execution:
-# Group A: A1 (new) → A2 (resume)
-# Group B: B1 (new) → B2 (resume)
-# Group C: C1 (new)
-# Group D: D1 (new) → D2 (resume)
-```
-
-**Example 2: With Git Verification**
-```bash
-/cli:codex-execute --verify-git "refactor API layer to use dependency injection"
-
-# After each subtask, verifies:
-# - Only expected files modified
-# - No breaking changes in unrelated code
-# - Tests still pass
-```
-
-**Example 3: With Task ID**
-```bash
-/cli:codex-execute IMPL-001
-
-# Loads task from .task/IMPL-001.json
-# Decomposes based on task requirements
-```
-
-## Best Practices
-
-1. **Task Flow First**: Always create visual flow diagram before execution
-2. **Group Related Work**: Cluster subtasks by domain/files for efficient resume
-3. **Subtask Granularity**: Keep subtasks small and focused (5-15 min each)
-4. **Clear Boundaries**: Each subtask should have well-defined input/output
-5. **Git Hygiene**: Use `--verify-git` for critical refactoring
-6. **Pre-Execution Staging**: Stage changes before each subtask to clearly see codex modifications
-7. **Smart Resume**: Use `resume --last` ONLY within same group
-8. **Fresh Sessions**: Start new session when switching to different group/domain
-9. **Recovery Points**: TodoWrite with group labels provides clear progress tracking
-10. **Image References**: Attach design files for UI tasks (first subtask in group)
-
-## Input Processing
-
-**Automatic Detection**:
-- Input matches task ID pattern → Load from `.task/[ID].json`
-- Otherwise → Use as task description
-
-**Task JSON Structure** (when loading from file):
-```json
-{
-  "task_id": "IMPL-001",
-  "title": "Implement user authentication",
-  "description": "Create JWT-based auth system",
-  "acceptance_criteria": [...],
-  "scope": {...},
-  "brainstorming_refs": [...]
-}
-```
-
-## Output Routing
-
-**Execution Log Destination**:
-- **IF** active workflow session exists:
-  - Execution log: `.workflow/WFS-[id]/.chat/codex-execute-[timestamp].md`
-  - Task summaries: `.workflow/WFS-[id]/.summaries/[TASK-ID]-summary.md` (if task ID)
-  - Task updates: `.workflow/WFS-[id]/.task/[TASK-ID].json` status updates
-  - TodoWrite tracking: Embedded in execution log
-- **ELSE** (no active session):
-  - **Recommended**: Create workflow session first (`/workflow:session:start`)
-  - **Alternative**: Save to `.workflow/.scratchpad/codex-execute-[description]-[timestamp].md`
-
-**Output Files** (during execution):
-```
-.workflow/WFS-[session-id]/
-├── .chat/
-│   └── codex-execute-20250105-143022.md    # Full execution log with task flow
-├── .summaries/
-│   ├── IMPL-001.1-summary.md               # Subtask summaries
-│   ├── IMPL-001.2-summary.md
-│   └── IMPL-001-summary.md                 # Final task summary
-└── .task/
-    ├── IMPL-001.json                       # Updated task status
-    └── [subtask JSONs if decomposed]
-```
-
-**Examples**:
-- During session `WFS-auth-system`, executing multi-stage auth implementation:
-  - Log: `.workflow/WFS-auth-system/.chat/codex-execute-20250105-143022.md`
-  - Summaries: `.workflow/WFS-auth-system/.summaries/IMPL-001.{1,2,3}-summary.md`
-  - Task status: `.workflow/WFS-auth-system/.task/IMPL-001.json` (status: completed)
-- No session, ad-hoc multi-stage task:
-  - Log: `.workflow/.scratchpad/codex-execute-auth-refactor-20250105-143045.md`
-
-**Save Results**:
-- Execution log with task flow diagram and TodoWrite tracking
-- Individual summaries for each completed subtask
-- Final consolidated summary when all subtasks complete
-- Modified code files throughout project
-
-## Notes
-
-**vs. `/cli:execute`**:
-- `/cli:execute`: Single-shot execution with Gemini/Qwen/Codex
-- `/cli:codex-execute`: Multi-stage Codex execution with automatic task decomposition and resume mechanism
-
-**Input Flexibility**: Accepts both freeform descriptions and task IDs (auto-detects and loads JSON)
-
-**Context Window**: `codex exec "..." resume --last` maintains conversation history, ensuring consistency across subtasks without redundant context injection.
-
-**Output Details**:
-- Output routing and scratchpad details: see workflow-architecture.md
-- Session management: see intelligent-tools-strategy.md
-- **⚠️ Code Modification**: This command performs multi-stage code modifications - execution log tracks all changes

.claude/commands/cli/discuss-plan.md

@@ -1,321 +0,0 @@
----
-name: discuss-plan
-description: Orchestrates an iterative, multi-model discussion for planning and analysis without implementation.
-argument-hint: "[--topic '...'] [--task-id '...'] [--rounds N]"
-allowed-tools: SlashCommand(*), Bash(*), TodoWrite(*), Read(*), Glob(*)
----
-
-# CLI Discuss-Plan Command (/cli:discuss-plan)
-
-## Purpose
-
-Orchestrates a multi-model collaborative discussion for in-depth planning and problem analysis. This command facilitates an iterative dialogue between Gemini, Codex, and Claude (the orchestrating AI) to explore a topic from multiple perspectives, refine ideas, and build a robust plan.
-
-**This command is for discussion and planning ONLY. It does NOT modify any code.**
-
-## Core Workflow: The Discussion Loop
-
-The command operates in iterative rounds, allowing the plan to evolve with each cycle. The user can choose to continue for more rounds or conclude when consensus is reached.
-
-```
-Topic Input → [Round 1: Gemini → Codex → Claude] → [User Review] →
-[Round 2: Gemini → Codex → Claude] → ... → Final Plan
-```
-
-### Model Roles & Priority
-
-**Priority Order**: Gemini > Codex > Claude
-
-1.  **Gemini (The Analyst)** - Priority 1
-    - Kicks off each round with deep analysis
-    - Provides foundational ideas and draft plans
-    - Analyzes current context or previous synthesis
-
-2.  **Codex (The Architect/Critic)** - Priority 2
-    - Reviews Gemini's output critically
-    - Uses deep reasoning for technical trade-offs
-    - Proposes alternative strategies
-    - **Participates purely in conversational/reasoning capacity**
-    - Uses resume mechanism to maintain discussion context
-
-3.  **Claude (The Synthesizer/Moderator)** - Priority 3
-    - Synthesizes discussion from Gemini and Codex
-    - Highlights agreements and contentions
-    - Structures refined plan
-    - Poses key questions for next round
-
-## Parameters
-
--   `<input>` (Required): Topic description or task ID (e.g., "Design a new caching layer" or `PLAN-002`)
--   `--rounds <N>` (Optional): Maximum number of discussion rounds (default: prompts after each round)
--   `--task-id <id>` (Optional): Associates discussion with workflow task ID
--   `--topic <description>` (Optional): High-level topic for discussion
-
-## Execution Flow
-
-### Phase 1: Initial Setup
-
-1.  **Input Processing**: Parse topic or task ID
-2.  **Context Gathering**: Identify relevant files based on topic
-
-### Phase 2: Discussion Round
-
-Each round consists of three sequential steps, tracked via `TodoWrite`.
-
-**Step 1: Gemini's Analysis (Priority 1)**
-
-Gemini analyzes the topic and proposes preliminary plan.
-
-```bash
-# Round 1: CONTEXT_INPUT is the initial topic
-# Subsequent rounds: CONTEXT_INPUT is the synthesis from previous round
-~/.claude/scripts/gemini-wrapper -p "
-PURPOSE: Analyze and propose a plan for '[topic]'
-TASK: Provide initial analysis, identify key modules, and draft implementation plan
-MODE: analysis
-CONTEXT: @{CLAUDE.md} [auto-detected files]
-INPUT: [CONTEXT_INPUT]
-EXPECTED: Structured analysis and draft plan for discussion
-RULES: Focus on technical depth and practical considerations
-"
-```
-
-**Step 2: Codex's Critique (Priority 2)**
-
-Codex reviews Gemini's output using conversational reasoning. Uses `resume --last` to maintain context across rounds.
-
-```bash
-# First round (new session)
-codex --full-auto exec "
-PURPOSE: Critically review technical plan
-TASK: Review the provided plan, identify weaknesses, suggest alternatives, reason about trade-offs
-MODE: analysis
-CONTEXT: @{CLAUDE.md} [relevant files]
-INPUT_PLAN: [Output from Gemini's analysis]
-EXPECTED: Critical review with alternative ideas and risk analysis
-RULES: Focus on architectural soundness and implementation feasibility
-" --skip-git-repo-check
-
-# Subsequent rounds (resume discussion)
-codex --full-auto exec "
-PURPOSE: Re-evaluate plan based on latest synthesis
-TASK: Review updated plan and discussion points, provide further critique or refined ideas
-MODE: analysis
-CONTEXT: Previous discussion context (maintained via resume)
-INPUT_PLAN: [Output from Gemini's analysis for current round]
-EXPECTED: Updated critique building on previous discussion
-RULES: Build on previous insights, avoid repeating points
-" resume --last --skip-git-repo-check
-```
-
-**Step 3: Claude's Synthesis (Priority 3)**
-
-Claude (orchestrating AI) synthesizes both outputs:
-
--   Summarizes Gemini's proposal and Codex's critique
--   Highlights agreements and disagreements
--   Structures consolidated plan
--   Presents open questions for next round
--   This synthesis becomes input for next round
-
-### Phase 3: User Review and Iteration
-
-1.  **Present Synthesis**: Show synthesized plan and key discussion points
-2.  **Continue or Conclude**: Use AskUserQuestion to prompt user:
-
-```typescript
-AskUserQuestion({
-  questions: [{
-    question: "Round of discussion complete. What is the next step?",
-    header: "Next Round",
-    options: [
-      { label: "Start another round", description: "Continue the discussion to refine the plan further." },
-      { label: "Conclude and finalize", description: "End the discussion and save the final plan." }
-    ],
-    multiSelect: false
-  }]
-})
-```
-
-3.  **Loop or Finalize**:
-    -   Continue → New round with Gemini analyzing latest synthesis
-    -   Conclude → Save final synthesized document
-
-## TodoWrite Tracking
-
-Progress tracked for each round and model.
-
-```javascript
-// Example for 2-round discussion
-TodoWrite({
-  todos: [
-    // Round 1
-    { content: "[Round 1] Gemini: Analyzing topic", status: "completed", activeForm: "Analyzing with Gemini" },
-    { content: "[Round 1] Codex: Critiquing plan", status: "completed", activeForm: "Critiquing with Codex" },
-    { content: "[Round 1] Claude: Synthesizing discussion", status: "completed", activeForm: "Synthesizing discussion" },
-    { content: "[User Action] Review Round 1 and decide next step", status: "in_progress", activeForm: "Awaiting user decision" },
-
-    // Round 2
-    { content: "[Round 2] Gemini: Analyzing refined plan", status: "pending", activeForm: "Analyzing refined plan" },
-    { content: "[Round 2] Codex: Re-evaluating plan [resume]", status: "pending", activeForm: "Re-evaluating with Codex" },
-    { content: "[Round 2] Claude: Finalizing plan", status: "pending", activeForm: "Finalizing plan" },
-    { content: "Discussion complete - Final plan generated", status: "pending", activeForm: "Generating final document" }
-  ]
-})
-```
-
-## Output Routing
-
--   **Primary Log**: Entire multi-round discussion logged to single file:
-    -   `.workflow/WFS-[id]/.chat/discuss-plan-[topic]-[timestamp].md`
--   **Final Plan**: Clean final version saved upon conclusion:
-    -   `.workflow/WFS-[id]/.summaries/plan-[topic].md`
--   **Scratchpad**: If no session active:
-    -   `.workflow/.scratchpad/discuss-plan-[topic]-[timestamp].md`
-
-## Discussion Structure
-
-Each round's output is structured as:
-
-```markdown
-## Round N: [Topic]
-
-### Gemini's Analysis (Priority 1)
-[Gemini's full analysis and proposal]
-
-### Codex's Critique (Priority 2)
-[Codex's critical review and alternatives]
-
-### Claude's Synthesis (Priority 3)
-**Points of Agreement:**
-- [Agreement 1]
-- [Agreement 2]
-
-**Points of Contention:**
-- [Issue 1]: Gemini suggests X, Codex suggests Y
-- [Issue 2]: Trade-off between A and B
-
-**Consolidated Plan:**
-[Structured plan incorporating both perspectives]
-
-**Open Questions for Next Round:**
-1. [Question 1]
-2. [Question 2]
-```
-
-## Examples
-
-### Example 1: Multi-Round Architecture Discussion
-
-**Command**: `/cli:discuss-plan --topic "Design a real-time notification system"`
-
-**Round 1**:
-1.  **Gemini**: Proposes WebSocket-based architecture with RabbitMQ message queue
-2.  **Codex**: Critiques as overly complex for MVP. Suggests Server-Sent Events (SSE) for simplicity (one-way notifications). Questions RabbitMQ necessity, proposes simpler Redis Pub/Sub
-3.  **Claude**: Synthesizes views:
-    -   **Plan A (Gemini)**: WebSockets + RabbitMQ (highly scalable, complex)
-    -   **Plan B (Codex)**: SSE + Redis (simpler, less overhead)
-    -   **Open Question**: Is bi-directional communication critical, or is simplicity priority?
-4.  **User Action**: Opts for another round to explore trade-offs
-
-**Round 2**:
-1.  **Gemini**: Analyzes synthesized document. Notes that if features like "user is typing" indicators are roadmapped, WebSockets better long-term. Drafts plan starting with SSE/Redis but designing for easy migration
-2.  **Codex**: Reviews migration plan. Reasons that migration itself could be complex. If feature set likely to expand, starting with WebSockets using managed service might be best cost/benefit
-3.  **Claude**: Synthesizes new discussion:
-    -   **Consensus**: Simple SSE/Redis too short-sighted
-    -   **Refined Options**:
-        1.  Phased approach (SSE → WebSocket) with clear migration plan
-        2.  Direct WebSocket with managed service (Pusher, Ably) to reduce ops overhead
-    -   **Recommendation**: Option 2 most robust and future-proof
-4.  **User Action**: Agrees with recommendation, concludes discussion
-
-**Final Output**: Planning document saved with:
-- Chosen architecture (Managed WebSocket service)
-- Multi-round reasoning
-- High-level implementation steps
-
-### Example 2: Feature Design Discussion
-
-**Command**: `/cli:discuss-plan --topic "Design user permission system" --rounds 2`
-
-**Round 1**:
-1.  **Gemini**: Proposes RBAC (Role-Based Access Control) with predefined roles
-2.  **Codex**: Suggests ABAC (Attribute-Based Access Control) for more flexibility
-3.  **Claude**: Synthesizes trade-offs between simplicity (RBAC) vs flexibility (ABAC)
-
-**Round 2**:
-1.  **Gemini**: Analyzes hybrid approach - RBAC for core permissions, attributes for fine-grained control
-2.  **Codex**: Reviews hybrid model, identifies implementation challenges
-3.  **Claude**: Final plan with phased rollout strategy
-
-**Automatic Conclusion**: Command concludes after 2 rounds as specified
-
-### Example 3: Problem-Solving Discussion
-
-**Command**: `/cli:discuss-plan --topic "Debug memory leak in data pipeline" --task-id ISSUE-042`
-
-**Round 1**:
-1.  **Gemini**: Identifies potential leak sources (unclosed handles, growing cache, event listeners)
-2.  **Codex**: Adds profiling tool recommendations, suggests memory monitoring
-3.  **Claude**: Structures debugging plan with phased approach
-
-**User Decision**: Single round sufficient, concludes with debugging strategy
-
-## Consensus Mechanisms
-
-**When to Continue:**
-- Significant disagreement between models
-- Open questions requiring deeper analysis
-- Trade-offs need more exploration
-- User wants additional perspectives
-
-**When to Conclude:**
-- Models converge on solution
-- All key questions addressed
-- User satisfied with plan depth
-- Maximum rounds reached (if specified)
-
-## Comparison with Other Commands
-
-| Command | Models | Rounds | Discussion | Implementation | Use Case |
-|---------|--------|--------|------------|----------------|----------|
-| `/cli:mode:plan` | Gemini | 1 | ❌ NO | ❌ NO | Single-model planning |
-| `/cli:analyze` | Gemini/Qwen | 1 | ❌ NO | ❌ NO | Code analysis |
-| `/cli:execute` | Any | 1 | ❌ NO | ✅ YES | Direct implementation |
-| `/cli:codex-execute` | Codex | 1 | ❌ NO | ✅ YES | Multi-stage implementation |
-| `/cli:discuss-plan` | **Gemini+Codex+Claude** | **Multiple** | ✅ **YES** | ❌ **NO** | **Multi-perspective planning** |
-
-## Best Practices
-
-1.  **Use for Complex Decisions**: Ideal for architectural decisions, design trade-offs, problem-solving
-2.  **Start with Broad Topic**: Let first round establish scope, subsequent rounds refine
-3.  **Review Each Synthesis**: Claude's synthesis is key decision point - review carefully
-4.  **Know When to Stop**: Don't over-iterate - 2-3 rounds usually sufficient
-5.  **Task Association**: Use `--task-id` for traceability in workflow
-6.  **Save Intermediate Results**: Each round's synthesis saved automatically
-7.  **Let Models Disagree**: Divergent views often reveal important trade-offs
-8.  **Focus Questions**: Use Claude's open questions to guide next round
-
-## Breaking Discussion Loops
-
-**Detecting Loops:**
-- Models repeating same arguments
-- No new insights emerging
-- Trade-offs well understood
-
-**Breaking Strategies:**
-1.  **User Decision**: Make executive decision when enough info gathered
-2.  **Timeboxing**: Set max rounds upfront with `--rounds`
-3.  **Criteria-Based**: Define decision criteria before starting
-4.  **Hybrid Approach**: Accept multiple valid solutions in final plan
-
-## Notes
-
--   **Pure Discussion**: This command NEVER modifies code - only produces planning documents
--   **Codex Role**: Codex participates as reasoning/critique tool, not executor
--   **Resume Context**: Codex maintains discussion context via `resume --last`
--   **Priority System**: Ensures Gemini leads analysis, Codex provides critique, Claude synthesizes
--   **Output Quality**: Multi-perspective discussion produces more robust plans than single-model analysis
--   Command patterns and session management: see intelligent-tools-strategy.md (loaded in memory)
--   Output routing details: see workflow-architecture.md
--   For implementation after discussion, use `/cli:execute` or `/cli:codex-execute` separately

.claude/commands/cli/execute.md

@@ -1,222 +0,0 @@
----
-name: execute
-description: Auto-execution of implementation tasks with YOLO permissions and intelligent context inference
-argument-hint: "[--agent] [--tool codex|gemini|qwen] [--enhance] description or task-id"
-allowed-tools: SlashCommand(*), Bash(*), Task(*)
----
-
-# CLI Execute Command (/cli:execute)
-
-## Purpose
-
-Execute implementation tasks with **YOLO permissions** (auto-approves all confirmations). **MODIFIES CODE**.
-
-**Intent**: Autonomous code implementation, modification, and generation
-**Supported Tools**: codex, gemini (default), qwen
-**Key Feature**: Automatic context inference and file pattern detection
-
-## Core Behavior
-
-1. **Code Modification**: This command MODIFIES, CREATES, and DELETES code files
-2. **Auto-Approval**: YOLO mode bypasses confirmation prompts for all operations
-3. **Implementation Focus**: Executes actual code changes, not just recommendations
-4. **Requires Explicit Intent**: Use only when implementation is intended
-
-## Core Concepts
-
-### YOLO Permissions
-Auto-approves: file pattern inference, execution, **file modifications**, summary generation
-
-**⚠️ WARNING**: This command will make actual code changes without manual confirmation
-
-### Execution Modes
-
-**1. Description Mode** (supports `--enhance`):
-- Input: Natural language description
-- Process: [Optional: Enhance] → Keyword analysis → Pattern inference → Execute
-
-**2. Task ID Mode** (no `--enhance`):
-- Input: Workflow task identifier (e.g., `IMPL-001`)
-- Process: Task JSON parsing → Scope analysis → Execute
-
-**3. Agent Mode** (`--agent` flag):
-- Input: Description or task-id
-- Process: 5-Phase Workflow → Context Discovery → Optimal Tool Selection → Execute
-
-### Context Inference
-
-Auto-selects files based on keywords and technology:
-- "auth" → `@{**/*auth*,**/*user*}`
-- "React" → `@{src/**/*.{jsx,tsx}}`
-- "api" → `@{**/api/**/*,**/routes/**/*}`
-- Always includes: `@{CLAUDE.md,**/*CLAUDE.md}`
-
-For precise file targeting, use `rg` or MCP tools to discover files first.
-
-### Codex Session Continuity
-
-**Resume Pattern** for related tasks:
-```bash
-# First task - establish session
-codex -C [dir] --full-auto exec "[task]" --skip-git-repo-check -s danger-full-access
-
-# Related task - continue session
-codex --full-auto exec "[related-task]" resume --last --skip-git-repo-check -s danger-full-access
-```
-
-Use `resume --last` when current task extends/relates to previous execution. See intelligent-tools-strategy.md for auto-resume rules.
-
-## Parameters
-
-- `--agent` - Use cli-execution-agent for automated context discovery (5-phase intelligent mode)
-- `--tool <codex|gemini|qwen>` - Select CLI tool (default: gemini, ignored in agent mode unless specified)
-- `--enhance` - Enhance input with `/enhance-prompt` first (Description Mode only)
-- `<description|task-id>` - Natural language description or task identifier
-- `--debug` - Verbose logging
-- `--save-session` - Save execution to workflow session
-
-## Workflow Integration
-
-**Session Management**: Auto-detects `.workflow/.active-*` marker
-- Active session: Save to `.workflow/WFS-[id]/.chat/execute-[timestamp].md`
-- No session: Create new session or save to scratchpad
-
-**Task Integration**: Load from `.task/[TASK-ID].json`, update status, generate summary
-
-## Output Routing
-
-**Execution Log Destination**:
-- **IF** active workflow session exists:
-  - Save to `.workflow/WFS-[id]/.chat/execute-[timestamp].md`
-  - Update task status in `.task/[TASK-ID].json` (if task ID provided)
-  - Generate summary in `.workflow/WFS-[id]/.summaries/[TASK-ID]-summary.md`
-- **ELSE** (no active session):
-  - **Option 1**: Create new workflow session for task
-  - **Option 2**: Save to `.workflow/.scratchpad/execute-[description]-[timestamp].md`
-
-**Output Files** (when active session exists):
-- Execution log: `.workflow/WFS-[id]/.chat/execute-[timestamp].md`
-- Task summary: `.workflow/WFS-[id]/.summaries/[TASK-ID]-summary.md` (if task ID)
-- Modified code: Project files per implementation
-
-**Examples**:
-- During session `WFS-auth-system`, executing `IMPL-001`:
-  - Log: `.workflow/WFS-auth-system/.chat/execute-20250105-143022.md`
-  - Summary: `.workflow/WFS-auth-system/.summaries/IMPL-001-summary.md`
-- No session, ad-hoc implementation:
-  - Log: `.workflow/.scratchpad/execute-jwt-auth-20250105-143045.md`
-
-## Execution Modes
-
-### Standard Mode (Default)
-```bash
-# Gemini/Qwen: MODE=write with --approval-mode yolo
-cd . && ~/.claude/scripts/gemini-wrapper --approval-mode yolo -p "
-PURPOSE: [implementation goal]
-TASK: [specific implementation]
-MODE: write
-CONTEXT: @{CLAUDE.md} [auto-detected files]
-EXPECTED: Working implementation with code changes
-RULES: [constraints] | Auto-approve all changes
-"
-
-# Codex: MODE=auto with danger-full-access
-codex -C . --full-auto exec "
-PURPOSE: [implementation goal]
-TASK: [specific implementation]
-MODE: auto
-CONTEXT: [auto-detected files]
-EXPECTED: Complete implementation with tests
-" --skip-git-repo-check -s danger-full-access
-```
-
-### Agent Mode (`--agent` flag)
-
-Delegate implementation to `cli-execution-agent` for intelligent execution with automated context discovery.
-
-**Agent invocation**:
-```javascript
-Task(
-  subagent_type="cli-execution-agent",
-  description="Implement with automated context discovery and optimal tool selection",
-  prompt=`
-    Task: ${description_or_task_id}
-    Mode: execute
-    Tool Preference: ${tool_flag || 'auto-select'}
-    ${enhance_flag ? 'Enhance: true' : ''}
-
-    Agent will autonomously:
-    - Discover implementation files and dependencies
-    - Assess complexity and select optimal tool
-    - Execute with YOLO permissions (auto-approve)
-    - Generate task summary if task-id provided
-  `
-)
-```
-
-The agent handles all phases internally, including complexity-based tool selection.
-
-## Examples
-
-**Basic Implementation (Standard Mode)** (⚠️ modifies code):
-```bash
-/cli:execute "implement JWT authentication with middleware"
-# Executes: Creates auth middleware, updates routes, modifies config
-# Result: NEW/MODIFIED code files with JWT implementation
-```
-
-**Intelligent Implementation (Agent Mode)** (⚠️ modifies code):
-```bash
-/cli:execute --agent "implement OAuth2 authentication with token refresh"
-# Phase 1: Classifies intent=execute, complexity=complex, keywords=['oauth2', 'auth', 'token', 'refresh']
-# Phase 2: MCP discovers auth patterns, existing middleware, JWT dependencies
-# Phase 3: Enhances prompt with discovered patterns and best practices
-# Phase 4: Selects Codex (complex task), executes with comprehensive context
-# Phase 5: Saves execution log + generates implementation summary
-# Result: Complete OAuth2 implementation + detailed execution log
-```
-
-**Enhanced Implementation** (⚠️ modifies code):
-```bash
-/cli:execute --enhance "implement JWT authentication"
-# Step 1: Enhance to expand requirements
-# Step 2: Execute implementation with auto-approval
-# Result: Complete auth system with MODIFIED code files
-```
-
-**Task Execution** (⚠️ modifies code):
-```bash
-/cli:execute IMPL-001
-# Reads: .task/IMPL-001.json for requirements
-# Executes: Implementation based on task spec
-# Result: Code changes per task definition
-```
-
-**Codex Implementation** (⚠️ modifies code):
-```bash
-/cli:execute --tool codex "optimize database queries"
-# Executes: Codex with full file access
-# Result: MODIFIED query code, new indexes, updated tests
-```
-
-**Qwen Code Generation** (⚠️ modifies code):
-```bash
-/cli:execute --tool qwen --enhance "refactor auth module"
-# Step 1: Enhanced refactoring plan
-# Step 2: Execute with MODE=write
-# Result: REFACTORED auth code with structural changes
-```
-
-## Comparison with Analysis Commands
-
-| Command | Intent | Code Changes | Auto-Approve |
-|---------|--------|--------------|--------------|
-| `/cli:analyze` | Understand code | ❌ NO | N/A |
-| `/cli:chat` | Ask questions | ❌ NO | N/A |
-| `/cli:execute` | **Implement** | ✅ **YES** | ✅ **YES** |
-
-## Notes
-
-- Command templates, YOLO mode details, and session management: see intelligent-tools-strategy.md (loaded in memory)
-- Output routing and scratchpad details: see workflow-architecture.md
-- **⚠️ Code Modification**: This command modifies code - execution logs document changes made

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

@@ -1,164 +0,0 @@
----
-name: bug-index
-description: Bug analysis and fix suggestions using CLI tools
-argument-hint: "[--agent] [--tool codex|gemini|qwen] [--enhance] [--cd path] bug description"
-allowed-tools: SlashCommand(*), Bash(*), Task(*)
----
-
-# CLI Mode: Bug Index (/cli:mode:bug-index)
-
-## Purpose
-
-Systematic bug analysis with diagnostic template (`~/.claude/prompt-templates/bug-fix.md`).
-
-**Supported Tools**: codex, gemini (default), qwen
-**Key Feature**: `--cd` flag for directory-scoped analysis
-
-## Parameters
-
-- `--agent` - Use cli-execution-agent for automated context discovery (5-phase intelligent mode)
-- `--tool <codex|gemini|qwen>` - Tool selection (default: gemini, ignored in agent mode)
-- `--enhance` - Enhance bug description with `/enhance-prompt` first
-- `--cd "path"` - Target directory for focused analysis
-- `<bug-description>` (Required) - Bug description or error message
-
-## Execution Flow
-
-### Standard Mode (Default)
-
-1. **Parse tool selection**: Extract `--tool` flag (default: gemini)
-2. **If `--enhance` flag present**: Execute `/enhance-prompt "[bug-description]"` first
-3. Parse bug description (original or enhanced)
-4. Detect target directory (from `--cd` or auto-infer)
-5. Build command for selected tool with bug-fix template
-6. Execute analysis (read-only, provides fix recommendations)
-7. Save to `.workflow/WFS-[id]/.chat/bug-index-[timestamp].md`
-
-### Agent Mode (`--agent` flag)
-
-Delegate bug analysis to `cli-execution-agent` for intelligent debugging with automated context discovery.
-
-**Agent invocation**:
-```javascript
-Task(
-  subagent_type="cli-execution-agent",
-  description="Analyze bug with automated context discovery",
-  prompt=`
-    Task: ${bug_description}
-    Mode: debug (bug analysis)
-    Tool Preference: ${tool_flag || 'auto-select'}
-    ${cd_flag ? `Directory Scope: ${cd_path}` : ''}
-    Template: bug-fix
-
-    Agent will autonomously:
-    - Discover bug-related files and error traces
-    - Build debug prompt with bug-fix template
-    - Execute analysis and provide fix recommendations
-    - Save analysis log
-  `
-)
-```
-
-The agent handles all phases internally.
-
-## Core Rules
-
-1. **Analysis Only**: This command analyzes bugs and suggests fixes - it does NOT modify code
-2. **Enhance First (if flagged)**: Execute `/enhance-prompt` before analysis
-3. **Directory Context**: Use `cd` when `--cd` provided or auto-detected
-4. **Template Required**: Always use bug-fix template
-5. **Session Output**: Save analysis results and fix recommendations to session chat
-
-## Analysis Focus (via Template)
-
-- Root cause investigation and diagnosis
-- Code path tracing to locate issues
-- Targeted minimal fix recommendations
-- Impact assessment of proposed changes
-
-## Command Template
-
-```bash
-cd [directory] && ~/.claude/scripts/gemini-wrapper --all-files -p "
-PURPOSE: [bug analysis goal]
-TASK: Systematic bug analysis and fix recommendations
-MODE: analysis
-CONTEXT: @{CLAUDE.md,**/*CLAUDE.md} [entire codebase in directory]
-EXPECTED: Root cause analysis, code path tracing, targeted fix suggestions
-RULES: $(cat ~/.claude/prompt-templates/bug-fix.md) | Bug: [description]
-"
-```
-
-## Examples
-
-**Basic Bug Analysis (Standard Mode)**:
-```bash
-/cli:mode:bug-index "null pointer error in login flow"
-# Executes: Gemini with bug-fix template
-# Returns: Root cause analysis, fix recommendations
-```
-
-**Intelligent Bug Analysis (Agent Mode)**:
-```bash
-/cli:mode:bug-index --agent "intermittent token validation failure"
-# Phase 1: Classifies as debug task, extracts keywords ['token', 'validation', 'failure']
-# Phase 2: MCP discovers token validation code, middleware, test files with errors
-# Phase 3: Builds debug prompt with bug-fix template + discovered error patterns
-# Phase 4: Executes Gemini with comprehensive bug context
-# Phase 5: Saves analysis log with detailed fix recommendations
-# Returns: Root cause analysis + code path traces + minimal fix suggestions
-```
-
-**Standard Template Example**:
-```bash
-cd . && ~/.claude/scripts/gemini-wrapper --all-files -p "
-PURPOSE: Debug authentication null pointer error
-TASK: Identify root cause and provide fix recommendations
-MODE: analysis
-CONTEXT: @{CLAUDE.md,**/*CLAUDE.md}
-EXPECTED: Root cause, code path, minimal fix suggestion, impact assessment
-RULES: $(cat ~/.claude/prompt-templates/bug-fix.md) | Bug: null pointer in login flow
-"
-```
-
-**Directory-Specific**:
-```bash
-cd src/auth && ~/.claude/scripts/gemini-wrapper --all-files -p "
-PURPOSE: Fix token validation failure
-TASK: Analyze token validation bug in auth module
-MODE: analysis
-CONTEXT: @{CLAUDE.md,**/*CLAUDE.md}
-EXPECTED: Validation logic analysis, fix recommendation with minimal changes
-RULES: $(cat ~/.claude/prompt-templates/bug-fix.md) | Bug: token validation fails intermittently
-"
-```
-
-## Bug Investigation Workflow
-
-```bash
-# 1. Find bug-related files
-rg "error_keyword" --files-with-matches
-mcp__code-index__search_code_advanced(pattern="error|exception", file_pattern="*.ts")
-
-# 2. Execute bug analysis with focused context (analysis only, no code changes)
-/cli:mode:bug-index --cd "src/module" "specific error description"
-```
-
-## Output Routing
-
-**Output Destination Logic**:
-- **Active session exists AND bug is session-relevant**:
-  - Save to `.workflow/WFS-[id]/.chat/bug-index-[timestamp].md`
-- **No active session OR quick debugging**:
-  - Save to `.workflow/.scratchpad/bug-index-[description]-[timestamp].md`
-
-**Examples**:
-- During active session `WFS-payment-fix`, analyzing payment bug → `.chat/bug-index-20250105-143022.md`
-- No session, quick null pointer investigation → `.scratchpad/bug-index-null-pointer-20250105-143045.md`
-
-## Notes
-
-- Command templates and file patterns: see intelligent-tools-strategy.md (loaded in memory)
-- Scratchpad directory details: see workflow-architecture.md
-- Template path: `~/.claude/prompt-templates/bug-fix.md`
-- Always uses `--all-files` for comprehensive codebase context

.claude/commands/cli/mode/code-analysis.md

@@ -1,170 +0,0 @@
----
-name: code-analysis
-description: Deep code analysis and debugging using CLI tools with specialized template
-argument-hint: "[--agent] [--tool codex|gemini|qwen] [--enhance] [--cd path] analysis target"
-allowed-tools: SlashCommand(*), Bash(*), Task(*)
----
-
-# CLI Mode: Code Analysis (/cli:mode:code-analysis)
-
-## Purpose
-
-Systematic code analysis with execution path tracing template (`~/.claude/prompt-templates/code-analysis.md`).
-
-**Supported Tools**: codex, gemini (default), qwen
-**Key Feature**: `--cd` flag for directory-scoped analysis
-
-## Parameters
-
-- `--agent` - Use cli-execution-agent for automated context discovery (5-phase intelligent mode)
-- `--tool <codex|gemini|qwen>` - Tool selection (default: gemini, ignored in agent mode)
-- `--enhance` - Enhance analysis target with `/enhance-prompt` first
-- `--cd "path"` - Target directory for focused analysis
-- `<analysis-target>` (Required) - Code analysis target or question
-
-## Execution Flow
-
-### Standard Mode (Default)
-
-1. **Parse tool selection**: Extract `--tool` flag (default: gemini)
-2. **If `--enhance` flag present**: Execute `/enhance-prompt "[analysis-target]"` first
-3. Parse analysis target (original or enhanced)
-4. Detect target directory (from `--cd` or auto-infer)
-5. Build command for selected tool with code-analysis template
-6. Execute deep analysis (read-only, no code modification)
-7. Save to `.workflow/WFS-[id]/.chat/code-analysis-[timestamp].md`
-
-### Agent Mode (`--agent` flag)
-
-Delegate code analysis to `cli-execution-agent` for intelligent execution path tracing with automated context discovery.
-
-**Agent invocation**:
-```javascript
-Task(
-  subagent_type="cli-execution-agent",
-  description="Analyze code execution paths with automated context discovery",
-  prompt=`
-    Task: ${analysis_target}
-    Mode: code-analysis (execution tracing)
-    Tool Preference: ${tool_flag || 'auto-select'}
-    ${cd_flag ? `Directory Scope: ${cd_path}` : ''}
-    Template: code-analysis
-
-    Agent will autonomously:
-    - Discover execution paths and call flows
-    - Build analysis prompt with code-analysis template
-    - Execute deep tracing analysis
-    - Generate call diagrams and save log
-  `
-)
-```
-
-The agent handles all phases internally.
-
-## Core Rules
-
-1. **Analysis Only**: This command analyzes code and provides insights - it does NOT modify code
-2. **Tool Selection**: Use `--tool` value or default to gemini
-3. **Enhance First (if flagged)**: Execute `/enhance-prompt` before analysis
-4. **Directory Context**: Use `cd` when `--cd` provided or auto-detected
-5. **Template Required**: Always use code-analysis template
-6. **Session Output**: Save analysis results to session chat
-
-## Analysis Capabilities (via Template)
-
-- **Systematic Code Analysis**: Break down complex code into manageable parts
-- **Execution Path Tracing**: Track variable states and call stacks
-- **Control & Data Flow**: Understand code logic and data transformations
-- **Call Flow Visualization**: Diagram function calling sequences
-- **Logical Reasoning**: Explain "why" behind code behavior
-- **Debugging Insights**: Identify potential bugs or inefficiencies
-
-## Command Template
-
-```bash
-cd [directory] && ~/.claude/scripts/gemini-wrapper --all-files -p "
-PURPOSE: [analysis goal]
-TASK: Systematic code analysis and execution path tracing
-MODE: analysis
-CONTEXT: @{CLAUDE.md,**/*CLAUDE.md} [entire codebase in directory]
-EXPECTED: Execution trace, call flow diagram, debugging insights
-RULES: $(cat ~/.claude/prompt-templates/code-analysis.md) | Focus on [aspect]
-"
-```
-
-## Examples
-
-**Basic Code Analysis (Standard Mode)**:
-```bash
-/cli:mode:code-analysis "trace authentication execution flow"
-# Executes: Gemini with code-analysis template
-# Returns: Execution trace, call diagram, debugging insights
-```
-
-**Intelligent Code Analysis (Agent Mode)**:
-```bash
-/cli:mode:code-analysis --agent "trace JWT token validation from request to database"
-# Phase 1: Classifies as deep analysis, keywords ['jwt', 'token', 'validation', 'database']
-# Phase 2: MCP discovers request handler → middleware → service → repository chain
-# Phase 3: Builds analysis prompt with code-analysis template + complete call path
-# Phase 4: Executes Gemini with traced execution paths
-# Phase 5: Saves detailed analysis with call flow diagrams and variable states
-# Returns: Complete execution trace + call diagram + data flow analysis
-```
-
-**Standard Template Example**:
-```bash
-cd . && ~/.claude/scripts/gemini-wrapper --all-files -p "
-PURPOSE: Trace authentication execution flow
-TASK: Analyze complete auth flow from request to response
-MODE: analysis
-CONTEXT: @{CLAUDE.md,**/*CLAUDE.md}
-EXPECTED: Step-by-step execution trace with call diagram, variable states
-RULES: $(cat ~/.claude/prompt-templates/code-analysis.md) | Focus on control flow
-"
-```
-
-**Directory-Specific Analysis**:
-```bash
-cd src/auth && ~/.claude/scripts/gemini-wrapper --all-files -p "
-PURPOSE: Understand JWT token validation logic
-TASK: Trace JWT validation from middleware to service layer
-MODE: analysis
-CONTEXT: @{CLAUDE.md,**/*CLAUDE.md}
-EXPECTED: Validation flow diagram, token lifecycle analysis
-RULES: $(cat ~/.claude/prompt-templates/code-analysis.md) | Focus on security
-"
-```
-
-## Code Tracing Workflow
-
-```bash
-# 1. Find entry points and related files
-rg "function.*authenticate|class.*AuthService" --files-with-matches
-mcp__code-index__search_code_advanced(pattern="authenticate|login", file_pattern="*.ts")
-
-# 2. Build call graph understanding
-# entry → middleware → service → repository
-
-# 3. Execute deep analysis (analysis only, no code changes)
-/cli:mode:code-analysis --cd "src" "trace execution from entry point"
-```
-
-## Output Routing
-
-**Output Destination Logic**:
-- **Active session exists AND analysis is session-relevant**:
-  - Save to `.workflow/WFS-[id]/.chat/code-analysis-[timestamp].md`
-- **No active session OR standalone analysis**:
-  - Save to `.workflow/.scratchpad/code-analysis-[description]-[timestamp].md`
-
-**Examples**:
-- During active session `WFS-auth-refactor`, analyzing auth flow → `.chat/code-analysis-20250105-143022.md`
-- No session, tracing request lifecycle → `.scratchpad/code-analysis-request-flow-20250105-143045.md`
-
-## Notes
-
-- Command templates and file patterns: see intelligent-tools-strategy.md (loaded in memory)
-- Scratchpad directory details: see workflow-architecture.md
-- Template path: `~/.claude/prompt-templates/code-analysis.md`
-- Always uses `--all-files` for comprehensive code context

.claude/commands/cli/mode/plan.md

@@ -1,168 +0,0 @@
----
-name: plan
-description: Project planning and architecture analysis using CLI tools
-argument-hint: "[--agent] [--tool codex|gemini|qwen] [--enhance] [--cd path] topic"
-allowed-tools: SlashCommand(*), Bash(*), Task(*)
----
-
-# CLI Mode: Plan (/cli:mode:plan)
-
-## Purpose
-
-Comprehensive planning and architecture analysis with strategic planning template (`~/.claude/prompt-templates/plan.md`).
-
-**Supported Tools**: codex, gemini (default), qwen
-**Key Feature**: `--cd` flag for directory-scoped planning
-
-## Parameters
-
-- `--agent` - Use cli-execution-agent for automated context discovery (5-phase intelligent mode)
-- `--tool <codex|gemini|qwen>` - Tool selection (default: gemini, ignored in agent mode)
-- `--enhance` - Enhance topic with `/enhance-prompt` first
-- `--cd "path"` - Target directory for focused planning
-- `<topic>` (Required) - Planning topic or architectural question
-
-## Execution Flow
-
-### Standard Mode (Default)
-
-1. **Parse tool selection**: Extract `--tool` flag (default: gemini)
-2. **If `--enhance` flag present**: Execute `/enhance-prompt "[topic]"` first
-3. Parse topic (original or enhanced)
-4. Detect target directory (from `--cd` or auto-infer)
-5. Build command for selected tool with planning template
-6. Execute analysis (read-only, no code modification)
-7. Save to `.workflow/WFS-[id]/.chat/plan-[timestamp].md`
-
-### Agent Mode (`--agent` flag)
-
-Delegate planning to `cli-execution-agent` for intelligent strategic planning with automated architecture discovery.
-
-**Agent invocation**:
-```javascript
-Task(
-  subagent_type="cli-execution-agent",
-  description="Create strategic plan with automated architecture discovery",
-  prompt=`
-    Task: ${planning_topic}
-    Mode: plan (strategic planning)
-    Tool Preference: ${tool_flag || 'auto-select'}
-    ${cd_flag ? `Directory Scope: ${cd_path}` : ''}
-    Template: plan
-
-    Agent will autonomously:
-    - Discover project structure and existing architecture
-    - Build planning prompt with plan template
-    - Execute strategic planning analysis
-    - Generate implementation roadmap and save
-  `
-)
-```
-
-The agent handles all phases internally.
-
-## Core Rules
-
-1. **Analysis Only**: This command provides planning recommendations and insights - it does NOT modify code
-2. **Enhance First (if flagged)**: Execute `/enhance-prompt` before planning
-3. **Directory Context**: Use `cd` when `--cd` provided or auto-detected
-4. **Template Required**: Always use planning template
-5. **Session Output**: Save analysis results to session chat
-
-## Planning Capabilities (via Template)
-
-- Strategic architecture insights and recommendations
-- Implementation roadmaps and suggestions
-- Key technical decisions analysis
-- Risk assessment
-- Resource planning
-
-## Command Template
-
-```bash
-cd [directory] && ~/.claude/scripts/gemini-wrapper --all-files -p "
-PURPOSE: [planning goal from topic]
-TASK: Comprehensive planning and architecture analysis
-MODE: analysis
-CONTEXT: @{CLAUDE.md,**/*CLAUDE.md} [entire codebase in directory]
-EXPECTED: Strategic insights, implementation recommendations, key decisions
-RULES: $(cat ~/.claude/prompt-templates/plan.md) | Focus on [topic area]
-"
-```
-
-## Examples
-
-**Basic Planning Analysis (Standard Mode)**:
-```bash
-/cli:mode:plan "design user dashboard architecture"
-# Executes: Gemini with planning template
-# Returns: Architecture recommendations, component design, roadmap
-```
-
-**Intelligent Planning (Agent Mode)**:
-```bash
-/cli:mode:plan --agent "design microservices architecture for payment system"
-# Phase 1: Classifies as architectural planning, keywords ['microservices', 'payment', 'architecture']
-# Phase 2: MCP discovers existing services, payment flows, integration patterns
-# Phase 3: Builds planning prompt with plan template + current architecture context
-# Phase 4: Executes Gemini with comprehensive project understanding
-# Phase 5: Saves planning document with implementation roadmap and migration strategy
-# Returns: Strategic architecture plan + implementation roadmap + risk assessment
-```
-
-**Standard Template Example**:
-```bash
-cd . && ~/.claude/scripts/gemini-wrapper --all-files -p "
-PURPOSE: Design user dashboard architecture
-TASK: Plan dashboard component structure and data flow
-MODE: analysis
-CONTEXT: @{CLAUDE.md,**/*CLAUDE.md}
-EXPECTED: Architecture recommendations, component design, data flow diagram
-RULES: $(cat ~/.claude/prompt-templates/plan.md) | Focus on scalability
-"
-```
-
-**Directory-Specific Planning**:
-```bash
-cd src/api && ~/.claude/scripts/gemini-wrapper --all-files -p "
-PURPOSE: Plan API refactoring strategy
-TASK: Analyze current API structure and recommend improvements
-MODE: analysis
-CONTEXT: @{CLAUDE.md,**/*CLAUDE.md}
-EXPECTED: Refactoring roadmap, breaking change analysis, migration plan
-RULES: $(cat ~/.claude/prompt-templates/plan.md) | Maintain backward compatibility
-"
-```
-
-## Planning Workflow
-
-```bash
-# 1. Discover project structure
-~/.claude/scripts/get_modules_by_depth.sh
-mcp__code-index__find_files(pattern="*.ts")
-
-# 2. Gather existing architecture info
-rg "architecture|design" --files-with-matches
-
-# 3. Execute planning analysis (analysis only, no code changes)
-/cli:mode:plan "topic for strategic planning"
-```
-
-## Output Routing
-
-**Output Destination Logic**:
-- **Active session exists AND planning is session-relevant**:
-  - Save to `.workflow/WFS-[id]/.chat/plan-[timestamp].md`
-- **No active session OR exploratory planning**:
-  - Save to `.workflow/.scratchpad/plan-[description]-[timestamp].md`
-
-**Examples**:
-- During active session `WFS-dashboard`, planning dashboard architecture → `.chat/plan-20250105-143022.md`
-- No session, exploring new feature idea → `.scratchpad/plan-feature-idea-20250105-143045.md`
-
-## Notes
-
-- Command templates and file patterns: see intelligent-tools-strategy.md (loaded in memory)
-- Scratchpad directory details: see workflow-architecture.md
-- Template path: `~/.claude/prompt-templates/plan.md`
-- Always uses `--all-files` for comprehensive project context

.claude/commands/enhance-prompt.md

@@ -1,37 +1,22 @@
 ---
 name: enhance-prompt
-description: Context-aware prompt enhancement using session memory and codebase analysis
+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 combining session memory context with codebase patterns, translating ambiguous requests into actionable specifications.
+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` → `Gemini Analysis (if needed)` → `Structured Output`
+`Intent Translation` → `Context Integration` → `Structured Output`
 
 **Context Sources:**
 - Session memory (conversation history, previous analysis)
-- Codebase patterns (via Gemini when triggered)
 - Implicit technical requirements
-
-## Gemini Trigger Logic
-
-```pseudo
-FUNCTION should_use_gemini(user_prompt):
-  critical_keywords = ["refactor", "migrate", "redesign", "auth", "payment", "security"]
-
-  RETURN (
-    prompt_affects_multiple_modules(user_prompt, threshold=3) OR
-    any_keyword_in_prompt(critical_keywords, user_prompt)
-  )
-END
-```
-
-**Gemini Integration:** ~/.claude/workflows/intelligent-tools-strategy.md
+- User intent patterns
 
 ## Enhancement Rules
 
@@ -47,22 +32,18 @@ END
 
 ### Context Integration Strategy
 
-**Session Memory First:**
+**Session Memory:**
 - Reference recent conversation context
 - Reuse previously identified patterns
 - Build on established understanding
-
-**Codebase Analysis (via Gemini):**
-- Only when complexity requires it
-- Focus on integration points
-- Identify existing patterns
+- 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
-# Gemini (if multi-module): Analyze AuthService patterns, middleware structure
+# Action: Implement JWT authentication with session persistence
 ```
 
 ## Output Structure
@@ -76,7 +57,7 @@ ATTENTION: [Critical constraints]
 
 ### Output Examples
 
-**Simple (no Gemini):**
+**Example 1:**
 ```bash
 # Input: "fix login button"
 INTENT: Debug non-functional login button
@@ -85,28 +66,28 @@ ACTION: Check event binding → verify state updates → test auth flow
 ATTENTION: Preserve existing OAuth integration
 ```
 
-**Complex (with Gemini):**
+**Example 2:**
 ```bash
 # Input: "refactor payment code"
 INTENT: Restructure payment module for maintainability
-CONTEXT: Session memory - PCI compliance requirements
-         Gemini - PaymentService → StripeAdapter pattern identified
-ACTION: Extract reusable validators → isolate payment gateway logic
+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
 ```
 
-## Automatic Triggers
+## Enhancement Triggers
 
 - Ambiguous language: "fix", "improve", "clean up"
-- Multi-module impact (>3 modules)
+- Vague requests requiring clarification
+- Complex technical requirements
 - Architecture changes
 - Critical systems: auth, payment, security
-- Complex refactoring
+- Multi-step refactoring
 
 ## Key Principles
 
-1. **Memory First**: Leverage session context before analysis
-2. **Minimal Gemini**: Only when complexity demands it
-3. **Context Reuse**: Build on previous understanding
-4. **Clear Output**: Structured, actionable specifications
+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/discover-by-prompt.md

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

.claude/commands/issue/discover.md

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

.claude/commands/issue/execute.md

@@ -0,0 +1,488 @@
+---
+name: execute
+description: Execute queue with DAG-based parallel orchestration (one commit per solution)
+argument-hint: "[--worktree [<existing-path>]] [--queue <queue-id>]"
+allowed-tools: TodoWrite(*), Bash(*), Read(*), AskUserQuestion(*)
+---
+
+# Issue Execute Command (/issue:execute)
+
+## Overview
+
+Minimal orchestrator that dispatches **solution IDs** to executors. Each executor receives a complete solution with all its tasks.
+
+**Design Principles:**
+- `queue dag` → returns parallel batches with solution IDs (S-1, S-2, ...)
+- `detail <id>` → READ-ONLY solution fetch (returns full solution with all tasks)
+- `done <id>` → update solution completion status
+- No race conditions: status changes only via `done`
+- **Executor handles all tasks within a solution sequentially**
+- **Worktree isolation**: Each executor can work in its own git worktree
+
+## Usage
+
+```bash
+/issue:execute                           # Execute active queue(s)
+/issue:execute --queue QUE-xxx           # Execute specific queue
+/issue:execute --worktree                # Use git worktrees for parallel isolation
+/issue:execute --worktree --queue QUE-xxx
+/issue:execute --worktree /path/to/existing/worktree  # Resume in existing worktree
+```
+
+**Parallelism**: Determined automatically by task dependency DAG (no manual control)
+**Executor & Dry-run**: Selected via interactive prompt (AskUserQuestion)
+**Worktree**: Creates isolated git worktrees for each parallel executor
+
+**⭐ 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 (if --worktree): Setup Worktree Base
+   └─ Ensure .worktrees directory exists
+
+Phase 1: Get DAG & User Selection
+   ├─ ccw issue queue dag [--queue QUE-xxx] → { 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)
+   ├─ For each solution ID in batch (parallel - all at once):
+   │   ├─ (if worktree) Create isolated worktree: git worktree add
+   │   ├─ 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>
+   │   └─ (if worktree) Cleanup: merge branch, remove worktree
+   └─ Wait for batch completion
+
+Phase 3: Next Batch
+   └─ ccw issue queue dag → check for newly-ready solutions
+```
+
+## Implementation
+
+### Phase 1: Get DAG & User Selection
+
+```javascript
+// Get dependency graph and parallel batches
+const dagJson = Bash(`ccw issue queue dag`).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 worktrees for parallel isolation?',
+      header: 'Worktree',
+      multiSelect: false,
+      options: [
+        { label: 'Yes (Recommended for parallel)', description: 'Each executor works in isolated worktree branch' },
+        { label: 'No', description: 'Work directly in current directory (serial only)' }
+      ]
+    }
+  ]
+});
+
+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 2: Dispatch Parallel Batch (DAG-driven)
+
+```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(', ')}`);
+
+// Setup worktree base directory if needed (using absolute paths)
+if (useWorktree) {
+  // Use absolute paths to avoid issues when running from subdirectories
+  const repoRoot = Bash('git rev-parse --show-toplevel').trim();
+  const worktreeBase = `${repoRoot}/.ccw/worktrees`;
+  Bash(`mkdir -p "${worktreeBase}"`);
+  // Prune stale worktrees from previous interrupted executions
+  Bash('git worktree prune');
+}
+
+// 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;
+
+// Launch ALL solutions in batch in parallel (DAG guarantees no conflicts)
+const executions = batch.map(solutionId => {
+  updateTodo(solutionId, 'in_progress');
+  return dispatchExecutor(solutionId, executor, useWorktree, existingWorktree);
+});
+
+await Promise.all(executions);
+batch.forEach(id => updateTodo(id, 'completed'));
+```
+
+### Executor Dispatch
+
+```javascript
+function dispatchExecutor(solutionId, executorType, useWorktree = false, existingWorktree = null) {
+  // Worktree setup commands (if enabled) - using absolute paths
+  // Supports both creating new worktrees and resuming in existing ones
+  const worktreeSetup = useWorktree ? `
+### Step 0: Setup Isolated Worktree
+\`\`\`bash
+# Use absolute paths to avoid issues when running from subdirectories
+REPO_ROOT=$(git rev-parse --show-toplevel)
+WORKTREE_BASE="\${REPO_ROOT}/.ccw/worktrees"
+
+# Check if existing worktree path was provided
+EXISTING_WORKTREE="${existingWorktree || ''}"
+
+if [[ -n "\${EXISTING_WORKTREE}" && -d "\${EXISTING_WORKTREE}" ]]; then
+  # Resume mode: Use existing worktree
+  WORKTREE_PATH="\${EXISTING_WORKTREE}"
+  WORKTREE_NAME=$(basename "\${WORKTREE_PATH}")
+
+  # Verify it's a valid git worktree
+  if ! git -C "\${WORKTREE_PATH}" rev-parse --is-inside-work-tree &>/dev/null; then
+    echo "Error: \${EXISTING_WORKTREE} is not a valid git worktree"
+    exit 1
+  fi
+
+  echo "Resuming in existing worktree: \${WORKTREE_PATH}"
+else
+  # Create mode: New worktree with timestamp
+  WORKTREE_NAME="exec-${solutionId}-$(date +%H%M%S)"
+  WORKTREE_PATH="\${WORKTREE_BASE}/\${WORKTREE_NAME}"
+
+  # Ensure worktree base exists
+  mkdir -p "\${WORKTREE_BASE}"
+
+  # Prune stale worktrees
+  git worktree prune
+
+  # Create worktree
+  git worktree add "\${WORKTREE_PATH}" -b "\${WORKTREE_NAME}"
+
+  echo "Created new worktree: \${WORKTREE_PATH}"
+fi
+
+# Setup cleanup trap for graceful failure handling
+cleanup_worktree() {
+  echo "Cleaning up worktree due to interruption..."
+  cd "\${REPO_ROOT}" 2>/dev/null || true
+  git worktree remove "\${WORKTREE_PATH}" --force 2>/dev/null || true
+  echo "Worktree removed. Branch '\${WORKTREE_NAME}' kept for inspection."
+}
+trap cleanup_worktree EXIT INT TERM
+
+cd "\${WORKTREE_PATH}"
+\`\`\`
+` : '';
+
+  const worktreeCleanup = useWorktree ? `
+### Step 5: Worktree Completion (User Choice)
+
+After all tasks complete, prompt for merge strategy:
+
+\`\`\`javascript
+AskUserQuestion({
+  questions: [{
+    question: "Solution ${solutionId} completed. What to do with worktree branch?",
+    header: "Merge",
+    multiSelect: false,
+    options: [
+      { label: "Create PR (Recommended)", description: "Push branch and create pull request - safest for parallel execution" },
+      { label: "Merge to main", description: "Merge branch and cleanup worktree (requires clean main)" },
+      { label: "Keep branch", description: "Cleanup worktree, keep branch for manual handling" }
+    ]
+  }]
+})
+\`\`\`
+
+**Based on selection:**
+\`\`\`bash
+# Disable cleanup trap before intentional cleanup
+trap - EXIT INT TERM
+
+# Return to repo root (use REPO_ROOT from setup)
+cd "\${REPO_ROOT}"
+
+# Validate main repo state before merge
+validate_main_clean() {
+  if [[ -n \$(git status --porcelain) ]]; then
+    echo "⚠️ Warning: Main repo has uncommitted changes."
+    echo "Cannot auto-merge. Falling back to 'Create PR' option."
+    return 1
+  fi
+  return 0
+}
+
+# Create PR (Recommended for parallel execution):
+git push -u origin "\${WORKTREE_NAME}"
+gh pr create --title "Solution ${solutionId}" --body "Issue queue execution"
+git worktree remove "\${WORKTREE_PATH}"
+
+# Merge to main (only if main is clean):
+if validate_main_clean; then
+  git merge --no-ff "\${WORKTREE_NAME}" -m "Merge solution ${solutionId}"
+  git worktree remove "\${WORKTREE_PATH}" && git branch -d "\${WORKTREE_NAME}"
+else
+  # Fallback to PR if main is dirty
+  git push -u origin "\${WORKTREE_NAME}"
+  gh pr create --title "Solution ${solutionId}" --body "Issue queue execution (main had uncommitted changes)"
+  git worktree remove "\${WORKTREE_PATH}"
+fi
+
+# Keep branch:
+git worktree remove "\${WORKTREE_PATH}"
+echo "Branch \${WORKTREE_NAME} kept for manual handling"
+\`\`\`
+
+**Parallel Execution Safety**: "Create PR" is the default and safest option for parallel executors, avoiding merge race conditions.
+` : '';
+
+  const prompt = `
+## Execute Solution ${solutionId}
+${worktreeSetup}
+### Step 1: Get Solution (read-only)
+\`\`\`bash
+ccw issue detail ${solutionId}
+\`\`\`
+
+### Step 2: Execute All Tasks Sequentially
+The detail command returns a FULL SOLUTION with all tasks.
+Execute each task in order (T1 → T2 → T3 → ...):
+
+For each task:
+1. Follow task.implementation steps
+2. Run task.test commands
+3. Verify task.acceptance criteria
+(Do NOT commit after each task)
+
+### Step 3: Commit Solution (Once)
+After ALL tasks pass, commit once with formatted summary:
+\`\`\`bash
+git add <all-modified-files>
+git commit -m "[type](scope): [solution.description]
+
+## Solution Summary
+- Solution-ID: ${solutionId}
+- Tasks: T1, T2, ...
+
+## Tasks Completed
+- [T1] task1.title: action
+- [T2] task2.title: action
+
+## Files Modified
+- file1.ts
+- file2.ts
+
+## Verification
+- All tests passed
+- All acceptance criteria verified"
+\`\`\`
+
+### Step 4: Report Completion
+\`\`\`bash
+ccw issue done ${solutionId} --result '{"summary": "...", "files_modified": [...], "commit": {"hash": "...", "type": "feat"}, "tasks_completed": N}'
+\`\`\`
+
+If any task failed:
+\`\`\`bash
+ccw issue done ${solutionId} --fail --reason '{"task_id": "TX", "error_type": "test_failure", "message": "..."}'
+\`\`\`
+${worktreeCleanup}`;
+
+  if (executorType === 'codex') {
+    return Bash(
+      `ccw cli -p "${escapePrompt(prompt)}" --tool codex --mode write --id exec-${solutionId}`,
+      { 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}`,
+      { timeout: 3600000, run_in_background: true }
+    );
+  } else {
+    return Task({
+      subagent_type: 'code-developer',
+      run_in_background: false,
+      description: `Execute solution ${solutionId}`,
+      prompt: prompt
+    });
+  }
+}
+```
+
+### Phase 3: Check Next Batch
+
+```javascript
+// Refresh DAG after batch completes
+const refreshedDag = JSON.parse(Bash(`ccw issue queue dag`).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` again for next batch.');
+}
+```
+
+## Parallel Execution Model
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│ Orchestrator                                                │
+├─────────────────────────────────────────────────────────────┤
+│ 1. ccw issue queue dag                                      │
+│    → { parallel_batches: [["S-1","S-2"], ["S-3"]] }        │
+│                                                             │
+│ 2. Dispatch batch 1 (parallel):                            │
+│    ┌──────────────────────┐ ┌──────────────────────┐       │
+│    │ Executor 1           │ │ Executor 2           │       │
+│    │ detail S-1           │ │ detail S-2           │       │
+│    │ → gets full solution │ │ → gets full solution │       │
+│    │ [T1→T2→T3 sequential]│ │ [T1→T2 sequential]   │       │
+│    │ commit (1x solution) │ │ commit (1x solution) │       │
+│    │ done S-1             │ │ done S-2             │       │
+│    └──────────────────────┘ └──────────────────────┘       │
+│                                                             │
+│ 3. ccw issue queue dag (refresh)                           │
+│    → S-3 now ready (S-1 completed, file conflict resolved) │
+└─────────────────────────────────────────────────────────────┘
+```
+
+**Why this works for parallel:**
+- `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
+
+## CLI Endpoint Contract
+
+### `ccw issue queue dag`
+Returns dependency graph with parallel batches (solution-level):
+```json
+{
+  "queue_id": "QUE-...",
+  "total": 3,
+  "ready_count": 2,
+  "completed_count": 0,
+  "nodes": [
+    { "id": "S-1", "issue_id": "ISS-xxx", "status": "pending", "ready": true, "task_count": 3 },
+    { "id": "S-2", "issue_id": "ISS-yyy", "status": "pending", "ready": true, "task_count": 2 },
+    { "id": "S-3", "issue_id": "ISS-zzz", "status": "pending", "ready": false, "depends_on": ["S-1"] }
+  ],
+  "parallel_batches": [["S-1", "S-2"], ["S-3"]]
+}
+```
+
+### `ccw issue detail <item_id>`
+Returns FULL SOLUTION with all tasks (READ-ONLY):
+```json
+{
+  "item_id": "S-1",
+  "issue_id": "ISS-xxx",
+  "solution_id": "SOL-xxx",
+  "status": "pending",
+  "solution": {
+    "id": "SOL-xxx",
+    "approach": "...",
+    "tasks": [
+      { "id": "T1", "title": "...", "implementation": [...], "test": {...} },
+      { "id": "T2", "title": "...", "implementation": [...], "test": {...} },
+      { "id": "T3", "title": "...", "implementation": [...], "test": {...} }
+    ],
+    "exploration_context": { "relevant_files": [...] }
+  },
+  "execution_hints": { "executor": "codex", "estimated_minutes": 180 }
+}
+```
+
+### `ccw issue done <item_id>`
+Marks solution completed/failed, updates queue state, checks for queue completion.
+
+## Error Handling
+
+| Error | Resolution |
+|-------|------------|
+| No queue | Run /issue:queue first |
+| No ready solutions | Dependencies blocked, check DAG |
+| Executor timeout | Solution not marked done, can retry |
+| Solution failure | Use `ccw issue retry` to reset |
+| Partial task failure | Executor reports which task failed via `done --fail` |
+
+## Related Commands
+
+- `/issue:plan` - Plan issues with solutions
+- `/issue:queue` - Form execution queue
+- `ccw issue queue dag` - View dependency graph
+- `ccw issue detail <id>` - View task details
+- `ccw issue retry` - Reset failed tasks

.claude/commands/issue/new.md

@@ -0,0 +1,413 @@
+---
+name: new
+description: Create structured issue from GitHub URL or text description
+argument-hint: "<github-url | text-description> [--priority 1-5]"
+allowed-tools: TodoWrite(*), Bash(*), Read(*), AskUserQuestion(*), mcp__ace-tool__search_context(*)
+---
+
+# Issue New Command (/issue:new)
+
+## Core Principle
+
+**Requirement Clarity Detection** → Ask only when needed
+
+```
+Clear Input (GitHub URL, structured text)  → Direct creation
+Unclear Input (vague description)          → Minimal clarifying questions
+```
+
+## Issue Structure 
+
+```typescript
+interface Issue {
+  id: string;                    // GH-123 or ISS-YYYYMMDD-HHMMSS
+  title: string;
+  status: 'registered' | 'planned' | 'queued' | 'in_progress' | 'completed' | 'failed';
+  priority: number;              // 1 (critical) to 5 (low)
+  context: string;               // Problem description (single source of truth)
+  source: 'github' | 'text' | 'discovery';
+  source_url?: string;
+  labels?: string[];
+
+  // GitHub binding (for non-GitHub sources that publish to GitHub)
+  github_url?: string;           // https://github.com/owner/repo/issues/123
+  github_number?: number;        // 123
+
+  // Optional structured fields
+  expected_behavior?: string;
+  actual_behavior?: string;
+  affected_components?: string[];
+
+  // Feedback history (failures + human clarifications)
+  feedback?: {
+    type: 'failure' | 'clarification' | 'rejection';
+    stage: string;               // new/plan/execute
+    content: string;
+    created_at: string;
+  }[];
+
+  // Solution binding
+  bound_solution_id: string | null;
+
+  // Timestamps
+  created_at: string;
+  updated_at: string;
+}
+```
+
+## Quick Reference
+
+```bash
+# Clear inputs - direct creation
+/issue:new https://github.com/owner/repo/issues/123
+/issue:new "Login fails with special chars. Expected: success. Actual: 500 error"
+
+# Vague input - will ask clarifying questions
+/issue:new "something wrong with auth"
+```
+
+## Implementation
+
+### Phase 1: Input Analysis & Clarity Detection
+
+```javascript
+const input = userInput.trim();
+const flags = parseFlags(userInput);  // --priority
+
+// Detect input type and clarity
+const isGitHubUrl = input.match(/github\.com\/[\w-]+\/[\w-]+\/issues\/\d+/);
+const isGitHubShort = input.match(/^#(\d+)$/);
+const hasStructure = input.match(/(expected|actual|affects|steps):/i);
+
+// Clarity score: 0-3
+let clarityScore = 0;
+if (isGitHubUrl || isGitHubShort) clarityScore = 3;  // GitHub = fully clear
+else if (hasStructure) clarityScore = 2;             // Structured text = clear
+else if (input.length > 50) clarityScore = 1;        // Long text = somewhat clear
+else clarityScore = 0;                               // Vague
+
+let issueData = {};
+```
+
+### Phase 2: Data Extraction (GitHub or Text)
+
+```javascript
+if (isGitHubUrl || isGitHubShort) {
+  // GitHub - fetch via gh CLI
+  const result = Bash(`gh issue view ${extractIssueRef(input)} --json number,title,body,labels,url`);
+  const gh = JSON.parse(result);
+  issueData = {
+    id: `GH-${gh.number}`,
+    title: gh.title,
+    source: 'github',
+    source_url: gh.url,
+    labels: gh.labels.map(l => l.name),
+    context: gh.body?.substring(0, 500) || gh.title,
+    ...parseMarkdownBody(gh.body)
+  };
+} else {
+  // Text description
+  issueData = {
+    id: `ISS-${new Date().toISOString().replace(/[-:T]/g, '').slice(0, 14)}`,
+    source: 'text',
+    ...parseTextDescription(input)
+  };
+}
+```
+
+### Phase 3: Lightweight Context Hint (Conditional)
+
+```javascript
+// ACE search ONLY for medium clarity (1-2) AND missing components
+// Skip for: GitHub (has context), vague (needs clarification first)
+// Note: Deep exploration happens in /issue:plan, this is just a quick hint
+
+if (clarityScore >= 1 && clarityScore <= 2 && !issueData.affected_components?.length) {
+  const keywords = extractKeywords(issueData.context);
+
+  if (keywords.length >= 2) {
+    try {
+      const aceResult = mcp__ace-tool__search_context({
+        project_root_path: process.cwd(),
+        query: keywords.slice(0, 3).join(' ')
+      });
+      issueData.affected_components = aceResult.files?.slice(0, 3) || [];
+    } catch {
+      // ACE failure is non-blocking
+    }
+  }
+}
+```
+
+### Phase 4: Conditional Clarification (Only if Unclear)
+
+```javascript
+// ONLY ask questions if clarity is low - simple open-ended prompt
+if (clarityScore < 2 && (!issueData.context || issueData.context.length < 20)) {
+  const answer = AskUserQuestion({
+    questions: [{
+      question: 'Please describe the issue in more detail:',
+      header: 'Clarify',
+      multiSelect: false,
+      options: [
+        { label: 'Provide details', description: 'Describe what, where, and expected behavior' }
+      ]
+    }]
+  });
+
+  // Use custom text input (via "Other")
+  if (answer.customText) {
+    issueData.context = answer.customText;
+    issueData.title = answer.customText.split(/[.\n]/)[0].substring(0, 60);
+    issueData.feedback = [{
+      type: 'clarification',
+      stage: 'new',
+      content: answer.customText,
+      created_at: new Date().toISOString()
+    }];
+  }
+}
+```
+
+### Phase 5: GitHub Publishing Decision (Non-GitHub Sources)
+
+```javascript
+// For non-GitHub sources, ask if user wants to publish to GitHub
+let publishToGitHub = false;
+
+if (issueData.source !== 'github') {
+  const publishAnswer = AskUserQuestion({
+    questions: [{
+      question: 'Would you like to publish this issue to GitHub?',
+      header: 'Publish',
+      multiSelect: false,
+      options: [
+        { label: 'Yes, publish to GitHub', description: 'Create issue on GitHub and link it' },
+        { label: 'No, keep local only', description: 'Store as local issue without GitHub sync' }
+      ]
+    }]
+  });
+
+  publishToGitHub = publishAnswer.answers?.['Publish']?.includes('Yes');
+}
+```
+
+### Phase 6: Create Issue
+
+**Summary Display:**
+- Show ID, title, source, affected files (if any)
+
+**Confirmation** (only for vague inputs, clarityScore < 2):
+- Use `AskUserQuestion` to confirm before creation
+
+**Issue Creation** (via CLI endpoint):
+```bash
+# Option 1: Pipe input (recommended for complex JSON - avoids shell escaping)
+echo '{"title":"...", "context":"...", "priority":3}' | ccw issue create
+
+# Option 2: Heredoc (for multi-line JSON)
+ccw issue create << 'EOF'
+{"title":"...", "context":"含\"引号\"的内容", "priority":3}
+EOF
+
+# Option 3: --data parameter (simple cases only)
+ccw issue create --data '{"title":"...", "priority":3}'
+```
+
+**CLI Endpoint Features:**
+| Feature | Description |
+|---------|-------------|
+| Auto-increment ID | `ISS-YYYYMMDD-NNN` (e.g., `ISS-20251229-001`) |
+| Trailing newline | Proper JSONL format, no corruption |
+| JSON output | Returns created issue with all fields |
+
+**Example:**
+```bash
+# Create issue via pipe (recommended)
+echo '{"title": "Login fails with special chars", "context": "500 error when password contains quotes", "priority": 2}' | ccw issue create
+
+# Or with heredoc for complex JSON
+ccw issue create << 'EOF'
+{
+  "title": "Login fails with special chars",
+  "context": "500 error when password contains \"quotes\"",
+  "priority": 2,
+  "source": "text",
+  "expected_behavior": "Login succeeds",
+  "actual_behavior": "500 Internal Server Error"
+}
+EOF
+
+# Output (JSON)
+{
+  "id": "ISS-20251229-001",
+  "title": "Login fails with special chars",
+  "status": "registered",
+  ...
+}
+```
+
+**GitHub Publishing** (if user opted in):
+```javascript
+// Step 1: Create local issue FIRST
+const localIssue = createLocalIssue(issueData);  // ccw issue create
+
+// Step 2: Publish to GitHub if requested
+if (publishToGitHub) {
+  const ghResult = Bash(`gh issue create --title "${issueData.title}" --body "${issueData.context}"`);
+  // Parse GitHub URL from output
+  const ghUrl = ghResult.match(/https:\/\/github\.com\/[\w-]+\/[\w-]+\/issues\/\d+/)?.[0];
+  const ghNumber = parseInt(ghUrl?.match(/\/issues\/(\d+)/)?.[1]);
+
+  if (ghNumber) {
+    // Step 3: Update local issue with GitHub binding
+    Bash(`ccw issue update ${localIssue.id} --github-url "${ghUrl}" --github-number ${ghNumber}`);
+    // Or via pipe:
+    // echo '{"github_url":"${ghUrl}","github_number":${ghNumber}}' | ccw issue update ${localIssue.id}
+  }
+}
+```
+
+**Workflow:**
+```
+1. Create local issue (ISS-YYYYMMDD-NNN) → stored in .workflow/issues.jsonl
+2. If publishToGitHub:
+   a. gh issue create → returns GitHub URL
+   b. Update local issue with github_url + github_number binding
+3. Both local and GitHub issues exist, linked together
+```
+
+**Example with GitHub Publishing:**
+```bash
+# User creates text issue
+/issue:new "Login fails with special chars. Expected: success. Actual: 500"
+
+# System asks: "Would you like to publish this issue to GitHub?"
+# User selects: "Yes, publish to GitHub"
+
+# Output:
+# ✓ Local issue created: ISS-20251229-001
+# ✓ Published to GitHub: https://github.com/org/repo/issues/123
+# ✓ GitHub binding saved to local issue
+# → Next step: /issue:plan ISS-20251229-001
+
+# Resulting issue JSON:
+{
+  "id": "ISS-20251229-001",
+  "title": "Login fails with special chars",
+  "source": "text",
+  "github_url": "https://github.com/org/repo/issues/123",
+  "github_number": 123,
+  ...
+}
+```
+
+**Completion:**
+- Display created issue ID
+- Show GitHub URL (if published)
+- Show next step: `/issue:plan <id>`
+
+## Execution Flow
+
+```
+Phase 1: Input Analysis
+   └─ Detect clarity score (GitHub URL? Structured text? Keywords?)
+
+Phase 2: Data Extraction (branched by clarity)
+   ┌────────────┬─────────────────┬──────────────┐
+   │  Score 3   │   Score 1-2     │   Score 0    │
+   │  GitHub    │   Text + ACE    │   Vague      │
+   ├────────────┼─────────────────┼──────────────┤
+   │  gh CLI    │  Parse struct   │ AskQuestion  │
+   │  → parse   │  + quick hint   │ (1 question) │
+   │            │  (3 files max)  │  → feedback  │
+   └────────────┴─────────────────┴──────────────┘
+
+Phase 3: GitHub Publishing Decision (non-GitHub only)
+   ├─ Source = github: Skip (already from GitHub)
+   └─ Source ≠ github: AskUserQuestion
+      ├─ Yes → publishToGitHub = true
+      └─ No  → publishToGitHub = false
+
+Phase 4: Create Issue
+   ├─ Score ≥ 2: Direct creation
+   └─ Score < 2: Confirm first → Create
+   └─ If publishToGitHub: gh issue create → link URL
+
+Note: Deep exploration & lifecycle deferred to /issue:plan
+```
+
+## Helper Functions
+
+```javascript
+function extractKeywords(text) {
+  const stopWords = new Set(['the', 'a', 'an', 'is', 'are', 'was', 'were', 'not', 'with']);
+  return text
+    .toLowerCase()
+    .split(/\W+/)
+    .filter(w => w.length > 3 && !stopWords.has(w))
+    .slice(0, 5);
+}
+
+function parseTextDescription(text) {
+  const result = { title: '', context: '' };
+  const sentences = text.split(/\.(?=\s|$)/);
+
+  result.title = sentences[0]?.trim().substring(0, 60) || 'Untitled';
+  result.context = text.substring(0, 500);
+
+  // Extract structured fields if present
+  const expected = text.match(/expected:?\s*([^.]+)/i);
+  const actual = text.match(/actual:?\s*([^.]+)/i);
+  const affects = text.match(/affects?:?\s*([^.]+)/i);
+
+  if (expected) result.expected_behavior = expected[1].trim();
+  if (actual) result.actual_behavior = actual[1].trim();
+  if (affects) {
+    result.affected_components = affects[1].split(/[,\s]+/).filter(c => c.includes('/') || c.includes('.'));
+  }
+
+  return result;
+}
+
+function parseMarkdownBody(body) {
+  if (!body) return {};
+  const result = {};
+
+  const problem = body.match(/##?\s*(problem|description)[:\s]*([\s\S]*?)(?=##|$)/i);
+  const expected = body.match(/##?\s*expected[:\s]*([\s\S]*?)(?=##|$)/i);
+  const actual = body.match(/##?\s*actual[:\s]*([\s\S]*?)(?=##|$)/i);
+
+  if (problem) result.context = problem[2].trim().substring(0, 500);
+  if (expected) result.expected_behavior = expected[2].trim();
+  if (actual) result.actual_behavior = actual[2].trim();
+
+  return result;
+}
+```
+
+## Examples
+
+### Clear Input (No Questions)
+
+```bash
+/issue:new https://github.com/org/repo/issues/42
+# → Fetches, parses, creates immediately
+
+/issue:new "Login fails with special chars. Expected: success. Actual: 500"
+# → Parses structure, creates immediately
+```
+
+### Vague Input (1 Question)
+
+```bash
+/issue:new "auth broken"
+# → Asks: "Input unclear. What is the issue about?"
+# → User provides details → saved to feedback[]
+# → Creates issue
+```
+
+## Related Commands
+
+- `/issue:plan` - Plan solution for issue
+

.claude/commands/issue/plan.md

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

.claude/commands/issue/queue.md

@@ -0,0 +1,382 @@
+---
+name: queue
+description: Form execution queue from bound solutions using issue-queue-agent (solution-level)
+argument-hint: "[--queues <n>] [--issue <id>]"
+allowed-tools: TodoWrite(*), Task(*), Bash(*), Read(*), Write(*)
+---
+
+# Issue Queue Command (/issue:queue)
+
+## Overview
+
+Queue formation command using **issue-queue-agent** that analyzes all bound solutions, resolves **inter-solution** conflicts, and creates an ordered execution queue at **solution level**.
+
+**Design Principle**: Queue items are **solutions**, not individual tasks. Each executor receives a complete solution with all its tasks.
+
+## Core Capabilities
+
+- **Agent-driven**: issue-queue-agent handles all ordering logic
+- **Solution-level granularity**: Queue items are solutions, not tasks
+- **Conflict clarification**: High-severity conflicts prompt user decision
+- Semantic priority calculation per solution (0.0-1.0)
+- Parallel/Sequential group assignment for solutions
+
+## Core Guidelines
+
+**⚠️ Data Access Principle**: Issues and queue files can grow very large. To avoid context overflow:
+
+| Operation | Correct | Incorrect |
+|-----------|---------|-----------|
+| List issues (brief) | `ccw issue list --status planned --brief` | `Read('issues.jsonl')` |
+| List queue (brief) | `ccw issue queue --brief` | `Read('queues/*.json')` |
+| Read issue details | `ccw issue status <id> --json` | `Read('issues.jsonl')` |
+| Get next item | `ccw issue next --json` | `Read('queues/*.json')` |
+| Update status | `ccw issue update <id> --status ...` | Direct file edit |
+| Sync from queue | `ccw issue update --from-queue` | Direct file edit |
+| **Read solution (brief)** | `ccw issue solution <id> --brief` | `Read('solutions/*.jsonl')` |
+
+**Output Options**:
+- `--brief`: JSON with minimal fields (id, status, counts)
+- `--json`: Full JSON (agent use only)
+
+**Orchestration vs Execution**:
+- **Command (orchestrator)**: Use `--brief` for minimal context
+- **Agent (executor)**: Fetch full details → `ccw issue status <id> --json`
+
+**ALWAYS** use CLI commands for CRUD operations. **NEVER** read entire `issues.jsonl` or `queues/*.json` directly.
+
+
+
+## Usage
+
+```bash
+/issue:queue [FLAGS]
+
+# Examples
+/issue:queue                      # Form NEW queue from all bound solutions
+/issue:queue --queues 3           # Form 3 parallel queues (solutions distributed)
+/issue:queue --issue GH-123       # Form queue for specific issue only
+/issue:queue --append GH-124      # Append to active queue
+/issue:queue --list               # List all queues (history)
+/issue:queue --switch QUE-xxx     # Switch active queue
+/issue:queue --archive            # Archive completed active queue
+
+# Flags
+--queues <n>          Number of parallel queues (default: 1)
+--issue <id>          Form queue for specific issue only
+--append <id>         Append issue to active queue (don't create new)
+
+# CLI subcommands (ccw issue queue ...)
+ccw issue queue list                  List all queues with status
+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
+
+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 queue summary (N queues), next step: /issue:execute
+```
+
+## Implementation
+
+### Phase 1: Solution Loading & Distribution
+
+**Data Loading:**
+- Use `ccw issue list --status planned --brief` to get planned issues with `bound_solution_id`
+- If no planned issues found → display message, suggest `/issue:plan`
+
+**Solution Brief Loading** (for each planned issue):
+```bash
+ccw issue solution <issue-id> --brief
+# Returns: [{ solution_id, is_bound, task_count, files_touched[] }]
+```
+
+**Build Solution Objects:**
+```json
+{
+  "issue_id": "ISS-xxx",
+  "solution_id": "SOL-ISS-xxx-1",
+  "task_count": 3,
+  "files_touched": ["src/auth.ts", "src/utils.ts"],
+  "priority": "medium"
+}
+```
+
+**Multi-Queue Distribution** (if `--queues > 1`):
+- Use `files_touched` from brief output for partitioning
+- Group solutions with overlapping files into same queue
+
+**Output:** Array of solution objects (or N arrays if multi-queue)
+
+### Phase 2-4: Agent-Driven Queue Formation
+
+**Generate Queue IDs** (command layer, pass to agent):
+```javascript
+const timestamp = new Date().toISOString().replace(/[-:T]/g, '').slice(0, 14);
+const numQueues = args.queues || 1;
+const queueIds = numQueues === 1
+  ? [`QUE-${timestamp}`]
+  : Array.from({length: numQueues}, (_, i) => `QUE-${timestamp}-${i + 1}`);
+```
+
+**Agent Prompt** (same for each queue, with assigned solutions):
+```
+## Order Solutions into Execution Queue
+
+**Queue ID**: ${queueId}
+**Solutions**: ${solutions.length} from ${issues.length} issues
+**Project Root**: ${cwd}
+**Queue Index**: ${queueIndex} of ${numQueues}
+
+### Input
+${JSON.stringify(solutions)}
+// Each object: { issue_id, solution_id, task_count, files_touched[], priority }
+
+### Workflow
+
+Step 1: Build dependency graph from solutions (nodes=solutions, edges=file conflicts via files_touched)
+Step 2: Use Gemini CLI for conflict analysis (5 types: file, API, data, dependency, architecture)
+Step 3: For high-severity conflicts without clear resolution → add to `clarifications`
+Step 4: Calculate semantic priority (base from issue priority + task_count boost)
+Step 5: Assign execution groups: P* (parallel, no overlaps) / S* (sequential, shared files)
+Step 6: Write queue JSON + update index
+
+### Output Requirements
+
+**Write files** (exactly 2):
+- `.workflow/issues/queues/${queueId}.json` - Full queue with solutions, conflicts, groups
+- `.workflow/issues/queues/index.json` - Update with new queue entry
+
+**Return JSON**:
+\`\`\`json
+{
+  "queue_id": "${queueId}",
+  "total_solutions": N,
+  "total_tasks": N,
+  "execution_groups": [{"id": "P1", "type": "parallel", "count": N}],
+  "issues_queued": ["ISS-xxx"],
+  "clarifications": [{"conflict_id": "CFT-1", "question": "...", "options": [...]}]
+}
+\`\`\`
+
+### Rules
+- Solution granularity (NOT individual tasks)
+- Queue Item ID format: S-1, S-2, S-3, ...
+- Use provided Queue ID (do NOT generate new)
+- `clarifications` only present if high-severity unresolved conflicts exist
+- Use `files_touched` from input (already extracted by orchestrator)
+
+### Done Criteria
+- [ ] Queue JSON written with all solutions ordered
+- [ ] Index updated with active_queue_id
+- [ ] No circular dependencies
+- [ ] Parallel groups have no file overlaps
+- [ ] Return JSON matches required shape
+```
+
+**Launch Agents** (parallel if multi-queue):
+```javascript
+const numQueues = args.queues || 1;
+
+if (numQueues === 1) {
+  // Single queue: single agent call
+  const result = Task(
+    subagent_type="issue-queue-agent",
+    prompt=buildPrompt(queueIds[0], solutions),
+    description=`Order ${solutions.length} solutions`
+  );
+} else {
+  // Multi-queue: parallel agent calls (single message with N Task calls)
+  const agentPromises = solutionGroups.map((group, i) =>
+    Task(
+      subagent_type="issue-queue-agent",
+      prompt=buildPrompt(queueIds[i], group, i + 1, numQueues),
+      description=`Queue ${i + 1}/${numQueues}: ${group.length} solutions`
+    )
+  );
+  // All agents launched in parallel via single message with multiple Task tool calls
+}
+```
+
+**Multi-Queue Index Update:**
+- First queue sets `active_queue_id`
+- All queues added to `queues` array with `queue_group` field linking them
+
+### Phase 5: Conflict Clarification
+
+**Collect Agent Results** (multi-queue):
+```javascript
+// Collect clarifications from all agents
+const allClarifications = results.flatMap((r, i) =>
+  (r.clarifications || []).map(c => ({ ...c, queue_id: queueIds[i], agent_id: agentIds[i] }))
+);
+```
+
+**Check Agent Return:**
+- Parse agent result JSON (or all results if multi-queue)
+- If any `clarifications` array exists and non-empty → user decision required
+
+**Clarification Flow:**
+```javascript
+if (allClarifications.length > 0) {
+  for (const clarification of allClarifications) {
+    // Present to user via AskUserQuestion
+    const answer = AskUserQuestion({
+      questions: [{
+        question: `[${clarification.queue_id}] ${clarification.question}`,
+        header: clarification.conflict_id,
+        options: clarification.options,
+        multiSelect: false
+      }]
+    });
+
+    // Resume respective agent with user decision
+    Task(
+      subagent_type="issue-queue-agent",
+      resume=clarification.agent_id,
+      prompt=`Conflict ${clarification.conflict_id} resolved: ${answer.selected}`
+    );
+  }
+}
+```
+
+### Phase 6: Status Update & Summary
+
+**Status Update** (MUST use CLI command, NOT direct file operations):
+
+```bash
+# Option 1: Batch update from queue (recommended)
+ccw issue update --from-queue [queue-id] --json
+ccw issue update --from-queue --json              # Use active queue
+ccw issue update --from-queue QUE-xxx --json      # Use specific queue
+
+# Option 2: Individual issue update
+ccw issue update <issue-id> --status queued
+```
+
+**⚠️ IMPORTANT**: Do NOT directly modify `issues.jsonl`. Always use CLI command to ensure proper validation and history tracking.
+
+**Output** (JSON):
+```json
+{
+  "success": true,
+  "queue_id": "QUE-xxx",
+  "queued": ["ISS-001", "ISS-002"],
+  "queued_count": 2,
+  "unplanned": ["ISS-003"],
+  "unplanned_count": 1
+}
+```
+
+**Behavior:**
+- Updates issues in queue to `status: 'queued'` (skips already queued/executing/completed)
+- Identifies planned issues with `bound_solution_id` NOT in queue → `unplanned` array
+- Optional `queue-id`: defaults to active queue if omitted
+
+**Summary Output:**
+- Display queue ID, solution count, task count
+- Show unplanned issues (planned but NOT in queue)
+- Show next step: `/issue:execute`
+
+
+## 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 |
+
+## Quality Checklist
+
+Before completing, verify:
+
+- [ ] All planned issues with `bound_solution_id` are included
+- [ ] Queue JSON written to `queues/{queue-id}.json` (N files if multi-queue)
+- [ ] Index updated in `queues/index.json` with `active_queue_id`
+- [ ] Multi-queue: All queues share same `queue_group`
+- [ ] No circular dependencies in solution DAG
+- [ ] All conflicts resolved (auto or via user clarification)
+- [ ] Parallel groups have no file overlaps
+- [ ] Cross-queue: No file overlaps between queues
+- [ ] Issue statuses updated to `queued`
+
+## Related Commands
+
+- `/issue:execute` - Execute queue with codex
+- `ccw issue queue list` - View current queue
+- `ccw issue update --from-queue [queue-id]` - Sync issue statuses from queue

.claude/commands/memory/code-map-memory.md

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

.claude/commands/memory/compact.md

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

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

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

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

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

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

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

.claude/commands/memory/load.md

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,332 @@
+---
+name: update-full
+description: Update all CLAUDE.md files using layer-based execution (Layer 3→1) with batched agents (4 modules/agent) and gemini→qwen→codex fallback, <20 modules uses direct parallel
+argument-hint: "[--tool gemini|qwen|codex] [--path <directory>]"
+---
+
+# Full Documentation Update (/memory:update-full)
+
+## Overview
+
+Orchestrates project-wide CLAUDE.md updates using batched agent execution with automatic tool fallback and 3-layer architecture support.
+
+**Parameters**:
+- `--tool <gemini|qwen|codex>`: Primary tool (default: gemini)
+- `--path <directory>`: Target specific directory (default: entire project)
+
+**Execution Flow**: Discovery → Plan Presentation → Execution → Safety Verification
+
+## 3-Layer Architecture & Auto-Strategy Selection
+
+### Layer Definition & Strategy Assignment
+
+| Layer | Depth | Strategy | Purpose | Context Pattern |
+|-------|-------|----------|---------|----------------|
+| **Layer 3** (Deepest) | ≥3 | `multi-layer` | Handle unstructured files, generate docs for all subdirectories | `@**/*` (all files) |
+| **Layer 2** (Middle) | 1-2 | `single-layer` | Aggregate from children + current code | `@*/CLAUDE.md @*.{ts,tsx,js,...}` |
+| **Layer 1** (Top) | 0 | `single-layer` | Aggregate from children + current code | `@*/CLAUDE.md @*.{ts,tsx,js,...}` |
+
+**Update Direction**: Layer 3 → Layer 2 → Layer 1 (bottom-up dependency flow)
+
+**Strategy Auto-Selection**: Strategies are automatically determined by directory depth - no user configuration needed.
+
+### Strategy Details
+
+#### Multi-Layer Strategy (Layer 3 Only)
+- **Use Case**: Deepest directories with unstructured file layouts
+- **Behavior**: Generates CLAUDE.md for current directory AND each subdirectory containing files
+- **Context**: All files in current directory tree (`@**/*`)
+
+
+#### Single-Layer Strategy (Layers 1-2)
+- **Use Case**: Upper layers that aggregate from existing documentation
+- **Behavior**: Generates CLAUDE.md only for current directory
+- **Context**: Direct children CLAUDE.md files + current directory code files
+
+### Example Flow
+```
+src/auth/handlers/ (depth 3) → MULTI-LAYER STRATEGY
+  CONTEXT: @**/* (all files in handlers/ and subdirs)
+  GENERATES: ./CLAUDE.md + CLAUDE.md in each subdir with files
+  ↓
+src/auth/ (depth 2) → SINGLE-LAYER STRATEGY
+  CONTEXT: @*/CLAUDE.md @*.ts (handlers/CLAUDE.md + current code)
+  GENERATES: ./CLAUDE.md only
+  ↓
+src/ (depth 1) → SINGLE-LAYER STRATEGY
+  CONTEXT: @*/CLAUDE.md (auth/CLAUDE.md, utils/CLAUDE.md)
+  GENERATES: ./CLAUDE.md only
+  ↓
+./ (depth 0) → SINGLE-LAYER STRATEGY
+  CONTEXT: @*/CLAUDE.md (src/CLAUDE.md, tests/CLAUDE.md)
+  GENERATES: ./CLAUDE.md only
+```
+
+## Core Execution Rules
+
+1. **Analyze First**: Git cache + module discovery before updates
+2. **Wait for Approval**: Present plan, no execution without user confirmation
+3. **Execution Strategy**:
+   - **<20 modules**: Direct parallel execution (max 4 concurrent per layer)
+   - **≥20 modules**: Agent batch processing (4 modules/agent, 73% overhead reduction)
+4. **Tool Fallback**: Auto-retry with fallback tools on failure
+5. **Layer Sequential**: Process layers 3→2→1 (bottom-up), parallel batches within layer
+6. **Safety Check**: Verify only CLAUDE.md files modified
+7. **Layer-based Grouping**: Group modules by LAYER (not depth) for execution
+
+## Tool Fallback Hierarchy
+
+```javascript
+--tool gemini  →  [gemini, qwen, codex]  // default
+--tool qwen    →  [qwen, gemini, codex]
+--tool codex   →  [codex, gemini, qwen]
+```
+
+**Trigger**: Non-zero exit code from update script
+
+| Tool   | Best For                       | Fallback To    |
+|--------|--------------------------------|----------------|
+| gemini | Documentation, patterns        | qwen → codex   |
+| qwen   | Architecture, system design    | gemini → codex |
+| codex  | Implementation, code quality   | gemini → qwen  |
+
+## Execution Phases
+
+### Phase 1: Discovery & Analysis
+
+```javascript
+// Cache git changes
+Bash({command: "git add -A 2>/dev/null || true", run_in_background: false});
+
+// Get module structure
+Bash({command: "ccw tool exec get_modules_by_depth '{\"format\":\"list\"}'", run_in_background: false});
+
+// OR with --path
+Bash({command: "cd <target-path> && ccw tool exec get_modules_by_depth '{\"format\":\"list\"}'", run_in_background: false});
+```
+
+**Parse output** `depth:N|path:<PATH>|...` to extract module paths and count.
+
+**Smart filter**: Auto-detect and skip tests/build/config/docs based on project tech stack.
+
+### Phase 2: Plan Presentation
+
+**For <20 modules**:
+```
+Update Plan:
+  Tool: gemini (fallback: qwen → codex)
+  Total: 7 modules
+  Execution: Direct parallel (< 20 modules threshold)
+
+  Will update:
+  - ./core/interfaces (12 files) - depth 2 [Layer 2] - single-layer strategy
+  - ./core (22 files) - depth 1 [Layer 2] - single-layer strategy
+  - ./models (9 files) - depth 1 [Layer 2] - single-layer strategy
+  - ./utils (12 files) - depth 1 [Layer 2] - single-layer strategy
+  - . (5 files) - depth 0 [Layer 1] - single-layer strategy
+
+  Context Strategy (Auto-Selected):
+  - Layer 2 (depth 1-2): @*/CLAUDE.md + current code files
+  - Layer 1 (depth 0): @*/CLAUDE.md + current code files
+
+  Auto-skipped: ./tests, __pycache__, setup.py (15 paths)
+  Execution order: Layer 2 → Layer 1
+  Estimated time: ~5-10 minutes
+
+  Confirm execution? (y/n)
+```
+
+**For ≥20 modules**:
+```
+Update Plan:
+  Tool: gemini (fallback: qwen → codex)
+  Total: 31 modules
+  Execution: Agent batch processing (4 modules/agent)
+
+  Will update:
+  - ./src/features/auth (12 files) - depth 3 [Layer 3] - multi-layer strategy
+  - ./.claude/commands/cli (6 files) - depth 3 [Layer 3] - multi-layer strategy
+  - ./src/utils (8 files) - depth 2 [Layer 2] - single-layer strategy
+  ...
+
+  Context Strategy (Auto-Selected):
+  - Layer 3 (depth ≥3): @**/* (all files)
+  - Layer 2 (depth 1-2): @*/CLAUDE.md + current code files
+  - Layer 1 (depth 0): @*/CLAUDE.md + current code files
+  
+  Auto-skipped: ./tests, __pycache__, setup.py (15 paths)
+  Execution order: Layer 2 → Layer 1
+  Estimated time: ~5-10 minutes
+
+  Agent allocation (by LAYER):
+  - Layer 3 (14 modules, depth ≥3): 4 agents [4, 4, 4, 2]
+  - Layer 2 (15 modules, depth 1-2): 4 agents [4, 4, 4, 3]
+  - Layer 1 (2 modules, depth 0): 1 agent [2]
+
+  Estimated time: ~15-25 minutes
+
+  Confirm execution? (y/n)
+```
+
+### Phase 3A: Direct Execution (<20 modules)
+
+**Strategy**: Parallel execution within layer (max 4 concurrent), no agent overhead.
+
+**CRITICAL**: All Bash commands use `run_in_background: false` for synchronous execution.
+
+```javascript
+for (let layer of [3, 2, 1]) {
+  if (modules_by_layer[layer].length === 0) continue;
+  let batches = batch_modules(modules_by_layer[layer], 4);
+
+  for (let batch of batches) {
+    let parallel_tasks = batch.map(module => {
+      return async () => {
+        let strategy = module.depth >= 3 ? "multi-layer" : "single-layer";
+        for (let tool of tool_order) {
+          Bash({
+            command: `cd ${module.path} && ccw tool exec update_module_claude '{"strategy":"${strategy}","path":".","tool":"${tool}"}'`,
+            run_in_background: false
+          });
+          if (bash_result.exit_code === 0) {
+            report(`✅ ${module.path} (Layer ${layer}) updated with ${tool}`);
+            return true;
+          }
+        }
+        report(`❌ FAILED: ${module.path} (Layer ${layer}) failed all tools`);
+        return false;
+      };
+    });
+    await Promise.all(parallel_tasks.map(task => task()));
+  }
+}
+```
+
+### Phase 3B: Agent Batch Execution (≥20 modules)
+
+**Strategy**: Batch modules into groups of 4, spawn memory-bridge agents per batch.
+
+```javascript
+// Group modules by LAYER and batch within each layer
+let modules_by_layer = group_by_layer(module_list);
+let tool_order = construct_tool_order(primary_tool);
+
+for (let layer of [3, 2, 1]) {
+  if (modules_by_layer[layer].length === 0) continue;
+
+  let batches = batch_modules(modules_by_layer[layer], 4);
+  let worker_tasks = [];
+
+  for (let batch of batches) {
+    worker_tasks.push(
+      Task(
+        subagent_type="memory-bridge",
+        description=`Update ${batch.length} modules in Layer ${layer}`,
+        prompt=generate_batch_worker_prompt(batch, tool_order, layer)
+      )
+    );
+  }
+
+  await parallel_execute(worker_tasks);
+}
+```
+
+**Batch Worker Prompt Template**:
+```
+PURPOSE: Update CLAUDE.md for assigned modules with tool fallback
+
+TASK: Update documentation for assigned modules using specified strategies.
+
+MODULES:
+{{module_path_1}} (strategy: {{strategy_1}})
+{{module_path_2}} (strategy: {{strategy_2}})
+...
+
+TOOLS (try in order): {{tool_1}}, {{tool_2}}, {{tool_3}}
+
+EXECUTION SCRIPT: ccw tool exec update_module_claude
+  - Accepts strategy parameter: multi-layer | single-layer
+  - Tool execution via direct CLI commands (gemini/qwen/codex)
+
+EXECUTION FLOW (for each module):
+  1. Tool fallback loop (exit on first success):
+     for tool in {{tool_1}} {{tool_2}} {{tool_3}}; do
+       Bash({
+         command: `cd "{{module_path}}" && ccw tool exec update_module_claude '{"strategy":"{{strategy}}","path":".","tool":"${tool}"}'`,
+         run_in_background: false
+       })
+       exit_code=$?
+
+       if [ $exit_code -eq 0 ]; then
+         report "✅ {{module_path}} updated with $tool"
+         break
+       else
+         report "⚠️  {{module_path}} failed with $tool, trying next..."
+         continue
+       fi
+     done
+
+  2. Handle complete failure (all tools failed):
+     if [ $exit_code -ne 0 ]; then
+       report "❌ FAILED: {{module_path}} - all tools exhausted"
+       # Continue to next module (do not abort batch)
+     fi
+
+FAILURE HANDLING:
+  - Module-level isolation: One module's failure does not affect others
+  - Exit code detection: Non-zero exit code triggers next tool
+  - Exhaustion reporting: Log modules where all tools failed
+  - Batch continuation: Always process remaining modules
+
+REPORTING FORMAT:
+  Per-module status:
+    ✅ path/to/module updated with {tool}
+    ⚠️  path/to/module failed with {tool}, trying next...
+    ❌ FAILED: path/to/module - all tools exhausted
+```
+### Phase 4: Safety Verification
+
+```javascript
+// Check only CLAUDE.md files modified
+Bash({command: 'git diff --cached --name-only | grep -v "CLAUDE.md" || echo "Only CLAUDE.md files modified"', run_in_background: false});
+
+// Display status
+Bash({command: "git status --short", run_in_background: false});
+```
+
+**Result Summary**:
+```
+Update Summary:
+  Total: 31 | Success: 29 | Failed: 2
+  Tool usage: gemini: 25, qwen: 4, codex: 0
+  Failed: path1, path2
+```
+
+## Error Handling
+
+**Batch Worker**: Tool fallback per module, batch isolation, clear status reporting
+**Coordinator**: Invalid path abort, user decline handling, safety check with auto-revert
+**Fallback Triggers**: Non-zero exit code, script timeout, unexpected output
+
+## Usage Examples
+
+```bash
+# Full project update (auto-strategy selection)
+/memory:update-full
+
+# Target specific directory
+/memory:update-full --path .claude
+/memory:update-full --path src/features/auth
+
+# Use specific tool
+/memory:update-full --tool qwen
+/memory:update-full --path .claude --tool qwen
+```
+
+## Key Advantages
+
+- **Efficiency**: 30 modules → 8 agents (73% reduction from sequential)
+- **Resilience**: 3-tier tool fallback per module
+- **Performance**: Parallel batches, no concurrency limits
+- **Observability**: Per-module tool usage, batch-level metrics
+- **Automation**: Zero configuration - strategy auto-selected by directory depth

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

@@ -1,330 +0,0 @@
----
-name: update-full
-description: Complete project-wide CLAUDE.md documentation update
-argument-hint: "[--tool gemini|qwen|codex] [--path <directory>]"
----
-
-# Full Documentation Update (/memory:update-full)
-
-## Coordinator Role
-
-**This command orchestrates project-wide CLAUDE.md updates** using depth-parallel execution strategy with intelligent complexity detection.
-
-**Execution Model**:
-
-1. **Initial Analysis**: Cache git changes, discover module structure
-2. **Complexity Detection**: Analyze module count, determine strategy
-3. **Plan Presentation**: Show user exactly what will be updated
-4. **Depth-Parallel Execution**: Update modules by depth (highest to lowest)
-5. **Safety Verification**: Ensure only CLAUDE.md files modified
-
-**Tool Selection**:
-- `--tool gemini` (default): Documentation generation, pattern recognition
-- `--tool qwen`: Architecture analysis, system design docs
-- `--tool codex`: Implementation validation, code quality analysis
-
-**Path Parameter**:
-- `--path <directory>` (optional): Target specific directory for updates
-- If not specified: Updates entire project from current directory
-- If specified: Changes to target directory before discovery
-
-## Core Rules
-
-1. **Analyze First**: Run git cache and module discovery before any updates
-2. **Scope Control**: Use --path to target specific directories, default is entire project
-3. **Wait for Approval**: Present plan, no execution without user confirmation
-4. **Depth-Parallel**: Same depth runs parallel (max 4 jobs), different depths sequential
-5. **Safety Check**: Verify only CLAUDE.md files modified, revert if source files touched
-6. **Independent Commands**: Each update is a separate bash() call
-7. **No Background Bash Tool**: Never use `run_in_background` parameter in bash() calls; use shell `&` for parallelism
-
-## Execution Workflow
-
-### Phase 1: Discovery & Analysis
-
-**Cache git changes:**
-```bash
-bash(git add -A 2>/dev/null || true)
-```
-
-**Get module structure:**
-
-*If no --path parameter:*
-```bash
-bash(~/.claude/scripts/get_modules_by_depth.sh list)
-```
-
-*If --path parameter specified:*
-```bash
-bash(cd <target-path> && ~/.claude/scripts/get_modules_by_depth.sh list)
-```
-
-**Example with path:**
-```bash
-# Update only .claude directory
-bash(cd .claude && ~/.claude/scripts/get_modules_by_depth.sh list)
-
-# Update specific feature directory
-bash(cd src/features/auth && ~/.claude/scripts/get_modules_by_depth.sh list)
-```
-
-**Parse Output**:
-- Extract module paths from `depth:N|path:<PATH>|...` format
-- Count total modules
-- Identify which modules have/need CLAUDE.md
-
-**Example output:**
-```
-depth:5|path:./.claude/workflows/cli-templates/prompts/analysis|files:5|has_claude:no
-depth:4|path:./.claude/commands/cli/mode|files:3|has_claude:no
-depth:3|path:./.claude/commands/cli|files:6|has_claude:no
-depth:0|path:.|files:14|has_claude:yes
-```
-
-**Validation**:
-- If --path specified, directory exists and is accessible
-- Module list contains depth and path information
-- At least one module exists
-- All paths are relative to target directory (if --path used)
-
----
-
-### Phase 2: Plan Presentation
-
-**Decision Logic**:
-- **Simple projects (≤20 modules)**: Present plan to user, wait for approval
-- **Complex projects (>20 modules)**: Delegate to memory-bridge agent
-
-**Plan format:**
-```
-📋 Update Plan:
-  Tool: gemini
-  Total modules: 31
-
-  NEW CLAUDE.md files (30):
-    - ./.claude/workflows/cli-templates/prompts/analysis/CLAUDE.md
-    - ./.claude/commands/cli/mode/CLAUDE.md
-    - ... (28 more)
-
-  UPDATE existing CLAUDE.md files (1):
-    - ./CLAUDE.md
-
-  ⚠️ Confirm execution? (y/n)
-```
-
-**User Confirmation Required**: No execution without explicit approval
-
----
-
-### Phase 3: Depth-Parallel Execution
-
-**Pattern**: Process highest depth first, parallel within depth, sequential across depths.
-
-**Command structure:**
-```bash
-bash(cd <module-path> && ~/.claude/scripts/update_module_claude.sh "." "full" "<tool>" &)
-```
-
-**Example - Depth 5 (8 modules):**
-```bash
-bash(cd ./.claude/workflows/cli-templates/prompts/analysis && ~/.claude/scripts/update_module_claude.sh "." "full" "gemini" &)
-```
-```bash
-bash(cd ./.claude/workflows/cli-templates/prompts/development && ~/.claude/scripts/update_module_claude.sh "." "full" "gemini" &)
-```
-```bash
-bash(cd ./.claude/workflows/cli-templates/prompts/documentation && ~/.claude/scripts/update_module_claude.sh "." "full" "gemini" &)
-```
-```bash
-bash(cd ./.claude/workflows/cli-templates/prompts/implementation && ~/.claude/scripts/update_module_claude.sh "." "full" "gemini" &)
-```
-
-*Wait for depth 5 completion...*
-
-**Example - Depth 4 (7 modules):**
-```bash
-bash(cd ./.claude/commands/cli/mode && ~/.claude/scripts/update_module_claude.sh "." "full" "gemini" &)
-```
-```bash
-bash(cd ./.claude/commands/workflow/brainstorm && ~/.claude/scripts/update_module_claude.sh "." "full" "gemini" &)
-```
-
-*Continue for remaining depths (3 → 2 → 1 → 0)...*
-
-**Execution Rules**:
-- Each command is separate bash() call
-- Up to 4 concurrent jobs per depth
-- Wait for all jobs in current depth before proceeding
-- Extract path from `depth:N|path:<PATH>|...` format
-- All paths relative to target directory (current dir or --path value)
-
-**Path Context**:
-- Without --path: Paths relative to current directory
-- With --path: Paths relative to specified target directory
-- Module discovery runs in target directory context
-
----
-
-### Phase 4: Safety Verification
-
-**Check modified files:**
-```bash
-bash(git diff --cached --name-only | grep -v "CLAUDE.md" || echo "✅ Only CLAUDE.md files modified")
-```
-
-**Expected output:**
-```
-✅ Only CLAUDE.md files modified
-```
-
-**If non-CLAUDE.md files detected:**
-```
-⚠️ Warning: Non-CLAUDE.md files were modified
-Modified files: src/index.ts, package.json
-→ Run: git restore --staged .
-```
-
-**Display final status:**
-```bash
-bash(git status --short)
-```
-
-**Example output:**
-```
-A  .claude/workflows/cli-templates/prompts/analysis/CLAUDE.md
-A  .claude/commands/cli/mode/CLAUDE.md
-M  CLAUDE.md
-... (30 more files)
-```
-
-## Command Pattern Reference
-
-**Single module update:**
-```bash
-bash(cd <module-path> && ~/.claude/scripts/update_module_claude.sh "." "full" "<tool>" &)
-```
-
-**Components**:
-- `cd <module-path>` - Navigate to module (from `path:` field)
-- `&&` - Ensure cd succeeds
-- `update_module_claude.sh` - Update script
-- `"."` - Current directory
-- `"full"` - Full update mode
-- `"<tool>"` - gemini/qwen/codex
-- `&` - Background execution
-
-**Path extraction:**
-```bash
-# From: depth:5|path:./src/auth|files:10|has_claude:no
-# Extract: ./src/auth
-# Command: bash(cd ./src/auth && ~/.claude/scripts/update_module_claude.sh "." "full" "gemini" &)
-```
-
-## Complex Projects Strategy
-
-For projects >20 modules, delegate to memory-bridge agent:
-
-```javascript
-Task(
-  subagent_type="memory-bridge",
-  description="Complex project full update",
-  prompt=`
-CONTEXT:
-- Total modules: ${module_count}
-- Tool: ${tool}
-- Mode: full
-
-MODULE LIST:
-${modules_output}
-
-REQUIREMENTS:
-1. Use TodoWrite to track each depth level
-2. Process depths N→0 sequentially, max 4 parallel per depth
-3. Command: cd "<path>" && update_module_claude.sh "." "full" "${tool}" &
-4. Extract path from "depth:N|path:<PATH>|..." format
-5. Verify all modules processed
-6. Run safety check
-7. Display git status
-`
-)
-```
-
-## Error Handling
-
-- **Invalid path parameter**: Report error if --path directory doesn't exist, abort execution
-- **Module discovery failure**: Report error, abort execution
-- **User declines approval**: Abort execution, no changes made
-- **Safety check failure**: Automatic staging revert, report modified files
-- **Update script failure**: Report failed modules, continue with remaining
-
-## Coordinator Checklist
-
-✅ Parse `--tool` parameter (default: gemini)
-✅ Parse `--path` parameter (optional, default: current directory)
-✅ Execute git cache in current directory
-✅ Execute module discovery (with cd if --path specified)
-✅ Parse module list, count total modules
-✅ Determine strategy based on module count (≤20 vs >20)
-✅ Present plan with exact file paths
-✅ **Wait for user confirmation** (simple projects only)
-✅ Organize modules by depth
-✅ For each depth (highest to lowest):
-  - Launch up to 5 parallel updates
-  - Wait for depth completion
-  - Proceed to next depth
-✅ Run safety check after all updates
-✅ Display git status
-✅ Report completion summary
-
-
-
-## Tool Parameter Reference
-
-**Gemini** (default):
-- Best for: Documentation generation, pattern recognition, architecture review
-- Context window: Large, handles complex codebases
-- Output style: Comprehensive, detailed explanations
-
-**Qwen**:
-- Best for: Architecture analysis, system design documentation
-- Context window: Large, similar to Gemini
-- Output style: Structured, systematic analysis
-
-**Codex**:
-- Best for: Implementation validation, code quality analysis
-- Capabilities: Mathematical reasoning, autonomous development
-- Output style: Technical, implementation-focused
-
-## Path Parameter Reference
-
-**Use Cases**:
-
-**Update configuration directory only:**
-```bash
-/memory:update-full --path .claude
-```
-- Updates only .claude directory and subdirectories
-- Useful after workflow or command modifications
-- Faster than full project update
-
-**Update specific feature module:**
-```bash
-/memory:update-full --path src/features/auth
-```
-- Updates authentication feature and sub-modules
-- Ideal for feature-specific documentation
-- Isolates scope for targeted updates
-
-**Update nested structure:**
-```bash
-/memory:update-full --path .claude/workflows/cli-templates
-```
-- Updates deeply nested directory tree
-- Maintains relative path structure in output
-- All module paths relative to specified directory
-
-**Best Practices**:
-- Use `--path` when working on specific features/modules
-- Omit `--path` for project-wide architectural changes
-- Combine with `--tool` for specialized documentation needs
-- Verify directory exists before execution (automatic validation)

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

@@ -1,306 +0,0 @@
----
-name: update-related
-description: Context-aware CLAUDE.md documentation updates based on recent changes
-argument-hint: "[--tool gemini|qwen|codex]"
----
-
-# Related Documentation Update (/memory:update-related)
-
-## Coordinator Role
-
-**This command orchestrates context-aware CLAUDE.md updates** for modules affected by recent changes using intelligent change detection.
-
-**Execution Model**:
-
-1. **Change Detection**: Analyze git changes to identify affected modules
-2. **Complexity Analysis**: Evaluate change count and determine strategy
-3. **Plan Presentation**: Show user which modules need updates
-4. **Depth-Parallel Execution**: Update affected modules by depth (highest to lowest)
-5. **Safety Verification**: Ensure only CLAUDE.md files modified
-
-**Tool Selection**:
-- `--tool gemini` (default): Documentation generation, pattern recognition
-- `--tool qwen`: Architecture analysis, system design docs
-- `--tool codex`: Implementation validation, code quality analysis
-
-## Core Rules
-
-1. **Detect Changes First**: Use git diff to identify affected modules before updates
-2. **Wait for Approval**: Present plan, no execution without user confirmation
-3. **Related Mode**: Update only changed modules and their parent contexts
-4. **Depth-Parallel**: Same depth runs parallel (max 4 jobs), different depths sequential
-5. **Safety Check**: Verify only CLAUDE.md files modified, revert if source files touched
-6. **No Background Bash Tool**: Never use `run_in_background` parameter in bash() calls; use shell `&` for parallelism
-
-## Execution Workflow
-
-### Phase 1: Change Detection & Analysis
-
-**Refresh code index:**
-```bash
-bash(mcp__code-index__refresh_index)
-```
-
-**Detect changed modules:**
-```bash
-bash(~/.claude/scripts/detect_changed_modules.sh list)
-```
-
-**Cache git changes:**
-```bash
-bash(git add -A 2>/dev/null || true)
-```
-
-**Parse Output**:
-- Extract changed module paths from `depth:N|path:<PATH>|...` format
-- Count affected modules
-- Identify which modules have/need CLAUDE.md updates
-
-**Example output:**
-```
-depth:3|path:./src/api/auth|files:5|types:[ts]|has_claude:no|change:new
-depth:2|path:./src/api|files:12|types:[ts]|has_claude:yes|change:modified
-depth:1|path:./src|files:8|types:[ts]|has_claude:yes|change:parent
-depth:0|path:.|files:14|has_claude:yes|change:parent
-```
-
-**Fallback behavior**:
-- If no git changes detected, use recent modules (first 10 by depth)
-
-**Validation**:
-- Changed module list contains valid paths
-- At least one affected module exists
-
----
-
-### Phase 2: Plan Presentation
-
-**Decision Logic**:
-- **Simple changes (≤15 modules)**: Present plan to user, wait for approval
-- **Complex changes (>15 modules)**: Delegate to memory-bridge agent
-
-**Plan format:**
-```
-📋 Related Update Plan:
-  Tool: gemini
-  Changed modules: 4
-
-  NEW CLAUDE.md files (1):
-    - ./src/api/auth/CLAUDE.md [new module]
-
-  UPDATE existing CLAUDE.md files (3):
-    - ./src/api/CLAUDE.md [parent of changed auth/]
-    - ./src/CLAUDE.md [parent context]
-    - ./CLAUDE.md [root level]
-
-  ⚠️ Confirm execution? (y/n)
-```
-
-**User Confirmation Required**: No execution without explicit approval
-
----
-
-### Phase 3: Depth-Parallel Execution
-
-**Pattern**: Process highest depth first, parallel within depth, sequential across depths.
-
-**Command structure:**
-```bash
-bash(cd <module-path> && ~/.claude/scripts/update_module_claude.sh "." "related" "<tool>" &)
-```
-
-**Example - Depth 3 (new module):**
-```bash
-bash(cd ./src/api/auth && ~/.claude/scripts/update_module_claude.sh "." "related" "gemini" &)
-```
-
-*Wait for depth 3 completion...*
-
-**Example - Depth 2 (modified parent):**
-```bash
-bash(cd ./src/api && ~/.claude/scripts/update_module_claude.sh "." "related" "gemini" &)
-```
-
-*Wait for depth 2 completion...*
-
-**Example - Depth 1 & 0 (parent contexts):**
-```bash
-bash(cd ./src && ~/.claude/scripts/update_module_claude.sh "." "related" "gemini" &)
-```
-```bash
-bash(cd . && ~/.claude/scripts/update_module_claude.sh "." "related" "gemini" &)
-```
-
-*Wait for all depths completion...*
-
-**Execution Rules**:
-- Each command is separate bash() call
-- Up to 4 concurrent jobs per depth
-- Wait for all jobs in current depth before proceeding
-- Use "related" mode (not "full") for context-aware updates
-- Extract path from `depth:N|path:<PATH>|...` format
-
-**Related Mode Behavior**:
-- Updates module based on recent git changes
-- Includes parent context for better documentation coherence
-- More efficient than full updates for iterative development
-
----
-
-### Phase 4: Safety Verification
-
-**Check modified files:**
-```bash
-bash(git diff --cached --name-only | grep -v "CLAUDE.md" || echo "✅ Only CLAUDE.md files modified")
-```
-
-**Expected output:**
-```
-✅ Only CLAUDE.md files modified
-```
-
-**If non-CLAUDE.md files detected:**
-```
-⚠️ Warning: Non-CLAUDE.md files were modified
-Modified files: src/api/auth/index.ts, package.json
-→ Run: git restore --staged .
-```
-
-**Display final statistics:**
-```bash
-bash(git diff --stat)
-```
-
-**Example output:**
-```
-.claude/workflows/cli-templates/prompts/analysis/CLAUDE.md | 45 +++++++++++++++++++++
-src/api/CLAUDE.md                                          | 23 +++++++++--
-src/CLAUDE.md                                              | 12 ++++--
-CLAUDE.md                                                  | 8 ++--
-4 files changed, 82 insertions(+), 6 deletions(-)
-```
-
-## Command Pattern Reference
-
-**Single module update:**
-```bash
-bash(cd <module-path> && ~/.claude/scripts/update_module_claude.sh "." "related" "<tool>" &)
-```
-
-**Components**:
-- `cd <module-path>` - Navigate to module (from `path:` field)
-- `&&` - Ensure cd succeeds
-- `update_module_claude.sh` - Update script
-- `"."` - Current directory
-- `"related"` - Related mode (context-aware, change-based)
-- `"<tool>"` - gemini/qwen/codex
-- `&` - Background execution
-
-**Path extraction:**
-```bash
-# From: depth:3|path:./src/api/auth|files:5|change:new|has_claude:no
-# Extract: ./src/api/auth
-# Command: bash(cd ./src/api/auth && ~/.claude/scripts/update_module_claude.sh "." "related" "gemini" &)
-```
-
-**Mode comparison:**
-- `"full"` - Complete module documentation regeneration
-- `"related"` - Context-aware update based on recent changes (faster)
-
-## Complex Changes Strategy
-
-For changes affecting >15 modules, delegate to memory-bridge agent:
-
-```javascript
-Task(
-  subagent_type="memory-bridge",
-  description="Complex project related update",
-  prompt=`
-CONTEXT:
-- Total modules: ${change_count}
-- Tool: ${tool}
-- Mode: related
-
-MODULE LIST:
-${changed_modules_output}
-
-REQUIREMENTS:
-1. Use TodoWrite to track each depth level
-2. Process depths N→0 sequentially, max 4 parallel per depth
-3. Command: cd "<path>" && update_module_claude.sh "." "related" "${tool}" &
-4. Extract path from "depth:N|path:<PATH>|..." format
-5. Verify all ${change_count} modules processed
-6. Run safety check
-7. Display git diff --stat
-`
-)
-```
-
-## Error Handling
-
-- **No changes detected**: Use fallback mode (recent 10 modules)
-- **Change detection failure**: Report error, abort execution
-- **User declines approval**: Abort execution, no changes made
-- **Safety check failure**: Automatic staging revert, report modified files
-- **Update script failure**: Report failed modules, continue with remaining
-
-## Coordinator Checklist
-
-✅ Parse `--tool` parameter (default: gemini)
-✅ Refresh code index for accurate change detection
-✅ Detect changed modules via detect_changed_modules.sh
-✅ Cache git changes to protect current state
-✅ Parse changed module list, count affected modules
-✅ Apply fallback if no changes detected (recent 10 modules)
-✅ Determine strategy based on change count (≤15 vs >15)
-✅ Present plan with exact file paths and change types
-✅ **Wait for user confirmation** (simple changes only)
-✅ Organize modules by depth
-✅ For each depth (highest to lowest):
-  - Launch up to 4 parallel updates with "related" mode
-  - Wait for depth completion
-  - Proceed to next depth
-✅ Run safety check after all updates
-✅ Display git diff statistics
-✅ Report completion summary
-
-## Usage Examples
-
-```bash
-# Daily development update (default: gemini)
-/memory:update-related
-
-# After feature work with specific tool
-/memory:update-related --tool qwen
-
-# Code quality review after implementation
-/memory:update-related --tool codex
-```
-
-## Tool Parameter Reference
-
-**Gemini** (default):
-- Best for: Documentation generation, pattern recognition
-- Use case: Daily development updates, feature documentation
-- Output style: Comprehensive, contextual explanations
-
-**Qwen**:
-- Best for: Architecture analysis, system design
-- Use case: Structural changes, API design updates
-- Output style: Structured, systematic documentation
-
-**Codex**:
-- Best for: Implementation validation, code quality
-- Use case: After implementation, refactoring work
-- Output style: Technical, implementation-focused
-
-## Comparison with Full Update
-
-| Aspect | Related Update | Full Update |
-|--------|----------------|-------------|
-| **Scope** | Changed modules only | All project modules |
-| **Speed** | Fast (minutes) | Slower (10-30 min) |
-| **Use case** | Daily development | Major refactoring |
-| **Mode** | `"related"` | `"full"` |
-| **Trigger** | After commits | After major changes |
-| **Complexity threshold** | ≤15 modules | ≤20 modules |

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

@@ -0,0 +1,332 @@
+---
+name: update-related
+description: Update CLAUDE.md for git-changed modules using batched agent execution (4 modules/agent) with gemini→qwen→codex fallback, <15 modules uses direct execution
+argument-hint: "[--tool gemini|qwen|codex]"
+---
+
+# Related Documentation Update (/memory:update-related)
+
+## Overview
+
+Orchestrates context-aware CLAUDE.md updates for changed modules using batched agent execution with automatic tool fallback (gemini→qwen→codex).
+
+**Parameters**:
+- `--tool <gemini|qwen|codex>`: Primary tool (default: gemini)
+
+**Execution Flow**:
+1. Change Detection → 2. Plan Presentation → 3. Batched Agent Execution → 4. Safety Verification
+
+## Core Rules
+
+1. **Detect Changes First**: Use git diff to identify affected modules
+2. **Wait for Approval**: Present plan, no execution without user confirmation
+3. **Execution Strategy**:
+   - <15 modules: Direct parallel execution (max 4 concurrent per depth, no agent overhead)
+   - ≥15 modules: Agent batch processing (4 modules/agent, 73% overhead reduction)
+4. **Tool Fallback**: Auto-retry with fallback tools on failure
+5. **Depth Sequential**: Process depths N→0, parallel batches within depth (both modes)
+6. **Related Mode**: Update only changed modules and their parent contexts
+
+## Tool Fallback Hierarchy
+
+```javascript
+--tool gemini  →  [gemini, qwen, codex]  // default
+--tool qwen    →  [qwen, gemini, codex]
+--tool codex   →  [codex, gemini, qwen]
+```
+
+**Trigger**: Non-zero exit code from update script
+
+## Phase 1: Change Detection & Analysis
+
+```javascript
+// Detect changed modules
+Bash({command: "ccw tool exec detect_changed_modules '{\"format\":\"list\"}'", run_in_background: false});
+
+// Cache git changes
+Bash({command: "git add -A 2>/dev/null || true", run_in_background: false});
+```
+
+**Parse output** `depth:N|path:<PATH>|change:<TYPE>` to extract affected modules.
+
+**Smart filter**: Auto-detect and skip tests/build/config/docs based on project tech stack (Node.js/Python/Go/Rust/etc).
+
+**Fallback**: If no changes detected, use recent modules (first 10 by depth).
+
+## Phase 2: Plan Presentation
+
+**Present filtered plan**:
+```
+Related Update Plan:
+  Tool: gemini (fallback: qwen → codex)
+  Changed: 4 modules | Batching: 4 modules/agent
+
+  Will update:
+  - ./src/api/auth (5 files) [new module]
+  - ./src/api (12 files) [parent of changed auth/]
+  - ./src (8 files) [parent context]
+  - . (14 files) [root level]
+
+  Auto-skipped (12 paths):
+  - Tests: ./src/api/auth.test.ts (8 paths)
+  - Config: tsconfig.json (3 paths)
+  - Other: node_modules (1 path)
+
+  Agent allocation:
+  - Depth 3 (1 module): 1 agent [1]
+  - Depth 2 (1 module): 1 agent [1]
+  - Depth 1 (1 module): 1 agent [1]
+  - Depth 0 (1 module): 1 agent [1]
+
+  Confirm execution? (y/n)
+```
+
+**Decision logic**:
+- User confirms "y": Proceed with execution
+- User declines "n": Abort, no changes
+- <15 modules: Direct execution
+- ≥15 modules: Agent batch execution
+
+## Phase 3A: Direct Execution (<15 modules)
+
+**Strategy**: Parallel execution within depth (max 4 concurrent), no agent overhead.
+
+**CRITICAL**: All Bash commands use `run_in_background: false` for synchronous execution.
+
+```javascript
+for (let depth of sorted_depths.reverse()) {  // N → 0
+  let batches = batch_modules(modules_by_depth[depth], 4);
+
+  for (let batch of batches) {
+    let parallel_tasks = batch.map(module => {
+      return async () => {
+        for (let tool of tool_order) {
+          Bash({
+            command: `cd ${module.path} && ccw tool exec update_module_claude '{"strategy":"single-layer","path":".","tool":"${tool}"}'`,
+            run_in_background: false
+          });
+          if (bash_result.exit_code === 0) {
+            report(`✅ ${module.path} updated with ${tool}`);
+            return true;
+          }
+        }
+        report(`❌ FAILED: ${module.path} failed all tools`);
+        return false;
+      };
+    });
+    await Promise.all(parallel_tasks.map(task => task()));
+  }
+}
+```
+
+---
+
+## Phase 3B: Agent Batch Execution (≥15 modules)
+
+### Batching Strategy
+
+```javascript
+// Batch modules into groups of 4
+function batch_modules(modules, batch_size = 4) {
+  let batches = [];
+  for (let i = 0; i < modules.length; i += batch_size) {
+    batches.push(modules.slice(i, i + batch_size));
+  }
+  return batches;
+}
+// Examples: 10→[4,4,2] | 8→[4,4] | 3→[3]
+```
+
+### Coordinator Orchestration
+
+```javascript
+let modules_by_depth = group_by_depth(changed_modules);
+let tool_order = construct_tool_order(primary_tool);
+
+for (let depth of sorted_depths.reverse()) {  // N → 0
+  let batches = batch_modules(modules_by_depth[depth], 4);
+  let worker_tasks = [];
+
+  for (let batch of batches) {
+    worker_tasks.push(
+      Task(
+        subagent_type="memory-bridge",
+        description=`Update ${batch.length} modules at depth ${depth}`,
+        prompt=generate_batch_worker_prompt(batch, tool_order, "related")
+      )
+    );
+  }
+
+  await parallel_execute(worker_tasks);  // Batches run in parallel
+}
+```
+
+### Batch Worker Prompt Template
+
+```
+PURPOSE: Update CLAUDE.md for assigned modules with tool fallback (related mode)
+
+TASK:
+Update documentation for the following modules based on recent changes. For each module, try tools in order until success.
+
+MODULES:
+{{module_path_1}}
+{{module_path_2}}
+{{module_path_3}}
+{{module_path_4}}
+
+TOOLS (try in order):
+1. {{tool_1}}
+2. {{tool_2}}
+3. {{tool_3}}
+
+EXECUTION:
+For each module above:
+  1. Try tool 1:
+     Bash({
+       command: `cd "{{module_path}}" && ccw tool exec update_module_claude '{"strategy":"single-layer","path":".","tool":"{{tool_1}}"}'`,
+       run_in_background: false
+     })
+     → Success: Report "✅ {{module_path}} updated with {{tool_1}}", proceed to next module
+     → Failure: Try tool 2
+  2. Try tool 2:
+     Bash({
+       command: `cd "{{module_path}}" && ccw tool exec update_module_claude '{"strategy":"single-layer","path":".","tool":"{{tool_2}}"}'`,
+       run_in_background: false
+     })
+     → Success: Report "✅ {{module_path}} updated with {{tool_2}}", proceed to next module
+     → Failure: Try tool 3
+  3. Try tool 3:
+     Bash({
+       command: `cd "{{module_path}}" && ccw tool exec update_module_claude '{"strategy":"single-layer","path":".","tool":"{{tool_3}}"}'`,
+       run_in_background: false
+     })
+     → Success: Report "✅ {{module_path}} updated with {{tool_3}}", proceed to next module
+     → Failure: Report "❌ FAILED: {{module_path}} failed all tools", proceed to next module
+
+REPORTING:
+Report final summary with:
+- Total processed: X modules
+- Successful: Y modules
+- Failed: Z modules
+- Tool usage: {{tool_1}}:X, {{tool_2}}:Y, {{tool_3}}:Z
+```
+
+## Phase 4: Safety Verification
+
+```javascript
+// Check only CLAUDE.md modified
+Bash({command: 'git diff --cached --name-only | grep -v "CLAUDE.md" || echo "Only CLAUDE.md files modified"', run_in_background: false});
+
+// Display statistics
+Bash({command: "git diff --stat", run_in_background: false});
+```
+
+**Aggregate results**:
+```
+Update Summary:
+  Total: 4 | Success: 4 | Failed: 0
+
+  Tool usage:
+  - gemini: 4 modules
+  - qwen: 0 modules (fallback)
+  - codex: 0 modules
+
+  Changes:
+  src/api/auth/CLAUDE.md  | 45 +++++++++++++++++++++
+  src/api/CLAUDE.md       | 23 +++++++++--
+  src/CLAUDE.md           | 12 ++++--
+  CLAUDE.md               | 8 ++--
+  4 files changed, 82 insertions(+), 6 deletions(-)
+```
+
+## Execution Summary
+
+**Module Count Threshold**:
+- **<15 modules**: Coordinator executes Phase 3A (Direct Execution)
+- **≥15 modules**: Coordinator executes Phase 3B (Agent Batch Execution)
+
+**Agent Hierarchy** (for ≥15 modules):
+- **Coordinator**: Handles batch division, spawns worker agents per depth
+- **Worker Agents**: Each processes 4 modules with tool fallback (related mode)
+
+## Error Handling
+
+**Batch Worker**:
+- Tool fallback per module (auto-retry)
+- Batch isolation (failures don't propagate)
+- Clear per-module status reporting
+
+**Coordinator**:
+- No changes: Use fallback (recent 10 modules)
+- User decline: No execution
+- Safety check fail: Auto-revert staging
+- Partial failures: Continue execution, report failed modules
+
+**Fallback Triggers**:
+- Non-zero exit code
+- Script timeout
+- Unexpected output
+
+## Tool Reference
+
+| Tool   | Best For                       | Fallback To    |
+|--------|--------------------------------|----------------|
+| gemini | Documentation, patterns        | qwen → codex   |
+| qwen   | Architecture, system design    | gemini → codex |
+| codex  | Implementation, code quality   | gemini → qwen  |
+
+## Usage Examples
+
+```bash
+# Daily development update
+/memory:update-related
+
+# After feature work with specific tool
+/memory:update-related --tool qwen
+
+# Code quality review after implementation
+/memory:update-related --tool codex
+```
+
+## Key Advantages
+
+**Efficiency**: 30 modules → 8 agents (73% reduction)
+**Resilience**: 3-tier fallback per module
+**Performance**: Parallel batches, no concurrency limits
+**Context-aware**: Updates based on actual git changes
+**Fast**: Only affected modules, not entire project
+
+## Coordinator Checklist
+
+- Parse `--tool` (default: gemini)
+- Refresh code index for accurate change detection
+- Detect changed modules via detect_changed_modules.sh
+- **Smart filter modules** (auto-detect tech stack, skip tests/build/config/docs)
+- Cache git changes
+- Apply fallback if no changes (recent 10 modules)
+- Construct tool fallback order
+- **Present filtered plan** with skip reasons and change types
+- **Wait for y/n confirmation**
+- Determine execution mode:
+  - **<15 modules**: Direct execution (Phase 3A)
+    - For each depth (N→0): Sequential module updates with tool fallback
+  - **≥15 modules**: Agent batch execution (Phase 3B)
+    - For each depth (N→0): Batch modules (4 per batch), spawn batch workers in parallel
+- Wait for depth/batch completion
+- Aggregate results
+- Safety check (only CLAUDE.md modified)
+- Display git diff statistics + summary
+
+## Comparison with Full Update
+
+| Aspect | Related Update | Full Update |
+|--------|----------------|-------------|
+| **Scope** | Changed modules only | All project modules |
+| **Speed** | Fast (minutes) | Slower (10-30 min) |
+| **Use case** | Daily development | Major refactoring |
+| **Mode** | `"related"` | `"full"` |
+| **Trigger** | After commits | After major changes |
+| **Batching** | 4 modules/agent | 4 modules/agent |
+| **Fallback** | gemini→qwen→codex | gemini→qwen→codex |
+| **Complexity threshold** | ≤15 modules | ≤20 modules |

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

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

.claude/commands/task/breakdown.md

@@ -1,6 +1,6 @@
 ---
 name: breakdown
-description: Intelligent task decomposition with context-aware subtask generation
+description: Decompose complex task into subtasks with dependency mapping, creates child task JSONs with parent references and execution order
 argument-hint: "task-id"
 ---
 
@@ -10,13 +10,12 @@ argument-hint: "task-id"
 Breaks down complex tasks into executable subtasks with context inheritance and agent assignment.
 
 ## Core Principles
-**Task System:** @~/.claude/workflows/workflow-architecture.md
 **File Cohesion:** Related files must stay in same task
 **10-Task Limit:** Total tasks cannot exceed 10 (triggers re-scoping)
 
 ## Core Features
 
-⚠️ **CRITICAL**: Manual breakdown with safety controls to prevent file conflicts and task limit violations.
+**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
@@ -51,7 +50,7 @@ Interactive process:
 Task: Build authentication module
 Current total tasks: 6/10
 
-⚠️  MANUAL BREAKDOWN REQUIRED
+MANUAL BREAKDOWN REQUIRED
 Define subtasks manually (remaining capacity: 4 tasks):
 
 1. Enter subtask title: User authentication core
@@ -60,11 +59,11 @@ Define subtasks manually (remaining capacity: 4 tasks):
 2. Enter subtask title: OAuth integration
    Focus files: services/OAuthService.js, routes/oauth.js
 
-⚠️  FILE CONFLICT DETECTED:
+FILE CONFLICT DETECTED:
    - routes/auth.js appears in multiple subtasks
    - Recommendation: Merge related authentication routes
 
-⚠️  SIMILAR FUNCTIONALITY WARNING:
+SIMILAR FUNCTIONALITY WARNING:
    - "User authentication" and "OAuth integration" both handle auth
    - Consider combining into single task
 
@@ -84,10 +83,10 @@ AskUserQuestion({
 
 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
+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
 ```
@@ -99,7 +98,7 @@ Files updated: .task/IMPL-1.json + 2 subtask files + TODO_LIST.md
 - **Implementation** → `@code-developer`
 - **Testing** → `@code-developer` (type: "test-gen")
 - **Test Validation** → `@test-fix-agent` (type: "test-fix")
-- **Review** → `@general-purpose` (optional)
+- **Review** → `@universal-executor` (optional)
 
 ### Context Inheritance
 - Subtasks inherit parent requirements
@@ -138,7 +137,6 @@ Files updated: .task/IMPL-1.json + 2 subtask files + TODO_LIST.md
 
 ## Implementation Details
 
-See @~/.claude/workflows/workflow-architecture.md for:
 - Complete task JSON schema
 - Implementation field structure
 - Context inheritance rules
@@ -169,45 +167,38 @@ See @~/.claude/workflows/workflow-architecture.md for:
 ```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
+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
+Task IMPL-5 not found
 
 # Already broken down
-⚠️ Task IMPL-1 already has subtasks
+Task IMPL-1 already has subtasks
 
 # Wrong status
-❌ Cannot breakdown completed task IMPL-2
+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
+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
+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
+Similar functions detected: "user login" and "authentication"
+Consider consolidating related functionality
 
 # Manual breakdown required
-❌ Automatic breakdown disabled. Use manual breakdown process.
+Automatic breakdown disabled. Use manual breakdown process.
 ```
 
-## Related Commands
-
-- `/task:create` - Create new tasks
-- `/task:execute` - Execute subtasks
-- `/workflow:status` - View task hierarchy
-- `/workflow:plan` - Plan within 10-task limit
-
 **System ensures**: Manual breakdown control with file cohesion enforcement, similar functionality detection, and 10-task limit compliance

.claude/commands/task/create.md

@@ -1,6 +1,6 @@
 ---
 name: create
-description: Create implementation tasks with automatic context awareness
+description: Generate task JSON from natural language description with automatic file pattern detection, scope inference, and dependency analysis
 argument-hint: "\"task title\""
 ---
 
@@ -37,7 +37,7 @@ Creates new implementation tasks with automatic context awareness and ID generat
 
 Output:
 ```
-✅ Task created: IMPL-1
+Task created: IMPL-1
 Title: Build authentication module
 Type: feature
 Agent: code-developer
@@ -73,7 +73,7 @@ Status: pending
 ### Analysis Triggers
 When implementation details incomplete:
 ```bash
-⚠️ Task requires analysis for implementation details
+Task requires analysis for implementation details
 Suggest running: gemini analysis for file locations and dependencies
 ```
 
@@ -104,7 +104,7 @@ Based on task type and title keywords:
 - **Design/Plan** → @planning-agent
 - **Test Generation** → @code-developer (type: "test-gen")
 - **Test Execution/Fix** → @test-fix-agent (type: "test-fix")
-- **Review/Audit** → @general-purpose (optional, only when explicitly requested)
+- **Review/Audit** → @universal-executor (optional, only when explicitly requested)
 
 ## Validation Rules
 
@@ -117,16 +117,16 @@ Based on task type and title keywords:
 
 ```bash
 # No workflow session
-❌ No active workflow found
-→ Use: /workflow init "project name"
+No active workflow found
+Use: /workflow init "project name"
 
 # Duplicate task
-⚠️ Similar task exists: IMPL-3
-→ Continue anyway? (y/n)
+Similar task exists: IMPL-3
+Continue anyway? (y/n)
 
 # Max depth exceeded
-❌ Cannot create IMPL-1.2.1 (max 2 levels)
-→ Use: IMPL-2 for new main task
+Cannot create IMPL-1.2.1 (max 2 levels)
+Use: IMPL-2 for new main task
 ```
 
 ## Examples
@@ -135,7 +135,7 @@ Based on task type and title keywords:
 ```bash
 /task:create "Implement user authentication"
 
-✅ Created IMPL-1: Implement user authentication
+Created IMPL-1: Implement user authentication
 Type: feature
 Agent: code-developer
 Status: pending
@@ -145,14 +145,8 @@ Status: pending
 ```bash
 /task:create "Fix login validation bug" --type=bugfix
 
-✅ Created IMPL-2: Fix login validation bug
+Created IMPL-2: Fix login validation bug
 Type: bugfix
 Agent: code-developer
 Status: pending
-```
-
-## Related Commands
-
-- `/task:breakdown` - Break into subtasks
-- `/task:execute` - Execute with agent
-- `/context` - View task details
+```

.claude/commands/task/execute.md

@@ -1,15 +1,15 @@
 ---
 name: execute
-description: Execute tasks with appropriate agents and context-aware orchestration
+description: Execute task JSON using appropriate agent (@doc-generator/@implementation-agent/@test-agent) with pre-analysis context loading and status tracking
 argument-hint: "task-id"
 ---
 
-### 🚀 **Command Overview: `/task:execute`**
+## Command Overview: /task:execute
 
--   **Purpose**: Executes tasks using intelligent agent selection, context preparation, and progress tracking.
--   **Core Principles**: @~/.claude/workflows/workflow-architecture.md
+**Purpose**: Executes tasks using intelligent agent selection, context preparation, and progress tracking.
 
-### ⚙️ **Execution Modes**
+
+## Execution Modes
 
 -   **auto (Default)**
     -   Fully autonomous execution with automatic agent selection.
@@ -19,10 +19,10 @@ argument-hint: "task-id"
     -   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 `@general-purpose`.
+    -   Optional manual review using `@universal-executor`.
     -   Used only when explicitly requested by user.
 
-### 🤖 **Agent Selection Logic**
+## Agent Selection Logic
 
 The system determines the appropriate agent for a task using the following logic.
 
@@ -45,18 +45,18 @@ FUNCTION select_agent(task, agent_override):
             WHEN CONTAINS "Execute tests", "Fix tests", "Validate":
                 RETURN "@test-fix-agent" // type: test-fix
             WHEN CONTAINS "Review code":
-                RETURN "@general-purpose" // Optional manual review
+                RETURN "@universal-executor" // Optional manual review
             DEFAULT:
                 RETURN "@code-developer" // Default agent
         END CASE
 END FUNCTION
 ```
 
-### 🔄 **Core Execution Protocol**
+## Core Execution Protocol
 
-`Pre-Execution` **->** `Execution` **->** `Post-Execution`
+`Pre-Execution` -> `Execution` -> `Post-Execution`
 
-### ✅ **Pre-Execution Protocol**
+### Pre-Execution Protocol
 
 `Validate Task & Dependencies` **->** `Prepare Execution Context` **->** `Coordinate with TodoWrite`
 
@@ -65,7 +65,7 @@ END FUNCTION
 -   **Session Context Injection**: Provides workflow directory paths to agents for TODO_LIST.md and summary management.
 -   **TodoWrite Coordination**: Generates execution Todos and checkpoints, syncing with `TODO_LIST.md`.
 
-### 🏁 **Post-Execution Protocol**
+### Post-Execution Protocol
 
 `Update Task Status` **->** `Generate Summary` **->** `Save Artifacts` **->** `Sync All Progress` **->** `Validate File Integrity`
 
@@ -73,7 +73,7 @@ END FUNCTION
 -   Creates a summary in `.summaries/`.
 -   Stores outputs and syncs progress across the entire workflow session.
 
-### 🧠 **Task & Subtask Execution Logic**
+### Task & Subtask Execution Logic
 
 This logic defines how single, multiple, or parent tasks are handled.
 
@@ -99,7 +99,7 @@ FUNCTION execute_task_command(task_id, mode, parallel_flag):
 END FUNCTION
 ```
 
-### 🛡️ **Error Handling & Recovery Logic**
+### Error Handling & Recovery Logic
 
 ```pseudo
 FUNCTION pre_execution_check(task):
@@ -124,7 +124,7 @@ END FUNCTION
 ```
 
 
-### 📄 **Simplified Context Structure (JSON)**
+### Simplified Context Structure (JSON)
 
 This is the simplified data structure loaded to provide context for task execution.
 
@@ -189,7 +189,7 @@ This is the simplified data structure loaded to provide context for task executi
       "pre_analysis": [
         {
           "action": "analyze patterns",
-          "template": "~/.claude/workflows/cli-templates/prompts/analysis/pattern.txt",
+          "template": "~/.claude/workflows/cli-templates/prompts/analysis/02-analyze-code-patterns.txt",
           "method": "gemini"
         }
       ]
@@ -199,10 +199,10 @@ This is the simplified data structure loaded to provide context for task executi
     "session": "WFS-user-auth",
     "phase": "IMPLEMENT",
     "session_context": {
-      "workflow_directory": ".workflow/WFS-user-auth/",
-      "todo_list_location": ".workflow/WFS-user-auth/TODO_LIST.md",
-      "summaries_directory": ".workflow/WFS-user-auth/.summaries/",
-      "task_json_location": ".workflow/WFS-user-auth/.task/"
+      "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": {
@@ -213,7 +213,7 @@ This is the simplified data structure loaded to provide context for task executi
 }
 ```
 
-### 🎯 **Agent-Specific Context**
+### Agent-Specific Context
 
 Different agents receive context tailored to their function, including implementation details:
 
@@ -236,20 +236,20 @@ Different agents receive context tailored to their function, including implement
 - Error conditions to validate from implementation.context_notes.error_handling
 - Performance requirements from implementation.context_notes.performance_considerations
 
-**`@general-purpose`**:
+**`@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**
+### Simplified File Output
 
 -   **Task JSON File (`.task/<task-id>.json`)**: Updated with status and last attempt time only.
 -   **Session File (`workflow-session.json`)**: Updated task stats (completed count).
 -   **Summary File**: Generated in `.summaries/` upon completion (optional).
 
-### 📝 **Simplified Summary Template**
+### Simplified Summary Template
 
 Optional summary file generated at `.summaries/IMPL-[task-id]-summary.md`.
 

.claude/commands/task/replan.md

@@ -1,12 +1,20 @@
 ---
 name: replan
-description: Replan individual tasks with detailed user input and change tracking
+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.
 
@@ -14,9 +22,6 @@ Replans individual tasks or batch processes multiple tasks with change tracking
 - **Single Task Mode**: Replan one task with specific changes
 - **Batch Mode**: Process multiple tasks from action-plan verification report
 
-## Core Principles
-**Task System:** @~/.claude/workflows/task-core.md
-
 ## Key Features
 - **Single/Batch Operations**: Single task or multiple tasks from verification report
 - **Multiple Input Sources**: Text, files, or verification report
@@ -24,7 +29,7 @@ Replans individual tasks or batch processes multiple tasks with change tracking
 - **Change Documentation**: Track all modifications
 - **Progress Tracking**: TodoWrite integration for batch operations
 
-⚠️ **CRITICAL**: Validates active session before replanning
+**CRITICAL**: Validates active session before replanning
 
 ## Operation Modes
 
@@ -189,7 +194,7 @@ AskUserQuestion({
 
 User selected: "Yes, rollback"
 
-✅ Task rolled back to version 1.1
+Task rolled back to version 1.1
 ```
 
 ## Batch Processing with TodoWrite
@@ -201,7 +206,7 @@ When processing multiple tasks, automatically creates TodoWrite task list:
 **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-004: Add FR-09 response surface explicit coverage
 - [ ] IMPL-008: Add NFR performance validation steps
 ```
 
@@ -255,9 +260,9 @@ AskUserQuestion({
 
 User selected: "Yes, apply"
 
-✓ Version 1.2 created
-✓ Context updated
-✓ Backup saved to .task/backup/IMPL-1-v1.1.json
+Version 1.2 created
+Context updated
+Backup saved to .task/backup/IMPL-1-v1.1.json
 ```
 
 ### Single Task - File Input
@@ -267,14 +272,14 @@ User selected: "Yes, apply"
 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
+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/WFS-{session}/.process/ACTION_PLAN_VERIFICATION.md
+/task:replan --batch .workflow/active/WFS-{session}/.process/ACTION_PLAN_VERIFICATION.md
 
 Parsing verification report...
 Found 4 tasks requiring replanning:
@@ -286,23 +291,23 @@ Found 4 tasks requiring replanning:
 Creating task tracking list...
 
 Processing IMPL-002...
-✓ Backup created: .task/backup/IMPL-002-v1.0.json
-✓ Updated to v1.1
+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
+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
+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
+Backup created: .task/backup/IMPL-008-v1.0.json
+Updated to v1.1
 
-✅ Batch replan completed: 4/4 successful
-📋 Summary report saved
+Batch replan completed: 4/4 successful
+Summary report saved
 ```
 
 ### Batch Mode - Auto-detection
@@ -320,35 +325,35 @@ Entering batch mode...
 ### Single Task Errors
 ```bash
 # Task not found
-❌ Task IMPL-5 not found
-→ Check task ID with /workflow:status
+Task IMPL-5 not found
+Check task ID with /workflow:status
 
 # Task completed
-⚠️ Task IMPL-1 is completed (cannot replan)
-→ Create new task for additional work
+Task IMPL-1 is completed (cannot replan)
+Create new task for additional work
 
 # File not found
-❌ File requirements.md not found
-→ Check file path
+File requirements.md not found
+Check file path
 
 # No input provided
-❌ Please specify changes needed
-→ Provide text, file, or verification report
+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
+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
+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
+Verification report contains no replan recommendations
+Check report content or use /workflow:action-plan-verify first
 ```
 
 ## Batch Mode Integration
@@ -429,16 +434,4 @@ TodoWrite({
 TodoWrite({
   todos: updateTaskStatus(taskId, "completed")
 });
-```
-
-## Related Commands
-
-- `/workflow:status` - View task structure and versions
-- `/workflow:action-plan-verify` - Generate verification report for batch mode
-- `/task:execute` - Execute replanned task
-- `/task:create` - Create new tasks
-- `/task:breakdown` - Break down complex tasks
-
-## Context
-
-$ARGUMENTS
+```

.claude/commands/version.md

@@ -1,6 +1,6 @@
 ---
 name: version
-description: Display version information and check for updates
+description: Display Claude Code version information and check for updates
 allowed-tools: Bash(*)
 ---
 
@@ -152,12 +152,12 @@ bash(printf "%s\n%s" "3.2.1" "3.2.2" | sort -V | tail -n 1)
 
 **Scenario 1: Up to date**
 ```
-✅ You are on the latest stable version (3.2.1)
+You are on the latest stable version (3.2.1)
 ```
 
 **Scenario 2: Upgrade available**
 ```
-⬆️ A newer stable version is available: v3.2.2
+A newer stable version is available: v3.2.2
 Your version: 3.2.1
 
 To upgrade:
@@ -167,7 +167,7 @@ Bash: bash <(curl -fsSL https://raw.githubusercontent.com/catlog22/Claude-Code-W
 
 **Scenario 3: Development version**
 ```
-✨ You are running a development version (3.4.0-dev)
+You are running a development version (3.4.0-dev)
 This is newer than the latest stable release (v3.3.0)
 ```
 
@@ -252,7 +252,3 @@ ERROR: version.json is invalid or corrupted
 
 ### Timeout Configuration
 All network calls should use `timeout: 30000` (30 seconds) to handle slow connections.
-
-## Related Commands
-- `/cli:cli-init` - Initialize CLI configurations
-- `/workflow:session:list` - List workflow sessions

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

@@ -1,6 +1,6 @@
 ---
 name: action-plan-verify
-description: Perform non-destructive cross-artifact consistency and quality analysis of IMPL_PLAN.md and task.json before execution
+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(*)
 ---
@@ -15,13 +15,13 @@ 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 (`synthesis-specification.md`) before implementation. This command MUST run only after `/workflow:plan` has successfully produced complete `IMPL_PLAN.md` and task JSON files.
+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 `synthesis-specification.md` 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.
+**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
 
@@ -32,26 +32,32 @@ Identify inconsistencies, duplications, ambiguities, and underspecified items be
 IF --session parameter provided:
     session_id = provided session
 ELSE:
-    CHECK: .workflow/.active-* marker files
-    IF active_session EXISTS:
-        session_id = get_active_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/WFS-{session}
+session_dir = .workflow/active/WFS-{session}
 brainstorm_dir = session_dir/.brainstorming
 task_dir = session_dir/.task
 
 # Validate required artifacts
-SYNTHESIS = brainstorm_dir/synthesis-specification.md
+# 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
-IF NOT EXISTS(SYNTHESIS):
-    ERROR: "synthesis-specification.md not found. Run /workflow:brainstorm:synthesis first"
+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):
@@ -72,7 +78,7 @@ Load only minimal necessary context from each artifact:
 - User's stated goals and objectives
 - User's scope definition
 
-**From synthesis-specification.md**:
+**From role analysis documents**:
 - Functional Requirements (IDs, descriptions, acceptance criteria)
 - Non-Functional Requirements (IDs, targets)
 - Business Requirements (IDs, success metrics)
@@ -95,7 +101,7 @@ Load only minimal necessary context from each artifact:
 - Dependencies (depends_on, blocks)
 - Context (requirements, focus_paths, acceptance, artifacts)
 - Flow control (pre_analysis, implementation_approach)
-- Meta (complexity, priority, use_codex)
+- Meta (complexity, priority)
 
 ### 3. Build Semantic Models
 
@@ -135,27 +141,27 @@ Focus on high-signal findings. Limit to 50 findings total; aggregate remainder i
 - **Unmapped Tasks**: Tasks with no clear requirement linkage
 - **NFR Coverage Gaps**: Non-functional requirements (performance, security, scalability) not reflected in tasks
 
-#### B. Consistency Validation
+#### 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
 
-#### C. Dependency Integrity
+#### 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
 
-#### D. Synthesis Alignment
+#### 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
 
-#### E. Task Specification Quality
+#### F. Task Specification Quality
 
 - **Ambiguous Focus Paths**: Tasks with vague or missing focus_paths
 - **Underspecified Acceptance**: Tasks without clear acceptance criteria
@@ -163,12 +169,12 @@ Focus on high-signal findings. Limit to 50 findings total; aggregate remainder i
 - **Weak Flow Control**: Tasks without clear implementation_approach or pre_analysis steps
 - **Missing Target Files**: Tasks without flow_control.target_files specification
 
-#### F. Duplication Detection
+#### G. Duplication Detection
 
 - **Overlapping Task Scope**: Multiple tasks with nearly identical descriptions
 - **Redundant Requirements Coverage**: Same requirement covered by multiple tasks without clear partitioning
 
-#### G. Feasibility Assessment
+#### H. Feasibility Assessment
 
 - **Complexity Misalignment**: Task marked "simple" but requires multiple file modifications
 - **Resource Conflicts**: Parallel tasks requiring same resources/files
@@ -203,21 +209,27 @@ Use this heuristic to prioritize findings:
 
 ### 6. Produce Compact Analysis Report
 
-Output a Markdown report (no file writes) with the following structure:
+**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**: synthesis-specification.md, IMPL_PLAN.md, {N} task files
+**Artifacts Analyzed**: role analysis documents, IMPL_PLAN.md, {N} task files
 
 ---
 
 ### Executive Summary
 
 - **Overall Risk Level**: CRITICAL | HIGH | MEDIUM | LOW
-- **Recommendation**: BLOCK_EXECUTION | PROCEED_WITH_FIXES | PROCEED_WITH_CAUTION | PROCEED
+- **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}
@@ -242,10 +254,10 @@ Output a Markdown report (no file writes) with the following structure:
 
 | 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** |
+| 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)
@@ -264,7 +276,7 @@ Output a Markdown report (no file writes) with the following structure:
 
 ### Dependency Graph Issues
 
-**Circular Dependencies**: None detected ✅
+**Circular Dependencies**: None detected
 
 **Broken Dependencies**:
 - IMPL-2.3 depends on "IMPL-2.4" (non-existent)
@@ -322,61 +334,114 @@ Output a Markdown report (no file writes) with the following structure:
 
 #### Action Recommendations
 
-**If CRITICAL Issues Exist**:
-- ❌ **BLOCK EXECUTION** - Resolve critical issues before proceeding
-- Use `/task:create` for missing requirements coverage
-- Fix broken dependencies and circular references
+**Recommendation Decision Matrix**:
 
-**If Only HIGH/MEDIUM/LOW Issues**:
-- ⚠️ **PROCEED WITH CAUTION** - Fix high-priority issues first
-- Use batch replan mode to apply all task improvements systematically
+| 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 |
 
-#### Batch Remediation
+**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
 
-**Report Location**: `.workflow/WFS-{session}/.process/ACTION_PLAN_VERIFICATION.md`
+**If HIGH Issues Exist** (PROCEED_WITH_FIXES):
+- Fix high-priority issues before execution
+- Use TodoWrite to systematically track and complete improvements
 
-**Apply All Task Improvements** (Recommended):
-```bash
-# Batch process all task replan recommendations
-/task:replan --batch .workflow/WFS-{session}/.process/ACTION_PLAN_VERIFICATION.md
+**If Only MEDIUM/LOW Issues** (PROCEED_WITH_CAUTION / PROCEED):
+- Can proceed with execution
+- Address issues during or after implementation
 
-# Or with auto-confirmation (no prompts)
-/task:replan --batch ACTION_PLAN_VERIFICATION.md --auto-confirm
-```
+#### TodoWrite-Based Remediation Workflow
 
-**Manual Selective Fixes**:
-```bash
-# Fix critical coverage gaps first
-/task:create "Implement user authentication (FR-03)"
-/task:create "Add performance optimization (NFR-01)"
+**Report Location**: `.workflow/active/WFS-{session}/.process/ACTION_PLAN_VERIFICATION.md`
 
-# Then apply task refinements individually
-/task:replan IMPL-1.2 "Add context.artifacts and target_files"
+**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**:
-- Batch mode extracts all `/task:replan` commands from report
-- Processes by priority: CRITICAL → HIGH → MEDIUM → LOW
-- Creates TodoWrite tracking for all modifications
+- 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 Provide Remediation Options
+### 7. Save Report and Execute TodoWrite-Based Remediation
 
-**Save Analysis Report**:
+**Step 7.1: Save Analysis Report**:
 ```bash
-report_path = ".workflow/WFS-{session}/.process/ACTION_PLAN_VERIFICATION.md"
+report_path = ".workflow/active/WFS-{session}/.process/ACTION_PLAN_VERIFICATION.md"
 Write(report_path, full_report_content)
 ```
 
-At end of report, provide batch remediation guidance:
+**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 Options
+### 🔧 Remediation Workflow
 
-**Recommended Workflow**:
-1. **TodoWrite Tracking**: Create task list for all fixes
-2. **Agent-Based Fixes**: Call action-planning-agent to regenerate task files
-3. **User Confirmation**: Wait for approval before executing fixes
+**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
 
-**Note**: All fixes require explicit user confirmation.
+**TodoWrite Execution Pattern**:
+```bash
+# Step 1: Create task list from verification report
+TodoWrite([
+  { content: "Fix FR-03 coverage gap - add authentication task", status: "pending", activeForm: "Fixing FR-03 coverage gap" },
+  { content: "Fix IMPL-1.2 consistency - align with ADR-02", status: "pending", activeForm: "Fixing IMPL-1.2 consistency" },
+  { content: "Add context.artifacts to IMPL-1.2", status: "pending", activeForm: "Adding context.artifacts to IMPL-1.2" },
+  # ... additional todos for each finding
+])
+
+# Step 2: Process each todo systematically
+# Mark as in_progress when starting
+# Apply fix using Read/Edit tools
+# Mark as completed when done
+# Move to next priority item
+```
+
+**File Modification Workflow**:
+```bash
+# For task JSON modifications:
+1. Read(.workflow/active/WFS-{session}/.task/IMPL-X.Y.json)
+2. Edit() to apply fixes
+3. Mark todo as completed
+
+# For IMPL_PLAN modifications:
+1. Read(.workflow/active/WFS-{session}/IMPL_PLAN.md)
+2. Edit() to apply strategic changes
+3. Mark todo as completed
+```
+
+**Note**: All fixes execute immediately after user confirmation without additional commands.

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

@@ -1,6 +1,6 @@
 ---
 name: api-designer
-description: Generate or update api-designer/analysis.md addressing topic-framework discussion points
+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(*)
 ---
@@ -8,10 +8,10 @@ allowed-tools: Task(conceptual-planning-agent), TodoWrite(*), Read(*), Write(*)
 ## 🔌 **API Designer Analysis Generator**
 
 ### Purpose
-**Specialized command for generating api-designer/analysis.md** that addresses topic-framework.md discussion points from backend API design perspective. Creates or updates role-specific analysis with framework references.
+**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 topic-framework.md
+- **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
@@ -46,12 +46,12 @@ allowed-tools: Task(conceptual-planning-agent), TodoWrite(*), Read(*), Write(*)
 ### Phase 1: Session & Framework Detection
 ```bash
 # Check active session and framework
-CHECK: .workflow/.active-* marker files
+CHECK: find .workflow/active/ -name "WFS-*" -type d
 IF active_session EXISTS:
     session_id = get_active_session()
-    brainstorm_dir = .workflow/WFS-{session}/.brainstorming/
+    brainstorm_dir = .workflow/active/WFS-{session}/.brainstorming/
 
-    CHECK: brainstorm_dir/topic-framework.md
+    CHECK: brainstorm_dir/guidance-specification.md
     IF EXISTS:
         framework_mode = true
         load_framework = true
@@ -78,20 +78,21 @@ ELSE:
 ```
 
 ### Phase 3: Agent Task Generation
-**Framework-Based Analysis** (when topic-framework.md exists):
+**Framework-Based Analysis** (when guidance-specification.md exists):
 ```bash
 Task(subagent_type="conceptual-planning-agent",
+     run_in_background=false,
      prompt="Generate API designer analysis addressing topic framework
 
      ## Framework Integration Required
-     **MANDATORY**: Load and address topic-framework.md discussion points
-     **Framework Reference**: @{session.brainstorm_dir}/topic-framework.md
+     **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 topic-framework.md completely
+     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 @../topic-framework.md
+     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
 
@@ -106,7 +107,7 @@ Task(subagent_type="conceptual-planning-agent",
      ```markdown
      # API Designer Analysis: [Topic]
 
-     **Framework Reference**: @../topic-framework.md
+     **Framework Reference**: @../guidance-specification.md
      **Role Focus**: Backend API Design and Contract Definition
 
      ## Core Requirements Analysis
@@ -136,18 +137,19 @@ Task(subagent_type="conceptual-planning-agent",
 # For existing analysis updates
 IF update_mode = "incremental":
     Task(subagent_type="conceptual-planning-agent",
+         run_in_background=false,
          prompt="Update existing API designer analysis
 
          ## Current Analysis Context
          **Existing Analysis**: @{session.brainstorm_dir}/api-designer/analysis.md
-         **Framework Reference**: @{session.brainstorm_dir}/topic-framework.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 @../topic-framework.md reference
+         5. **Maintain References**: Keep @../guidance-specification.md reference
 
          ## Update Instructions
          - Read existing analysis completely
@@ -162,15 +164,15 @@ IF update_mode = "incremental":
 
 ### Output Files
 ```
-.workflow/WFS-[topic]/.brainstorming/
-├── topic-framework.md          # Input: Framework (if exists)
+.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**: @../topic-framework.md (if framework exists)
+- **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
@@ -181,7 +183,7 @@ IF update_mode = "incremental":
 Session detection and selection:
 ```bash
 # Check for active sessions
-active_sessions=$(find .workflow -name ".active-*" 2>/dev/null)
+active_sessions=$(find .workflow/active/ -name "WFS-*" -type d 2>/dev/null)
 if [ multiple_sessions ]; then
   prompt_user_to_select_session()
 else
@@ -280,7 +282,7 @@ TodoWrite tracking for two-step process:
 
 ### Output Location
 ```
-.workflow/WFS-{topic-slug}/.brainstorming/api-designer/
+.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
@@ -531,7 +533,7 @@ Upon completion, update `workflow-session.json`:
       "api_designer": {
         "status": "completed",
         "completed_at": "timestamp",
-        "output_directory": ".workflow/WFS-{topic}/.brainstorming/api-designer/",
+        "output_directory": ".workflow/active/WFS-{topic}/.brainstorming/api-designer/",
         "key_insights": ["endpoint_design", "versioning_strategy", "data_contracts"]
       }
     }

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

@@ -1,373 +1,453 @@
 ---
 name: artifacts
-description: Generate role-specific topic-framework.md dynamically based on selected roles
-argument-hint: "topic or challenge description for framework generation"
-allowed-tools: TodoWrite(*), Read(*), Write(*), Bash(*), Glob(*)
+description: Interactive clarification generating confirmed guidance specification through role-based analysis and synthesis
+argument-hint: "topic or challenge description [--count N]"
+allowed-tools: TodoWrite(*), Read(*), Write(*), Glob(*), AskUserQuestion(*)
 ---
 
-# Topic Framework Generator Command
+## Overview
 
-## Usage
-```bash
-/workflow:brainstorm:artifacts "<topic>" [--roles "role1,role2,role3"]
-```
+Seven-phase workflow: **Context collection** → **Topic analysis** → **Role selection** → **Role questions** → **Conflict resolution** → **Final check** → **Generate specification**
 
-**Recommended Structured Format**:
-```bash
-/workflow:brainstorm:artifacts "GOAL: [objective] SCOPE: [boundaries] CONTEXT: [background]" [--roles "..."]
-```
+All user interactions use AskUserQuestion tool (max 4 questions per call, multi-round).
 
-## Purpose
-**Generate dynamic topic-framework.md tailored to selected roles**. Creates role-specific discussion frameworks that address relevant perspectives. If no roles specified, generates comprehensive framework covering common analysis areas.
+**Input**: `"GOAL: [objective] SCOPE: [boundaries] CONTEXT: [background]" [--count N]`
+**Output**: `.workflow/active/WFS-{topic}/.brainstorming/guidance-specification.md`
+**Core Principle**: Questions dynamically generated from project context + topic keywords, NOT generic templates
 
-**⚠️ User Intent Preservation**: Topic description is stored in session metadata and serves as authoritative reference throughout workflow lifecycle.
-
-## Role-Based Framework Generation
-
-**Dynamic Generation**: Framework content adapts based on selected roles
-- **With roles**: Generate targeted discussion points for specified roles only
-- **Without roles**: Generate comprehensive framework covering all common areas
-
-## Core Workflow
-
-### Topic Framework Generation Process
-
-**Phase 1: Session Management** ⚠️ FIRST STEP
-- **Active session detection**: Check `.workflow/.active-*` markers
-- **Session selection**: Prompt user if multiple active sessions found
-- **Auto-creation**: Create `WFS-[topic-slug]` only if no active session exists
-- **Framework check**: Check if `topic-framework.md` exists (update vs create mode)
-
-**Phase 2: Role Analysis** ⚠️ NEW
-- **Parse roles parameter**: Extract roles from `--roles "role1,role2,role3"` if provided
-- **Role validation**: Verify each role is valid (matches available role commands)
-- **Store role list**: Save selected roles to session metadata for reference
-- **Default behavior**: If no roles specified, use comprehensive coverage
-
-**Phase 3: Dynamic Topic Analysis**
-- **Scope definition**: Define topic boundaries and objectives
-- **Stakeholder identification**: Identify key users and stakeholders based on selected roles
-- **Requirements gathering**: Extract requirements relevant to selected roles
-- **Context collection**: Gather context appropriate for role perspectives
-
-**Phase 4: Role-Specific Framework Generation**
-- **Discussion points creation**: Generate 3-5 discussion areas **tailored to selected roles**
-- **Role-targeted questions**: Create questions specifically for chosen roles
-- **Framework document**: Generate `topic-framework.md` with role-specific sections
-- **Validation check**: Ensure framework addresses all selected role perspectives
-
-**Phase 5: Metadata Storage**
-- **Save role assignment**: Store selected roles in session metadata
-- **Framework versioning**: Track which roles framework addresses
-- **Update tracking**: Maintain role evolution if framework updated
-
-## Implementation Standards
-
-### Discussion-Driven Analysis
-**Interactive Approach**: Direct conversation and exploration without predefined role constraints
-
-**Process Flow**:
-1. **Topic introduction**: Understanding scope and context
-2. **Exploratory questioning**: Open-ended investigation
-3. **Component identification**: Breaking down into manageable pieces
-4. **Relationship analysis**: Understanding connections and dependencies
-5. **Documentation generation**: Structured capture of insights
-
-**Key Areas of Investigation**:
-- **Functional aspects**: What the topic needs to accomplish
-- **Technical considerations**: Implementation constraints and requirements
-- **User perspectives**: How different stakeholders are affected
-- **Business implications**: Cost, timeline, and strategic considerations
-- **Risk assessment**: Potential challenges and mitigation strategies
-
-### Document Generation Standards
-
-**Always Created**:
-- **discussion-summary.md**: Main conversation points and key insights
-- **component-analysis.md**: Detailed breakdown of topic components
-
-## Document Generation
-
-**Primary Output**: Single structured `topic-framework.md` document
-
-**Document Structure**:
-```
-.workflow/WFS-[topic]/.brainstorming/
-└── topic-framework.md          # ★ STRUCTURED FRAMEWORK DOCUMENT
-```
-
-**Note**: `workflow-session.json` is located at `.workflow/WFS-[topic]/workflow-session.json` (session root), not inside `.brainstorming/`.
-
-## Framework Template Structures
-
-### Dynamic Role-Based Framework
-
-Framework content adapts based on `--roles` parameter:
-
-#### Option 1: Specific Roles Provided
-```markdown
-# [Topic] - Discussion Framework
-
-## Topic Overview
-- **Scope**: [Topic boundaries relevant to selected roles]
-- **Objectives**: [Goals from perspective of selected roles]
-- **Context**: [Background focusing on role-specific concerns]
-- **Target Roles**: ui-designer, system-architect, subject-matter-expert
-
-## Role-Specific Discussion Points
-
-### For UI Designer
-1. **User Interface Requirements**
-   - What interface components are needed?
-   - What user interactions must be supported?
-   - What visual design considerations apply?
-
-2. **User Experience Challenges**
-   - What are the key user journeys?
-   - What accessibility requirements exist?
-   - How to balance aesthetics with functionality?
-
-### For System Architect
-1. **Architecture Decisions**
-   - What architectural patterns fit this solution?
-   - What scalability requirements exist?
-   - How does this integrate with existing systems?
-
-2. **Technical Implementation**
-   - What technology stack is appropriate?
-   - What are the performance requirements?
-   - What dependencies must be managed?
-
-### For Subject Matter Expert
-1. **Domain Expertise & Standards**
-   - What industry standards and best practices apply?
-   - What regulatory compliance requirements exist?
-   - What domain-specific patterns should be followed?
-
-2. **Technical Quality & Risk**
-   - What technical debt considerations exist?
-   - What scalability and maintenance implications apply?
-   - What knowledge transfer and documentation is needed?
-
-## Cross-Role Integration Points
-- How do UI decisions impact architecture?
-- How does architecture constrain UI possibilities?
-- What domain standards affect both UI and architecture?
-
-## Framework Usage
-**For Role Agents**: Address your specific section + integration points
-**Reference Format**: @../topic-framework.md in your analysis.md
-**Update Process**: Use /workflow:brainstorm:artifacts to update
+**Parameters**:
+- `topic` (required): Topic or challenge description (structured format recommended)
+- `--count N` (optional): Number of roles to select (system recommends N+2 options, default: 3)
 
 ---
-*Generated for roles: ui-designer, system-architect, subject-matter-expert*
-*Last updated: [timestamp]*
-```
 
-#### Option 2: No Roles Specified (Comprehensive)
-```markdown
-# [Topic] - Discussion Framework
+## Quick Reference
 
-## Topic Overview
-- **Scope**: [Comprehensive topic boundaries]
-- **Objectives**: [All-encompassing goals]
-- **Context**: [Full background and constraints]
-- **Stakeholders**: [All relevant parties]
+### Phase Summary
 
-## Core Discussion Areas
+| 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 |
 
-### 1. Requirements & Objectives
-- What are the fundamental requirements?
-- What are the critical success factors?
-- What constraints must be considered?
+### AskUserQuestion Pattern
 
-### 2. Technical & Architecture
-- What are the technical challenges?
-- What architectural decisions are needed?
-- What integration points exist?
-
-### 3. User Experience & Design
-- Who are the primary users?
-- What are the key user journeys?
-- What usability requirements exist?
-
-### 4. Security & Compliance
-- What security requirements exist?
-- What compliance considerations apply?
-- What data protection is needed?
-
-### 5. Implementation & Operations
-- What are the implementation risks?
-- What resources are required?
-- How will this be maintained?
-
-## Available Role Perspectives
-Framework supports analysis from any of these roles:
-- **Technical**: system-architect, data-architect, subject-matter-expert
-- **Product & Design**: ui-designer, ux-expert, product-manager, product-owner
-- **Agile & Quality**: scrum-master, test-strategist
-
----
-*Comprehensive framework - adaptable to any role*
-*Last updated: [timestamp]*
-```
-
-## Role-Specific Content Generation
-
-### Available Roles and Their Focus Areas
-
-**Technical Roles**:
-- `system-architect`: Architecture patterns, scalability, technology stack, integration
-- `data-architect`: Data modeling, processing workflows, analytics, storage
-- `subject-matter-expert`: Domain expertise, industry standards, compliance, best practices
-
-**Product & Design Roles**:
-- `ui-designer`: User interface, visual design, interaction patterns, accessibility
-- `ux-expert`: User experience optimization, usability testing, interaction design, design systems
-- `product-manager`: Business value, feature prioritization, market positioning, roadmap
-- `product-owner`: Backlog management, user stories, acceptance criteria, stakeholder alignment
-
-**Agile & Quality Roles**:
-- `scrum-master`: Sprint planning, team dynamics, process optimization, delivery management
-- `test-strategist`: Testing strategies, quality assurance, test automation, validation approaches
-
-### Dynamic Discussion Point Generation
-
-**For each selected role, generate**:
-1. **2-3 core discussion areas** specific to that role's perspective
-2. **3-5 targeted questions** per discussion area
-3. **Cross-role integration points** showing how roles interact
-
-**Example mapping**:
 ```javascript
-// If roles = ["ui-designer", "system-architect"]
-Generate:
-- UI Designer section: UI Requirements, UX Challenges
-- System Architect section: Architecture Decisions, Technical Implementation
-- Integration Points: UI↔Architecture dependencies
+// 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 */]
+  }]
+})
 ```
 
-### Framework Generation Examples
+### Multi-Round Execution
 
-#### Example 1: Architecture-Heavy Topic
-```bash
-/workflow:brainstorm:artifacts "Design scalable microservices platform" --roles "system-architect,data-architect,subject-matter-expert"
+```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
+}
 ```
-**Generated framework focuses on**:
-- Service architecture and communication patterns
-- Data flow and storage strategies
-- Domain standards and best practices
 
-#### Example 2: User-Focused Topic
-```bash
-/workflow:brainstorm:artifacts "Improve user onboarding experience" --roles "ui-designer,ux-expert,product-manager"
+---
+
+## Task Tracking
+
+**TodoWrite Rule**: EXTEND auto-parallel's task list (NOT replace/overwrite)
+
+**When called from auto-parallel**:
+- Find artifacts parent task → Mark "in_progress"
+- APPEND sub-tasks (Phase 0-5) → Mark each as completes
+- When Phase 5 completes → Mark parent "completed"
+- PRESERVE all other auto-parallel tasks
+
+**Standalone Mode**:
+```json
+[
+  {"content": "Initialize session", "status": "pending", "activeForm": "Initializing"},
+  {"content": "Phase 0: Context collection", "status": "pending", "activeForm": "Phase 0"},
+  {"content": "Phase 1: Topic analysis (2-4 questions)", "status": "pending", "activeForm": "Phase 1"},
+  {"content": "Phase 2: Role selection", "status": "pending", "activeForm": "Phase 2"},
+  {"content": "Phase 3: Role questions (per role)", "status": "pending", "activeForm": "Phase 3"},
+  {"content": "Phase 4: Conflict resolution", "status": "pending", "activeForm": "Phase 4"},
+  {"content": "Phase 4.5: Final clarification", "status": "pending", "activeForm": "Phase 4.5"},
+  {"content": "Phase 5: Generate specification", "status": "pending", "activeForm": "Phase 5"}
+]
 ```
-**Generated framework focuses on**:
-- Onboarding flow and UI components
-- User experience optimization and usability
-- Business value and success metrics
 
-#### Example 3: Agile Delivery Topic
-```bash
-/workflow:brainstorm:artifacts "Optimize sprint delivery process" --roles "scrum-master,product-owner,test-strategist"
+---
+
+## Execution Phases
+
+### Session Management
+
+- Check `.workflow/active/` for existing sessions
+- Multiple → Prompt selection | Single → Use it | None → Create `WFS-[topic-slug]`
+- Parse `--count N` parameter (default: 3)
+- Store decisions in `workflow-session.json`
+
+### Phase 0: Context Collection
+
+**Goal**: Gather project context BEFORE user interaction
+
+**Steps**:
+1. Check if `context-package.json` exists → Skip if valid
+2. Invoke `context-search-agent` (BRAINSTORM MODE - lightweight)
+3. Output: `.workflow/active/WFS-{session-id}/.process/context-package.json`
+
+**Graceful Degradation**: If agent fails, continue to Phase 1 without context
+
+```javascript
+Task(
+  subagent_type="context-search-agent",
+  run_in_background=false,
+  description="Gather project context for brainstorm",
+  prompt=`
+Execute context-search-agent in BRAINSTORM MODE (Phase 1-2 only).
+
+Session: ${session_id}
+Task: ${task_description}
+Output: .workflow/${session_id}/.process/context-package.json
+
+Required fields: metadata, project_context, assets, dependencies, conflict_detection
+`
+)
 ```
-**Generated framework focuses on**:
-- Sprint planning and team collaboration
-- Backlog management and prioritization
-- Quality assurance and testing strategies
 
-#### Example 4: Comprehensive Analysis
-```bash
-/workflow:brainstorm:artifacts "Build real-time collaboration feature"
+### Phase 1: Topic Analysis
+
+**Goal**: Extract keywords/challenges enriched by Phase 0 context
+
+**Steps**:
+1. Load Phase 0 context (tech_stack, modules, conflict_risk)
+2. Deep topic analysis (entities, challenges, constraints, metrics)
+3. Generate 2-4 context-aware probing questions
+4. AskUserQuestion → Store to `session.intent_context`
+
+**Example**:
+```javascript
+AskUserQuestion({
+  questions: [
+    {
+      question: "实时协作平台的主要技术挑战？",
+      header: "核心挑战",
+      multiSelect: false,
+      options: [
+        { label: "实时数据同步", description: "100+用户同时在线，状态同步复杂度高" },
+        { label: "可扩展性架构", description: "用户规模增长时的系统扩展能力" },
+        { label: "冲突解决机制", description: "多用户同时编辑的冲突处理策略" }
+      ]
+    },
+    {
+      question: "MVP阶段最关注的指标？",
+      header: "优先级",
+      multiSelect: false,
+      options: [
+        { label: "功能完整性", description: "实现所有核心功能" },
+        { label: "用户体验", description: "流畅的交互体验和响应速度" },
+        { label: "系统稳定性", description: "高可用性和数据一致性" }
+      ]
+    }
+  ]
+})
 ```
-**Generated framework covers** all aspects (no roles specified)
 
-## Session Management ⚠️ CRITICAL
-- **⚡ FIRST ACTION**: Check for all `.workflow/.active-*` markers before processing
-- **Multiple sessions support**: Different Claude instances can have different active sessions
-- **User selection**: If multiple active sessions found, prompt user to select which one to work with
-- **Auto-session creation**: `WFS-[topic-slug]` only if no active session exists
-- **Session continuity**: MUST use selected active session for all processing
-- **Context preservation**: All discussion and analysis stored in session directory
-- **Session isolation**: Each session maintains independent state
+**⚠️ CRITICAL**: Questions MUST reference topic keywords. Generic "Project type?" violates dynamic generation.
 
-## Discussion Areas
+### Phase 2: Role Selection
 
-### Core Investigation Topics
-- **Purpose & Goals**: What are we trying to achieve?
-- **Scope & Boundaries**: What's included and excluded?
-- **Success Criteria**: How do we measure success?
-- **Constraints**: What limitations exist?
-- **Stakeholders**: Who is affected or involved?
+**Goal**: User selects roles from intelligent recommendations
 
-### Technical Considerations
-- **Requirements**: What must the solution provide?
-- **Dependencies**: What does it rely on?
-- **Integration**: How does it connect to existing systems?
-- **Performance**: What are the speed/scale requirements?
-- **Security**: What protection is needed?
+**Available Roles**: data-architect, product-manager, product-owner, scrum-master, subject-matter-expert, system-architect, test-strategist, ui-designer, ux-expert
 
-### Implementation Factors
-- **Timeline**: When is it needed?
-- **Resources**: What people/budget/tools are available?
-- **Risks**: What could go wrong?
-- **Alternatives**: What other approaches exist?
-- **Migration**: How do we transition from current state?
+**Steps**:
+1. Analyze Phase 1 keywords → Recommend count+2 roles with rationale
+2. AskUserQuestion (multiSelect=true) → Store to `session.selected_roles`
+3. If count+2 > 4, split into multiple rounds
 
-## Update Mechanism ⚠️ SMART UPDATES
+**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: "数据同步模型和存储方案设计" }
+    ]
+  }]
+})
+```
 
-### Framework Update Logic
-```bash
-# Check existing framework
-IF topic-framework.md EXISTS:
-    SHOW current framework to user
-    ASK: "Framework exists. Do you want to:"
-    OPTIONS:
-      1. "Replace completely" → Generate new framework
-      2. "Add discussion points" → Append to existing
-      3. "Refine existing points" → Interactive editing
-      4. "Cancel" → Exit without changes
+**⚠️ CRITICAL**: User MUST interact. NEVER auto-select without confirmation.
+
+### Phase 3: Role-Specific Questions
+
+**Goal**: Generate deep questions mapping role expertise to Phase 1 challenges
+
+**Algorithm**:
+1. FOR each selected role:
+   - Map Phase 1 challenges to role domain
+   - Generate 3-4 questions (implementation depth, trade-offs, edge cases)
+   - AskUserQuestion per role → Store to `session.role_decisions[role]`
+2. Process roles sequentially (one at a time for clarity)
+3. If role needs > 4 questions, split into multiple rounds
+
+**Example** (system-architect):
+```javascript
+AskUserQuestion({
+  questions: [
+    {
+      question: "100+ 用户实时状态同步方案？",
+      header: "状态同步",
+      multiSelect: false,
+      options: [
+        { label: "Event Sourcing", description: "完整事件历史，支持回溯，存储成本高" },
+        { label: "集中式状态管理", description: "实现简单，单点瓶颈风险" },
+        { label: "CRDT", description: "去中心化，自动合并，学习曲线陡" }
+      ]
+    },
+    {
+      question: "两个用户同时编辑冲突如何解决？",
+      header: "冲突解决",
+      multiSelect: false,
+      options: [
+        { label: "自动合并", description: "用户无感知，可能产生意外结果" },
+        { label: "手动解决", description: "用户控制，增加交互复杂度" },
+        { label: "版本控制", description: "保留历史，需要分支管理" }
+      ]
+    }
+  ]
+})
+```
+
+### Phase 4: Conflict Resolution
+
+**Goal**: Resolve ACTUAL conflicts from Phase 3 answers
+
+**Algorithm**:
+1. Analyze Phase 3 answers for conflicts:
+   - Contradictory choices (e.g., "fast iteration" vs "complex Event Sourcing")
+   - Missing integration (e.g., "Optimistic updates" but no conflict handling)
+   - Implicit dependencies (e.g., "Live cursors" but no auth defined)
+2. Generate clarification questions referencing SPECIFIC Phase 3 choices
+3. AskUserQuestion (max 4 per call, multi-round) → Store to `session.cross_role_decisions`
+4. If NO conflicts: Skip Phase 4 (inform user: "未检测到跨角色冲突，跳过Phase 4")
+
+**Example**:
+```javascript
+AskUserQuestion({
+  questions: [{
+    question: "CRDT 与 UI 回滚期望冲突，如何解决？\n背景：system-architect选择CRDT，ui-designer期望回滚UI",
+    header: "架构冲突",
+    multiSelect: false,
+    options: [
+      { label: "采用 CRDT", description: "保持去中心化，调整UI期望" },
+      { label: "显示合并界面", description: "增加用户交互，展示冲突详情" },
+      { label: "切换到 OT", description: "支持回滚，增加服务器复杂度" }
+    ]
+  }]
+})
+```
+
+### Phase 4.5: Final Clarification
+
+**Purpose**: Ensure no important points missed before generating specification
+
+**Steps**:
+1. Ask initial check:
+   ```javascript
+   AskUserQuestion({
+     questions: [{
+       question: "在生成最终规范之前，是否有前面未澄清的重点需要补充？",
+       header: "补充确认",
+       multiSelect: false,
+       options: [
+         { label: "无需补充", description: "前面的讨论已经足够完整" },
+         { label: "需要补充", description: "还有重要内容需要澄清" }
+       ]
+     }]
+   })
+   ```
+2. If "需要补充":
+   - Analyze user's additional points
+   - Generate progressive questions (not role-bound, interconnected)
+   - AskUserQuestion (max 4 per round) → Store to `session.additional_decisions`
+   - Repeat until user confirms completion
+3. If "无需补充": Proceed to Phase 5
+
+**Progressive Pattern**: Questions interconnected, each round informs next, continue until resolved.
+
+### Phase 5: Generate Specification
+
+**Steps**:
+1. Load all decisions: `intent_context` + `selected_roles` + `role_decisions` + `cross_role_decisions` + `additional_decisions`
+2. Transform Q&A to declarative: Questions → Headers, Answers → CONFIRMED/SELECTED statements
+3. Generate `guidance-specification.md`
+4. Update `workflow-session.json` (metadata only)
+5. Validate: No interrogative sentences, all decisions traceable
+
+---
+
+## Question Guidelines
+
+### Core Principle
+
+**Target**: 开发者（理解技术但需要从用户需求出发）
+
+**Question Structure**: `[业务场景/需求前提] + [技术关注点]`
+**Option Structure**: `标签：[技术方案] + 说明：[业务影响] + [技术权衡]`
+
+### Quality Rules
+
+**MUST Include**:
+- ✅ All questions in Chinese (用中文提问)
+- ✅ 业务场景作为问题前提
+- ✅ 技术选项的业务影响说明
+- ✅ 量化指标和约束条件
+
+**MUST Avoid**:
+- ❌ 纯技术选型无业务上下文
+- ❌ 过度抽象的用户体验问题
+- ❌ 脱离话题的通用架构问题
+
+### Phase-Specific Requirements
+
+| Phase | Focus | Key Requirements |
+|-------|-------|------------------|
+| 1 | 意图理解 | Reference topic keywords, 用户场景、业务约束、优先级 |
+| 2 | 角色推荐 | Intelligent analysis (NOT keyword mapping), explain relevance |
+| 3 | 角色问题 | Reference Phase 1 keywords, concrete options with trade-offs |
+| 4 | 冲突解决 | Reference SPECIFIC Phase 3 choices, explain impact on both roles |
+
+---
+
+## Output & Governance
+
+### Output Template
+
+**File**: `.workflow/active/WFS-{topic}/.brainstorming/guidance-specification.md`
+
+```markdown
+# [Project] - Confirmed Guidance Specification
+
+**Metadata**: [timestamp, type, focus, roles]
+
+## 1. Project Positioning & Goals
+**CONFIRMED Objectives**: [from topic + Phase 1]
+**CONFIRMED Success Criteria**: [from Phase 1 answers]
+
+## 2-N. [Role] Decisions
+### SELECTED Choices
+**[Question topic]**: [User's answer]
+- **Rationale**: [From option description]
+- **Impact**: [Implications]
+
+### Cross-Role Considerations
+**[Conflict resolved]**: [Resolution from Phase 4]
+- **Affected Roles**: [Roles involved]
+
+## Cross-Role Integration
+**CONFIRMED Integration Points**: [API/Data/Auth from multiple roles]
+
+## Risks & Constraints
+**Identified Risks**: [From answers] → Mitigation: [Approach]
+
+## Next Steps
+**⚠️ Automatic Continuation** (when called from auto-parallel):
+- auto-parallel assigns agents for role-specific analysis
+- Each selected role gets conceptual-planning-agent
+- Agents read this guidance-specification.md for context
+
+## Appendix: Decision Tracking
+| Decision ID | Category | Question | Selected | Phase | Rationale |
+|-------------|----------|----------|----------|-------|-----------|
+| D-001 | Intent | [Q] | [A] | 1 | [Why] |
+| D-002 | Roles | [Selected] | [Roles] | 2 | [Why] |
+| D-003+ | [Role] | [Q] | [A] | 3 | [Why] |
+```
+
+### File Structure
+
+```
+.workflow/active/WFS-[topic]/
+├── workflow-session.json              # Metadata ONLY
+├── .process/
+│   └── context-package.json           # Phase 0 output
+└── .brainstorming/
+    └── guidance-specification.md      # Full guidance content
+```
+
+### Session Metadata
+
+```json
+{
+  "session_id": "WFS-{topic-slug}",
+  "type": "brainstorming",
+  "topic": "{original user input}",
+  "selected_roles": ["system-architect", "ui-designer", "product-manager"],
+  "phase_completed": "artifacts",
+  "timestamp": "2025-10-24T10:30:00Z",
+  "count_parameter": 3
+}
+```
+
+**⚠️ Rule**: Session JSON stores ONLY metadata. All guidance content goes to guidance-specification.md.
+
+### Validation Checklist
+
+- ✅ No interrogative sentences (use CONFIRMED/SELECTED)
+- ✅ Every decision traceable to user answer
+- ✅ Cross-role conflicts resolved or documented
+- ✅ Next steps concrete and specific
+- ✅ No content duplication between .json and .md
+
+### Update Mechanism
+
+```
+IF guidance-specification.md EXISTS:
+  Prompt: "Regenerate completely / Update sections / Cancel"
 ELSE:
-    CREATE new framework
+  Run full Phase 0-5 flow
 ```
 
-### Update Strategies
+### Governance Rules
 
-**1. Complete Replacement**
-- Backup existing framework as `topic-framework-[timestamp].md.backup`
-- Generate completely new framework
-- Preserve role-specific analysis points from previous version
+- 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
 
-**2. Incremental Addition**
-- Load existing framework
-- Identify new discussion areas through user interaction
-- Add new sections while preserving existing structure
-- Update framework usage instructions
-
-**3. Refinement Mode**
-- Interactive editing of existing discussion points
-- Allow modification of scope, objectives, and questions
-- Preserve framework structure and role assignments
-- Update timestamp and version info
-
-### Version Control
-- **Backup Creation**: Always backup before major changes
-- **Change Tracking**: Include change summary in framework footer
-- **Rollback Support**: Keep previous version accessible
-
-## Error Handling
-- **Session creation failure**: Provide clear error message and retry option
-- **Discussion stalling**: Offer structured prompts to continue exploration
-- **Documentation issues**: Graceful handling of file creation problems
-- **Missing context**: Prompt for additional information when needed
-
-## Reference Information
-
-### File Structure Reference
-**Architecture**: @~/.claude/workflows/workflow-architecture.md
-**Session Management**: Standard workflow session protocols
-
-### Integration Points
-- **Compatible with**: Other brainstorming commands in the same session
-- **Builds foundation for**: More detailed planning and implementation phases
-- **Outputs used by**: `/workflow:brainstorm:synthesis` command for cross-analysis integration
+**CRITICAL**: Guidance is single source of truth for downstream phases. Ambiguity violates governance.

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

@@ -1,378 +1,443 @@
 ---
 name: auto-parallel
-description: Parallel brainstorming automation with dynamic role selection and concurrent execution
+description: Parallel brainstorming automation with dynamic role selection and concurrent execution across multiple perspectives
 argument-hint: "topic or challenge description" [--count N]
 allowed-tools: SlashCommand(*), Task(*), TodoWrite(*), Read(*), Write(*), Bash(*), Glob(*)
 ---
 
 # Workflow Brainstorm Parallel Auto Command
 
+## Coordinator Role
+
+**This command is a pure orchestrator**: Executes 3 phases in sequence (interactive framework → parallel role analysis → synthesis), coordinating specialized commands/agents through task attachment model.
+
+**Task Attachment Model**:
+- SlashCommand execute **expands workflow** by attaching sub-tasks to current TodoWrite
+- Task agent execute **attaches analysis tasks** to orchestrator's TodoWrite
+- Phase 1: artifacts command attaches its internal tasks (Phase 1-5)
+- Phase 2: N conceptual-planning-agent tasks attached in parallel
+- Phase 3: synthesis command attaches its internal tasks
+- Orchestrator **executes these attached tasks** sequentially (Phase 1, 3) or in parallel (Phase 2)
+- After completion, attached tasks are **collapsed** back to high-level phase summary
+- This is **task expansion**, not external delegation
+
+**Execution Model - Auto-Continue Workflow**:
+
+This workflow runs **fully autonomously** once triggered. Phase 1 (artifacts) handles user interaction, Phase 2 (role agents) runs in parallel.
+
+1. **User triggers**: `/workflow:brainstorm:auto-parallel "topic" [--count N]`
+2. **Execute Phase 1** → artifacts command (tasks ATTACHED) → Auto-continues
+3. **Execute Phase 2** → Parallel role agents (N tasks ATTACHED concurrently) → Auto-continues
+4. **Execute Phase 3** → Synthesis command (tasks ATTACHED) → Reports final summary
+
+**Auto-Continue Mechanism**:
+- TodoList tracks current phase status and dynamically manages task attachment/collapse
+- When Phase 1 (artifacts) finishes executing, automatically load roles and launch Phase 2 agents
+- When Phase 2 (all agents) finishes executing, automatically execute Phase 3 synthesis
+- **⚠️ CONTINUOUS EXECUTION** - Do not stop until all phases complete
+
+## Core Rules
+
+1. **Start Immediately**: First action is TodoWrite initialization, second action is execute Phase 1 command
+2. **No Preliminary Analysis**: Do not analyze topic before Phase 1 - artifacts handles all analysis
+3. **Parse Every Output**: Extract selected_roles from workflow-session.json after Phase 1
+4. **Auto-Continue via TodoList**: Check TodoList status to execute next pending phase automatically
+5. **Track Progress**: Update TodoWrite dynamically with task attachment/collapse pattern
+6. **Task Attachment Model**: SlashCommand and Task executes **attach** sub-tasks to current workflow. Orchestrator **executes** these attached tasks itself, then **collapses** them after completion
+7. **⚠️ CRITICAL: DO NOT STOP**: Continuous multi-phase workflow. After executing all attached tasks, immediately collapse them and execute next phase
+8. **Parallel Execution**: Phase 2 attaches multiple agent tasks simultaneously for concurrent execution
+
 ## Usage
+
 ```bash
-/workflow:brainstorm:auto-parallel "<topic>" [--count N]
+/workflow:brainstorm:auto-parallel "<topic>" [--count N] [--style-skill package-name]
 ```
 
 **Recommended Structured Format**:
 ```bash
-/workflow:brainstorm:auto-parallel "GOAL: [objective] SCOPE: [boundaries] CONTEXT: [background]" [--count N]
+/workflow:brainstorm:auto-parallel "GOAL: [objective] SCOPE: [boundaries] CONTEXT: [background]" [--count N] [--style-skill package-name]
 ```
 
 **Parameters**:
 - `topic` (required): Topic or challenge description (structured format recommended)
-- `--count N` (optional): Number of roles to auto-select (default: 3, max: 9)
+- `--count N` (optional): Number of roles to select (default: 3, max: 9)
+- `--style-skill package-name` (optional): Style SKILL package to load for UI design (located at `.claude/skills/style-{package-name}/`)
 
-**⚠️ User Intent Preservation**: Topic description is stored in session metadata as authoritative reference throughout entire brainstorming workflow and plan generation.
+## 3-Phase Execution
 
-## Role Selection Logic
-- **Technical & Architecture**: `architecture|system|performance|database|security` → system-architect, data-architect, security-expert, subject-matter-expert
-- **API & Backend**: `api|endpoint|rest|graphql|backend|interface|contract|service` → api-designer, system-architect, data-architect
-- **Product & UX**: `user|ui|ux|interface|design|product|feature|experience` → ui-designer, user-researcher, product-manager, ux-expert, product-owner
-- **Business & Process**: `business|process|workflow|cost|innovation|testing` → business-analyst, innovation-lead, test-strategist
-- **Agile & Delivery**: `agile|sprint|scrum|team|collaboration|delivery` → scrum-master, product-owner
-- **Domain Expertise**: `domain|standard|compliance|expertise|regulation` → subject-matter-expert
-- **Multi-role**: Complex topics automatically select N complementary roles (N specified by --count, default 3)
-- **Default**: `product-manager` if no clear match
-- **Count Parameter**: `--count N` determines number of roles to auto-select (default: 3, max: 9)
+### Phase 1: Interactive Framework Generation
 
-**Template Loading**: `bash($(cat "~/.claude/workflows/cli-templates/planning-roles/<role-name>.md"))`
-**Template Source**: `.claude/workflows/cli-templates/planning-roles/`
-**Available Roles**: api-designer, data-architect, product-manager, product-owner, scrum-master, subject-matter-expert, system-architect, test-strategist, ui-designer, ux-expert
+**Step 1: Execute** - Interactive framework generation via artifacts command
 
-**Example**:
-```bash
-bash($(cat "~/.claude/workflows/cli-templates/planning-roles/system-architect.md"))
-bash($(cat "~/.claude/workflows/cli-templates/planning-roles/ui-designer.md"))
+```javascript
+SlashCommand(command="/workflow:brainstorm:artifacts \"{topic}\" --count {N}")
 ```
 
-## Core Workflow
+**What It Does**:
+- Topic analysis: Extract challenges, generate task-specific questions
+- Role selection: Recommend count+2 roles, user selects via AskUserQuestion
+- Role questions: Generate 3-4 questions per role, collect user decisions
+- Conflict resolution: Detect and resolve cross-role conflicts
+- Guidance generation: Transform Q&A to declarative guidance-specification.md
 
-### Structured Topic Processing → Role Analysis → Synthesis
-The command follows a structured three-phase approach with dedicated document types:
+**Parse Output**:
+- **⚠️ Memory Check**: If `selected_roles[]` already in conversation memory from previous load, skip file read
+- Extract: `selected_roles[]` from workflow-session.json (if not in memory)
+- Extract: `session_id` from workflow-session.json (if not in memory)
+- Verify: guidance-specification.md exists
 
-**Phase 1: Framework Generation** ⚠️ COMMAND EXECUTION
-- **Role selection**: Auto-select N roles based on topic keywords and --count parameter (default: 3, see Role Selection Logic)
-- **Call artifacts command**: Execute `/workflow:brainstorm:artifacts "{topic}" --roles "{role1,role2,...,roleN}"` using SlashCommand tool
-- **Role-specific framework**: Generate framework with sections tailored to selected roles
-- **⚠️ User intent storage**: Topic saved in workflow-session.json as primary reference for all downstream phases
+**Validation**:
+- guidance-specification.md created with confirmed decisions
+- workflow-session.json contains selected_roles[] (metadata only, no content duplication)
+- Session directory `.workflow/active/WFS-{topic}/.brainstorming/` exists
 
-**Phase 2: Role Analysis Execution** ⚠️ PARALLEL AGENT ANALYSIS
-- **Parallel execution**: Multiple roles execute simultaneously for faster completion
-- **Independent agents**: Each role gets dedicated conceptual-planning-agent running in parallel
-- **Shared framework**: All roles reference the same topic framework for consistency
-- **Concurrent generation**: Role-specific analysis documents generated simultaneously
-- **Progress tracking**: Parallel agents update progress independently
+**TodoWrite Update (Phase 1 SlashCommand executed - tasks attached)**:
+```json
+[
+  {"content": "Phase 0: Parameter Parsing", "status": "completed", "activeForm": "Parsing count parameter"},
+  {"content": "Phase 1: Interactive Framework Generation", "status": "in_progress", "activeForm": "Executing artifacts interactive framework"},
+  {"content": "  → Topic analysis and question generation", "status": "in_progress", "activeForm": "Analyzing topic"},
+  {"content": "  → Role selection and user confirmation", "status": "pending", "activeForm": "Selecting roles"},
+  {"content": "  → Role questions and user decisions", "status": "pending", "activeForm": "Collecting role questions"},
+  {"content": "  → Conflict detection and resolution", "status": "pending", "activeForm": "Resolving conflicts"},
+  {"content": "  → Guidance specification generation", "status": "pending", "activeForm": "Generating guidance"},
+  {"content": "Phase 2: Parallel Role Analysis", "status": "pending", "activeForm": "Executing parallel role analysis"},
+  {"content": "Phase 3: Synthesis Integration", "status": "pending", "activeForm": "Executing synthesis integration"}
+]
+```
 
-**Phase 3: Synthesis Generation** ⚠️ COMMAND EXECUTION
-- **Call synthesis command**: Execute `/workflow:brainstorm:synthesis` using SlashCommand tool
-- **⚠️ User intent injection**: Synthesis loads original topic from session metadata as highest priority reference
-- **Intent alignment**: Synthesis validates all role insights against user's original objectives
+**Note**: SlashCommand execute **attaches** artifacts' 5 internal tasks. Orchestrator **executes** these tasks sequentially.
 
-## Implementation Standards
+**Next Action**: Tasks attached → **Execute Phase 1.1-1.5** sequentially
 
-### Simplified Command Orchestration ⚠️ STREAMLINED
-Auto command coordinates independent specialized commands:
+**TodoWrite Update (Phase 1 completed - tasks collapsed)**:
+```json
+[
+  {"content": "Phase 0: Parameter Parsing", "status": "completed", "activeForm": "Parsing count parameter"},
+  {"content": "Phase 1: Interactive Framework Generation", "status": "completed", "activeForm": "Executing artifacts interactive framework"},
+  {"content": "Phase 2: Parallel Role Analysis", "status": "pending", "activeForm": "Executing parallel role analysis"},
+  {"content": "Phase 3: Synthesis Integration", "status": "pending", "activeForm": "Executing synthesis integration"}
+]
+```
 
-**Command Sequence**:
-1. **Role Selection**: Auto-select N relevant roles based on topic keywords and --count parameter (default: 3)
-2. **Generate Role-Specific Framework**: Use SlashCommand to execute `/workflow:brainstorm:artifacts "{topic}" --roles "{role1,role2,...,roleN}"` (stores user intent in session)
-3. **Parallel Role Analysis**: Execute selected role agents in parallel, each reading their specific framework section
-4. **Generate Synthesis**: Use SlashCommand to execute `/workflow:brainstorm:synthesis` (loads user intent from session as primary reference)
+**Note**: Phase 1 tasks completed and collapsed to summary.
 
-**SlashCommand Integration**:
-1. **artifacts command**: Called via SlashCommand tool with `--roles` parameter for role-specific framework generation
-2. **role agents**: Each agent reads its dedicated section in the role-specific framework
-3. **synthesis command**: Called via SlashCommand tool for final integration with role-targeted insights
-4. **Command coordination**: SlashCommand handles execution and validation
+**After Phase 1**: Auto-continue to Phase 2 (parallel role agent execution)
 
-**Role Selection Logic**:
-- **Technical**: `architecture|system|performance|database` → system-architect, data-architect, subject-matter-expert
-- **API & Backend**: `api|endpoint|rest|graphql|backend|interface|contract|service` → api-designer, system-architect, data-architect
-- **Product & UX**: `user|ui|ux|interface|design|product|feature|experience` → ui-designer, ux-expert, product-manager, product-owner
-- **Agile & Delivery**: `agile|sprint|scrum|team|collaboration|delivery` → scrum-master, product-owner
-- **Domain Expertise**: `domain|standard|compliance|expertise|regulation` → subject-matter-expert
-- **Auto-select**: N most relevant roles based on topic analysis (N from --count parameter, default: 3)
+---
 
-### Parameter Parsing
+### Phase 2: Parallel Role Analysis Execution
 
-**Count Parameter Handling**:
+**For Each Selected Role**:
 ```bash
-# Parse --count parameter from user input
+Task(conceptual-planning-agent): "
+[FLOW_CONTROL]
+
+Execute {role-name} analysis for existing topic framework
+
+## Context Loading
+ASSIGNED_ROLE: {role-name}
+OUTPUT_LOCATION: .workflow/active/WFS-{session}/.brainstorming/{role}/
+TOPIC: {user-provided-topic}
+
+## Flow Control Steps
+1. load_topic_framework → .workflow/active/WFS-{session}/.brainstorming/guidance-specification.md
+2. load_role_template → ~/.claude/workflows/cli-templates/planning-roles/{role}.md
+3. load_session_metadata → .workflow/active/WFS-{session}/workflow-session.json
+4. load_style_skill (ui-designer only, if style_skill_package) → .claude/skills/style-{style_skill_package}/
+
+## Analysis Requirements
+**Primary Reference**: Original user prompt from workflow-session.json is authoritative
+**Framework Source**: Address all discussion points in guidance-specification.md from {role-name} perspective
+**Role Focus**: {role-name} domain expertise aligned with user intent
+**Structured Approach**: Create analysis.md addressing framework discussion points
+**Template Integration**: Apply role template guidelines within framework structure
+
+## Expected Deliverables
+1. **analysis.md** (optionally with analysis-{slug}.md sub-documents)
+2. **Framework Reference**: @../guidance-specification.md
+3. **User Intent Alignment**: Validate against session_context
+
+## Completion Criteria
+- Address each discussion point from guidance-specification.md with {role-name} expertise
+- Provide actionable recommendations from {role-name} perspective within analysis files
+- All output files MUST start with `analysis` prefix (no recommendations.md or other naming)
+- Reference framework document using @ notation for integration
+- Update workflow-session.json with completion status
+"
+```
+
+**Parallel Execute**:
+- Launch N agents simultaneously (one message with multiple Task calls)
+- Each agent task **attached** to orchestrator's TodoWrite
+- All agents execute concurrently, each attaching their own analysis sub-tasks
+- Each agent operates independently reading same guidance-specification.md
+
+**Input**:
+- `selected_roles[]` from Phase 1
+- `session_id` from Phase 1
+- guidance-specification.md path
+
+**Validation**:
+- Each role creates `.workflow/active/WFS-{topic}/.brainstorming/{role}/analysis.md`
+- Optionally with `analysis-{slug}.md` sub-documents (max 5)
+- **File pattern**: `analysis*.md` for globbing
+- **FORBIDDEN**: `recommendations.md` or any non-`analysis` prefixed files
+- All N role analyses completed
+
+**TodoWrite Update (Phase 2 agents executed - tasks attached in parallel)**:
+```json
+[
+  {"content": "Phase 0: Parameter Parsing", "status": "completed", "activeForm": "Parsing count parameter"},
+  {"content": "Phase 1: Interactive Framework Generation", "status": "completed", "activeForm": "Executing artifacts interactive framework"},
+  {"content": "Phase 2: Parallel Role Analysis", "status": "in_progress", "activeForm": "Executing parallel role analysis"},
+  {"content": "  → Execute system-architect analysis", "status": "in_progress", "activeForm": "Executing system-architect analysis"},
+  {"content": "  → Execute ui-designer analysis", "status": "in_progress", "activeForm": "Executing ui-designer analysis"},
+  {"content": "  → Execute product-manager analysis", "status": "in_progress", "activeForm": "Executing product-manager analysis"},
+  {"content": "Phase 3: Synthesis Integration", "status": "pending", "activeForm": "Executing synthesis integration"}
+]
+```
+
+**Note**: Multiple Task executes **attach** N role analysis tasks simultaneously. Orchestrator **executes** these tasks in parallel.
+
+**Next Action**: Tasks attached → **Execute Phase 2.1-2.N** concurrently
+
+**TodoWrite Update (Phase 2 completed - tasks collapsed)**:
+```json
+[
+  {"content": "Phase 0: Parameter Parsing", "status": "completed", "activeForm": "Parsing count parameter"},
+  {"content": "Phase 1: Interactive Framework Generation", "status": "completed", "activeForm": "Executing artifacts interactive framework"},
+  {"content": "Phase 2: Parallel Role Analysis", "status": "completed", "activeForm": "Executing parallel role analysis"},
+  {"content": "Phase 3: Synthesis Integration", "status": "pending", "activeForm": "Executing synthesis integration"}
+]
+```
+
+**Note**: Phase 2 parallel tasks completed and collapsed to summary.
+
+**After Phase 2**: Auto-continue to Phase 3 (synthesis)
+
+---
+
+### Phase 3: Synthesis Generation
+
+**Step 3: Execute** - Synthesis integration via synthesis command
+
+```javascript
+SlashCommand(command="/workflow:brainstorm:synthesis --session {sessionId}")
+```
+
+**What It Does**:
+- Load original user intent from workflow-session.json
+- Read all role analysis.md files
+- Integrate role insights into synthesis-specification.md
+- Validate alignment with user's original objectives
+
+**Input**: `sessionId` from Phase 1
+
+**Validation**:
+- `.workflow/active/WFS-{topic}/.brainstorming/synthesis-specification.md` exists
+- Synthesis references all role analyses
+
+**TodoWrite Update (Phase 3 SlashCommand executed - tasks attached)**:
+```json
+[
+  {"content": "Phase 0: Parameter Parsing", "status": "completed", "activeForm": "Parsing count parameter"},
+  {"content": "Phase 1: Interactive Framework Generation", "status": "completed", "activeForm": "Executing artifacts interactive framework"},
+  {"content": "Phase 2: Parallel Role Analysis", "status": "completed", "activeForm": "Executing parallel role analysis"},
+  {"content": "Phase 3: Synthesis Integration", "status": "in_progress", "activeForm": "Executing synthesis integration"},
+  {"content": "  → Load role analysis files", "status": "in_progress", "activeForm": "Loading role analyses"},
+  {"content": "  → Integrate insights across roles", "status": "pending", "activeForm": "Integrating insights"},
+  {"content": "  → Generate synthesis specification", "status": "pending", "activeForm": "Generating synthesis"}
+]
+```
+
+**Note**: SlashCommand execute **attaches** synthesis' internal tasks. Orchestrator **executes** these tasks sequentially.
+
+**Next Action**: Tasks attached → **Execute Phase 3.1-3.3** sequentially
+
+**TodoWrite Update (Phase 3 completed - tasks collapsed)**:
+```json
+[
+  {"content": "Phase 0: Parameter Parsing", "status": "completed", "activeForm": "Parsing count parameter"},
+  {"content": "Phase 1: Interactive Framework Generation", "status": "completed", "activeForm": "Executing artifacts interactive framework"},
+  {"content": "Phase 2: Parallel Role Analysis", "status": "completed", "activeForm": "Executing parallel role analysis"},
+  {"content": "Phase 3: Synthesis Integration", "status": "completed", "activeForm": "Executing synthesis integration"}
+]
+```
+
+**Note**: Phase 3 tasks completed and collapsed to summary.
+
+**Return to User**:
+```
+Brainstorming complete for session: {sessionId}
+Roles analyzed: {count}
+Synthesis: .workflow/active/WFS-{topic}/.brainstorming/synthesis-specification.md
+
+✅ Next Steps:
+1. /workflow:concept-clarify --session {sessionId}  # Optional refinement
+2. /workflow:plan --session {sessionId}  # Generate implementation plan
+```
+
+## TodoWrite Pattern
+
+**Core Concept**: Dynamic task attachment and collapse for parallel brainstorming workflow with interactive framework generation and concurrent role analysis.
+
+### Key Principles
+
+1. **Task Attachment** (when SlashCommand/Task executed):
+   - Sub-command's or agent's internal tasks are **attached** to orchestrator's TodoWrite
+   - Phase 1: `/workflow:brainstorm:artifacts` attaches 5 internal tasks (Phase 1.1-1.5)
+   - Phase 2: Multiple `Task(conceptual-planning-agent)` calls attach N role analysis tasks simultaneously
+   - Phase 3: `/workflow:brainstorm:synthesis` attaches 3 internal tasks (Phase 3.1-3.3)
+   - First attached task marked as `in_progress`, others as `pending`
+   - Orchestrator **executes** these attached tasks (sequentially for Phase 1, 3; in parallel for Phase 2)
+
+2. **Task Collapse** (after sub-tasks complete):
+   - Remove detailed sub-tasks from TodoWrite
+   - **Collapse** to high-level phase summary
+   - Example: Phase 1.1-1.5 collapse to "Execute artifacts interactive framework generation: completed"
+   - Phase 2: Multiple role tasks collapse to "Execute parallel role analysis: completed"
+   - Phase 3: Synthesis tasks collapse to "Execute synthesis integration: completed"
+   - Maintains clean orchestrator-level view
+
+3. **Continuous Execution**:
+   - After collapse, automatically proceed to next pending phase
+   - No user intervention required between phases
+   - TodoWrite dynamically reflects current execution state
+
+**Lifecycle Summary**: Initial pending tasks → Phase 1 executed (artifacts tasks ATTACHED) → Artifacts sub-tasks executed → Phase 1 completed (tasks COLLAPSED) → Phase 2 executed (N role tasks ATTACHED in parallel) → Role analyses executed concurrently → Phase 2 completed (tasks COLLAPSED) → Phase 3 executed (synthesis tasks ATTACHED) → Synthesis sub-tasks executed → Phase 3 completed (tasks COLLAPSED) → Workflow complete.
+
+### Brainstorming Workflow Specific Features
+
+- **Phase 1**: Interactive framework generation with user Q&A (SlashCommand attachment)
+- **Phase 2**: Parallel role analysis execution with N concurrent agents (Task agent attachments)
+- **Phase 3**: Cross-role synthesis integration (SlashCommand attachment)
+- **Dynamic Role Count**: `--count N` parameter determines number of Phase 2 parallel tasks (default: 3, max: 9)
+- **Mixed Execution**: Sequential (Phase 1, 3) and Parallel (Phase 2) task execution
+
+
+## Input Processing
+
+**Count Parameter Parsing**:
+```javascript
+// Extract --count from user input
 IF user_input CONTAINS "--count":
     EXTRACT count_value FROM "--count N" pattern
     IF count_value > 9:
-        count_value = 9  # Cap at maximum 9 roles
-    END IF
+        count_value = 9  // Cap at maximum 9 roles
 ELSE:
-    count_value = 3  # Default to 3 roles
-END IF
+    count_value = 3  // Default to 3 roles
+
+// Pass to artifacts command
+EXECUTE: /workflow:brainstorm:artifacts "{topic}" --count {count_value}
 ```
 
-**Role Selection with Count**:
-1. **Analyze topic keywords**: Identify relevant role categories
-2. **Rank roles by relevance**: Score based on keyword matches
-3. **Select top N roles**: Pick N most relevant roles (N = count_value)
-4. **Ensure diversity**: Balance across different expertise areas
-5. **Minimum guarantee**: Always include at least one role (default to product-manager if no matches)
-
-### Simplified Processing Standards
-
-**Core Principles**:
-1. **Minimal preprocessing** - Only workflow-session.json and basic role selection
-2. **Agent autonomy** - Agents handle their own context and validation
-3. **Parallel execution** - Multiple agents can work simultaneously
-4. **Post-processing synthesis** - Integration happens after agent completion
-5. **TodoWrite control** - Progress tracking throughout all phases
-
-**Implementation Rules**:
-- **Role count**: N roles auto-selected based on --count parameter (default: 3, max: 9) and keyword mapping
-- **No upfront validation**: Agents handle their own context requirements
-- **Parallel execution**: Each agent operates concurrently without dependencies
-- **Synthesis at end**: Integration only after all agents complete
-
-**Agent Self-Management** (Agents decide their own approach):
-- **Context gathering**: Agents determine what questions to ask
-- **Template usage**: Agents load and apply their own role templates
-- **Analysis depth**: Agents determine appropriate level of detail
-- **Documentation**: Agents create their own file structure and content
-
-### Session Management ⚠️ CRITICAL
-- **⚡ FIRST ACTION**: Check for all `.workflow/.active-*` markers before role processing
-- **Multiple sessions support**: Different Claude instances can have different active brainstorming sessions
-- **User selection**: If multiple active sessions found, prompt user to select which one to work with
-- **Auto-session creation**: `WFS-[topic-slug]` only if no active session exists
-- **Session continuity**: MUST use selected active session for all role processing
-- **Context preservation**: Each role's context and agent output stored in session directory
-- **Session isolation**: Each session maintains independent brainstorming state and role assignments
-
-## Document Generation
-
-**Command Coordination Workflow**: artifacts → parallel role analysis → synthesis
-
-**Output Structure**: Coordinated commands generate framework, role analyses, and synthesis documents as defined in their respective command specifications.
-
-
-## Agent Prompt Templates
-
-### Task Agent Invocation Template
-
-
-```bash
-Task(subagent_type="conceptual-planning-agent",
-     prompt="Execute brainstorming analysis: {role-name} perspective for {topic}
-
-     ## Role Assignment
-     **ASSIGNED_ROLE**: {role-name}
-     **TOPIC**: {user-provided-topic}
-     **OUTPUT_LOCATION**: .workflow/WFS-{topic}/.brainstorming/{role}/
-
-     ## Execution Instructions
-     [FLOW_CONTROL]
-
-     ### Flow Control Steps
-     **AGENT RESPONSIBILITY**: Execute these pre_analysis steps sequentially with context accumulation:
-
-     1. **load_topic_framework**
-        - Action: Load structured topic discussion framework
-        - Command: bash(cat .workflow/WFS-{topic}/.brainstorming/topic-framework.md 2>/dev/null || echo 'Topic framework not found')
-        - Output: topic_framework
-
-     2. **load_role_template**
-        - Action: Load {role-name} planning template
-        - Command: bash($(cat "~/.claude/workflows/cli-templates/planning-roles/{role}.md"))
-        - Output: role_template
-
-     3. **load_session_metadata**
-        - Action: Load session metadata and original user intent
-        - Command: bash(cat .workflow/WFS-{topic}/workflow-session.json 2>/dev/null || echo '{}')
-        - Output: session_metadata (contains original user prompt in 'project' or 'description' field)
-
-     ### Implementation Context
-     **⚠️ User Intent Authority**: Original user prompt from session_metadata.project is PRIMARY reference
-     **Topic Framework**: Use loaded topic-framework.md for structured analysis
-     **Role Focus**: {role-name} domain expertise and perspective aligned with user intent
-     **Analysis Type**: Address framework discussion points from role perspective, filtered by user objectives
-     **Template Framework**: Combine role template with topic framework structure
-     **Structured Approach**: Create analysis.md addressing all topic framework points relevant to user's goals
-
-     ### Session Context
-     **Workflow Directory**: .workflow/WFS-{topic}/.brainstorming/
-     **Output Directory**: .workflow/WFS-{topic}/.brainstorming/{role}/
-     **Session JSON**: .workflow/WFS-{topic}/workflow-session.json
-
-     ### Dependencies & Context
-     **Topic**: {user-provided-topic}
-     **Role Template**: "~/.claude/workflows/cli-templates/planning-roles/{role}.md"
-     **User Requirements**: To be gathered through interactive questioning
-
-     ## Completion Requirements
-     1. Execute all flow control steps in sequence (load topic framework, role template, session metadata with user intent)
-     2. **⚠️ User Intent Alignment**: Validate analysis aligns with original user objectives from session_metadata
-     3. **Address Topic Framework**: Respond to all discussion points in topic-framework.md from role perspective
-     4. **Filter by User Goals**: Prioritize insights directly relevant to user's stated objectives
-     5. Apply role template guidelines within topic framework structure
-     6. Generate structured role analysis addressing framework points aligned with user intent
-     7. Create single comprehensive deliverable in OUTPUT_LOCATION:
-        - analysis.md (structured analysis addressing all topic framework points with role-specific insights filtered by user goals)
-     8. Include framework reference: @../topic-framework.md in analysis.md
-     9. Update workflow-session.json with completion status",
-     description="Execute {role-name} brainstorming analysis")
-```
-
-### Parallel Role Agent调用示例
-```bash
-# Execute N roles in parallel using single message with multiple Task calls
-# (N determined by --count parameter, default 3, shown below with 3 roles as example)
-
-Task(subagent_type="conceptual-planning-agent",
-     prompt="Execute brainstorming analysis: {role-1} perspective for {topic}...",
-     description="Execute {role-1} brainstorming analysis")
-
-Task(subagent_type="conceptual-planning-agent",
-     prompt="Execute brainstorming analysis: {role-2} perspective for {topic}...",
-     description="Execute {role-2} brainstorming analysis")
-
-Task(subagent_type="conceptual-planning-agent",
-     prompt="Execute brainstorming analysis: {role-3} perspective for {topic}...",
-     description="Execute {role-3} brainstorming analysis")
-
-# ... repeat for remaining N-3 roles if --count > 3
-```
-
-### Direct Synthesis Process (Command-Driven)
-**Synthesis execution**: Use SlashCommand to execute `/workflow:brainstorm:synthesis` after role completion
-
-
-## TodoWrite Control Flow ⚠️ CRITICAL
-
-### Workflow Progress Tracking
-**MANDATORY**: Use Claude Code's built-in TodoWrite tool throughout entire brainstorming workflow:
-
+**Style-Skill Parameter Parsing**:
 ```javascript
-// Phase 1: Create initial todo list for command-coordinated brainstorming workflow
-TodoWrite({
-  todos: [
-    {
-      content: "Initialize brainstorming session and detect active sessions",
-      status: "pending",
-      activeForm: "Initializing brainstorming session"
-    },
-    {
-      content: "Parse --count parameter and select N roles based on topic keyword analysis",
-      status: "pending",
-      activeForm: "Parsing parameters and selecting roles for brainstorming"
-    },
-    {
-      content: "Execute artifacts command with selected roles for role-specific framework",
-      status: "pending",
-      activeForm: "Generating role-specific topic framework"
-    },
-    {
-      content: "Execute [role-1] analysis [conceptual-planning-agent] [FLOW_CONTROL] addressing framework",
-      status: "pending",
-      activeForm: "Executing [role-1] structured framework analysis"
-    },
-    {
-      content: "Execute [role-2] analysis [conceptual-planning-agent] [FLOW_CONTROL] addressing framework",
-      status: "pending",
-      activeForm: "Executing [role-2] structured framework analysis"
-    },
-    // ... repeat for N roles (N determined by --count parameter, default 3)
-    {
-      content: "Execute [role-N] analysis [conceptual-planning-agent] [FLOW_CONTROL] addressing framework",
-      status: "pending",
-      activeForm: "Executing [role-N] structured framework analysis"
-    },
-    {
-      content: "Execute synthesis command using SlashCommand for final integration",
-      status: "pending",
-      activeForm: "Executing synthesis command for integrated analysis"
-    }
-  ]
-});
+// Extract --style-skill from user input
+IF user_input CONTAINS "--style-skill":
+    EXTRACT style_skill_name FROM "--style-skill package-name" pattern
 
-// Phase 2: Update status as workflow progresses - ONLY ONE task should be in_progress at a time
-TodoWrite({
-  todos: [
-    {
-      content: "Initialize brainstorming session and detect active sessions",
-      status: "completed",  // Mark completed preprocessing
-      activeForm: "Initializing brainstorming session"
-    },
-    {
-      content: "Select roles for topic analysis and create workflow-session.json",
-      status: "in_progress",  // Mark current task as in_progress
-      activeForm: "Selecting roles and creating session metadata"
-    },
-    // ... other tasks remain pending
-  ]
-});
+    // Validate SKILL package exists
+    skill_path = ".claude/skills/style-{style_skill_name}/SKILL.md"
+    IF file_exists(skill_path):
+        style_skill_package = style_skill_name
+        style_reference_path = ".workflow/reference_style/{style_skill_name}"
+        echo("✓ Style SKILL package found: style-{style_skill_name}")
+        echo("  Design reference: {style_reference_path}")
+    ELSE:
+        echo("⚠ WARNING: Style SKILL package not found: {style_skill_name}")
+        echo("  Expected location: {skill_path}")
+        echo("  Continuing without style reference...")
+        style_skill_package = null
+ELSE:
+    style_skill_package = null
+    echo("No style-skill specified, ui-designer will use default workflow")
 
-// Phase 3: Parallel agent execution tracking (N roles, N from --count parameter)
-TodoWrite({
-  todos: [
-    // ... previous completed tasks
-    {
-      content: "Execute [role-1] analysis [conceptual-planning-agent] [FLOW_CONTROL]",
-      status: "in_progress",  // Executing in parallel
-      activeForm: "Executing [role-1] brainstorming analysis"
-    },
-    {
-      content: "Execute [role-2] analysis [conceptual-planning-agent] [FLOW_CONTROL]",
-      status: "in_progress",  // Executing in parallel
-      activeForm: "Executing [role-2] brainstorming analysis"
-    },
-    // ... repeat for remaining N-2 roles
-    {
-      content: "Execute [role-N] analysis [conceptual-planning-agent] [FLOW_CONTROL]",
-      status: "in_progress",  // Executing in parallel
-      activeForm: "Executing [role-N] brainstorming analysis"
-    }
-  ]
-});
+// Store for Phase 2 ui-designer context
+CONTEXT_VARS:
+    - style_skill_package: {style_skill_package}
+    - style_reference_path: {style_reference_path}
 ```
 
-**TodoWrite Integration Rules**:
-1. **Create initial todos**: All workflow phases at start
-2. **Mark in_progress**: Multiple parallel tasks can be in_progress simultaneously
-3. **Update immediately**: After each task completion
-4. **Track agent execution**: Include [agent-type] and [FLOW_CONTROL] markers for parallel agents
-5. **Final synthesis**: Mark synthesis as in_progress only after all parallel agents complete
+**Topic Structuring**:
+1. **Already Structured** → Pass directly to artifacts
+   ```
+   User: "GOAL: Build platform SCOPE: 100 users CONTEXT: Real-time"
+   → Pass as-is to artifacts
+   ```
+
+2. **Simple Text** → Pass directly (artifacts handles structuring)
+   ```
+   User: "Build collaboration platform"
+   → artifacts will analyze and structure
+   ```
+
+## Session Management
+
+**⚡ FIRST ACTION**: Check `.workflow/active/` for existing sessions before Phase 1
+
+**Multiple Sessions Support**:
+- Different Claude instances can have different brainstorming sessions
+- If multiple sessions found, prompt user to select
+- If single session found, use it
+- If no session exists, create `WFS-[topic-slug]`
+
+**Session Continuity**:
+- MUST use selected session for all phases
+- Each role's context stored in session directory
+- Session isolation: Each session maintains independent state
+
+## Output Structure
+
+**Phase 1 Output**:
+- `.workflow/active/WFS-{topic}/.brainstorming/guidance-specification.md` (framework content)
+- `.workflow/active/WFS-{topic}/workflow-session.json` (metadata: selected_roles[], topic, timestamps, style_skill_package)
+
+**Phase 2 Output**:
+- `.workflow/active/WFS-{topic}/.brainstorming/{role}/analysis.md` (one per role)
+- `.superdesign/design_iterations/` (ui-designer artifacts, if --style-skill provided)
+
+**Phase 3 Output**:
+- `.workflow/active/WFS-{topic}/.brainstorming/synthesis-specification.md` (integrated analysis)
+
+**⚠️ Storage Separation**: Guidance content in .md files, metadata in .json (no duplication)
+**⚠️ Style References**: When --style-skill provided, workflow-session.json stores style_skill_package name, ui-designer loads from `.claude/skills/style-{package-name}/`
+
+## Available Roles
+
+- data-architect (数据架构师)
+- product-manager (产品经理)
+- product-owner (产品负责人)
+- scrum-master (敏捷教练)
+- subject-matter-expert (领域专家)
+- system-architect (系统架构师)
+- test-strategist (测试策略师)
+- ui-designer (UI 设计师)
+- ux-expert (UX 专家)
+
+**Role Selection**: Handled by artifacts command (intelligent recommendation + user selection)
+
+## Error Handling
+
+- **Role selection failure**: artifacts defaults to product-manager with explanation
+- **Agent execution failure**: Agent-specific retry with minimal dependencies
+- **Template loading issues**: Agent handles graceful degradation
+- **Synthesis conflicts**: Synthesis highlights disagreements without resolution
 
 ## Reference Information
 
-### Structured Processing Schema
-Each role processing follows structured framework pattern:
-- **topic_framework**: Structured discussion framework document
-- **role**: Selected planning role name with framework reference
-- **agent**: Dedicated conceptual-planning-agent instance
-- **structured_analysis**: Agent addresses all framework discussion points
-- **output**: Role-specific analysis.md addressing topic framework structure
+**File Structure**:
+```
+.workflow/active/WFS-[topic]/
+├── workflow-session.json              # Session metadata ONLY
+└── .brainstorming/
+    ├── guidance-specification.md      # Framework (Phase 1)
+    ├── {role}/
+    │   ├── analysis.md                # Main document (with optional @references)
+    │   └── analysis-{slug}.md         # Section documents (max 5)
+    └── synthesis-specification.md     # Integration (Phase 3)
+```
 
-### File Structure Reference
-**Architecture**: @~/.claude/workflows/workflow-architecture.md
-**Role Templates**: @~/.claude/workflows/cli-templates/planning-roles/
+**Template Source**: `~/.claude/workflows/cli-templates/planning-roles/`
 
-### Execution Integration
-Command coordination model: artifacts command → parallel role analysis → synthesis command
-
-
-## Error Handling
-- **Role selection failure**: Default to `product-manager` with explanation
-- **Agent execution failure**: Agent-specific retry with minimal dependencies
-- **Template loading issues**: Agent handles graceful degradation
-- **Synthesis conflicts**: Synthesis agent highlights disagreements without resolution
-
-## Quality Standards
-
-### Agent Autonomy Excellence
-- **Single role focus**: Each agent handles exactly one role independently
-- **Self-contained execution**: Agent manages own context, validation, and output
-- **Parallel processing**: Multiple agents can execute simultaneously
-- **Complete ownership**: Agent produces entire role-specific analysis package
-
-### Minimal Coordination Excellence
-- **Lightweight handoff**: Only topic and role assignment provided
-- **Agent self-management**: Agents handle their own workflow and validation
-- **Concurrent operation**: No inter-agent dependencies enabling parallel execution
-- **Reference-based synthesis**: Post-processing integration without content duplication
-- **TodoWrite orchestration**: Progress tracking and workflow control throughout entire process

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

@@ -1,6 +1,6 @@
 ---
 name: data-architect
-description: Generate or update data-architect/analysis.md addressing topic-framework discussion points
+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(*)
 ---
@@ -8,10 +8,10 @@ allowed-tools: Task(conceptual-planning-agent), TodoWrite(*), Read(*), Write(*)
 ## 📊 **Data Architect Analysis Generator**
 
 ### Purpose
-**Specialized command for generating data-architect/analysis.md** that addresses topic-framework.md discussion points from data architecture perspective. Creates or updates role-specific analysis with framework references.
+**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 topic-framework.md
+- **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
@@ -47,12 +47,12 @@ allowed-tools: Task(conceptual-planning-agent), TodoWrite(*), Read(*), Write(*)
 ### Phase 1: Session & Framework Detection
 ```bash
 # Check active session and framework
-CHECK: .workflow/.active-* marker files
+CHECK: find .workflow/active/ -name "WFS-*" -type d
 IF active_session EXISTS:
     session_id = get_active_session()
-    brainstorm_dir = .workflow/WFS-{session}/.brainstorming/
+    brainstorm_dir = .workflow/active/WFS-{session}/.brainstorming/
 
-    CHECK: brainstorm_dir/topic-framework.md
+    CHECK: brainstorm_dir/guidance-specification.md
     IF EXISTS:
         framework_mode = true
         load_framework = true
@@ -87,13 +87,13 @@ Execute data-architect analysis for existing topic framework
 
 ## Context Loading
 ASSIGNED_ROLE: data-architect
-OUTPUT_LOCATION: .workflow/WFS-{session}/.brainstorming/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/WFS-{session}/.brainstorming/topic-framework.md)
+   - Command: Read(.workflow/active/WFS-{session}/.brainstorming/guidance-specification.md)
    - Output: topic_framework_content
 
 2. **load_role_template**
@@ -103,21 +103,21 @@ ANALYSIS_MODE: {framework_mode ? "framework_based" : "standalone"}
 
 3. **load_session_metadata**
    - Action: Load session metadata and existing context
-   - Command: Read(.workflow/WFS-{session}/workflow-session.json)
+   - Command: Read(.workflow/active/WFS-{session}/workflow-session.json)
    - Output: session_context
 
 ## Analysis Requirements
-**Framework Reference**: Address all discussion points in topic-framework.md from data architecture perspective
+**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 @../topic-framework.md reference in analysis
+2. **Framework Reference**: Include @../guidance-specification.md reference in analysis
 
 ## Completion Criteria
-- Address each discussion point from topic-framework.md with data architecture expertise
+- 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
@@ -136,7 +136,7 @@ TodoWrite({
       activeForm: "Detecting session and framework"
     },
     {
-      content: "Load topic-framework.md and session metadata for context",
+      content: "Load guidance-specification.md and session metadata for context",
       status: "pending",
       activeForm: "Loading framework and session context"
     },
@@ -163,8 +163,8 @@ TodoWrite({
 
 ### Framework-Based Analysis
 ```
-.workflow/WFS-{session}/.brainstorming/data-architect/
-└── analysis.md    # Structured analysis addressing topic-framework.md discussion points
+.workflow/active/WFS-{session}/.brainstorming/data-architect/
+└── analysis.md    # Structured analysis addressing guidance-specification.md discussion points
 ```
 
 ### Analysis Document Structure
@@ -172,11 +172,11 @@ TodoWrite({
 # Data Architect Analysis: [Topic from Framework]
 
 ## Framework Reference
-**Topic Framework**: @../topic-framework.md
+**Topic Framework**: @../guidance-specification.md
 **Role Focus**: Data Architecture perspective
 
 ## Discussion Points Analysis
-[Address each point from topic-framework.md with data architecture expertise]
+[Address each point from guidance-specification.md with data architecture expertise]
 
 ### Core Requirements (from framework)
 [Data architecture perspective on requirements]
@@ -208,13 +208,13 @@ TodoWrite({
   "data_architect": {
     "status": "completed",
     "framework_addressed": true,
-    "output_location": ".workflow/WFS-{session}/.brainstorming/data-architect/analysis.md",
-    "framework_reference": "@../topic-framework.md"
+    "output_location": ".workflow/active/WFS-{session}/.brainstorming/data-architect/analysis.md",
+    "framework_reference": "@../guidance-specification.md"
   }
 }
 ```
 
 ### Integration Points
-- **Framework Reference**: @../topic-framework.md for structured discussion 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,6 +1,6 @@
 ---
 name: product-manager
-description: Generate or update product-manager/analysis.md addressing topic-framework discussion points
+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(*)
 ---
@@ -8,10 +8,10 @@ allowed-tools: Task(conceptual-planning-agent), TodoWrite(*), Read(*), Write(*)
 ## 🎯 **Product Manager Analysis Generator**
 
 ### Purpose
-**Specialized command for generating product-manager/analysis.md** that addresses topic-framework.md discussion points from product strategy perspective. Creates or updates role-specific analysis with framework references.
+**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 topic-framework.md
+- **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
@@ -27,12 +27,12 @@ allowed-tools: Task(conceptual-planning-agent), TodoWrite(*), Read(*), Write(*)
 ### Phase 1: Session & Framework Detection
 ```bash
 # Check active session and framework
-CHECK: .workflow/.active-* marker files
+CHECK: find .workflow/active/ -name "WFS-*" -type d
 IF active_session EXISTS:
     session_id = get_active_session()
-    brainstorm_dir = .workflow/WFS-{session}/.brainstorming/
+    brainstorm_dir = .workflow/active/WFS-{session}/.brainstorming/
 
-    CHECK: brainstorm_dir/topic-framework.md
+    CHECK: brainstorm_dir/guidance-specification.md
     IF EXISTS:
         framework_mode = true
         load_framework = true
@@ -67,13 +67,13 @@ Execute product-manager analysis for existing topic framework
 
 ## Context Loading
 ASSIGNED_ROLE: product-manager
-OUTPUT_LOCATION: .workflow/WFS-{session}/.brainstorming/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/WFS-{session}/.brainstorming/topic-framework.md)
+   - Command: Read(.workflow/active/WFS-{session}/.brainstorming/guidance-specification.md)
    - Output: topic_framework_content
 
 2. **load_role_template**
@@ -83,21 +83,21 @@ ANALYSIS_MODE: {framework_mode ? "framework_based" : "standalone"}
 
 3. **load_session_metadata**
    - Action: Load session metadata and existing context
-   - Command: Read(.workflow/WFS-{session}/workflow-session.json)
+   - Command: Read(.workflow/active/WFS-{session}/workflow-session.json)
    - Output: session_context
 
 ## Analysis Requirements
-**Framework Reference**: Address all discussion points in topic-framework.md from product strategy perspective
+**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 @../topic-framework.md reference in analysis
+2. **Framework Reference**: Include @../guidance-specification.md reference in analysis
 
 ## Completion Criteria
-- Address each discussion point from topic-framework.md with product management expertise
+- 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
@@ -116,7 +116,7 @@ TodoWrite({
       activeForm: "Detecting session and framework"
     },
     {
-      content: "Load topic-framework.md and session metadata for context",
+      content: "Load guidance-specification.md and session metadata for context",
       status: "pending",
       activeForm: "Loading framework and session context"
     },
@@ -143,8 +143,8 @@ TodoWrite({
 
 ### Framework-Based Analysis
 ```
-.workflow/WFS-{session}/.brainstorming/product-manager/
-└── analysis.md    # Structured analysis addressing topic-framework.md discussion points
+.workflow/active/WFS-{session}/.brainstorming/product-manager/
+└── analysis.md    # Structured analysis addressing guidance-specification.md discussion points
 ```
 
 ### Analysis Document Structure
@@ -152,11 +152,11 @@ TodoWrite({
 # Product Manager Analysis: [Topic from Framework]
 
 ## Framework Reference
-**Topic Framework**: @../topic-framework.md
+**Topic Framework**: @../guidance-specification.md
 **Role Focus**: Product Strategy perspective
 
 ## Discussion Points Analysis
-[Address each point from topic-framework.md with product management expertise]
+[Address each point from guidance-specification.md with product management expertise]
 
 ### Core Requirements (from framework)
 [Product strategy perspective on user needs and requirements]
@@ -188,13 +188,13 @@ TodoWrite({
   "product_manager": {
     "status": "completed",
     "framework_addressed": true,
-    "output_location": ".workflow/WFS-{session}/.brainstorming/product-manager/analysis.md",
-    "framework_reference": "@../topic-framework.md"
+    "output_location": ".workflow/active/WFS-{session}/.brainstorming/product-manager/analysis.md",
+    "framework_reference": "@../guidance-specification.md"
   }
 }
 ```
 
 ### Integration Points
-- **Framework Reference**: @../topic-framework.md for structured discussion 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,6 +1,6 @@
 ---
 name: product-owner
-description: Generate or update product-owner/analysis.md addressing topic-framework discussion points
+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(*)
 ---
@@ -8,10 +8,10 @@ allowed-tools: Task(conceptual-planning-agent), TodoWrite(*), Read(*), Write(*)
 ## 🎯 **Product Owner Analysis Generator**
 
 ### Purpose
-**Specialized command for generating product-owner/analysis.md** that addresses topic-framework.md discussion points from product backlog and feature prioritization perspective. Creates or updates role-specific analysis with framework references.
+**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 topic-framework.md
+- **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
@@ -27,12 +27,12 @@ allowed-tools: Task(conceptual-planning-agent), TodoWrite(*), Read(*), Write(*)
 ### Phase 1: Session & Framework Detection
 ```bash
 # Check active session and framework
-CHECK: .workflow/.active-* marker files
+CHECK: find .workflow/active/ -name "WFS-*" -type d
 IF active_session EXISTS:
     session_id = get_active_session()
-    brainstorm_dir = .workflow/WFS-{session}/.brainstorming/
+    brainstorm_dir = .workflow/active/WFS-{session}/.brainstorming/
 
-    CHECK: brainstorm_dir/topic-framework.md
+    CHECK: brainstorm_dir/guidance-specification.md
     IF EXISTS:
         framework_mode = true
         load_framework = true
@@ -67,13 +67,13 @@ Execute product-owner analysis for existing topic framework
 
 ## Context Loading
 ASSIGNED_ROLE: product-owner
-OUTPUT_LOCATION: .workflow/WFS-{session}/.brainstorming/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/WFS-{session}/.brainstorming/topic-framework.md)
+   - Command: Read(.workflow/active/WFS-{session}/.brainstorming/guidance-specification.md)
    - Output: topic_framework_content
 
 2. **load_role_template**
@@ -83,21 +83,21 @@ ANALYSIS_MODE: {framework_mode ? "framework_based" : "standalone"}
 
 3. **load_session_metadata**
    - Action: Load session metadata and existing context
-   - Command: Read(.workflow/WFS-{session}/workflow-session.json)
+   - Command: Read(.workflow/active/WFS-{session}/workflow-session.json)
    - Output: session_context
 
 ## Analysis Requirements
-**Framework Reference**: Address all discussion points in topic-framework.md from product backlog and feature prioritization perspective
+**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 @../topic-framework.md reference in analysis
+2. **Framework Reference**: Include @../guidance-specification.md reference in analysis
 
 ## Completion Criteria
-- Address each discussion point from topic-framework.md with product ownership expertise
+- 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
@@ -116,7 +116,7 @@ TodoWrite({
       activeForm: "Detecting session and framework"
     },
     {
-      content: "Load topic-framework.md and session metadata for context",
+      content: "Load guidance-specification.md and session metadata for context",
       status: "pending",
       activeForm: "Loading framework and session context"
     },
@@ -143,8 +143,8 @@ TodoWrite({
 
 ### Framework-Based Analysis
 ```
-.workflow/WFS-{session}/.brainstorming/product-owner/
-└── analysis.md    # Structured analysis addressing topic-framework.md discussion points
+.workflow/active/WFS-{session}/.brainstorming/product-owner/
+└── analysis.md    # Structured analysis addressing guidance-specification.md discussion points
 ```
 
 ### Analysis Document Structure
@@ -152,11 +152,11 @@ TodoWrite({
 # Product Owner Analysis: [Topic from Framework]
 
 ## Framework Reference
-**Topic Framework**: @../topic-framework.md
+**Topic Framework**: @../guidance-specification.md
 **Role Focus**: Product Backlog & Feature Prioritization perspective
 
 ## Discussion Points Analysis
-[Address each point from topic-framework.md with product ownership expertise]
+[Address each point from guidance-specification.md with product ownership expertise]
 
 ### Core Requirements (from framework)
 [User story formulation and backlog refinement perspective]
@@ -188,13 +188,13 @@ TodoWrite({
   "product_owner": {
     "status": "completed",
     "framework_addressed": true,
-    "output_location": ".workflow/WFS-{session}/.brainstorming/product-owner/analysis.md",
-    "framework_reference": "@../topic-framework.md"
+    "output_location": ".workflow/active/WFS-{session}/.brainstorming/product-owner/analysis.md",
+    "framework_reference": "@../guidance-specification.md"
   }
 }
 ```
 
 ### Integration Points
-- **Framework Reference**: @../topic-framework.md for structured discussion points
+- **Framework Reference**: @../guidance-specification.md for structured discussion points
 - **Cross-Role Synthesis**: Product ownership insights available for synthesis-report.md integration
 - **Agent Autonomy**: Independent execution with framework guidance

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

@@ -1,6 +1,6 @@
 ---
 name: scrum-master
-description: Generate or update scrum-master/analysis.md addressing topic-framework discussion points
+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(*)
 ---
@@ -8,10 +8,10 @@ allowed-tools: Task(conceptual-planning-agent), TodoWrite(*), Read(*), Write(*)
 ## 🎯 **Scrum Master Analysis Generator**
 
 ### Purpose
-**Specialized command for generating scrum-master/analysis.md** that addresses topic-framework.md discussion points from agile process and team collaboration perspective. Creates or updates role-specific analysis with framework references.
+**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 topic-framework.md
+- **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
@@ -27,12 +27,12 @@ allowed-tools: Task(conceptual-planning-agent), TodoWrite(*), Read(*), Write(*)
 ### Phase 1: Session & Framework Detection
 ```bash
 # Check active session and framework
-CHECK: .workflow/.active-* marker files
+CHECK: find .workflow/active/ -name "WFS-*" -type d
 IF active_session EXISTS:
     session_id = get_active_session()
-    brainstorm_dir = .workflow/WFS-{session}/.brainstorming/
+    brainstorm_dir = .workflow/active/WFS-{session}/.brainstorming/
 
-    CHECK: brainstorm_dir/topic-framework.md
+    CHECK: brainstorm_dir/guidance-specification.md
     IF EXISTS:
         framework_mode = true
         load_framework = true
@@ -67,13 +67,13 @@ Execute scrum-master analysis for existing topic framework
 
 ## Context Loading
 ASSIGNED_ROLE: scrum-master
-OUTPUT_LOCATION: .workflow/WFS-{session}/.brainstorming/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/WFS-{session}/.brainstorming/topic-framework.md)
+   - Command: Read(.workflow/active/WFS-{session}/.brainstorming/guidance-specification.md)
    - Output: topic_framework_content
 
 2. **load_role_template**
@@ -83,21 +83,21 @@ ANALYSIS_MODE: {framework_mode ? "framework_based" : "standalone"}
 
 3. **load_session_metadata**
    - Action: Load session metadata and existing context
-   - Command: Read(.workflow/WFS-{session}/workflow-session.json)
+   - Command: Read(.workflow/active/WFS-{session}/workflow-session.json)
    - Output: session_context
 
 ## Analysis Requirements
-**Framework Reference**: Address all discussion points in topic-framework.md from agile process and team collaboration perspective
+**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 @../topic-framework.md reference in analysis
+2. **Framework Reference**: Include @../guidance-specification.md reference in analysis
 
 ## Completion Criteria
-- Address each discussion point from topic-framework.md with scrum mastery expertise
+- 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
@@ -116,7 +116,7 @@ TodoWrite({
       activeForm: "Detecting session and framework"
     },
     {
-      content: "Load topic-framework.md and session metadata for context",
+      content: "Load guidance-specification.md and session metadata for context",
       status: "pending",
       activeForm: "Loading framework and session context"
     },
@@ -143,8 +143,8 @@ TodoWrite({
 
 ### Framework-Based Analysis
 ```
-.workflow/WFS-{session}/.brainstorming/scrum-master/
-└── analysis.md    # Structured analysis addressing topic-framework.md discussion points
+.workflow/active/WFS-{session}/.brainstorming/scrum-master/
+└── analysis.md    # Structured analysis addressing guidance-specification.md discussion points
 ```
 
 ### Analysis Document Structure
@@ -152,11 +152,11 @@ TodoWrite({
 # Scrum Master Analysis: [Topic from Framework]
 
 ## Framework Reference
-**Topic Framework**: @../topic-framework.md
+**Topic Framework**: @../guidance-specification.md
 **Role Focus**: Agile Process & Team Collaboration perspective
 
 ## Discussion Points Analysis
-[Address each point from topic-framework.md with scrum mastery expertise]
+[Address each point from guidance-specification.md with scrum mastery expertise]
 
 ### Core Requirements (from framework)
 [Sprint planning and iteration breakdown perspective]
@@ -188,13 +188,13 @@ TodoWrite({
   "scrum_master": {
     "status": "completed",
     "framework_addressed": true,
-    "output_location": ".workflow/WFS-{session}/.brainstorming/scrum-master/analysis.md",
-    "framework_reference": "@../topic-framework.md"
+    "output_location": ".workflow/active/WFS-{session}/.brainstorming/scrum-master/analysis.md",
+    "framework_reference": "@../guidance-specification.md"
   }
 }
 ```
 
 ### Integration Points
-- **Framework Reference**: @../topic-framework.md for structured discussion 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,6 +1,6 @@
 ---
 name: subject-matter-expert
-description: Generate or update subject-matter-expert/analysis.md addressing topic-framework discussion points
+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(*)
 ---
@@ -8,10 +8,10 @@ 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 topic-framework.md discussion points from domain knowledge and technical expertise perspective. Creates or updates role-specific analysis with framework references.
+**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 topic-framework.md
+- **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
@@ -27,12 +27,12 @@ allowed-tools: Task(conceptual-planning-agent), TodoWrite(*), Read(*), Write(*)
 ### Phase 1: Session & Framework Detection
 ```bash
 # Check active session and framework
-CHECK: .workflow/.active-* marker files
+CHECK: find .workflow/active/ -name "WFS-*" -type d
 IF active_session EXISTS:
     session_id = get_active_session()
-    brainstorm_dir = .workflow/WFS-{session}/.brainstorming/
+    brainstorm_dir = .workflow/active/WFS-{session}/.brainstorming/
 
-    CHECK: brainstorm_dir/topic-framework.md
+    CHECK: brainstorm_dir/guidance-specification.md
     IF EXISTS:
         framework_mode = true
         load_framework = true
@@ -67,13 +67,13 @@ Execute subject-matter-expert analysis for existing topic framework
 
 ## Context Loading
 ASSIGNED_ROLE: subject-matter-expert
-OUTPUT_LOCATION: .workflow/WFS-{session}/.brainstorming/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/WFS-{session}/.brainstorming/topic-framework.md)
+   - Command: Read(.workflow/active/WFS-{session}/.brainstorming/guidance-specification.md)
    - Output: topic_framework_content
 
 2. **load_role_template**
@@ -83,21 +83,21 @@ ANALYSIS_MODE: {framework_mode ? "framework_based" : "standalone"}
 
 3. **load_session_metadata**
    - Action: Load session metadata and existing context
-   - Command: Read(.workflow/WFS-{session}/workflow-session.json)
+   - Command: Read(.workflow/active/WFS-{session}/workflow-session.json)
    - Output: session_context
 
 ## Analysis Requirements
-**Framework Reference**: Address all discussion points in topic-framework.md from domain expertise and technical standards perspective
+**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 @../topic-framework.md reference in analysis
+2. **Framework Reference**: Include @../guidance-specification.md reference in analysis
 
 ## Completion Criteria
-- Address each discussion point from topic-framework.md with subject matter expertise
+- 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
@@ -116,7 +116,7 @@ TodoWrite({
       activeForm: "Detecting session and framework"
     },
     {
-      content: "Load topic-framework.md and session metadata for context",
+      content: "Load guidance-specification.md and session metadata for context",
       status: "pending",
       activeForm: "Loading framework and session context"
     },
@@ -143,8 +143,8 @@ TodoWrite({
 
 ### Framework-Based Analysis
 ```
-.workflow/WFS-{session}/.brainstorming/subject-matter-expert/
-└── analysis.md    # Structured analysis addressing topic-framework.md discussion points
+.workflow/active/WFS-{session}/.brainstorming/subject-matter-expert/
+└── analysis.md    # Structured analysis addressing guidance-specification.md discussion points
 ```
 
 ### Analysis Document Structure
@@ -152,11 +152,11 @@ TodoWrite({
 # Subject Matter Expert Analysis: [Topic from Framework]
 
 ## Framework Reference
-**Topic Framework**: @../topic-framework.md
+**Topic Framework**: @../guidance-specification.md
 **Role Focus**: Domain Expertise & Technical Standards perspective
 
 ## Discussion Points Analysis
-[Address each point from topic-framework.md with subject matter expertise]
+[Address each point from guidance-specification.md with subject matter expertise]
 
 ### Core Requirements (from framework)
 [Domain-specific requirements and industry standards perspective]
@@ -188,13 +188,13 @@ TodoWrite({
   "subject_matter_expert": {
     "status": "completed",
     "framework_addressed": true,
-    "output_location": ".workflow/WFS-{session}/.brainstorming/subject-matter-expert/analysis.md",
-    "framework_reference": "@../topic-framework.md"
+    "output_location": ".workflow/active/WFS-{session}/.brainstorming/subject-matter-expert/analysis.md",
+    "framework_reference": "@../guidance-specification.md"
   }
 }
 ```
 
 ### Integration Points
-- **Framework Reference**: @../topic-framework.md for structured discussion 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,378 +1,398 @@
 ---
 name: synthesis
-description: Generate synthesis-specification.md from topic-framework and role analyses with @ references using conceptual-planning-agent
+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(*)
+allowed-tools: Task(conceptual-planning-agent), TodoWrite(*), Read(*), Write(*), Edit(*), Glob(*), AskUserQuestion(*)
 ---
 
-## 🧩 **Synthesis Document Generator**
+## Overview
 
-### Core Function
-**Specialized command for generating synthesis-specification.md** that integrates topic-framework.md and all role analysis.md files using @ reference system. Creates comprehensive implementation specification with cross-role insights.
+Six-phase workflow to eliminate ambiguities and enhance conceptual depth in role analyses:
 
-**Dynamic Role Discovery**: Automatically detects which roles participated in brainstorming by scanning for `*/analysis.md` files. Synthesizes only actual participating roles, not predefined lists.
+**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
 
-### Primary Capabilities
-- **Dynamic Role Discovery**: Automatically identifies participating roles at runtime
-- **Framework Integration**: Reference topic-framework.md discussion points across all discovered roles
-- **Role Analysis Integration**: Consolidate all discovered role/analysis.md files using @ references
-- **Cross-Framework Comparison**: Compare how each participating role addressed framework discussion points
-- **@ Reference System**: Create structured references to source documents
-- **Update Detection**: Smart updates when new role analyses are added
-- **Flexible Participation**: Supports any subset of available roles (1 to 9+)
+All user interactions use AskUserQuestion tool (max 4 questions per call, multi-round).
 
-### Document Integration Model
-**Three-Document Reference System**:
-1. **topic-framework.md** → Structured discussion framework (input)
-2. **[role]/analysis.md** → Role-specific analyses addressing framework (input)
-3. **synthesis-specification.md** → Complete integrated specification (output)
+**Document Flow**:
+- Input: `[role]/analysis*.md`, `guidance-specification.md`, session metadata
+- Output: Updated `[role]/analysis*.md` with Enhancements + Clarifications sections
 
-## ⚙️ **Execution Protocol**
+---
 
-### ⚠️ Agent Execution with Flow Control
-**Execution Model**: Uses conceptual-planning-agent for synthesis generation with structured file loading.
+## Quick Reference
 
-**Rationale**:
-- **Autonomous Execution**: Agent independently loads and processes all required documents
-- **Flow Control**: Structured document loading ensures systematic analysis
-- **Complex Cognitive Analysis**: Leverages agent's analytical capabilities for cross-role synthesis
-- **Conceptual Focus**: Agent specializes in conceptual analysis and multi-perspective integration
+### Phase Summary
 
-**Agent Responsibility**: All file reading and synthesis generation performed by conceptual-planning-agent with FLOW_CONTROL instructions.
+| 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
 
-### 📋 Task Tracking Protocol
-Initialize synthesis task tracking using TodoWrite at command start:
 ```json
 [
-  {"content": "Detect active session and validate topic-framework.md existence", "status": "in_progress", "activeForm": "Detecting session and validating framework"},
-  {"content": "Discover participating role analyses dynamically", "status": "pending", "activeForm": "Discovering role analyses"},
-  {"content": "Check existing synthesis and confirm user action", "status": "pending", "activeForm": "Checking update mechanism"},
-  {"content": "Execute synthesis generation using conceptual-planning-agent with FLOW_CONTROL", "status": "pending", "activeForm": "Executing agent-based synthesis generation"},
-  {"content": "Agent performs cross-role analysis and generates synthesis-specification.md", "status": "pending", "activeForm": "Agent analyzing and generating synthesis"},
-  {"content": "Update workflow-session.json with synthesis completion status", "status": "pending", "activeForm": "Updating session metadata"}
+  {"content": "Detect session and validate analyses", "status": "pending", "activeForm": "Detecting session"},
+  {"content": "Discover role analysis file paths", "status": "pending", "activeForm": "Discovering paths"},
+  {"content": "Execute analysis agent (cross-role analysis)", "status": "pending", "activeForm": "Executing analysis"},
+  {"content": "Present enhancements via AskUserQuestion", "status": "pending", "activeForm": "Selecting enhancements"},
+  {"content": "Clarification questions via AskUserQuestion", "status": "pending", "activeForm": "Clarifying"},
+  {"content": "Execute parallel update agents", "status": "pending", "activeForm": "Updating documents"},
+  {"content": "Update context package and metadata", "status": "pending", "activeForm": "Finalizing"}
 ]
 ```
 
-### Phase 1: Document Discovery & Validation
-```bash
-# Detect active brainstorming session
-IF --session parameter provided:
-    session_id = provided session
-ELSE:
-    CHECK: .workflow/.active-* marker files
-    IF active_session EXISTS:
-        session_id = get_active_session()
-    ELSE:
-        ERROR: "No active brainstorming session found"
-        EXIT
+---
 
-brainstorm_dir = .workflow/WFS-{session}/.brainstorming/
+## Execution Phases
 
-# Validate required documents
-CHECK: brainstorm_dir/topic-framework.md
-IF NOT EXISTS:
-    ERROR: "topic-framework.md not found. Run /workflow:brainstorm:artifacts first"
-    EXIT
+### Phase 1: Discovery & Validation
 
-# Load user's original prompt from session metadata
-session_metadata = Read(.workflow/WFS-{session}/workflow-session.json)
-original_user_prompt = session_metadata.project || session_metadata.description
-IF NOT original_user_prompt:
-    WARN: "No original user prompt found in session metadata"
-    original_user_prompt = "Not available"
-```
+1. **Detect Session**: Use `--session` parameter or find `.workflow/active/WFS-*`
+2. **Validate Files**:
+   - `guidance-specification.md` (optional, warn if missing)
+   - `*/analysis*.md` (required, error if empty)
+3. **Load User Intent**: Extract from `workflow-session.json`
 
-### Phase 2: Role Analysis Discovery
-```bash
-# Dynamically discover available role analyses
-SCAN_DIRECTORY: .workflow/WFS-{session}/.brainstorming/
-FIND_ANALYSES: [
-    Scan all subdirectories for */analysis.md files
-    Extract role names from directory names
-]
+### Phase 2: Role Discovery & Path Preparation
 
-# Available roles (for reference, actual participation is dynamic):
-# - product-manager
-# - product-owner
-# - scrum-master
-# - system-architect
-# - ui-designer
-# - ux-expert
-# - data-architect
-# - subject-matter-expert
-# - test-strategist
+**Main flow prepares file paths for Agent**:
 
-LOAD_DOCUMENTS: {
-    "original_user_prompt": original_user_prompt (from session metadata),
-    "topic_framework": topic-framework.md,
-    "role_analyses": [dynamically discovered analysis.md files],
-    "participating_roles": [extract role names from discovered directories],
-    "existing_synthesis": synthesis-specification.md (if exists)
-}
+1. **Discover Analysis Files**:
+   - Glob: `.workflow/active/WFS-{session}/.brainstorming/*/analysis*.md`
+   - Supports: analysis.md + analysis-{slug}.md (max 5)
 
-# Note: Not all roles participate in every brainstorming session
-# Only synthesize roles that actually produced analysis.md files
-# CRITICAL: Original user prompt MUST be primary reference for synthesis
-```
+2. **Extract Role Information**:
+   - `role_analysis_paths`: Relative paths
+   - `participating_roles`: Role names from directories
 
-### Phase 3: Update Mechanism Check
-```bash
-# Check for existing synthesis
-IF synthesis-specification.md EXISTS:
-    SHOW current synthesis summary to user
-    ASK: "Synthesis exists. Do you want to:"
-    OPTIONS:
-      1. "Regenerate completely" → Create new synthesis
-      2. "Update with new analyses" → Integrate new role analyses
-      3. "Preserve existing" → Exit without changes
-ELSE:
-    CREATE new synthesis
-```
+3. **Pass to Agent**: session_id, brainstorm_dir, role_analysis_paths, participating_roles
 
-### Phase 4: Agent Execution with Flow Control
-**Synthesis Generation using conceptual-planning-agent**
+### Phase 3A: Analysis & Enhancement Agent
 
-Delegate synthesis generation to conceptual-planning-agent with structured file loading:
+**Agent executes cross-role analysis**:
 
-```bash
-Task(conceptual-planning-agent): "
-[FLOW_CONTROL]
+```javascript
+Task(conceptual-planning-agent, `
+## Agent Mission
+Analyze role documents, identify conflicts/gaps, generate enhancement recommendations
 
-Execute comprehensive synthesis generation from topic framework and role analyses
-
-## Context Loading
-OUTPUT_FILE: synthesis-specification.md
-OUTPUT_PATH: .workflow/WFS-{session}/.brainstorming/synthesis-specification.md
-SESSION_ID: {session_id}
-ANALYSIS_MODE: cross_role_synthesis
-
-## ⚠️ CRITICAL: User Intent Authority
-**ORIGINAL USER PROMPT IS THE PRIMARY REFERENCE**: {original_user_prompt}
-All synthesis MUST align with user's original intent. Topic framework and role analyses are supplementary context.
+## Input
+- brainstorm_dir: ${brainstorm_dir}
+- role_analysis_paths: ${role_analysis_paths}
+- participating_roles: ${participating_roles}
 
 ## Flow Control Steps
-1. **load_original_user_prompt**
-   - Action: Load user's original intent from session metadata
-   - Command: Read(.workflow/WFS-{session}/workflow-session.json)
-   - Extract: project field or description field
-   - Output: original_user_prompt (PRIMARY REFERENCE)
-   - Priority: HIGHEST - This is the authoritative source of user intent
+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, ...
 
-2. **load_topic_framework**
-   - Action: Load structured topic discussion framework
-   - Command: Read(.workflow/WFS-{session}/.brainstorming/topic-framework.md)
-   - Output: topic_framework_content
-   - Note: Validate alignment with original_user_prompt
-
-3. **discover_role_analyses**
-   - Action: Dynamically discover all participating role analysis files
-   - Command: Glob(.workflow/WFS-{session}/.brainstorming/*/analysis.md)
-   - Output: role_analysis_paths, participating_roles
-
-4. **load_role_analyses**
-   - Action: Load all discovered role analysis documents
-   - Command: Read(each path from role_analysis_paths)
-   - Output: role_analyses_content
-   - Note: Filter insights relevant to original_user_prompt
-
-5. **check_existing_synthesis**
-   - Action: Check if synthesis-specification.md already exists
-   - Command: Read(.workflow/WFS-{session}/.brainstorming/synthesis-specification.md) [if exists]
-   - Output: existing_synthesis_content [optional]
-
-6. **load_synthesis_template**
-   - Action: Load synthesis role template for structure and guidelines
-   - Command: Read(~/.claude/workflows/cli-templates/planning-roles/synthesis-role.md)
-   - Output: synthesis_template_guidelines
-
-## Synthesis Requirements
-
-### ⚠️ PRIMARY REQUIREMENT: User Intent Alignment
-**User's Original Goal is Supreme**: Synthesis MUST directly address {original_user_prompt}
-**Intent Validation**: Every requirement, design decision, and recommendation must trace back to user's original intent
-**Deviation Detection**: Flag any role analysis points that drift from user's stated goals
-**Refocus Mechanism**: When role discussions diverge, explicitly refocus on original user prompt
-**Traceability**: Each section should reference how it fulfills user's original intent
-
-### Core Integration
-**Cross-Role Analysis**: Integrate all discovered role analyses with comprehensive coverage
-**Framework Integration**: Address how each role responded to topic-framework.md discussion points
-**User Intent Filter**: Prioritize insights that directly serve user's original prompt
-**Decision Transparency**: Document both adopted solutions and rejected alternatives with rationale
-**Process Integration**: Include team capability gaps, process risks, and collaboration patterns
-**Visual Documentation**: Include key diagrams (architecture, data model, user journey) via Mermaid
-**Priority Matrix**: Create quantified recommendation matrix aligned with user's goals
-**Actionable Plan**: Provide phased implementation roadmap addressing user's original objectives
-
-### Cross-Role Analysis Process (Agent Internal Execution)
-Perform systematic cross-role analysis following these steps:
-
-1. **Data Collection**: Extract key insights, recommendations, concerns, and diagrams from each discovered role analysis
-2. **Consensus Identification**: Identify common themes and agreement areas across all participating roles
-3. **Disagreement Analysis**: Document conflicting views and track which specific roles disagree on each point
-4. **Innovation Extraction**: Identify breakthrough ideas and cross-role synergy opportunities
-5. **Priority Scoring**: Calculate multi-dimensional priority scores (impact, feasibility, effort, risk) for each recommendation
-6. **Decision Matrix**: Create comprehensive evaluation matrix and sort recommendations by priority
-
-## Synthesis Quality Standards
-Follow synthesis-specification.md structure defined in synthesis-role.md template:
-- Use template structure for comprehensive document organization
-- Apply analysis guidelines for cross-role synthesis process
-- Include all required sections from template (Executive Summary, Key Designs, Requirements, etc.)
-- Follow @ reference system for traceability to source role analyses
-- Apply quality standards from template (completeness, visual clarity, decision transparency)
-- Validate output against template's output validation checklist
-
-## Expected Deliverables
-1. **synthesis-specification.md**: Complete integrated specification consolidating all role perspectives
-2. **@ References**: Include cross-references to source role analyses
-3. **Session Metadata Update**: Update workflow-session.json with synthesis completion status
-
-## Completion Criteria
-- ⚠️ **USER INTENT ALIGNMENT**: Synthesis directly addresses user's original prompt
-- All discovered role analyses integrated without gaps
-- Framework discussion points addressed across all roles
-- **Intent traceability**: Each major section references user's original goals
-- Controversial points documented with dissenting roles identified
-- Process concerns (team capabilities, risks, collaboration) captured
-- Quantified priority recommendations aligned with user's objectives
-- Actionable implementation plan addressing user's stated goals
-- Comprehensive risk assessment with mitigation strategies
-- **Deviation warnings**: Any significant departures from user intent flagged explicitly
-
-## Execution Notes
-- Dynamic role participation: Only synthesize roles that produced analysis.md files
-- Update mechanism: If synthesis exists, prompt user for regenerate/update/preserve decision
-- Timeout allocation: Complex synthesis task (60-90 min recommended)
-- Reference @intelligent-tools-strategy.md for timeout guidelines
-"
+## Output Format
+[
+  {
+    "id": "EP-001",
+    "title": "API Contract Specification",
+    "affected_roles": ["system-architect", "api-designer"],
+    "category": "Architecture",
+    "current_state": "High-level API descriptions",
+    "enhancement": "Add detailed contract definitions",
+    "rationale": "Enables precise implementation",
+    "priority": "High"
+  }
+]
+`)
 ```
 
-## 📊 **Output Specification**
+### Phase 4: User Interaction
 
-### Output Location
-The synthesis process creates **one consolidated document** that integrates all role perspectives:
+**All interactions via AskUserQuestion (Chinese questions)**
 
-```
-.workflow/WFS-{topic-slug}/.brainstorming/
-├── topic-framework.md          # Input: Framework structure
-├── [role]/analysis.md          # Input: Role analyses (multiple)
-└── synthesis-specification.md  # ★ OUTPUT: Complete integrated specification
+#### Step 1: Enhancement Selection
+
+```javascript
+// If enhancements > 4, split into multiple rounds
+const enhancements = [...]; // from Phase 3A
+const BATCH_SIZE = 4;
+
+for (let i = 0; i < enhancements.length; i += BATCH_SIZE) {
+  const batch = enhancements.slice(i, i + BATCH_SIZE);
+
+  AskUserQuestion({
+    questions: [{
+      question: `请选择要应用的改进建议 (第${Math.floor(i/BATCH_SIZE)+1}轮)`,
+      header: "改进选择",
+      multiSelect: true,
+      options: batch.map(ep => ({
+        label: `${ep.id}: ${ep.title}`,
+        description: `影响: ${ep.affected_roles.join(', ')} | ${ep.enhancement}`
+      }))
+    }]
+  })
+
+  // Store selections before next round
+}
+
+// User can also skip: provide "跳过" option
 ```
 
-#### synthesis-specification.md Structure
+#### Step 2: Clarification Questions
 
-**Document Purpose**: Defines **"WHAT"** to build - comprehensive requirements and design blueprint.
-**Scope**: High-level features, requirements, and design specifications. Does NOT include executable task breakdown (that's IMPL_PLAN.md's responsibility).
+```javascript
+// Generate questions based on 9-category taxonomy scan
+// Categories: User Intent, Requirements, Architecture, UX, Feasibility, Risk, Process, Decisions, Terminology
 
-**Template Reference**: Complete document structure and content guidelines available in `synthesis-role.md` template, including:
-- Executive Summary with strategic overview
-- Key Designs & Decisions (architecture diagrams, ADRs, user journeys)
-- Controversial Points & Alternatives (decision transparency)
-- Requirements & Acceptance Criteria (Functional, Non-Functional, Business)
-- Design Specifications (UI/UX, Architecture, Domain Expertise)
-- Process & Collaboration Concerns (team skills, risks, patterns, constraints)
-- Implementation Roadmap (high-level phases)
-- Risk Assessment & Mitigation strategies
+const clarifications = [...]; // from analysis
+const BATCH_SIZE = 4;
 
-**Agent Usage**: The conceptual-planning-agent loads this template to understand expected structure and quality standards.
+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);
 
-## 🔄 **Session Integration**
+  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
+      }))
+    }))
+  })
 
-### Streamlined Status Synchronization
-Upon completion, update `workflow-session.json`:
+  // Store answers before next round
+}
+```
 
-**Dynamic Role Participation**: The `participating_roles` and `roles_synthesized` values are determined at runtime based on actual analysis.md files discovered.
+### Question Guidelines
+
+**Target**: 开发者（理解技术但需要从用户需求出发）
+
+**Question Structure**: `[跨角色分析发现] + [需要澄清的决策点]`
+**Option Structure**: `标签：[具体方案] + 说明：[业务影响] + [技术权衡]`
+
+**9-Category Taxonomy**:
+
+| Category | Focus | Example Question Pattern |
+|----------|-------|--------------------------|
+| User Intent | 用户目标 | "MVP阶段核心目标？" + 验证/壁垒/完整性 |
+| Requirements | 需求细化 | "功能优先级如何排序？" + 核心/增强/可选 |
+| Architecture | 架构决策 | "技术栈选择考量？" + 熟悉度/先进性/成熟度 |
+| UX | 用户体验 | "交互复杂度取舍？" + 简洁/丰富/渐进 |
+| Feasibility | 可行性 | "资源约束下的范围？" + 最小/标准/完整 |
+| Risk | 风险管理 | "风险容忍度？" + 保守/平衡/激进 |
+| Process | 流程规范 | "迭代节奏？" + 快速/稳定/灵活 |
+| Decisions | 决策确认 | "冲突解决方案？" + 方案A/方案B/折中 |
+| Terminology | 术语统一 | "统一使用哪个术语？" + 术语A/术语B |
+
+**Quality Rules**:
+
+**MUST Include**:
+- ✅ All questions in Chinese (用中文提问)
+- ✅ 基于跨角色分析的具体发现
+- ✅ 选项包含业务影响说明
+- ✅ 解决实际的模糊点或冲突
+
+**MUST Avoid**:
+- ❌ 与角色分析无关的通用问题
+- ❌ 重复已在 artifacts 阶段确认的内容
+- ❌ 过于细节的实现级问题
+
+#### Step 3: Build Update Plan
+
+```javascript
+update_plan = {
+  "role1": {
+    "enhancements": ["EP-001", "EP-003"],
+    "clarifications": [
+      {"question": "...", "answer": "...", "category": "..."}
+    ]
+  },
+  "role2": {
+    "enhancements": ["EP-002"],
+    "clarifications": [...]
+  }
+}
+```
+
+### Phase 5: Parallel Document Update Agents
+
+**Execute in parallel** (one agent per role):
+
+```javascript
+// Single message with multiple Task calls for parallelism
+Task(conceptual-planning-agent, `
+## Agent Mission
+Apply enhancements and clarifications to ${role} analysis
+
+## Input
+- role: ${role}
+- analysis_path: ${brainstorm_dir}/${role}/analysis.md
+- enhancements: ${role_enhancements}
+- clarifications: ${role_clarifications}
+- original_user_intent: ${intent}
+
+## Flow Control Steps
+1. load_current_analysis → Read analysis file
+2. add_clarifications_section → Insert Q&A section
+3. apply_enhancements → Integrate into relevant sections
+4. resolve_contradictions → Remove conflicts
+5. enforce_terminology → Align terminology
+6. validate_intent → Verify alignment with user intent
+7. write_updated_file → Save changes
+
+## Output
+Updated ${role}/analysis.md
+`)
+```
+
+**Agent Characteristics**:
+- **Isolation**: Each agent updates exactly ONE role (parallel safe)
+- **Dependencies**: Zero cross-agent dependencies
+- **Validation**: All updates must align with original_user_intent
+
+### Phase 6: Finalization
+
+#### Step 1: Update Context Package
+
+```javascript
+// Sync updated analyses to context-package.json
+const context_pkg = Read(".workflow/active/WFS-{session}/.process/context-package.json")
+
+// Update guidance-specification if exists
+// Update synthesis-specification if exists
+// Re-read all role analysis files
+// Update metadata timestamps
+
+Write(context_pkg_path, JSON.stringify(context_pkg))
+```
+
+#### Step 2: Update Session Metadata
 
 ```json
 {
   "phases": {
     "BRAINSTORM": {
-      "status": "completed",
-      "synthesis_completed": true,
+      "status": "clarification_completed",
+      "clarification_completed": true,
       "completed_at": "timestamp",
-      "participating_roles": ["<dynamically-discovered-role-1>", "<dynamically-discovered-role-2>", "..."],
-      "available_roles": ["product-manager", "product-owner", "scrum-master", "system-architect", "ui-designer", "ux-expert", "data-architect", "subject-matter-expert", "test-strategist"],
-      "consolidated_output": {
-        "synthesis_specification": ".workflow/WFS-{topic}/.brainstorming/synthesis-specification.md"
+      "participating_roles": [...],
+      "clarification_results": {
+        "enhancements_applied": ["EP-001", "EP-002"],
+        "questions_asked": 3,
+        "categories_clarified": ["Architecture", "UX"],
+        "roles_updated": ["role1", "role2"]
       },
-      "synthesis_quality": {
-        "role_integration": "complete",
-        "requirement_coverage": "comprehensive",
-        "decision_transparency": "alternatives_documented",
-        "process_risks_identified": true,
-        "implementation_readiness": "ready"
-      },
-      "content_metrics": {
-        "roles_synthesized": "<COUNT(participating_roles)>",
-        "functional_requirements": "<dynamic-count>",
-        "non_functional_requirements": "<dynamic-count>",
-        "business_requirements": "<dynamic-count>",
-        "architecture_decisions": "<dynamic-count>",
-        "controversial_points": "<dynamic-count>",
-        "diagrams_included": "<dynamic-count>",
-        "process_risks": "<dynamic-count>",
-        "team_skill_gaps": "<dynamic-count>",
-        "implementation_phases": "<dynamic-count>",
-        "risk_factors_identified": "<dynamic-count>"
+      "quality_metrics": {
+        "user_intent_alignment": "validated",
+        "ambiguity_resolution": "complete",
+        "terminology_consistency": "enforced"
       }
     }
   }
 }
 ```
 
-**Example with actual values**:
-```json
-{
-  "phases": {
-    "BRAINSTORM": {
-      "status": "completed",
-      "participating_roles": ["product-manager", "system-architect", "ui-designer", "ux-expert", "scrum-master"],
-      "content_metrics": {
-        "roles_synthesized": 5,
-        "functional_requirements": 18,
-        "controversial_points": 2
-      }
-    }
-  }
-}
+#### Step 3: Completion Report
+
+```markdown
+## ✅ Clarification Complete
+
+**Enhancements Applied**: EP-001, EP-002, EP-003
+**Questions Answered**: 3/5
+**Roles Updated**: role1, role2, role3
+
+### Next Steps
+✅ PROCEED: `/workflow:plan --session WFS-{session-id}`
 ```
 
-## ✅ **Quality Assurance**
+---
 
-Verify synthesis output meets these standards (detailed criteria in `synthesis-role.md` template):
+## Output
 
-### Content Completeness
-- [ ] All discovered role analyses integrated without gaps
-- [ ] Key designs documented (architecture diagrams, ADRs, user journeys via Mermaid)
-- [ ] Controversial points captured with alternatives and rationale
-- [ ] Process concerns included (team skills, risks, collaboration patterns)
-- [ ] Requirements documented (Functional, Non-Functional, Business) with sources
+**Location**: `.workflow/active/WFS-{session}/.brainstorming/[role]/analysis*.md`
 
-### Analysis Quality
-- [ ] Cross-role synthesis identifies consensus and conflicts
-- [ ] Decision transparency documents both adopted and rejected alternatives
-- [ ] Priority recommendations with multi-dimensional evaluation
-- [ ] Implementation roadmap with phased approach
-- [ ] Risk assessment with mitigation strategies
-- [ ] @ references to source role analyses throughout
+**Updated Structure**:
+```markdown
+## Clarifications
+### Session {date}
+- **Q**: {question} (Category: {category})
+  **A**: {answer}
 
-## 🚀 **Recommended Next Steps**
-
-After synthesis completion, proceed to action planning:
-
-### Standard Workflow (Recommended)
-```bash
-/workflow:concept-clarify --session WFS-{session-id}  # Optional: Clarify ambiguities
-/workflow:plan --session WFS-{session-id}             # Generate IMPL_PLAN.md and tasks
-/workflow:action-plan-verify --session WFS-{session-id}  # Optional: Verify plan quality
-/workflow:execute --session WFS-{session-id}          # Start implementation
+## {Existing Sections}
+{Refined content based on clarifications}
 ```
 
-### TDD Workflow
-```bash
-/workflow:concept-clarify --session WFS-{session-id}  # Optional: Clarify ambiguities
-/workflow:tdd-plan --session WFS-{session-id} "Feature description"
-/workflow:action-plan-verify --session WFS-{session-id}  # Optional: Verify plan quality
-/workflow:execute --session WFS-{session-id}
-```
+**Changes**:
+- User intent validated/corrected
+- Requirements more specific/measurable
+- Architecture with rationale
+- Ambiguities resolved, placeholders removed
+- Consistent terminology
+
+---
+
+## Quality Checklist
+
+**Content**:
+- ✅ All role analyses loaded/analyzed
+- ✅ Cross-role analysis (consensus, conflicts, gaps)
+- ✅ 9-category ambiguity scan
+- ✅ Questions prioritized
+
+**Analysis**:
+- ✅ User intent validated
+- ✅ Cross-role synthesis complete
+- ✅ Ambiguities resolved
+- ✅ Terminology consistent
+
+**Documents**:
+- ✅ Clarifications section formatted
+- ✅ Sections reflect answers
+- ✅ No placeholders (TODO/TBD)
+- ✅ Valid Markdown

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

@@ -1,6 +1,6 @@
 ---
 name: system-architect
-description: Generate or update system-architect/analysis.md addressing topic-framework discussion points
+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(*)
 ---
@@ -8,10 +8,10 @@ allowed-tools: Task(conceptual-planning-agent), TodoWrite(*), Read(*), Write(*)
 ## 🏗️ **System Architect Analysis Generator**
 
 ### Purpose
-**Specialized command for generating system-architect/analysis.md** that addresses topic-framework.md discussion points from system architecture perspective. Creates or updates role-specific analysis with framework references.
+**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 topic-framework.md
+- **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
@@ -46,12 +46,12 @@ allowed-tools: Task(conceptual-planning-agent), TodoWrite(*), Read(*), Write(*)
 ### Phase 1: Session & Framework Detection
 ```bash
 # Check active session and framework
-CHECK: .workflow/.active-* marker files
+CHECK: find .workflow/active/ -name "WFS-*" -type d
 IF active_session EXISTS:
     session_id = get_active_session()
-    brainstorm_dir = .workflow/WFS-{session}/.brainstorming/
+    brainstorm_dir = .workflow/active/WFS-{session}/.brainstorming/
 
-    CHECK: brainstorm_dir/topic-framework.md
+    CHECK: brainstorm_dir/guidance-specification.md
     IF EXISTS:
         framework_mode = true
         load_framework = true
@@ -78,20 +78,21 @@ ELSE:
 ```
 
 ### Phase 3: Agent Task Generation
-**Framework-Based Analysis** (when topic-framework.md exists):
+**Framework-Based Analysis** (when guidance-specification.md exists):
 ```bash
 Task(subagent_type="conceptual-planning-agent",
+     run_in_background=false,
      prompt="Generate system architect analysis addressing topic framework
 
      ## Framework Integration Required
-     **MANDATORY**: Load and address topic-framework.md discussion points
-     **Framework Reference**: @{session.brainstorm_dir}/topic-framework.md
+     **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 topic-framework.md completely
+     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 @../topic-framework.md
+     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
 
@@ -106,7 +107,7 @@ Task(subagent_type="conceptual-planning-agent",
      ```markdown
      # System Architect Analysis: [Topic]
 
-     **Framework Reference**: @../topic-framework.md
+     **Framework Reference**: @../guidance-specification.md
      **Role Focus**: System Architecture and Technical Design
 
      ## Core Requirements Analysis
@@ -136,18 +137,19 @@ Task(subagent_type="conceptual-planning-agent",
 # For existing analysis updates
 IF update_mode = "incremental":
     Task(subagent_type="conceptual-planning-agent",
+         run_in_background=false,
          prompt="Update existing system architect analysis
 
          ## Current Analysis Context
          **Existing Analysis**: @{session.brainstorm_dir}/system-architect/analysis.md
-         **Framework Reference**: @{session.brainstorm_dir}/topic-framework.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 @../topic-framework.md reference
+         5. **Maintain References**: Keep @../guidance-specification.md reference
 
          ## Update Instructions
          - Read existing analysis completely
@@ -162,15 +164,15 @@ IF update_mode = "incremental":
 
 ### Output Files
 ```
-.workflow/WFS-[topic]/.brainstorming/
-├── topic-framework.md          # Input: Framework (if exists)
+.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**: @../topic-framework.md (if framework exists)
+- **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
@@ -186,8 +188,8 @@ IF update_mode = "incremental":
 ### ⚠️ Session Management - FIRST STEP
 Session detection and selection:
 ```bash
-# Check for active sessions
-active_sessions=$(find .workflow -name ".active-*" 2>/dev/null)
+# 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
@@ -279,7 +281,7 @@ TodoWrite tracking for two-step process:
 
 ### Output Location
 ```
-.workflow/WFS-{topic-slug}/.brainstorming/system-architect/
+.workflow/active/WFS-{topic-slug}/.brainstorming/system-architect/
 ├── analysis.md                 # Primary architecture analysis
 ├── architecture-design.md      # Detailed system design and diagrams
 ├── technology-stack.md         # Technology stack recommendations and justifications
@@ -340,7 +342,7 @@ Upon completion, update `workflow-session.json`:
       "system_architect": {
         "status": "completed",
         "completed_at": "timestamp",
-        "output_directory": ".workflow/WFS-{topic}/.brainstorming/system-architect/",
+        "output_directory": ".workflow/active/WFS-{topic}/.brainstorming/system-architect/",
         "key_insights": ["scalability_bottleneck", "architecture_pattern", "technology_recommendation"]
       }
     }

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

@@ -1,6 +1,6 @@
 ---
 name: ui-designer
-description: Generate or update ui-designer/analysis.md addressing topic-framework discussion points
+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(*)
 ---
@@ -8,10 +8,10 @@ allowed-tools: Task(conceptual-planning-agent), TodoWrite(*), Read(*), Write(*)
 ## 🎨 **UI Designer Analysis Generator**
 
 ### Purpose
-**Specialized command for generating ui-designer/analysis.md** that addresses topic-framework.md discussion points from UI/UX design perspective. Creates or updates role-specific analysis with framework references.
+**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 topic-framework.md
+- **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
@@ -48,12 +48,12 @@ allowed-tools: Task(conceptual-planning-agent), TodoWrite(*), Read(*), Write(*)
 ### Phase 1: Session & Framework Detection
 ```bash
 # Check active session and framework
-CHECK: .workflow/.active-* marker files
+CHECK: find .workflow/active/ -name "WFS-*" -type d
 IF active_session EXISTS:
     session_id = get_active_session()
-    brainstorm_dir = .workflow/WFS-{session}/.brainstorming/
+    brainstorm_dir = .workflow/active/WFS-{session}/.brainstorming/
 
-    CHECK: brainstorm_dir/topic-framework.md
+    CHECK: brainstorm_dir/guidance-specification.md
     IF EXISTS:
         framework_mode = true
         load_framework = true
@@ -88,13 +88,13 @@ Execute ui-designer analysis for existing topic framework
 
 ## Context Loading
 ASSIGNED_ROLE: ui-designer
-OUTPUT_LOCATION: .workflow/WFS-{session}/.brainstorming/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/WFS-{session}/.brainstorming/topic-framework.md)
+   - Command: Read(.workflow/active/WFS-{session}/.brainstorming/guidance-specification.md)
    - Output: topic_framework_content
 
 2. **load_role_template**
@@ -104,21 +104,21 @@ ANALYSIS_MODE: {framework_mode ? "framework_based" : "standalone"}
 
 3. **load_session_metadata**
    - Action: Load session metadata and existing context
-   - Command: Read(.workflow/WFS-{session}/workflow-session.json)
+   - Command: Read(.workflow/active/WFS-{session}/workflow-session.json)
    - Output: session_context
 
 ## Analysis Requirements
-**Framework Reference**: Address all discussion points in topic-framework.md from UI/UX perspective
+**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 @../topic-framework.md reference in analysis
+2. **Framework Reference**: Include @../guidance-specification.md reference in analysis
 
 ## Completion Criteria
-- Address each discussion point from topic-framework.md with UI/UX design expertise
+- 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
@@ -137,7 +137,7 @@ TodoWrite({
       activeForm: "Detecting session and framework"
     },
     {
-      content: "Load topic-framework.md and session metadata for context",
+      content: "Load guidance-specification.md and session metadata for context",
       status: "pending",
       activeForm: "Loading framework and session context"
     },
@@ -164,8 +164,8 @@ TodoWrite({
 
 ### Framework-Based Analysis
 ```
-.workflow/WFS-{session}/.brainstorming/ui-designer/
-└── analysis.md    # Structured analysis addressing topic-framework.md discussion points
+.workflow/active/WFS-{session}/.brainstorming/ui-designer/
+└── analysis.md    # Structured analysis addressing guidance-specification.md discussion points
 ```
 
 ### Analysis Document Structure
@@ -173,11 +173,11 @@ TodoWrite({
 # UI Designer Analysis: [Topic from Framework]
 
 ## Framework Reference
-**Topic Framework**: @../topic-framework.md
+**Topic Framework**: @../guidance-specification.md
 **Role Focus**: UI/UX Design perspective
 
 ## Discussion Points Analysis
-[Address each point from topic-framework.md with UI/UX expertise]
+[Address each point from guidance-specification.md with UI/UX expertise]
 
 ### Core Requirements (from framework)
 [UI/UX perspective on requirements]
@@ -209,13 +209,13 @@ TodoWrite({
   "ui_designer": {
     "status": "completed",
     "framework_addressed": true,
-    "output_location": ".workflow/WFS-{session}/.brainstorming/ui-designer/analysis.md",
-    "framework_reference": "@../topic-framework.md"
+    "output_location": ".workflow/active/WFS-{session}/.brainstorming/ui-designer/analysis.md",
+    "framework_reference": "@../guidance-specification.md"
   }
 }
 ```
 
 ### Integration Points
-- **Framework Reference**: @../topic-framework.md for structured discussion 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,6 +1,6 @@
 ---
 name: ux-expert
-description: Generate or update ux-expert/analysis.md addressing topic-framework discussion points
+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(*)
 ---
@@ -8,10 +8,10 @@ allowed-tools: Task(conceptual-planning-agent), TodoWrite(*), Read(*), Write(*)
 ## 🎯 **UX Expert Analysis Generator**
 
 ### Purpose
-**Specialized command for generating ux-expert/analysis.md** that addresses topic-framework.md discussion points from user experience and interface design perspective. Creates or updates role-specific analysis with framework references.
+**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 topic-framework.md
+- **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
@@ -48,12 +48,12 @@ allowed-tools: Task(conceptual-planning-agent), TodoWrite(*), Read(*), Write(*)
 ### Phase 1: Session & Framework Detection
 ```bash
 # Check active session and framework
-CHECK: .workflow/.active-* marker files
+CHECK: find .workflow/active/ -name "WFS-*" -type d
 IF active_session EXISTS:
     session_id = get_active_session()
-    brainstorm_dir = .workflow/WFS-{session}/.brainstorming/
+    brainstorm_dir = .workflow/active/WFS-{session}/.brainstorming/
 
-    CHECK: brainstorm_dir/topic-framework.md
+    CHECK: brainstorm_dir/guidance-specification.md
     IF EXISTS:
         framework_mode = true
         load_framework = true
@@ -88,13 +88,13 @@ Execute ux-expert analysis for existing topic framework
 
 ## Context Loading
 ASSIGNED_ROLE: ux-expert
-OUTPUT_LOCATION: .workflow/WFS-{session}/.brainstorming/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/WFS-{session}/.brainstorming/topic-framework.md)
+   - Command: Read(.workflow/active/WFS-{session}/.brainstorming/guidance-specification.md)
    - Output: topic_framework_content
 
 2. **load_role_template**
@@ -104,21 +104,21 @@ ANALYSIS_MODE: {framework_mode ? "framework_based" : "standalone"}
 
 3. **load_session_metadata**
    - Action: Load session metadata and existing context
-   - Command: Read(.workflow/WFS-{session}/workflow-session.json)
+   - Command: Read(.workflow/active/WFS-{session}/workflow-session.json)
    - Output: session_context
 
 ## Analysis Requirements
-**Framework Reference**: Address all discussion points in topic-framework.md from user experience and interface design perspective
+**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 @../topic-framework.md reference in analysis
+2. **Framework Reference**: Include @../guidance-specification.md reference in analysis
 
 ## Completion Criteria
-- Address each discussion point from topic-framework.md with UX design expertise
+- 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
@@ -137,7 +137,7 @@ TodoWrite({
       activeForm: "Detecting session and framework"
     },
     {
-      content: "Load topic-framework.md and session metadata for context",
+      content: "Load guidance-specification.md and session metadata for context",
       status: "pending",
       activeForm: "Loading framework and session context"
     },
@@ -164,8 +164,8 @@ TodoWrite({
 
 ### Framework-Based Analysis
 ```
-.workflow/WFS-{session}/.brainstorming/ux-expert/
-└── analysis.md    # Structured analysis addressing topic-framework.md discussion points
+.workflow/active/WFS-{session}/.brainstorming/ux-expert/
+└── analysis.md    # Structured analysis addressing guidance-specification.md discussion points
 ```
 
 ### Analysis Document Structure
@@ -173,11 +173,11 @@ TodoWrite({
 # UX Expert Analysis: [Topic from Framework]
 
 ## Framework Reference
-**Topic Framework**: @../topic-framework.md
+**Topic Framework**: @../guidance-specification.md
 **Role Focus**: User Experience & Interface Design perspective
 
 ## Discussion Points Analysis
-[Address each point from topic-framework.md with UX design expertise]
+[Address each point from guidance-specification.md with UX design expertise]
 
 ### Core Requirements (from framework)
 [User interface and interaction design requirements perspective]
@@ -209,13 +209,13 @@ TodoWrite({
   "ux_expert": {
     "status": "completed",
     "framework_addressed": true,
-    "output_location": ".workflow/WFS-{session}/.brainstorming/ux-expert/analysis.md",
-    "framework_reference": "@../topic-framework.md"
+    "output_location": ".workflow/active/WFS-{session}/.brainstorming/ux-expert/analysis.md",
+    "framework_reference": "@../guidance-specification.md"
   }
 }
 ```
 
 ### Integration Points
-- **Framework Reference**: @../topic-framework.md for structured discussion points
+- **Framework Reference**: @../guidance-specification.md for structured discussion points
 - **Cross-Role Synthesis**: UX design insights available for synthesis-report.md integration
 - **Agent Autonomy**: Independent execution with framework guidance

.claude/commands/workflow/clean.md

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

@@ -1,353 +0,0 @@
----
-name: concept-clarify
-description: Identify underspecified areas in brainstorming artifacts through targeted clarification questions before action planning
-argument-hint: "[optional: --session session-id]"
-allowed-tools: Read(*), Write(*), Edit(*), TodoWrite(*), Glob(*), Bash(*)
----
-
-## User Input
-
-```text
-$ARGUMENTS
-```
-
-You **MUST** consider the user input before proceeding (if not empty).
-
-## Outline
-
-**Goal**: Detect and reduce ambiguity or missing decision points in planning artifacts before moving to task generation. Supports both brainstorm and plan workflows.
-
-**Timing**:
-- **Brainstorm mode**: Runs AFTER `/workflow:brainstorm:synthesis` and BEFORE `/workflow:plan`
-- **Plan mode**: Runs AFTER Phase 3 (concept-enhanced) and BEFORE Phase 4 (task-generate) within `/workflow:plan`
-
-This serves as a quality gate to ensure conceptual clarity before detailed task planning or generation.
-
-**Execution steps**:
-
-1. **Session Detection & Validation**
-   ```bash
-   # Detect active workflow session
-   IF --session parameter provided:
-       session_id = provided session
-   ELSE:
-       CHECK: .workflow/.active-* marker files
-       IF active_session EXISTS:
-           session_id = get_active_session()
-       ELSE:
-           ERROR: "No active workflow session found. Use --session <session-id> or start a session."
-           EXIT
-
-   # Mode detection: plan vs brainstorm
-   brainstorm_dir = .workflow/WFS-{session}/.brainstorming/
-   process_dir = .workflow/WFS-{session}/.process/
-
-   IF EXISTS(process_dir/ANALYSIS_RESULTS.md):
-       clarify_mode = "plan"
-       primary_artifact = process_dir/ANALYSIS_RESULTS.md
-       INFO: "Plan mode: Analyzing ANALYSIS_RESULTS.md"
-   ELSE IF EXISTS(brainstorm_dir/synthesis-specification.md):
-       clarify_mode = "brainstorm"
-       primary_artifact = brainstorm_dir/synthesis-specification.md
-       INFO: "Brainstorm mode: Analyzing synthesis-specification.md"
-   ELSE:
-       ERROR: "No valid artifact found. Run /workflow:brainstorm:synthesis or /workflow:plan first"
-       EXIT
-
-   # Mode-specific validation
-   IF clarify_mode == "brainstorm":
-       CHECK: brainstorm_dir/topic-framework.md
-       IF NOT EXISTS:
-           WARN: "topic-framework.md not found. Verification will be limited."
-   ```
-
-2. **Load Artifacts (Mode-Aware)**
-   ```bash
-   # Load primary artifact (determined in step 1)
-   primary_content = Read(primary_artifact)
-
-   # Load user's original intent from session metadata
-   session_metadata = Read(.workflow/WFS-{session}/workflow-session.json)
-   original_user_intent = session_metadata.project || session_metadata.description
-   IF NOT original_user_intent:
-       WARN: "No original user intent found in session metadata"
-       original_user_intent = "Not available"
-
-   # Load mode-specific supplementary artifacts
-   IF clarify_mode == "brainstorm":
-       topic_framework = Read(brainstorm_dir + "/topic-framework.md") # if exists
-       role_analyses = Glob(brainstorm_dir + "/*/analysis.md")
-       participating_roles = extract_role_names(role_analyses)
-   # Plan mode: primary_content (ANALYSIS_RESULTS.md) is self-contained
-   ```
-
-3. **Ambiguity & Coverage Scan**
-
-   Perform structured scan using this taxonomy. For each category, mark status: **Clear** / **Partial** / **Missing**.
-
-   **⚠️ User Intent Alignment** (NEW - HIGHEST PRIORITY):
-   - Primary artifact alignment with original user intent
-   - Goal consistency between artifact and user's stated objectives
-   - Scope match with user's requirements
-   - Success criteria reflects user's expectations
-   - Any unexplained deviations from user intent
-
-   **Requirements Clarity**:
-   - Functional requirements specificity and measurability
-   - Non-functional requirements with quantified targets
-   - Business requirements with success metrics
-   - Acceptance criteria completeness
-
-   **Architecture & Design Clarity**:
-   - Architecture decisions with rationale
-   - Data model completeness (entities, relationships, constraints)
-   - Technology stack justification
-   - Integration points and API contracts
-
-   **User Experience & Interface**:
-   - User journey completeness
-   - Critical interaction flows
-   - Error/edge case handling
-   - Accessibility and localization considerations
-
-   **Implementation Feasibility**:
-   - Team capability vs. required skills
-   - External dependencies and failure modes
-   - Resource constraints (timeline, personnel)
-   - Technical constraints and tradeoffs
-
-   **Risk & Mitigation**:
-   - Critical risks identified
-   - Mitigation strategies defined
-   - Success factors clarity
-   - Monitoring and quality gates
-
-   **Process & Collaboration**:
-   - Role responsibilities and handoffs
-   - Collaboration patterns defined
-   - Timeline and milestone clarity
-   - Dependency management strategy
-
-   **Decision Traceability**:
-   - Controversial points documented
-   - Alternatives considered and rejected
-   - Decision rationale clarity
-   - Consensus vs. dissent tracking
-
-   **Terminology & Consistency**:
-   - Canonical terms defined
-   - Consistent naming across artifacts
-   - No unresolved placeholders (TODO, TBD, ???)
-
-   For each category with **Partial** or **Missing** status, add to candidate question queue unless:
-   - Clarification would not materially change implementation strategy
-   - Information is better deferred to planning phase
-
-4. **Generate Prioritized Question Queue**
-
-   Internally generate prioritized queue of candidate questions (maximum 5):
-
-   **Constraints**:
-   - Maximum 5 questions per session
-   - Each question must be answerable with:
-     * Multiple-choice (2-5 mutually exclusive options), OR
-     * Short answer (≤5 words)
-   - Only include questions whose answers materially impact:
-     * Architecture decisions
-     * Data modeling
-     * Task decomposition
-     * Risk mitigation
-     * Success criteria
-   - Ensure category coverage balance
-   - Favor clarifications that reduce downstream rework risk
-
-   **Prioritization Heuristic**:
-   ```
-   priority_score = (impact_on_planning * 0.4) +
-                    (uncertainty_level * 0.3) +
-                    (risk_if_unresolved * 0.3)
-   ```
-
-   If zero high-impact ambiguities found, proceed to **Step 8** (report success).
-
-5. **Sequential Question Loop** (Interactive)
-
-   Present **EXACTLY ONE** question at a time:
-
-   **Multiple-choice format**:
-   ```markdown
-   **Question {N}/5**: {Question text}
-
-   | Option | Description |
-   |--------|-------------|
-   | A | {Option A description} |
-   | B | {Option B description} |
-   | C | {Option C description} |
-   | D | {Option D description} |
-   | Short | Provide different answer (≤5 words) |
-   ```
-
-   **Short-answer format**:
-   ```markdown
-   **Question {N}/5**: {Question text}
-
-   Format: Short answer (≤5 words)
-   ```
-
-   **Answer Validation**:
-   - Validate answer maps to option or fits ≤5 word constraint
-   - If ambiguous, ask quick disambiguation (doesn't count as new question)
-   - Once satisfactory, record in working memory and proceed to next question
-
-   **Stop Conditions**:
-   - All critical ambiguities resolved
-   - User signals completion ("done", "no more", "proceed")
-   - Reached 5 questions
-
-   **Never reveal future queued questions in advance**.
-
-6. **Integration After Each Answer** (Incremental Update)
-
-   After each accepted answer:
-
-   ```bash
-   # Ensure Clarifications section exists
-   IF primary_content NOT contains "## Clarifications":
-       Insert "## Clarifications" section after first heading
-
-   # Create session subsection
-   IF NOT contains "### Session YYYY-MM-DD":
-       Create "### Session {today's date}" under "## Clarifications"
-
-   # Append clarification entry
-   APPEND: "- Q: {question} → A: {answer}"
-
-   # Apply clarification to appropriate section
-   CASE category:
-       Functional Requirements → Update "## Requirements" or equivalent section
-       Architecture → Update "## Architecture" or "## Design" sections
-       User Experience → Update "## UI/UX" or "## User Experience" sections
-       Risk → Update "## Risks" or "## Risk Assessment" sections
-       Process → Update "## Process" or "## Implementation" sections
-       Data Model → Update "## Data Model" or "## Database" sections
-       Non-Functional → Update "## Non-Functional Requirements" or equivalent
-
-   # Remove obsolete/contradictory statements
-   IF clarification invalidates existing statement:
-       Replace statement instead of duplicating
-
-   # Save immediately to primary_artifact
-   Write(primary_artifact)
-   ```
-
-7. **Validation After Each Write**
-
-   - [ ] Clarifications section contains exactly one bullet per accepted answer
-   - [ ] Total asked questions ≤ 5
-   - [ ] Updated sections contain no lingering placeholders
-   - [ ] No contradictory earlier statements remain
-   - [ ] Markdown structure valid
-   - [ ] Terminology consistent across all updated sections
-
-8. **Completion Report**
-
-   After questioning loop ends or early termination:
-
-   ```markdown
-   ## ✅ Concept Verification Complete
-
-   **Session**: WFS-{session-id}
-   **Mode**: {clarify_mode}
-   **Questions Asked**: {count}/5
-   **Artifacts Updated**: {primary_artifact filename}
-   **Sections Touched**: {list section names}
-
-   ### Coverage Summary
-
-   | Category | Status | Notes |
-   |----------|--------|-------|
-   | Requirements Clarity | ✅ Resolved | Acceptance criteria quantified |
-   | Architecture & Design | ✅ Clear | No ambiguities found |
-   | Implementation Feasibility | ⚠️ Deferred | Team training plan to be defined in IMPL_PLAN |
-   | Risk & Mitigation | ✅ Resolved | Critical risks now have mitigation strategies |
-   | ... | ... | ... |
-
-   **Legend**:
-   - ✅ Resolved: Was Partial/Missing, now addressed
-   - ✅ Clear: Already sufficient
-   - ⚠️ Deferred: Low impact, better suited for planning phase
-   - ❌ Outstanding: Still Partial/Missing but question quota reached
-
-   ### Recommendations
-
-   - ✅ **PROCEED to /workflow:plan**: Conceptual foundation is clear
-   - OR ⚠️ **Address Outstanding Items First**: {list critical outstanding items}
-   - OR 🔄 **Run /workflow:concept-clarify Again**: If new information available
-
-   ### Next Steps
-
-   **If Outstanding Items Exist**:
-   1. TodoWrite tracking for outstanding issues
-   2. Call conceptual-planning-agent to fix conceptual gaps
-   3. Wait for user confirmation before proceeding
-
-   **If No Issues**:
-   ```bash
-   /workflow:plan  # Generate IMPL_PLAN.md and task.json
-   ```
-   ```
-
-9. **Update Session Metadata**
-
-   ```bash
-   # Update metadata based on mode
-   IF clarify_mode == "brainstorm":
-       phase_key = "BRAINSTORM"
-   ELSE: # plan mode
-       phase_key = "PLAN"
-
-   # Update session metadata
-   {
-     "phases": {
-       "{phase_key}": {
-         "status": "concept_verified",
-         "concept_verification": {
-           "completed": true,
-           "completed_at": "timestamp",
-           "mode": "{clarify_mode}",
-           "questions_asked": {count},
-           "categories_clarified": [{list}],
-           "outstanding_items": [],
-           "recommendation": "PROCEED" # or "ADDRESS_OUTSTANDING"
-         }
-       }
-     }
-   }
-   ```
-
-## Behavior Rules
-
-- **If no meaningful ambiguities found**: Report "No critical ambiguities detected. Conceptual foundation is clear." and suggest proceeding to `/workflow:plan`.
-- **If synthesis-specification.md missing**: Instruct user to run `/workflow:brainstorm:synthesis` first.
-- **Never exceed 5 questions** (disambiguation retries don't count as new questions).
-- **Respect user early termination**: Signals like "stop", "done", "proceed" should stop questioning.
-- **If quota reached with high-impact items unresolved**: Explicitly flag them under "Outstanding" with recommendation to address before planning.
-- **Avoid speculative tech stack questions** unless absence blocks conceptual clarity.
-
-## Operating Principles
-
-### Context Efficiency
-- **Minimal high-signal tokens**: Focus on actionable clarifications
-- **Progressive disclosure**: Load artifacts incrementally
-- **Deterministic results**: Rerunning without changes produces consistent analysis
-
-### Verification Guidelines
-- **NEVER hallucinate missing sections**: Report them accurately
-- **Prioritize high-impact ambiguities**: Focus on what affects planning
-- **Use examples over exhaustive rules**: Cite specific instances
-- **Report zero issues gracefully**: Emit success report with coverage statistics
-- **Update incrementally**: Save after each answer to minimize context loss
-
-## Context
-
-{ARGS}

.claude/commands/workflow/debug.md

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

.claude/commands/workflow/execute.md

@@ -1,133 +1,327 @@
 ---
 name: execute
-description: Coordinate agents for existing workflow tasks with automatic discovery
+description: Coordinate agent execution for workflow tasks with automatic session discovery, parallel task processing, and status tracking
 argument-hint: "[--resume-session=\"session-id\"]"
 ---
 
 # Workflow Execute Command
 
 ## Overview
-Orchestrates autonomous workflow execution through systematic task discovery, agent coordination, and progress tracking. **Executes entire workflow without user interruption**, providing complete context to agents and ensuring proper flow control execution with comprehensive TodoWrite tracking.
+Orchestrates autonomous workflow execution through systematic task discovery, agent coordination, and progress tracking. **Executes entire workflow without user interruption** (except initial session selection if multiple active sessions exist), providing complete context to agents and ensuring proper flow control execution with comprehensive TodoWrite tracking.
 
 **Resume Mode**: When called with `--resume-session` flag, skips discovery phase and directly enters TodoWrite generation and agent execution for the specified session.
 
+## Performance Optimization Strategy
+
+**Lazy Loading**: Task JSONs read **on-demand** during execution, not upfront. TODO_LIST.md + IMPL_PLAN.md provide metadata for planning.
+
+**Loading Strategy**:
+- **TODO_LIST.md**: Read in Phase 3 (task metadata, status, dependencies for TodoWrite generation)
+- **IMPL_PLAN.md**: Check existence in Phase 2 (normal mode), parse execution strategy in Phase 4A
+- **Task JSONs**: Lazy loading - read only when task is about to execute (Phase 4B)
+
 ## Core Rules
 **Complete entire workflow autonomously without user interruption, using TodoWrite for comprehensive progress tracking.**
-**Execute all discovered pending tasks sequentially until workflow completion or blocking dependency.**
-**Auto-complete session when all tasks finished: Call `/workflow:session:complete` upon workflow completion.**
+**Execute all discovered pending tasks until workflow completion or blocking dependency.**
+**User-choice completion: When all tasks finished, ask user to choose review or complete.**
+**ONE AGENT = ONE TASK JSON: Each agent instance executes exactly one task JSON file - never batch multiple tasks into single agent execution.**
 
 ## Core Responsibilities
 - **Session Discovery**: Identify and select active workflow sessions
-- **Task Dependency Resolution**: Analyze task relationships and execution order
+- **Execution Strategy Parsing**: Extract execution model from IMPL_PLAN.md
 - **TodoWrite Progress Tracking**: Maintain real-time execution status throughout entire workflow
 - **Agent Orchestration**: Coordinate specialized agents with complete context
-- **Flow Control Execution**: Execute pre-analysis steps and context accumulation
 - **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
-- **Discovery-first**: Auto-discover existing plans and tasks
-- **Status-aware**: Execute only ready tasks with resolved dependencies
-- **Context-rich**: Provide complete task JSON and accumulated context to agents
-- **Progress tracking**: **Continuous TodoWrite updates throughout entire workflow execution**
-- **Flow control**: Sequential step execution with variable passing
-- **Autonomous completion**: **Execute all tasks without user interruption until workflow complete**
+- **Progress tracking**: Continuous TodoWrite updates throughout entire workflow execution
+- **Autonomous completion**: Execute all tasks without user interruption until workflow complete
 
-## Flow Control Execution
-**[FLOW_CONTROL]** marker indicates task JSON contains `flow_control.pre_analysis` steps for context preparation.
+## Execution Process
 
-### Orchestrator Responsibility
-- Pass complete task JSON to agent (including `flow_control` block)
-- Provide session paths for artifact access
-- Monitor agent completion
+```
+Normal Mode:
+Phase 1: Discovery
+   ├─ Count active sessions
+   └─ Decision:
+      ├─ count=0 → ERROR: No active sessions
+      ├─ count=1 → Auto-select session → Phase 2
+      └─ count>1 → AskUserQuestion (max 4 options) → Phase 2
 
-### Agent Responsibility
-- Parse `flow_control.pre_analysis` array from JSON
-- Execute steps sequentially with variable substitution
-- Accumulate context from artifacts and dependencies
-- Follow error handling per `step.on_error`
-- Complete implementation using accumulated context
+Phase 2: Planning Document Validation
+   ├─ Check IMPL_PLAN.md exists
+   ├─ Check TODO_LIST.md exists
+   └─ Validate .task/ contains IMPL-*.json files
 
-**Orchestrator does NOT execute flow control steps - Agent interprets and executes them from JSON.**
+Phase 3: TodoWrite Generation
+   ├─ Update session status to "active" (Step 0)
+   ├─ Parse TODO_LIST.md for task statuses
+   ├─ Generate TodoWrite for entire workflow
+   └─ Prepare session context paths
+
+Phase 4: Execution Strategy & Task Execution
+   ├─ Step 4A: Parse execution strategy from IMPL_PLAN.md
+   └─ Step 4B: Execute tasks with lazy loading
+      └─ Loop:
+         ├─ Get next in_progress task from TodoWrite
+         ├─ Lazy load task JSON
+         ├─ Launch agent with task context
+         ├─ Mark task completed (update IMPL-*.json status)
+         │  # Quick fix: Update task status for ccw dashboard
+         │  # TS=$(date -Iseconds) && jq --arg ts "$TS" '.status="completed" | .status_history=(.status_history // [])+[{"from":"in_progress","to":"completed","changed_at":$ts}]' IMPL-X.json > tmp.json && mv tmp.json IMPL-X.json
+         └─ Advance to next task
+
+Phase 5: Completion
+   ├─ Update task statuses in JSON files
+   ├─ Generate summaries
+   └─ AskUserQuestion: Choose next step
+      ├─ "Enter Review" → /workflow:review
+      └─ "Complete Session" → /workflow:session:complete
+
+Resume Mode (--resume-session):
+   ├─ Skip Phase 1 & Phase 2
+   └─ Entry Point: Phase 3 (TodoWrite Generation)
+      ├─ Update session status to "active" (if not already)
+      └─ Continue: Phase 4 → Phase 5
+```
 
 ## Execution Lifecycle
 
-### Resume Mode Detection
-**Special Flag Processing**: When `--resume-session="session-id"` is provided:
-1. **Skip Discovery Phase**: Use provided session ID directly
-2. **Load Specified Session**: Read session state from `.workflow/{session-id}/`
-3. **Direct TodoWrite Generation**: Skip to Phase 3 (Planning) immediately
-4. **Accelerated Execution**: Enter agent coordination without validation delays
+### Phase 1: Discovery
+**Applies to**: Normal mode only (skipped in resume mode)
 
-### Phase 1: Discovery (Normal Mode Only)
-1. **Check Active Sessions**: Find `.workflow/.active-*` markers
-2. **Select Session**: If multiple found, prompt user selection
-3. **Load Session State**: Read `workflow-session.json` and `IMPL_PLAN.md`
-4. **Scan Tasks**: Analyze `.task/*.json` files for ready tasks
+**Purpose**: Find and select active workflow session with user confirmation when multiple sessions exist
 
-**Note**: In resume mode, this phase is completely skipped.
+**Process**:
 
-### Phase 2: Analysis (Normal Mode Only)
-1. **Dependency Resolution**: Build execution order based on `depends_on`
-2. **Status Validation**: Filter tasks with `status: "pending"` and met dependencies
-3. **Agent Assignment**: Determine agent type from `meta.agent` or `meta.type`
-4. **Context Preparation**: Load dependency summaries and inherited context
+#### Step 1.1: Count Active Sessions
+```bash
+bash(find .workflow/active/ -name "WFS-*" -type d 2>/dev/null | wc -l)
+```
 
-**Note**: In resume mode, this phase is also skipped as session analysis was already completed by `/workflow:status`.
+#### Step 1.2: Handle Session Selection
 
-### Phase 3: Planning (Resume Mode Entry Point)
-**This is where resume mode directly enters after skipping Phases 1 & 2**
+**Case A: No Sessions** (count = 0)
+```
+ERROR: No active workflow sessions found
+Run /workflow:plan "task description" to create a session
+```
 
-1. **Create TodoWrite List**: Generate task list with status markers from session state
-2. **Mark Initial Status**: Set first pending task as `in_progress`
-3. **Prepare Session Context**: Inject workflow paths for agent use (using provided session-id)
-4. **Prepare Complete Task JSON**: Include pre_analysis and flow control steps for agent consumption
-5. **Validate Prerequisites**: Ensure all required context is available from existing session
+**Case B: Single Session** (count = 1)
+```bash
+bash(find .workflow/active/ -name "WFS-*" -type d 2>/dev/null | head -1 | xargs basename)
+```
+Auto-select and continue to Phase 2.
+
+**Case C: Multiple Sessions** (count > 1)
+
+List sessions with metadata and prompt user selection:
+```bash
+bash(for dir in .workflow/active/WFS-*/; do [ -d "$dir" ] || continue; session=$(basename "$dir"); project=$(jq -r '.project // "Unknown"' "${dir}workflow-session.json" 2>/dev/null || echo "Unknown"); total=$(grep -c '^\- \[' "${dir}TODO_LIST.md" 2>/dev/null || echo 0); completed=$(grep -c '^\- \[x\]' "${dir}TODO_LIST.md" 2>/dev/null || echo 0); if [ "$total" -gt 0 ]; then progress=$((completed * 100 / total)); else progress=0; fi; echo "$session | $project | $completed/$total tasks ($progress%)"; done)
+```
+
+Use AskUserQuestion to present formatted options (max 4 options shown):
+```javascript
+// If more than 4 sessions, show most recent 4 with "Other" option for manual input
+const sessions = getActiveSessions()  // sorted by last modified
+const displaySessions = sessions.slice(0, 4)
+
+AskUserQuestion({
+  questions: [{
+    question: "Multiple active sessions detected. Select one:",
+    header: "Session",
+    multiSelect: false,
+    options: displaySessions.map(s => ({
+      label: s.id,
+      description: `${s.project} | ${s.progress}`
+    }))
+    // Note: User can select "Other" to manually enter session ID
+  }]
+})
+```
+
+**Input Validation**:
+- If user selects from options: Use selected session ID
+- If user selects "Other" and provides input: Validate session exists
+- If validation fails: Show error and re-prompt or suggest available sessions
+
+Parse user input (supports: number "1", full ID "WFS-auth-system", or partial "auth"), validate selection, and continue to Phase 2.
+
+#### Step 1.3: Load Session Metadata
+```bash
+bash(cat .workflow/active/${sessionId}/workflow-session.json)
+```
+
+**Output**: Store session metadata in memory
+**DO NOT read task JSONs yet** - defer until execution phase (lazy loading)
+
+**Resume Mode**: This entire phase is skipped when `--resume-session="session-id"` flag is provided.
+
+### Phase 2: Planning Document Validation
+**Applies to**: Normal mode only (skipped in resume mode)
+
+**Purpose**: Validate planning artifacts exist before execution
+
+**Process**:
+1. **Check IMPL_PLAN.md**: Verify file exists (defer detailed parsing to Phase 4A)
+2. **Check TODO_LIST.md**: Verify file exists (defer reading to Phase 3)
+3. **Validate Task Directory**: Ensure `.task/` contains at least one IMPL-*.json file
+
+**Key Optimization**: Only existence checks here. Actual file reading happens in later phases.
+
+**Resume Mode**: This phase is skipped when `--resume-session` flag is provided. Resume mode entry point is Phase 3.
+
+### Phase 3: TodoWrite Generation
+**Applies to**: Both normal and resume modes (resume mode entry point)
+
+**Step 0: Update Session Status to Active**
+Before generating TodoWrite, update session status from "planning" to "active":
+```bash
+# Update session status (idempotent - safe to run if already active)
+jq '.status = "active" | .execution_started_at = (.execution_started_at // now | todate)' \
+  .workflow/active/${sessionId}/workflow-session.json > tmp.json && \
+  mv tmp.json .workflow/active/${sessionId}/workflow-session.json
+```
+This ensures the dashboard shows the session as "ACTIVE" during execution.
+
+**Process**:
+1. **Create TodoWrite List**: Generate task list from TODO_LIST.md (not from task JSONs)
+   - Parse TODO_LIST.md to extract all tasks with current statuses
+   - Identify first pending task with met dependencies
+   - Generate comprehensive TodoWrite covering entire workflow
+2. **Prepare Session Context**: Inject workflow paths for agent use (using provided session-id)
+3. **Validate Prerequisites**: Ensure IMPL_PLAN.md and TODO_LIST.md exist and are valid
 
 **Resume Mode Behavior**:
-- Load existing session state directly from `.workflow/{session-id}/`
-- Use session's task files and summaries without discovery
-- Generate TodoWrite from current session progress
-- Proceed immediately to agent execution
+- Load existing TODO_LIST.md directly from `.workflow/active/{session-id}/`
+- Extract current progress from TODO_LIST.md
+- Generate TodoWrite from TODO_LIST.md state
+- Proceed immediately to agent execution (Phase 4)
+
+### Phase 4: Execution Strategy Selection & Task Execution
+**Applies to**: Both normal and resume modes
+
+**Step 4A: Parse Execution Strategy from IMPL_PLAN.md**
+
+Read IMPL_PLAN.md Section 4 to extract:
+- **Execution Model**: Sequential | Parallel | Phased | TDD Cycles
+- **Parallelization Opportunities**: Which tasks can run in parallel
+- **Serialization Requirements**: Which tasks must run sequentially
+- **Critical Path**: Priority execution order
+
+If IMPL_PLAN.md lacks execution strategy, use intelligent fallback (analyze task structure).
+
+**Step 4B: Execute Tasks with Lazy Loading**
+
+**Key Optimization**: Read task JSON **only when needed** for execution
+
+**Execution Loop Pattern**:
+```
+while (TODO_LIST.md has pending tasks) {
+  next_task_id = getTodoWriteInProgressTask()
+  task_json = Read(.workflow/active/{session}/.task/{next_task_id}.json)  // Lazy load
+  executeTaskWithAgent(task_json)
+  updateTodoListMarkCompleted(next_task_id)
+  advanceTodoWriteToNextTask()
+}
+```
+
+**Execution Process per Task**:
+1. **Identify Next Task**: From TodoWrite, get the next `in_progress` task ID
+2. **Load Task JSON on Demand**: Read `.task/{task-id}.json` for current task ONLY
+3. **Validate Task Structure**: Ensure all 5 required fields exist (id, title, status, meta, context, flow_control)
+4. **Launch Agent**: Invoke specialized agent with complete context including flow control steps
+5. **Monitor Progress**: Track agent execution and handle errors without user interruption
+6. **Collect Results**: Gather implementation results and outputs
+7. **Continue Workflow**: Identify next pending task from TODO_LIST.md and repeat
+
+**Note**: TODO_LIST.md updates are handled by agents (e.g., code-developer.md), not by the orchestrator.
 
-### Phase 4: Execution
-1. **Pass Task with Flow Control**: Include complete task JSON with `pre_analysis` steps for agent execution
-2. **Launch Agent**: Invoke specialized agent with complete context including flow control steps
-3. **Monitor Progress**: Track agent execution and handle errors without user interruption
-4. **Collect Results**: Gather implementation results and outputs
-5. **Continue Workflow**: Automatically proceed to next pending task until completion
 
 ### Phase 5: Completion
+**Applies to**: Both normal and resume modes
+
+**Process**:
 1. **Update Task Status**: Mark completed tasks in JSON files
 2. **Generate Summary**: Create task summary in `.summaries/`
 3. **Update TodoWrite**: Mark current task complete, advance to next
 4. **Synchronize State**: Update session state and workflow status
 5. **Check Workflow Complete**: Verify all tasks are completed
-6. **Auto-Complete Session**: Call `/workflow:session:complete` when all tasks finished
+6. **User Choice**: When all tasks finished, ask user to choose next step:
 
-## Task Discovery & Queue Building
-
-### Session Discovery Process (Normal Mode)
-```
-├── Check for .active-* markers in .workflow/
-├── If multiple active sessions found → Prompt user to select
-├── Locate selected session's workflow folder
-├── Load selected session's workflow-session.json and IMPL_PLAN.md
-├── Scan selected session's .task/ directory for task JSON files
-├── Analyze task statuses and dependencies for selected session only
-└── Build execution queue of ready tasks from selected session
+```javascript
+AskUserQuestion({
+  questions: [{
+    question: "All tasks completed. What would you like to do next?",
+    header: "Next Step",
+    multiSelect: false,
+    options: [
+      {
+        label: "Enter Review",
+        description: "Run specialized review (security/architecture/quality/action-items)"
+      },
+      {
+        label: "Complete Session",
+        description: "Archive session and update manifest"
+      }
+    ]
+  }]
+})
 ```
 
-### Resume Mode Process (--resume-session flag)
-```
-├── Use provided session-id directly (skip discovery)
-├── Validate .workflow/{session-id}/ directory exists
-├── Load session's workflow-session.json and IMPL_PLAN.md directly
-├── Scan session's .task/ directory for task JSON files
-├── Use existing task statuses and dependencies (no re-analysis needed)
-└── Build execution queue from session state (prioritize pending/in-progress tasks)
-```
+**Based on user selection**:
+- **"Enter Review"**: Execute `/workflow:review`
+- **"Complete Session"**: Execute `/workflow:session:complete`
+
+## Execution Strategy (IMPL_PLAN-Driven)
+
+### Strategy Priority
+
+**IMPL_PLAN-Driven Execution (Recommended)**:
+1. **Read IMPL_PLAN.md execution strategy** (Section 4: Implementation Strategy)
+2. **Follow explicit guidance**:
+   - Execution Model (Sequential/Parallel/Phased/TDD)
+   - Parallelization Opportunities (which tasks can run in parallel)
+   - Serialization Requirements (which tasks must run sequentially)
+   - Critical Path (priority execution order)
+3. **Use TODO_LIST.md for status tracking** only
+4. **IMPL_PLAN decides "HOW"**, execute.md implements it
+
+**Intelligent Fallback (When IMPL_PLAN lacks execution details)**:
+1. **Analyze task structure**:
+   - Check `meta.execution_group` in task JSONs
+   - Analyze `depends_on` relationships
+   - Understand task complexity and risk
+2. **Apply smart defaults**:
+   - No dependencies + same execution_group → Parallel
+   - Has dependencies → Sequential (wait for deps)
+   - Critical/high-risk tasks → Sequential
+3. **Conservative approach**: When uncertain, prefer sequential execution
+
+### Execution Models
+
+#### 1. Sequential Execution
+**When**: IMPL_PLAN specifies "Sequential" OR no clear parallelization guidance
+**Pattern**: Execute tasks one by one in TODO_LIST order
+**TodoWrite**: ONE task marked as `in_progress` at a time
+
+#### 2. Parallel Execution
+**When**: IMPL_PLAN specifies "Parallel" with clear parallelization opportunities
+**Pattern**: Execute independent task groups concurrently by launching multiple agent instances
+**TodoWrite**: MULTIPLE tasks (in same batch) marked as `in_progress` simultaneously
+**Agent Instantiation**: Launch one agent instance per task (respects ONE AGENT = ONE TASK JSON rule)
+
+#### 3. Phased Execution
+**When**: IMPL_PLAN specifies "Phased" with phase breakdown
+**Pattern**: Execute tasks in phases, respect phase boundaries
+**TodoWrite**: Within each phase, follow Sequential or Parallel rules
+
+#### 4. Intelligent Fallback
+**When**: IMPL_PLAN lacks execution strategy details
+**Pattern**: Analyze task structure and apply smart defaults
+**TodoWrite**: Follow Sequential or Parallel rules based on analysis
 
 ### Task Status Logic
 ```
@@ -136,135 +330,36 @@ completed → skip
 blocked → skip until dependencies clear
 ```
 
-## Batch Execution with Dependency Graph
-
-### Parallel Execution Algorithm
-**Core principle**: Execute independent tasks concurrently in batches based on dependency graph.
-
-#### Algorithm Steps
-```javascript
-function executeBatchWorkflow(sessionId) {
-  // 1. Build dependency graph from task JSONs
-  const graph = buildDependencyGraph(`.workflow/${sessionId}/.task/*.json`);
-
-  // 2. Process batches until graph is empty
-  while (!graph.isEmpty()) {
-    // 3. Identify current batch (tasks with in-degree = 0)
-    const batch = graph.getNodesWithInDegreeZero();
-
-    // 4. Check for parallel execution opportunities
-    const parallelGroups = groupByExecutionGroup(batch);
-
-    // 5. Execute batch concurrently
-    await Promise.all(
-      parallelGroups.map(group => executeBatch(group))
-    );
-
-    // 6. Update graph: remove completed tasks and their edges
-    graph.removeNodes(batch);
-
-    // 7. Update TodoWrite to reflect completed batch
-    updateTodoWriteAfterBatch(batch);
-  }
-
-  // 8. All tasks complete - auto-complete session
-  SlashCommand("/workflow:session:complete");
-}
-
-function buildDependencyGraph(taskFiles) {
-  const tasks = loadAllTaskJSONs(taskFiles);
-  const graph = new DirectedGraph();
-
-  tasks.forEach(task => {
-    graph.addNode(task.id, task);
-
-    // Add edges for dependencies
-    task.context.depends_on?.forEach(depId => {
-      graph.addEdge(depId, task.id); // Edge from dependency to task
-    });
-  });
-
-  return graph;
-}
-
-function groupByExecutionGroup(tasks) {
-  const groups = {};
-
-  tasks.forEach(task => {
-    const groupId = task.meta.execution_group || task.id;
-    if (!groups[groupId]) groups[groupId] = [];
-    groups[groupId].push(task);
-  });
-
-  return Object.values(groups);
-}
-
-async function executeBatch(tasks) {
-  // Execute all tasks in batch concurrently
-  return Promise.all(
-    tasks.map(task => executeTask(task))
-  );
-}
-```
-
-#### Execution Group Rules
-1. **Same `execution_group` ID** → Execute in parallel (independent, different contexts)
-2. **No `execution_group` (null)** → Execute sequentially (has dependencies)
-3. **Different `execution_group` IDs** → Execute in parallel (independent batches)
-4. **Same `context_signature`** → Should have been merged (warning if not)
-
-#### Parallel Execution Example
-```
-Batch 1 (no dependencies):
-  - IMPL-1.1 (execution_group: "parallel-auth-api") → Agent 1
-  - IMPL-1.2 (execution_group: "parallel-ui-comp") → Agent 2
-  - IMPL-1.3 (execution_group: "parallel-db-schema") → Agent 3
-
-Wait for Batch 1 completion...
-
-Batch 2 (depends on Batch 1):
-  - IMPL-2.1 (execution_group: null, depends_on: [IMPL-1.1, IMPL-1.2]) → Agent 1
-
-Wait for Batch 2 completion...
-
-Batch 3 (independent of Batch 2):
-  - IMPL-3.1 (execution_group: "parallel-tests-1") → Agent 1
-  - IMPL-3.2 (execution_group: "parallel-tests-2") → Agent 2
-```
-
 ## TodoWrite Coordination
-**Comprehensive workflow tracking** with immediate status updates throughout entire execution without user interruption:
 
-#### TodoWrite Workflow Rules
-1. **Initial Creation**: Generate TodoWrite from discovered pending tasks for entire workflow
-   - **Normal Mode**: Create from discovery results
-   - **Resume Mode**: Create from existing session state and current progress
-2. **Parallel Task Support**:
-   - **Single-task execution**: Mark ONLY ONE task as `in_progress` at a time
-   - **Batch execution**: Mark ALL tasks in current batch as `in_progress` simultaneously
-   - **Execution group indicator**: Show `[execution_group: group-id]` for parallel tasks
-3. **Immediate Updates**: Update status after each task/batch completion without user interruption
-4. **Status Synchronization**: Sync with JSON task files after updates
-5. **Continuous Tracking**: Maintain TodoWrite throughout entire workflow execution until completion
+### TodoWrite Rules (Unified)
 
-#### Resume Mode TodoWrite Generation
-**Special behavior when `--resume-session` flag is present**:
-- Load existing session progress from `.workflow/{session-id}/TODO_LIST.md`
-- Identify currently in-progress or next pending task
-- Generate TodoWrite starting from interruption point
-- Preserve completed task history in TodoWrite display
-- Focus on remaining pending tasks for execution
+**Rule 1: Initial Creation**
+- **Normal Mode**: Generate TodoWrite from discovered pending tasks for entire workflow
+- **Resume Mode**: Generate from existing session state and current progress
 
-#### TodoWrite Tool Usage
-**Use Claude Code's built-in TodoWrite tool** to track workflow progress in real-time:
+**Rule 2: In-Progress Task Count (Execution-Model-Dependent)**
+- **Sequential execution**: Mark ONLY ONE task as `in_progress` at a time
+- **Parallel batch execution**: Mark ALL tasks in current batch as `in_progress` simultaneously
+- **Execution group indicator**: Show `[execution_group: group-id]` for parallel tasks
 
+**Rule 3: Status Updates**
+- **Immediate Updates**: Update status after each task/batch completion without user interruption
+- **Status Synchronization**: Sync with JSON task files after updates
+- **Continuous Tracking**: Maintain TodoWrite throughout entire workflow execution until completion
+
+**Rule 4: Workflow Completion Check**
+- When all tasks marked `completed`, prompt user to choose review or complete session
+
+### TodoWrite Tool Usage
+
+**Example 1: Sequential Execution**
 ```javascript
-// Example 1: Sequential execution (traditional)
 TodoWrite({
   todos: [
     {
       content: "Execute IMPL-1.1: Design auth schema [code-developer] [FLOW_CONTROL]",
-      status: "in_progress",  // Single task in progress
+      status: "in_progress",  // ONE task in progress
       activeForm: "Executing IMPL-1.1: Design auth schema"
     },
     {
@@ -274,8 +369,10 @@ TodoWrite({
     }
   ]
 });
+```
 
-// Example 2: Batch execution (parallel tasks with execution_group)
+**Example 2: Parallel Batch Execution**
+```javascript
 TodoWrite({
   todos: [
     {
@@ -300,274 +397,67 @@ TodoWrite({
     }
   ]
 });
-
-// Example 3: After batch completion
-TodoWrite({
-  todos: [
-    {
-      content: "Execute IMPL-1.1: Build Auth API [code-developer] [execution_group: parallel-auth-api]",
-      status: "completed",  // Batch completed
-      activeForm: "Executing IMPL-1.1: Build Auth API"
-    },
-    {
-      content: "Execute IMPL-1.2: Build User UI [code-developer] [execution_group: parallel-ui-comp]",
-      status: "completed",  // Batch completed
-      activeForm: "Executing IMPL-1.2: Build User UI"
-    },
-    {
-      content: "Execute IMPL-1.3: Setup Database [code-developer] [execution_group: parallel-db-schema]",
-      status: "completed",  // Batch completed
-      activeForm: "Executing IMPL-1.3: Setup Database"
-    },
-    {
-      content: "Execute IMPL-2.1: Integration Tests [test-fix-agent]",
-      status: "in_progress",  // Next batch started
-      activeForm: "Executing IMPL-2.1: Integration Tests"
-    }
-  ]
-});
 ```
 
-**TodoWrite Integration Rules**:
-- **Continuous Workflow Tracking**: Use TodoWrite tool throughout entire workflow execution
-- **Real-time Updates**: Immediate progress tracking without user interruption
-- **Single Active Task**: Only ONE task marked as `in_progress` at any time
-- **Immediate Completion**: Mark tasks `completed` immediately after finishing
-- **Status Sync**: Sync TodoWrite status with JSON task files after each update
-- **Full Execution**: Continue TodoWrite tracking until all workflow tasks complete
-- **Workflow Completion Check**: When all tasks marked `completed`, auto-call `/workflow:session:complete`
+## Agent Execution Pattern
 
-#### TODO_LIST.md Update Timing
-- **Before Agent Launch**: Update TODO_LIST.md to mark task as `in_progress` (⚠️)
-- **After Task Complete**: Update TODO_LIST.md to mark as `completed` (✅), advance to next
-- **On Error**: Keep as `in_progress` in TODO_LIST.md, add error note
-- **Workflow Complete**: When all tasks completed, call `/workflow:session:complete`
-- **Session End**: Sync all TODO_LIST.md statuses with JSON task files
+### Flow Control Execution
+**[FLOW_CONTROL]** marker indicates task JSON contains `flow_control.pre_analysis` steps for context preparation.
 
-### 3. Agent Context Management
-**Comprehensive context preparation** for autonomous agent execution:
+**Note**: Orchestrator does NOT execute flow control steps - Agent interprets and executes them autonomously.
 
-#### Context Sources (Priority Order)
-1. **Complete Task JSON**: Full task definition including all fields and artifacts
-2. **Artifacts Context**: Brainstorming outputs and synthesis specifications from task.context.artifacts
-3. **Flow Control Context**: Accumulated outputs from pre_analysis steps (including artifact loading)
-4. **Dependency Summaries**: Previous task completion summaries
-5. **Session Context**: Workflow paths and session metadata
-6. **Inherited Context**: Parent task context and shared variables
+### Agent Prompt Template
+**Path-Based Invocation**: Pass paths and trigger markers, let agent parse task JSON autonomously.
 
-#### Context Assembly Process
-```
-1. Load Task JSON → Base context (including artifacts array)
-2. Load Artifacts → Synthesis specifications and brainstorming outputs
-3. Execute Flow Control → Accumulated context (with artifact loading steps)
-4. Load Dependencies → Dependency context
-5. Prepare Session Paths → Session context
-6. Combine All → Complete agent context with artifact integration
-```
-
-#### Agent Context Package Structure
-```json
-{
-  "task": { /* Complete task JSON with artifacts array */ },
-  "artifacts": {
-    "synthesis_specification": { "path": ".workflow/WFS-session/.brainstorming/synthesis-specification.md", "priority": "highest" },
-    "topic_framework": { "path": ".workflow/WFS-session/.brainstorming/topic-framework.md", "priority": "medium" },
-    "role_analyses": [ /* Individual role analysis files */ ],
-    "available_artifacts": [ /* All detected brainstorming artifacts */ ]
-  },
-  "flow_context": {
-    "step_outputs": {
-      "synthesis_specification": "...",
-      "individual_artifacts": "...",
-      "pattern_analysis": "...",
-      "dependency_context": "..."
-    }
-  },
-  "session": {
-    "workflow_dir": ".workflow/WFS-session/",
-    "brainstorming_dir": ".workflow/WFS-session/.brainstorming/",
-    "todo_list_path": ".workflow/WFS-session/TODO_LIST.md",
-    "summaries_dir": ".workflow/WFS-session/.summaries/",
-    "task_json_path": ".workflow/WFS-session/.task/IMPL-1.1.json"
-  },
-  "dependencies": [ /* Task summaries from depends_on */ ],
-  "inherited": { /* Parent task context */ }
-}
-```
-
-#### Context Validation Rules
-- **Task JSON Complete**: All 5 fields present and valid, including artifacts array in context
-- **Artifacts Available**: Synthesis specifications and brainstorming outputs accessible
-- **Flow Control Ready**: All pre_analysis steps completed including artifact loading steps
-- **Dependencies Loaded**: All depends_on summaries available
-- **Session Paths Valid**: All workflow paths exist and accessible, including .brainstorming directory
-- **Agent Assignment**: Valid agent type specified in meta.agent
-
-### 4. Agent Execution Pattern
-**Structured agent invocation** with complete context and clear instructions:
-
-#### Agent Prompt Template
 ```bash
 Task(subagent_type="{meta.agent}",
-     prompt="**EXECUTE TASK FROM JSON**
+     run_in_background=false,
+     prompt="Implement task {task.id}: {task.title}
 
-     ## Task JSON Location
-     {session.task_json_path}
+     [FLOW_CONTROL]
 
-     ## Instructions
-     1. **Load Complete Task JSON**: Read and validate all fields (id, title, status, meta, context, flow_control)
-     2. **Execute Flow Control**: If `flow_control.pre_analysis` exists, execute steps sequentially:
-        - Load artifacts (synthesis-specification.md, role analyses) using commands in each step
-        - Accumulate context from step outputs using variable substitution [variable_name]
-        - Handle errors per step.on_error (skip_optional | fail | retry_once)
-     3. **Implement Solution**: Follow `flow_control.implementation_approach` using accumulated context
-     4. **Complete Task**:
-        - Update task status: `jq '.status = \"completed\"' {session.task_json_path} > temp.json && mv temp.json {session.task_json_path}`
-        - Update TODO list: {session.todo_list_path}
-        - Generate summary: {session.summaries_dir}/{task.id}-summary.md
-        - Check workflow completion and call `/workflow:session:complete` if all tasks done
+     **Input**:
+     - Task JSON: {session.task_json_path}
+     - Context Package: {session.context_package_path}
 
-     ## Context Sources (All from JSON)
-     - Requirements: `context.requirements`
-     - Focus Paths: `context.focus_paths`
-     - Acceptance: `context.acceptance`
-     - Artifacts: `context.artifacts` (synthesis specs, brainstorming outputs)
-     - Dependencies: `context.depends_on`
-     - Target Files: `flow_control.target_files`
-
-     ## Session Paths
-     - Workflow Dir: {session.workflow_dir}
+     **Output Location**:
+     - Workflow: {session.workflow_dir}
      - TODO List: {session.todo_list_path}
      - Summaries: {session.summaries_dir}
-     - Flow Context: {flow_context.step_outputs}
 
-     **Complete JSON structure is authoritative - load and follow it exactly.**"),
-     description="Execute task: {task.id}")
+     **Execution**: Read task JSON → Parse flow_control → Execute implementation_approach → Update TODO_LIST.md → Generate summary",
+     description="Implement: {task.id}")
 ```
 
-#### Agent JSON Loading Specification
-**MANDATORY AGENT PROTOCOL**: All agents must follow this exact loading sequence:
+**Key Markers**:
+- `Implement` keyword: Triggers tech stack detection and guidelines loading
+- `[FLOW_CONTROL]`: Triggers flow_control.pre_analysis execution
 
-1. **JSON Loading**: First action must be `cat {session.task_json_path}`
-2. **Field Validation**: Verify all 5 required fields exist: `id`, `title`, `status`, `meta`, `context`, `flow_control`
-3. **Structure Parsing**: Parse nested fields correctly:
-   - `meta.type` and `meta.agent` (NOT flat `task_type`)
-   - `context.requirements`, `context.focus_paths`, `context.acceptance`
-   - `context.depends_on`, `context.inherited`
-   - `flow_control.pre_analysis` array, `flow_control.target_files`
-4. **Flow Control Execution**: If `flow_control.pre_analysis` exists, execute steps sequentially
-5. **Status Management**: Update JSON status upon completion
+**Why Path-Based**: Agent (code-developer.md) autonomously:
+- Reads and parses task JSON (requirements, acceptance, flow_control)
+- Loads tech stack guidelines based on detected language
+- Executes pre_analysis steps and implementation_approach
+- Generates structured summary with integration points
 
-**JSON Field Reference**:
-```json
-{
-  "id": "IMPL-1.2",
-  "title": "Task title",
-  "status": "pending|active|completed|blocked",
-  "meta": {
-    "type": "feature|bugfix|refactor|test-gen|test-fix|docs",
-    "agent": "@code-developer|@test-fix-agent|@general-purpose"
-  },
-  "context": {
-    "requirements": ["req1", "req2"],
-    "focus_paths": ["src/path1", "src/path2"],
-    "acceptance": ["criteria1", "criteria2"],
-    "depends_on": ["IMPL-1.1"],
-    "inherited": { "from": "parent", "context": ["info"] },
-    "artifacts": [
-      {
-        "type": "synthesis_specification",
-        "source": "brainstorm_synthesis",
-        "path": ".workflow/WFS-[session]/.brainstorming/synthesis-specification.md",
-        "priority": "highest",
-        "contains": "complete_integrated_specification"
-      },
-      {
-        "type": "individual_role_analysis",
-        "source": "brainstorm_roles",
-        "path": ".workflow/WFS-[session]/.brainstorming/[role]/analysis.md",
-        "priority": "low",
-        "contains": "role_specific_analysis_fallback"
-      }
-    ]
-  },
-  "flow_control": {
-    "pre_analysis": [
-      {
-        "step": "load_synthesis_specification",
-        "action": "Load consolidated synthesis specification from brainstorming",
-        "commands": [
-          "bash(ls .workflow/WFS-[session]/.brainstorming/synthesis-specification.md 2>/dev/null || echo 'synthesis specification not found')",
-          "Read(.workflow/WFS-[session]/.brainstorming/synthesis-specification.md)"
-        ],
-        "output_to": "synthesis_specification",
-        "on_error": "skip_optional"
-      },
-      {
-        "step": "step_name",
-        "command": "bash_command",
-        "output_to": "variable",
-        "on_error": "skip_optional|fail|retry_once"
-      }
-    ],
-    "implementation_approach": [
-      {
-        "step": 1,
-        "title": "Implement task following synthesis specification",
-        "description": "Implement '[title]' following synthesis specification. PRIORITY: Use synthesis-specification.md as primary requirement source. When implementation needs technical details (e.g., API schemas, caching configs, design tokens), refer to artifacts[] for detailed specifications from original role analyses.",
-        "modification_points": [
-          "Apply consolidated requirements from synthesis-specification.md",
-          "Follow technical guidelines from synthesis",
-          "Consult artifacts for implementation details when needed",
-          "Integrate with existing patterns"
-        ],
-        "logic_flow": [
-          "Load synthesis specification",
-          "Parse architecture and requirements",
-          "Implement following specification",
-          "Consult artifacts for technical details when needed",
-          "Validate against acceptance criteria"
-        ],
-        "depends_on": [],
-        "output": "implementation"
-      }
-    ],
-    "target_files": ["file:function:lines", "path/to/NewFile.ts"]
-  }
-}
-```
+Embedding task content in prompt creates duplication and conflicts with agent's parsing logic.
 
-#### Execution Flow
-1. **Load Task JSON**: Agent reads and validates complete JSON structure
-2. **Execute Flow Control**: Agent runs pre_analysis steps if present
-3. **Prepare Implementation**: Agent uses implementation_approach from JSON
-4. **Launch Implementation**: Agent follows focus_paths and target_files
-5. **Update Status**: Agent marks JSON status as completed
-6. **Generate Summary**: Agent creates completion summary
-
-#### Agent Assignment Rules
+### Agent Assignment Rules
 ```
 meta.agent specified → Use specified agent
 meta.agent missing → Infer from meta.type:
   - "feature" → @code-developer
   - "test-gen" → @code-developer
   - "test-fix" → @test-fix-agent
-  - "review" → @general-purpose
+  - "review" → @universal-executor
   - "docs" → @doc-generator
 ```
 
-#### Error Handling During Execution
-- **Agent Failure**: Retry once with adjusted context
-- **Flow Control Error**: Skip optional steps, fail on critical
-- **Context Missing**: Reload from JSON files and retry
-- **Timeout**: Mark as blocked, continue with next task
-
 ## Workflow File Structure Reference
 ```
-.workflow/WFS-[topic-slug]/
+.workflow/active/WFS-[topic-slug]/
 ├── workflow-session.json     # Session state and metadata
 ├── IMPL_PLAN.md             # Planning document and requirements
-├── TODO_LIST.md             # Progress tracking (auto-updated)
+├── TODO_LIST.md             # Progress tracking (updated by agents)
 ├── .task/                   # Task definitions (JSON only)
 │   ├── IMPL-1.json          # Main task definitions
 │   └── IMPL-1.1.json        # Subtask definitions
@@ -575,78 +465,26 @@ meta.agent missing → Infer from meta.type:
 │   ├── IMPL-1-summary.md    # Task completion details
 │   └── IMPL-1.1-summary.md  # Subtask completion details
 └── .process/                # Planning artifacts
+    ├── context-package.json # Smart context package
     └── ANALYSIS_RESULTS.md  # Planning analysis results
 ```
 
 ## Error Handling & Recovery
 
-### Discovery Phase Errors
-| Error | Cause | Resolution | Command |
-|-------|-------|------------|---------|
-| No active session | No `.active-*` markers found | Create or resume session | `/workflow:plan "project"` |
-| Multiple sessions | Multiple `.active-*` markers | Select specific session | Manual choice prompt |
-| Corrupted session | Invalid JSON files | Recreate session structure | `/workflow:session:status --validate` |
-| Missing task files | Broken task references | Regenerate tasks | `/task:create` or repair |
+### Common Errors & Recovery
 
-### Execution Phase Errors
-| Error | Cause | Recovery Strategy | Max Attempts |
-|-------|-------|------------------|--------------|
+| Error Type | Cause | Recovery Strategy | Max Attempts |
+|-----------|-------|------------------|--------------|
+| **Discovery Errors** |
+| No active session | No sessions in `.workflow/active/` | Create or resume session: `/workflow:plan "project"` | N/A |
+| Multiple sessions | Multiple sessions in `.workflow/active/` | Prompt user selection | N/A |
+| Corrupted session | Invalid JSON files | Recreate session structure or validate files | N/A |
+| **Execution Errors** |
 | Agent failure | Agent crash/timeout | Retry with simplified context | 2 |
 | Flow control error | Command failure | Skip optional, fail critical | 1 per step |
 | Context loading error | Missing dependencies | Reload from JSON, use defaults | 3 |
 | JSON file corruption | File system issues | Restore from backup/recreate | 1 |
 
-### Recovery Procedures
-
-#### Session Recovery
-```bash
-# Check session integrity
-find .workflow -name ".active-*" | while read marker; do
-  session=$(basename "$marker" | sed 's/^\.active-//')
-  if [ ! -d ".workflow/$session" ]; then
-    echo "Removing orphaned marker: $marker"
-    rm "$marker"
-  fi
-done
-
-# Recreate corrupted session files
-if [ ! -f ".workflow/$session/workflow-session.json" ]; then
-  echo '{"session_id":"'$session'","status":"active"}' > ".workflow/$session/workflow-session.json"
-fi
-```
-
-#### Task Recovery
-```bash
-# Validate task JSON integrity
-for task_file in .workflow/$session/.task/*.json; do
-  if ! jq empty "$task_file" 2>/dev/null; then
-    echo "Corrupted task file: $task_file"
-    # Backup and regenerate or restore from backup
-  fi
-done
-
-# Fix missing dependencies
-missing_deps=$(jq -r '.context.depends_on[]?' .workflow/$session/.task/*.json | sort -u)
-for dep in $missing_deps; do
-  if [ ! -f ".workflow/$session/.task/$dep.json" ]; then
-    echo "Missing dependency: $dep - creating placeholder"
-  fi
-done
-```
-
-#### Context Recovery
-```bash
-# Reload context from available sources
-if [ -f ".workflow/$session/.process/ANALYSIS_RESULTS.md" ]; then
-  echo "Reloading planning context..."
-fi
-
-# Restore from documentation if available
-if [ -d ".workflow/docs/" ]; then
-  echo "Using documentation context as fallback..."
-fi
-```
-
 ### Error Prevention
 - **Pre-flight Checks**: Validate session integrity before execution
 - **Backup Strategy**: Create task snapshots before major operations
@@ -654,16 +492,3 @@ fi
 - **Dependency Validation**: Check all depends_on references exist
 - **Context Verification**: Ensure all required context is available
 
-## Usage Examples
-
-### Basic Usage
-```bash
-/workflow:execute          # Execute all pending tasks autonomously
-/workflow:session:status           # Check progress
-/task:execute IMPL-1.2     # Execute specific task
-```
-
-### Integration
-- **Planning**: `/workflow:plan` → `/workflow:execute` → `/workflow:review`
-- **Recovery**: `/workflow:status --validate` → `/workflow:execute`
-

.claude/commands/workflow/init.md

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

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

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

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

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

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

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

.claude/commands/workflow/plan.md

@@ -1,7 +1,7 @@
 ---
 name: plan
-description: Orchestrate 5-phase planning workflow with quality gate, executing commands and passing context between phases
-argument-hint: "[--agent] [--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: "\"text description\"|file.md"
 allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*)
 ---
 
@@ -13,26 +13,28 @@ allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*)
 
 **Execution Model - Auto-Continue Workflow with Quality Gate**:
 
-This workflow runs **mostly autonomously** once triggered, with one interactive quality gate (Phase 3.5). Phases 3 and 4 are delegated to specialized agents for complex analysis and task generation.
+This workflow runs **fully autonomously** once triggered. Phase 3 (conflict resolution) and Phase 4 (task generation) are delegated to specialized agents.
+
 
 1. **User triggers**: `/workflow:plan "task"`
 2. **Phase 1 executes** → Session discovery → Auto-continues
 3. **Phase 2 executes** → Context gathering → Auto-continues
-4. **Phase 3 executes** (cli-execution-agent) → Intelligent analysis → Auto-continues
-5. **Phase 3.5 executes** → **Pauses for user Q&A** → User answers clarification questions → Auto-continues
-6. **Phase 4 executes** (task-generate-agent if --agent) → Task generation → Reports final summary
+4. **Phase 3 executes** (optional, if conflict_risk ≥ medium) → Conflict resolution → Auto-continues
+5. **Phase 4 executes** → Task generation (task-generate-agent) → Reports final summary
+
+**Task Attachment Model**:
+- SlashCommand execute **expands workflow** by attaching sub-tasks to current TodoWrite
+- When a sub-command is executed (e.g., `/workflow:tools:context-gather`), its internal tasks are attached to the orchestrator's TodoWrite
+- Orchestrator **executes these attached tasks** sequentially
+- After completion, attached tasks are **collapsed** back to high-level phase summary
+- This is **task expansion**, not external delegation
 
 **Auto-Continue Mechanism**:
-- TodoList tracks current phase status
-- After each phase completion, automatically executes next pending phase
-- **Phase 3.5 requires user interaction** - answers clarification questions (up to 5)
-- If no ambiguities found, Phase 3.5 auto-skips and continues to Phase 4
+- TodoList tracks current phase status and dynamically manages task attachment/collapse
+- When each phase finishes executing, automatically execute next pending phase
+- All phases run autonomously without user interaction (clarification handled in brainstorm phase)
 - Progress updates shown at each phase for visibility
-
-**Execution Modes**:
-- **Manual Mode** (default): Use `/workflow:tools:task-generate`
-- **Agent Mode** (`--agent`): Use `/workflow:tools:task-generate-agent`
-- **CLI Execute Mode** (`--cli-execute`): Generate tasks with Codex execution commands
+- **⚠️ CONTINUOUS EXECUTION** - Do not stop until all phases complete
 
 ## Core Rules
 
@@ -40,13 +42,49 @@ This workflow runs **mostly autonomously** once triggered, with one interactive
 2. **No Preliminary Analysis**: Do not read files, analyze structure, or gather context before Phase 1
 3. **Parse Every Output**: Extract required data from each command/agent output for next phase
 4. **Auto-Continue via TodoList**: Check TodoList status to execute next pending phase automatically
-5. **Track Progress**: Update TodoWrite after every phase completion
-6. **Agent Delegation**: Phase 3 uses cli-execution-agent for autonomous intelligent analysis
+5. **Track Progress**: Update TodoWrite dynamically with task attachment/collapse pattern
+6. **Task Attachment Model**: SlashCommand execute **attaches** sub-tasks to current workflow. Orchestrator **executes** these attached tasks itself, then **collapses** them after completion
+7. **⚠️ CRITICAL: DO NOT STOP**: Continuous multi-phase workflow. After executing all attached tasks, immediately collapse them and execute next phase
+
+## Execution Process
+
+```
+Input Parsing:
+   └─ Convert user input to structured format (GOAL/SCOPE/CONTEXT)
+
+Phase 1: Session Discovery
+   └─ /workflow:session:start --auto "structured-description"
+      └─ Output: sessionId (WFS-xxx)
+
+Phase 2: Context Gathering
+   └─ /workflow:tools:context-gather --session sessionId "structured-description"
+      ├─ Tasks attached: Analyze structure → Identify integration → Generate package
+      └─ Output: contextPath + conflict_risk
+
+Phase 3: Conflict Resolution 
+   └─ Decision (conflict_risk check):
+      ├─ conflict_risk ≥ medium → Execute /workflow:tools:conflict-resolution
+      │   ├─ Tasks attached: Detect conflicts → Present to user → Apply strategies
+      │   └─ Output: Modified brainstorm artifacts
+      └─ conflict_risk < medium → Skip to Phase 4
+
+Phase 4: Task Generation
+   └─ /workflow:tools:task-generate-agent --session sessionId
+      └─ Output: IMPL_PLAN.md, task JSONs, TODO_LIST.md
+
+Return:
+   └─ Summary with recommended next steps
+```
 
 ## 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**:
 ```
@@ -67,7 +105,9 @@ CONTEXT: Existing user database schema, REST API endpoints
 
 **Validation**:
 - Session ID successfully extracted
-- Session directory `.workflow/[sessionId]/` exists
+- Session directory `.workflow/active/[sessionId]/` exists
+
+**Note**: Session directory contains `workflow-session.json` (metadata). Do NOT look for `manifest.json` here - it only exists in `.workflow/archives/` for archived sessions.
 
 **TodoWrite**: Mark phase 1 completed, phase 2 in_progress
 
@@ -76,7 +116,12 @@ CONTEXT: Existing user database schema, REST API endpoints
 ---
 
 ### 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
 
@@ -84,152 +129,234 @@ CONTEXT: Existing user database schema, REST API endpoints
 
 **Parse Output**:
 - Extract: context-package.json path (store as `contextPath`)
-- Typical pattern: `.workflow/[sessionId]/.process/context-package.json`
+- Typical pattern: `.workflow/active/[sessionId]/.process/context-package.json`
 
 **Validation**:
 - Context package path extracted
 - File exists and is valid JSON
 
-**TodoWrite**: Mark phase 2 completed, phase 3 in_progress
+<!-- TodoWrite: When context-gather executed, INSERT 3 context-gather tasks, mark first as in_progress -->
 
-**After Phase 2**: Return to user showing Phase 2 results, then auto-continue to Phase 3
+**TodoWrite Update (Phase 2 SlashCommand executed - tasks attached)**:
+```json
+[
+  {"content": "Phase 1: Session Discovery", "status": "completed", "activeForm": "Executing session discovery"},
+  {"content": "Phase 2: Context Gathering", "status": "in_progress", "activeForm": "Executing context gathering"},
+  {"content": "  → Analyze codebase structure", "status": "in_progress", "activeForm": "Analyzing codebase structure"},
+  {"content": "  → Identify integration points", "status": "pending", "activeForm": "Identifying integration points"},
+  {"content": "  → Generate context package", "status": "pending", "activeForm": "Generating context package"},
+  {"content": "Phase 4: Task Generation", "status": "pending", "activeForm": "Executing task generation"}
+]
+```
+
+**Note**: SlashCommand execute **attaches** context-gather's 3 tasks. Orchestrator **executes** these tasks sequentially.
+
+<!-- TodoWrite: After Phase 2 tasks complete, REMOVE Phase 2.1-2.3, restore to orchestrator view -->
+
+**TodoWrite Update (Phase 2 completed - tasks collapsed)**:
+```json
+[
+  {"content": "Phase 1: Session Discovery", "status": "completed", "activeForm": "Executing session discovery"},
+  {"content": "Phase 2: Context Gathering", "status": "completed", "activeForm": "Executing context gathering"},
+  {"content": "Phase 4: Task Generation", "status": "pending", "activeForm": "Executing task generation"}
+]
+```
+
+**Note**: Phase 2 tasks completed and collapsed to summary.
+
+**After Phase 2**: Return to user showing Phase 2 results, then auto-continue to Phase 3/4 (depending on conflict_risk)
 
 ---
 
-### Phase 3: Intelligent Analysis
+### Phase 3: Conflict Resolution
 
-**Command**: `SlashCommand(command="/workflow:tools:concept-enhanced --session [sessionId] --context [contextPath]")`
+**Trigger**: Only execute when context-package.json indicates conflict_risk is "medium" or "high"
 
-**Input**: `sessionId` from Phase 1, `contextPath` from Phase 2
+**Step 3.1: Execute** - Detect and resolve conflicts with CLI analysis
+
+```javascript
+SlashCommand(command="/workflow:tools:conflict-resolution --session [sessionId] --context [contextPath]")
+```
+
+**Input**:
+- sessionId from Phase 1
+- contextPath from Phase 2
+- conflict_risk from context-package.json
 
 **Parse Output**:
-- Extract: Execution status (success/failed)
-- Verify: ANALYSIS_RESULTS.md file path
+- Extract: Execution status (success/skipped/failed)
+- Verify: conflict-resolution.json file path (if executed)
 
 **Validation**:
-- File `.workflow/[sessionId]/.process/ANALYSIS_RESULTS.md` exists
+- File `.workflow/active/[sessionId]/.process/conflict-resolution.json` exists (if executed)
 
+**Skip Behavior**:
+- If conflict_risk is "none" or "low", skip directly to Phase 3.5
+- Display: "No significant conflicts detected, proceeding to clarification"
 
-**TodoWrite**: Mark phase 3 completed, phase 3.5 in_progress
+<!-- TodoWrite: If conflict_risk ≥ medium, INSERT 3 conflict-resolution tasks -->
 
-**After Phase 3**: Return to user showing Phase 3 results, then auto-continue to Phase 3.5
+**TodoWrite Update (Phase 3 SlashCommand executed - tasks attached, if conflict_risk ≥ medium)**:
+```json
+[
+  {"content": "Phase 1: Session Discovery", "status": "completed", "activeForm": "Executing session discovery"},
+  {"content": "Phase 2: Context Gathering", "status": "completed", "activeForm": "Executing context gathering"},
+  {"content": "Phase 3: Conflict Resolution", "status": "in_progress", "activeForm": "Resolving conflicts"},
+  {"content": "  → Detect conflicts with CLI analysis", "status": "in_progress", "activeForm": "Detecting conflicts"},
+  {"content": "  → Present conflicts to user", "status": "pending", "activeForm": "Presenting conflicts"},
+  {"content": "  → Apply resolution strategies", "status": "pending", "activeForm": "Applying resolution strategies"},
+  {"content": "Phase 4: Task Generation", "status": "pending", "activeForm": "Executing task generation"}
+]
+```
+
+**Note**: SlashCommand execute **attaches** conflict-resolution's 3 tasks. Orchestrator **executes** these tasks sequentially.
+
+<!-- TodoWrite: After Phase 3 tasks complete, REMOVE Phase 3.1-3.3, restore to orchestrator view -->
+
+**TodoWrite Update (Phase 3 completed - tasks collapsed)**:
+```json
+[
+  {"content": "Phase 1: Session Discovery", "status": "completed", "activeForm": "Executing session discovery"},
+  {"content": "Phase 2: Context Gathering", "status": "completed", "activeForm": "Executing context gathering"},
+  {"content": "Phase 3: Conflict Resolution", "status": "completed", "activeForm": "Resolving conflicts"},
+  {"content": "Phase 4: Task Generation", "status": "pending", "activeForm": "Executing task generation"}
+]
+```
+
+**Note**: Phase 3 tasks completed and collapsed to summary.
+
+**After Phase 3**: Return to user showing conflict resolution results (if executed) and selected strategies, then auto-continue to Phase 3.5
 
 **Memory State Check**:
 - Evaluate current context window usage and memory state
-- If memory usage is high (>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
 
 ---
 
-### Phase 3.5: Concept Clarification (Quality Gate)
+### Phase 3.5: Pre-Task Generation Validation (Optional Quality Gate)
 
-**Command**: `SlashCommand(command="/workflow:concept-clarify --session [sessionId]")`
+**Purpose**: Optional quality gate before task generation - primarily handled by brainstorm synthesis phase
 
-**Purpose**: Quality gate to verify and clarify analysis results before task generation
 
-**Input**: `sessionId` from Phase 1
+**Current Behavior**: Auto-skip to Phase 4 (Task Generation)
 
-**Behavior**:
-- Auto-detects plan mode (ANALYSIS_RESULTS.md exists)
-- Interactively asks up to 5 targeted questions to resolve ambiguities
-- Updates ANALYSIS_RESULTS.md with clarifications
-- Pauses workflow for user input (breaks auto-continue temporarily)
+**Future Enhancement**: Could add additional validation steps like:
+- Cross-reference checks between conflict resolution and brainstorm analyses
+- Final sanity checks before task generation
+- User confirmation prompt for proceeding
 
-**Parse Output**:
-- Verify clarifications added to ANALYSIS_RESULTS.md
-- Check recommendation: "PROCEED" or "ADDRESS_OUTSTANDING"
+**TodoWrite**: Mark phase 3.5 completed (auto-skip), phase 4 in_progress
 
-**Validation**:
-- ANALYSIS_RESULTS.md updated with `## Clarifications` section
-- All critical ambiguities resolved or documented as outstanding
-
-**TodoWrite**: Mark phase 3.5 completed, phase 4 in_progress
-
-**After Phase 3.5**: Return to user showing clarification summary, then auto-continue to Phase 4
-
-**Skip Conditions**:
-- If `/workflow:concept-clarify` reports "No critical ambiguities detected", automatically proceed to Phase 4
-- User can skip by responding "skip" or "proceed" immediately
+**After Phase 3.5**: Auto-continue to Phase 4 immediately
 
 ---
 
 ### Phase 4: Task Generation
 
 **Relationship with Brainstorm Phase**:
-- If brainstorm synthesis exists (synthesis-specification.md), Phase 3 analysis incorporates it as input
-- **⚠️ User's original intent is ALWAYS primary**: New or refined user goals override synthesis recommendations
-- **synthesis-specification.md defines "WHAT"**: Requirements, design specs, high-level features
+- If brainstorm role analyses exist ([role]/analysis.md files), Phase 3 analysis incorporates them as input
+- **User's original intent is ALWAYS primary**: New or refined user goals override brainstorm recommendations
+- **Role analysis.md files define "WHAT"**: Requirements, design specs, role-specific insights
 - **IMPL_PLAN.md defines "HOW"**: Executable task breakdown, dependencies, implementation sequence
-- Task generation translates high-level specifications into concrete, actionable work items
-- **Intent priority**: Current user prompt > synthesis-specification.md > topic-framework.md
+- 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 Selection**:
-- Manual: `SlashCommand(command="/workflow:tools:task-generate --session [sessionId]")`
-- Agent: `SlashCommand(command="/workflow:tools:task-generate-agent --session [sessionId]")`
-- CLI Execute: Add `--cli-execute` flag to either command
+**Step 4.1: Execute** - Generate implementation plan and task JSONs
 
-**Flag Combination**:
-- `--cli-execute` alone: Manual task generation with CLI execution
-- `--agent --cli-execute`: Agent task generation with CLI execution
-
-**Command Examples**:
-```bash
-# Manual with CLI execution
-/workflow:tools:task-generate --session WFS-auth --cli-execute
-
-# Agent with CLI execution
-/workflow:tools:task-generate-agent --session WFS-auth --cli-execute
+```javascript
+SlashCommand(command="/workflow:tools:task-generate-agent --session [sessionId]")
 ```
 
+**CLI Execution Note**: CLI tool usage is now determined semantically by action-planning-agent based on user's task description. If user specifies "use Codex/Gemini/Qwen for X", the agent embeds `command` fields in relevant `implementation_approach` steps.
+
 **Input**: `sessionId` from Phase 1
 
 **Validation**:
-- `.workflow/[sessionId]/IMPL_PLAN.md` exists
-- `.workflow/[sessionId]/.task/IMPL-*.json` exists (at least one)
-- `.workflow/[sessionId]/TODO_LIST.md` exists
+- `.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**: Mark phase 4 completed
+<!-- TodoWrite: When task-generate-agent executed, ATTACH 1 agent task -->
+
+**TodoWrite Update (Phase 4 SlashCommand executed - agent task attached)**:
+```json
+[
+  {"content": "Phase 1: Session Discovery", "status": "completed", "activeForm": "Executing session discovery"},
+  {"content": "Phase 2: Context Gathering", "status": "completed", "activeForm": "Executing context gathering"},
+  {"content": "Phase 4: Task Generation", "status": "in_progress", "activeForm": "Executing task generation"}
+]
+```
+
+**Note**: Single agent task attached. Agent autonomously completes discovery, planning, and output generation internally.
+
+<!-- TodoWrite: After agent completes, mark task as completed -->
+
+**TodoWrite Update (Phase 4 completed)**:
+```json
+[
+  {"content": "Phase 1: Session Discovery", "status": "completed", "activeForm": "Executing session discovery"},
+  {"content": "Phase 2: Context Gathering", "status": "completed", "activeForm": "Executing context gathering"},
+  {"content": "Phase 4: Task Generation", "status": "completed", "activeForm": "Executing task generation"}
+]
+```
+
+**Note**: Agent task completed. No collapse needed (single task).
 
 **Return to User**:
 ```
 Planning complete for session: [sessionId]
 Tasks generated: [count]
-Plan: .workflow/[sessionId]/IMPL_PLAN.md
+Plan: .workflow/active/[sessionId]/IMPL_PLAN.md
 
-✅ Recommended Next Steps:
+Recommended Next Steps:
 1. /workflow:action-plan-verify --session [sessionId]  # Verify plan quality before execution
 2. /workflow:status  # Review task breakdown
 3. /workflow:execute  # Start implementation (after verification)
 
-⚠️ Quality Gate: Consider running /workflow:action-plan-verify to catch issues early
+Quality Gate: Consider running /workflow:action-plan-verify to catch issues early
 ```
 
 ## TodoWrite Pattern
 
-```javascript
-// Initialize (before Phase 1)
-TodoWrite({todos: [
-  {"content": "Execute session discovery", "status": "in_progress", "activeForm": "Executing session discovery"},
-  {"content": "Execute context gathering", "status": "pending", "activeForm": "Executing context gathering"},
-  {"content": "Execute intelligent analysis", "status": "pending", "activeForm": "Executing intelligent analysis"},
-  {"content": "Execute concept clarification", "status": "pending", "activeForm": "Executing concept clarification"},
-  {"content": "Execute task generation", "status": "pending", "activeForm": "Executing task generation"}
-]})
+**Core Concept**: Dynamic task attachment and collapse for real-time visibility into workflow execution.
 
-// After Phase 1
-TodoWrite({todos: [
-  {"content": "Execute session discovery", "status": "completed", "activeForm": "Executing session discovery"},
-  {"content": "Execute context gathering", "status": "in_progress", "activeForm": "Executing context gathering"},
-  {"content": "Execute intelligent analysis", "status": "pending", "activeForm": "Executing intelligent analysis"},
-  {"content": "Execute concept clarification", "status": "pending", "activeForm": "Executing concept clarification"},
-  {"content": "Execute task generation", "status": "pending", "activeForm": "Executing task generation"}
-]})
+### Key Principles
 
-// Continue pattern for Phase 2, 3, 3.5, 4...
-```
+1. **Task Attachment** (when SlashCommand executed):
+   - Sub-command's internal tasks are **attached** to orchestrator's TodoWrite
+   - **Phase 2, 3**: Multiple sub-tasks attached (e.g., Phase 2.1, 2.2, 2.3)
+   - **Phase 4**: Single agent task attached (e.g., "Execute task-generate-agent")
+   - First attached task marked as `in_progress`, others as `pending`
+   - Orchestrator **executes** these attached tasks sequentially
+
+2. **Task Collapse** (after sub-tasks complete):
+   - **Applies to Phase 2, 3**: Remove detailed sub-tasks from TodoWrite
+   - **Collapse** to high-level phase summary
+   - Example: Phase 2.1-2.3 collapse to "Execute context gathering: completed"
+   - **Phase 4**: No collapse needed (single task, just mark completed)
+   - Maintains clean orchestrator-level view
+
+3. **Continuous Execution**:
+   - After completion, automatically proceed to next pending phase
+   - No user intervention required between phases
+   - TodoWrite dynamically reflects current execution state
+
+**Lifecycle Summary**: Initial pending tasks → Phase executed (tasks ATTACHED) → Sub-tasks executed sequentially → Phase completed (tasks COLLAPSED to summary for Phase 2/3, or marked completed for Phase 4) → Next phase begins → Repeat until all phases complete.
+
+
+
+**Note**: See individual Phase descriptions for detailed TodoWrite Update examples:
+- **Phase 2, 3**: Multiple sub-tasks with attach/collapse pattern
+- **Phase 4**: Single agent task (no collapse needed)
 
 ## Input Processing
 
@@ -277,20 +404,22 @@ Phase 1: session:start --auto "structured-description"
     ↓
 Phase 2: context-gather --session sessionId "structured-description"
     ↓ Input: sessionId + session memory + structured description
-    ↓ Output: contextPath (context-package.json)
+    ↓ Output: contextPath (context-package.json) + conflict_risk
     ↓
-Phase 3: cli-execution-agent (Intelligent Analysis)
-    ↓ Input: sessionId + contextPath + task description
-    ↓ Agent discovers context, enhances prompt, executes with Gemini
-    ↓ Output: ANALYSIS_RESULTS.md + execution log
+Phase 3: conflict-resolution [AUTO-TRIGGERED if conflict_risk ≥ medium]
+    ↓ Input: sessionId + contextPath + conflict_risk
+    ↓ CLI-powered conflict detection (JSON output)
+    ↓ AskUserQuestion: Present conflicts + resolution strategies
+    ↓ User selects strategies (or skip)
+    ↓ Apply modifications via Edit tool:
+    ↓   - Update guidance-specification.md
+    ↓   - Update role analyses (*.md)
+    ↓   - Mark context-package.json as "resolved"
+    ↓ Output: Modified brainstorm artifacts (NO report file)
+    ↓ Skip if conflict_risk is none/low → proceed directly to Phase 4
     ↓
-Phase 3.5: concept-clarify --session sessionId (Quality Gate)
-    ↓ Input: sessionId + ANALYSIS_RESULTS.md (auto-detected)
-    ↓ Interactive: User answers clarification questions
-    ↓ Output: Updated ANALYSIS_RESULTS.md with clarifications
-    ↓
-Phase 4: task-generate[--agent] --session sessionId
-    ↓ Input: sessionId + clarified ANALYSIS_RESULTS.md + session memory
+Phase 4: task-generate-agent --session sessionId
+    ↓ Input: sessionId + resolved brainstorm artifacts + session memory
     ↓ Output: IMPL_PLAN.md, task JSONs, TODO_LIST.md
     ↓
 Return summary to user
@@ -299,14 +428,58 @@ Return summary to user
 **Session Memory Flow**: Each phase receives session ID, which provides access to:
 - Previous task summaries
 - Existing context and analysis
-- Brainstorming artifacts
+- Brainstorming artifacts (potentially modified by Phase 3)
 - Session-specific configuration
 
-**Structured Description Benefits**:
-- **Clarity**: Clear separation of goal, scope, and context
-- **Consistency**: Same format across all phases
-- **Traceability**: Easy to track what was requested
-- **Precision**: Better context gathering and analysis
+
+## Execution Flow Diagram
+
+```
+User triggers: /workflow:plan "Build authentication system"
+  ↓
+[TodoWrite Init] 3 orchestrator-level tasks
+  ↓
+Phase 1: Session Discovery
+  → sessionId extracted
+  ↓
+Phase 2: Context Gathering (SlashCommand executed)
+  → ATTACH 3 sub-tasks: ← ATTACHED
+    - → Analyze codebase structure
+    - → Identify integration points
+    - → Generate context package
+  → Execute sub-tasks sequentially
+  → COLLAPSE tasks ← COLLAPSED
+  → contextPath + conflict_risk extracted
+  ↓
+Conditional Branch: Check conflict_risk
+  ├─ IF conflict_risk ≥ medium:
+  │   Phase 3: Conflict Resolution (SlashCommand executed)
+  │     → ATTACH 3 sub-tasks: ← ATTACHED
+  │       - → Detect conflicts with CLI analysis
+  │       - → Present conflicts to user
+  │       - → Apply resolution strategies
+  │     → Execute sub-tasks sequentially
+  │     → COLLAPSE tasks ← COLLAPSED
+  │
+  └─ ELSE: Skip Phase 3, proceed to Phase 4
+  ↓
+Phase 4: Task Generation (SlashCommand executed)
+  → Single agent task (no sub-tasks)
+  → Agent autonomously completes internally:
+    (discovery → planning → output)
+  → Outputs: IMPL_PLAN.md, IMPL-*.json, TODO_LIST.md
+  ↓
+Return summary to user
+```
+
+**Key Points**:
+- **← ATTACHED**: Tasks attached to TodoWrite when SlashCommand executed
+  - Phase 2, 3: Multiple sub-tasks
+  - Phase 4: Single agent task
+- **← COLLAPSED**: Sub-tasks collapsed to summary after completion (Phase 2, 3 only)
+- **Phase 4**: Single agent task, no collapse (just mark completed)
+- **Conditional Branch**: Phase 3 only executes if conflict_risk ≥ medium
+- **Continuous Flow**: No user intervention between phases
 
 ## Error Handling
 
@@ -316,27 +489,21 @@ Return summary to user
 
 ## Coordinator Checklist
 
-✅ **Pre-Phase**: Convert user input to structured format (GOAL/SCOPE/CONTEXT)
-✅ Initialize TodoWrite before any command (include Phase 3.5)
-✅ Execute Phase 1 immediately with structured description
-✅ Parse session ID from Phase 1 output, store in memory
-✅ Pass session ID and structured description to Phase 2 command
-✅ Parse context path from Phase 2 output, store in memory
-✅ **Launch Phase 3 agent**: Build Task prompt with sessionId and contextPath
-✅ Wait for agent completion, parse execution log path
-✅ Verify ANALYSIS_RESULTS.md created by agent
-✅ **Execute Phase 3.5**: Pass session ID to `/workflow:concept-clarify`
-✅ Wait for user interaction (clarification Q&A)
-✅ Verify ANALYSIS_RESULTS.md updated with clarifications
-✅ Check recommendation: proceed if "PROCEED", otherwise alert user
-✅ **Build Phase 4 command** based on flags:
-  - Base command: `/workflow:tools:task-generate` (or `-agent` if `--agent` flag)
-  - Add `--session [sessionId]`
-  - Add `--cli-execute` if flag present
-✅ Pass session ID to Phase 4 command
-✅ Verify all Phase 4 outputs
-✅ Update TodoWrite after each phase
-✅ After each phase, automatically continue to next phase based on TodoList status
+- **Pre-Phase**: Convert user input to structured format (GOAL/SCOPE/CONTEXT)
+- Initialize TodoWrite before any command (Phase 3 added dynamically after Phase 2)
+- Execute Phase 1 immediately with structured description
+- Parse session ID from Phase 1 output, store in memory
+- Pass session ID and structured description to Phase 2 command
+- Parse context path from Phase 2 output, store in memory
+- **Extract conflict_risk from context-package.json**: Determine Phase 3 execution
+- **If conflict_risk ≥ medium**: Launch Phase 3 conflict-resolution with sessionId and contextPath
+- Wait for Phase 3 to finish executing (if executed), verify conflict-resolution.json created
+- **If conflict_risk is none/low**: Skip Phase 3, proceed directly to Phase 4
+- **Build Phase 4 command**: `/workflow:tools:task-generate-agent --session [sessionId]`
+- Pass session ID to Phase 4 command
+- Verify all Phase 4 outputs
+- Update TodoWrite after each phase (dynamically adjust for Phase 3 presence)
+- After each phase, automatically continue to next phase based on TodoList status
 
 ## Structure Template Reference
 
@@ -364,3 +531,21 @@ CONSTRAINTS: [Limitations or boundaries]
 # Phase 2
 /workflow:tools:context-gather --session WFS-123 "GOAL: Build authentication\nSCOPE: JWT, login, registration\nCONTEXT: REST API"
 ```
+
+## Related Commands
+
+**Prerequisite Commands**:
+- `/workflow:brainstorm:artifacts` - Optional: Generate role-based analyses before planning (if complex requirements need multiple perspectives)
+- `/workflow:brainstorm:synthesis` - Optional: Refine brainstorm analyses with clarifications
+
+**Called by This Command** (5 phases):
+- `/workflow:session:start` - Phase 1: Create or discover workflow session
+- `/workflow:tools:context-gather` - Phase 2: Gather project context and analyze codebase
+- `/workflow:tools:conflict-resolution` - Phase 3: Detect and resolve conflicts (auto-triggered if conflict_risk ≥ medium)
+- `/compact` - Phase 3: Memory optimization (if context approaching limits)
+- `/workflow:tools:task-generate-agent` - Phase 4: Generate task JSON files with agent-driven approach
+
+**Follow-up Commands**:
+- `/workflow:action-plan-verify` - Recommended: Verify plan quality and catch issues before execution
+- `/workflow:status` - Review task breakdown and current progress
+- `/workflow:execute` - Begin implementation of generated tasks

.claude/commands/workflow/replan.md

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

.claude/commands/workflow/resume.md

@@ -1,93 +0,0 @@
----
-name: resume
-description: Intelligent workflow session resumption with automatic progress analysis
-argument-hint: "session-id for workflow session to resume"
-allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*)
----
-
-# Sequential Workflow Resume Command
-
-## Usage
-```bash
-/workflow:resume "<session-id>"
-```
-
-## Purpose
-**Sequential command coordination for workflow resumption** by first analyzing current session status, then continuing execution with special resume context. This command orchestrates intelligent session resumption through two-step process.
-
-## Command Coordination Workflow
-
-### Phase 1: Status Analysis
-1. **Call status command**: Execute `/workflow:status` to analyze current session state
-2. **Verify session information**: Check session ID, progress, and current task status
-3. **Identify resume point**: Determine where workflow was interrupted
-
-### Phase 2: Resume Execution
-1. **Call execute with resume flag**: Execute `/workflow:execute --resume-session="{session-id}"`
-2. **Pass session context**: Provide analyzed session information to execute command
-3. **Direct agent execution**: Skip discovery phase, directly enter TodoWrite and agent execution
-
-## Implementation Protocol
-
-### Sequential Command Execution
-```bash
-# Phase 1: Analyze current session status
-SlashCommand(command="/workflow:status")
-
-# Phase 2: Resume execution with special flag
-SlashCommand(command="/workflow:execute --resume-session=\"{session-id}\"")
-```
-
-### Progress Tracking
-```javascript
-TodoWrite({
-  todos: [
-    {
-      content: "Analyze current session status and progress",
-      status: "in_progress",
-      activeForm: "Analyzing session status"
-    },
-    {
-      content: "Resume workflow execution with session context",
-      status: "pending",
-      activeForm: "Resuming workflow execution"
-    }
-  ]
-});
-```
-
-## Resume Information Flow
-
-### Status Analysis Results
-The `/workflow:status` command provides:
-- **Session ID**: Current active session identifier
-- **Current Progress**: Completed, in-progress, and pending tasks
-- **Interruption Point**: Last executed task and next pending task
-- **Session State**: Overall workflow status
-
-### Execute Command Context
-The special `--resume-session` flag tells `/workflow:execute`:
-- **Skip Discovery**: Don't search for sessions, use provided session ID
-- **Direct Execution**: Go straight to TodoWrite generation and agent launching
-- **Context Restoration**: Use existing session state and summaries
-- **Resume Point**: Continue from identified interruption point
-
-## Error Handling
-
-### Session Validation Failures
-- **Session not found**: Report missing session, suggest available sessions
-- **Session inactive**: Recommend activating session first
-- **Status command fails**: Retry once, then report analysis failure
-
-### Execute Resumption Failures
-- **No pending tasks**: Report workflow completion status
-- **Execute command fails**: Report resumption failure, suggest manual intervention
-
-## Success Criteria
-1. **Status analysis complete**: Session state properly analyzed and reported
-2. **Execute command launched**: Resume execution started with proper context
-3. **Agent coordination**: TodoWrite and agent execution initiated successfully
-4. **Context preservation**: Session state and progress properly maintained
-
----
-*Sequential command coordination for workflow session resumption*

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

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

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

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

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

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

.claude/commands/workflow/review.md

@@ -1,20 +1,20 @@
 ---
 name: review
-description: Optional specialized review (security, architecture, docs) for completed implementation
-argument-hint: "[--type=security|architecture|action-items|quality] [optional: session-id]"
+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] [--archived] [optional: session-id]"
 ---
 
-### 🚀 Command Overview: `/workflow:review`
+## Command Overview: /workflow:review
 
 **Optional specialized review** for completed implementations. In the standard workflow, **passing tests = approved code**. Use this command only when specialized review is required (security, architecture, compliance, docs).
 
 ## Philosophy: "Tests Are the Review"
 
-- ✅ **Default**: All tests pass → Code approved
-- 🔍 **Optional**: Specialized reviews for:
-  - 🔒 Security audits (vulnerabilities, auth/authz)
-  - 🏗️ Architecture compliance (patterns, technical debt)
-  - 📋 Action items verification (requirements met, acceptance criteria)
+- **Default**: All tests pass -> Code approved
+- **Optional**: Specialized reviews for:
+  - Security audits (vulnerabilities, auth/authz)
+  - Architecture compliance (patterns, technical debt)
+  - Action items verification (requirements met, acceptance criteria)
 
 ## Review Types
 
@@ -29,28 +29,71 @@ argument-hint: "[--type=security|architecture|action-items|quality] [optional: s
 - For documentation generation, use `/workflow:tools:docs`
 - For CLAUDE.md updates, use `/update-memory-related`
 
+## Execution Process
+
+```
+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 + --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 (active or archived)
+   └─ Check for completed implementation (.summaries/IMPL-*.md exists)
+
+Step 3: Type Check
+   └─ Decision:
+      ├─ type=docs → Redirect to /workflow:tools:docs
+      └─ Other types → Continue to analysis
+
+Step 4: Model Analysis Phase
+   ├─ Load context (summaries, test results, changed files)
+   └─ Perform specialized review by type:
+      ├─ security → Security patterns + Gemini analysis
+      ├─ architecture → Qwen architecture analysis
+      ├─ quality → Gemini code quality analysis
+      └─ action-items → Requirements verification
+
+Step 5: Generate Report
+   └─ Output: REVIEW-{type}.md
+```
+
 ## Execution Template
 
 ```bash
 #!/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/ -name '.active-*' | head -1 | sed 's/.*active-//')
+    sessionId=$(find .workflow/active/ -name "WFS-*" -type d | head -1 | xargs basename)
 fi
 
-# Step 2: Validation
-if [ ! -d ".workflow/${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/${sessionId}/.summaries" ] || [ -z "$(find .workflow/${sessionId}/.summaries/ -name "IMPL-*.md" -type f 2>/dev/null)" ]; then
-    echo "❌ No completed implementation found. Complete implementation first"
+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
 
@@ -59,7 +102,7 @@ review_type="${TYPE_ARG:-quality}"
 
 # Redirect docs review to specialized command
 if [ "$review_type" = "docs" ]; then
-    echo "💡 For documentation generation, please use:"
+    echo "For documentation generation, please use:"
     echo "   /workflow:tools:docs"
     echo ""
     echo "The docs command provides:"
@@ -73,80 +116,86 @@ fi
 # BASH_EXECUTION_STOPS → MODEL_ANALYSIS_BEGINS
 ```
 
-### 🧠 Model Analysis Phase
+### Model Analysis Phase
 
 After bash validation, the model takes control to:
 
 1. **Load Context**: Read completed task summaries and changed files
    ```bash
-   # Load implementation summaries
-   cat .workflow/${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/${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/${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`
 
    **Security Review** (`--type=security`):
-   - Use MCP code search for security patterns:
+   - Use ripgrep for security patterns:
      ```bash
-     mcp__code-index__search_code_advanced(pattern="password|token|secret|auth", file_pattern="*.{ts,js,py}")
-     mcp__code-index__search_code_advanced(pattern="eval|exec|innerHTML|dangerouslySetInnerHTML", file_pattern="*.{ts,js,tsx}")
+     rg "password|token|secret|auth" -g "*.{ts,js,py}"
+     rg "eval|exec|innerHTML|dangerouslySetInnerHTML" -g "*.{ts,js,tsx}"
      ```
    - Use Gemini for security analysis:
      ```bash
-     cd .workflow/${sessionId} && ~/.claude/scripts/gemini-wrapper -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/${sessionId} && ~/.claude/scripts/qwen-wrapper -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/${sessionId} && ~/.claude/scripts/gemini-wrapper -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/${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/${sessionId} && ~/.claude/scripts/gemini-wrapper -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
@@ -157,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}
      ```
 
 
@@ -195,7 +244,7 @@ After bash validation, the model takes control to:
 4. **Output Files**:
    ```bash
    # Save review report
-   Write(.workflow/${sessionId}/REVIEW-${review_type}.md)
+   Write(${sessionPath}/REVIEW-${review_type}.md)
 
    # Update session metadata
    # (optional) Update workflow-session.json with review status
@@ -205,7 +254,7 @@ After bash validation, the model takes control to:
    ```bash
    # If architecture or quality issues found, suggest memory update
    if [ "$review_type" = "architecture" ] || [ "$review_type" = "quality" ]; then
-       echo "💡 Consider updating project documentation:"
+       echo "Consider updating project documentation:"
        echo "   /update-memory-related"
    fi
    ```
@@ -222,15 +271,22 @@ 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
 ```
 
-## ✨ Features
+## Features
 
 - **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
@@ -240,10 +296,10 @@ After bash validation, the model takes control to:
 
 ```
 Standard Workflow:
-  plan → execute → test-gen → execute ✅
+  plan -> execute -> test-gen -> execute (complete)
 
 Optional Review (when needed):
-  plan → execute → test-gen → execute → review (security/architecture/docs)
+  plan -> execute -> test-gen -> execute -> review (security/architecture/docs)
 ```
 
 **When to Use**:
@@ -257,10 +313,10 @@ Optional Review (when needed):
 - Simple bug fixes (test-fix-agent handles it)
 - Minor changes (update-memory-related is enough)
 
-## Related Commands
+## Post-Review Action
 
-- `/workflow:execute` - Must complete implementation first
-- `/workflow:test-gen` - Primary quality gate (tests)
-- `/workflow:tools:docs` - Generate hierarchical documentation (use instead of `--type=docs`)
-- `/update-memory-related` - Update CLAUDE.md docs after architecture findings
-- `/workflow:status` - Check session status
+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,6 +1,6 @@
 ---
 name: complete
-description: Mark the active workflow session as complete and remove active flag
+description: Mark active workflow session as complete, archive with lessons learned, update manifest, remove active flag
 examples:
   - /workflow:session:complete
   - /workflow:session:complete --detailed
@@ -8,98 +8,146 @@ examples:
 
 # Complete Workflow Session (/workflow:session:complete)
 
-## Overview
-Mark the currently active workflow session as complete, update its status, and remove the active flag marker.
+Mark the currently active workflow session as complete, archive it, and update manifests.
+
+## Pre-defined Commands
 
-## Usage
 ```bash
-/workflow:session:complete           # Complete current active session
-/workflow:session:complete --detailed # Show detailed completion summary
+# 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
 ```
 
-## Implementation Flow
+## Key Files to Read
+
+**For manifest.json generation**, read ONLY these files:
+
+| 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) |
+
+## Execution Flow
+
+### Phase 1: Find Session (2 commands)
 
-### Step 1: Find Active Session
 ```bash
-ls .workflow/.active-* 2>/dev/null | head -1
+# 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"
 ```
 
-### Step 2: Get Session Name
+**Output**: `SESSION_ID` = e.g., `WFS-auth-feature`
+
+### Phase 2: Generate Manifest Entry (Read-only)
+
+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>"
+    }
+  },
+  "tags": ["<3-5 keywords from IMPL_PLAN.md>"],
+  "lessons": {
+    "successes": ["<key wins>"],
+    "challenges": ["<difficulties>"],
+    "watch_patterns": ["<patterns to monitor>"]
+  }
+}
+```
+
+**Lessons Generation**: Use gemini with `~/.claude/workflows/cli-templates/prompts/archive/analysis-simple.txt`
+
+### Phase 3: Atomic Commit (4 commands)
+
 ```bash
-basename .workflow/.active-WFS-session-name | sed 's/^\.active-//'
+# 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
 ```
 
-### Step 3: Update Session Status
+**Output**:
+```
+✓ Session "$SESSION_ID" archived successfully
+  Location: .workflow/archives/$SESSION_ID/
+  Manifest: Updated with N total sessions
+```
+
+### Phase 4: Update project.json (Optional)
+
+**Skip if**: `.workflow/project.json` doesn't exist
+
 ```bash
-jq '.status = "completed"' .workflow/WFS-session/workflow-session.json > temp.json
-mv temp.json .workflow/WFS-session/workflow-session.json
+# Check
+test -f .workflow/project.json || echo "SKIP"
 ```
 
-### Step 4: Add Completion Timestamp
-```bash
-jq '.completed_at = "'$(date -u +%Y-%m-%dT%H:%M:%SZ)'"' .workflow/WFS-session/workflow-session.json > temp.json
-mv temp.json .workflow/WFS-session/workflow-session.json
+**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>" }
+}
 ```
 
-### Step 5: Count Final Statistics
-```bash
-find .workflow/WFS-session/.task/ -name "*.json" -type f 2>/dev/null | wc -l
-find .workflow/WFS-session/.summaries/ -name "*.md" -type f 2>/dev/null | wc -l
+**Output**:
+```
+✓ Feature added to project registry
 ```
 
-### Step 6: Remove Active Marker
-```bash
-rm .workflow/.active-WFS-session-name
+## Error Recovery
+
+| 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 |
+
+## Quick Reference
+
 ```
-
-## Simple Bash Commands
-
-### Basic Operations
-- **Find active session**: `find .workflow/ -name ".active-*" -type f`
-- **Get session name**: `basename marker | sed 's/^\.active-//'`
-- **Update status**: `jq '.status = "completed"' session.json > temp.json`
-- **Add timestamp**: `jq '.completed_at = "'$(date -u +%Y-%m-%dT%H:%M:%SZ)'"'`
-- **Count tasks**: `find .task/ -name "*.json" -type f | wc -l`
-- **Count completed**: `find .summaries/ -name "*.md" -type f 2>/dev/null | wc -l`
-- **Remove marker**: `rm .workflow/.active-session`
-
-### Completion Result
+Phase 1: find session → create .archiving marker
+Phase 2: read key files → build manifest entry (no writes)
+Phase 3: mkdir → mv → update manifest.json → rm marker
+Phase 4: update project.json features array (optional)
 ```
-Session WFS-user-auth completed
-- Status: completed
-- Started: 2025-09-15T10:00:00Z
-- Completed: 2025-09-15T16:30:00Z
-- Duration: 6h 30m
-- Total tasks: 8
-- Completed tasks: 8
-- Success rate: 100%
-```
-
-### Detailed Summary (--detailed flag)
-```
-Session Completion Summary:
-├── Session: WFS-user-auth
-├── Project: User authentication system
-├── Total time: 6h 30m
-├── Tasks completed: 8/8 (100%)
-├── Files generated: 24 files
-├── Summaries created: 8 summaries
-├── Status: All tasks completed successfully
-└── Location: .workflow/WFS-user-auth/
-```
-
-### Error Handling
-```bash
-# No active session
-find .workflow/ -name ".active-*" -type f 2>/dev/null || echo "No active session found"
-
-# Incomplete tasks
-task_count=$(find .task/ -name "*.json" -type f | wc -l)
-summary_count=$(find .summaries/ -name "*.md" -type f 2>/dev/null | wc -l)
-test $task_count -eq $summary_count || echo "Warning: Not all tasks completed"
-```
-
-## Related Commands
-- `/workflow:session:list` - View all sessions including completed
-- `/workflow:session:start` - Start new session
-- `/workflow:status` - Check completion status before completing

.claude/commands/workflow/session/list.md

@@ -1,6 +1,6 @@
 ---
 name: list
-description: List all workflow sessions with status
+description: List all workflow sessions with status filtering, shows session metadata and progress information
 examples:
   - /workflow:session:list
 ---
@@ -19,35 +19,35 @@ Display all workflow sessions with their current status, progress, and metadata.
 
 ### Step 1: Find All Sessions
 ```bash
-ls .workflow/WFS-* 2>/dev/null
+ls .workflow/active/WFS-* 2>/dev/null
 ```
 
 ### Step 2: Check Active Session
 ```bash
-ls .workflow/.active-* 2>/dev/null | head -1
+find .workflow/active/ -name "WFS-*" -type d 2>/dev/null | head -1
 ```
 
 ### Step 3: Read Session Metadata
 ```bash
-jq -r '.session_id, .status, .project' .workflow/WFS-session/workflow-session.json
+jq -r '.session_id, .status, .project' .workflow/active/WFS-session/workflow-session.json
 ```
 
 ### Step 4: Count Task Progress
 ```bash
-find .workflow/WFS-session/.task/ -name "*.json" -type f 2>/dev/null | wc -l
-find .workflow/WFS-session/.summaries/ -name "*.md" -type f 2>/dev/null | wc -l
+find .workflow/active/WFS-session/.task/ -name "*.json" -type f 2>/dev/null | wc -l
+find .workflow/active/WFS-session/.summaries/ -name "*.md" -type f 2>/dev/null | wc -l
 ```
 
 ### Step 5: Get Creation Time
 ```bash
-jq -r '.created_at // "unknown"' .workflow/WFS-session/workflow-session.json
+jq -r '.created_at // "unknown"' .workflow/active/WFS-session/workflow-session.json
 ```
 
 ## Simple Bash Commands
 
 ### Basic Operations
-- **List sessions**: `find .workflow/ -maxdepth 1 -type d -name "WFS-*"`
-- **Find active**: `find .workflow/ -name ".active-*" -type f`
+- **List sessions**: `find .workflow/active/ -name "WFS-*" -type d`
+- **Find active**: `find .workflow/active/ -name "WFS-*" -type d`
 - **Read session data**: `jq -r '.session_id, .status' session.json`
 - **Count tasks**: `find .task/ -name "*.json" -type f | wc -l`
 - **Count completed**: `find .summaries/ -name "*.md" -type f 2>/dev/null | wc -l`
@@ -59,19 +59,19 @@ jq -r '.created_at // "unknown"' .workflow/WFS-session/workflow-session.json
 ```
 Workflow Sessions:
 
-✅ WFS-oauth-integration (ACTIVE)
+[ACTIVE] WFS-oauth-integration
    Project: OAuth2 authentication system
    Status: active
    Progress: 3/8 tasks completed
    Created: 2025-09-15T10:30:00Z
 
-⏸️ WFS-user-profile (PAUSED)
+[PAUSED] WFS-user-profile
    Project: User profile management
    Status: paused
    Progress: 1/5 tasks completed
    Created: 2025-09-14T14:15:00Z
 
-📁 WFS-database-migration (COMPLETED)
+[COMPLETED] WFS-database-migration
    Project: Database schema migration
    Status: completed
    Progress: 4/4 tasks completed
@@ -81,24 +81,16 @@ Total: 3 sessions (1 active, 1 paused, 1 completed)
 ```
 
 ### Status Indicators
-- **✅**: Active session
-- **⏸️**: Paused session
-- **📁**: Completed session
-- **❌**: Error/corrupted session
+- **[ACTIVE]**: Active session
+- **[PAUSED]**: Paused session
+- **[COMPLETED]**: Completed session
+- **[ERROR]**: Error/corrupted session
 
 ### Quick Commands
 ```bash
 # Count all sessions
-ls .workflow/WFS-* | wc -l
-
-# Show only active
-ls .workflow/.active-* | basename | sed 's/^\.active-//'
+ls .workflow/active/WFS-* | wc -l
 
 # Show recent sessions
-ls -t .workflow/WFS-*/workflow-session.json | head -3
-```
-
-## Related Commands
-- `/workflow:session:start` - Create new session
-- `/workflow:session:switch` - Switch to different session
-- `/workflow:session:status` - Detailed session info
+ls -t .workflow/active/WFS-*/workflow-session.json | head -3
+```

.claude/commands/workflow/session/resume.md

@@ -1,6 +1,6 @@
 ---
 name: resume
-description: Resume the most recently paused workflow session
+description: Resume the most recently paused workflow session with automatic session discovery and status update
 ---
 
 # Resume Workflow Session (/workflow:session:resume)
@@ -17,45 +17,39 @@ Resume the most recently paused workflow session, restoring all context and stat
 
 ### Step 1: Find Paused Sessions
 ```bash
-ls .workflow/WFS-* 2>/dev/null
+ls .workflow/active/WFS-* 2>/dev/null
 ```
 
 ### Step 2: Check Session Status
 ```bash
-jq -r '.status' .workflow/WFS-session/workflow-session.json
+jq -r '.status' .workflow/active/WFS-session/workflow-session.json
 ```
 
 ### Step 3: Find Most Recent Paused
 ```bash
-ls -t .workflow/WFS-*/workflow-session.json | head -1
+ls -t .workflow/active/WFS-*/workflow-session.json | head -1
 ```
 
 ### Step 4: Update Session Status
 ```bash
-jq '.status = "active"' .workflow/WFS-session/workflow-session.json > temp.json
-mv temp.json .workflow/WFS-session/workflow-session.json
+jq '.status = "active"' .workflow/active/WFS-session/workflow-session.json > temp.json
+mv temp.json .workflow/active/WFS-session/workflow-session.json
 ```
 
 ### Step 5: Add Resume Timestamp
 ```bash
-jq '.resumed_at = "'$(date -u +%Y-%m-%dT%H:%M:%SZ)'"' .workflow/WFS-session/workflow-session.json > temp.json
-mv temp.json .workflow/WFS-session/workflow-session.json
-```
-
-### Step 6: Create Active Marker
-```bash
-touch .workflow/.active-WFS-session-name
+jq '.resumed_at = "'$(date -u +%Y-%m-%dT%H:%M:%SZ)'"' .workflow/active/WFS-session/workflow-session.json > temp.json
+mv temp.json .workflow/active/WFS-session/workflow-session.json
 ```
 
 ## Simple Bash Commands
 
 ### Basic Operations
-- **List sessions**: `ls .workflow/WFS-*`
+- **List sessions**: `ls .workflow/active/WFS-*`
 - **Check status**: `jq -r '.status' session.json`
-- **Find recent**: `ls -t .workflow/*/workflow-session.json | head -1`
+- **Find recent**: `ls -t .workflow/active/*/workflow-session.json | head -1`
 - **Update status**: `jq '.status = "active"' session.json > temp.json`
 - **Add timestamp**: `jq '.resumed_at = "'$(date -u +%Y-%m-%dT%H:%M:%SZ)'"'`
-- **Create marker**: `touch .workflow/.active-session`
 
 ### Resume Result
 ```
@@ -64,9 +58,4 @@ Session WFS-user-auth resumed
 - Paused at: 2025-09-15T14:30:00Z
 - Resumed at: 2025-09-15T15:45:00Z
 - Ready for: /workflow:execute
-```
-
-## Related Commands
-- `/workflow:session:pause` - Pause current session
-- `/workflow:execute` - Continue workflow execution
-- `/workflow:session:list` - Show all sessions
+```

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

@@ -0,0 +1,299 @@
+---
+name: solidify
+description: Crystallize session learnings and user-defined constraints into permanent project guidelines
+argument-hint: "[--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 "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
+---
+
+# 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 a new workflow session with intelligent session management
-argument-hint: [--auto|--new] [optional: task description for new session]
+description: Discover existing sessions or start new workflow session with intelligent session management and conflict detection
+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)
@@ -13,6 +15,55 @@ examples:
 ## Overview
 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
+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 files exist by calling `/workflow:init`.
+
+### Check and Initialize
+```bash
+# 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 either NOT_FOUND**, delegate to `/workflow:init`:
+```javascript
+// Call workflow:init for intelligent project analysis
+SlashCommand({command: "/workflow:init"});
+
+// Wait for init completion
+// project-tech.json and project-guidelines.json will be created
+```
+
+**Output**:
+- 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.
+
 ## Mode 1: Discovery Mode (Default)
 
 ### Usage
@@ -20,19 +71,14 @@ Manages workflow sessions with three operation modes: discovery (manual), auto (
 /workflow:session:start
 ```
 
-### Step 1: Check Active Sessions
+### Step 1: List Active Sessions
 ```bash
-bash(ls .workflow/.active-* 2>/dev/null)
+bash(ls -1 .workflow/active/ 2>/dev/null | head -5)
 ```
 
-### Step 2: List All Sessions
+### Step 2: Display Session Metadata
 ```bash
-bash(ls -1 .workflow/WFS-* 2>/dev/null | head -5)
-```
-
-### Step 3: Display Session Metadata
-```bash
-bash(cat .workflow/WFS-promptmaster-platform/workflow-session.json)
+bash(cat .workflow/active/WFS-promptmaster-platform/workflow-session.json)
 ```
 
 ### Step 4: User Decision
@@ -49,7 +95,7 @@ Present session information and wait for user to select or create session.
 
 ### Step 1: Check Active Sessions Count
 ```bash
-bash(ls .workflow/.active-* 2>/dev/null | wc -l)
+bash(find .workflow/active/ -name "WFS-*" -type d 2>/dev/null | wc -l)
 ```
 
 ### Step 2a: No Active Sessions → Create New
@@ -58,15 +104,12 @@ bash(ls .workflow/.active-* 2>/dev/null | wc -l)
 bash(echo "implement OAuth2 auth" | sed 's/[^a-zA-Z0-9]/-/g' | tr '[:upper:]' '[:lower:]' | cut -c1-50)
 
 # Create directory structure
-bash(mkdir -p .workflow/WFS-implement-oauth2-auth/.process)
-bash(mkdir -p .workflow/WFS-implement-oauth2-auth/.task)
-bash(mkdir -p .workflow/WFS-implement-oauth2-auth/.summaries)
+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/WFS-implement-oauth2-auth/workflow-session.json)
-
-# Mark as active
-bash(touch .workflow/.active-WFS-implement-oauth2-auth)
+# 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`
@@ -74,10 +117,10 @@ bash(touch .workflow/.active-WFS-implement-oauth2-auth)
 ### Step 2b: Single Active Session → Check Relevance
 ```bash
 # Extract session ID
-bash(ls .workflow/.active-* 2>/dev/null | head -1 | xargs basename | sed 's/^\.active-//')
+bash(find .workflow/active/ -name "WFS-*" -type d 2>/dev/null | head -1 | xargs basename)
 
 # Read project name from metadata
-bash(cat .workflow/WFS-promptmaster-platform/workflow-session.json | grep -o '"project":"[^"]*"' | cut -d'"' -f4)
+bash(cat .workflow/active/WFS-promptmaster-platform/workflow-session.json | grep -o '"project":"[^"]*"' | cut -d'"' -f4)
 
 # Check keyword match (manual comparison)
 # If task contains project keywords → Reuse session
@@ -90,7 +133,7 @@ bash(cat .workflow/WFS-promptmaster-platform/workflow-session.json | grep -o '"p
 ### Step 2c: Multiple Active Sessions → Use First
 ```bash
 # Get first active session
-bash(ls .workflow/.active-* 2>/dev/null | head -1 | xargs basename | sed 's/^\.active-//')
+bash(find .workflow/active/ -name "WFS-*" -type d 2>/dev/null | head -1 | xargs basename)
 
 # Output warning and session ID
 # WARNING: Multiple active sessions detected
@@ -110,29 +153,28 @@ bash(ls .workflow/.active-* 2>/dev/null | head -1 | xargs basename | sed 's/^\.a
 bash(echo "fix login bug" | sed 's/[^a-zA-Z0-9]/-/g' | tr '[:upper:]' '[:lower:]' | cut -c1-50)
 
 # Check if exists, add counter if needed
-bash(ls .workflow/WFS-fix-login-bug 2>/dev/null && echo "WFS-fix-login-bug-2" || echo "WFS-fix-login-bug")
+bash(ls .workflow/active/WFS-fix-login-bug 2>/dev/null && echo "WFS-fix-login-bug-2" || echo "WFS-fix-login-bug")
 ```
 
 ### Step 2: Create Session Structure
 ```bash
-bash(mkdir -p .workflow/WFS-fix-login-bug/.process)
-bash(mkdir -p .workflow/WFS-fix-login-bug/.task)
-bash(mkdir -p .workflow/WFS-fix-login-bug/.summaries)
+bash(mkdir -p .workflow/active/WFS-fix-login-bug/.process)
+bash(mkdir -p .workflow/active/WFS-fix-login-bug/.task)
+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/WFS-fix-login-bug/workflow-session.json)
-```
-
-### Step 4: Mark Active and Clean Old Markers
-```bash
-bash(rm .workflow/.active-* 2>/dev/null)
-bash(touch .workflow/.active-WFS-fix-login-bug)
+# 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`
 
+## Execution Guideline
+
+- **Non-interrupting**: When called from other commands, this command completes and returns control to the caller without interrupting subsequent tasks.
+
 ## Output Format Specification
 
 ### Success
@@ -153,68 +195,9 @@ DECISION: Reusing existing session
 SESSION_ID: WFS-promptmaster-platform
 ```
 
-## Command Integration
-
-### For /workflow:plan (Use Auto Mode)
-```bash
-SlashCommand(command="/workflow:session:start --auto \"implement OAuth2 authentication\"")
-
-# Parse session ID from output
-grep "^SESSION_ID:" | awk '{print $2}'
-```
-
-### For Interactive Workflows (Use Discovery Mode)
-```bash
-SlashCommand(command="/workflow:session:start")
-```
-
-### For New Isolated Work (Use Force New Mode)
-```bash
-SlashCommand(command="/workflow:session:start --new \"experimental feature\"")
-```
-
-## Simple Bash Commands
-
-### Basic Operations
-```bash
-# Check active sessions
-bash(ls .workflow/.active-*)
-
-# List all sessions
-bash(ls .workflow/WFS-*)
-
-# Read session metadata
-bash(cat .workflow/WFS-[session-id]/workflow-session.json)
-
-# Create session directories
-bash(mkdir -p .workflow/WFS-[session-id]/.process)
-bash(mkdir -p .workflow/WFS-[session-id]/.task)
-bash(mkdir -p .workflow/WFS-[session-id]/.summaries)
-
-# Mark session as active
-bash(touch .workflow/.active-WFS-[session-id])
-
-# Clean active markers
-bash(rm .workflow/.active-*)
-```
-
-### Generate Session Slug
-```bash
-bash(echo "Task Description" | sed 's/[^a-zA-Z0-9]/-/g' | tr '[:upper:]' '[:lower:]' | cut -c1-50)
-```
-
-### Create Metadata JSON
-```bash
-bash(echo '{"session_id":"WFS-test","project":"test project","status":"planning"}' > .workflow/WFS-test/workflow-session.json)
-```
 
 ## Session ID Format
 - Pattern: `WFS-[lowercase-slug]`
 - Characters: `a-z`, `0-9`, `-` only
 - Max length: 50 characters
-- Uniqueness: Add numeric suffix if collision (`WFS-auth-2`, `WFS-auth-3`)
-
-## Related Commands
-- `/workflow:plan` - Uses `--auto` mode for session management
-- `/workflow:execute` - Uses discovery mode for session selection
-- `/workflow:session:status` - Shows detailed session information
+- Uniqueness: Add numeric suffix if collision (`WFS-auth-2`, `WFS-auth-3`)

.claude/commands/workflow/status.md

@@ -1,124 +0,0 @@
----
-name: workflow:status
-description: Generate on-demand views from JSON task data
-argument-hint: "[optional: task-id]"
----
-
-# Workflow Status Command (/workflow:status)
-
-## Overview
-Generates on-demand views from JSON task data. No synchronization needed - all views are calculated from the current state of JSON files.
-
-## Usage
-```bash
-/workflow:status                    # Show current workflow overview
-/workflow:status impl-1             # Show specific task details
-/workflow:status --validate         # Validate workflow integrity
-```
-
-## Implementation Flow
-
-### Step 1: Find Active Session
-```bash
-find .workflow/ -name ".active-*" -type f 2>/dev/null | head -1
-```
-
-### Step 2: Load Session Data
-```bash
-cat .workflow/WFS-session/workflow-session.json
-```
-
-### Step 3: Scan Task Files
-```bash
-find .workflow/WFS-session/.task/ -name "*.json" -type f 2>/dev/null
-```
-
-### Step 4: Generate Task Status
-```bash
-cat .workflow/WFS-session/.task/impl-1.json | jq -r '.status'
-```
-
-### Step 5: Count Task Progress
-```bash
-find .workflow/WFS-session/.task/ -name "*.json" -type f | wc -l
-find .workflow/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
-- [⚠️] impl-1: Current task in progress
-- [ ] impl-2: Next pending task
-
-## Completed Tasks
-- [✅] impl-0: Setup completed
-```
-
-## Simple Bash Commands
-
-### Basic Operations
-- **Find active session**: `find .workflow/ -name ".active-*" -type f`
-- **Read session info**: `cat .workflow/session/workflow-session.json`
-- **List tasks**: `find .workflow/session/.task/ -name "*.json" -type f`
-- **Check task status**: `cat task.json | jq -r '.status'`
-- **Count completed**: `find .summaries/ -name "*.md" -type f | wc -l`
-
-### Task Status Check
-- **pending**: Not started yet
-- **active**: Currently in progress
-- **completed**: Finished with summary
-- **blocked**: Waiting for dependencies
-
-### Validation Commands
-```bash
-# Check session exists
-test -f .workflow/.active-* && echo "Session active"
-
-# Validate task files
-for f in .workflow/session/.task/*.json; do jq empty "$f" && echo "Valid: $f"; done
-
-# Check summaries match
-find .task/ -name "*.json" -type f | wc -l
-find .summaries/ -name "*.md" -type f 2>/dev/null | wc -l
-```
-
-## Simple Output Format
-
-### Default Overview
-```
-Session: WFS-user-auth
-Status: ACTIVE
-Progress: 5/12 tasks
-
-Current: impl-3 (Building API endpoints)
-Next: impl-4 (Adding authentication)
-Completed: impl-1, impl-2
-```
-
-### Task Details
-```
-Task: impl-1
-Title: Build authentication module
-Status: completed
-Agent: code-developer
-Created: 2025-09-15
-Completed: 2025-09-15
-Summary: .summaries/impl-1-summary.md
-```
-
-### Validation Results
-```
-✅ Session file valid
-✅ 8 task files found
-✅ 3 summaries found
-⚠️ 5 tasks pending completion
-```
-
-## Related Commands
-- `/workflow:execute` - Uses this for task discovery
-- `/workflow:resume` - Uses this for progress analysis
-- `/workflow:session:status` - Shows session metadata

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

@@ -1,7 +1,7 @@
 ---
 name: tdd-plan
-description: Orchestrate TDD workflow planning with Red-Green-Refactor task chains
-argument-hint: "[--agent] \"feature description\"|file.md"
+description: TDD workflow planning with Red-Green-Refactor task chain generation, test-first development structure, and cycle tracking
+argument-hint: "\"feature description\"|file.md"
 allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*)
 ---
 
@@ -9,26 +9,43 @@ allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*)
 
 ## Coordinator Role
 
-**This command is a pure orchestrator**: Execute 5 slash commands in sequence, parse outputs, pass context, and ensure complete TDD workflow creation.
+**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**:
-- **Manual Mode** (default): Use `/workflow:tools:task-generate-tdd`
-- **Agent Mode** (`--agent`): Use `/workflow:tools:task-generate-tdd --agent`
+**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 execute **expands workflow** by attaching sub-tasks to current TodoWrite
+- When executing a sub-command (e.g., `/workflow:tools:test-context-gather`), its internal tasks are attached to the orchestrator's TodoWrite
+- Orchestrator **executes these attached tasks** sequentially
+- After completion, attached tasks are **collapsed** back to high-level phase summary
+- This is **task expansion**, not external delegation
+
+**Auto-Continue Mechanism**:
+- TodoList tracks current phase status and dynamically manages task attachment/collapse
+- When each phase finishes executing, automatically execute next pending phase
+- All phases run autonomously without user interaction
+- **⚠️ CONTINUOUS EXECUTION** - Do not stop until all phases complete
 
 ## Core Rules
 
-1. **Start Immediately**: First action is TodoWrite initialization, second action is 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. **Sequential Execution**: Each phase depends on previous output
-5. **Complete All Phases**: Do not return until Phase 7 completes (with concept verification)
+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. **Quality Gate**: Phase 5 concept verification ensures clarity before task generation
+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
 
-## 7-Phase Execution (with Concept Verification)
+## 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**:
 ```
@@ -41,13 +58,45 @@ TEST_FOCUS: [Test scenarios]
 
 **Parse**: Extract sessionId
 
-### Phase 2: Context Gathering
-**Command**: `/workflow:tools:context-gather --session [sessionId] "TDD: [structured-description]"`
+**TodoWrite**: Mark phase 1 completed, phase 2 in_progress
 
-**Parse**: Extract contextPath
+**After Phase 1**: Return to user showing Phase 1 results, then auto-continue to Phase 2
+
+---
+
+### Phase 2: Context Gathering
+
+**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
+
+**Input**: `sessionId` from Phase 1
+
+**Parse Output**:
+- Extract: context-package.json path (store as `contextPath`)
+- Typical pattern: `.workflow/active/[sessionId]/.process/context-package.json`
+
+**Validation**:
+- Context package path extracted
+- File exists and is valid JSON
+
+**TodoWrite**: Mark phase 2 completed, phase 3 in_progress
+
+**After Phase 2**: Return to user showing Phase 2 results, then auto-continue to Phase 3
+
+---
 
 ### 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
@@ -55,45 +104,139 @@ TEST_FOCUS: [Test scenarios]
 - Related components and integration points
 - Test framework detection
 
-**Parse**: Extract testContextPath (`.workflow/[sessionId]/.process/test-context-package.json`)
+**Parse**: Extract testContextPath (`.workflow/active/[sessionId]/.process/test-context-package.json`)
 
-**Benefits**:
-- Makes TDD aware of existing environment
-- Identifies reusable test patterns
-- Prevents duplicate test creation
-- Enables integration with existing tests
 
-### Phase 4: TDD Analysis
-**Command**: `/workflow:tools:concept-enhanced --session [sessionId] --context [contextPath]`
 
-**Note**: Generates ANALYSIS_RESULTS.md with TDD-specific structure:
-- Feature list with testable requirements
-- Test cases for Red phase
-- Implementation requirements for Green phase
-- Refactoring opportunities
-- Task dependencies and execution order
+<!-- TodoWrite: When test-context-gather executed, INSERT 3 test-context-gather tasks -->
 
-**Parse**: Verify ANALYSIS_RESULTS.md contains TDD breakdown sections
+**TodoWrite Update (Phase 3 SlashCommand executed - tasks attached)**:
+```json
+[
+  {"content": "Phase 1: Session Discovery", "status": "completed", "activeForm": "Executing session discovery"},
+  {"content": "Phase 2: Context Gathering", "status": "completed", "activeForm": "Executing context gathering"},
+  {"content": "Phase 3: Test Coverage Analysis", "status": "in_progress", "activeForm": "Executing test coverage analysis"},
+  {"content": "  → Detect test framework and conventions", "status": "in_progress", "activeForm": "Detecting test framework"},
+  {"content": "  → Analyze existing test coverage", "status": "pending", "activeForm": "Analyzing test coverage"},
+  {"content": "  → Identify coverage gaps", "status": "pending", "activeForm": "Identifying coverage gaps"},
+  {"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"}
+]
+```
 
-### Phase 5: Concept Verification (NEW QUALITY GATE)
-**Command**: `/workflow:concept-verify --session [sessionId]`
+**Note**: SlashCommand execute **attaches** test-context-gather's 3 tasks. Orchestrator **executes** these tasks.
 
-**Purpose**: Verify conceptual clarity before TDD task generation
-- Clarify test requirements and acceptance criteria
-- Resolve ambiguities in expected behavior
-- Validate TDD approach is appropriate
+**Next Action**: Tasks attached → **Execute Phase 3.1-3.3** sequentially
 
-**Behavior**:
-- If no ambiguities found → Auto-proceed to Phase 6
-- If ambiguities exist → Interactive clarification (up to 5 questions)
-- After clarifications → Auto-proceed to Phase 6
+<!-- TodoWrite: After Phase 3 tasks complete, REMOVE Phase 3.1-3.3, restore to orchestrator view -->
 
-**Parse**: Verify concept verification completed (check for clarifications section in ANALYSIS_RESULTS.md or synthesis file if exists)
+**TodoWrite Update (Phase 3 completed - tasks collapsed)**:
+```json
+[
+  {"content": "Phase 1: Session Discovery", "status": "completed", "activeForm": "Executing session discovery"},
+  {"content": "Phase 2: Context Gathering", "status": "completed", "activeForm": "Executing context gathering"},
+  {"content": "Phase 3: Test Coverage Analysis", "status": "completed", "activeForm": "Executing test coverage analysis"},
+  {"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"}
+]
+```
 
-### Phase 6: TDD Task Generation
-**Command**:
-- Manual: `/workflow:tools:task-generate-tdd --session [sessionId]`
-- Agent: `/workflow:tools:task-generate-tdd --session [sessionId] --agent`
+**Note**: Phase 3 tasks completed and collapsed to summary.
+
+**After Phase 3**: Return to user showing test coverage results, then auto-continue to Phase 4/5 (depending on conflict_risk)
+
+---
+
+### Phase 4: Conflict Resolution (Optional - auto-triggered by conflict risk)
+
+**Trigger**: Only execute when context-package.json indicates conflict_risk is "medium" or "high"
+
+**Step 4.1: Execute** - Conflict detection and resolution
+
+```javascript
+SlashCommand(command="/workflow:tools:conflict-resolution --session [sessionId] --context [contextPath]")
+```
+
+**Input**:
+- sessionId from Phase 1
+- contextPath from Phase 2
+- conflict_risk from context-package.json
+
+**Parse Output**:
+- Extract: Execution status (success/skipped/failed)
+- Verify: conflict-resolution.json file path (if executed)
+
+**Validation**:
+- File `.workflow/active/[sessionId]/.process/conflict-resolution.json` exists (if executed)
+
+**Skip Behavior**:
+- If conflict_risk is "none" or "low", skip directly to Phase 5
+- Display: "No significant conflicts detected, proceeding to TDD task generation"
+
+<!-- TodoWrite: If conflict_risk ≥ medium, INSERT 3 conflict-resolution tasks when executed -->
+
+**TodoWrite Update (Phase 4 SlashCommand executed - tasks attached, if conflict_risk ≥ medium)**:
+```json
+[
+  {"content": "Phase 1: Session Discovery", "status": "completed", "activeForm": "Executing session discovery"},
+  {"content": "Phase 2: Context Gathering", "status": "completed", "activeForm": "Executing context gathering"},
+  {"content": "Phase 3: 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": "  → 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 execute **attaches** conflict-resolution's 3 tasks. Orchestrator **executes** these tasks.
+
+**Next Action**: Tasks attached → **Execute Phase 4.1-4.3** sequentially
+
+<!-- TodoWrite: After Phase 4 tasks complete, REMOVE Phase 4.1-4.3, restore to orchestrator view -->
+
+**TodoWrite Update (Phase 4 completed - tasks collapsed)**:
+```json
+[
+  {"content": "Phase 1: Session Discovery", "status": "completed", "activeForm": "Executing session discovery"},
+  {"content": "Phase 2: Context Gathering", "status": "completed", "activeForm": "Executing context gathering"},
+  {"content": "Phase 3: Test Coverage Analysis", "status": "completed", "activeForm": "Executing test coverage analysis"},
+  {"content": "Phase 4: Conflict Resolution", "status": "completed", "activeForm": "Executing conflict resolution"},
+  {"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**: Phase 4 tasks completed and collapsed to summary.
+
+**After Phase 4**: Return to user showing conflict resolution results (if executed) and selected strategies, then auto-continue to Phase 5
+
+**Memory State Check**:
+- Evaluate current context window usage and memory state
+- If memory usage is high (>110K tokens or approaching context limits):
+
+  **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
+
+---
+
+### Phase 5: TDD Task Generation
+
+**Step 5.1: Execute** - TDD task generation via action-planning-agent
+
+```javascript
+SlashCommand(command="/workflow:tools:task-generate-tdd --session [sessionId]")
+```
+
+**Note**: CLI tool usage is determined semantically from user's task description.
 
 **Parse**: Extract feature count, task count (not chain count - tasks now contain internal TDD cycles)
 
@@ -108,7 +251,42 @@ TEST_FOCUS: [Test scenarios]
 - IMPL_PLAN.md contains workflow_type: "tdd" in frontmatter
 - Task count ≤10 (compliance with task limit)
 
-### Phase 7: TDD Structure Validation & Action Plan Verification (RECOMMENDED)
+<!-- 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"},
+  {"content": "Phase 2: Context Gathering", "status": "completed", "activeForm": "Executing context gathering"},
+  {"content": "Phase 3: Test Coverage Analysis", "status": "completed", "activeForm": "Executing test coverage analysis"},
+  {"content": "Phase 5: TDD Task Generation", "status": "in_progress", "activeForm": "Executing TDD task generation"},
+  {"content": "  → Discovery - analyze TDD requirements", "status": "in_progress", "activeForm": "Analyzing TDD requirements"},
+  {"content": "  → Planning - design Red-Green-Refactor cycles", "status": "pending", "activeForm": "Designing TDD cycles"},
+  {"content": "  → Output - generate IMPL tasks with internal TDD phases", "status": "pending", "activeForm": "Generating TDD tasks"},
+  {"content": "Phase 6: TDD Structure Validation", "status": "pending", "activeForm": "Validating TDD structure"}
+]
+```
+
+**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
+
+<!-- TodoWrite: After Phase 5 tasks complete, REMOVE Phase 5.1-5.3, restore to orchestrator view -->
+
+**TodoWrite Update (Phase 5 completed - tasks collapsed)**:
+```json
+[
+  {"content": "Phase 1: Session Discovery", "status": "completed", "activeForm": "Executing session discovery"},
+  {"content": "Phase 2: Context Gathering", "status": "completed", "activeForm": "Executing context gathering"},
+  {"content": "Phase 3: Test Coverage Analysis", "status": "completed", "activeForm": "Executing test coverage analysis"},
+  {"content": "Phase 5: TDD Task Generation", "status": "completed", "activeForm": "Executing TDD task generation"},
+  {"content": "Phase 6: TDD Structure Validation", "status": "in_progress", "activeForm": "Validating TDD structure"}
+]
+```
+
+**Note**: Phase 5 tasks completed and collapsed to summary. Each generated IMPL task contains complete Red-Green-Refactor cycle internally.
+
+### Phase 6: TDD Structure Validation & Action Plan Verification (RECOMMENDED)
 **Internal validation first, then recommend external verification**
 
 **Internal Validation**:
@@ -134,20 +312,20 @@ 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 10-task limit)
 
 Structure:
-- IMPL-1: {Feature 1 Name} (Internal: 🔴 Red → 🟢 Green → 🔵 Refactor)
-- IMPL-2: {Feature 2 Name} (Internal: 🔴 Red → 🟢 Green → 🔵 Refactor)
+- IMPL-1: {Feature 1 Name} (Internal: Red → Green → Refactor)
+- IMPL-2: {Feature 2 Name} (Internal: Red → Green → Refactor)
 - IMPL-3: {Complex Feature} (Container)
-  - IMPL-3.1: {Sub-feature A} (Internal: 🔴 Red → 🟢 Green → 🔵 Refactor)
-  - IMPL-3.2: {Sub-feature B} (Internal: 🔴 Red → 🟢 Green → 🔵 Refactor)
+  - IMPL-3.1: {Sub-feature A} (Internal: Red → Green → Refactor)
+  - IMPL-3.2: {Sub-feature B} (Internal: Red → Green → Refactor)
 [...]
 
 Plans generated:
-- Unified Implementation Plan: .workflow/[sessionId]/IMPL_PLAN.md
+- Unified Implementation Plan: .workflow/active/[sessionId]/IMPL_PLAN.md
   (includes TDD Implementation Tasks section with workflow_type: "tdd")
-- Task List: .workflow/[sessionId]/TODO_LIST.md
+- Task List: .workflow/active/[sessionId]/TODO_LIST.md
   (with internal TDD phase indicators)
 
 TDD Configuration:
@@ -155,29 +333,95 @@ TDD Configuration:
 - Green phase includes test-fix cycle (max 3 iterations)
 - Auto-revert on max iterations reached
 
-✅ Recommended Next Steps:
+Recommended Next Steps:
 1. /workflow:action-plan-verify --session [sessionId]  # Verify TDD plan quality and dependencies
 2. /workflow:execute --session [sessionId]  # Start TDD execution
 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:action-plan-verify to validate TDD task structure and dependencies
 ```
 
 ## TodoWrite Pattern
 
-```javascript
-// Initialize (7 phases now with concept verification)
-[
-  {content: "Execute session discovery", status: "in_progress", activeForm: "Executing session discovery"},
-  {content: "Execute context gathering", status: "pending", activeForm": "Executing context gathering"},
-  {content: "Execute test coverage analysis", status: "pending", activeForm": "Executing test coverage analysis"},
-  {content: "Execute TDD analysis", status: "pending", activeForm": "Executing TDD analysis"},
-  {content: "Execute concept verification", status: "pending", activeForm": "Executing concept verification"},
-  {content: "Execute TDD task generation", status: "pending", activeForm: "Executing TDD task generation"},
-  {content: "Validate TDD structure", status: "pending", activeForm: "Validating TDD structure"}
-]
+**Core Concept**: Dynamic task attachment and collapse for TDD workflow with test coverage analysis and Red-Green-Refactor cycle generation.
 
-// Update after each phase: mark current "completed", next "in_progress"
+### Key Principles
+
+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`
+   - Orchestrator **executes** these attached tasks sequentially
+
+2. **Task Collapse** (after sub-tasks complete):
+   - Remove detailed sub-tasks from TodoWrite
+   - **Collapse** to high-level phase summary
+   - Example: Phase 3.1-3.3 collapse to "Execute test coverage analysis: completed"
+   - Maintains clean orchestrator-level view
+
+3. **Continuous Execution**:
+   - After collapse, automatically proceed to next pending phase
+   - No user intervention required between phases
+   - TodoWrite dynamically reflects current execution state
+
+**Lifecycle Summary**: Initial pending tasks → Phase 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
+
+- **Phase 3**: Test coverage analysis detects existing patterns and gaps
+- **Phase 5**: Generated IMPL tasks contain internal Red-Green-Refactor cycles
+- **Conditional Phase 4**: Conflict resolution only if conflict_risk ≥ medium
+
+
+
+**Note**: See individual Phase descriptions (Phase 3, 4, 5) for detailed TodoWrite Update examples with full JSON structures.
+
+## Execution Flow Diagram
+
+```
+TDD Workflow Orchestrator
+│
+├─ Phase 1: Session Discovery
+│  └─ /workflow:session:start --auto
+│     └─ Returns: sessionId
+│
+├─ Phase 2: Context Gathering
+│  └─ /workflow:tools:context-gather
+│     └─ Returns: context-package.json path
+│
+├─ Phase 3: Test Coverage Analysis                    ← ATTACHED (3 tasks)
+│  └─ /workflow:tools:test-context-gather
+│     ├─ Phase 3.1: Detect test framework
+│     ├─ Phase 3.2: Analyze existing test coverage
+│     └─ Phase 3.3: Identify coverage gaps
+│     └─ Returns: test-context-package.json           ← COLLAPSED
+│
+├─ Phase 4: Conflict Resolution (conditional)
+│  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.3: Apply resolution strategies
+│     └─ Returns: conflict-resolution.json            ← COLLAPSED
+│  ELSE:
+│  └─ Skip to Phase 5
+│
+├─ Phase 5: TDD Task Generation                       ← ATTACHED (3 tasks)
+│  └─ /workflow:tools:task-generate-tdd
+│     ├─ Phase 5.1: Discovery - analyze TDD requirements
+│     ├─ Phase 5.2: Planning - design Red-Green-Refactor cycles
+│     └─ Phase 5.3: Output - generate IMPL tasks with internal TDD phases
+│     └─ Returns: IMPL-*.json, IMPL_PLAN.md           ← COLLAPSED
+│        (Each IMPL task contains internal Red-Green-Refactor cycle)
+│
+└─ Phase 6: TDD Structure Validation
+   └─ Internal validation + summary returned
+   └─ Recommend: /workflow:action-plan-verify
+
+Key Points:
+• ← ATTACHED: SlashCommand attaches sub-tasks to orchestrator TodoWrite
+• ← COLLAPSED: Sub-tasks executed and collapsed to phase summary
+• TDD-specific: Each generated IMPL task contains complete Red-Green-Refactor cycle
 ```
 
 ## Input Processing
@@ -196,111 +440,21 @@ Convert user input to TDD-structured format:
 - **TDD validation failure**: Report incomplete chains or wrong dependencies
 
 ## Related Commands
-- `/workflow:plan` - Standard (non-TDD) planning
-- `/workflow:execute` - Execute TDD tasks
-- `/workflow:tdd-verify` - Verify TDD compliance
-- `/workflow:status` - View progress
-## TDD Workflow Enhancements
 
-### Overview
-The TDD workflow has been significantly enhanced by integrating best practices from both traditional `plan --agent` and `test-gen` workflows, creating a hybrid approach that bridges the gap between idealized TDD and real-world development complexity.
+**Prerequisite Commands**:
+- None - TDD planning is self-contained (can optionally run brainstorm commands before)
 
-### Key Improvements
+**Called by This Command** (6 phases):
+- `/workflow:session:start` - Phase 1: Create or discover TDD workflow session
+- `/workflow:tools:context-gather` - Phase 2: Gather project context and analyze codebase
+- `/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 (CLI tool usage determined semantically)
 
-#### 1. Test Coverage Analysis (Phase 3)
-**Adopted from test-gen workflow**
-
-Before planning TDD tasks, the workflow now analyzes the existing codebase:
-- Detects existing test patterns and conventions
-- Identifies current test coverage
-- Discovers related components and integration points
-- Detects test framework automatically
-
-**Benefits**:
-- Context-aware TDD planning
-- Avoids duplicate test creation
-- Enables integration with existing tests
-- No longer assumes greenfield scenarios
-
-#### 2. Iterative Green Phase with Test-Fix Cycle
-**Adopted from test-gen workflow**
-
-IMPL (Green phase) tasks now include automatic test-fix cycle for resilient implementation:
-
-**Enhanced IMPL Task Flow**:
-```
-1. Write minimal implementation code
-2. Execute test suite
-3. IF tests pass → Complete task ✅
-4. IF tests fail → Enter fix cycle:
-   a. Gemini diagnoses with bug-fix template
-   b. Apply fix (manual or Codex)
-   c. Retest
-   d. Repeat (max 3 iterations)
-5. IF max iterations → Auto-revert changes 🔄
-```
-
-**Benefits**:
-- ✅ Faster feedback within Green phase
-- ✅ Autonomous recovery from implementation errors
-- ✅ Systematic debugging with Gemini
-- ✅ Safe rollback prevents broken state
-
-#### 3. Agent-Driven Planning
-**From plan --agent workflow**
-
-Supports action-planning-agent for more autonomous TDD planning with:
-- MCP tool integration (code-index, exa)
-- Memory-first principles
-- Brainstorming artifact integration
-- Task merging over decomposition
-
-### Workflow Comparison
-
-| Aspect | Previous | Current (Optimized) |
-|--------|----------|---------------------|
-| **Phases** | 6 (with test coverage) | 7 (added concept verification) |
-| **Context** | Greenfield assumption | Existing codebase aware |
-| **Task Structure** | 1 feature = 3 tasks (TEST/IMPL/REFACTOR) | 1 feature = 1 task (internal TDD cycle) |
-| **Task Count** | 5 features = 15 tasks | 5 features = 5 tasks (70% reduction) |
-| **Green Phase** | Single implementation | Iterative with fix cycle |
-| **Failure Handling** | Manual intervention | Auto-diagnose + fix + revert |
-| **Test Analysis** | None | Deep coverage analysis |
-| **Feedback Loop** | Post-execution | During Green phase |
-| **Task Management** | High overhead (15 tasks) | Low overhead (5 tasks) |
-| **Execution Efficiency** | Frequent context switching | Continuous context per feature |
-
-### Migration Notes
-
-**Backward Compatibility**: ✅ Fully compatible
-- Existing TDD workflows continue to work
-- New features are additive, not breaking
-- Phase 3 can be skipped if test-context-gather not available
-
-**Session Structure**:
-```
-.workflow/WFS-xxx/
-├── IMPL_PLAN.md (unified plan with TDD Implementation Tasks section)
-├── TODO_LIST.md (with internal TDD phase indicators)
-├── .process/
-│   ├── context-package.json
-│   ├── test-context-package.json
-│   ├── ANALYSIS_RESULTS.md (enhanced with TDD breakdown)
-│   └── green-fix-iteration-*.md (fix logs from Green phase cycles)
-└── .task/
-    ├── IMPL-1.json (Complete TDD task: Red-Green-Refactor internally)
-    ├── IMPL-2.json (Complete TDD task)
-    ├── IMPL-3.json (Complex feature container, if needed)
-    ├── IMPL-3.1.json (Complex feature subtask, if needed)
-    └── IMPL-3.2.json (Complex feature subtask, if needed)
-```
-
-**File Count Comparison**:
-- **Old structure**: 5 features = 15 task files (TEST/IMPL/REFACTOR × 5)
-- **New structure**: 5 features = 5 task files (IMPL-N × 5)
-- **Complex features**: Add container + subtasks only when necessary
-
-**Configuration Options** (in IMPL tasks):
-- `meta.max_iterations`: Fix attempts (default: 3)
-- `meta.use_codex`: Auto-fix mode (default: false)
+**Follow-up Commands**:
+- `/workflow:action-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
 

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

@@ -1,9 +1,9 @@
 ---
 name: tdd-verify
-description: Verify TDD workflow compliance and generate quality report
+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-wrapper:*)
+allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(gemini:*)
 ---
 
 # TDD Verification Command (/workflow:tdd-verify)
@@ -18,6 +18,39 @@ allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(gemini-wrapper:*)
 - Validate TDD cycle execution
 - Generate compliance report
 
+## Execution Process
+
+```
+Input Parsing:
+   └─ Decision (session argument):
+      ├─ session-id provided → Use provided session
+      └─ No session-id → Auto-detect active session
+
+Phase 1: Session Discovery
+   ├─ Validate session directory exists
+   └─ TodoWrite: Mark phase 1 completed
+
+Phase 2: Task Chain 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
+
+Phase 3: Test Execution Analysis
+   └─ /workflow:tools:tdd-coverage-analysis
+      ├─ Coverage metrics extraction
+      ├─ TDD cycle verification
+      └─ Compliance score calculation
+
+Phase 4: Compliance Report Generation
+   ├─ Gemini analysis for comprehensive report
+   ├─ Generate TDD_COMPLIANCE_REPORT.md
+   └─ Return summary to user
+```
+
 ## 4-Phase Execution
 
 ### Phase 1: Session Discovery
@@ -28,7 +61,7 @@ allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(gemini-wrapper:*)
 sessionId = argument
 
 # Else auto-detect active session
-find .workflow/ -name '.active-*' | head -1 | sed 's/.*active-//'
+find .workflow/active/ -name "WFS-*" -type d | head -1 | sed 's/.*\///'
 ```
 
 **Extract**: sessionId
@@ -44,18 +77,32 @@ find .workflow/ -name '.active-*' | head -1 | sed 's/.*active-//'
 
 ```bash
 # Load all task JSONs
-find .workflow/{sessionId}/.task/ -name '*.json'
+for task_file in .workflow/active/{sessionId}/.task/*.json; do
+  cat "$task_file"
+done
 
 # Extract task IDs
-find .workflow/{sessionId}/.task/ -name '*.json' -exec jq -r '.id' {} \;
+for task_file in .workflow/active/{sessionId}/.task/*.json; do
+  cat "$task_file" | jq -r '.id'
+done
 
-# Check dependencies
-find .workflow/{sessionId}/.task/ -name 'IMPL-*.json' -exec jq -r '.context.depends_on[]?' {} \;
-find .workflow/{sessionId}/.task/ -name 'REFACTOR-*.json' -exec jq -r '.context.depends_on[]?' {} \;
+# Check dependencies - read tasks and filter for IMPL/REFACTOR
+for task_file in .workflow/active/{sessionId}/.task/IMPL-*.json; do
+  cat "$task_file" | jq -r '.context.depends_on[]?'
+done
+
+for task_file in .workflow/active/{sessionId}/.task/REFACTOR-*.json; do
+  cat "$task_file" | jq -r '.context.depends_on[]?'
+done
 
 # Check meta fields
-find .workflow/{sessionId}/.task/ -name '*.json' -exec jq -r '.meta.tdd_phase' {} \;
-find .workflow/{sessionId}/.task/ -name '*.json' -exec jq -r '.meta.agent' {} \;
+for task_file in .workflow/active/{sessionId}/.task/*.json; do
+  cat "$task_file" | jq -r '.meta.tdd_phase'
+done
+
+for task_file in .workflow/active/{sessionId}/.task/*.json; do
+  cat "$task_file" | jq -r '.meta.agent'
+done
 ```
 
 **Validation**:
@@ -82,9 +129,9 @@ find .workflow/{sessionId}/.task/ -name '*.json' -exec jq -r '.meta.agent' {} \;
 - Compliance score
 
 **Validation**:
-- `.workflow/{sessionId}/.process/test-results.json` exists
-- `.workflow/{sessionId}/.process/coverage-report.json` exists
-- `.workflow/{sessionId}/.process/tdd-cycle-report.md` exists
+- `.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
 
 **TodoWrite**: Mark phase 3 completed, phase 4 in_progress
 
@@ -94,10 +141,10 @@ find .workflow/{sessionId}/.task/ -name '*.json' -exec jq -r '.meta.agent' {} \;
 **Gemini analysis for comprehensive TDD compliance report**
 
 ```bash
-cd project-root && ~/.claude/scripts/gemini-wrapper -p "
+ccw cli -p "
 PURPOSE: Generate TDD compliance report
 TASK: Analyze TDD workflow execution and generate quality report
-CONTEXT: @{.workflow/{sessionId}/.task/*.json,.workflow/{sessionId}/.summaries/*,.workflow/{sessionId}/.process/tdd-cycle-report.md}
+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
@@ -106,7 +153,7 @@ EXPECTED:
 - 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/{sessionId}/TDD_COMPLIANCE_REPORT.md
+" --tool gemini --mode analysis --cd project-root > .workflow/active/{sessionId}/TDD_COMPLIANCE_REPORT.md
 ```
 
 **Output**: TDD_COMPLIANCE_REPORT.md
@@ -118,14 +165,14 @@ RULES: Focus on TDD best practices and workflow adherence. Be specific about vio
 TDD Verification Report - Session: {sessionId}
 
 ## Chain Validation
-✅ Feature 1: TEST-1.1 → IMPL-1.1 → REFACTOR-1.1 (Complete)
-✅ Feature 2: TEST-2.1 → IMPL-2.1 → REFACTOR-2.1 (Complete)
-⚠️  Feature 3: TEST-3.1 → IMPL-3.1 (Missing REFACTOR phase)
+[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
+All TEST tasks produced failing tests
+All IMPL tasks made tests pass
+All REFACTOR tasks maintained green tests
 
 ## Coverage Metrics
 Line Coverage: {percentage}%
@@ -134,7 +181,7 @@ Function Coverage: {percentage}%
 
 ## Compliance Score: {score}/100
 
-Detailed report: .workflow/{sessionId}/TDD_COMPLIANCE_REPORT.md
+Detailed report: .workflow/active/{sessionId}/TDD_COMPLIANCE_REPORT.md
 
 Recommendations:
 - Complete missing REFACTOR-3.1 task
@@ -168,7 +215,7 @@ TodoWrite({todos: [
 
 ### Chain Validation Algorithm
 ```
-1. Load all task JSONs from .workflow/{sessionId}/.task/
+1. Load all task JSONs from .workflow/active/{sessionId}/.task/
 2. Extract task IDs and group by feature number
 3. For each feature:
    - Check TEST-N.M exists
@@ -202,7 +249,7 @@ Final Score: Max(0, Base Score - Deductions)
 
 ## Output Files
 ```
-.workflow/{session-id}/
+.workflow/active/{session-id}/
 ├── TDD_COMPLIANCE_REPORT.md     # Comprehensive compliance report ⭐
 └── .process/
     ├── test-results.json         # From tdd-coverage-analysis
@@ -215,8 +262,8 @@ Final Score: Max(0, Base Score - Deductions)
 ### Session Discovery Errors
 | Error | Cause | Resolution |
 |-------|-------|------------|
-| No active session | No .active-* file | Provide session-id explicitly |
-| Multiple active sessions | Multiple .active-* files | Provide session-id explicitly |
+| No active session | No WFS-* directories | Provide session-id explicitly |
+| Multiple active sessions | Multiple WFS-* directories | Provide session-id explicitly |
 | Session not found | Invalid session-id | Check available sessions |
 
 ### Validation Errors
@@ -237,7 +284,7 @@ Final Score: Max(0, Base Score - Deductions)
 
 ### Command Chain
 - **Called After**: `/workflow:execute` (when TDD tasks completed)
-- **Calls**: `/workflow:tools:tdd-coverage-analysis`, Gemini wrapper
+- **Calls**: `/workflow:tools:tdd-coverage-analysis`, Gemini CLI
 - **Related**: `/workflow:tdd-plan`, `/workflow:status`
 
 ### Basic Usage
@@ -271,20 +318,20 @@ Status: {EXCELLENT | GOOD | NEEDS IMPROVEMENT | FAILED}
 ## 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
+- **Red Phase**: Test created and failed with clear message
+- **Green Phase**: Minimal implementation made test pass
+- **Refactor Phase**: 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
+- **Red Phase**: Test created and failed
+- **Green Phase**: Implementation seems over-engineered
+- **Refactor Phase**: Missing
 
 **Issues**:
 - REFACTOR-2.1 task not completed
@@ -306,16 +353,16 @@ Status: {EXCELLENT | GOOD | NEEDS IMPROVEMENT | FAILED}
 ## 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
+- Feature 3: No evidence of initial test failure
 
 ### Green Phase (Make Test Pass)
-- ✅ {N}/{total} implementations made tests pass
-- ✅ All implementations minimal and focused
+- {N}/{total} implementations made tests pass
+- All implementations minimal and focused
 
 ### Refactor Phase (Improve Quality)
-- ⚠️ {N}/{total} features completed refactoring
-- ❌ Feature 2, 4: Refactoring step skipped
+- {N}/{total} features completed refactoring
+- Feature 2, 4: Refactoring step skipped
 
 ## Best Practices Assessment
 
@@ -351,8 +398,3 @@ Status: {EXCELLENT | GOOD | NEEDS IMPROVEMENT | FAILED}
 {Summary of compliance status and next steps}
 ```
 
-## Related Commands
-- `/workflow:tdd-plan` - Creates TDD workflow
-- `/workflow:execute` - Executes TDD tasks
-- `/workflow:tools:tdd-coverage-analysis` - Analyzes test coverage
-- `/workflow:status` - Views workflow progress

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

@@ -1,7 +1,7 @@
 ---
 name: test-fix-gen
-description: Create independent test-fix workflow session from existing implementation (session or prompt-based)
-argument-hint: "[--use-codex] [--cli-execute] (source-session-id | \"feature description\" | /path/to/file.md)"
+description: Create test-fix workflow session from session ID, description, or file path with test strategy generation and task planning
+argument-hint: "(source-session-id | \"feature description\" | /path/to/file.md)"
 allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*)
 ---
 
@@ -13,7 +13,11 @@ allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*)
 
 This command creates an independent test-fix workflow session for existing code. It orchestrates a 5-phase process to analyze implementation, generate test requirements, and create executable test generation and fix tasks.
 
-**⚠️ Command Scope**: Prepares test workflow artifacts only. Task execution requires separate commands (`/workflow:test-cycle-execute` or `/workflow:execute`).
+**CRITICAL - Command Scope**:
+- **This command ONLY generates task JSON files** (IMPL-001.json, IMPL-002.json)
+- **Does NOT execute tests or apply fixes** - all execution happens in separate orchestrator
+- **Must call `/workflow:test-cycle-execute`** after this command to actually run tests and fixes
+- **Test failure handling happens in test-cycle-execute**, not here
 
 ### Dual-Mode Support
 
@@ -39,17 +43,33 @@ 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
 
-This command is a **pure orchestrator**:
+This command is a **pure planning coordinator**:
 - Does NOT analyze code directly
 - Does NOT generate tests or documentation
-- ONLY coordinates slash commands in sequence
+- Does NOT execute tests or apply fixes
+- Does NOT handle test failures or iterations
+- ONLY coordinates slash commands to generate task JSON files
 - Parses outputs to pass data between phases
 - Creates independent test workflow session
+- **All execution delegated to `/workflow:test-cycle-execute`**
+
+**Task Attachment Model**:
+- SlashCommand execute **expands workflow** by attaching sub-tasks to current TodoWrite
+- When executing a sub-command (e.g., `/workflow:tools:test-context-gather`), its internal tasks are attached to the orchestrator's TodoWrite
+- Orchestrator **executes these attached tasks** sequentially
+- After completion, attached tasks are **collapsed** back to high-level phase summary
+- This is **task expansion**, not external delegation
+
+**Auto-Continue Mechanism**:
+- TodoList tracks current phase status and dynamically manages task attachment/collapse
+- When each phase finishes executing, automatically execute next pending phase
+- All phases run autonomously without user interaction
+- **⚠️ CONTINUOUS EXECUTION** - Do not stop until all phases complete
 
 ---
 
@@ -59,16 +79,14 @@ This command is a **pure orchestrator**:
 
 ```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
@@ -76,11 +94,8 @@ This command is a **pure orchestrator**:
 # 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
@@ -88,17 +103,14 @@ This command is a **pure orchestrator**:
 # 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
@@ -116,30 +128,50 @@ This command is a **pure orchestrator**:
 
 ### 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 after every phase
+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
+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**:
@@ -155,9 +187,15 @@ This command is a **pure orchestrator**:
 
 #### 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
 
@@ -186,7 +224,11 @@ This command is a **pure orchestrator**:
 
 #### 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
@@ -195,9 +237,25 @@ This command is a **pure orchestrator**:
 **Expected Behavior**:
 - Use Gemini to analyze coverage gaps and implementation
 - Study existing test patterns and conventions
-- Generate test requirements for missing test files
-- Design test generation strategy
-- Generate `TEST_ANALYSIS_RESULTS.md`
+- Generate **multi-layered test requirements** (L0: Static Analysis, L1: Unit, L2: Integration, L3: E2E)
+- Design test generation strategy with quality assurance criteria
+- Generate `TEST_ANALYSIS_RESULTS.md` with structured test layers
+
+**Enhanced Test Requirements**:
+For each targeted file/function, Gemini MUST generate:
+1. **L0: Static Analysis Requirements**:
+   - Linting rules to enforce (ESLint, Prettier)
+   - Type checking requirements (TypeScript)
+   - Anti-pattern detection rules
+2. **L1: Unit Test Requirements**:
+   - Happy path scenarios (valid inputs → expected outputs)
+   - Negative path scenarios (invalid inputs → error handling)
+   - Edge cases (null, undefined, 0, empty strings/arrays)
+3. **L2: Integration Test Requirements**:
+   - Successful component interactions
+   - Failure handling scenarios (service unavailable, timeout)
+4. **L3: E2E Test Requirements** (if applicable):
+   - Key user journeys from start to finish
 
 **Parse Output**:
 - Verify `.workflow/[testSessionId]/.process/TEST_ANALYSIS_RESULTS.md` created
@@ -206,9 +264,18 @@ This command is a **pure orchestrator**:
 - TEST_ANALYSIS_RESULTS.md exists with complete sections:
   - Coverage Assessment
   - Test Framework & Conventions
-  - Test Requirements by File
+  - **Multi-Layered Test Plan** (NEW):
+    - L0: Static Analysis Plan
+    - L1: Unit Test Plan
+    - L2: Integration Test Plan
+    - L3: E2E Test Plan (if applicable)
+  - Test Requirements by File (with layer annotations)
   - Test Generation Strategy
   - Implementation Targets
+  - Quality Assurance Criteria (NEW):
+    - Minimum coverage thresholds
+    - Required test types per function
+    - Acceptance criteria for test quality
   - Success Criteria
 
 **TodoWrite**: Mark phase 3 completed, phase 4 in_progress
@@ -217,24 +284,30 @@ This command is a **pure orchestrator**:
 
 #### 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
-- Generate **minimum 2 task JSON files** (expandable based on complexity):
+- Parse TEST_ANALYSIS_RESULTS.md from Phase 3 (multi-layered test plan)
+- Generate **minimum 3 task JSON files** (expandable based on complexity):
   - **IMPL-001.json**: Test Understanding & Generation (`@code-developer`)
+  - **IMPL-001.5-review.json**: Test Quality Gate (`@test-fix-agent`) ← **NEW**
   - **IMPL-002.json**: Test Execution & Fix Cycle (`@test-fix-agent`)
   - **IMPL-003+**: Additional tasks if needed for complex projects
-- Generate `IMPL_PLAN.md` with test strategy
+- Generate `IMPL_PLAN.md` with multi-layered test strategy
 - Generate `TODO_LIST.md` with task checklist
 
 **Parse Output**:
 - Verify `.workflow/[testSessionId]/.task/IMPL-001.json` exists
+- Verify `.workflow/[testSessionId]/.task/IMPL-001.5-review.json` exists ← **NEW**
 - Verify `.workflow/[testSessionId]/.task/IMPL-002.json` exists
 - Verify additional `.task/IMPL-*.json` if applicable
 - Verify `IMPL_PLAN.md` and `TODO_LIST.md` created
@@ -255,11 +328,16 @@ Test Session: [testSessionId]
 
 Tasks Created:
 - IMPL-001: Test Understanding & Generation (@code-developer)
+- IMPL-001.5: Test Quality Gate - Static Analysis & Coverage (@test-fix-agent) ← NEW
 - IMPL-002: Test Execution & Fix Cycle (@test-fix-agent)
 [- IMPL-003+: Additional tasks if applicable]
 
+Test Strategy: Multi-Layered (L0: Static, L1: Unit, L2: Integration, L3: E2E)
 Test Framework: [detected framework]
 Test Files to Generate: [count]
+Quality Thresholds:
+- Minimum Coverage: 80%
+- Static Analysis: Zero critical issues
 Max Fix Iterations: 5
 Fix Mode: [Manual|Codex Automated]
 
@@ -267,84 +345,196 @@ Review artifacts:
 - Test plan: .workflow/[testSessionId]/IMPL_PLAN.md
 - Task list: .workflow/[testSessionId]/TODO_LIST.md
 
-Next Steps:
-- Review IMPL_PLAN.md
-- Execute: /workflow:test-cycle-execute [testSessionId]
+CRITICAL - Next Steps:
+1. Review IMPL_PLAN.md (now includes multi-layered test strategy)
+2. **MUST execute: /workflow:test-cycle-execute**
+   - This command only generated task JSON files
+   - Test execution and fix iterations happen in test-cycle-execute
+   - Do NOT attempt to run tests or fixes in main workflow
+3. IMPL-001.5 will validate test quality before fix cycle begins
 ```
 
 **TodoWrite**: Mark phase 5 completed
 
-**Note**: Command completes here. Task execution requires separate workflow commands.
+**BOUNDARY NOTE**:
+- Command completes here - only task JSON files generated
+- All test execution, failure detection, CLI analysis, fix generation happens in `/workflow:test-cycle-execute`
+- This command does NOT handle test failures or apply fixes
 
 ---
 
-### TodoWrite Progress Tracking
+### TodoWrite Pattern
 
-Track all 5 phases:
+**Core Concept**: Dynamic task attachment and collapse for test-fix-gen workflow with dual-mode support (Session Mode and Prompt Mode).
 
-```javascript
-TodoWrite({todos: [
-  {"content": "Create independent test session", "status": "in_progress|completed", "activeForm": "Creating test session"},
-  {"content": "Gather test coverage context", "status": "pending|in_progress|completed", "activeForm": "Gathering test coverage context"},
-  {"content": "Analyze test requirements with Gemini", "status": "pending|in_progress|completed", "activeForm": "Analyzing test requirements"},
-  {"content": "Generate test generation and execution tasks", "status": "pending|in_progress|completed", "activeForm": "Generating test tasks"},
-  {"content": "Return workflow summary", "status": "pending|in_progress|completed", "activeForm": "Returning workflow summary"}
-]})
+#### Initial TodoWrite Structure
+
+```json
+[
+  {"content": "Phase 1: Create Test Session", "status": "in_progress", "activeForm": "Creating test session"},
+  {"content": "Phase 2: Gather Test Context", "status": "pending", "activeForm": "Gathering test context"},
+  {"content": "Phase 3: Test Generation Analysis", "status": "pending", "activeForm": "Analyzing test generation"},
+  {"content": "Phase 4: Generate Test Tasks", "status": "pending", "activeForm": "Generating test tasks"},
+  {"content": "Phase 5: Return Summary", "status": "pending", "activeForm": "Completing"}
+]
 ```
 
-Update status to `in_progress` when starting each phase, `completed` when done.
+#### Key Principles
+
+1. **Task Attachment** (when SlashCommand executed):
+   - Sub-command's internal tasks are **attached** to orchestrator's TodoWrite
+   - Example - Phase 2 with sub-tasks:
+   ```json
+   [
+     {"content": "Phase 1: Create Test Session", "status": "completed", "activeForm": "Creating test session"},
+     {"content": "Phase 2: Gather Test Context", "status": "in_progress", "activeForm": "Gathering test context"},
+     {"content": "  → Load context and analyze coverage", "status": "in_progress", "activeForm": "Loading context"},
+     {"content": "  → Detect test framework and conventions", "status": "pending", "activeForm": "Detecting framework"},
+     {"content": "  → Generate context package", "status": "pending", "activeForm": "Generating context"},
+     {"content": "Phase 3: Test Generation Analysis", "status": "pending", "activeForm": "Analyzing test generation"},
+     {"content": "Phase 4: Generate Test Tasks", "status": "pending", "activeForm": "Generating test tasks"},
+     {"content": "Phase 5: Return Summary", "status": "pending", "activeForm": "Completing"}
+   ]
+   ```
+
+2. **Task Collapse** (after sub-tasks complete):
+   - Remove detailed sub-tasks from TodoWrite
+   - **Collapse** to high-level phase summary
+   - Example - Phase 2 completed:
+   ```json
+   [
+     {"content": "Phase 1: Create Test Session", "status": "completed", "activeForm": "Creating test session"},
+     {"content": "Phase 2: Gather Test Context", "status": "completed", "activeForm": "Gathering test context"},
+     {"content": "Phase 3: Test Generation Analysis", "status": "in_progress", "activeForm": "Analyzing test generation"},
+     {"content": "Phase 4: Generate Test Tasks", "status": "pending", "activeForm": "Generating test tasks"},
+     {"content": "Phase 5: Return Summary", "status": "pending", "activeForm": "Completing"}
+   ]
+   ```
+
+3. **Continuous Execution**:
+   - After collapse, automatically proceed to next pending phase
+   - No user intervention required between phases
+   - TodoWrite dynamically reflects current execution state
+
+**Lifecycle Summary**: Initial pending tasks → Phase 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
+
+- **Dual-Mode Support**: Automatic mode detection based on input pattern
+  - **Session Mode**: Input pattern `WFS-*` → uses `test-context-gather` for cross-session context
+  - **Prompt Mode**: Text or file path → uses `context-gather` for direct codebase analysis
+- **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**: CLI tool usage determined semantically from user's task description
+
 
 ---
 
 ## Task Specifications
 
-Generates minimum 2 tasks (expandable for complex projects):
+Generates minimum 3 tasks (expandable for complex projects):
 
 ### IMPL-001: Test Understanding & Generation
 
 **Agent**: `@code-developer`
 
-**Purpose**: Understand source implementation and generate test files
+**Purpose**: Understand source implementation and generate test files following multi-layered test strategy
 
 **Task Configuration**:
 - Task ID: `IMPL-001`
 - `meta.type: "test-gen"`
 - `meta.agent: "@code-developer"`
-- `context.requirements`: Understand source implementation and generate tests
+- `context.requirements`: Understand source implementation and generate tests across all layers (L0-L3)
 - `flow_control.target_files`: Test files to create from TEST_ANALYSIS_RESULTS.md section 5
 
 **Execution Flow**:
 1. **Understand Phase**:
    - Load TEST_ANALYSIS_RESULTS.md and test context
    - Understand source code implementation patterns
-   - Analyze test requirements and conventions
-   - Identify test scenarios and edge cases
+   - Analyze multi-layered test requirements (L0: Static, L1: Unit, L2: Integration, L3: E2E)
+   - Identify test scenarios, edge cases, and error paths
 2. **Generation Phase**:
-   - Generate test files following existing patterns
-   - Ensure test coverage aligns with requirements
+   - Generate L1 unit test files following existing patterns
+   - Generate L2 integration test files (if applicable)
+   - Generate L3 E2E test files (if applicable)
+   - Ensure test coverage aligns with multi-layered requirements
+   - Include both positive and negative test cases
 3. **Verification Phase**:
    - Verify test completeness and correctness
+   - Ensure each test has meaningful assertions
+   - Check for test anti-patterns (tests without assertions, overly broad mocks)
+
+### IMPL-001.5: Test Quality Gate ← **NEW**
+
+**Agent**: `@test-fix-agent`
+
+**Purpose**: Validate test quality before entering fix cycle - prevent "hollow tests" from becoming the source of truth
+
+**Task Configuration**:
+- Task ID: `IMPL-001.5-review`
+- `meta.type: "test-quality-review"`
+- `meta.agent: "@test-fix-agent"`
+- `context.depends_on: ["IMPL-001"]`
+- `context.requirements`: Validate generated tests meet quality standards
+- `context.quality_config`: Load from `.claude/workflows/test-quality-config.json`
+
+**Execution Flow**:
+1. **L0: Static Analysis**:
+   - Run linting on test files (ESLint, Prettier)
+   - Check for test anti-patterns:
+     - Tests without assertions (`expect()` missing)
+     - Empty test bodies (`it('should...', () => {})`)
+     - Disabled tests without justification (`it.skip`, `xit`)
+   - Verify TypeScript type safety (if applicable)
+2. **Coverage Analysis**:
+   - Run coverage analysis on generated tests
+   - Calculate coverage percentage for target source files
+   - Identify uncovered branches and edge cases
+3. **Test Quality Metrics**:
+   - Verify minimum coverage threshold met (default: 80%)
+   - Verify all critical functions have negative test cases
+   - Verify integration tests cover key component interactions
+4. **Quality Gate Decision**:
+   - **PASS**: Coverage ≥ 80%, zero critical anti-patterns → Proceed to IMPL-002
+   - **FAIL**: Coverage < 80% OR critical anti-patterns found → Loop back to IMPL-001 with feedback
+
+**Acceptance Criteria**:
+- Static analysis: Zero critical issues
+- Test coverage: ≥ 80% for target files
+- Test completeness: All targeted functions have unit tests
+- Negative test coverage: Each public API has at least one error handling test
+- Integration coverage: Key component interactions have integration tests (if applicable)
+
+**Failure Handling**:
+If quality gate fails:
+1. Generate detailed feedback report (`.process/test-quality-report.md`)
+2. Update IMPL-001 task with specific improvement requirements
+3. Trigger IMPL-001 re-execution with enhanced context
+4. Maximum 2 quality gate retries before escalating to user
 
 ### IMPL-002: Test Execution & Fix Cycle
 
 **Agent**: `@test-fix-agent`
 
-**Purpose**: Execute tests and apply iterative fixes (max 5 iterations)
+**Purpose**: Execute initial tests and trigger orchestrator-managed fix cycles
+
+**Note**: This task executes tests and reports results. The test-cycle-execute orchestrator manages all fix iterations, CLI analysis, and fix task generation.
 
 **Task Configuration**:
 - 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**:
-- **Cycle Pattern**: test → gemini_diagnose → manual_fix (or codex) → retest
-- **Tools Configuration**:
+**Note**: This specification describes what test-cycle-execute orchestrator will do. The agent only executes single tasks.
+- **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)
-- **Exit Conditions**:
+  - 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)
 
@@ -368,7 +558,7 @@ Generates minimum 2 tasks (expandable for complex projects):
 
 ### Output Files Structure
 
-Created in `.workflow/WFS-test-[session]/`:
+Created in `.workflow/active/WFS-test-[session]/`:
 
 ```
 WFS-test-[session]/
@@ -389,25 +579,69 @@ 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
 
-### Complete Data Flow
+### Execution Flow Diagram
 
-**Example Command**: `/workflow:test-fix-gen WFS-user-auth`
+```
+Test-Fix-Gen Workflow Orchestrator (Dual-Mode Support)
+│
+├─ Phase 1: Create Test Session
+│  ├─ Session Mode: /workflow:session:start --new (with source_session_id)
+│  └─ Prompt Mode: /workflow:session:start --new (without source_session_id)
+│     └─ Returns: testSessionId (WFS-test-[slug])
+│
+├─ Phase 2: Gather Context                                   ← ATTACHED (3 tasks)
+│  ├─ Session Mode: /workflow:tools:test-context-gather
+│  │  └─ Load source session summaries + analyze coverage
+│  └─ Prompt Mode: /workflow:tools:context-gather
+│     └─ Analyze codebase from description
+│     ├─ Phase 2.1: Load context and analyze coverage
+│     ├─ Phase 2.2: Detect test framework and conventions
+│     └─ Phase 2.3: Generate context package
+│     └─ Returns: [test-]context-package.json                ← COLLAPSED
+│
+├─ Phase 3: Test Generation Analysis                         ← ATTACHED (3 tasks)
+│  └─ /workflow:tools:test-concept-enhanced
+│     ├─ Phase 3.1: Analyze coverage gaps with Gemini
+│     ├─ Phase 3.2: Study existing test patterns
+│     └─ Phase 3.3: Generate test generation strategy
+│     └─ Returns: TEST_ANALYSIS_RESULTS.md                   ← COLLAPSED
+│
+├─ Phase 4: Generate Test Tasks                              ← ATTACHED (3 tasks)
+│  └─ /workflow:tools:test-task-generate
+│     ├─ Phase 4.1: Parse TEST_ANALYSIS_RESULTS.md
+│     ├─ Phase 4.2: Generate task JSONs (IMPL-001, IMPL-002)
+│     └─ Phase 4.3: Generate IMPL_PLAN.md and TODO_LIST.md
+│     └─ Returns: Task JSONs and plans                       ← COLLAPSED
+│
+└─ Phase 5: Return Summary
+   └─ Command ends, control returns to user
 
-**Phase Execution Chain**:
-1. Phase 1: `session-start` → `WFS-test-user-auth`
-2. Phase 2: `test-context-gather` → `test-context-package.json`
-3. Phase 3: `test-concept-enhanced` → `TEST_ANALYSIS_RESULTS.md`
-4. Phase 4: `test-task-generate` → `IMPL-001.json` + `IMPL-002.json` (+ additional if needed)
-5. Phase 5: Return summary
+Artifacts Created:
+├── .workflow/active/WFS-test-[session]/
+│   ├── workflow-session.json
+│   ├── IMPL_PLAN.md
+│   ├── TODO_LIST.md
+│   ├── .task/
+│   │   ├── IMPL-001.json (test understanding & generation)
+│   │   ├── IMPL-002.json (test execution & fix cycle)
+│   │   └── IMPL-003.json (optional: test review & certification)
+│   └── .process/
+│       ├── [test-]context-package.json
+│       └── TEST_ANALYSIS_RESULTS.md
 
-**Command completes after Phase 5**
+Key Points:
+• ← ATTACHED: SlashCommand attaches sub-tasks to orchestrator TodoWrite
+• ← COLLAPSED: Sub-tasks executed and collapsed to phase summary
+• Dual-Mode: Session Mode and Prompt Mode share same attachment pattern
+• Command Boundary: Execution delegated to /workflow:test-cycle-execute
+```
 
 ---
 
@@ -443,28 +677,23 @@ WFS-test-[session]/
 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
+## Related Commands
 
-**Planning Phase**:
-- `/workflow:plan` - Create implementation workflow
-- `/workflow:session:start` - Initialize workflow session
+**Prerequisite Commands**:
+- `/workflow:plan` or `/workflow:execute` - Complete implementation session (for Session Mode)
+- None for Prompt Mode (ad-hoc test generation)
 
-**Context Gathering**:
-- `/workflow:tools:test-context-gather` - Session-based context (Phase 2 for session mode)
-- `/workflow:tools:context-gather` - Prompt-based context (Phase 2 for prompt mode)
+**Called by This Command** (5 phases):
+- `/workflow:session:start` - Phase 1: Create independent test workflow session
+- `/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 (CLI tool usage determined semantically)
 
-**Analysis & Task Generation**:
-- `/workflow:tools:test-concept-enhanced` - Gemini test analysis (Phase 3)
-- `/workflow:tools:test-task-generate` - Generate test tasks (Phase 4)
+**Follow-up Commands**:
+- `/workflow:status` - Review generated test tasks
+- `/workflow:test-cycle-execute` - Execute test generation and iterative fix cycles
+- `/workflow:execute` - Standard execution of generated test tasks
 
-**Execution**:
-- `/workflow:test-cycle-execute` - Execute test-fix workflow (recommended for IMPL-002)
-- `/workflow:execute` - Execute standard workflow tasks
-- `/workflow:status` - Check task progress
-
-**Review & Management**:
-- `/workflow:review` - Review workflow results
-- `/workflow:session:complete` - Mark session complete

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

@@ -1,7 +1,7 @@
 ---
 name: test-gen
-description: Create independent test-fix workflow session by analyzing completed implementation
-argument-hint: "[--use-codex] [--cli-execute] source-session-id"
+description: Create independent test-fix workflow session from completed implementation session, analyzes code to generate test tasks
+argument-hint: "source-session-id"
 allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*)
 ---
 
@@ -16,7 +16,20 @@ 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 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
+
+**Auto-Continue Mechanism**:
+- TodoList tracks current phase status and dynamically manages task attachment/collapse
+- When each phase finishes executing, automatically execute next pending phase
+- All phases run autonomously without user interaction
+- **⚠️ CONTINUOUS EXECUTION** - Do not stop until all phases complete
 
 **Execution Flow**:
 1. Initialize TodoWrite → Create test session → Parse session ID
@@ -24,7 +37,7 @@ allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*)
 3. Analyze implementation with concept-enhanced → Parse ANALYSIS_RESULTS.md
 4. Generate test task from analysis → Return summary
 
-**⚠️ Command Scope**: This command ONLY prepares test workflow artifacts. It does NOT execute tests or implementation. Task execution requires separate user action.
+**Command Scope**: This command ONLY prepares test workflow artifacts. It does NOT execute tests or implementation. Task execution requires separate user action.
 
 ## Core Rules
 
@@ -33,23 +46,46 @@ allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*)
 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 to user until Phase 5 completes (summary returned)
-6. **Track Progress**: Update TodoWrite after every phase completion
+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)
-9. **⚠️ Command Boundary**: This command ends at Phase 5 summary. Test execution is NOT part of this command.
+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 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**:
@@ -67,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`)
 
@@ -89,12 +130,49 @@ allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*)
 - Test framework detected
 - Test conventions documented
 
-**TodoWrite**: Mark phase 2 completed, phase 3 in_progress
+<!-- TodoWrite: When test-context-gather executed, INSERT 3 test-context-gather tasks -->
+
+**TodoWrite Update (Phase 2 SlashCommand executed - tasks attached)**:
+```json
+[
+  {"content": "Create independent test session", "status": "completed", "activeForm": "Creating test session"},
+  {"content": "Phase 2.1: Load source session summaries (test-context-gather)", "status": "in_progress", "activeForm": "Loading source session summaries"},
+  {"content": "Phase 2.2: Analyze test coverage with MCP tools (test-context-gather)", "status": "pending", "activeForm": "Analyzing test coverage"},
+  {"content": "Phase 2.3: Identify coverage gaps and framework (test-context-gather)", "status": "pending", "activeForm": "Identifying coverage gaps"},
+  {"content": "Analyze test requirements with Gemini", "status": "pending", "activeForm": "Analyzing test requirements"},
+  {"content": "Generate test generation and execution tasks", "status": "pending", "activeForm": "Generating test tasks"},
+  {"content": "Return workflow summary", "status": "pending", "activeForm": "Returning workflow summary"}
+]
+```
+
+**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
+
+<!-- TodoWrite: After Phase 2 tasks complete, REMOVE Phase 2.1-2.3, restore to orchestrator view -->
+
+**TodoWrite Update (Phase 2 completed - tasks collapsed)**:
+```json
+[
+  {"content": "Create independent test session", "status": "completed", "activeForm": "Creating test session"},
+  {"content": "Gather test coverage context", "status": "completed", "activeForm": "Gathering test coverage context"},
+  {"content": "Analyze test requirements with Gemini", "status": "pending", "activeForm": "Analyzing test requirements"},
+  {"content": "Generate test generation and execution tasks", "status": "pending", "activeForm": "Generating test tasks"},
+  {"content": "Return workflow summary", "status": "pending", "activeForm": "Returning workflow summary"}
+]
+```
+
+**Note**: Phase 2 tasks completed and collapsed to summary.
 
 ---
 
 ### 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
@@ -121,17 +199,54 @@ allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*)
   - Implementation Targets (test files to create)
   - Success Criteria
 
-**TodoWrite**: Mark phase 3 completed, phase 4 in_progress
+<!-- TodoWrite: When test-concept-enhanced executed, INSERT 3 concept-enhanced tasks -->
+
+**TodoWrite Update (Phase 3 SlashCommand executed - tasks attached)**:
+```json
+[
+  {"content": "Create independent test session", "status": "completed", "activeForm": "Creating test session"},
+  {"content": "Gather test coverage context", "status": "completed", "activeForm": "Gathering test coverage context"},
+  {"content": "Phase 3.1: Analyze coverage gaps with Gemini (test-concept-enhanced)", "status": "in_progress", "activeForm": "Analyzing coverage gaps"},
+  {"content": "Phase 3.2: Study existing test patterns (test-concept-enhanced)", "status": "pending", "activeForm": "Studying test patterns"},
+  {"content": "Phase 3.3: Generate test generation strategy (test-concept-enhanced)", "status": "pending", "activeForm": "Generating test strategy"},
+  {"content": "Generate test generation and execution tasks", "status": "pending", "activeForm": "Generating test tasks"},
+  {"content": "Return workflow summary", "status": "pending", "activeForm": "Returning workflow summary"}
+]
+```
+
+**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
+
+<!-- TodoWrite: After Phase 3 tasks complete, REMOVE Phase 3.1-3.3, restore to orchestrator view -->
+
+**TodoWrite Update (Phase 3 completed - tasks collapsed)**:
+```json
+[
+  {"content": "Create independent test session", "status": "completed", "activeForm": "Creating test session"},
+  {"content": "Gather test coverage context", "status": "completed", "activeForm": "Gathering test coverage context"},
+  {"content": "Analyze test requirements with Gemini", "status": "completed", "activeForm": "Analyzing test requirements"},
+  {"content": "Generate test generation and execution tasks", "status": "pending", "activeForm": "Generating test tasks"},
+  {"content": "Return workflow summary", "status": "pending", "activeForm": "Returning workflow summary"}
+]
+```
+
+**Note**: Phase 3 tasks completed and collapsed to summary.
 
 ---
 
 ### 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
@@ -161,29 +276,60 @@ 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**: Mark phase 4 completed, phase 5 in_progress
+<!-- TodoWrite: When test-task-generate executed, INSERT 3 test-task-generate tasks -->
+
+**TodoWrite Update (Phase 4 SlashCommand executed - tasks attached)**:
+```json
+[
+  {"content": "Create independent test session", "status": "completed", "activeForm": "Creating test session"},
+  {"content": "Gather test coverage context", "status": "completed", "activeForm": "Gathering test coverage context"},
+  {"content": "Analyze test requirements with Gemini", "status": "completed", "activeForm": "Analyzing test requirements"},
+  {"content": "Phase 4.1: Parse TEST_ANALYSIS_RESULTS.md (test-task-generate)", "status": "in_progress", "activeForm": "Parsing test analysis"},
+  {"content": "Phase 4.2: Generate IMPL-001.json and IMPL-002.json (test-task-generate)", "status": "pending", "activeForm": "Generating task JSONs"},
+  {"content": "Phase 4.3: Generate IMPL_PLAN.md and TODO_LIST.md (test-task-generate)", "status": "pending", "activeForm": "Generating plan documents"},
+  {"content": "Return workflow summary", "status": "pending", "activeForm": "Returning workflow summary"}
+]
+```
+
+**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
+
+<!-- TodoWrite: After Phase 4 tasks complete, REMOVE Phase 4.1-4.3, restore to orchestrator view -->
+
+**TodoWrite Update (Phase 4 completed - tasks collapsed)**:
+```json
+[
+  {"content": "Create independent test session", "status": "completed", "activeForm": "Creating test session"},
+  {"content": "Gather test coverage context", "status": "completed", "activeForm": "Gathering test coverage context"},
+  {"content": "Analyze test requirements with Gemini", "status": "completed", "activeForm": "Analyzing test requirements"},
+  {"content": "Generate test generation and execution tasks", "status": "completed", "activeForm": "Generating test tasks"},
+  {"content": "Return workflow summary", "status": "in_progress", "activeForm": "Returning workflow summary"}
+]
+```
+
+**Note**: Phase 4 tasks completed and collapsed to summary.
 
 ---
 
-### Phase 5: Return Summary (⚠️ Command Ends Here)
+### Phase 5: Return Summary (Command Ends Here)
 
-**⚠️ Important**: This is the final phase of `/workflow:test-gen`. The command completes and returns control to the user. No automatic execution occurs.
+**Important**: This is the final phase of `/workflow:test-gen`. The command completes and returns control to the user. No automatic execution occurs.
 
 **Return to User**:
 ```
-✅ Test workflow preparation complete!
+Test workflow preparation complete!
 
 Source Session: [sourceSessionId]
 Test Session: [testSessionId]
@@ -196,58 +342,93 @@ 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:
+Review Generated Artifacts:
 - Test plan: .workflow/[testSessionId]/IMPL_PLAN.md
 - Task list: .workflow/[testSessionId]/TODO_LIST.md
 - Analysis: .workflow/[testSessionId]/.process/TEST_ANALYSIS_RESULTS.md
 
-⚠️ Ready for execution. Use appropriate workflow commands to proceed.
+Ready for execution. Use appropriate workflow commands to proceed.
 ```
 
 **TodoWrite**: Mark phase 5 completed
 
-**⚠️ Command Boundary**: After this phase, the command terminates and returns to user prompt.
+**Command Boundary**: After this phase, the command terminates and returns to user prompt.
 
 ---
 
 ## TodoWrite Pattern
 
-Track progress through 5 phases:
+**Core Concept**: Dynamic task attachment and collapse for test-gen workflow with cross-session context gathering and test generation strategy.
 
-```javascript
-TodoWrite({todos: [
-  {"content": "Create independent test session", "status": "in_progress|completed", "activeForm": "Creating test session"},
-  {"content": "Gather test coverage context", "status": "pending|in_progress|completed", "activeForm": "Gathering test coverage context"},
-  {"content": "Analyze test requirements with Gemini", "status": "pending|in_progress|completed", "activeForm": "Analyzing test requirements"},
-  {"content": "Generate test generation and execution tasks", "status": "pending|in_progress|completed", "activeForm": "Generating test tasks"},
-  {"content": "Return workflow summary", "status": "pending|in_progress|completed", "activeForm": "Returning workflow summary"}
-]})
-```
+### Key Principles
 
-Update status to `in_progress` when starting each phase, mark `completed` when done.
+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`
+   - Orchestrator **executes** these attached tasks sequentially
 
-## Data Flow
+2. **Task Collapse** (after sub-tasks complete):
+   - Remove detailed sub-tasks from TodoWrite
+   - **Collapse** to high-level phase summary
+   - Example: Phase 2.1-2.3 collapse to "Gather test coverage context: completed"
+   - Maintains clean orchestrator-level view
+
+3. **Continuous Execution**:
+   - After collapse, automatically proceed to next pending phase
+   - No user intervention required between phases
+   - TodoWrite dynamically reflects current execution state
+
+**Lifecycle Summary**: Initial pending tasks → Phase 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**: CLI tool usage determined semantically from user's task description
+
+
+
+**Note**: See individual Phase descriptions (Phase 2, 3, 4) for detailed TodoWrite Update examples with full JSON structures.
+
+## Execution Flow Diagram
 
 ```
-┌─────────────────────────────────────────────────────────┐
-│ /workflow:test-gen WFS-user-auth                        │
-├─────────────────────────────────────────────────────────┤
-│ Phase 1: session-start → WFS-test-user-auth            │
-│   ↓                                                     │
-│ Phase 2: test-context-gather → test-context-package.json│
-│   ↓                                                     │
-│ Phase 3: test-concept-enhanced → TEST_ANALYSIS_RESULTS.md│
-│   ↓                                                     │
-│ Phase 4: test-task-generate → IMPL-001.json + IMPL-002.json│
-│   ↓                                                     │
-│ Phase 5: Return summary                                │
-└─────────────────────────────────────────────────────────┘
-         ⚠️ COMMAND ENDS - Control returns to user
+Test-Gen Workflow Orchestrator
+│
+├─ Phase 1: Create Test Session
+│  └─ /workflow:session:start --new
+│     └─ Returns: testSessionId (WFS-test-[source])
+│
+├─ Phase 2: Gather Test Context                           ← ATTACHED (3 tasks)
+│  └─ /workflow:tools:test-context-gather
+│     ├─ Phase 2.1: Load source session summaries
+│     ├─ Phase 2.2: Analyze test coverage with MCP tools
+│     └─ Phase 2.3: Identify coverage gaps and framework
+│     └─ Returns: test-context-package.json               ← COLLAPSED
+│
+├─ Phase 3: Test Generation Analysis                      ← ATTACHED (3 tasks)
+│  └─ /workflow:tools:test-concept-enhanced
+│     ├─ Phase 3.1: Analyze coverage gaps with Gemini
+│     ├─ Phase 3.2: Study existing test patterns
+│     └─ Phase 3.3: Generate test generation strategy
+│     └─ Returns: TEST_ANALYSIS_RESULTS.md                ← COLLAPSED
+│
+├─ Phase 4: Generate Test Tasks                           ← ATTACHED (3 tasks)
+│  └─ /workflow:tools:test-task-generate
+│     ├─ Phase 4.1: Parse TEST_ANALYSIS_RESULTS.md
+│     ├─ Phase 4.2: Generate IMPL-001.json and IMPL-002.json
+│     └─ Phase 4.3: Generate IMPL_PLAN.md and TODO_LIST.md
+│     └─ Returns: Task JSONs and plans                    ← COLLAPSED
+│
+└─ Phase 5: Return Summary
+   └─ Command ends, control returns to user
 
 Artifacts Created:
-├── .workflow/WFS-test-[session]/
+├── .workflow/active/WFS-test-[session]/
 │   ├── workflow-session.json
 │   ├── IMPL_PLAN.md
 │   ├── TODO_LIST.md
@@ -257,6 +438,10 @@ Artifacts Created:
 │   └── .process/
 │       ├── test-context-package.json
 │       └── TEST_ANALYSIS_RESULTS.md
+
+Key Points:
+• ← ATTACHED: SlashCommand attaches sub-tasks to orchestrator TodoWrite
+• ← COLLAPSED: Sub-tasks executed and collapsed to phase summary
 ```
 
 ## Session Metadata
@@ -274,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.
 
@@ -290,7 +475,7 @@ See `/workflow:tools:test-task-generate` for complete task JSON schemas.
 
 ## Output Files
 
-Created in `.workflow/WFS-test-[session]/`:
+Created in `.workflow/active/WFS-test-[session]/`:
 - `workflow-session.json` - Session metadata
 - `.process/test-context-package.json` - Coverage analysis
 - `.process/TEST_ANALYSIS_RESULTS.md` - Test requirements
@@ -311,11 +496,10 @@ Created in `.workflow/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
 
@@ -330,8 +514,16 @@ See `/workflow:tools:test-task-generate` for complete JSON schemas.
 
 ## Related Commands
 
-- `/workflow:tools:test-context-gather` - Phase 2 (coverage analysis)
-- `/workflow:tools:test-concept-enhanced` - Phase 3 (Gemini test analysis)
-- `/workflow:tools:test-task-generate` - Phase 4 (task generation)
-- `/workflow:execute` - Execute workflow
-- `/workflow:status` - Check progress
+**Prerequisite Commands**:
+- `/workflow:plan` or `/workflow:execute` - Complete implementation session that needs test validation
+
+**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 (CLI tool usage determined semantically)
+
+**Follow-up Commands**:
+- `/workflow:status` - Review generated test tasks
+- `/workflow:test-cycle-execute` - Execute test generation and fix cycles
+- `/workflow:execute` - Execute generated test tasks

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

@@ -1,229 +0,0 @@
----
-name: concept-enhanced
-description: Enhanced intelligent analysis with parallel CLI execution and design blueprint generation
-argument-hint: "--session WFS-session-id --context path/to/context-package.json"
-examples:
-  - /workflow:tools:concept-enhanced --session WFS-auth --context .workflow/WFS-auth/.process/context-package.json
-  - /workflow:tools:concept-enhanced --session WFS-payment --context .workflow/WFS-payment/.process/context-package.json
----
-
-# Enhanced Analysis Command (/workflow:tools:concept-enhanced)
-
-## Overview
-Advanced solution design and feasibility analysis engine with parallel CLI execution. Processes standardized context packages to produce ANALYSIS_RESULTS.md focused on solution improvements, key design decisions, and critical insights.
-
-**Scope**: Solution-focused technical analysis only. Does NOT generate task breakdowns or implementation plans.
-
-**Usage**: Standalone command or integrated into `/workflow:plan`. Accepts context packages and orchestrates Gemini/Codex for comprehensive analysis.
-
-## Core Philosophy & Responsibilities
-- **Agent Coordination**: Delegate analysis execution to specialized agent (cli-execution-agent)
-- **Solution-Focused Analysis**: Emphasize design decisions, architectural rationale, and critical insights (exclude task planning)
-- **Context-Driven**: Parse and validate context-package.json for precise analysis
-- **Agent-Driven Tool Selection**: Agent autonomously selects Gemini/Codex based on task complexity
-- **Solution Design**: Evaluate architecture, identify key design decisions with rationale
-- **Feasibility Assessment**: Analyze technical complexity, risks, implementation readiness
-- **Optimization Recommendations**: Performance, security, and code quality improvements
-- **Output Validation**: Verify ANALYSIS_RESULTS.md generation and quality
-- **Single Output**: Generate only ANALYSIS_RESULTS.md with technical analysis
-
-## Analysis Strategy Selection
-
-**Agent-Driven Strategy**: cli-execution-agent autonomously determines tool selection based on:
-- **Task Complexity**: Number of modules, integration scope, technical depth
-- **Tech Stack**: Frontend (Gemini-focused), Backend (Codex-preferred), Fullstack (hybrid)
-- **Analysis Focus**: Architecture design (Gemini), Feasibility validation (Codex), Performance optimization (both)
-
-**Complexity Tiers** (Agent decides internally):
-- **Simple (≤3 modules)**: Gemini-only analysis
-- **Medium (4-6 modules)**: Gemini comprehensive analysis
-- **Complex (>6 modules)**: Gemini + Codex parallel execution
-
-## Execution Lifecycle
-
-### Phase 1: Validation & Preparation
-1. **Session Validation**: Verify `.workflow/{session_id}/` exists, load `workflow-session.json`
-2. **Context Package Validation**: Verify path, validate JSON format and structure
-3. **Task Analysis**: Extract keywords, identify domain/complexity, determine scope
-4. **Agent Preparation**: Prepare agent task prompt with complete analysis requirements
-
-### Phase 2: Agent-Delegated Analysis
-
-**Agent Invocation**:
-```javascript
-Task(
-  subagent_type="cli-execution-agent",
-  description="Enhanced solution design and feasibility analysis",
-  prompt=`
-## Execution Context
-
-**Session ID**: {session_id}
-**Mode**: Enhanced Analysis with CLI Tool Orchestration
-
-## Input Context
-
-**Context Package**: {context_path}
-**Session State**: .workflow/{session_id}/workflow-session.json
-**Project Standards**: CLAUDE.md
-
-## Analysis Task
-
-### Analysis Templates (Use these to guide CLI tool execution)
-- **Document Structure**: ~/.claude/workflows/cli-templates/prompts/workflow/analysis-results-structure.txt
-- **Gemini Analysis**: ~/.claude/workflows/cli-templates/prompts/workflow/gemini-solution-design.txt
-- **Codex Validation**: ~/.claude/workflows/cli-templates/prompts/workflow/codex-feasibility-validation.txt
-
-### Execution Strategy
-1. **Load Context**: Read context-package.json to determine task complexity (module count, integration scope)
-2. **Gemini Analysis** (ALL tasks): Execute using gemini-solution-design.txt template
-   - Output: .workflow/{session_id}/.process/gemini-solution-design.md
-3. **Codex Validation** (COMPLEX tasks >6 modules only): Execute using codex-feasibility-validation.txt template
-   - Output: .workflow/{session_id}/.process/codex-feasibility-validation.md
-4. **Synthesize Results**: Combine outputs into ANALYSIS_RESULTS.md following analysis-results-structure.txt
-
-### Output Requirements
-
-**Intermediate Outputs**:
-- Gemini: \`.workflow/{session_id}/.process/gemini-solution-design.md\` (always required)
-- Codex: \`.workflow/{session_id}/.process/codex-feasibility-validation.md\` (complex tasks only)
-
-**Final Output**:
-- \`.workflow/{session_id}/.process/ANALYSIS_RESULTS.md\` (synthesized, required)
-
-**Required Sections** (7 sections per analysis-results-structure.txt):
-1. Executive Summary
-2. Current State Analysis
-3. Proposed Solution Design
-4. Implementation Strategy
-5. Solution Optimization
-6. Critical Success Factors
-7. Reference Information
-
-### Synthesis Rules
-- Follow 7-section structure from analysis-results-structure.txt
-- Integrate Gemini insights as primary content
-- Incorporate Codex validation findings (if executed)
-- Resolve conflicts between tools with clear rationale
-- Generate confidence scores (1-5 scale) for all assessment dimensions
-- Provide final recommendation: PROCEED | PROCEED_WITH_MODIFICATIONS | RECONSIDER | REJECT
-
-## Output
-Generate final ANALYSIS_RESULTS.md and report completion status:
-- Gemini analysis: [completed/failed]
-- Codex validation: [completed/skipped/failed]
-- Synthesis: [completed/failed]
-- Final output: .workflow/{session_id}/.process/ANALYSIS_RESULTS.md
-`
-)
-```
-
-**Agent Execution Flow** (Internal to cli-execution-agent):
-1. Parse session ID and context path, load context-package.json
-2. Analyze task complexity (module count, integration scope)
-3. Discover additional context via MCP code-index
-4. Execute Gemini analysis (all tasks) with template-guided prompt
-5. Execute Codex validation (complex tasks >6 modules) with template-guided prompt
-6. Synthesize Gemini + Codex outputs into ANALYSIS_RESULTS.md
-7. Verify output file exists at correct path
-8. Return execution log path
-
-**Command Execution**: Launch agent via Task tool, wait for completion
-
-### Phase 3: Output Validation
-1. **File Verification**: Confirm `.workflow/{session_id}/.process/ANALYSIS_RESULTS.md` exists
-2. **Content Validation**: Verify required sections present (Executive Summary, Solution Design, etc.)
-3. **Quality Check**: Ensure design rationale, feasibility assessment, confidence scores included
-4. **Agent Log**: Retrieve agent execution log from `.workflow/{session_id}/.chat/`
-5. **Success Criteria**: File exists, contains all required sections, meets quality standards
-
-## Analysis Results Format
-
-**Template Reference**: `~/.claude/workflows/cli-templates/prompts/workflow/analysis-results-structure.txt`
-
-Generated ANALYSIS_RESULTS.md focuses on **solution improvements, key design decisions, and critical insights** (NOT task planning).
-
-### Required Structure (7 Sections)
-
-1. **Executive Summary**: Analysis focus, tools used, overall assessment (X/5), recommendation status
-2. **Current State Analysis**: Architecture overview, compatibility/dependencies, critical findings
-3. **Proposed Solution Design**: Core principles, system design, key decisions with rationale, technical specs
-4. **Implementation Strategy**: Development approach, code modification targets, feasibility assessment, risk mitigation
-5. **Solution Optimization**: Performance, security, code quality recommendations
-6. **Critical Success Factors**: Technical requirements, quality metrics, success validation
-7. **Reference Information**: Tool analysis summary, context & resources
-
-### Key Requirements
-
-**Code Modification Targets**:
-- Existing files: `file:function:lines` (e.g., `src/auth/login.ts:validateUser:45-52`)
-- New files: `file` only (e.g., `src/auth/PasswordReset.ts`)
-- Unknown lines: `file:function:*`
-
-**Key Design Decisions** (minimum 2):
-- Decision statement
-- Rationale (why this approach)
-- Alternatives considered (tradeoffs)
-- Impact (implications on architecture)
-
-**Assessment Scores** (1-5 scale):
-- Conceptual Integrity, Architectural Soundness, Technical Feasibility, Implementation Readiness
-- Overall Confidence score
-- Final Recommendation: PROCEED | PROCEED_WITH_MODIFICATIONS | RECONSIDER | REJECT
-
-### Content Focus
-- ✅ Solution improvements and architectural decisions
-- ✅ Design rationale, alternatives, and tradeoffs
-- ✅ Risk assessment with mitigation strategies
-- ✅ Optimization opportunities (performance, security, quality)
-- ❌ Task lists or implementation steps
-- ❌ Code examples or snippets
-- ❌ Project management timelines
-
-## Execution Management
-
-### Error Handling & Recovery
-1. **Pre-execution**: Verify session/context package exists and is valid
-2. **Agent Monitoring**: Track agent execution status via Task tool
-3. **Validation**: Check ANALYSIS_RESULTS.md generation on completion
-4. **Error Recovery**:
-   - Agent execution failure → report error, check agent logs
-   - Missing output file → retry agent execution once
-   - Incomplete output → use agent logs to diagnose issue
-5. **Graceful Degradation**: If agent fails, report specific error and suggest manual analysis
-
-### Agent Delegation Benefits
-- **Autonomous Tool Selection**: Agent decides Gemini/Codex based on complexity
-- **Context Discovery**: Agent discovers additional relevant files via MCP
-- **Prompt Enhancement**: Agent optimizes prompts with discovered patterns
-- **Error Handling**: Agent manages CLI tool failures internally
-- **Log Tracking**: Agent execution logs saved to `.workflow/{session_id}/.chat/`
-
-## Integration & Success Criteria
-
-### Input/Output Interface
-**Input**:
-- `--session` (required): Session ID (e.g., WFS-auth)
-- `--context` (required): Context package path
-
-**Output**:
-- Single file: `ANALYSIS_RESULTS.md` at `.workflow/{session_id}/.process/`
-- No supplementary files (JSON, roadmap, templates)
-
-### Quality & Success Validation
-**Quality Checks**: Completeness, consistency, feasibility validation
-
-**Success Criteria**:
-- ✅ Solution-focused analysis (design decisions, critical insights, NO task planning)
-- ✅ Single output file only (ANALYSIS_RESULTS.md)
-- ✅ Design decision depth with rationale/alternatives/tradeoffs
-- ✅ Feasibility assessment (complexity, risks, readiness)
-- ✅ Optimization strategies (performance, security, quality)
-- ✅ Agent-driven tool selection (autonomous Gemini/Codex execution)
-- ✅ Robust error handling (validation, retry, graceful degradation)
-- ✅ Confidence scoring with clear recommendation status
-- ✅ Agent execution log saved to session chat directory
-
-## Related Commands
-- `/context:gather` - Generate context packages required by this command
-- `/workflow:plan` - Call this command for analysis
-- `/task:create` - Create specific tasks based on analysis results

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

@@ -0,0 +1,602 @@
+---
+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"
+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
+---
+
+# Conflict Resolution Command
+
+## Purpose
+Analyzes conflicts between implementation plans and existing codebase, **including module scenario uniqueness detection**, generating multiple resolution strategies with **iterative clarification until boundaries are clear**.
+
+**Scope**: Detection and strategy generation only - NO code modification or task creation.
+
+**Trigger**: Auto-executes in `/workflow:plan` Phase 3 when `conflict_risk ≥ medium`.
+
+## Core Responsibilities
+
+| Responsibility | Description |
+|---------------|-------------|
+| **Detect Conflicts** | Analyze plan vs existing code inconsistencies |
+| **Scenario Uniqueness** | **NEW**: 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 |
+| **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 |
+| **Structured Data** | JSON output for programmatic processing, NO file generation |
+
+## Conflict Categories
+
+### 1. Architecture Conflicts
+- Incompatible design patterns
+- Module structure changes
+- Pattern migration requirements
+
+### 2. API Conflicts
+- Breaking contract changes
+- Signature modifications
+- Public interface impacts
+
+### 3. Data Model Conflicts
+- Schema modifications
+- Type breaking changes
+- Data migration needs
+
+### 4. Dependency Conflicts
+- Version incompatibilities
+- Setup conflicts
+- Breaking updates
+
+### 5. Module Scenario Overlap
+- **NEW**: Functional overlap between new and existing modules
+- Scenario boundary ambiguity
+- Duplicate responsibility detection
+- Module merge/split decisions
+- **Requires iterative clarification until uniqueness confirmed**
+
+## Execution Process
+
+```
+Input Parsing:
+   ├─ Parse flags: --session, --context
+   └─ Validation: Both REQUIRED, conflict_risk >= medium
+
+Phase 1: Validation
+   ├─ Step 1: Verify session directory exists
+   ├─ Step 2: Load context-package.json
+   ├─ Step 3: Check conflict_risk (skip if none/low)
+   └─ Step 4: Prepare agent task prompt
+
+Phase 2: CLI-Powered Analysis (Agent)
+   ├─ Execute Gemini analysis (Qwen fallback)
+   ├─ Detect conflicts including ModuleOverlap category
+   └─ Generate 2-4 strategies per conflict with modifications
+
+Phase 3: Iterative User Interaction
+   └─ FOR each conflict (one by one):
+      ├─ Display conflict with overlap_analysis (if ModuleOverlap)
+      ├─ Display strategies (2-4 + custom option)
+      ├─ User selects strategy
+      └─ IF clarification_needed:
+         ├─ Collect answers
+         ├─ Agent re-analysis
+         └─ Loop until uniqueness_confirmed (max 10 rounds)
+
+Phase 4: Apply Modifications
+   ├─ Step 1: Extract modifications from resolved strategies
+   ├─ Step 2: Apply using Edit tool
+   ├─ Step 3: Update context-package.json (mark resolved)
+   └─ Step 4: Output custom conflict summary (if any)
+```
+
+## Execution Flow
+
+### Phase 1: Validation
+```
+1. Verify session directory exists
+2. Load context-package.json
+3. Check conflict_risk (skip if none/low)
+4. Prepare agent task prompt
+```
+
+### Phase 2: CLI-Powered Analysis
+
+**Agent Delegation**:
+```javascript
+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
+  - **NEW**: Load exploration_results and use aggregated_insights for enhanced analysis
+  - Extract role analyses and requirements
+
+  ### 2. Execute CLI Analysis (Enhanced with Exploration + Scenario Uniqueness)
+
+  Primary (Gemini):
+  ccw cli -p "
+  PURPOSE: Detect conflicts between plan and codebase, using exploration insights
+  TASK:
+  • **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
+  • **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:
+    - Validation of exploration conflict_indicators
+    - ModuleOverlap conflicts with overlap_analysis
+    - Targeted clarification questions
+  RULES: $(cat ~/.claude/workflows/cli-templates/prompts/analysis/02-analyze-code-patterns.txt) | Focus on breaking changes, migration needs, and functional overlaps | Prioritize exploration-identified conflicts | analysis=READ-ONLY
+  " --tool gemini --mode analysis --cd {project_root}
+
+  Fallback: Qwen (same prompt) → Claude (manual analysis)
+
+  ### 3. Generate Strategies (2-4 per conflict)
+
+  Template per conflict:
+  - Severity: Critical/High/Medium
+  - Category: Architecture/API/Data/Dependency/ModuleOverlap
+  - Affected files + impact
+  - **For ModuleOverlap**: Include overlap_analysis with existing modules and scenarios
+  - Options with pros/cons, effort, risk
+  - **For ModuleOverlap strategies**: Add clarification_needed questions for boundary definition
+  - Recommended strategy + rationale
+
+  ### 4. Return Structured Conflict Data
+
+  ⚠️ Output to conflict-resolution.json (generated in Phase 4)
+
+  **Schema Reference**: Execute \`cat ~/.claude/workflows/cli-templates/schemas/conflict-resolution-schema.json\` to get full schema
+
+  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)
+  - 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
+`)
+```
+
+**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
+
+```javascript
+FOR each conflict:
+  round = 0, clarified = false, userClarifications = []
+
+  WHILE (!clarified && round++ < 10):
+    // 1. Display conflict info (text output for context)
+    displayConflictSummary(conflict)  // id, brief, severity, overlap_analysis if ModuleOverlap
+
+    // 2. Strategy selection via AskUserQuestion
+    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('; ')}` }
+        ]
+      }]
+    })
+
+    // 3. Handle selection
+    if (userChoice === "自定义修改") {
+      customConflicts.push({ id, brief, category, suggestions, overlap_analysis })
+      break
+    }
+
+    selectedStrategy = findStrategyByName(userChoice)
+
+    // 4. Clarification (if needed) - batched max 4 per call
+    if (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
+
+selectedStrategies = resolvedConflicts.map(r => ({
+  conflict_id: r.conflict.id, strategy: r.strategy, clarifications: r.strategy.clarifications || []
+}))
+```
+
+**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
+
+```javascript
+// 1. Extract modifications from resolved strategies
+const modifications = [];
+selectedStrategies.forEach(item => {
+  if (item.strategy && item.strategy.modifications) {
+    modifications.push(...item.strategy.modifications.map(mod => ({
+      ...mod,
+      conflict_id: item.conflict_id,
+      clarifications: item.clarifications
+    })));
+  }
+});
+
+console.log(`\n正在应用 ${modifications.length} 个修改...`);
+
+// 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,
+        old_string: mod.old_content,
+        new_string: mod.new_content
+      });
+    } else if (mod.change_type === "add") {
+      // Handle addition - append or insert based on section
+      const fileContent = Read(mod.file);
+      const updated = insertContentAfterSection(fileContent, mod.section, mod.new_content);
+      Write(mod.file, updated);
+    } else if (mod.change_type === "remove") {
+      Edit({
+        file_path: mod.file,
+        old_string: mod.old_content,
+        new_string: ""
+      });
+    }
+
+    appliedModifications.push(mod);
+    console.log(`  ✓ 成功`);
+  } catch (error) {
+    console.log(`  ✗ 失败: ${error.message}`);
+    failedModifications.push({ ...mod, error: error.message });
+  }
+});
+
+// 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.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));
+
+// 4. Output custom conflict summary with overlap analysis (if any)
+if (customConflicts.length > 0) {
+  console.log(`\n${'='.repeat(60)}`);
+  console.log(`需要自定义处理的冲突 (${customConflicts.length})`);
+  console.log(`${'='.repeat(60)}\n`);
+
+  customConflicts.forEach(conflict => {
+    console.log(`【${conflict.category}】${conflict.id}: ${conflict.brief}`);
+
+    // Show overlap analysis for ModuleOverlap conflicts
+    if (conflict.category === 'ModuleOverlap' && conflict.overlap_analysis) {
+      console.log(`\n场景重叠信息:`);
+      console.log(`  新模块: ${conflict.overlap_analysis.new_module.name}`);
+      console.log(`  场景: ${conflict.overlap_analysis.new_module.scenarios.join(', ')}`);
+      console.log(`\n  与以下模块重叠:`);
+      conflict.overlap_analysis.existing_modules.forEach(mod => {
+        console.log(`    - ${mod.name} (${mod.file})`);
+        console.log(`      重叠场景: ${mod.overlap_scenarios.join(', ')}`);
+      });
+    }
+
+    console.log(`\n修改建议:`);
+    conflict.suggestions.forEach(suggestion => {
+      console.log(`  - ${suggestion}`);
+    });
+    console.log();
+  });
+}
+
+// 5. Output failure summary (if any)
+if (failedModifications.length > 0) {
+  console.log(`\n⚠️ 部分修改失败 (${failedModifications.length}):`);
+  failedModifications.forEach(mod => {
+    console.log(`  - ${mod.file}: ${mod.error}`);
+  });
+}
+
+// 6. Return summary
+return {
+  total_conflicts: conflicts.length,
+  resolved_with_strategy: selectedStrategies.length,
+  custom_handling: customConflicts.length,
+  modifications_applied: appliedModifications.length,
+  modifications_failed: failedModifications.length,
+  modified_files: [...new Set(appliedModifications.map(m => m.file))],
+  custom_conflicts: customConflicts,
+  clarification_records: selectedStrategies.filter(s => s.clarifications.length > 0)
+};
+```
+
+**Validation**:
+```
+✓ Agent returns valid JSON structure with ModuleOverlap conflicts
+✓ Conflicts processed ONE BY ONE (not in batches)
+✓ ModuleOverlap conflicts include overlap_analysis field
+✓ Strategies with clarification_needed display questions
+✓ User selections captured correctly per conflict
+✓ Clarification loop continues until uniqueness confirmed
+✓ Agent re-analysis returns uniqueness_confirmed and updated_strategy
+✓ Maximum 10 rounds per conflict safety limit enforced
+✓ Edit tool successfully applies modifications
+✓ guidance-specification.md updated
+✓ Role analyses (*.md) updated
+✓ context-package.json marked as resolved with clarification records
+✓ Custom conflicts display overlap_analysis for manual handling
+✓ Agent log saved to .workflow/active/{session_id}/.chat/
+```
+
+## 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.
+
+**Structure**: Defined in Phase 2, Step 4 (agent prompt)
+
+### Key Requirements
+| Requirement | Details |
+|------------|---------|
+| **Conflict batching** | Max 10 conflicts per round (no total limit) |
+| **Strategy count** | 2-4 strategies per conflict |
+| **Modifications** | Each strategy includes file paths, old_content, new_content |
+| **User-facing text** | Chinese (brief, strategy names, pros/cons) |
+| **Technical fields** | English (severity, category, complexity, risk) |
+| **old_content precision** | 20-100 chars for unique Edit tool matching |
+| **File targets** | guidance-specification.md, role analyses (*.md) |
+
+## Error Handling
+
+### Recovery Strategy
+```
+1. Pre-check: Verify conflict_risk ≥ medium
+2. Monitor: Track agent via Task tool
+3. Validate: Parse agent JSON output
+4. Recover:
+   - Agent failure → check logs + report error
+   - Invalid JSON → retry once with Claude fallback
+   - CLI failure → fallback to Claude analysis
+   - Edit tool failure → report affected files + rollback option
+   - User cancels → mark as "unresolved", continue to task-generate
+5. Degrade: If all fail, generate minimal conflict report and skip modifications
+```
+
+### Rollback Handling
+```
+If Edit tool fails mid-application:
+1. Log all successfully applied modifications
+2. Output rollback option via text interaction
+3. If rollback selected: restore files from git or backups
+4. If continue: mark partial resolution in context-package.json
+```
+
+## Integration
+
+### Interface
+**Input**:
+- `--session` (required): WFS-{session-id}
+- `--context` (required): context-package.json path
+- Requires: `conflict_risk ≥ medium`
+
+**Output**:
+- 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, resolution_file reference)
+
+**User Interaction**:
+- **Iterative conflict processing**: One conflict at a time, not in batches
+- Each conflict: 2-4 strategy options + "自定义修改" option (with suggestions)
+- **Clarification loop**: Unlimited questions per conflict until uniqueness confirmed (max 10 rounds)
+- **ModuleOverlap conflicts**: Display overlap_analysis with existing modules
+- **Agent re-analysis**: Dynamic strategy updates based on user clarifications
+
+### Success Criteria
+```
+✓ CLI analysis returns valid JSON structure with ModuleOverlap category
+✓ Agent performs scenario uniqueness detection (searches existing modules)
+✓ Conflicts processed ONE BY ONE with iterative clarification
+✓ Min 2 strategies per conflict with modifications
+✓ ModuleOverlap conflicts include overlap_analysis with existing modules
+✓ Strategies requiring clarification include clarification_needed questions
+✓ Each conflict includes 2-5 modification_suggestions
+✓ Text output displays conflict with overlap analysis (if ModuleOverlap)
+✓ User selections captured per conflict
+✓ Clarification loop continues until uniqueness confirmed (unlimited rounds, max 10)
+✓ Agent re-analysis with user clarifications updates strategy
+✓ Uniqueness confirmation based on clear scenario boundaries
+✓ Edit tool applies modifications successfully
+✓ Custom conflicts displayed with overlap_analysis for manual handling
+✓ guidance-specification.md updated with resolved conflicts
+✓ Role analyses (*.md) updated with resolved conflicts
+✓ context-package.json marked as "resolved" with clarification records
+✓ conflict-resolution.json generated with full resolution details
+✓ Modification summary includes:
+  - Total conflicts
+  - Resolved with strategy (count)
+  - Custom handling (count)
+  - Clarification records
+  - Overlap analysis for custom ModuleOverlap conflicts
+✓ Agent log saved to .workflow/active/{session_id}/.chat/
+✓ Error handling robust (validate/retry/degrade)
+```
+

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

@@ -1,353 +1,441 @@
 ---
 name: gather
-description: Intelligently collect project context using general-purpose agent based on task description and package into standardized JSON
+description: Intelligently collect project context using context-search-agent based on task description, packages into standardized JSON
 argument-hint: "--session WFS-session-id \"task description\""
 examples:
   - /workflow:tools:context-gather --session WFS-user-auth "Implement user authentication system"
   - /workflow:tools:context-gather --session WFS-payment "Refactor payment module API"
   - /workflow:tools:context-gather --session WFS-bugfix "Fix login validation error"
+allowed-tools: Task(*), Read(*), Glob(*)
 ---
 
 # Context Gather Command (/workflow:tools:context-gather)
 
 ## Overview
-Agent-driven intelligent context collector that gathers relevant information from project codebase, documentation, and dependencies based on task descriptions, generating standardized context packages.
+
+Orchestrator command that invokes `context-search-agent` to gather comprehensive project context for implementation planning. Generates standardized `context-package.json` with codebase analysis, dependencies, and conflict detection.
+
 
 ## Core Philosophy
-- **Agent-Driven**: Delegate execution to general-purpose agent for autonomous operation
-- **Two-Phase Flow**: Discovery (context loading) → Execution (context gathering and packaging)
-- **Memory-First**: Reuse loaded documents from conversation memory
-- **MCP-Enhanced**: Use MCP tools for advanced code analysis and file discovery
-- **Intelligent Collection**: Auto-identify relevant resources based on keyword analysis
-- **Comprehensive Coverage**: Collect code, documentation, configurations, and dependencies
-- **Standardized Output**: Generate unified format context-package.json
 
-## Execution Lifecycle
+- **Agent Delegation**: Delegate all discovery to `context-search-agent` for autonomous execution
+- **Detection-First**: Check for existing context-package before executing
+- **Plan Mode**: Full comprehensive analysis (vs lightweight brainstorm mode)
+- **Standardized Output**: Generate `.workflow/active/{session}/.process/context-package.json`
 
-### Phase 1: Discovery & Context Loading
-**⚡ Memory-First Rule**: Skip file loading if documents already in conversation memory
+## Execution Process
+
+```
+Input Parsing:
+   ├─ Parse flags: --session
+   └─ Parse: task_description (required)
+
+Step 1: Context-Package Detection
+   └─ Decision (existing package):
+      ├─ Valid package exists → Return existing (skip execution)
+      └─ No valid package → Continue to Step 2
+
+Step 2: Complexity Assessment & Parallel Explore (NEW)
+   ├─ Analyze task_description → classify Low/Medium/High
+   ├─ Select exploration angles (1-4 based on complexity)
+   ├─ Launch N cli-explore-agents in parallel
+   │  └─ Each outputs: exploration-{angle}.json
+   └─ Generate explorations-manifest.json
+
+Step 3: Invoke Context-Search Agent (with exploration input)
+   ├─ Phase 1: Initialization & Pre-Analysis
+   ├─ Phase 2: Multi-Source Discovery
+   │  ├─ Track 0: Exploration Synthesis (prioritize & deduplicate)
+   │  ├─ Track 1-4: Existing tracks
+   └─ Phase 3: Synthesis & Packaging
+      └─ Generate context-package.json with exploration_results
+
+Step 4: Output Verification
+   └─ Verify context-package.json contains exploration_results
+```
+
+## Execution Flow
+
+### Step 1: Context-Package Detection
+
+**Execute First** - Check if valid package already exists:
 
-**Agent Context Package**:
 ```javascript
-{
-  "session_id": "WFS-[session-id]",
-  "task_description": "[user provided task description]",
-  "session_metadata": {
-    // If in memory: use cached content
-    // Else: Load from .workflow/{session-id}/workflow-session.json
-  },
-  "mcp_capabilities": {
-    // Agent will use these tools to discover project context
-    "code_index": true,
-    "exa_code": true,
-    "exa_web": true
+const contextPackagePath = `.workflow/${session_id}/.process/context-package.json`;
+
+if (file_exists(contextPackagePath)) {
+  const existing = Read(contextPackagePath);
+
+  // Validate package belongs to current session
+  if (existing?.metadata?.session_id === session_id) {
+    console.log("✅ Valid context-package found for session:", session_id);
+    console.log("📊 Stats:", existing.statistics);
+    console.log("⚠️  Conflict Risk:", existing.conflict_detection.risk_level);
+    return existing; // Skip execution, return existing
+  } else {
+    console.warn("⚠️ Invalid session_id in existing package, re-generating...");
   }
 }
-
-// Agent will autonomously execute:
-// - Project structure analysis: bash(~/.claude/scripts/get_modules_by_depth.sh)
-// - Documentation loading: Read(CLAUDE.md), Read(README.md)
 ```
 
-**Discovery Actions**:
-1. **Load Session Context** (if not in memory)
-   ```javascript
-   if (!memory.has("workflow-session.json")) {
-     Read(.workflow/{session-id}/workflow-session.json)
-   }
-   ```
+### Step 2: Complexity Assessment & Parallel Explore
 
-### Phase 2: Agent Execution (Context Gathering & Packaging)
+**Only execute if Step 1 finds no valid package**
 
-**Agent Invocation**:
 ```javascript
-Task(
-  subagent_type="general-purpose",
-  description="Gather project context and generate context package",
-  prompt=`
-## Execution Context
-
-**Session ID**: WFS-{session-id}
-**Task Description**: {task_description}
-**Mode**: Agent-Driven Context Gathering
-
-## Phase 1: Discovery Results (Provided Context)
-
-### Session Metadata
-{session_metadata_content}
-
-### MCP Capabilities
-- code-index: Available for file discovery and code search
-- exa-code: Available for external research
-- exa-web: Available for web search
-
-## Phase 2: Context Gathering Task
-
-### Core Responsibilities
-1. **Project Structure Analysis**: Execute get_modules_by_depth.sh for architecture overview
-2. **Documentation Loading**: Load CLAUDE.md, README.md and relevant documentation
-3. **Keyword Extraction**: Extract core keywords from task description
-4. **Smart File Discovery**: Use MCP code-index tools to locate relevant files
-5. **Code Structure Analysis**: Analyze project structure to identify relevant modules
-6. **Dependency Discovery**: Identify tech stack and dependency relationships
-7. **Context Packaging**: Generate standardized JSON context package
-
-### Execution Process
-
-#### Step 0: Foundation Setup (Execute First)
-1. **Project Structure Analysis**
-   Execute to get comprehensive architecture overview:
-   \`\`\`javascript
-   bash(~/.claude/scripts/get_modules_by_depth.sh)
-   \`\`\`
-
-2. **Load Project Documentation** (if not in memory)
-   Load core project documentation:
-   \`\`\`javascript
-   Read(CLAUDE.md)
-   Read(README.md)
-   // Load other relevant documentation based on session context
-   \`\`\`
-
-#### Step 1: Task Analysis
-1. **Keyword Extraction**
-   - Parse task description to extract core keywords
-   - Identify technical domain (auth, API, frontend, backend, etc.)
-   - Determine complexity level (simple, medium, complex)
-
-2. **Scope Determination**
-   - Define collection scope based on keywords
-   - Identify potentially involved modules and components
-   - Set file type filters
-
-#### Step 2: MCP-Enhanced File Discovery
-1. **Code File Location**
-   Use MCP code-index tools:
-   \`\`\`javascript
-   // Find files by pattern
-   mcp__code-index__find_files(pattern="*{keyword}*")
-
-   // Search code content
-   mcp__code-index__search_code_advanced(
-     pattern="{keyword_patterns}",
-     file_pattern="*.{ts,js,py,go,md}",
-     context_lines=3
-   )
-
-   // Get file summaries
-   mcp__code-index__get_file_summary(file_path="relevant/file.ts")
-   \`\`\`
-
-2. **Configuration Files Discovery**
-   Locate: package.json, requirements.txt, Cargo.toml, tsconfig.json, etc.
-
-3. **Test Files Location**
-   Find test files related to task keywords
-
-#### Step 3: Intelligent Filtering & Association
-1. **Relevance Scoring**
-   - Score based on keyword match degree
-   - Score based on file path relevance
-   - Score based on code content relevance
-
-2. **Dependency Analysis**
-   - Analyze import/require statements
-   - Identify inter-module dependencies
-   - Determine core and optional dependencies
-
-#### Step 4: Context Packaging
-Generate standardized context-package.json following the format below
-
-### Required Output
-
-**Output Location**: \`.workflow/{session-id}/.process/context-package.json\`
-
-**Output Format**:
-\`\`\`json
-{
-  "metadata": {
-    "task_description": "Implement user authentication system",
-    "timestamp": "2025-09-29T10:30:00Z",
-    "keywords": ["user", "authentication", "JWT", "login"],
-    "complexity": "medium",
-    "tech_stack": ["typescript", "node.js", "express"],
-    "session_id": "WFS-user-auth"
-  },
-  "assets": [
-    {
-      "type": "documentation",
-      "path": "CLAUDE.md",
-      "relevance": "Project development standards and conventions",
-      "priority": "high"
-    },
-    {
-      "type": "documentation",
-      "path": ".workflow/docs/architecture/security.md",
-      "relevance": "Security architecture design guidance",
-      "priority": "high"
-    },
-    {
-      "type": "source_code",
-      "path": "src/auth/AuthService.ts",
-      "relevance": "Existing authentication service implementation",
-      "priority": "high"
-    },
-    {
-      "type": "source_code",
-      "path": "src/models/User.ts",
-      "relevance": "User data model definition",
-      "priority": "medium"
-    },
-    {
-      "type": "config",
-      "path": "package.json",
-      "relevance": "Project dependencies and tech stack",
-      "priority": "medium"
-    },
-    {
-      "type": "test",
-      "path": "tests/auth/*.test.ts",
-      "relevance": "Authentication related test cases",
-      "priority": "medium"
-    }
-  ],
-  "tech_stack": {
-    "frameworks": ["express", "typescript"],
-    "libraries": ["jsonwebtoken", "bcrypt"],
-    "testing": ["jest", "supertest"]
-  },
-  "statistics": {
-    "total_files": 15,
-    "source_files": 8,
-    "docs_files": 4,
-    "config_files": 2,
-    "test_files": 1
-  }
-}
-\`\`\`
-
-### Quality Validation
-
-Before completion, verify:
-- [ ] context-package.json created in correct location
-- [ ] Valid JSON format with all required fields
-- [ ] Metadata includes task description, keywords, complexity
-- [ ] Assets array contains relevant files with priorities
-- [ ] Tech stack accurately identified
-- [ ] Statistics section provides file counts
-- [ ] File relevance accuracy >80%
-- [ ] No sensitive information exposed
-
-### Performance Optimization
-
-**Large Project Optimization**:
-- File count limit: Maximum 50 files per type
-- Size filtering: Skip oversized files (>10MB)
-- Depth limit: Maximum search depth of 3 levels
-- Use MCP tools for efficient discovery
-
-**MCP Tools Integration**:
-Agent should use MCP code-index tools when available:
-\`\`\`javascript
-// Set project path
-mcp__code-index__set_project_path(path="{current_project_path}")
-
-// Refresh index
-mcp__code-index__refresh_index()
-
-// Find files by pattern
-mcp__code-index__find_files(pattern="*{keyword}*")
-
-// Search code content
-mcp__code-index__search_code_advanced(
-  pattern="{keyword_patterns}",
-  file_pattern="*.{ts,js,py,go,md}",
-  context_lines=3
-)
-\`\`\`
-
-**Fallback Strategy**:
-When MCP tools unavailable, agent should use traditional commands:
-- \`find\` for file discovery
-- \`rg\` or \`grep\` for content search
-- Bash commands from project structure analysis
-
-## Output
-
-Generate context-package.json and report completion:
-- Task description: {description}
-- Keywords extracted: {count}
-- Files collected: {total}
-  - Source files: {count}
-  - Documentation: {count}
-  - Configuration: {count}
-  - Tests: {count}
-- Tech stack identified: {frameworks/libraries}
-- Output location: .workflow/{session-id}/.process/context-package.json
-\`
-)
-\`\`\`
-
-## Command Integration
-
-### Usage
-```bash
-# Basic usage
-/workflow:tools:context-gather --session WFS-auth "Implement JWT authentication"
-
-# Called by /workflow:plan
-SlashCommand(command="/workflow:tools:context-gather --session WFS-[id] \\"[task description]\\"")
-```
-
-### Agent Context Passing
-
-**Memory-Aware Context Assembly**:
-```javascript
-// Assemble minimal context package for agent
-// Agent will execute project structure analysis and documentation loading
-const agentContext = {
-  session_id: "WFS-[id]",
-  task_description: "[user provided task description]",
-
-  // Use memory if available, else load
-  session_metadata: memory.has("workflow-session.json")
-    ? memory.get("workflow-session.json")
-    : Read(.workflow/WFS-[id]/workflow-session.json),
-
-  // MCP capabilities - agent will use these tools
-  mcp_capabilities: {
-    code_index: true,
-    exa_code: true,
-    exa_web: true
-  }
+// 2.1 Complexity Assessment
+function analyzeTaskComplexity(taskDescription) {
+  const text = taskDescription.toLowerCase();
+  if (/architect|refactor|restructure|modular|cross-module/.test(text)) return 'High';
+  if (/multiple|several|integrate|migrate|extend/.test(text)) return 'Medium';
+  return 'Low';
 }
 
-// Note: Agent will execute these steps autonomously:
-// - bash(~/.claude/scripts/get_modules_by_depth.sh) for project structure
-// - Read(CLAUDE.md) and Read(README.md) for documentation
-```
+const ANGLE_PRESETS = {
+  architecture: ['architecture', 'dependencies', 'modularity', 'integration-points'],
+  security: ['security', 'auth-patterns', 'dataflow', 'validation'],
+  performance: ['performance', 'bottlenecks', 'caching', 'data-access'],
+  bugfix: ['error-handling', 'dataflow', 'state-management', 'edge-cases'],
+  feature: ['patterns', 'integration-points', 'testing', 'dependencies'],
+  refactor: ['architecture', 'patterns', 'dependencies', 'testing']
+};
 
-## Session ID Integration
+function selectAngles(taskDescription, complexity) {
+  const text = taskDescription.toLowerCase();
+  let preset = 'feature';
+  if (/refactor|architect|restructure/.test(text)) preset = 'architecture';
+  else if (/security|auth|permission/.test(text)) preset = 'security';
+  else if (/performance|slow|optimi/.test(text)) preset = 'performance';
+  else if (/fix|bug|error|issue/.test(text)) preset = 'bugfix';
 
-### Session ID Usage
-- **Required Parameter**: `--session WFS-session-id`
-- **Session Context Loading**: Load existing session state and metadata
-- **Session Continuity**: Maintain context across workflow pipeline phases
-
-### Session Validation
-```javascript
-// Validate session exists
-const sessionPath = `.workflow/${session_id}`;
-if (!fs.existsSync(sessionPath)) {
-  console.error(`❌ Session ${session_id} not found`);
-  process.exit(1);
+  const count = complexity === 'High' ? 4 : (complexity === 'Medium' ? 3 : 1);
+  return ANGLE_PRESETS[preset].slice(0, count);
 }
-```
+
+const complexity = analyzeTaskComplexity(task_description);
+const selectedAngles = selectAngles(task_description, complexity);
+const sessionFolder = `.workflow/active/${session_id}/.process`;
+
+// 2.2 Launch Parallel Explore Agents
+const explorationTasks = selectedAngles.map((angle, index) =>
+  Task(
+    subagent_type="cli-explore-agent",
+    run_in_background=false,
+    description=`Explore: ${angle}`,
+    prompt=`
+## Task Objective
+Execute **${angle}** exploration for task planning context. Analyze codebase from this specific angle to discover relevant structure, patterns, and constraints.
+
+## Assigned Context
+- **Exploration Angle**: ${angle}
+- **Task Description**: ${task_description}
+- **Session ID**: ${session_id}
+- **Exploration Index**: ${index + 1} of ${selectedAngles.length}
+- **Output File**: ${sessionFolder}/exploration-${angle}.json
+
+## MANDATORY FIRST STEPS (Execute by Agent)
+**You (cli-explore-agent) MUST execute these steps in order:**
+1. Run: ccw tool exec get_modules_by_depth '{}' (project structure)
+2. Run: rg -l "{keyword_from_task}" --type ts (locate relevant files)
+3. Execute: cat ~/.claude/workflows/cli-templates/schemas/explore-json-schema.json (get output schema reference)
+
+## Exploration Strategy (${angle} focus)
+
+**Step 1: Structural Scan** (Bash)
+- get_modules_by_depth.sh → identify modules related to ${angle}
+- find/rg → locate files relevant to ${angle} aspect
+- Analyze imports/dependencies from ${angle} perspective
+
+**Step 2: Semantic Analysis** (Gemini CLI)
+- How does existing code handle ${angle} concerns?
+- What patterns are used for ${angle}?
+- Where would new code integrate from ${angle} viewpoint?
+
+**Step 3: Write Output**
+- Consolidate ${angle} findings into JSON
+- Identify ${angle}-specific clarification needs
+
+## Expected Output
+
+**File**: ${sessionFolder}/exploration-${angle}.json
+
+**Schema Reference**: Schema obtained in MANDATORY FIRST STEPS step 3, follow schema exactly
+
+**Required Fields** (all ${angle} focused):
+- project_structure: Modules/architecture relevant to ${angle}
+- relevant_files: Files affected from ${angle} perspective
+  **IMPORTANT**: Use object format with relevance scores for synthesis:
+  \`[{path: "src/file.ts", relevance: 0.85, rationale: "Core ${angle} logic"}]\`
+  Scores: 0.7+ high priority, 0.5-0.7 medium, <0.5 low
+- patterns: ${angle}-related patterns to follow
+- dependencies: Dependencies relevant to ${angle}
+- integration_points: Where to integrate from ${angle} viewpoint (include file:line locations)
+- constraints: ${angle}-specific limitations/conventions
+- clarification_needs: ${angle}-related ambiguities (options array + recommended index)
+- _metadata.exploration_angle: "${angle}"
 
 ## Success Criteria
-- Valid context-package.json generated in correct location
-- Contains sufficient relevant information (>80% relevance)
-- Execution completes within reasonable time (<2 minutes)
-- All required fields present and properly formatted
-- Agent reports completion status with statistics
+- [ ] Schema obtained via cat explore-json-schema.json
+- [ ] get_modules_by_depth.sh executed
+- [ ] At least 3 relevant files identified with ${angle} rationale
+- [ ] Patterns are actionable (code examples, not generic advice)
+- [ ] Integration points include file:line locations
+- [ ] Constraints are project-specific to ${angle}
+- [ ] JSON output follows schema exactly
+- [ ] clarification_needs includes options + recommended
 
+## Output
+Write: ${sessionFolder}/exploration-${angle}.json
+Return: 2-3 sentence summary of ${angle} findings
+`
+  )
+);
+
+// 2.3 Generate Manifest after all complete
+const explorationFiles = bash(`find ${sessionFolder} -name "exploration-*.json" -type f`).split('\n').filter(f => f.trim());
+const explorationManifest = {
+  session_id,
+  task_description,
+  timestamp: new Date().toISOString(),
+  complexity,
+  exploration_count: selectedAngles.length,
+  angles_explored: selectedAngles,
+  explorations: explorationFiles.map(file => {
+    const data = JSON.parse(Read(file));
+    return { angle: data._metadata.exploration_angle, file: file.split('/').pop(), path: file, index: data._metadata.exploration_index };
+  })
+};
+Write(`${sessionFolder}/explorations-manifest.json`, JSON.stringify(explorationManifest, null, 2));
+```
+
+### Step 3: Invoke Context-Search Agent
+
+**Only execute after Step 2 completes**
+
+```javascript
+Task(
+  subagent_type="context-search-agent",
+  run_in_background=false,
+  description="Gather comprehensive context for plan",
+  prompt=`
+## Execution Mode
+**PLAN MODE** (Comprehensive) - Full Phase 1-3 execution
+
+## Session Information
+- **Session ID**: ${session_id}
+- **Task Description**: ${task_description}
+- **Output Path**: .workflow/${session_id}/.process/context-package.json
+
+## Exploration Input (from Step 2)
+- **Manifest**: ${sessionFolder}/explorations-manifest.json
+- **Exploration Count**: ${explorationManifest.exploration_count}
+- **Angles**: ${explorationManifest.angles_explored.join(', ')}
+- **Complexity**: ${complexity}
+
+## Mission
+Execute complete context-search-agent workflow for implementation planning:
+
+### Phase 1: Initialization & Pre-Analysis
+1. **Project State Loading**:
+   - Read and parse `.workflow/project-tech.json`. Use its `technology_analysis` section as the foundational `project_context`. This is your primary source for architecture, tech stack, and key components.
+   - Read and parse `.workflow/project-guidelines.json`. Load `conventions`, `constraints`, and `learnings` into a `project_guidelines` section.
+   - If files don't exist, proceed with fresh analysis.
+2. **Detection**: Check for existing context-package (early exit if valid)
+3. **Foundation**: Initialize CodexLens, get project structure, load docs
+4. **Analysis**: Extract keywords, determine scope, classify complexity based on task description and project state
+
+### Phase 2: Multi-Source Context Discovery
+Execute all discovery tracks:
+- **Track 0**: Exploration Synthesis (load ${sessionFolder}/explorations-manifest.json, prioritize critical_files, deduplicate patterns/integration_points)
+- **Track 1**: Historical archive analysis (query manifest.json for lessons learned)
+- **Track 2**: Reference documentation (CLAUDE.md, architecture docs)
+- **Track 3**: Web examples (use Exa MCP for unfamiliar tech/APIs)
+- **Track 4**: 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 4-source data**: Merge findings from all sources (archive > docs > code > web). **Prioritize the context from `project-tech.json`** for architecture and tech stack unless code analysis reveals it's outdated.
+3. **Populate `project_context`**: Directly use the `technology_analysis` from `project-tech.json` to fill the `project_context` section. Include description, technology_stack, architecture, and key_components.
+4. **Populate `project_guidelines`**: Load conventions, constraints, and learnings from `project-guidelines.json` into a dedicated section.
+5. Integrate brainstorm artifacts (if .brainstorming/ exists, read content)
+6. Perform conflict detection with risk assessment
+7. **Inject historical conflicts** from archive analysis into conflict_detection
+8. Generate and validate context-package.json
+
+## Output Requirements
+Complete context-package.json with:
+- **metadata**: task_description, keywords, complexity, tech_stack, session_id
+- **project_context**: description, technology_stack, architecture, key_components (sourced from `project-tech.json`)
+- **project_guidelines**: {conventions, constraints, quality_rules, learnings} (sourced from `project-guidelines.json`)
+- **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, historical_conflicts[]}
+- **exploration_results**: {manifest_path, exploration_count, angles, explorations[], aggregated_insights} (from Track 0)
+
+## 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.
+`
+)
+```
+
+### Step 4: Output Verification
+
+After agent completes, verify output:
+
+```javascript
+// Verify file was created
+const outputPath = `.workflow/${session_id}/.process/context-package.json`;
+if (!file_exists(outputPath)) {
+  throw new Error("❌ Agent failed to generate context-package.json");
+}
+
+// Verify exploration_results included
+const pkg = JSON.parse(Read(outputPath));
+if (pkg.exploration_results?.exploration_count > 0) {
+  console.log(`✅ Exploration results aggregated: ${pkg.exploration_results.exploration_count} angles`);
+}
+```
+
+## Parameter Reference
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `--session` | string | ✅ | Workflow session ID (e.g., WFS-user-auth) |
+| `task_description` | string | ✅ | Detailed task description for context extraction |
+
+## Output Schema
+
+Refer to `context-search-agent.md` Phase 3.7 for complete `context-package.json` schema.
+
+**Key Sections**:
+- **metadata**: Session info, keywords, complexity, tech stack
+- **project_context**: Architecture patterns, conventions, tech stack (populated from `project-tech.json`)
+- **project_guidelines**: Conventions, constraints, quality rules, learnings (populated from `project-guidelines.json`)
+- **assets**: Categorized files with relevance scores (documentation, source_code, config, tests)
+- **dependencies**: Internal and external dependency graphs
+- **brainstorm_artifacts**: Brainstorm documents with full content (if exists)
+- **conflict_detection**: Risk assessment with mitigation strategies and historical conflicts
+- **exploration_results**: Aggregated exploration insights (from parallel explore phase)
+
+## Historical Archive Analysis
+
+### Track 1: Query Archive Manifest
+
+The context-search-agent MUST perform historical archive analysis as Track 1 in Phase 2:
+
+**Step 1: Check for Archive Manifest**
+```bash
+# Check if archive manifest exists
+if [[ -f .workflow/archives/manifest.json ]]; then
+  # Manifest available for querying
+fi
+```
+
+**Step 2: Extract Task Keywords**
+```javascript
+// From current task description, extract key entities and operations
+const keywords = extractKeywords(task_description);
+// Examples: ["User", "model", "authentication", "JWT", "reporting"]
+```
+
+**Step 3: Search Archive for Relevant Sessions**
+```javascript
+// Query manifest for sessions with matching tags or descriptions
+const relevantArchives = archives.filter(archive => {
+  return archive.tags.some(tag => keywords.includes(tag)) ||
+         keywords.some(kw => archive.description.toLowerCase().includes(kw.toLowerCase()));
+});
+```
+
+**Step 4: Extract Watch Patterns**
+```javascript
+// For each relevant archive, check watch_patterns for applicability
+const historicalConflicts = [];
+
+relevantArchives.forEach(archive => {
+  archive.lessons.watch_patterns?.forEach(pattern => {
+    // Check if pattern trigger matches current task
+    if (isPatternRelevant(pattern.pattern, task_description)) {
+      historicalConflicts.push({
+        source_session: archive.session_id,
+        pattern: pattern.pattern,
+        action: pattern.action,
+        files_to_check: pattern.related_files,
+        archived_at: archive.archived_at
+      });
+    }
+  });
+});
+```
+
+**Step 5: Inject into Context Package**
+```json
+{
+  "conflict_detection": {
+    "risk_level": "medium",
+    "risk_factors": ["..."],
+    "affected_modules": ["..."],
+    "mitigation_strategy": "...",
+    "historical_conflicts": [
+      {
+        "source_session": "WFS-auth-feature",
+        "pattern": "When modifying User model",
+        "action": "Check reporting-service and auditing-service dependencies",
+        "files_to_check": ["src/models/User.ts", "src/services/reporting.ts"],
+        "archived_at": "2025-09-16T09:00:00Z"
+      }
+    ]
+  }
+}
+```
+
+### Risk Level Escalation
+
+If `historical_conflicts` array is not empty, minimum risk level should be "medium":
+
+```javascript
+if (historicalConflicts.length > 0 && currentRisk === "low") {
+  conflict_detection.risk_level = "medium";
+  conflict_detection.risk_factors.push(
+    `${historicalConflicts.length} historical conflict pattern(s) detected from past sessions`
+  );
+}
+```
+
+### Archive Query Algorithm
+
+```markdown
+1. IF .workflow/archives/manifest.json does NOT exist → Skip Track 1, continue to Track 2
+2. IF manifest exists:
+   a. Load manifest.json
+   b. Extract keywords from task_description (nouns, verbs, technical terms)
+   c. Filter archives where:
+      - ANY tag matches keywords (case-insensitive) OR
+      - description contains keywords (case-insensitive substring match)
+   d. For each relevant archive:
+      - Read lessons.watch_patterns array
+      - Check if pattern.pattern keywords overlap with task_description
+      - If relevant: Add to historical_conflicts array
+   e. IF historical_conflicts.length > 0:
+      - Set risk_level = max(current_risk, "medium")
+      - Add to risk_factors
+3. Continue to Track 2 (reference documentation)
+```
+
+## Notes
+
+- **Detection-first**: Always check for existing package before invoking agent
+- **Dual project file integration**: Agent reads both `.workflow/project-tech.json` (tech analysis) and `.workflow/project-guidelines.json` (user constraints) as primary sources
+- **Guidelines injection**: Project guidelines are included in context-package to ensure task generation respects user-defined constraints
+- **No redundancy**: This command is a thin orchestrator, all logic in agent
+- **Plan-specific**: Use this for implementation planning; brainstorm mode uses direct agent call

.claude/commands/workflow/tools/task-generate-agent.md

@@ -1,340 +1,563 @@
 ---
 name: task-generate-agent
-description: Autonomous task generation using action-planning-agent with discovery and output phases
-argument-hint: "--session WFS-session-id [--cli-execute]"
+description: Generate implementation plan documents (IMPL_PLAN.md, task JSONs, TODO_LIST.md) using action-planning-agent - produces planning artifacts, does NOT execute code implementation
+argument-hint: "--session WFS-session-id"
 examples:
   - /workflow:tools:task-generate-agent --session WFS-auth
-  - /workflow:tools:task-generate-agent --session WFS-auth --cli-execute
 ---
 
-# Autonomous Task Generation Command
+# Generate Implementation Plan Command
 
 ## Overview
-Autonomous task JSON and IMPL_PLAN.md generation using action-planning-agent with two-phase execution: discovery and document generation. Supports both agent-driven execution (default) and CLI tool execution modes.
+Generate implementation planning documents (IMPL_PLAN.md, task JSONs, TODO_LIST.md) using action-planning-agent. This command produces **planning artifacts only** - it does NOT execute code implementation. Actual code implementation requires separate execution command (e.g., /workflow:execute).
 
 ## Core Philosophy
-- **Agent-Driven**: Delegate execution to action-planning-agent for autonomous operation
-- **Two-Phase Flow**: Discovery (context gathering) → Output (document generation)
+- **Planning Only**: Generate planning documents (IMPL_PLAN.md, task JSONs, TODO_LIST.md) - does NOT implement code
+- **Agent-Driven Document Generation**: Delegate plan generation to action-planning-agent
+- **N+1 Parallel Planning**: Auto-detect multi-module projects, enable parallel planning (2+1 or 3+1 mode)
+- **Progressive Loading**: Load context incrementally (Core → Selective → On-Demand) due to analysis.md file size
 - **Memory-First**: Reuse loaded documents from conversation memory
+- **Smart Selection**: Load synthesis_output OR guidance + relevant role analyses, NOT all role analyses
 - **MCP-Enhanced**: Use MCP tools for advanced code analysis and research
-- **Pre-Selected Templates**: Command selects correct template based on `--cli-execute` flag **before** invoking agent
-- **Agent Simplicity**: Agent receives pre-selected template and focuses only on content generation
+- **Path Clarity**: All `focus_paths` prefer absolute paths (e.g., `D:\\project\\src\\module`), or clear relative paths from project root (e.g., `./src/module`)
 
-## Execution Lifecycle
+## Execution Process
 
-### Phase 1: Discovery & Context Loading
-**⚡ Memory-First Rule**: Skip file loading if documents already in conversation memory
+```
+Input Parsing:
+   ├─ Parse flags: --session
+   └─ Validation: session_id REQUIRED
 
-**Agent Context Package**:
+Phase 0: User Configuration (Interactive)
+   ├─ Question 1: Supplementary materials/guidelines?
+   ├─ Question 2: Execution method preference (Agent/CLI/Hybrid)
+   ├─ Question 3: CLI tool preference (if CLI selected)
+   └─ Store: userConfig for agent prompt
+
+Phase 1: Context Preparation & Module Detection (Command)
+   ├─ Assemble session paths (metadata, context package, output dirs)
+   ├─ Provide metadata (session_id, execution_mode, mcp_capabilities)
+   ├─ Auto-detect modules from context-package + directory structure
+   └─ Decision:
+      ├─ modules.length == 1 → Single Agent Mode (Phase 2A)
+      └─ modules.length >= 2 → Parallel Mode (Phase 2B + Phase 3)
+
+Phase 2A: Single Agent Planning (Original Flow)
+   ├─ Load context package (progressive loading strategy)
+   ├─ Generate Task JSON Files (.task/IMPL-*.json)
+   ├─ Create IMPL_PLAN.md
+   └─ Generate TODO_LIST.md
+
+Phase 2B: N Parallel Planning (Multi-Module)
+   ├─ Launch N action-planning-agents simultaneously (one per module)
+   ├─ Each agent generates module-scoped tasks (IMPL-{prefix}{seq}.json)
+   ├─ Task ID format: IMPL-A1, IMPL-A2... / IMPL-B1, IMPL-B2...
+   └─ Each module limited to ≤9 tasks
+
+Phase 3: Integration (+1 Coordinator, Multi-Module Only)
+   ├─ Collect all module task JSONs
+   ├─ Resolve cross-module dependencies (CROSS::{module}::{pattern} → actual ID)
+   ├─ Generate unified IMPL_PLAN.md (grouped by module)
+   └─ Generate TODO_LIST.md (hierarchical: module → tasks)
+```
+
+## Document Generation Lifecycle
+
+### Phase 0: User Configuration (Interactive)
+
+**Purpose**: Collect user preferences before task generation to ensure generated tasks match execution expectations.
+
+**User Questions**:
 ```javascript
-{
-  "session_id": "WFS-[session-id]",
-  "execution_mode": "agent-mode" | "cli-execute-mode",  // Determined by flag
-  "task_json_template_path": "~/.claude/workflows/cli-templates/prompts/workflow/task-json-agent-mode.txt"
-                           | "~/.claude/workflows/cli-templates/prompts/workflow/task-json-cli-mode.txt",
-  // Path selected by command based on --cli-execute flag, agent reads it
-  "session_metadata": {
-    // If in memory: use cached content
-    // Else: Load from .workflow/{session-id}/workflow-session.json
-  },
-  "analysis_results": {
-    // If in memory: use cached content
-    // Else: Load from .workflow/{session-id}/.process/ANALYSIS_RESULTS.md
-  },
-  "artifacts_inventory": {
-    // If in memory: use cached list
-    // Else: Scan .workflow/{session-id}/.brainstorming/ directory
-    "synthesis_specification": "path or null",
-    "topic_framework": "path or null",
-    "role_analyses": ["paths"]
-  },
-  "context_package": {
-    // If in memory: use cached content
-    // Else: Load from .workflow/{session-id}/.process/context-package.json
-  },
-  "mcp_capabilities": {
-    "code_index": true,
-    "exa_code": true,
-    "exa_web": true
-  }
+AskUserQuestion({
+  questions: [
+    {
+      question: "Do you have supplementary materials or guidelines to include?",
+      header: "Materials",
+      multiSelect: false,
+      options: [
+        { label: "No additional materials", description: "Use existing context only" },
+        { label: "Provide file paths", description: "I'll specify paths to include" },
+        { label: "Provide inline content", description: "I'll paste content directly" }
+      ]
+    },
+    {
+      question: "Select execution method for generated tasks:",
+      header: "Execution",
+      multiSelect: false,
+      options: [
+        { label: "Agent (Recommended)", description: "Claude agent executes tasks directly" },
+        { label: "Hybrid", description: "Agent orchestrates, calls CLI for complex steps" },
+        { label: "CLI Only", description: "All execution via CLI tools (codex/gemini/qwen)" }
+      ]
+    },
+    {
+      question: "If using CLI, which tool do you prefer?",
+      header: "CLI Tool",
+      multiSelect: false,
+      options: [
+        { label: "Codex (Recommended)", description: "Best for implementation tasks" },
+        { label: "Gemini", description: "Best for analysis and large context" },
+        { label: "Qwen", description: "Alternative analysis tool" },
+        { label: "Auto", description: "Let agent decide per-task" }
+      ]
+    }
+  ]
+})
+```
+
+**Handle Materials Response**:
+```javascript
+if (userConfig.materials === "Provide file paths") {
+  // Follow-up question for file paths
+  const pathsResponse = AskUserQuestion({
+    questions: [{
+      question: "Enter file paths to include (comma-separated or one per line):",
+      header: "Paths",
+      multiSelect: false,
+      options: [
+        { label: "Enter paths", description: "Provide paths in text input" }
+      ]
+    }]
+  })
+  userConfig.supplementaryPaths = parseUserPaths(pathsResponse)
 }
 ```
 
-**Discovery Actions**:
-1. **Load Session Context** (if not in memory)
-   ```javascript
-   if (!memory.has("workflow-session.json")) {
-     Read(.workflow/{session-id}/workflow-session.json)
-   }
-   ```
-
-2. **Load Analysis Results** (if not in memory)
-   ```javascript
-   if (!memory.has("ANALYSIS_RESULTS.md")) {
-     Read(.workflow/{session-id}/.process/ANALYSIS_RESULTS.md)
-   }
-   ```
-
-3. **Discover Artifacts** (if not in memory)
-   ```javascript
-   if (!memory.has("artifacts_inventory")) {
-     bash(find .workflow/{session-id}/.brainstorming/ -name "*.md" -type f)
-   }
-   ```
-
-4. **MCP Code Analysis** (optional - enhance understanding)
-   ```javascript
-   // Find relevant files for task context
-   mcp__code-index__find_files(pattern="*auth*")
-   mcp__code-index__search_code_advanced(
-     pattern="authentication|oauth",
-     file_pattern="*.ts"
-   )
-   ```
-
-5. **MCP External Research** (optional - gather best practices)
-   ```javascript
-   // Get external examples for implementation
-   mcp__exa__get_code_context_exa(
-     query="TypeScript JWT authentication best practices",
-     tokensNum="dynamic"
-   )
-   ```
-
-### Phase 2: Agent Execution (Document Generation)
-
-**Pre-Agent Template Selection** (Command decides path before invoking agent):
+**Build userConfig**:
 ```javascript
-// Command checks flag and selects template PATH (not content)
-const templatePath = hasCliExecuteFlag
-  ? "~/.claude/workflows/cli-templates/prompts/workflow/task-json-cli-mode.txt"
-  : "~/.claude/workflows/cli-templates/prompts/workflow/task-json-agent-mode.txt";
+const userConfig = {
+  supplementaryMaterials: {
+    type: "none|paths|inline",
+    content: [...],  // Parsed paths or inline content
+  },
+  executionMethod: "agent|hybrid|cli",
+  preferredCliTool: "codex|gemini|qwen|auto",
+  enableResume: true  // Always enable resume for CLI executions
+}
 ```
 
+**Pass to Agent**: Include `userConfig` in agent prompt for Phase 2A/2B.
+
+### Phase 1: Context Preparation & Module Detection (Command Responsibility)
+
+**Command prepares session paths, metadata, and detects module structure.**
+
+**Session Path Structure**:
+```
+.workflow/active/WFS-{session-id}/
+├── workflow-session.json          # Session metadata
+├── .process/
+│   └── context-package.json       # Context package with artifact catalog
+├── .task/                         # Output: Task JSON files
+│   ├── IMPL-A1.json               # Multi-module: prefixed by module
+│   ├── IMPL-A2.json
+│   ├── IMPL-B1.json
+│   └── ...
+├── IMPL_PLAN.md                   # Output: Implementation plan (grouped by module)
+└── TODO_LIST.md                   # Output: TODO list (hierarchical)
+```
+
+**Command Preparation**:
+1. **Assemble Session Paths** for agent prompt:
+   - `session_metadata_path`
+   - `context_package_path`
+   - Output directory paths
+
+2. **Provide Metadata** (simple values):
+   - `session_id`
+   - `mcp_capabilities` (available MCP tools)
+
+3. **Auto Module Detection** (determines single vs parallel mode):
+   ```javascript
+   function autoDetectModules(contextPackage, projectRoot) {
+     // === Complexity Gate: Only parallelize for High complexity ===
+     const complexity = contextPackage.metadata?.complexity || 'Medium';
+     if (complexity !== 'High') {
+       // Force single agent mode for Low/Medium complexity
+       // This maximizes agent context reuse for related tasks
+       return [{ name: 'main', prefix: '', paths: ['.'] }];
+     }
+
+     // Priority 1: Explicit frontend/backend separation
+     if (exists('src/frontend') && exists('src/backend')) {
+       return [
+         { name: 'frontend', prefix: 'A', paths: ['src/frontend'] },
+         { name: 'backend', prefix: 'B', paths: ['src/backend'] }
+       ];
+     }
+
+     // Priority 2: Monorepo structure
+     if (exists('packages/*') || exists('apps/*')) {
+       return detectMonorepoModules();  // Returns 2-3 main packages
+     }
+
+     // Priority 3: Context-package dependency clustering
+     const modules = clusterByDependencies(contextPackage.dependencies?.internal);
+     if (modules.length >= 2) return modules.slice(0, 3);
+
+     // Default: Single module (original flow)
+     return [{ name: 'main', prefix: '', paths: ['.'] }];
+   }
+   ```
+
+**Decision Logic**:
+- `complexity !== 'High'` → Force Phase 2A (Single Agent, maximize context reuse)
+- `modules.length == 1` → Phase 2A (Single Agent, original flow)
+- `modules.length >= 2 && complexity == 'High'` → Phase 2B + Phase 3 (N+1 Parallel)
+
+**Note**: CLI tool usage is now determined semantically by action-planning-agent based on user's task description, not by flags.
+
+### Phase 2A: Single Agent Planning (Original Flow)
+
+**Condition**: `modules.length == 1` (no multi-module detected)
+
+**Purpose**: Generate IMPL_PLAN.md, task JSONs, and TODO_LIST.md - planning documents only, NOT code implementation.
+
 **Agent Invocation**:
 ```javascript
 Task(
   subagent_type="action-planning-agent",
-  description="Generate task JSON and implementation plan",
+  run_in_background=false,
+  description="Generate planning documents (IMPL_PLAN.md, task JSONs, TODO_LIST.md)",
   prompt=`
-## Execution Context
+## TASK OBJECTIVE
+Generate implementation planning documents (IMPL_PLAN.md, task JSONs, TODO_LIST.md) for workflow session
 
-**Session ID**: WFS-{session-id}
-**Execution Mode**: {agent-mode | cli-execute-mode}
-**Task JSON Template Path**: {template_path}
+IMPORTANT: This is PLANNING ONLY - you are generating planning documents, NOT implementing code.
 
-## Phase 1: Discovery Results (Provided Context)
+CRITICAL: Follow the progressive loading strategy defined in agent specification (load analysis.md files incrementally due to file size)
 
-### Session Metadata
-{session_metadata_content}
+## SESSION PATHS
+Input:
+  - Session Metadata: .workflow/active/{session-id}/workflow-session.json
+  - Context Package: .workflow/active/{session-id}/.process/context-package.json
 
-### Analysis Results
-{analysis_results_content}
+Output:
+  - Task Dir: .workflow/active/{session-id}/.task/
+  - IMPL_PLAN: .workflow/active/{session-id}/IMPL_PLAN.md
+  - TODO_LIST: .workflow/active/{session-id}/TODO_LIST.md
 
-### Artifacts Inventory
-- **Synthesis Specification**: {synthesis_spec_path}
-- **Topic Framework**: {topic_framework_path}
-- **Role Analyses**: {role_analyses_list}
+## CONTEXT METADATA
+Session ID: {session-id}
+MCP Capabilities: {exa_code, exa_web, code_index}
 
-### Context Package
-{context_package_summary}
+## USER CONFIGURATION (from Phase 0)
+Execution Method: ${userConfig.executionMethod}  // agent|hybrid|cli
+Preferred CLI Tool: ${userConfig.preferredCliTool}  // codex|gemini|qwen|auto
+Supplementary Materials: ${userConfig.supplementaryMaterials}
 
-### MCP Analysis Results (Optional)
-**Code Structure**: {mcp_code_index_results}
-**External Research**: {mcp_exa_research_results}
+## CLI TOOL SELECTION
+Based on userConfig.executionMethod:
+- "agent": No command field in implementation_approach steps
+- "hybrid": Add command field to complex steps only (agent handles simple steps)
+- "cli": Add command field to ALL implementation_approach steps
 
-## Phase 2: Document Generation Task
+CLI Resume Support (MANDATORY for all CLI commands):
+- Use --resume parameter to continue from previous task execution
+- Read previous task's cliExecutionId from session state
+- Format: ccw cli -p "[prompt]" --resume ${previousCliId} --tool ${tool} --mode write
 
-### Task Decomposition Standards
-**Core Principle**: Task Merging Over Decomposition
-- **Merge Rule**: Execute together when possible
-- **Decompose Only When**:
-  - Excessive workload (>2500 lines or >6 files)
-  - Different tech stacks or domains
-  - Sequential dependency blocking
-  - Parallel execution needed
+## EXPLORATION CONTEXT (from context-package.exploration_results)
+- Load exploration_results from context-package.json
+- Use aggregated_insights.critical_files for focus_paths generation
+- Apply aggregated_insights.constraints to acceptance criteria
+- Reference aggregated_insights.all_patterns for implementation approach
+- Use aggregated_insights.all_integration_points for precise modification locations
+- Use conflict_indicators for risk-aware task sequencing
 
-**Task Limits**:
-- **Maximum 10 tasks** (hard limit)
-- **Function-based**: Complete units (logic + UI + tests + config)
-- **Hierarchy**: Flat (≤5) | Two-level (6-10) | Re-scope (>10)
+## CONFLICT RESOLUTION CONTEXT (if exists)
+- Check context-package.conflict_detection.resolution_file for conflict-resolution.json path
+- If exists, load .process/conflict-resolution.json:
+  - Apply planning_constraints as task constraints (for brainstorm-less workflows)
+  - Reference resolved_conflicts for implementation approach alignment
+  - Handle custom_conflicts with explicit task notes
 
-### Required Outputs
+## EXPECTED DELIVERABLES
+1. Task JSON Files (.task/IMPL-*.json)
+   - 6-field schema (id, title, status, context_package_path, meta, context, flow_control)
+   - Quantified requirements with explicit counts
+   - Artifacts integration from context package
+   - **focus_paths enhanced with exploration critical_files**
+   - Flow control with pre_analysis steps (include exploration integration_points analysis)
+   - **CLI Execution IDs and strategies (MANDATORY)**
 
-#### 1. Task JSON Files (.task/IMPL-*.json)
-**Location**: .workflow/{session-id}/.task/
-**Template**: Read from the template path provided above
+2. Implementation Plan (IMPL_PLAN.md)
+   - Context analysis and artifact references
+   - Task breakdown and execution strategy
+   - Complete structure per agent definition
 
-**Task JSON Template Loading**:
-\`\`\`
-Read({template_path})
-\`\`\`
+3. TODO List (TODO_LIST.md)
+   - Hierarchical structure (containers, pending, completed markers)
+   - Links to task JSONs and summaries
+   - Matches task JSON hierarchy
 
-**Important**:
-- Read the template from the path provided in context
-- Use the template structure exactly as written
-- Replace placeholder variables ({synthesis_spec_path}, {role_analysis_path}, etc.) with actual session-specific paths
-- Include MCP tool integration in pre_analysis steps
-- Map artifacts based on task domain (UI → ui-designer, Backend → system-architect)
+## CLI EXECUTION ID REQUIREMENTS (MANDATORY)
+Each task JSON MUST include:
+- **cli_execution_id**: Unique ID for CLI execution (format: `{session_id}-{task_id}`)
+- **cli_execution**: Strategy object based on depends_on:
+  - No deps → `{ "strategy": "new" }`
+  - 1 dep (single child) → `{ "strategy": "resume", "resume_from": "parent-cli-id" }`
+  - 1 dep (multiple children) → `{ "strategy": "fork", "resume_from": "parent-cli-id" }`
+  - N deps → `{ "strategy": "merge_fork", "merge_from": ["id1", "id2", ...] }`
 
-#### 2. IMPL_PLAN.md
-**Location**: .workflow/{session-id}/IMPL_PLAN.md
+**CLI Execution Strategy Rules**:
+1. **new**: Task has no dependencies - starts fresh CLI conversation
+2. **resume**: Task has 1 parent AND that parent has only this child - continues same conversation
+3. **fork**: Task has 1 parent BUT parent has multiple children - creates new branch with parent context
+4. **merge_fork**: Task has multiple parents - merges all parent contexts into new conversation
 
-**IMPL_PLAN Template**:
-\`\`\`
-$(cat ~/.claude/workflows/cli-templates/prompts/workflow/impl-plan-template.txt)
-\`\`\`
+**Execution Command Patterns**:
+- new: `ccw cli -p "[prompt]" --tool [tool] --mode write --id [cli_execution_id]`
+- resume: `ccw cli -p "[prompt]" --resume [resume_from] --tool [tool] --mode write`
+- fork: `ccw cli -p "[prompt]" --resume [resume_from] --id [cli_execution_id] --tool [tool] --mode write`
+- merge_fork: `ccw cli -p "[prompt]" --resume [merge_from.join(',')] --id [cli_execution_id] --tool [tool] --mode write`
 
-**Important**:
-- Use the template above for IMPL_PLAN.md generation
-- Replace all {placeholder} variables with actual session-specific values
-- Populate CCW Workflow Context based on actual phase progression
-- Extract content from ANALYSIS_RESULTS.md and context-package.json
-- List all detected brainstorming artifacts with correct paths
+## QUALITY STANDARDS
+Hard Constraints:
+  - Task count <= 18 (hard limit - request re-scope if exceeded)
+  - All requirements quantified (explicit counts and enumerated lists)
+  - Acceptance criteria measurable (include verification commands)
+  - Artifact references mapped from context package
+  - All documents follow agent-defined structure
 
-#### 3. TODO_LIST.md
-**Location**: .workflow/{session-id}/TODO_LIST.md
-**Structure**:
-\`\`\`markdown
-# Tasks: {Session Topic}
-
-## Task Progress
-▸ **IMPL-001**: [Main Task Group] → [📋](./.task/IMPL-001.json)
-  - [ ] **IMPL-001.1**: [Subtask] → [📋](./.task/IMPL-001.1.json)
-  - [ ] **IMPL-001.2**: [Subtask] → [📋](./.task/IMPL-001.2.json)
-
-- [ ] **IMPL-002**: [Simple Task] → [📋](./.task/IMPL-002.json)
-
-## Status Legend
-- \`▸\` = Container task (has subtasks)
-- \`- [ ]\` = Pending leaf task
-- \`- [x]\` = Completed leaf task
-\`\`\`
-
-### Execution Instructions for Agent
-
-**Agent Task**: Generate task JSON files, IMPL_PLAN.md, and TODO_LIST.md based on analysis results
-
-**Note**: The correct task JSON template path has been pre-selected by the command based on the `--cli-execute` flag and is provided in the context as `{template_path}`.
-
-**Step 1: Load Task JSON Template**
-- Read template from the provided path: `Read({template_path})`
-- This template is already the correct one based on execution mode
-
-**Step 2: Extract and Decompose Tasks**
-- Parse ANALYSIS_RESULTS.md for task recommendations
-- Apply task merging rules (merge when possible, decompose only when necessary)
-- Map artifacts to tasks based on domain (UI/Backend/Data)
-- Ensure task count ≤10
-
-**Step 3: Generate Task JSON Files**
-- Use the template structure from Step 1
-- Create .task/IMPL-*.json files with proper structure
-- Replace all {placeholder} variables with actual session paths
-- Embed artifacts array with brainstorming outputs
-- Include MCP tool integration in pre_analysis steps
-
-**Step 4: Create IMPL_PLAN.md**
-- Use IMPL_PLAN template
-- Populate all sections with session-specific content
-- List artifacts with priorities and usage guidelines
-- Document execution strategy and dependencies
-
-**Step 5: Generate TODO_LIST.md**
-- Create task progress checklist matching generated JSONs
-- Use proper status indicators (▸, [ ], [x])
-- Link to task JSON files
-
-**Step 6: Update Session State**
-- Update workflow-session.json with task count and artifact inventory
-- Mark session ready for execution
-
-### MCP Enhancement Examples
-
-**Code Index Usage**:
-\`\`\`javascript
-// Discover authentication-related files
-mcp__code-index__find_files(pattern="*auth*")
-
-// Search for OAuth patterns
-mcp__code-index__search_code_advanced(
-  pattern="oauth|jwt|authentication",
-  file_pattern="*.{ts,js}"
-)
-
-// Get file summary for key components
-mcp__code-index__get_file_summary(
-  file_path="src/auth/index.ts"
-)
-\`\`\`
-
-**Exa Research Usage**:
-\`\`\`javascript
-// Get best practices for task implementation
-mcp__exa__get_code_context_exa(
-  query="TypeScript OAuth2 implementation patterns",
-  tokensNum="dynamic"
-)
-
-// Research specific API usage
-mcp__exa__get_code_context_exa(
-  query="Express.js JWT middleware examples",
-  tokensNum=5000
-)
-\`\`\`
-
-### Quality Validation
-
-Before completion, verify:
-- [ ] All task JSON files created in .task/ directory
-- [ ] Each task JSON has 5 required fields
-- [ ] Artifact references correctly mapped
-- [ ] Flow control includes artifact loading steps
-- [ ] MCP tool integration added where appropriate
-- [ ] IMPL_PLAN.md follows required structure
-- [ ] TODO_LIST.md matches task JSONs
-- [ ] Dependency graph is acyclic
-- [ ] Task count within limits (≤10)
-- [ ] Session state updated
-
-## Output
-
-Generate all three documents and report completion status:
-- Task JSON files created: N files
-- Artifacts integrated: synthesis-spec, topic-framework, N role analyses
-- MCP enhancements: code-index, exa-research
-- Session ready for execution: /workflow:execute
+## SUCCESS CRITERIA
+- All planning documents generated successfully:
+  - Task JSONs valid and saved to .task/ directory
+  - IMPL_PLAN.md created with complete structure
+  - TODO_LIST.md generated matching task JSONs
+- Return completion status with document count and task breakdown summary
 `
 )
 ```
 
+### Phase 2B: N Parallel Planning (Multi-Module)
 
-### Agent Context Passing
+**Condition**: `modules.length >= 2` (multi-module detected)
 
-**Memory-Aware Context Assembly**:
+**Purpose**: Launch N action-planning-agents simultaneously, one per module, for parallel task JSON generation.
+
+**Note**: Phase 2B agents generate Task JSONs ONLY. IMPL_PLAN.md and TODO_LIST.md are generated by Phase 3 Coordinator.
+
+**Parallel Agent Invocation**:
 ```javascript
-// Assemble context package for agent
-const agentContext = {
-  session_id: "WFS-[id]",
+// Launch N agents in parallel (one per module)
+const planningTasks = modules.map(module =>
+  Task(
+    subagent_type="action-planning-agent",
+    run_in_background=false,
+    description=`Generate ${module.name} module task JSONs`,
+    prompt=`
+## TASK OBJECTIVE
+Generate task JSON files for ${module.name} module within workflow session
 
-  // Use memory if available, else load
-  session_metadata: memory.has("workflow-session.json")
-    ? memory.get("workflow-session.json")
-    : Read(.workflow/WFS-[id]/workflow-session.json),
+IMPORTANT: This is PLANNING ONLY - generate task JSONs, NOT implementing code.
+IMPORTANT: Generate Task JSONs ONLY. IMPL_PLAN.md and TODO_LIST.md by Phase 3 Coordinator.
 
-  analysis_results: memory.has("ANALYSIS_RESULTS.md")
-    ? memory.get("ANALYSIS_RESULTS.md")
-    : Read(.workflow/WFS-[id]/.process/ANALYSIS_RESULTS.md),
+CRITICAL: Follow the progressive loading strategy defined in agent specification (load analysis.md files incrementally due to file size)
 
-  artifacts_inventory: memory.has("artifacts_inventory")
-    ? memory.get("artifacts_inventory")
-    : discoverArtifacts(),
+## MODULE SCOPE
+- Module: ${module.name} (${module.type})
+- Focus Paths: ${module.paths.join(', ')}
+- Task ID Prefix: IMPL-${module.prefix}
+- Task Limit: ≤9 tasks (hard limit for this module)
+- Other Modules: ${otherModules.join(', ')} (reference only, do NOT generate tasks for them)
 
-  context_package: memory.has("context-package.json")
-    ? memory.get("context-package.json")
-    : Read(.workflow/WFS-[id]/.process/context-package.json),
+## SESSION PATHS
+Input:
+  - Session Metadata: .workflow/active/{session-id}/workflow-session.json
+  - Context Package: .workflow/active/{session-id}/.process/context-package.json
 
-  // Optional MCP enhancements
-  mcp_analysis: executeMcpDiscovery()
+Output:
+  - Task Dir: .workflow/active/{session-id}/.task/
+
+## CONTEXT METADATA
+Session ID: {session-id}
+MCP Capabilities: {exa_code, exa_web, code_index}
+
+## USER CONFIGURATION (from Phase 0)
+Execution Method: ${userConfig.executionMethod}  // agent|hybrid|cli
+Preferred CLI Tool: ${userConfig.preferredCliTool}  // codex|gemini|qwen|auto
+Supplementary Materials: ${userConfig.supplementaryMaterials}
+
+## CLI TOOL SELECTION
+Based on userConfig.executionMethod:
+- "agent": No command field in implementation_approach steps
+- "hybrid": Add command field to complex steps only (agent handles simple steps)
+- "cli": Add command field to ALL implementation_approach steps
+
+CLI Resume Support (MANDATORY for all CLI commands):
+- Use --resume parameter to continue from previous task execution
+- Read previous task's cliExecutionId from session state
+- Format: ccw cli -p "[prompt]" --resume ${previousCliId} --tool ${tool} --mode write
+
+## EXPLORATION CONTEXT (from context-package.exploration_results)
+- Load exploration_results from context-package.json
+- Filter for ${module.name} module: Use aggregated_insights.critical_files matching ${module.paths.join(', ')}
+- Apply module-relevant constraints from aggregated_insights.constraints
+- Reference aggregated_insights.all_patterns applicable to ${module.name}
+- Use aggregated_insights.all_integration_points for precise modification locations within module scope
+- Use conflict_indicators for risk-aware task sequencing
+
+## CONFLICT RESOLUTION CONTEXT (if exists)
+- Check context-package.conflict_detection.resolution_file for conflict-resolution.json path
+- If exists, load .process/conflict-resolution.json:
+  - Apply planning_constraints relevant to ${module.name} as task constraints
+  - Reference resolved_conflicts affecting ${module.name} for implementation approach alignment
+  - Handle custom_conflicts with explicit task notes
+
+## CROSS-MODULE DEPENDENCIES
+- For dependencies ON other modules: Use placeholder depends_on: ["CROSS::{module}::{pattern}"]
+- Example: depends_on: ["CROSS::B::api-endpoint"] (this module depends on B's api-endpoint task)
+- Phase 3 Coordinator resolves to actual task IDs
+- For dependencies FROM other modules: Document in task context as "provides_for" annotation
+
+## EXPECTED DELIVERABLES
+Task JSON Files (.task/IMPL-${module.prefix}*.json):
+  - 6-field schema (id, title, status, context_package_path, meta, context, flow_control)
+  - Task ID format: IMPL-${module.prefix}1, IMPL-${module.prefix}2, ...
+  - Quantified requirements with explicit counts
+  - Artifacts integration from context package (filtered for ${module.name})
+  - **focus_paths enhanced with exploration critical_files (module-scoped)**
+  - Flow control with pre_analysis steps (include exploration integration_points analysis)
+  - **CLI Execution IDs and strategies (MANDATORY)**
+  - Focus ONLY on ${module.name} module scope
+
+## CLI EXECUTION ID REQUIREMENTS (MANDATORY)
+Each task JSON MUST include:
+- **cli_execution_id**: Unique ID for CLI execution (format: `{session_id}-IMPL-${module.prefix}{seq}`)
+- **cli_execution**: Strategy object based on depends_on:
+  - No deps → `{ "strategy": "new" }`
+  - 1 dep (single child) → `{ "strategy": "resume", "resume_from": "parent-cli-id" }`
+  - 1 dep (multiple children) → `{ "strategy": "fork", "resume_from": "parent-cli-id" }`
+  - N deps → `{ "strategy": "merge_fork", "merge_from": ["id1", "id2", ...] }`
+  - Cross-module dep → `{ "strategy": "cross_module_fork", "resume_from": "CROSS::{module}::{pattern}" }`
+
+**CLI Execution Strategy Rules**:
+1. **new**: Task has no dependencies - starts fresh CLI conversation
+2. **resume**: Task has 1 parent AND that parent has only this child - continues same conversation
+3. **fork**: Task has 1 parent BUT parent has multiple children - creates new branch with parent context
+4. **merge_fork**: Task has multiple parents - merges all parent contexts into new conversation
+5. **cross_module_fork**: Task depends on task from another module - Phase 3 resolves placeholder
+
+**Execution Command Patterns**:
+- new: `ccw cli -p "[prompt]" --tool [tool] --mode write --id [cli_execution_id]`
+- resume: `ccw cli -p "[prompt]" --resume [resume_from] --tool [tool] --mode write`
+- fork: `ccw cli -p "[prompt]" --resume [resume_from] --id [cli_execution_id] --tool [tool] --mode write`
+- merge_fork: `ccw cli -p "[prompt]" --resume [merge_from.join(',')] --id [cli_execution_id] --tool [tool] --mode write`
+- cross_module_fork: (Phase 3 resolves placeholder, then uses fork pattern)
+
+## QUALITY STANDARDS
+Hard Constraints:
+  - Task count <= 9 for this module (hard limit - coordinate with Phase 3 if exceeded)
+  - All requirements quantified (explicit counts and enumerated lists)
+  - Acceptance criteria measurable (include verification commands)
+  - Artifact references mapped from context package (module-scoped filter)
+  - Focus paths use absolute paths or clear relative paths from project root
+  - Cross-module dependencies use CROSS:: placeholder format
+
+## SUCCESS CRITERIA
+- Task JSONs saved to .task/ with IMPL-${module.prefix}* naming
+- All task JSONs include cli_execution_id and cli_execution strategy
+- Cross-module dependencies use CROSS:: placeholder format consistently
+- Focus paths scoped to ${module.paths.join(', ')} only
+- Return: task count, task IDs, dependency summary (internal + cross-module)
+    `
+  )
+);
+
+// Execute all in parallel
+await Promise.all(planningTasks);
+```
+
+**Output Structure** (direct to .task/):
+```
+.task/
+├── IMPL-A1.json      # Module A (e.g., frontend)
+├── IMPL-A2.json
+├── IMPL-B1.json      # Module B (e.g., backend)
+├── IMPL-B2.json
+└── IMPL-C1.json      # Module C (e.g., shared)
+```
+
+**Task ID Naming**:
+- Format: `IMPL-{prefix}{seq}.json`
+- Prefix: A, B, C... (assigned by detection order)
+- Sequence: 1, 2, 3... (per-module increment)
+
+### Phase 3: Integration (+1 Coordinator Agent, Multi-Module Only)
+
+**Condition**: Only executed when `modules.length >= 2`
+
+**Purpose**: Collect all module tasks, resolve cross-module dependencies, generate unified IMPL_PLAN.md and TODO_LIST.md documents.
+
+**Coordinator Agent Invocation**:
+```javascript
+// Wait for all Phase 2B agents to complete
+const moduleResults = await Promise.all(planningTasks);
+
+// Launch +1 Coordinator Agent
+Task(
+  subagent_type="action-planning-agent",
+  run_in_background=false,
+  description="Integrate module tasks and generate unified documents",
+  prompt=`
+## TASK OBJECTIVE
+Integrate all module task JSONs, resolve cross-module dependencies, and generate unified IMPL_PLAN.md and TODO_LIST.md
+
+IMPORTANT: This is INTEGRATION ONLY - consolidate existing task JSONs, NOT creating new tasks.
+
+## SESSION PATHS
+Input:
+  - Session Metadata: .workflow/active/{session-id}/workflow-session.json
+  - Context Package: .workflow/active/{session-id}/.process/context-package.json
+  - Task JSONs: .workflow/active/{session-id}/.task/IMPL-*.json (from Phase 2B)
+Output:
+  - Updated Task JSONs: .workflow/active/{session-id}/.task/IMPL-*.json (resolved dependencies)
+  - IMPL_PLAN: .workflow/active/{session-id}/IMPL_PLAN.md
+  - TODO_LIST: .workflow/active/{session-id}/TODO_LIST.md
+
+## CONTEXT METADATA
+Session ID: {session-id}
+Modules: ${modules.map(m => m.name + '(' + m.prefix + ')').join(', ')}
+Module Count: ${modules.length}
+
+## INTEGRATION STEPS
+1. Collect all .task/IMPL-*.json, group by module prefix
+2. Resolve CROSS:: dependencies → actual task IDs, update task JSONs
+3. Generate IMPL_PLAN.md (multi-module format per agent specification)
+4. Generate TODO_LIST.md (hierarchical format per agent specification)
+
+## CROSS-MODULE DEPENDENCY RESOLUTION
+- Pattern: CROSS::{module}::{pattern} → IMPL-{module}* matching title/context
+- Example: CROSS::B::api-endpoint → IMPL-B1 (if B1 title contains "api-endpoint")
+- Log unresolved as warnings
+
+## EXPECTED DELIVERABLES
+1. Updated Task JSONs with resolved dependency IDs
+2. IMPL_PLAN.md - multi-module format with cross-dependency section
+3. TODO_LIST.md - hierarchical by module with cross-dependency section
+
+## SUCCESS CRITERIA
+- No CROSS:: placeholders remaining in task JSONs
+- IMPL_PLAN.md and TODO_LIST.md generated with multi-module structure
+- Return: task count, per-module breakdown, resolved dependency count
+  `
+)
+```
+
+**Dependency Resolution Algorithm**:
+```javascript
+function resolveCrossModuleDependency(placeholder, allTasks) {
+  const [, targetModule, pattern] = placeholder.match(/CROSS::(\w+)::(.+)/);
+  const candidates = allTasks.filter(t =>
+    t.id.startsWith(`IMPL-${targetModule}`) &&
+    (t.title.toLowerCase().includes(pattern.toLowerCase()) ||
+     t.context?.description?.toLowerCase().includes(pattern.toLowerCase()))
+  );
+  return candidates.length > 0
+    ? candidates.sort((a, b) => a.id.localeCompare(b.id))[0].id
+    : placeholder; // Keep for manual resolution
 }
 ```
+