refactor: Add tree-style execution flow diagrams to all workflow commands

Added tree-style execution process diagrams using ASCII art (├─, └─, │) to 34 workflow command files across three directories for improved readability and execution flow clarity.

## Changes by Directory

### workflow/ root (17 files)
- lite-plan.md, lite-execute.md, lite-fix.md
- plan.md, execute.md, replan.md
- status.md, review.md, review-fix.md
- review-session-cycle.md, review-module-cycle.md
- session commands (start, complete, resume, list)
- tdd-plan.md, tdd-verify.md, test-cycle-execute.md, test-gen.md, test-fix-gen.md

### workflow/ui-design/ (10 files)
- layout-extract.md, animation-extract.md, style-extract.md
- generate.md, import-from-code.md, codify-style.md
- imitate-auto.md, explore-auto.md
- reference-page-generator.md, design-sync.md

### workflow/tools/ (8 files)
- conflict-resolution.md, task-generate-agent.md, context-gather.md
- tdd-coverage-analysis.md, task-generate-tdd.md
- test-task-generate.md, test-concept-enhanced.md, test-context-gather.md

## Diagram Features
- Input parsing with flag enumeration
- Decision branching with conditional paths
- Phase/step hierarchy with clear nesting
- Mode detection and validation flows

🤖 Generated with [Claude Code](https://claude.com/claude-code)

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

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

@@ -1,620 +1,182 @@
 ---
 name: cli-explore-agent
 description: |
-  Read-only code exploration and structural analysis agent specialized in module discovery, dependency mapping, and architecture comprehension using dual-source strategy (Bash rapid scan + Gemini CLI semantic analysis).
-
-  Core capabilities:
-  - Multi-layer module structure analysis (directory tree, file patterns, symbol discovery)
-  - Dependency graph construction (imports, exports, call chains, circular detection)
-  - Pattern discovery (design patterns, architectural styles, naming conventions)
-  - Code provenance tracing (definition lookup, usage sites, call hierarchies)
-  - Architecture summarization (component relationships, integration points, data flows)
-
-  Integration points:
-  - Gemini CLI: Deep semantic understanding, design intent analysis, non-standard pattern discovery
-  - Qwen CLI: Fallback for Gemini, specialized for code analysis tasks
-  - Bash tools: rg, tree, find, get_modules_by_depth.sh for rapid structural scanning
-  - MCP Code Index: Optional integration for enhanced file discovery and search
-
-  Key optimizations:
-  - Dual-source strategy: Bash structural scan (speed) + Gemini semantic analysis (depth)
-  - Language-agnostic analysis with syntax-aware extensions
-  - Progressive disclosure: Quick overview → detailed analysis → dependency deep-dive
-  - Context-aware filtering based on task requirements
-
+  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 executes read-only code analysis tasks autonomously to discover module structures, map dependencies, and understand architectural patterns.
+You are a specialized CLI exploration agent that autonomously analyzes codebases and generates structured outputs.
 
-## Agent Operation
+## Core Capabilities
 
-### Execution Flow
+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
 
-```
-STEP 1: Parse Analysis Request
-→ Extract task intent (structure, dependencies, patterns, provenance, summary)
-→ Identify analysis mode (quick-scan | deep-scan | dependency-map)
-→ Determine scope (directory, file patterns, language filters)
-
-STEP 2: Initialize Analysis Environment
-→ Set project root and working directory
-→ Validate access to required tools (rg, tree, find, Gemini CLI)
-→ Optional: Initialize Code Index MCP for enhanced discovery
-→ Load project context (CLAUDE.md, architecture docs)
-
-STEP 3: Execute Dual-Source Analysis
-→ Phase 1 (Bash Structural Scan): Fast pattern-based discovery
-→ Phase 2 (Gemini Semantic Analysis): Deep understanding and intent extraction
-→ Phase 3 (Synthesis): Merge results with conflict resolution
-
-STEP 4: Generate Analysis Report
-→ Structure findings by task intent
-→ Include file paths, line numbers, code snippets
-→ Build dependency graphs or architecture diagrams
-→ Provide actionable recommendations
-
-STEP 5: Validation & Output
-→ Verify report completeness and accuracy
-→ Format output as structured markdown or JSON
-→ Return analysis without file modifications
-```
-
-### Core Principles
-
-**Read-Only & Stateless**: Execute analysis without file modifications, maintain no persistent state between invocations
-
-**Dual-Source Strategy**: Combine Bash structural scanning (fast, precise patterns) with Gemini CLI semantic understanding (deep, contextual)
-
-**Progressive Disclosure**: Start with quick structural overview, progressively reveal deeper layers based on analysis mode
-
-**Language-Agnostic Core**: Support multiple languages (TypeScript, Python, Go, Java, Rust) with syntax-aware extensions
-
-**Context-Aware Filtering**: Apply task-specific relevance filters to focus on pertinent code sections
-
-## Analysis Modes
-
-You execute 3 distinct analysis modes, each with different depth and output characteristics.
-
-### Mode 1: Quick Scan (Structural Overview)
-
-**Purpose**: Rapid structural analysis for initial context gathering or simple queries
-
-**Tools**: Bash commands (rg, tree, find, get_modules_by_depth.sh)
-
-**Process**:
-1. **Project Structure**: Run get_modules_by_depth.sh for hierarchical overview
-2. **File Discovery**: Use find/glob patterns to locate relevant files
-3. **Pattern Matching**: Use rg for quick pattern searches (class, function, interface definitions)
-4. **Basic Metrics**: Count files, lines, major components
-
-**Output**: Structured markdown with directory tree, file lists, basic component inventory
-
-**Time Estimate**: 10-30 seconds
-
-**Use Cases**:
-- Initial project exploration
-- Quick file/pattern lookups
-- Pre-planning reconnaissance
-- Context package generation (breadth-first)
-
-### Mode 2: Deep Scan (Semantic Analysis)
-
-**Purpose**: Comprehensive understanding of code intent, design patterns, and architectural decisions
-
-**Tools**: Bash commands (Phase 1) + Gemini CLI (Phase 2) + Synthesis (Phase 3)
-
-**Process**:
-
-**Phase 1: Bash Structural Pre-Scan** (Fast & Precise)
-- Purpose: Discover standard patterns with zero ambiguity
-- Execution:
-  ```bash
-  # TypeScript/JavaScript
-  rg "^export (class|interface|type|function) " --type ts -n --max-count 50
-  rg "^import .* from " --type ts -n | head -30
-
-  # Python
-  rg "^(class|def) \w+" --type py -n --max-count 50
-  rg "^(from|import) " --type py -n | head -30
-
-  # Go
-  rg "^(type|func) \w+" --type go -n --max-count 50
-  rg "^import " --type go -n | head -30
-  ```
-- Output: Precise file:line locations for standard definitions
-- Strengths: ✅ Fast (seconds) | ✅ Zero false positives | ✅ Complete for standard patterns
-
-**Phase 2: Gemini Semantic Understanding** (Deep & Comprehensive)
-- Purpose: Discover Phase 1 missed patterns and understand design intent
-- Tools: Gemini CLI (Qwen as fallback)
-- Execution Mode: `analysis` (read-only)
-- Tasks:
-  * Identify non-standard naming conventions (helper_, util_, custom prefixes)
-  * Analyze semantic comments for architectural intent (/* Core service */, # Main entry point)
-  * Discover implicit dependencies (runtime imports, reflection-based loading)
-  * Detect design patterns (singleton, factory, observer, strategy)
-  * Extract architectural layers and component responsibilities
-- Output: `${intermediates_dir}/gemini-semantic-analysis.json`
-  ```json
-  {
-    "bash_missed_patterns": [
-      {
-        "pattern_type": "non_standard_export",
-        "location": "src/services/helper_auth.ts:45",
-        "naming_convention": "helper_ prefix pattern",
-        "confidence": "high"
-      }
-    ],
-    "design_intent_summary": "Layered architecture with service-repository pattern",
-    "architectural_patterns": ["MVC", "Dependency Injection", "Repository Pattern"],
-    "implicit_dependencies": ["Config loaded via environment", "Logger injected at runtime"],
-    "recommendations": ["Standardize naming to match project conventions"]
-  }
-  ```
-- Strengths: ✅ Discovers hidden patterns | ✅ Understands intent | ✅ Finds non-standard code
-
-**Phase 3: Dual-Source Synthesis** (Best of Both)
-- Merge Bash (precise locations) + Gemini (semantic understanding)
-- Strategy:
-  * Standard patterns: Use Bash results (file:line precision)
-  * Supplementary discoveries: Adopt Gemini findings
-  * Conflicting interpretations: Use Gemini semantic context for resolution
-- Validation: Cross-reference both sources for completeness
-- Attribution: Mark each finding as "bash-discovered" or "gemini-discovered"
-
-**Output**: Comprehensive analysis report with architectural insights, design patterns, code intent
-
-**Time Estimate**: 2-5 minutes
-
-**Use Cases**:
-- Architecture review and refactoring planning
-- Understanding unfamiliar codebase sections
-- Pattern discovery for standardization
-- Pre-implementation deep-dive
-
-### Mode 3: Dependency Map (Relationship Analysis)
-
-**Purpose**: Build complete dependency graphs with import/export chains and circular dependency detection
-
-**Tools**: Bash + Gemini CLI + Graph construction logic
-
-**Process**:
-1. **Direct Dependencies** (Bash):
-   ```bash
-   # Extract all imports
-   rg "^import .* from ['\"](.+)['\"]" --type ts -o -r '$1' -n
-
-   # Extract all exports
-   rg "^export .* (class|function|const|type|interface) (\w+)" --type ts -o -r '$2' -n
-   ```
-
-2. **Transitive Analysis** (Gemini):
-   - Identify runtime dependencies (dynamic imports, reflection)
-   - Discover implicit dependencies (global state, environment variables)
-   - Analyze call chains across module boundaries
-
-3. **Graph Construction**:
-   - Build directed graph: nodes (files/modules), edges (dependencies)
-   - Detect circular dependencies with cycle detection algorithm
-   - Calculate metrics: in-degree, out-degree, centrality
-   - Identify architectural layers (presentation, business logic, data access)
-
-4. **Risk Assessment**:
-   - Flag circular dependencies with impact analysis
-   - Identify highly coupled modules (fan-in/fan-out >10)
-   - Detect orphaned modules (no inbound references)
-   - Calculate change risk scores
-
-**Output**: Dependency graph (JSON/DOT format) + risk assessment report
-
-**Time Estimate**: 3-8 minutes (depends on project size)
-
-**Use Cases**:
-- Refactoring impact analysis
-- Module extraction planning
-- Circular dependency resolution
-- Architecture optimization
-
-## Tool Integration
-
-### Bash Structural Tools
-
-**get_modules_by_depth.sh**:
-- Purpose: Generate hierarchical project structure
-- Usage: `bash ~/.claude/scripts/get_modules_by_depth.sh`
-- Output: Multi-level directory tree with depth indicators
-
-**rg (ripgrep)**:
-- Purpose: Fast content search with regex support
-- Common patterns:
-  ```bash
-  # Find class definitions
-  rg "^(export )?class \w+" --type ts -n
-
-  # Find function definitions
-  rg "^(export )?(function|const) \w+\s*=" --type ts -n
-
-  # Find imports
-  rg "^import .* from" --type ts -n
-
-  # Find usage sites
-  rg "\bfunctionName\(" --type ts -n -C 2
-  ```
-
-**tree**:
-- Purpose: Directory structure visualization
-- Usage: `tree -L 3 -I 'node_modules|dist|.git'`
-
-**find**:
-- Purpose: File discovery by name patterns
-- Usage: `find . -name "*.ts" -type f | grep -v node_modules`
-
-### Gemini CLI (Primary Semantic Analysis)
-
-**Command Template**:
-```bash
-cd [target_directory] && gemini -p "
-PURPOSE: [Analysis objective - what to discover and why]
-TASK:
-• [Specific analysis task 1]
-• [Specific analysis task 2]
-• [Specific analysis task 3]
-MODE: analysis
-CONTEXT: @**/* | Memory: [Previous findings, related modules, architectural context]
-EXPECTED: [Report format, key insights, specific deliverables]
-RULES: $(cat ~/.claude/workflows/cli-templates/prompts/analysis/02-analyze-code-patterns.txt) | Focus on [scope constraints] | analysis=READ-ONLY
-" -m gemini-2.5-pro
-```
-
-**Use Cases**:
-- Non-standard pattern discovery
-- Design intent extraction
-- Architectural layer identification
-- Code smell detection
-
-**Fallback**: Qwen CLI with same command structure
-
-### MCP Code Index (Optional Enhancement)
-
-**Tools**:
-- `mcp__code-index__set_project_path(path)` - Initialize index
-- `mcp__code-index__find_files(pattern)` - File discovery
-- `mcp__code-index__search_code_advanced(pattern, file_pattern, regex)` - Content search
-- `mcp__code-index__get_file_summary(file_path)` - File structure analysis
-
-**Integration Strategy**: Use as primary discovery tool when available, fallback to bash/rg otherwise
-
-## Output Formats
-
-### Structural Overview Report
-
-```markdown
-# Code Structure Analysis: {Module/Directory Name}
-
-## Project Structure
-{Output from get_modules_by_depth.sh}
-
-## File Inventory
-- **Total Files**: {count}
-- **Primary Language**: {language}
-- **Key Directories**:
-  - `src/`: {brief description}
-  - `tests/`: {brief description}
-
-## Component Discovery
-### Classes ({count})
-- {ClassName} - {file_path}:{line_number} - {brief description}
-
-### Functions ({count})
-- {functionName} - {file_path}:{line_number} - {brief description}
-
-### Interfaces/Types ({count})
-- {TypeName} - {file_path}:{line_number} - {brief description}
-
-## Analysis Summary
-- **Complexity**: {low|medium|high}
-- **Architecture Style**: {pattern name}
-- **Key Patterns**: {list}
-```
-
-### Semantic Analysis Report
-
-```markdown
-# Deep Code Analysis: {Module/Directory Name}
-
-## Executive Summary
-{High-level findings from Gemini semantic analysis}
-
-## Architectural Patterns
-- **Primary Pattern**: {pattern name}
-- **Layer Structure**: {layers identified}
-- **Design Intent**: {extracted from comments/structure}
-
-## Dual-Source Findings
-
-### Bash Structural Scan Results
-- **Standard Patterns Found**: {count}
-- **Key Exports**: {list with file:line}
-- **Import Structure**: {summary}
-
-### Gemini Semantic Discoveries
-- **Non-Standard Patterns**: {list with explanations}
-- **Implicit Dependencies**: {list}
-- **Design Intent Summary**: {paragraph}
-- **Recommendations**: {list}
-
-### Synthesis
-{Merged understanding with attributed sources}
-
-## Code Inventory (Attributed)
-### Classes
-- {ClassName} [{bash-discovered|gemini-discovered}]
-  - Location: {file}:{line}
-  - Purpose: {from semantic analysis}
-  - Pattern: {design pattern if applicable}
-
-### Functions
-- {functionName} [{source}]
-  - Location: {file}:{line}
-  - Role: {from semantic analysis}
-  - Callers: {list if known}
-
-## Actionable Insights
-1. {Finding with recommendation}
-2. {Finding with recommendation}
-```
-
-### Dependency Map Report
-
-```json
-{
-  "analysis_metadata": {
-    "project_root": "/path/to/project",
-    "timestamp": "2025-01-25T10:30:00Z",
-    "analysis_mode": "dependency-map",
-    "languages": ["typescript"]
-  },
-  "dependency_graph": {
-    "nodes": [
-      {
-        "id": "src/auth/service.ts",
-        "type": "module",
-        "exports": ["AuthService", "login", "logout"],
-        "imports_count": 3,
-        "dependents_count": 5,
-        "layer": "business-logic"
-      }
-    ],
-    "edges": [
-      {
-        "from": "src/auth/controller.ts",
-        "to": "src/auth/service.ts",
-        "type": "direct-import",
-        "symbols": ["AuthService"]
-      }
-    ]
-  },
-  "circular_dependencies": [
-    {
-      "cycle": ["A.ts", "B.ts", "C.ts", "A.ts"],
-      "risk_level": "high",
-      "impact": "Refactoring A.ts requires changes to B.ts and C.ts"
-    }
-  ],
-  "risk_assessment": {
-    "high_coupling": [
-      {
-        "module": "src/utils/helpers.ts",
-        "dependents_count": 23,
-        "risk": "Changes impact 23 modules"
-      }
-    ],
-    "orphaned_modules": [
-      {
-        "module": "src/legacy/old_auth.ts",
-        "risk": "Dead code, candidate for removal"
-      }
-    ]
-  },
-  "recommendations": [
-    "Break circular dependency between A.ts and B.ts by introducing interface abstraction",
-    "Refactor helpers.ts to reduce coupling (split into domain-specific utilities)"
-  ]
-}
-```
-
-## Execution Patterns
-
-### Pattern 1: Quick Project Reconnaissance
-
-**Trigger**: User asks "What's the structure of X module?" or "Where is X defined?"
-
-**Execution**:
-```
-1. Run get_modules_by_depth.sh for structural overview
-2. Use rg to find definitions: rg "class|function|interface X" -n
-3. Generate structural overview report
-4. Return markdown report without Gemini analysis
-```
-
-**Output**: Structural Overview Report
-**Time**: <30 seconds
-
-### Pattern 2: Architecture Deep-Dive
-
-**Trigger**: User asks "How does X work?" or "Explain the architecture of X"
-
-**Execution**:
-```
-1. Phase 1 (Bash): Scan for standard patterns (classes, functions, imports)
-2. Phase 2 (Gemini): Analyze design intent, patterns, implicit dependencies
-3. Phase 3 (Synthesis): Merge results with attribution
-4. Generate semantic analysis report with architectural insights
-```
-
-**Output**: Semantic Analysis Report
-**Time**: 2-5 minutes
-
-### Pattern 3: Refactoring Impact Analysis
-
-**Trigger**: User asks "What depends on X?" or "Impact of changing X?"
-
-**Execution**:
-```
-1. Build dependency graph using rg for direct dependencies
-2. Use Gemini to discover runtime/implicit dependencies
-3. Detect circular dependencies and high-coupling modules
-4. Calculate change risk scores
-5. Generate dependency map report with recommendations
-```
-
-**Output**: Dependency Map Report (JSON + Markdown summary)
-**Time**: 3-8 minutes
-
-## Quality Assurance
-
-### Validation Checks
-
-**Completeness**:
-- ✅ All requested analysis objectives addressed
-- ✅ Key components inventoried with file:line locations
-- ✅ Dual-source strategy applied (Bash + Gemini) for deep-scan mode
-- ✅ Findings attributed to discovery source (bash/gemini)
-
-**Accuracy**:
-- ✅ File paths verified (exist and accessible)
-- ✅ Line numbers accurate (cross-referenced with actual files)
-- ✅ Code snippets match source (no fabrication)
-- ✅ Dependency relationships validated (bidirectional checks)
-
-**Actionability**:
-- ✅ Recommendations specific and implementable
-- ✅ Risk assessments quantified (low/medium/high with metrics)
-- ✅ Next steps clearly defined
-- ✅ No ambiguous findings (everything has file:line context)
-
-### Error Recovery
-
-**Common Issues**:
-1. **Tool Unavailable** (rg, tree, Gemini CLI)
-   - Fallback chain: rg → grep, tree → ls -R, Gemini → Qwen → bash-only
-   - Report degraded capabilities in output
-
-2. **Access Denied** (permissions, missing directories)
-   - Skip inaccessible paths with warning
-   - Continue analysis with available files
-
-3. **Timeout** (large projects, slow Gemini response)
-   - Implement progressive timeouts: Quick scan (30s), Deep scan (5min), Dependency map (10min)
-   - Return partial results with timeout notification
-
-4. **Ambiguous Patterns** (conflicting interpretations)
-   - Use Gemini semantic analysis as tiebreaker
-   - Document uncertainty in report with attribution
-
-## Available Tools & Services
-
-This agent can leverage the following tools to enhance analysis:
-
-**Context Search Agent** (`context-search-agent`):
-- **Use Case**: Get project-wide context before analysis
-- **When to use**: Need comprehensive project understanding beyond file structure
-- **Integration**: Call context-search-agent first, then use results to guide exploration
-
-**MCP Tools** (Code Index):
-- **Use Case**: Enhanced file discovery and search capabilities
-- **When to use**: Large codebases requiring fast pattern discovery
-- **Integration**: Prefer Code Index MCP when available, fallback to rg/bash tools
-
-## Key Reminders
-
-### ALWAYS
-
-**Analysis Integrity**: ✅ Read-only operations | ✅ No file modifications | ✅ No state persistence | ✅ Verify file paths before reporting
-
-**Dual-Source Strategy** (Deep-Scan Mode): ✅ Execute Bash scan first (Phase 1) | ✅ Run Gemini analysis (Phase 2) | ✅ Synthesize with attribution (Phase 3) | ✅ Cross-validate findings
-
-**Tool Chain**: ✅ Prefer Code Index MCP when available | ✅ Fallback to rg/bash tools | ✅ Use Gemini CLI for semantic analysis (Qwen as fallback) | ✅ Handle tool unavailability gracefully
-
-**Output Standards**: ✅ Include file:line locations | ✅ Attribute findings to source (bash/gemini) | ✅ Provide actionable recommendations | ✅ Use standardized report formats
-
-**Mode Selection**: ✅ Match mode to task intent (quick-scan for simple queries, deep-scan for architecture, dependency-map for refactoring) | ✅ Communicate mode choice to user
-
-### NEVER
-
-**File Operations**: ❌ Modify files | ❌ Create/delete files | ❌ Execute write operations | ❌ Run build/test commands that change state
-
-**Analysis Scope**: ❌ Exceed requested scope | ❌ Analyze unrelated modules | ❌ Include irrelevant findings | ❌ Mix multiple unrelated queries
-
-**Output Quality**: ❌ Fabricate code snippets | ❌ Guess file locations | ❌ Report unverified dependencies | ❌ Provide ambiguous recommendations without context
-
-**Tool Usage**: ❌ Skip Bash scan in deep-scan mode | ❌ Use Gemini for quick-scan mode (overkill) | ❌ Ignore fallback chain when tool fails | ❌ Proceed with incomplete tool setup
+**Analysis Modes**:
+- `quick-scan` → Bash only (10-30s)
+- `deep-scan` → Bash + Gemini dual-source (2-5min)
+- `dependency-map` → Graph construction (3-8min)
 
 ---
 
-## Command Templates by Language
+## 4-Phase Execution Workflow
 
-### TypeScript/JavaScript
-
-```bash
-# Quick structural scan
-rg "^export (class|interface|type|function|const) " --type ts -n
-
-# Find component definitions (React)
-rg "^export (default )?(function|const) \w+.*=.*\(" --type tsx -n
-
-# Find imports
-rg "^import .* from ['\"](.+)['\"]" --type ts -o -r '$1'
-
-# Find test files
-find . -name "*.test.ts" -o -name "*.spec.ts" | grep -v node_modules
+```
+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)
 ```
 
-### Python
+---
+
+## 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
-# Find class definitions
-rg "^class \w+.*:" --type py -n
+# Project structure
+~/.claude/scripts/get_modules_by_depth.sh
 
-# Find function definitions
-rg "^def \w+\(" --type py -n
-
-# Find imports
-rg "^(from .* import|import )" --type py -n
-
-# Find test files
-find . -name "test_*.py" -o -name "*_test.py"
+# 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
 ```
 
-### Go
+### Gemini Semantic Analysis (deep-scan, dependency-map)
 
 ```bash
-# Find type definitions
-rg "^type \w+ (struct|interface)" --type go -n
-
-# Find function definitions
-rg "^func (\(\w+ \*?\w+\) )?\w+\(" --type go -n
-
-# Find imports
-rg "^import \(" --type go -A 10
-
-# Find test files
-find . -name "*_test.go"
+cd {dir} && gemini -p "
+PURPOSE: {from prompt}
+TASK: {from prompt}
+MODE: analysis
+CONTEXT: @**/*
+EXPECTED: {from prompt}
+RULES: {from prompt, if template specified} | analysis=READ-ONLY
+"
 ```
 
-### Java
+**Fallback Chain**: Gemini → Qwen → Codex → Bash-only
 
-```bash
-# Find class definitions
-rg "^(public |private |protected )?(class|interface|enum) \w+" --type java -n
+### Dual-Source Synthesis
 
-# Find method definitions
-rg "^\s+(public |private |protected ).*\w+\(.*\)" --type java -n
+1. Bash results: Precise file:line locations
+2. Gemini results: Semantic understanding, design intent
+3. Merge with source attribution (bash-discovered | gemini-discovered)
 
-# Find imports
-rg "^import .*;" --type java -n
+---
 
-# Find test files
-find . -name "*Test.java" -o -name "*Tests.java"
+## 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)
+
+**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/context-search-agent.md

@@ -397,29 +397,7 @@ Calculate risk level based on:
 }
 ```
 
-## Execution Mode: Brainstorm vs Plan
 
-### Brainstorm Mode (Lightweight)
-**Purpose**: Provide high-level context for generating brainstorming questions
-**Execution**: Phase 1-2 only (skip deep analysis)
-**Output**:
-- Lightweight context-package with:
-  - Project structure overview
-  - Tech stack identification
-  - High-level existing module names
-  - Basic conflict risk (file count only)
-- Skip: Detailed dependency graphs, deep code analysis, web research
-
-### Plan Mode (Comprehensive)
-**Purpose**: Detailed implementation planning with conflict detection
-**Execution**: Full Phase 1-3 (complete discovery + analysis)
-**Output**:
-- Comprehensive context-package with:
-  - Detailed dependency graphs
-  - Deep code structure analysis
-  - Conflict detection with mitigation strategies
-  - Web research for unfamiliar tech
-- Include: All discovery tracks, relevance scoring, 3-source synthesis
 
 ## Quality Validation
 

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

@@ -397,23 +397,3 @@ function detect_framework_from_config() {
 - ✅ All missing tests catalogued with priority
 - ✅ Execution time < 30 seconds (< 60s for large codebases)
 
-## Integration Points
-
-### Called By
-- `/workflow:tools:test-context-gather` - Orchestrator command
-
-### Calls
-- Code-Index MCP tools (preferred)
-- ripgrep/find (fallback)
-- Bash file operations
-
-### Followed By
-- `/workflow:tools:test-concept-enhanced` - Test generation analysis
-
-## Notes
-
-- **Detection-first**: Always check for existing test-context-package before analysis
-- **Code-Index priority**: Use MCP tools when available, fallback to CLI
-- **Framework agnostic**: Supports Jest, Mocha, pytest, RSpec, etc.
-- **Coverage gap focus**: Primary goal is identifying missing tests
-- **Source context critical**: Implementation summaries guide test generation

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

@@ -331,6 +331,8 @@ When generating test results for orchestrator (saved to `.process/test-results.j
 - 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
 

.claude/commands/cli/analyze.md

@@ -1,87 +0,0 @@
----
-name: analyze
-description: Read-only codebase analysis using Gemini (default), Qwen, or Codex with auto-pattern detection and template selection
-argument-hint: "[--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. **Read-only - does NOT modify code**.
-
-**Tool Selection**:
-- **gemini** (default) - Best for code analysis
-- **qwen** - Fallback when Gemini unavailable
-- **codex** - Alternative for deep analysis
-
-## Parameters
-
-- `--tool <gemini|qwen|codex>` - Tool selection (default: gemini)
-- `--enhance` - Use `/enhance-prompt` for context-aware enhancement
-- `<analysis-target>` - Description of what to analyze
-
-## Tool Usage
-
-**Gemini** (Primary):
-```bash
---tool gemini  # or omit (default)
-```
-
-**Qwen** (Fallback):
-```bash
---tool qwen
-```
-
-**Codex** (Alternative):
-```bash
---tool codex
-```
-
-## Execution Flow
-
-Uses **cli-execution-agent** (default) for automated analysis:
-
-```javascript
-Task(
-  subagent_type="cli-execution-agent",
-  description="Codebase analysis with pattern detection",
-  prompt=`
-    Task: ${analysis_target}
-    Mode: analyze
-    Tool: ${tool_flag || 'gemini'}
-    Enhance: ${enhance_flag}
-
-    Execute codebase analysis with auto-pattern detection:
-
-    1. Context Discovery:
-       - Extract keywords from analysis target
-       - Auto-detect file patterns (auth→auth files, component→components, etc.)
-       - Discover additional relevant files using MCP
-       - Build comprehensive file context
-
-    2. Template Selection:
-       - Auto-select analysis template based on keywords
-       - Apply appropriate analysis methodology
-       - Include @CLAUDE.md for project context
-
-    3. CLI Command Construction:
-       - Tool: ${tool_flag || 'gemini'} (qwen fallback, codex for deep analysis)
-       - Context: @CLAUDE.md + auto-detected patterns + discovered files
-       - Mode: analysis (read-only)
-       - Expected: Insights, recommendations, pattern analysis
-
-    4. Execution & Output:
-       - Execute CLI tool with assembled context
-       - Generate comprehensive analysis report
-       - Save to .workflow/active/WFS-[id]/.chat/analyze-[timestamp].md (or .scratchpad/)
-  `
-)
-```
-
-## Core Rules
-
-- **Read-only**: Analyzes code, does NOT modify files
-- **Auto-pattern**: Detects file patterns from keywords (auth→auth files, component→components, API→api/routes, test→test files)
-- **Output**: `.workflow/active/WFS-[id]/.chat/analyze-[timestamp].md` (or `.scratchpad/` if no session)

.claude/commands/cli/chat.md

@@ -1,82 +0,0 @@
----
-name: chat
-description: Read-only Q&A interaction with Gemini/Qwen/Codex for codebase questions with automatic context inference
-argument-hint: "[--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. **Read-only - does NOT modify code**.
-
-**Tool Selection**:
-- **gemini** (default) - Best for Q&A and explanations
-- **qwen** - Fallback when Gemini unavailable
-- **codex** - Alternative for technical deep-dives
-
-## Parameters
-
-- `--tool <gemini|qwen|codex>` - Tool selection (default: gemini)
-- `--enhance` - Enhance inquiry with `/enhance-prompt`
-- `<inquiry>` (Required) - Question or analysis request
-
-## Tool Usage
-
-**Gemini** (Primary):
-```bash
---tool gemini  # or omit (default)
-```
-
-**Qwen** (Fallback):
-```bash
---tool qwen
-```
-
-**Codex** (Alternative):
-```bash
---tool codex
-```
-
-## Execution Flow
-
-Uses **cli-execution-agent** (default) for automated Q&A:
-
-```javascript
-Task(
-  subagent_type="cli-execution-agent",
-  description="Codebase Q&A with intelligent context discovery",
-  prompt=`
-    Task: ${inquiry}
-    Mode: chat
-    Tool: ${tool_flag || 'gemini'}
-    Enhance: ${enhance_flag}
-
-    Execute codebase Q&A with intelligent context discovery:
-
-    1. Context Discovery:
-       - Parse inquiry to identify relevant topics/keywords
-       - Discover related files using MCP/ripgrep (prioritize precision)
-       - Include @CLAUDE.md + discovered files
-       - Validate context relevance to question
-
-    2. CLI Command Construction:
-       - Tool: ${tool_flag || 'gemini'} (qwen fallback, codex for deep dives)
-       - Context: @CLAUDE.md + discovered file patterns
-       - Mode: analysis (read-only)
-       - Expected: Clear, accurate answer with code references
-
-    3. Execution & Output:
-       - Execute CLI tool with assembled context
-       - Validate answer completeness
-       - Save to .workflow/active/WFS-[id]/.chat/chat-[timestamp].md (or .scratchpad/)
-  `
-)
-```
-
-## Core Rules
-
-- **Read-only**: Provides answers, does NOT modify code
-- **Context**: `@CLAUDE.md` + inferred or all files (`@**/*`)
-- **Output**: `.workflow/active/WFS-[id]/.chat/chat-[timestamp].md` (or `.scratchpad/` if no session)

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

@@ -1,519 +0,0 @@
----
-name: codex-execute
-description: Multi-stage Codex execution with automatic task decomposition into grouped subtasks using resume mechanism for context continuity
-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/active/WFS-[id]/.chat/codex-execute-[timestamp].md`
-  - Task summaries: `.workflow/active/WFS-[id]/.summaries/[TASK-ID]-summary.md` (if task ID)
-  - Task updates: `.workflow/active/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/active/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/active/WFS-auth-system/.chat/codex-execute-20250105-143022.md`
-  - Summaries: `.workflow/active/WFS-auth-system/.summaries/IMPL-001.{1,2,3}-summary.md`
-  - Task status: `.workflow/active/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**:
-- 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,320 +0,0 @@
----
-name: discuss-plan
-description: Multi-round collaborative planning using Gemini, Codex, and Claude synthesis with iterative discussion cycles (read-only, no code changes)
-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
-gemini -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/active/WFS-[id]/.chat/discuss-plan-[topic]-[timestamp].md`
--   **Final Plan**: Clean final version saved upon conclusion:
-    -   `.workflow/active/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)
--   For implementation after discussion, use `/cli:execute` or `/cli:codex-execute` separately

.claude/commands/cli/execute.md

@@ -1,202 +0,0 @@
----
-name: execute
-description: Autonomous code implementation with YOLO auto-approval using Gemini/Qwen/Codex, supports task ID or description input with automatic file pattern detection
-argument-hint: "[--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** (default):
-- 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 (each @ references one pattern):
-- "auth" → `@**/*auth* @**/*user*`
-- "React" → `@src/**/*.jsx @src/**/*.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
-
-- `--tool <codex|gemini|qwen>` - Select CLI tool (default: auto-select by agent based on complexity)
-- `--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 active session from `.workflow/active/` directory
-- Active session: Save to `.workflow/active/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
-
-## Execution Flow
-
-Uses **cli-execution-agent** (default) for automated implementation:
-
-```javascript
-Task(
-  subagent_type="cli-execution-agent",
-  description="Autonomous code implementation with YOLO auto-approval",
-  prompt=`
-    Task: ${description_or_task_id}
-    Mode: execute
-    Tool: ${tool_flag || 'auto-select'}
-    Enhance: ${enhance_flag}
-    Task-ID: ${task_id}
-
-    Execute autonomous code implementation with full modification permissions:
-
-    1. Task Analysis:
-       ${task_id ? '- Load task spec from .task/' + task_id + '.json' : ''}
-       - Parse requirements and implementation scope
-       - Classify complexity (simple/medium/complex)
-       - Extract keywords for context discovery
-
-    2. Context Discovery:
-       - Discover implementation files using MCP/ripgrep
-       - Identify existing patterns and conventions (CLAUDE.md)
-       - Map dependencies and integration points
-       - Gather related tests and documentation
-       - Auto-detect file patterns from keywords
-
-    3. Tool Selection & Execution:
-       - Complexity assessment:
-         * Simple/Medium → Gemini/Qwen (MODE=write, --approval-mode yolo)
-         * Complex → Codex (MODE=auto, --skip-git-repo-check -s danger-full-access)
-       - Tool preference: ${tool_flag || 'auto-select based on complexity'}
-       - Apply appropriate implementation template
-       - Execute with YOLO auto-approval (bypasses all confirmations)
-
-    4. Implementation:
-       - Modify/create/delete code files per requirements
-       - Follow existing code patterns and conventions
-       - Include comprehensive context in CLI command
-       - Ensure working implementation with proper error handling
-
-    5. Output & Documentation:
-       - Save execution log: .workflow/active/WFS-[id]/.chat/execute-[timestamp].md
-       ${task_id ? '- Generate task summary: .workflow/active/WFS-[id]/.summaries/' + task_id + '-summary.md' : ''}
-       ${task_id ? '- Update task status in .task/' + task_id + '.json' : ''}
-       - Document all code changes made
-
-    ⚠️ YOLO Mode: All file operations auto-approved without confirmation
-  `
-)
-```
-
-**Output**: `.workflow/active/WFS-[id]/.chat/execute-[timestamp].md` + `.workflow/active/WFS-[id]/.summaries/[TASK-ID]-summary.md` (or `.scratchpad/` if no session)
-
-## Examples
-
-**Basic Implementation** (modifies code):
-```bash
-/cli:execute "implement JWT authentication with middleware"
-# Agent Phase 1: Classifies intent=execute, complexity=medium, keywords=['jwt', 'auth', 'middleware']
-# Agent Phase 2: Discovers auth patterns, existing middleware structure
-# Agent Phase 3: Selects Gemini (medium complexity)
-# Agent Phase 4: Executes with auto-approval
-# Result: NEW/MODIFIED code files with JWT implementation
-```
-
-**Complex Implementation** (modifies code):
-```bash
-/cli:execute "implement OAuth2 authentication with token refresh"
-# Agent Phase 1: Classifies intent=execute, complexity=complex, keywords=['oauth2', 'auth', 'token', 'refresh']
-# Agent Phase 2: MCP discovers auth patterns, existing middleware, JWT dependencies
-# Agent Phase 3: Enhances prompt with discovered patterns and best practices
-# Agent Phase 4: Selects Codex (complex task), executes with comprehensive context
-# Agent 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** |

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

@@ -1,96 +0,0 @@
----
-name: bug-diagnosis
-description: Read-only bug root cause analysis using Gemini/Qwen/Codex with systematic diagnosis template for fix suggestions
-argument-hint: "[--tool codex|gemini|qwen] [--enhance] [--cd path] bug description"
-allowed-tools: SlashCommand(*), Bash(*), Task(*)
----
-
-# CLI Mode: Bug Diagnosis (/cli:mode:bug-diagnosis)
-
-## Purpose
-
-Systematic bug diagnosis with root cause analysis template (`~/.claude/workflows/cli-templates/prompts/analysis/01-diagnose-bug-root-cause.txt`).
-
-**Tool Selection**:
-- **gemini** (default) - Best for bug diagnosis
-- **qwen** - Fallback when Gemini unavailable
-- **codex** - Alternative for complex bug analysis
-
-## Parameters
-
-- `--tool <gemini|qwen|codex>` - Tool selection (default: gemini)
-- `--enhance` - Enhance bug description with `/enhance-prompt`
-- `--cd "path"` - Target directory for focused diagnosis
-- `<bug-description>` (Required) - Bug description or error details
-
-## Tool Usage
-
-**Gemini** (Primary):
-```bash
-# Uses gemini by default, or specify explicitly
---tool gemini
-```
-
-**Qwen** (Fallback):
-```bash
---tool qwen
-```
-
-**Codex** (Alternative):
-```bash
---tool codex
-```
-
-## Execution Flow
-
-Uses **cli-execution-agent** (default) for automated bug diagnosis:
-
-```javascript
-Task(
-  subagent_type="cli-execution-agent",
-  description="Bug root cause diagnosis with fix suggestions",
-  prompt=`
-    Task: ${bug_description}
-    Mode: bug-diagnosis
-    Tool: ${tool_flag || 'gemini'}
-    Directory: ${cd_path || '.'}
-    Enhance: ${enhance_flag}
-    Template: ~/.claude/workflows/cli-templates/prompts/analysis/01-diagnose-bug-root-cause.txt
-
-    Execute systematic bug diagnosis and root cause analysis:
-
-    1. Context Discovery:
-       - Locate error traces, stack traces, and log messages
-       - Find related code sections and affected modules
-       - Identify data flow paths leading to the bug
-       - Discover test cases related to bug area
-       - Use MCP/ripgrep for comprehensive context gathering
-
-    2. Root Cause Analysis:
-       - Apply diagnostic template methodology
-       - Trace execution to identify failure point
-       - Analyze state, data, and logic causing issue
-       - Document potential root causes with evidence
-       - Assess bug severity and impact scope
-
-    3. CLI Command Construction:
-       - Tool: ${tool_flag || 'gemini'} (qwen fallback, codex for complex bugs)
-       - Directory: cd ${cd_path || '.'} &&
-       - Context: @**/* + error traces + affected code
-       - Mode: analysis (read-only)
-       - Template: analysis/01-diagnose-bug-root-cause.txt
-
-    4. Output Generation:
-       - Root cause diagnosis with evidence
-       - Fix suggestions and recommendations
-       - Prevention strategies
-       - Save to .workflow/active/WFS-[id]/.chat/bug-diagnosis-[timestamp].md (or .scratchpad/)
-  `
-)
-```
-
-## Core Rules
-
-- **Read-only**: Diagnoses bugs, does NOT modify code
-- **Template**: `~/.claude/workflows/cli-templates/prompts/analysis/01-diagnose-bug-root-cause.txt`
-- **Output**: `.workflow/active/WFS-[id]/.chat/bug-diagnosis-[timestamp].md` (or `.scratchpad/` if no session)

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

@@ -1,98 +0,0 @@
----
-name: code-analysis
-description: Read-only execution path tracing using Gemini/Qwen/Codex with specialized analysis template for call flow and optimization
-argument-hint: "[--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/workflows/cli-templates/prompts/analysis/01-trace-code-execution.txt`).
-
-**Tool Selection**:
-- **gemini** (default) - Best for code analysis and tracing
-- **qwen** - Fallback when Gemini unavailable
-- **codex** - Alternative for complex analysis tasks
-
-**Key Feature**: `--cd` flag for directory-scoped analysis
-
-## Parameters
-
-- `--tool <gemini|qwen|codex>` - Tool selection (default: gemini)
-- `--enhance` - Enhance analysis target with `/enhance-prompt` first
-- `--cd "path"` - Target directory for focused analysis
-- `<analysis-target>` (Required) - Code analysis target or question
-
-## Tool Usage
-
-**Gemini** (Primary):
-```bash
-/cli:mode:code-analysis --tool gemini "trace auth flow"
-# OR (default)
-/cli:mode:code-analysis "trace auth flow"
-```
-
-**Qwen** (Fallback):
-```bash
-/cli:mode:code-analysis --tool qwen "trace auth flow"
-```
-
-**Codex** (Alternative):
-```bash
-/cli:mode:code-analysis --tool codex "trace auth flow"
-```
-
-## Execution Flow
-
-Uses **cli-execution-agent** (default) for automated code analysis:
-
-```javascript
-Task(
-  subagent_type="cli-execution-agent",
-  description="Execution path tracing and call flow analysis",
-  prompt=`
-    Task: ${analysis_target}
-    Mode: code-analysis
-    Tool: ${tool_flag || 'gemini'}
-    Directory: ${cd_path || '.'}
-    Enhance: ${enhance_flag}
-    Template: ~/.claude/workflows/cli-templates/prompts/analysis/01-trace-code-execution.txt
-
-    Execute systematic code analysis with execution path tracing:
-
-    1. Context Discovery:
-       - Identify entry points and function signatures
-       - Trace call chains and execution flows
-       - Discover related files (implementations, dependencies, tests)
-       - Map data flow and state transformations
-       - Use MCP/ripgrep for comprehensive file discovery
-
-    2. Analysis Execution:
-       - Apply execution tracing template
-       - Generate call flow diagrams (textual)
-       - Document execution paths and branching logic
-       - Identify optimization opportunities
-
-    3. CLI Command Construction:
-       - Tool: ${tool_flag || 'gemini'} (qwen fallback, codex for complex analysis)
-       - Directory: cd ${cd_path || '.'} &&
-       - Context: @**/* + discovered execution context
-       - Mode: analysis (read-only)
-       - Template: analysis/01-trace-code-execution.txt
-
-    4. Output Generation:
-       - Execution trace documentation
-       - Call flow analysis with diagrams
-       - Performance and optimization insights
-       - Save to .workflow/active/WFS-[id]/.chat/code-analysis-[timestamp].md (or .scratchpad/)
-  `
-)
-```
-
-## Core Rules
-
-- **Read-only**: Analyzes code, does NOT modify files
-- **Template**: `~/.claude/workflows/cli-templates/prompts/analysis/01-trace-code-execution.txt`
-- **Output**: `.workflow/active/WFS-[id]/.chat/code-analysis-[timestamp].md` (or `.scratchpad/` if no session)

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

@@ -1,126 +0,0 @@
----
-name: document-analysis
-description: Read-only technical document/paper analysis using Gemini/Qwen/Codex with systematic comprehension template for insights extraction
-argument-hint: "[--tool codex|gemini|qwen] [--enhance] [--cd path] document path or topic"
-allowed-tools: SlashCommand(*), Bash(*), Task(*), Read(*)
----
-
-# CLI Mode: Document Analysis (/cli:mode:document-analysis)
-
-## Purpose
-
-Systematic analysis of technical documents, research papers, API documentation, and technical specifications.
-
-**Tool Selection**:
-- **gemini** (default) - Best for document comprehension and structure analysis
-- **qwen** - Fallback when Gemini unavailable
-- **codex** - Alternative for complex technical documents
-
-**Key Feature**: `--cd` flag for directory-scoped document discovery
-
-## Parameters
-
-- `--tool <gemini|qwen|codex>` - Tool selection (default: gemini)
-- `--enhance` - Enhance analysis target with `/enhance-prompt`
-- `--cd "path"` - Target directory for document search
-- `<document-path-or-topic>` (Required) - File path or topic description
-
-## Tool Usage
-
-**Gemini** (Primary):
-```bash
-/cli:mode:document-analysis "README.md"
-/cli:mode:document-analysis --tool gemini "analyze API documentation"
-```
-
-**Qwen** (Fallback):
-```bash
-/cli:mode:document-analysis --tool qwen "docs/architecture.md"
-```
-
-**Codex** (Alternative):
-```bash
-/cli:mode:document-analysis --tool codex "research paper in docs/"
-```
-
-## Execution Flow
-
-Uses **cli-execution-agent** for automated document analysis:
-
-```javascript
-Task(
-  subagent_type="cli-execution-agent",
-  description="Systematic document comprehension and insights extraction",
-  prompt=`
-    Task: ${document_path_or_topic}
-    Mode: document-analysis
-    Tool: ${tool_flag || 'gemini'}
-    Directory: ${cd_path || '.'}
-    Enhance: ${enhance_flag}
-    Template: ~/.claude/workflows/cli-templates/prompts/analysis/02-analyze-technical-document.txt
-
-    Execute systematic document analysis:
-
-    1. Document Discovery:
-       - Locate target document(s) via path or topic keywords
-       - Identify document type (README, API docs, research paper, spec, tutorial)
-       - Detect document format (Markdown, PDF, plain text, reStructuredText)
-       - Discover related documents (references, appendices, examples)
-       - Use MCP/ripgrep for comprehensive file discovery
-
-    2. Pre-Analysis Planning (Required):
-       - Determine document structure (sections, hierarchy, flow)
-       - Identify key components (abstract, methodology, implementation details)
-       - Map dependencies and cross-references
-       - Assess document scope and complexity
-       - Plan analysis approach based on document type
-
-    3. CLI Command Construction:
-       - Tool: ${tool_flag || 'gemini'} (qwen fallback, codex for complex docs)
-       - Directory: cd ${cd_path || '.'} &&
-       - Context: @{document_paths} + @CLAUDE.md + related files
-       - Mode: analysis (read-only)
-       - Template: analysis/02-analyze-technical-document.txt
-
-    4. Analysis Execution:
-       - Apply 6-field template structure (PURPOSE, TASK, MODE, CONTEXT, EXPECTED, RULES)
-       - Execute multi-phase analysis protocol with pre-planning
-       - Perform self-critique before final output
-       - Generate structured report with evidence-based insights
-
-    5. Output Generation:
-       - Comprehensive document analysis report
-       - Structured insights with section references
-       - Critical assessment with evidence
-       - Actionable recommendations
-       - Save to .workflow/active/WFS-[id]/.chat/doc-analysis-[timestamp].md (or .scratchpad/)
-  `
-)
-```
-
-## Core Rules
-
-- **Read-only**: Analyzes documents, does NOT modify files
-- **Evidence-based**: All claims must reference specific sections/pages
-- **Pre-planning**: Requires analysis approach planning before execution
-- **Precise language**: Direct, accurate wording - no persuasive embellishment
-- **Output**: `.workflow/active/WFS-[id]/.chat/doc-analysis-[timestamp].md` (or `.scratchpad/` if no session)
-
-## Document Types Supported
-
-| Type | Focus Areas | Key Outputs |
-|------|-------------|-------------|
-| README | Purpose, setup, usage | Integration steps, quick-start guide |
-| API Documentation | Endpoints, parameters, responses | API usage patterns, integration points |
-| Research Paper | Methodology, findings, validity | Applicable techniques, implementation feasibility |
-| Specification | Requirements, standards, constraints | Compliance checklist, implementation requirements |
-| Tutorial | Learning path, examples, exercises | Key concepts, practical applications |
-| Architecture Docs | System design, components, patterns | Design decisions, integration points, trade-offs |
-
-## Best Practices
-
-1. **Scope Definition**: Clearly define what aspects to analyze before starting
-2. **Layered Reading**: Structure/Overview → Details → Critical Analysis → Synthesis
-3. **Evidence Trail**: Track section references for all extracted information
-4. **Gap Identification**: Note missing information or unclear sections explicitly
-5. **Actionable Output**: Focus on insights that inform decisions or actions

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

@@ -1,93 +0,0 @@
----
-name: plan
-description: Read-only architecture planning using Gemini/Qwen/Codex with strategic planning template for modification plans and impact analysis
-argument-hint: "[--tool codex|gemini|qwen] [--enhance] [--cd path] topic"
-allowed-tools: SlashCommand(*), Bash(*), Task(*)
----
-
-# CLI Mode: Plan (/cli:mode:plan)
-
-## Purpose
-
-Strategic software architecture planning template (`~/.claude/workflows/cli-templates/prompts/planning/01-plan-architecture-design.txt`).
-
-**Tool Selection**:
-- **gemini** (default) - Best for architecture planning
-- **qwen** - Fallback when Gemini unavailable
-- **codex** - Alternative for implementation planning
-
-## Parameters
-
-- `--tool <gemini|qwen|codex>` - Tool selection (default: gemini)
-- `--enhance` - Enhance task with `/enhance-prompt`
-- `--cd "path"` - Target directory for focused planning
-- `<planning-task>` (Required) - Architecture planning task or modification requirements
-
-## Tool Usage
-
-**Gemini** (Primary):
-```bash
---tool gemini  # or omit (default)
-```
-
-**Qwen** (Fallback):
-```bash
---tool qwen
-```
-
-**Codex** (Alternative):
-```bash
---tool codex
-```
-
-## Execution Flow
-
-Uses **cli-execution-agent** (default) for automated planning:
-
-```javascript
-Task(
-  subagent_type="cli-execution-agent",
-  description="Architecture planning with impact analysis",
-  prompt=`
-    Task: ${planning_task}
-    Mode: plan
-    Tool: ${tool_flag || 'gemini'}
-    Directory: ${cd_path || '.'}
-    Enhance: ${enhance_flag}
-    Template: ~/.claude/workflows/cli-templates/prompts/planning/01-plan-architecture-design.txt
-
-    Execute strategic architecture planning:
-
-    1. Context Discovery:
-       - Analyze current architecture structure
-       - Identify affected components and modules
-       - Map dependencies and integration points
-       - Assess modification impacts (scope, complexity, risks)
-
-    2. Planning Analysis:
-       - Apply strategic planning template
-       - Generate modification plan with phases
-       - Document architectural decisions and rationale
-       - Identify potential conflicts and mitigation strategies
-
-    3. CLI Command Construction:
-       - Tool: ${tool_flag || 'gemini'} (qwen fallback, codex for implementation guidance)
-       - Directory: cd ${cd_path || '.'} &&
-       - Context: @**/* (full architecture context)
-       - Mode: analysis (read-only, no code generation)
-       - Template: planning/01-plan-architecture-design.txt
-
-    4. Output Generation:
-       - Strategic modification plan
-       - Impact analysis and risk assessment
-       - Implementation roadmap
-       - Save to .workflow/active/WFS-[id]/.chat/plan-[timestamp].md (or .scratchpad/)
-  `
-)
-```
-
-## Core Rules
-
-- **Read-only**: Creates modification plans, does NOT generate code
-- **Template**: `~/.claude/workflows/cli-templates/prompts/planning/01-plan-architecture-design.txt`
-- **Output**: `.workflow/active/WFS-[id]/.chat/plan-[timestamp].md` (or `.scratchpad/` if no session)

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

@@ -143,68 +143,10 @@ Perform Deep Scan analysis for feature: {FEATURE_KEYWORD}
 - File Discovery: MCP Code Index (preferred) + rg fallback
 - Target: 5-15 most relevant files
 
-**Expected Output Format**:
-Return comprehensive analysis as structured JSON:
-{
-  \"feature\": \"{FEATURE_KEYWORD}\",
-  \"analysis_metadata\": {
-    \"tool_used\": \"gemini|qwen\",
-    \"timestamp\": \"ISO_TIMESTAMP\",
-    \"analysis_mode\": \"deep-scan\"
-  },
-  \"files_analyzed\": [
-    {\"file\": \"path/to/file.ts\", \"relevance\": \"high|medium|low\", \"role\": \"brief description\"}
-  ],
-  \"architecture\": {
-    \"overview\": \"High-level description\",
-    \"modules\": [
-      {\"name\": \"ModuleName\", \"file\": \"file:line\", \"responsibility\": \"description\", \"dependencies\": [...]}
-    ],
-    \"interactions\": [
-      {\"from\": \"ModuleA\", \"to\": \"ModuleB\", \"type\": \"import|call|data-flow\", \"description\": \"...\"}
-    ],
-    \"entry_points\": [
-      {\"function\": \"main\", \"file\": \"file:line\", \"description\": \"...\"}
-    ]
-  },
-  \"function_calls\": {
-    \"call_chains\": [
-      {
-        \"chain_id\": 1,
-        \"description\": \"User authentication flow\",
-        \"sequence\": [
-          {\"function\": \"login\", \"file\": \"file:line\", \"calls\": [\"validateCredentials\", \"createSession\"]}
-        ]
-      }
-    ],
-    \"sequences\": [
-      {\"from\": \"Client\", \"to\": \"AuthService\", \"method\": \"login(username, password)\", \"returns\": \"Session\"}
-    ]
-  },
-  \"data_flow\": {
-    \"structures\": [
-      {\"name\": \"UserData\", \"stage\": \"input\", \"shape\": {\"username\": \"string\", \"password\": \"string\"}}
-    ],
-    \"transformations\": [
-      {\"from\": \"RawInput\", \"to\": \"ValidatedData\", \"transformer\": \"validateUser\", \"file\": \"file:line\"}
-    ]
-  },
-  \"conditional_logic\": {
-    \"branches\": [
-      {\"condition\": \"isAuthenticated\", \"file\": \"file:line\", \"true_path\": \"...\", \"false_path\": \"...\"}
-    ],
-    \"error_handling\": [
-      {\"error_type\": \"AuthenticationError\", \"handler\": \"handleAuthError\", \"file\": \"file:line\", \"recovery\": \"retry|fail\"}
-    ]
-  },
-  \"design_patterns\": [
-    {\"pattern\": \"Repository Pattern\", \"location\": \"src/repositories\", \"description\": \"...\"}
-  ],
-  \"recommendations\": [
-    \"Consider extracting authentication logic into separate module\",
-    \"Add error recovery for network failures\"
-  ]
-}
+**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)

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

@@ -32,12 +32,16 @@ Identify inconsistencies, duplications, ambiguities, and underspecified items be
 IF --session parameter provided:
     session_id = provided session
 ELSE:
-    CHECK: find .workflow/active/ -name "WFS-*" -type d
-    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/active/WFS-{session}
@@ -45,13 +49,15 @@ brainstorm_dir = session_dir/.brainstorming
 task_dir = session_dir/.task
 
 # Validate required artifacts
-SYNTHESIS = brainstorm_dir/role analysis documents
+# 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: "role analysis documents 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):
@@ -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,7 +209,9 @@ 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
@@ -217,7 +225,11 @@ Output a Markdown report (no file writes) with the following structure:
 ### 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}
@@ -322,14 +334,27 @@ 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 TodoWrite to track all required fixes
-- Fix broken dependencies and circular references
+**Recommendation Decision Matrix**:
 
-**If Only HIGH/MEDIUM/LOW Issues**:
-- **PROCEED WITH CAUTION** - Fix high-priority issues first
-- Use TodoWrite to systematically track and complete all improvements
+| Condition | Recommendation | Action |
+|-----------|----------------|--------|
+| Critical > 0 | BLOCK_EXECUTION | Must resolve all critical issues before proceeding |
+| Critical = 0, High > 0 | PROCEED_WITH_FIXES | Fix high-priority issues before execution |
+| Critical = 0, High = 0, Medium > 0 | PROCEED_WITH_CAUTION | Proceed with awareness of medium issues |
+| Only Low or None | PROCEED | Safe to execute workflow |
+
+**If CRITICAL Issues Exist** (BLOCK_EXECUTION):
+- Resolve all critical issues before proceeding
+- Use TodoWrite to track required fixes
+- Fix broken dependencies and circular references first
+
+**If HIGH Issues Exist** (PROCEED_WITH_FIXES):
+- Fix high-priority issues before execution
+- Use TodoWrite to systematically track and complete improvements
+
+**If Only MEDIUM/LOW Issues** (PROCEED_WITH_CAUTION / PROCEED):
+- Can proceed with execution
+- Address issues during or after implementation
 
 #### TodoWrite-Based Remediation Workflow
 
@@ -359,13 +384,18 @@ Priority Order:
 
 ### 7. Save Report and Execute TodoWrite-Based Remediation
 
-**Save Analysis Report**:
+**Step 7.1: Save Analysis Report**:
 ```bash
 report_path = ".workflow/active/WFS-{session}/.process/ACTION_PLAN_VERIFICATION.md"
 Write(report_path, full_report_content)
 ```
 
-**After Report Generation**:
+**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

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

@@ -90,14 +90,15 @@ This workflow runs **fully autonomously** once triggered. Phase 1 (artifacts) ha
 **TodoWrite Update (Phase 1 SlashCommand invoked - tasks attached)**:
 ```json
 [
-  {"content": "Parse --count parameter from user input", "status": "completed", "activeForm": "Parsing count parameter"},
-  {"content": "Phase 1.1: Topic analysis and question generation (artifacts)", "status": "in_progress", "activeForm": "Analyzing topic"},
-  {"content": "Phase 1.2: Role selection and user confirmation (artifacts)", "status": "pending", "activeForm": "Selecting roles"},
-  {"content": "Phase 1.3: Role questions and user decisions (artifacts)", "status": "pending", "activeForm": "Collecting role questions"},
-  {"content": "Phase 1.4: Conflict detection and resolution (artifacts)", "status": "pending", "activeForm": "Resolving conflicts"},
-  {"content": "Phase 1.5: Guidance specification generation (artifacts)", "status": "pending", "activeForm": "Generating guidance"},
-  {"content": "Execute parallel role analysis", "status": "pending", "activeForm": "Executing parallel role analysis"},
-  {"content": "Execute synthesis integration", "status": "pending", "activeForm": "Executing synthesis integration"}
+  {"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"}
 ]
 ```
 
@@ -108,10 +109,10 @@ This workflow runs **fully autonomously** once triggered. Phase 1 (artifacts) ha
 **TodoWrite Update (Phase 1 completed - tasks collapsed)**:
 ```json
 [
-  {"content": "Parse --count parameter from user input", "status": "completed", "activeForm": "Parsing count parameter"},
-  {"content": "Execute artifacts interactive framework generation", "status": "completed", "activeForm": "Executing artifacts interactive framework"},
-  {"content": "Execute parallel role analysis", "status": "pending", "activeForm": "Executing parallel role analysis"},
-  {"content": "Execute synthesis integration", "status": "pending", "activeForm": "Executing synthesis integration"}
+  {"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"}
 ]
 ```
 
@@ -203,12 +204,13 @@ TOPIC: {user-provided-topic}
 **TodoWrite Update (Phase 2 agents invoked - tasks attached in parallel)**:
 ```json
 [
-  {"content": "Parse --count parameter from user input", "status": "completed", "activeForm": "Parsing count parameter"},
-  {"content": "Execute artifacts interactive framework generation", "status": "completed", "activeForm": "Executing artifacts interactive framework"},
-  {"content": "Phase 2.1: Execute system-architect analysis [conceptual-planning-agent]", "status": "in_progress", "activeForm": "Executing system-architect analysis"},
-  {"content": "Phase 2.2: Execute ui-designer analysis [conceptual-planning-agent]", "status": "in_progress", "activeForm": "Executing ui-designer analysis"},
-  {"content": "Phase 2.3: Execute product-manager analysis [conceptual-planning-agent]", "status": "in_progress", "activeForm": "Executing product-manager analysis"},
-  {"content": "Execute synthesis integration", "status": "pending", "activeForm": "Executing synthesis integration"}
+  {"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"}
 ]
 ```
 
@@ -219,10 +221,10 @@ TOPIC: {user-provided-topic}
 **TodoWrite Update (Phase 2 completed - tasks collapsed)**:
 ```json
 [
-  {"content": "Parse --count parameter from user input", "status": "completed", "activeForm": "Parsing count parameter"},
-  {"content": "Execute artifacts interactive framework generation", "status": "completed", "activeForm": "Executing artifacts interactive framework"},
-  {"content": "Execute parallel role analysis", "status": "completed", "activeForm": "Executing parallel role analysis"},
-  {"content": "Execute synthesis integration", "status": "pending", "activeForm": "Executing synthesis integration"}
+  {"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"}
 ]
 ```
 
@@ -251,12 +253,13 @@ TOPIC: {user-provided-topic}
 **TodoWrite Update (Phase 3 SlashCommand invoked - tasks attached)**:
 ```json
 [
-  {"content": "Parse --count parameter from user input", "status": "completed", "activeForm": "Parsing count parameter"},
-  {"content": "Execute artifacts interactive framework generation", "status": "completed", "activeForm": "Executing artifacts interactive framework"},
-  {"content": "Execute parallel role analysis", "status": "completed", "activeForm": "Executing parallel role analysis"},
-  {"content": "Phase 3.1: Load role analysis files (synthesis)", "status": "in_progress", "activeForm": "Loading role analyses"},
-  {"content": "Phase 3.2: Integrate insights across roles (synthesis)", "status": "pending", "activeForm": "Integrating insights"},
-  {"content": "Phase 3.3: Generate synthesis specification (synthesis)", "status": "pending", "activeForm": "Generating synthesis"}
+  {"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"}
 ]
 ```
 
@@ -267,10 +270,10 @@ TOPIC: {user-provided-topic}
 **TodoWrite Update (Phase 3 completed - tasks collapsed)**:
 ```json
 [
-  {"content": "Parse --count parameter from user input", "status": "completed", "activeForm": "Parsing count parameter"},
-  {"content": "Execute artifacts interactive framework generation", "status": "completed", "activeForm": "Executing artifacts interactive framework"},
-  {"content": "Execute parallel role analysis", "status": "completed", "activeForm": "Executing parallel role analysis"},
-  {"content": "Execute synthesis integration", "status": "completed", "activeForm": "Executing synthesis integration"}
+  {"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"}
 ]
 ```
 

.claude/commands/workflow/execute.md

@@ -16,9 +16,9 @@ Orchestrates autonomous workflow execution through systematic task discovery, ag
 **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 2 (task metadata, status, dependencies)
-- **IMPL_PLAN.md**: Read existence in Phase 2, parse execution strategy when needed
-- **Task JSONs**: Complete lazy loading (read only during execution)
+- **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.**
@@ -39,6 +39,48 @@ Orchestrates autonomous workflow execution through systematic task discovery, ag
 - **Progress tracking**: Continuous TodoWrite updates throughout entire workflow execution
 - **Autonomous completion**: Execute all tasks without user interruption until workflow complete
 
+## Execution Process
+
+```
+Normal Mode:
+Phase 1: Discovery
+   ├─ Count active sessions
+   └─ Decision:
+      ├─ count=0 → ERROR: No active sessions
+      ├─ count=1 → Auto-select session → Phase 2
+      └─ count>1 → AskUserQuestion (max 4 options) → Phase 2
+
+Phase 2: Planning Document Validation
+   ├─ Check IMPL_PLAN.md exists
+   ├─ Check TODO_LIST.md exists
+   └─ Validate .task/ contains IMPL-*.json files
+
+Phase 3: TodoWrite Generation
+   ├─ 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
+         └─ Advance to next task
+
+Phase 5: Completion
+   ├─ Update task statuses in JSON files
+   ├─ Generate summaries
+   └─ Auto-call /workflow:session:complete
+
+Resume Mode (--resume-session):
+   ├─ Skip Phase 1 & Phase 2
+   └─ Entry Point: Phase 3 (TodoWrite Generation)
+      └─ Continue: Phase 4 → Phase 5
+```
+
 ## Execution Lifecycle
 
 ### Phase 1: Discovery
@@ -81,16 +123,31 @@ bash(for dir in .workflow/active/WFS-*/; do
 done)
 ```
 
-Use AskUserQuestion to present formatted options:
-```
-Multiple active workflow sessions detected. Please select one:
+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)
 
-1. WFS-auth-system | Authentication System | 3/5 tasks (60%)
-2. WFS-payment-module | Payment Integration | 0/8 tasks (0%)
-
-Enter number, full session ID, or partial match:
+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
@@ -103,20 +160,19 @@ bash(cat .workflow/active/${sessionId}/workflow-session.json)
 
 **Resume Mode**: This entire phase is skipped when `--resume-session="session-id"` flag is provided.
 
-### Phase 2: Planning Document Analysis
+### Phase 2: Planning Document Validation
 **Applies to**: Normal mode only (skipped in resume mode)
 
-**Optimized to avoid reading all task JSONs upfront**
+**Purpose**: Validate planning artifacts exist before execution
 
 **Process**:
-1. **Check IMPL_PLAN.md**: Verify file exists and has valid structure (defer detailed parsing to Phase 4)
-2. **Read TODO_LIST.md**: Get current task statuses and execution progress
-3. **Extract Task Metadata**: Parse task IDs, titles, and dependency relationships from TODO_LIST.md
-4. **Build Execution Queue**: Determine ready tasks based on TODO_LIST.md status and dependencies
+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**: Use IMPL_PLAN.md (existence check only) and TODO_LIST.md as primary sources instead of reading all task JSONs. Detailed IMPL_PLAN.md parsing happens in Phase 4A.
+**Key Optimization**: Only existence checks here. Actual file reading happens in later phases.
 
-**Resume Mode**: When `--resume-session` flag is provided, **session discovery** (Phase 1) is skipped, but **task metadata loading** (TODO_LIST.md reading) still occurs in Phase 3 for TodoWrite generation.
+**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)
@@ -156,7 +212,7 @@ If IMPL_PLAN.md lacks execution strategy, use intelligent fallback (analyze task
 ```
 while (TODO_LIST.md has pending tasks) {
   next_task_id = getTodoWriteInProgressTask()
-  task_json = Read(.workflow/session/{session}/.task/{next_task_id}.json)  // Lazy load
+  task_json = Read(.workflow/active/{session}/.task/{next_task_id}.json)  // Lazy load
   executeTaskWithAgent(task_json)
   updateTodoListMarkCompleted(next_task_id)
   advanceTodoWriteToNextTask()

.claude/commands/workflow/init.md

@@ -20,9 +20,40 @@ Initialize `.workflow/project.json` with comprehensive project understanding by
 /workflow:init --regenerate    # Force regeneration
 ```
 
+## Execution Process
+
+```
+Input Parsing:
+   └─ Parse --regenerate flag → regenerate = true | false
+
+Decision:
+   ├─ EXISTS + 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.json
+   └─ Display summary
+
+Output:
+   └─ .workflow/project.json (+ .backup if regenerate)
+```
+
 ## Implementation
 
-### Step 1: Check Existing State
+### 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.json && echo "EXISTS" || echo "NOT_FOUND")
@@ -59,8 +90,9 @@ Task(
   prompt=`
 Analyze project for workflow initialization and generate .workflow/project.json.
 
-## Output Schema Reference
-~/.claude/workflows/cli-templates/schemas/project-json-schema.json
+## MANDATORY FIRST STEPS
+1. Execute: cat ~/.claude/workflows/cli-templates/schemas/project-json-schema.json (get schema reference)
+2. Execute: ~/.claude/scripts/get_modules_by_depth.sh (get project structure)
 
 ## Task
 Generate complete project.json with:

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

@@ -92,7 +92,7 @@ AskUserQuestion({
 
 **Trigger**: User calls with file path
 
-**Input**: Path to file containing task description or Enhanced Task JSON
+**Input**: Path to file containing task description or plan.json
 
 **Step 1: Read and Detect Format**
 
@@ -103,42 +103,30 @@ fileContent = Read(filePath)
 try {
   jsonData = JSON.parse(fileContent)
 
-  // Check if Enhanced Task JSON from lite-plan
-  if (jsonData.meta?.workflow === "lite-plan") {
-    // Extract plan data
-    planObject = {
-      summary: jsonData.context.plan.summary,
-      approach: jsonData.context.plan.approach,
-      tasks: jsonData.context.plan.tasks,
-      estimated_time: jsonData.meta.estimated_time,
-      recommended_execution: jsonData.meta.recommended_execution,
-      complexity: jsonData.meta.complexity
-    }
-    explorationContext = jsonData.context.exploration || null
-    clarificationContext = jsonData.context.clarifications || null
-    originalUserInput = jsonData.title
-
-    isEnhancedTaskJson = true
+  // 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 Enhanced Task JSON - treat as plain text
+    // Valid JSON but not plan.json - treat as plain text
     originalUserInput = fileContent
-    isEnhancedTaskJson = false
+    isPlanJson = false
   }
 } catch {
   // Not valid JSON - treat as plain text prompt
   originalUserInput = fileContent
-  isEnhancedTaskJson = false
+  isPlanJson = false
 }
 ```
 
 **Step 2: Create Execution Plan**
 
-If `isEnhancedTaskJson === true`:
-- Use extracted `planObject` directly
-- Skip planning, use lite-plan's existing plan
-- User still selects execution method and code review
+If `isPlanJson === true`:
+- Use `planObject` directly
+- User selects execution method and code review
 
-If `isEnhancedTaskJson === false`:
+If `isPlanJson === false`:
 - Treat file content as prompt (same behavior as Mode 2)
 - Create simple execution plan from content
 
@@ -150,26 +138,29 @@ If `isEnhancedTaskJson === false`:
 
 ## Execution Process
 
-### Workflow Overview
-
 ```
-Input Processing → Mode Detection
-    |
-    v
-[Mode 1] --in-memory: Load executionContext → Skip selection
-[Mode 2] Prompt: Create plan → User selects method + review
-[Mode 3] File: Detect format → Extract plan OR treat as prompt → User selects
-    |
-    v
-Execution & Progress Tracking
-    ├─ Step 1: Initialize execution tracking
-    ├─ Step 2: Create TodoWrite execution list
-    ├─ Step 3: Launch execution (Agent or Codex)
-    ├─ Step 4: Track execution progress
-    └─ Step 5: Code review (optional)
-    |
-    v
-Execution Complete
+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
+   │   ├─ Infer dependencies (same file → sequential, keywords → sequential)
+   │   ├─ Group into batches (parallel: independent, sequential: dependent)
+   │   └─ Create TodoWrite list for batches
+   ├─ Step 3: Launch execution
+   │   ├─ Phase 1: All parallel batches (⚡ concurrent via multiple tool calls)
+   │   └─ Phase 2: Sequential batches (→ one by one)
+   ├─ 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
@@ -336,18 +327,35 @@ Outputs: ${result.keyOutputs || 'See git diff'}
 ${result.notes ? `Notes: ${result.notes}` : ''}
   `).join('\n---\n')}` : ''}
 
-  ## Code Context
-  ${explorationContext || "No exploration performed"}
+  ## Multi-Angle Code Context
+
+  ${explorationsContext && Object.keys(explorationsContext).length > 0 ?
+    explorationAngles.map(angle => {
+      const exp = explorationsContext[angle]
+      return `### Exploration Angle: ${angle}
+
+**Project Structure**: ${exp.project_structure || 'N/A'}
+**Relevant Files**: ${exp.relevant_files?.join(', ') || 'None'}
+**Patterns**: ${exp.patterns || 'N/A'}
+**Dependencies**: ${exp.dependencies || 'N/A'}
+**Integration Points**: ${exp.integration_points || 'N/A'}
+**Constraints**: ${exp.constraints || 'N/A'}`
+    }).join('\n\n---\n\n')
+    : "No exploration performed"
+  }
 
   ${clarificationContext ? `\n## Clarifications\n${JSON.stringify(clarificationContext, null, 2)}` : ''}
 
-  ${executionContext?.session?.artifacts ? `\n## Planning Artifacts
-  Detailed planning context available in:
-  ${executionContext.session.artifacts.exploration ? `- Exploration: ${executionContext.session.artifacts.exploration}` : ''}
-  - Plan: ${executionContext.session.artifacts.plan}
-  - Task: ${executionContext.session.artifacts.task}
+  ${executionContext?.session?.artifacts ? `\n## Exploration Artifact Files
 
-  Read these files for detailed architecture, patterns, and constraints.` : ''}
+  Detailed exploration context available in:
+  ${executionContext.session.artifacts.explorations?.map(exp =>
+    `- Angle: ${exp.angle} → ${exp.path}`
+  ).join('\n') || ''}
+  ${executionContext.session.artifacts.explorations_manifest ? `- Manifest: ${executionContext.session.artifacts.explorations_manifest}` : ''}
+  - Plan: ${executionContext.session.artifacts.plan}
+
+  Read exploration files for comprehensive context from multiple angles.` : ''}
 
   ## Requirements
   MUST complete ALL ${planObject.tasks.length} tasks listed above in this single execution.
@@ -407,24 +415,34 @@ ${result.notes ? `Notes: ${result.notes}` : ''}
 IMPORTANT: Review previous results. Build on completed work. Avoid duplication.
 ` : ''}
 
-### Code Context from Exploration
-${explorationContext ? `
-Project Structure: ${explorationContext.project_structure || 'Standard structure'}
-Relevant Files: ${explorationContext.relevant_files?.join(', ') || 'TBD'}
-Current Patterns: ${explorationContext.patterns || 'Follow existing conventions'}
-Integration Points: ${explorationContext.dependencies || 'None specified'}
-Constraints: ${explorationContext.constraints || 'None'}
-` : 'No prior exploration - analyze codebase as needed'}
+### Multi-Angle Code Context
+
+${explorationsContext && Object.keys(explorationsContext).length > 0 ?
+  `Exploration conducted from ${explorationAngles.length} angles:
+
+${explorationAngles.map(angle => {
+  const exp = explorationsContext[angle]
+  return `Angle: ${angle}
+- Structure: ${exp.project_structure || 'Standard structure'}
+- Files: ${exp.relevant_files?.slice(0, 5).join(', ') || 'TBD'}${exp.relevant_files?.length > 5 ? ` (+${exp.relevant_files.length - 5} more)` : ''}
+- Patterns: ${exp.patterns?.substring(0, 100) || 'Follow existing'}${exp.patterns?.length > 100 ? '...' : ''}
+- Constraints: ${exp.constraints || 'None'}`
+}).join('\n\n')}
+`
+  : 'No prior exploration - analyze codebase as needed'
+}
 
 ${clarificationContext ? `\n### User Clarifications\n${Object.entries(clarificationContext).map(([q, a]) => `${q}: ${a}`).join('\n')}` : ''}
 
-${executionContext?.session?.artifacts ? `\n### Planning Artifact Files
-Detailed planning context available in session folder:
-${executionContext.session.artifacts.exploration ? `- Exploration: ${executionContext.session.artifacts.exploration}` : ''}
+${executionContext?.session?.artifacts ? `\n### Exploration Artifact Files
+Detailed context from multiple exploration angles available in:
+${executionContext.session.artifacts.explorations?.map(exp =>
+  `- Angle: ${exp.angle} → ${exp.path}`
+).join('\n') || ''}
+${executionContext.session.artifacts.explorations_manifest ? `- Manifest: ${executionContext.session.artifacts.explorations_manifest}` : ''}
 - Plan: ${executionContext.session.artifacts.plan}
-- Task: ${executionContext.session.artifacts.task}
 
-Read these files for complete architecture details, code patterns, and integration constraints.
+Read exploration files for comprehensive architectural, pattern, and constraint details from multiple angles.
 ` : ''}
 
 ## Requirements
@@ -438,9 +456,16 @@ Complexity: ${planObject.complexity}
 **Execution with tracking**:
 ```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
+}
+
 bash_result = Bash(
   command=cli_command,
-  timeout=600000  // 10 minutes
+  timeout=timeoutByComplexity[planObject.complexity] || 3600000
 )
 
 // Update TodoWrite when execution completes
@@ -456,58 +481,57 @@ Progress tracked at batch level (not individual task level). Icons: ⚡ (paralle
 
 **Skip Condition**: Only run if `codeReviewTool ≠ "Skip"`
 
-**Review Focus**: Verify implementation against task.json acceptance criteria
-- Read task.json from session artifacts for acceptance criteria
+**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 (read task.json for acceptance criteria)
-- Gemini Review: Execute gemini CLI with review prompt (task.json in CONTEXT)
-- Custom tool: Execute specified CLI tool (qwen, codex, etc.) with task.json reference
+- 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 task.json `context.acceptance`
+- **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 task.json acceptance criteria
-TASK: • Verify task.json acceptance criteria fulfillment • Analyze code quality • Identify issues • Suggest improvements • Validate plan adherence
+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: @**/* @{task.json} @{plan.json} [@{exploration.json}] | Memory: Review lite-execute changes against task.json requirements
-EXPECTED: Quality assessment with acceptance criteria verification, issue identification, and recommendations. Explicitly check each acceptance criterion from task.json.
-RULES: $(cat ~/.claude/workflows/cli-templates/prompts/analysis/02-review-code-quality.txt) | Focus on task.json acceptance criteria and plan adherence | analysis=READ-ONLY
+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 task.json: ${executionContext.session.artifacts.task}
+# - Read plan.json: ${executionContext.session.artifacts.plan}
 # - Apply unified review criteria (see Shared Prompt Template)
 # - Report findings directly
 
 # Method 2: Gemini Review (recommended)
 gemini -p "[Shared Prompt Template with artifacts]"
-# CONTEXT includes: @**/* @${task.json} @${plan.json} [@${exploration.json}]
+# CONTEXT includes: @**/* @${plan.json} [@${exploration.json}]
 
 # Method 3: Qwen Review (alternative)
 qwen -p "[Shared Prompt Template with artifacts]"
 # Same prompt as Gemini, different execution engine
 
 # Method 4: Codex Review (autonomous)
-codex --full-auto exec "[Verify task.json acceptance criteria at ${task.json}]" --skip-git-repo-check -s danger-full-access
+codex --full-auto exec "[Verify plan acceptance criteria at ${plan.json}]" --skip-git-repo-check -s danger-full-access
 ```
 
 **Implementation Note**: Replace `[Shared Prompt Template with artifacts]` placeholder with actual template content, substituting:
-- `@{task.json}` → `@${executionContext.session.artifacts.task}`
 - `@{plan.json}` → `@${executionContext.session.artifacts.plan}`
-- `[@{exploration.json}]` → `@${executionContext.session.artifacts.exploration}` (if exists)
+- `[@{exploration.json}]` → exploration files from artifacts (if exists)
 
 ## Best Practices
 
@@ -543,7 +567,9 @@ Passed from lite-plan via global variable:
     recommended_execution: string,
     complexity: string
   },
-  explorationContext: {...} | null,
+  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,
@@ -554,9 +580,9 @@ Passed from lite-plan via global variable:
     id: string,                        // Session identifier: {taskSlug}-{shortTimestamp}
     folder: string,                    // Session folder path: .workflow/.lite-plan/{session-id}
     artifacts: {
-      exploration: string | null,      // exploration.json path (if exploration performed)
-      plan: string,                    // plan.json path (always present)
-      task: string                     // task.json path (always exported)
+      explorations: [{angle, path}],   // exploration-{angle}.json paths
+      explorations_manifest: string,   // explorations-manifest.json path
+      plan: string                     // plan.json path (always present)
     }
   }
 }

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

@@ -52,14 +52,42 @@ Fast-track bug fixing workflow optimized for quick diagnosis, targeted fixes, an
 
 ## Execution Process
 
-### Workflow Overview
-
 ```
-Bug Input → Diagnosis (Phase 1) → Impact Assessment (Phase 2)
-        ↓
-    Severity Auto-Detection → Fix Planning (Phase 3)
-        ↓
-    Verification Strategy (Phase 4) → User Confirmation (Phase 5) → Execution (Phase 6)
+Input Parsing:
+   └─ Parse flags: --hotfix → hotfixMode = true | false
+
+Phase 1: Diagnosis & Root Cause Analysis
+   └─ Decision (confidence-based):
+      ├─ High confidence (specific error) → Direct grep search (5min)
+      ├─ Medium confidence → cli-explore-agent focused search (10-15min)
+      └─ Low confidence (vague) → cli-explore-agent broad search (20min)
+   └─ Hotfix mode: Minimal search (Read suspected file + git blame)
+
+Phase 2: Impact Assessment & Severity Auto-Detection
+   └─ Calculate risk_score → Auto-determine severity
+      ├─ ≥8.0 → critical
+      ├─ ≥5.0 → high
+      ├─ ≥3.0 → medium
+      └─ <3.0 → low
+   └─ Hotfix mode: Skip, assume critical
+
+Phase 3: Fix Planning & Strategy Selection
+   └─ Decision (by risk score):
+      ├─ risk_score ≥5.0 or hotfix → Single best strategy (fastest)
+      └─ risk_score <5.0 → Multiple strategy options for user selection
+
+Phase 4: Verification Strategy
+   └─ Select test scope by risk score
+   └─ Define branch strategy (feature vs hotfix)
+
+Phase 5: User Confirmation
+   └─ Default mode: 3 dimensions (approach, execution, verification)
+   └─ Hotfix mode: 2 dimensions (deploy confirmation, monitoring)
+
+Phase 6: Execution Dispatch
+   ├─ Export Enhanced Task JSON
+   ├─ Dispatch to lite-execute --in-memory
+   └─ Hotfix mode: Generate follow-up tasks
 ```
 
 ### Phase Summary
@@ -77,6 +105,14 @@ Bug Input → Diagnosis (Phase 1) → Impact Assessment (Phase 2)
 
 ## Detailed Phase Execution
 
+### Input Parsing
+
+**Parse --hotfix flag**:
+```javascript
+const hotfixMode = $ARGUMENTS.includes('--hotfix') || $ARGUMENTS.includes('-h')
+const bugDescription = $ARGUMENTS.replace(/--hotfix|-h/g, '').trim()
+```
+
 ### Phase 1: Diagnosis & Root Cause Analysis
 
 **Goal**: Identify root cause and affected code paths
@@ -480,7 +516,6 @@ if (mode === "hotfix") {
   - Location: ${sessionFolder}/followup.json
   `)
 }
-}
 ```
 
 **TodoWrite**: Mark Phase 6 completed

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

@@ -34,20 +34,41 @@ Intelligent lightweight planning command with dynamic workflow adaptation based
 ## Execution Process
 
 ```
-User Input → Task Analysis & Exploration Decision (Phase 1)
-          ↓
-     Clarification (Phase 2, optional)
-          ↓
-     Complexity Assessment & Planning (Phase 3)
-          ↓
-     Task Confirmation & Execution Selection (Phase 4)
-          ↓
-     Dispatch to Execution (Phase 5)
+Phase 1: Task Analysis & Exploration
+   ├─ Parse input (description or .md file)
+   ├─ Claude intelligent complexity assessment (Low/Medium/High)
+   ├─ Exploration decision (auto-detect or --explore flag)
+   └─ Decision:
+      ├─ needsExploration=true → Launch parallel cli-explore-agents (1-4 based on complexity)
+      └─ needsExploration=false → Skip to Phase 2/3
+
+Phase 2: Clarification (optional)
+   ├─ Aggregate clarification_needs from all exploration angles
+   ├─ Deduplicate similar questions
+   └─ Decision:
+      ├─ Has clarifications → AskUserQuestion (max 4 questions)
+      └─ No clarifications → Skip to Phase 3
+
+Phase 3: Planning
+   └─ Decision (based on Phase 1 complexity):
+      ├─ Low → Direct Claude planning → plan.json
+      └─ Medium/High → cli-lite-planning-agent → plan.json
+
+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: Dispatch
+   ├─ Build executionContext (plan + explorations + clarifications + selections)
+   └─ SlashCommand("/workflow:lite-execute --in-memory")
 ```
 
 ## Implementation
 
-### Phase 1: Task Analysis & Exploration Decision
+### Phase 1: Intelligent Multi-Angle Exploration
 
 **Session Setup**:
 ```javascript
@@ -60,7 +81,7 @@ const sessionFolder = `.workflow/.lite-plan/${sessionId}`
 bash(`mkdir -p ${sessionFolder}`)
 ```
 
-**Decision Logic**:
+**Exploration Decision Logic**:
 ```javascript
 needsExploration = (
   flags.includes('--explore') || flags.includes('-e') ||
@@ -69,62 +90,228 @@ needsExploration = (
   task.needs_architecture_understanding ||
   task.modifies_existing_code
 )
+
+if (!needsExploration) {
+  // Skip to Phase 2 (Clarification) or Phase 3 (Planning)
+  proceed_to_next_phase()
+}
 ```
 
-**If exploration needed** - Invoke cli-explore-agent:
+**Complexity Assessment** (Claude Intelligent Analysis):
+```javascript
+// Claude 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))
+
+console.log(`
+## Exploration Plan
+
+Task Complexity: ${complexity}
+Selected Angles: ${selectedAngles.join(', ')}
+
+Launching ${selectedAngles.length} parallel explorations...
+`)
+```
+
+**Launch Parallel Explorations** - Orchestrator assigns angle to each agent:
 
 ```javascript
-Task(
-  subagent_type="cli-explore-agent",
-  description="Analyze codebase for task context",
-  prompt=`
-Analyze codebase for task context and generate exploration.json.
+// Launch agents with pre-assigned angles
+const explorationTasks = selectedAngles.map((angle, index) =>
+  Task(
+    subagent_type="cli-explore-agent",
+    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.
 
-## Output Schema Reference
-~/.claude/workflows/cli-templates/schemas/explore-json-schema.json
+## Assigned Context
+- **Exploration Angle**: ${angle}
+- **Task Description**: ${task_description}
+- **Exploration Index**: ${index + 1} of ${selectedAngles.length}
+- **Output File**: ${sessionFolder}/exploration-${angle}.json
 
-## Task Description
-${task_description}
+## MANDATORY FIRST STEPS (Execute by Agent)
+**You (cli-explore-agent) MUST execute these steps in order:**
+1. Run: ~/.claude/scripts/get_modules_by_depth.sh (project structure)
+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)
 
-## Requirements
-Generate exploration.json with:
-- project_structure: Architecture and module organization
-- relevant_files: File paths to be affected
-- patterns: Code patterns, conventions, styles
-- dependencies: External/internal module dependencies
-- integration_points: Task connections with existing code
-- constraints: Technical limitations/requirements
-- clarification_needs: Ambiguities requiring user input
-- _metadata: timestamp, task_description, source
+## Exploration Strategy (${angle} focus)
 
-## Execution
-1. Structural scan: get_modules_by_depth.sh, find, rg
-2. Semantic analysis: Gemini for patterns/architecture
-3. Write JSON: Write('${sessionFolder}/exploration.json', jsonContent)
-4. Return brief completion summary
+**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
 
-Time Limit: 60 seconds
+**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
+- patterns: ${angle}-related patterns to follow
+- dependencies: Dependencies relevant to ${angle}
+- integration_points: Where to integrate from ${angle} viewpoint
+- constraints: ${angle}-specific limitations/conventions
+- clarification_needs: ${angle}-related ambiguities (with options array)
+- _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 array
+
+## Output
+Write: ${sessionFolder}/exploration-${angle}.json
+Return: 2-3 sentence summary of ${angle} findings
 `
+  )
 )
+
+// Execute all exploration tasks in parallel
 ```
 
-**Output**: `${sessionFolder}/exploration.json` (if exploration performed)
+**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: new Date().toISOString(),
+  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)
 
-**Skip if**: No exploration or `clarification_needs` is empty
+**Skip if**: No exploration or `clarification_needs` is empty across all explorations
 
-**If clarification needed**:
+**Aggregate clarification needs from all exploration angles**:
 ```javascript
-const exploration = JSON.parse(Read(`${sessionFolder}/exploration.json`))
+// 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))
+}))
 
-if (exploration.clarification_needs?.length > 0) {
+// 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
+      })
+    })
+  }
+})
+
+// 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)
+
+if (uniqueClarifications.length > 0) {
   AskUserQuestion({
-    questions: exploration.clarification_needs.map(need => ({
-      question: `${need.context}\n\n${need.question}`,
-      header: "Clarification",
+    questions: uniqueClarifications.map(need => ({
+      question: `[${need.source_angle}] ${need.question}\n\nContext: ${need.context}`,
+      header: need.source_angle,
       multiSelect: false,
       options: need.options.map(opt => ({
         label: opt,
@@ -139,19 +326,9 @@ if (exploration.clarification_needs?.length > 0) {
 
 ---
 
-### Phase 3: Complexity Assessment & Planning
+### Phase 3: Planning
 
-**Complexity Assessment**:
-```javascript
-complexityScore = {
-  file_count: exploration?.relevant_files?.length || 0,
-  integration_points: exploration?.dependencies?.length || 0,
-  architecture_changes: exploration?.constraints?.includes('architecture'),
-  task_scope: estimated_steps > 5
-}
-
-// Low: score < 3, Medium: 3-5, High: > 5
-```
+**Planning Strategy Selection** (based on Phase 1 complexity):
 
 **Low Complexity** - Direct planning by Claude:
 - Generate plan directly, write to `${sessionFolder}/plan.json`
@@ -167,13 +344,22 @@ Task(
 Generate implementation plan and write plan.json.
 
 ## Output Schema Reference
-~/.claude/workflows/cli-templates/schemas/plan-json-schema.json
+Execute: cat ~/.claude/workflows/cli-templates/schemas/plan-json-schema.json (get schema reference before generating plan)
 
 ## Task Description
 ${task_description}
 
-## Exploration Context
-${sessionFolder}/exploration.json (if exists)
+## 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"}
@@ -184,20 +370,24 @@ ${complexity}
 ## Requirements
 Generate plan.json with:
 - summary: 2-3 sentence overview
-- approach: High-level implementation strategy
+- approach: High-level implementation strategy (incorporating insights from all exploration angles)
 - tasks: 3-10 structured tasks with:
   - title, file, action, description
   - implementation (3-7 steps)
   - reference (pattern, files, examples)
   - acceptance (2-4 criteria)
 - estimated_time, recommended_execution, complexity
-- _metadata: timestamp, source, planning_mode
+- _metadata:
+  - timestamp, source, planning_mode
+  - exploration_angles: ${JSON.stringify(manifest.explorations.map(e => e.angle))}
 
 ## Execution
-1. Execute CLI planning using Gemini (Qwen fallback)
-2. Parse output and structure plan
-3. Write JSON: Write('${sessionFolder}/plan.json', jsonContent)
-4. Return brief completion summary
+1. Read ALL exploration files for comprehensive context
+2. Execute CLI planning using Gemini (Qwen fallback)
+3. Synthesize findings from multiple exploration angles
+4. Parse output and structure plan
+5. Write JSON: Write('${sessionFolder}/plan.json', jsonContent)
+6. Return brief completion summary
 `
 )
 ```
@@ -269,54 +459,26 @@ AskUserQuestion({
 
 ### Phase 5: Dispatch to Execution
 
-**Step 5.1: Generate task.json** (by command, not agent)
+**Step 5.1: Build executionContext**
 
 ```javascript
-const taskId = `LP-${shortTimestamp}`
-const exploration = file_exists(`${sessionFolder}/exploration.json`)
-  ? JSON.parse(Read(`${sessionFolder}/exploration.json`))
-  : null
+// 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`))
 
-const taskJson = {
-  id: taskId,
-  title: task_description,
-  status: "pending",
-
-  meta: {
-    type: "planning",
-    created_at: new Date().toISOString(),
-    complexity: plan.complexity,
-    estimated_time: plan.estimated_time,
-    recommended_execution: plan.recommended_execution,
-    workflow: "lite-plan",
-    session_id: sessionId,
-    session_folder: sessionFolder
-  },
-
-  context: {
-    requirements: [task_description],
-    plan: {
-      summary: plan.summary,
-      approach: plan.approach,
-      tasks: plan.tasks
-    },
-    exploration: exploration,
-    clarifications: clarificationContext || null,
-    focus_paths: exploration?.relevant_files || [],
-    acceptance: plan.tasks.flatMap(t => t.acceptance)
-  }
-}
-
-Write(`${sessionFolder}/task.json`, JSON.stringify(taskJson, null, 2))
-```
-
-**Step 5.2: Store executionContext**
-
-```javascript
 executionContext = {
   planObject: plan,
-  explorationContext: exploration,
+  explorationsContext: explorations,
+  explorationAngles: manifest.explorations.map(e => e.angle),
+  explorationManifest: manifest,
   clarificationContext: clarificationContext || null,
   executionMethod: userSelection.execution_method,
   codeReviewTool: userSelection.code_review_tool,
@@ -325,15 +487,18 @@ executionContext = {
     id: sessionId,
     folder: sessionFolder,
     artifacts: {
-      exploration: exploration ? `${sessionFolder}/exploration.json` : null,
-      plan: `${sessionFolder}/plan.json`,
-      task: `${sessionFolder}/task.json`
+      explorations: manifest.explorations.map(exp => ({
+        angle: exp.angle,
+        path: exp.path
+      })),
+      explorations_manifest: `${sessionFolder}/explorations-manifest.json`,
+      plan: `${sessionFolder}/plan.json`
     }
   }
 }
 ```
 
-**Step 5.3: Dispatch**
+**Step 5.2: Dispatch**
 
 ```javascript
 SlashCommand(command="/workflow:lite-execute --in-memory")
@@ -343,9 +508,22 @@ SlashCommand(command="/workflow:lite-execute --in-memory")
 
 ```
 .workflow/.lite-plan/{task-slug}-{timestamp}/
-├── exploration.json    # If exploration performed (by cli-explore-agent)
-├── plan.json           # Always created (by agent or direct planning)
-└── task.json           # Always created (by command)
+├── 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

.claude/commands/workflow/plan.md

@@ -46,6 +46,36 @@ This workflow runs **fully autonomously** once triggered. Phase 3 (conflict reso
 6. **Task Attachment Model**: SlashCommand invocation **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 (conditional)
+   └─ 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 [--cli-execute]
+      └─ Output: IMPL_PLAN.md, task JSONs, TODO_LIST.md
+
+Return:
+   └─ Summary with recommended next steps
+```
+
 ## 5-Phase Execution
 
 ### Phase 1: Session Discovery
@@ -100,11 +130,12 @@ CONTEXT: Existing user database schema, REST API endpoints
 **TodoWrite Update (Phase 2 SlashCommand invoked - tasks attached)**:
 ```json
 [
-  {"content": "Execute session discovery", "status": "completed", "activeForm": "Executing session discovery"},
-  {"content": "Phase 2.1: Analyze codebase structure (context-gather)", "status": "in_progress", "activeForm": "Analyzing codebase structure"},
-  {"content": "Phase 2.2: Identify integration points (context-gather)", "status": "pending", "activeForm": "Identifying integration points"},
-  {"content": "Phase 2.3: Generate context package (context-gather)", "status": "pending", "activeForm": "Generating context package"},
-  {"content": "Execute task generation", "status": "pending", "activeForm": "Executing task generation"}
+  {"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"}
 ]
 ```
 
@@ -115,9 +146,9 @@ CONTEXT: Existing user database schema, REST API endpoints
 **TodoWrite Update (Phase 2 completed - tasks collapsed)**:
 ```json
 [
-  {"content": "Execute session discovery", "status": "completed", "activeForm": "Executing session discovery"},
-  {"content": "Execute context gathering", "status": "completed", "activeForm": "Executing context gathering"},
-  {"content": "Execute task generation", "status": "pending", "activeForm": "Executing task generation"}
+  {"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"}
 ]
 ```
 
@@ -154,12 +185,13 @@ CONTEXT: Existing user database schema, REST API endpoints
 **TodoWrite Update (Phase 3 SlashCommand invoked - tasks attached, if conflict_risk ≥ medium)**:
 ```json
 [
-  {"content": "Execute session discovery", "status": "completed", "activeForm": "Executing session discovery"},
-  {"content": "Execute context gathering", "status": "completed", "activeForm": "Executing context gathering"},
-  {"content": "Phase 3.1: Detect conflicts with CLI analysis (conflict-resolution)", "status": "in_progress", "activeForm": "Detecting conflicts"},
-  {"content": "Phase 3.2: Present conflicts to user (conflict-resolution)", "status": "pending", "activeForm": "Presenting conflicts"},
-  {"content": "Phase 3.3: Apply resolution strategies (conflict-resolution)", "status": "pending", "activeForm": "Applying resolution strategies"},
-  {"content": "Execute task generation", "status": "pending", "activeForm": "Executing task generation"}
+  {"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"}
 ]
 ```
 
@@ -170,10 +202,10 @@ CONTEXT: Existing user database schema, REST API endpoints
 **TodoWrite Update (Phase 3 completed - tasks collapsed)**:
 ```json
 [
-  {"content": "Execute session discovery", "status": "completed", "activeForm": "Executing session discovery"},
-  {"content": "Execute context gathering", "status": "completed", "activeForm": "Executing context gathering"},
-  {"content": "Resolve conflicts and apply fixes", "status": "completed", "activeForm": "Resolving conflicts"},
-  {"content": "Execute task generation", "status": "pending", "activeForm": "Executing task generation"}
+  {"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"}
 ]
 ```
 
@@ -243,9 +275,9 @@ SlashCommand(command="/workflow:tools:task-generate-agent --session [sessionId]
 **TodoWrite Update (Phase 4 SlashCommand invoked - agent task attached)**:
 ```json
 [
-  {"content": "Execute session discovery", "status": "completed", "activeForm": "Executing session discovery"},
-  {"content": "Execute context gathering", "status": "completed", "activeForm": "Executing context gathering"},
-  {"content": "Execute task-generate-agent", "status": "in_progress", "activeForm": "Executing task-generate-agent"}
+  {"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"}
 ]
 ```
 
@@ -256,9 +288,9 @@ SlashCommand(command="/workflow:tools:task-generate-agent --session [sessionId]
 **TodoWrite Update (Phase 4 completed)**:
 ```json
 [
-  {"content": "Execute session discovery", "status": "completed", "activeForm": "Executing session discovery"},
-  {"content": "Execute context gathering", "status": "completed", "activeForm": "Executing context gathering"},
-  {"content": "Execute task-generate-agent", "status": "completed", "activeForm": "Executing task-generate-agent"}
+  {"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"}
 ]
 ```
 
@@ -396,29 +428,28 @@ Phase 1: Session Discovery
   → sessionId extracted
   ↓
 Phase 2: Context Gathering (SlashCommand invoked)
-  → ATTACH 3 tasks: ← ATTACHED
-    - Phase 2.1: Analyze codebase structure
-    - Phase 2.2: Identify integration points
-    - Phase 2.3: Generate context package
-  → Execute Phase 2.1-2.3
+  → 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 invoked)
-  │     → ATTACH 3 tasks: ← ATTACHED
-  │       - Phase 3.1: Detect conflicts with CLI analysis
-  │       - Phase 3.2: Present conflicts to user
-  │       - Phase 3.3: Apply resolution strategies
-  │     → Execute Phase 3.1-3.3
+  │     → 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 invoked)
-  → ATTACH 1 agent task: ← ATTACHED
-    - Execute task-generate-agent
+  → Single agent task (no sub-tasks)
   → Agent autonomously completes internally:
     (discovery → planning → output)
   → Outputs: IMPL_PLAN.md, IMPL-*.json, TODO_LIST.md

.claude/commands/workflow/replan.md

@@ -48,8 +48,54 @@ Intelligently replans workflow sessions or individual tasks with interactive bou
 /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**:
@@ -97,11 +143,10 @@ Options: Dynamically generated from existing tasks' focus_paths
 **Q3: Task Changes** (if scope >= task_restructure)
 ```javascript
 Options:
-- 添加新任务
-- 删除现有任务
-- 合并任务
-- 拆分任务
-- 仅更新内容
+- 添加/删除任务 (add_remove)
+- 合并/拆分任务 (merge_split)
+- 仅更新内容 (update_only)
+// Note: Max 4 options for AskUserQuestion
 ```
 
 **Q4: Dependency Changes**

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

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

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

@@ -0,0 +1,795 @@
+---
+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. **Real-time Visibility**: JSON-based progress tracking with interactive HTML dashboard
+6. **Unified Archive**: Review results archived with session for historical reference
+
+### Orchestrator Boundary (CRITICAL)
+- **ONLY command** for independent multi-dimensional module review
+- Manages: dimension coordination, aggregation, iteration control, progress tracking
+- Delegates: Code exploration and analysis to @cli-explore-agent, dimension-specific reviews via Deep Scan mode
+- **⚠️ DASHBOARD CONSTRAINT**: Dashboard is generated ONCE during Phase 1 initialization. After initialization, orchestrator and agents MUST NOT read, write, or modify dashboard.html - it remains static for user interaction only.
+
+## How It Works
+
+### Execution Flow
+
+```
+Phase 1: Discovery & Initialization
+   └─ Resolve file patterns, validate paths, initialize state, create output structure → Generate dashboard.html
+
+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 → Output dashboard path
+```
+
+### 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
+SlashCommand(command="/workflow:session:start \"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 dashboard polling
+
+**Step 5: Dashboard Generation**
+
+**Constraints**:
+- **MANDATORY**: Dashboard MUST be generated from template: `~/.claude/templates/review-cycle-dashboard.html`
+- **PROHIBITED**: Direct creation or custom generation without template
+- **POST-GENERATION**: Orchestrator and agents MUST NOT read/write/modify dashboard.html after creation
+
+**Generation Commands** (3 independent steps):
+```bash
+# Step 1: Copy template to output location
+cp ~/.claude/templates/review-cycle-dashboard.html ${sessionDir}/.review/dashboard.html
+
+# Step 2: Replace SESSION_ID placeholder
+sed -i "s|{{SESSION_ID}}|${sessionId}|g" ${sessionDir}/.review/dashboard.html
+
+# Step 3: Replace REVIEW_TYPE placeholder
+sed -i "s|{{REVIEW_TYPE}}|module|g" ${sessionDir}/.review/dashboard.html
+
+# Step 4: Replace REVIEW_DIR placeholder
+sed -i "s|{{REVIEW_DIR}}|${reviewDir}|g" ${sessionDir}/.review/dashboard.html
+
+# Output: Start local server and output dashboard URL
+# Use Python HTTP server (available on most systems)
+cd ${sessionDir}/.review && python -m http.server 8765 --bind 127.0.0.1 &
+echo "📊 Dashboard: http://127.0.0.1:8765/dashboard.html"
+echo "   (Press Ctrl+C to stop server when done)"
+```
+
+**Step 6: TodoWrite Initialization**
+- 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: Dashboard path to user
+
+
+
+### 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
+│   └── ...
+└── dashboard.html                       # Interactive dashboard (primary output)
+```
+
+**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",
+  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)
+
+    ## 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",
+  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)
+
+    ## 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
+6. **Dashboard Polling**: Refresh every 5 seconds for real-time updates
+7. **Export Results**: Use dashboard export for external tracking tools
+
+## Related Commands
+
+### Automated Fix Workflow
+After completing a module review, use the dashboard to select findings and export them for automated fixing:
+
+```bash
+# Step 1: Complete review (this command)
+/workflow:review-module-cycle src/auth/**
+
+# Step 2: Open dashboard, select findings, and export
+# Dashboard generates: fix-export-{timestamp}.json
+
+# Step 3: Run automated fixes
+/workflow:review-fix .workflow/active/WFS-{session-id}/.review/fix-export-{timestamp}.json
+```
+
+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,805 @@
+---
+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
+4. **Real-time Visibility**: JSON-based progress tracking with interactive HTML dashboard
+
+### Orchestrator Boundary (CRITICAL)
+- **ONLY command** for comprehensive multi-dimensional review
+- Manages: dimension coordination, aggregation, iteration control, progress tracking
+- Delegates: Code exploration and analysis to @cli-explore-agent, dimension-specific reviews via Deep Scan mode
+- **⚠️ DASHBOARD CONSTRAINT**: Dashboard is generated ONCE during Phase 1 initialization. After initialization, orchestrator and agents MUST NOT read, write, or modify dashboard.html - it remains static for user interaction only.
+
+## How It Works
+
+### Execution Flow (Simplified)
+
+```
+Phase 1: Discovery & Initialization
+   └─ Validate session, initialize state, create output structure → Generate dashboard.html
+
+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 → Output dashboard path
+```
+
+### 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 dashboard polling
+
+**Step 6: Dashboard Generation**
+
+**Constraints**:
+- **MANDATORY**: Dashboard MUST be generated from template: `~/.claude/templates/review-cycle-dashboard.html`
+- **PROHIBITED**: Direct creation or custom generation without template
+- **POST-GENERATION**: Orchestrator and agents MUST NOT read/write/modify dashboard.html after creation
+
+**Generation Commands** (3 independent steps):
+```bash
+# Step 1: Copy template to output location
+cp ~/.claude/templates/review-cycle-dashboard.html ${sessionDir}/.review/dashboard.html
+
+# Step 2: Replace SESSION_ID placeholder
+sed -i "s|{{SESSION_ID}}|${sessionId}|g" ${sessionDir}/.review/dashboard.html
+
+# Step 3: Replace REVIEW_TYPE placeholder
+sed -i "s|{{REVIEW_TYPE}}|session|g" ${sessionDir}/.review/dashboard.html
+
+# Step 4: Replace REVIEW_DIR placeholder
+sed -i "s|{{REVIEW_DIR}}|${reviewDir}|g" ${sessionDir}/.review/dashboard.html
+
+# Output: Start local server and output dashboard URL
+cd ${sessionDir}/.review && python -m http.server 8765 --bind 127.0.0.1 &
+echo "📊 Dashboard: http://127.0.0.1:8765/dashboard.html"
+echo "   (Press Ctrl+C to stop server when done)"
+```
+
+**Step 7: TodoWrite Initialization**
+- 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
+- Output: Dashboard path to user
+
+
+
+### 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
+│   └── ...
+└── dashboard.html                       # Interactive dashboard (primary output)
+```
+
+**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",
+  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)
+
+    ## 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",
+  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)
+
+    ## 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
+5. **Dashboard Polling**: Refresh every 5 seconds for real-time updates
+6. **Export Results**: Use dashboard export for external tracking tools
+
+## Related Commands
+
+### Automated Fix Workflow
+After completing a review, use the dashboard to select findings and export them for automated fixing:
+
+```bash
+# Step 1: Complete review (this command)
+/workflow:review-session-cycle
+
+# Step 2: Open dashboard, select findings, and export
+# Dashboard generates: fix-export-{timestamp}.json
+
+# Step 3: Run automated fixes
+/workflow:review-fix .workflow/active/WFS-{session-id}/.review/fix-export-{timestamp}.json
+```
+
+See `/workflow:review-fix` for automated fixing with smart grouping, parallel execution, and test verification.
+

.claude/commands/workflow/review.md

@@ -29,6 +29,39 @@ 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 session-id argument (optional)
+
+Step 1: Session Resolution
+   └─ Decision:
+      ├─ session-id provided → Use provided session
+      └─ Not provided → Auto-detect from .workflow/active/
+
+Step 2: Validation
+   ├─ Check session directory exists
+   └─ 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

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

@@ -87,20 +87,29 @@ Analyze workflow session for archival preparation. Session is STILL in active lo
 
 2. **Count files**: tasks (.task/*.json) and summaries (.summaries/*.md)
 
-3. **Generate lessons**: Use gemini with ~/.claude/workflows/cli-templates/prompts/archive/analysis-simple.txt
-   - Return: {successes, challenges, watch_patterns}
+3. **Extract review data** (if .review/ exists):
+   - Count dimension results: .review/dimensions/*.json
+   - Count deep-dive results: .review/iterations/*.json
+   - Extract findings summary from dimension JSONs (total, critical, high, medium, low)
+   - Check fix results if .review/fixes/ exists (fixed_count, failed_count)
+   - Build review_metrics: {dimensions_analyzed, total_findings, severity_distribution, fix_success_rate}
 
-4. **Build archive entry**:
+4. **Generate lessons**: Use gemini with ~/.claude/workflows/cli-templates/prompts/archive/analysis-simple.txt
+   - Return: {successes, challenges, watch_patterns}
+   - If review data exists, include review-specific lessons (common issue patterns, effective fixes)
+
+5. **Build archive entry**:
    - Calculate: duration_hours, success_rate, tags (3-5 keywords)
    - Construct complete JSON with session_id, description, archived_at, metrics, tags, lessons
    - Include archive_path: ".workflow/archives/WFS-session-name" (future location)
+   - If review data exists, include review_metrics in metrics object
 
-5. **Extract feature metadata** (for Phase 4):
+6. **Extract feature metadata** (for Phase 4):
    - Parse IMPL_PLAN.md for title (first # heading)
    - Extract description (first paragraph, max 200 chars)
    - Generate feature tags (3-5 keywords from content)
 
-6. **Return result**: Complete metadata package for atomic commit
+7. **Return result**: Complete metadata package for atomic commit
    {
      "status": "success",
      "session_id": "WFS-session-name",
@@ -109,7 +118,17 @@ Analyze workflow session for archival preparation. Session is STILL in active lo
        "description": "...",
        "archived_at": "...",
        "archive_path": ".workflow/archives/WFS-session-name",
-       "metrics": {...},
+       "metrics": {
+         "duration_hours": 2.5,
+         "tasks_completed": 5,
+         "summaries_generated": 3,
+         "review_metrics": {                    // Optional, only if .review/ exists
+           "dimensions_analyzed": 4,
+           "total_findings": 15,
+           "severity_distribution": {"critical": 1, "high": 3, "medium": 8, "low": 3},
+           "fix_success_rate": 0.87             // Optional, only if .review/fixes/ exists
+         }
+       },
        "tags": [...],
        "lessons": {...}
      },
@@ -193,6 +212,7 @@ bash(rm .workflow/archives/WFS-session-name/.archiving)
   Location: .workflow/archives/WFS-session-name/
   Lessons: ${archiveEntry.lessons.successes.length} successes, ${archiveEntry.lessons.challenges.length} challenges
   Manifest: Updated with ${manifest.length} total sessions
+  ${reviewMetrics ? `Review: ${reviewMetrics.total_findings} findings across ${reviewMetrics.dimensions_analyzed} dimensions, ${Math.round(reviewMetrics.fix_success_rate * 100)}% fixed` : ''}
 ```
 
 ### Phase 4: Update Project Feature Registry
@@ -435,9 +455,10 @@ Session state: PARTIALLY COMPLETE (session archived, manifest needs update)
 **Phase 2: Agent Analysis** (Read-only data processing)
 - Extract all session data from active location
 - Count tasks and summaries
-- Generate lessons learned analysis
+- Extract review data if .review/ exists (dimension results, findings, fix results)
+- Generate lessons learned analysis (including review-specific lessons if applicable)
 - Extract feature metadata from IMPL_PLAN.md
-- Build complete archive + feature metadata package
+- Build complete archive + feature metadata package (with review_metrics if applicable)
 - **No file modifications** - pure analysis
 - **Total**: 1 agent invocation
 

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

@@ -148,6 +148,10 @@ bash(echo '{"session_id":"WFS-fix-login-bug","project":"fix login bug","status":
 
 **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
@@ -168,25 +172,6 @@ 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\"")
-```
 
 ## Session ID Format
 - Pattern: `WFS-[lowercase-slug]`

.claude/commands/workflow/status.md

@@ -23,6 +23,35 @@ No synchronization needed - all views are calculated from current JSON state.
 /workflow:status --dashboard        # Generate HTML dashboard board
 ```
 
+## Execution Process
+
+```
+Input Parsing:
+   └─ Decision (mode detection):
+      ├─ --project flag → Project Overview Mode
+      ├─ --dashboard flag → Dashboard Mode
+      ├─ task-id argument → Task Details Mode
+      └─ No flags → Workflow Session Mode (default)
+
+Project Overview Mode:
+   ├─ Check project.json exists
+   ├─ Read project data
+   ├─ Parse and display overview + features
+   └─ Show recent archived sessions
+
+Workflow Session Mode (default):
+   ├─ Find active session
+   ├─ Load session data
+   ├─ Scan task files
+   └─ Display task progress
+
+Dashboard Mode:
+   ├─ Collect active sessions
+   ├─ Collect archived sessions
+   ├─ Generate HTML from template
+   └─ Write dashboard.html
+```
+
 ## Implementation Flow
 
 ### Mode Selection

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

@@ -100,13 +100,14 @@ TEST_FOCUS: [Test scenarios]
 **TodoWrite Update (Phase 3 SlashCommand invoked - tasks attached)**:
 ```json
 [
-  {"content": "Execute session discovery", "status": "completed", "activeForm": "Executing session discovery"},
-  {"content": "Execute context gathering", "status": "completed", "activeForm": "Executing context gathering"},
-  {"content": "Phase 3.1: Detect test framework and conventions (test-context-gather)", "status": "in_progress", "activeForm": "Detecting test framework"},
-  {"content": "Phase 3.2: Analyze existing test coverage (test-context-gather)", "status": "pending", "activeForm": "Analyzing test coverage"},
-  {"content": "Phase 3.3: Identify coverage gaps (test-context-gather)", "status": "pending", "activeForm": "Identifying coverage gaps"},
-  {"content": "Execute TDD task generation", "status": "pending", "activeForm": "Executing TDD task generation"},
-  {"content": "Validate TDD structure", "status": "pending", "activeForm": "Validating TDD structure"}
+  {"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"}
 ]
 ```
 
@@ -119,11 +120,11 @@ TEST_FOCUS: [Test scenarios]
 **TodoWrite Update (Phase 3 completed - tasks collapsed)**:
 ```json
 [
-  {"content": "Execute session discovery", "status": "completed", "activeForm": "Executing session discovery"},
-  {"content": "Execute context gathering", "status": "completed", "activeForm": "Executing context gathering"},
-  {"content": "Execute test coverage analysis", "status": "completed", "activeForm": "Executing test coverage analysis"},
-  {"content": "Execute TDD task generation", "status": "pending", "activeForm": "Executing TDD task generation"},
-  {"content": "Validate TDD structure", "status": "pending", "activeForm": "Validating TDD structure"}
+  {"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"}
 ]
 ```
 
@@ -160,14 +161,15 @@ TEST_FOCUS: [Test scenarios]
 **TodoWrite Update (Phase 4 SlashCommand invoked - tasks attached, if conflict_risk ≥ medium)**:
 ```json
 [
-  {"content": "Execute session discovery", "status": "completed", "activeForm": "Executing session discovery"},
-  {"content": "Execute context gathering", "status": "completed", "activeForm": "Executing context gathering"},
-  {"content": "Execute test coverage analysis", "status": "completed", "activeForm": "Executing test coverage analysis"},
-  {"content": "Phase 4.1: Detect conflicts with CLI analysis (conflict-resolution)", "status": "in_progress", "activeForm": "Detecting conflicts"},
-  {"content": "Phase 4.2: Present conflicts to user (conflict-resolution)", "status": "pending", "activeForm": "Presenting conflicts"},
-  {"content": "Phase 4.3: Apply resolution strategies (conflict-resolution)", "status": "pending", "activeForm": "Applying resolution strategies"},
-  {"content": "Execute TDD task generation", "status": "pending", "activeForm": "Executing TDD task generation"},
-  {"content": "Validate TDD structure", "status": "pending", "activeForm": "Validating TDD structure"}
+  {"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"}
 ]
 ```
 
@@ -180,12 +182,12 @@ TEST_FOCUS: [Test scenarios]
 **TodoWrite Update (Phase 4 completed - tasks collapsed)**:
 ```json
 [
-  {"content": "Execute session discovery", "status": "completed", "activeForm": "Executing session discovery"},
-  {"content": "Execute context gathering", "status": "completed", "activeForm": "Executing context gathering"},
-  {"content": "Execute test coverage analysis", "status": "completed", "activeForm": "Executing test coverage analysis"},
-  {"content": "Execute conflict resolution", "status": "completed", "activeForm": "Executing conflict resolution"},
-  {"content": "Execute TDD task generation", "status": "pending", "activeForm": "Executing TDD task generation"},
-  {"content": "Validate TDD structure", "status": "pending", "activeForm": "Validating TDD structure"}
+  {"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"}
 ]
 ```
 
@@ -226,13 +228,14 @@ TEST_FOCUS: [Test scenarios]
 **TodoWrite Update (Phase 5 SlashCommand invoked - tasks attached)**:
 ```json
 [
-  {"content": "Execute session discovery", "status": "completed", "activeForm": "Executing session discovery"},
-  {"content": "Execute context gathering", "status": "completed", "activeForm": "Executing context gathering"},
-  {"content": "Execute test coverage analysis", "status": "completed", "activeForm": "Executing test coverage analysis"},
-  {"content": "Phase 5.1: Discovery - analyze TDD requirements (task-generate-tdd)", "status": "in_progress", "activeForm": "Analyzing TDD requirements"},
-  {"content": "Phase 5.2: Planning - design Red-Green-Refactor cycles (task-generate-tdd)", "status": "pending", "activeForm": "Designing TDD cycles"},
-  {"content": "Phase 5.3: Output - generate IMPL tasks with internal TDD phases (task-generate-tdd)", "status": "pending", "activeForm": "Generating TDD tasks"},
-  {"content": "Validate TDD structure", "status": "pending", "activeForm": "Validating TDD structure"}
+  {"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"}
 ]
 ```
 
@@ -245,11 +248,11 @@ TEST_FOCUS: [Test scenarios]
 **TodoWrite Update (Phase 5 completed - tasks collapsed)**:
 ```json
 [
-  {"content": "Execute session discovery", "status": "completed", "activeForm": "Executing session discovery"},
-  {"content": "Execute context gathering", "status": "completed", "activeForm": "Executing context gathering"},
-  {"content": "Execute test coverage analysis", "status": "completed", "activeForm": "Executing test coverage analysis"},
-  {"content": "Execute TDD task generation", "status": "completed", "activeForm": "Executing TDD task generation"},
-  {"content": "Validate TDD structure", "status": "in_progress", "activeForm": "Validating TDD structure"}
+  {"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"}
 ]
 ```
 

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

@@ -18,6 +18,39 @@ allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(gemini:*)
 - 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

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

@@ -343,19 +343,49 @@ CRITICAL - Next Steps:
 
 **Core Concept**: Dynamic task attachment and collapse for test-fix-gen workflow with dual-mode support (Session Mode and Prompt Mode).
 
+#### 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"}
+]
+```
+
 #### Key Principles
 
 1. **Task Attachment** (when SlashCommand invoked):
    - Sub-command's internal tasks are **attached** to orchestrator's TodoWrite
-   - Example: `/workflow:tools:test-context-gather` (Session Mode) or `/workflow:tools:context-gather` (Prompt Mode) 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
+   - 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.1-2.3 collapse to "Gather test coverage context: completed"
-   - Maintains clean orchestrator-level view
+   - 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

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

@@ -59,6 +59,41 @@ Analyzes conflicts between implementation plans and existing codebase, **includi
 - 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

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

@@ -24,6 +24,38 @@ Orchestrator command that invokes `context-search-agent` to gather comprehensive
 - **Plan Mode**: Full comprehensive analysis (vs lightweight brainstorm mode)
 - **Standardized Output**: Generate `.workflow/active/{session}/.process/context-package.json`
 
+## 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: Invoke Context-Search Agent
+   ├─ Phase 1: Initialization & Pre-Analysis
+   │  ├─ Load project.json as primary context
+   │  ├─ Initialize code-index
+   │  └─ Classify complexity
+   ├─ Phase 2: Multi-Source Discovery
+   │  ├─ Track 1: Historical archive analysis
+   │  ├─ Track 2: Reference documentation
+   │  ├─ Track 3: Web examples (Exa MCP)
+   │  └─ Track 4: Codebase analysis (5-layer)
+   └─ Phase 3: Synthesis & Packaging
+      ├─ Apply relevance scoring
+      ├─ Integrate brainstorm artifacts
+      ├─ Perform conflict detection
+      └─ Generate context-package.json
+
+Step 3: Output Verification
+   └─ Verify context-package.json created
+```
+
 ## Execution Flow
 
 ### Step 1: Context-Package Detection

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

@@ -22,6 +22,24 @@ Generate implementation planning documents (IMPL_PLAN.md, task JSONs, TODO_LIST.
 - **MCP-Enhanced**: Use MCP tools for advanced code analysis and research
 - **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 Process
+
+```
+Input Parsing:
+   ├─ Parse flags: --session, --cli-execute
+   └─ Validation: session_id REQUIRED
+
+Phase 1: Context Preparation (Command)
+   ├─ Assemble session paths (metadata, context package, output dirs)
+   └─ Provide metadata (session_id, execution_mode, mcp_capabilities)
+
+Phase 2: Planning Document Generation (Agent)
+   ├─ Load context package (progressive loading strategy)
+   ├─ Generate Task JSON Files (.task/IMPL-*.json)
+   ├─ Create IMPL_PLAN.md
+   └─ Generate TODO_LIST.md
+```
+
 ## Document Generation Lifecycle
 
 ### Phase 1: Context Preparation (Command Responsibility)

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

@@ -53,6 +53,30 @@ Autonomous TDD task JSON and IMPL_PLAN.md generation using action-planning-agent
 - **Current approach**: 1 feature = 1 task (IMPL-N with internal Red-Green-Refactor phases)
 - **Complex features**: 1 container (IMPL-N) + subtasks (IMPL-N.M) when necessary
 
+## Execution Process
+
+```
+Input Parsing:
+   ├─ Parse flags: --session, --cli-execute
+   └─ Validation: session_id REQUIRED
+
+Phase 1: Discovery & Context Loading (Memory-First)
+   ├─ Load session context (if not in memory)
+   ├─ Load context package (if not in memory)
+   ├─ Load test context package (if not in memory)
+   ├─ Extract & load role analyses from context package
+   ├─ Load conflict resolution (if exists)
+   └─ Optional: MCP external research
+
+Phase 2: Agent Execution (Document Generation)
+   ├─ Pre-agent template selection (agent-mode OR cli-execute-mode)
+   ├─ Invoke action-planning-agent
+   ├─ Generate TDD Task JSON Files (.task/IMPL-*.json)
+   │  └─ Each task: complete Red-Green-Refactor cycle internally
+   ├─ Create IMPL_PLAN.md (TDD variant)
+   └─ Generate TODO_LIST.md with TDD phase indicators
+```
+
 ## Execution Lifecycle
 
 ### Phase 1: Discovery & Context Loading

.claude/commands/workflow/tools/tdd-coverage-analysis.md

@@ -17,6 +17,38 @@ Analyze test coverage and verify Red-Green-Refactor cycle execution for TDD work
 - Verify TDD cycle execution (Red -> Green -> Refactor)
 - Generate coverage and cycle reports
 
+## Execution Process
+
+```
+Input Parsing:
+   ├─ Parse flags: --session
+   └─ Validation: session_id REQUIRED
+
+Phase 1: Extract Test Tasks
+   └─ Find TEST-*.json files and extract focus_paths
+
+Phase 2: Run Test Suite
+   └─ Decision (test framework):
+      ├─ Node.js → npm test --coverage --json
+      ├─ Python → pytest --cov --json-report
+      └─ Other → [test_command] --coverage --json
+
+Phase 3: Parse Coverage Data
+   ├─ Extract line coverage percentage
+   ├─ Extract branch coverage percentage
+   ├─ Extract function coverage percentage
+   └─ Identify uncovered lines/branches
+
+Phase 4: Verify TDD Cycle
+   └─ FOR each TDD chain (TEST-N.M → IMPL-N.M → REFACTOR-N.M):
+      ├─ Red Phase: Verify tests created and failed initially
+      ├─ Green Phase: Verify tests now pass
+      └─ Refactor Phase: Verify code quality improved
+
+Phase 5: Generate Analysis Report
+   └─ Create tdd-cycle-report.md with coverage metrics and cycle verification
+```
+
 ## Execution Lifecycle
 
 ### Phase 1: Extract Test Tasks

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

@@ -24,6 +24,29 @@ Workflow coordinator that delegates test analysis to cli-execution-agent. Agent
 - Execute Gemini analysis via agent for test strategy generation
 - Validate agent outputs (gemini-test-analysis.md, TEST_ANALYSIS_RESULTS.md)
 
+## Execution Process
+
+```
+Input Parsing:
+   ├─ Parse flags: --session, --context
+   └─ Validation: Both REQUIRED
+
+Phase 1: Context Preparation (Command)
+   ├─ Load workflow-session.json
+   ├─ Verify test session type is "test-gen"
+   ├─ Validate test-context-package.json
+   └─ Determine strategy (Simple: 1-3 files | Medium: 4-6 | Complex: >6)
+
+Phase 2: Test Analysis Execution (Agent)
+   ├─ Execute Gemini analysis via cli-execution-agent
+   └─ Generate TEST_ANALYSIS_RESULTS.md
+
+Phase 3: Output Validation (Command)
+   ├─ Verify gemini-test-analysis.md exists
+   ├─ Validate TEST_ANALYSIS_RESULTS.md
+   └─ Confirm test requirements are actionable
+```
+
 ## Execution Lifecycle
 
 ### Phase 1: Context Preparation (Command Responsibility)

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

@@ -24,6 +24,36 @@ Orchestrator command that invokes `test-context-search-agent` to gather comprehe
 - **Source Context Loading**: Import implementation summaries from source session
 - **Standardized Output**: Generate `.workflow/active/{test_session_id}/.process/test-context-package.json`
 
+## Execution Process
+
+```
+Input Parsing:
+   ├─ Parse flags: --session
+   └─ Validation: test_session_id REQUIRED
+
+Step 1: Test-Context-Package Detection
+   └─ Decision (existing package):
+      ├─ Valid package exists → Return existing (skip execution)
+      └─ No valid package → Continue to Step 2
+
+Step 2: Invoke Test-Context-Search Agent
+   ├─ Phase 1: Session Validation & Source Context Loading
+   │  ├─ Detection: Check for existing test-context-package
+   │  ├─ Test session validation
+   │  └─ Source context loading (summaries, changed files)
+   ├─ Phase 2: Test Coverage Analysis
+   │  ├─ Track 1: Existing test discovery
+   │  ├─ Track 2: Coverage gap analysis
+   │  └─ Track 3: Coverage statistics
+   └─ Phase 3: Framework Detection & Packaging
+      ├─ Framework identification
+      ├─ Convention analysis
+      └─ Generate test-context-package.json
+
+Step 3: Output Verification
+   └─ Verify test-context-package.json created
+```
+
 ## Execution Flow
 
 ### Step 1: Test-Context-Package Detection

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

@@ -32,6 +32,29 @@ Generate test planning documents (IMPL_PLAN.md, test task JSONs, TODO_LIST.md) u
 - **Manual Mode** (default): Gemini diagnosis → user applies fixes
 - **Codex Mode** (`--use-codex`): Gemini diagnosis → Codex applies fixes with resume mechanism
 
+## Execution Process
+
+```
+Input Parsing:
+   ├─ Parse flags: --session, --use-codex, --cli-execute
+   └─ Validation: session_id REQUIRED
+
+Phase 1: Context Preparation (Command)
+   ├─ Assemble test session paths
+   │  ├─ session_metadata_path
+   │  ├─ test_analysis_results_path (REQUIRED)
+   │  └─ test_context_package_path
+   └─ Provide metadata (session_id, execution_mode, use_codex, source_session_id)
+
+Phase 2: Test Document Generation (Agent)
+   ├─ Load TEST_ANALYSIS_RESULTS.md as primary requirements source
+   ├─ Generate Test Task JSON Files (.task/IMPL-*.json)
+   │  ├─ IMPL-001: Test generation (meta.type: "test-gen")
+   │  └─ IMPL-002+: Test execution & fix (meta.type: "test-fix")
+   ├─ Create IMPL_PLAN.md (test_session variant)
+   └─ Generate TODO_LIST.md with test phase indicators
+```
+
 ## Document Generation Lifecycle
 
 ### Phase 1: Context Preparation (Command Responsibility)

.claude/commands/workflow/ui-design/animation-extract.md

@@ -23,6 +23,44 @@ Extract animation and transition patterns from prompt inference and image refere
 - **Production-Ready**: CSS var() format, WCAG-compliant, semantic naming
 - **Default Behavior**: Non-interactive mode uses inferred patterns + best practices
 
+## Execution Process
+
+```
+Input Parsing:
+   ├─ Parse flags: --design-id, --session, --images, --focus, --interactive, --refine
+   └─ Decision (mode detection):
+      ├─ --refine flag → Refinement Mode
+      └─ No --refine → Exploration Mode
+
+Phase 0: Setup & Input Validation
+   ├─ Step 1: Detect input mode & base path
+   ├─ Step 2: Prepare image references (if available)
+   ├─ Step 3: Load design tokens context
+   └─ Step 4: Memory check (skip if exists)
+
+Phase 1: Animation Specification Generation
+   ├─ Step 1: Load project context
+   ├─ Step 2: Generate animation specification options (Agent Task 1)
+   │  └─ Decision:
+   │     ├─ Exploration Mode → Generate specification questions
+   │     └─ Refinement Mode → Generate refinement options
+   └─ Step 3: Verify options file created
+
+Phase 1.5: User Confirmation (Optional)
+   └─ Decision (--interactive flag):
+      ├─ --interactive present → Present options, capture selection
+      └─ No --interactive → Skip to Phase 2
+
+Phase 2: Animation System Generation
+   ├─ Step 1: Load user selection or use defaults
+   ├─ Step 2: Create output directory
+   └─ Step 3: Launch animation generation task (Agent Task 2)
+
+Phase 3: Verify Output
+   ├─ Step 1: Check files created
+   └─ Step 2: Verify file sizes
+```
+
 ## Phase 0: Setup & Input Validation
 
 ### Step 1: Detect Input Mode & Base Path

.claude/commands/workflow/ui-design/design-sync.md

@@ -19,6 +19,48 @@ Synchronize finalized design system references to brainstorming artifacts, prepa
 - **Plan-Ready Output**: Ensure design artifacts discoverable by task-generate
 - **Minimal Reading**: Verify file existence, don't read design content
 
+## Execution Process
+
+```
+Input Parsing:
+   ├─ Parse flags: --session, --selected-prototypes
+   └─ Validation: session_id REQUIRED
+
+Phase 1: Session & Artifact Validation
+   ├─ Step 1: Validate session exists
+   ├─ Step 2: Find latest design run
+   ├─ Step 3: Detect design system structure
+   └─ Step 4: Select prototypes (--selected-prototypes OR all)
+
+Phase 1.1: Memory Check (Conditional)
+   └─ Decision (current design run in synthesis):
+      ├─ Already updated → Skip Phase 2-5, EXIT
+      └─ Not found → Continue to Phase 2
+
+Phase 2: Load Target Artifacts
+   ├─ Read role analysis documents (files to update)
+   ├─ Read ui-designer/analysis.md (if exists)
+   └─ Read prototype notes (minimal context)
+
+Phase 3: Update Synthesis Specification
+   └─ Edit role analysis documents with UI/UX Guidelines section
+
+Phase 4A: Update Relevant Role Analysis Documents
+   ├─ ui-designer/analysis.md (always)
+   ├─ ux-expert/analysis.md (if animations exist)
+   ├─ system-architect/analysis.md (if layouts exist)
+   └─ product-manager/analysis.md (if prototypes)
+
+Phase 4B: Create UI Designer Design System Reference
+   └─ Write ui-designer/design-system-reference.md
+
+Phase 5: Update Context Package
+   └─ Update context-package.json with design system references
+
+Phase 6: Completion
+   └─ Report updated artifacts
+```
+
 ## Execution Protocol
 
 ### Phase 1: Session & Artifact Validation

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

@@ -40,6 +40,51 @@ allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*), Glob(*), Write(*
 
 **Target Type Detection**: Automatically inferred from prompt/targets, or explicitly set via `--target-type`.
 
+## Execution Process
+
+```
+Input Parsing:
+   ├─ Parse flags: --input, --targets, --target-type, --device-type, --session, --style-variants, --layout-variants
+   └─ Decision (input detection):
+      ├─ Contains * or glob matches → images_input (visual)
+      ├─ File/directory exists → code import source
+      └─ Pure text → design prompt
+
+Phase 1-4: Parameter Parsing & Initialization
+   ├─ Phase 1: Normalize parameters (legacy deprecation warning)
+   ├─ Phase 2: Intelligent prompt parsing (extract variant counts)
+   ├─ Phase 3: Device type inference (explicit > keywords > target_type > default)
+   └─ Phase 4: Run initialization and directory setup
+
+Phase 5: Unified Target Inference
+   ├─ Priority: --pages/--components (legacy) → --targets → prompt analysis → synthesis → default
+   ├─ Display confirmation with modification options
+   └─ User confirms → IMMEDIATELY triggers Phase 7
+
+Phase 6: Code Import (Conditional)
+   └─ Decision (design_source):
+      ├─ code_only | hybrid → Execute /workflow:ui-design:import-from-code
+      └─ visual_only → Skip to Phase 7
+
+Phase 7: Style Extraction
+   └─ Decision (needs_visual_supplement):
+      ├─ visual_only OR supplement needed → Execute /workflow:ui-design:style-extract
+      └─ code_only AND style_complete → Use code import
+
+Phase 8: Animation Extraction
+   └─ Decision (should_extract_animation):
+      ├─ visual_only OR incomplete OR regenerate → Execute /workflow:ui-design:animation-extract
+      └─ code_only AND animation_complete → Use code import
+
+Phase 9: Layout Extraction
+   └─ Decision (needs_visual_supplement OR NOT layout_complete):
+      ├─ True → Execute /workflow:ui-design:layout-extract
+      └─ False → Use code import
+
+Phase 10: UI Assembly
+   └─ Execute /workflow:ui-design:generate → Workflow complete
+```
+
 ## Core Rules
 
 1. **Start Immediately**: TodoWrite initialization → Phase 7 execution
@@ -528,10 +573,10 @@ SlashCommand(command)
 ```javascript
 // Initialize IMMEDIATELY after Phase 5 user confirmation to track multi-phase execution (4 orchestrator-level tasks)
 TodoWrite({todos: [
-  {"content": "Execute style extraction", "status": "in_progress", "activeForm": "Executing style extraction"},
-  {"content": "Execute animation extraction", "status": "pending", "activeForm": "Executing animation extraction"},
-  {"content": "Execute layout extraction", "status": "pending", "activeForm": "Executing layout extraction"},
-  {"content": "Execute UI assembly", "status": "pending", "activeForm": "Executing UI assembly"}
+  {"content": "Phase 7: Style Extraction", "status": "in_progress", "activeForm": "Executing style extraction"},
+  {"content": "Phase 8: Animation Extraction", "status": "pending", "activeForm": "Executing animation extraction"},
+  {"content": "Phase 9: Layout Extraction", "status": "pending", "activeForm": "Executing layout extraction"},
+  {"content": "Phase 10: UI Assembly", "status": "pending", "activeForm": "Executing UI assembly"}
 ]})
 
 // ⚠️ CRITICAL: Dynamic TodoWrite task attachment strategy:
@@ -539,14 +584,23 @@ TodoWrite({todos: [
 // **Key Concept**: SlashCommand invocation ATTACHES tasks to current workflow.
 // Orchestrator EXECUTES these attached tasks itself, not waiting for external completion.
 //
-// Phase 7-10 SlashCommand Invocation Pattern:
-// 1. SlashCommand invocation ATTACHES sub-command tasks to TodoWrite
-// 2. TodoWrite expands to include attached tasks
-// 3. Orchestrator EXECUTES attached tasks sequentially
-// 4. After all attached tasks complete, COLLAPSE them into phase summary
-// 5. Update next phase to in_progress
-// 6. IMMEDIATELY execute next phase (auto-continue)
-// 7. After Phase 10 completes, workflow finishes (generate command handles preview files)
+// Phase 7-10 SlashCommand Invocation Pattern (when tasks are attached):
+// Example - Phase 7 with sub-tasks:
+// [
+//   {"content": "Phase 7: Style Extraction", "status": "in_progress", "activeForm": "Executing style extraction"},
+//   {"content": "  → Analyze style references", "status": "in_progress", "activeForm": "Analyzing style references"},
+//   {"content": "  → Generate style variants", "status": "pending", "activeForm": "Generating style variants"},
+//   {"content": "  → Create design tokens", "status": "pending", "activeForm": "Creating design tokens"},
+//   {"content": "Phase 8: Animation Extraction", "status": "pending", "activeForm": "Executing animation extraction"},
+//   ...
+// ]
+//
+// After sub-tasks complete, COLLAPSE back to:
+// [
+//   {"content": "Phase 7: Style Extraction", "status": "completed", "activeForm": "Executing style extraction"},
+//   {"content": "Phase 8: Animation Extraction", "status": "in_progress", "activeForm": "Executing animation extraction"},
+//   ...
+// ]
 //
 ```
 

.claude/commands/workflow/ui-design/generate.md

@@ -21,6 +21,36 @@ Pure assembler that combines pre-extracted layout templates with design tokens t
 - `/workflow:ui-design:style-extract` → Complete design systems (design-tokens.json + style-guide.md)
 - `/workflow:ui-design:layout-extract` → Layout structure
 
+## Execution Process
+
+```
+Input Parsing:
+   ├─ Parse flags: --design-id, --session
+   └─ Decision (base path resolution):
+      ├─ --design-id provided → Exact match by design ID
+      ├─ --session provided → Latest in session
+      └─ No flags → Latest globally
+
+Phase 1: Setup & Validation
+   ├─ Step 1: Resolve base path & parse configuration
+   ├─ Step 2: Load layout templates
+   ├─ Step 3: Validate design tokens
+   └─ Step 4: Load animation tokens (optional)
+
+Phase 2: Assembly (Agent)
+   ├─ Step 1: Calculate agent grouping plan
+   │  └─ Grouping rules:
+   │     ├─ Style isolation: Each agent processes ONE style
+   │     ├─ Balanced distribution: Layouts evenly split
+   │     └─ Max 10 layouts per agent, max 6 concurrent agents
+   ├─ Step 2: Launch batched assembly tasks (parallel)
+   └─ Step 3: Verify generated files
+
+Phase 3: Generate Preview Files
+   ├─ Step 1: Run preview generation script
+   └─ Step 2: Verify preview files
+```
+
 ## Phase 1: Setup & Validation
 
 ### Step 1: Resolve Base Path & Parse Configuration

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

@@ -36,6 +36,50 @@ allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Write(*), Bash(*)
 
 **Task Attachment Model**: SlashCommand invocation is NOT delegation - it's task expansion. The orchestrator executes these attached tasks itself, not waiting for external completion.
 
+## Execution Process
+
+```
+Input Parsing:
+   ├─ Parse flags: --input, --session (legacy: --images, --prompt)
+   └─ Decision (input detection):
+      ├─ Contains * or glob matches → images_input (visual)
+      ├─ File/directory exists → code import source
+      └─ Pure text → design prompt
+
+Phase 0: Parameter Parsing & Input Detection
+   ├─ Step 1: Normalize parameters (legacy deprecation warning)
+   ├─ Step 2: Detect design source (hybrid | code_only | visual_only)
+   └─ Step 3: Initialize directories and metadata
+
+Phase 0.5: Code Import (Conditional)
+   └─ Decision (design_source):
+      ├─ hybrid → Execute /workflow:ui-design:import-from-code
+      └─ Other → Skip to Phase 2
+
+Phase 2: Style Extraction
+   └─ Decision (skip_style):
+      ├─ code_only AND style_complete → Use code import
+      └─ Otherwise → Execute /workflow:ui-design:style-extract
+
+Phase 2.3: Animation Extraction
+   └─ Decision (skip_animation):
+      ├─ code_only AND animation_complete → Use code import
+      └─ Otherwise → Execute /workflow:ui-design:animation-extract
+
+Phase 2.5: Layout Extraction
+   └─ Decision (skip_layout):
+      ├─ code_only AND layout_complete → Use code import
+      └─ Otherwise → Execute /workflow:ui-design:layout-extract
+
+Phase 3: UI Assembly
+   └─ Execute /workflow:ui-design:generate
+
+Phase 4: Design System Integration
+   └─ Decision (session_id):
+      ├─ Provided → Execute /workflow:ui-design:update
+      └─ Not provided → Standalone completion
+```
+
 ## Core Rules
 
 1. **Start Immediately**: TodoWrite initialization → Phase 2 execution
@@ -570,12 +614,12 @@ ELSE:
 ```javascript
 // Initialize IMMEDIATELY at start of Phase 0 to track multi-phase execution (6 orchestrator-level tasks)
 TodoWrite({todos: [
-  {content: "Initialize and detect design source", status: "in_progress", activeForm: "Initializing"},
-  {content: "Extract style (complete design systems)", status: "pending", activeForm: "Extracting style"},
-  {content: "Extract animation (CSS auto mode)", status: "pending", activeForm: "Extracting animation"},
-  {content: "Extract layout (structure templates)", status: "pending", activeForm: "Extracting layout"},
-  {content: "Assemble UI prototypes", status: "pending", activeForm: "Assembling UI"},
-  {content: "Integrate design system", status: "pending", activeForm: "Integrating"}
+  {content: "Phase 0: Initialize and Detect Design Source", status: "in_progress", activeForm: "Initializing"},
+  {content: "Phase 2: Style Extraction", status: "pending", activeForm: "Extracting style"},
+  {content: "Phase 2.3: Animation Extraction", status: "pending", activeForm: "Extracting animation"},
+  {content: "Phase 2.5: Layout Extraction", status: "pending", activeForm: "Extracting layout"},
+  {content: "Phase 3: UI Assembly", status: "pending", activeForm: "Assembling UI"},
+  {content: "Phase 4: Design System Integration", status: "pending", activeForm: "Integrating"}
 ]})
 
 // ⚠️ CRITICAL: Dynamic TodoWrite task attachment strategy:
@@ -583,13 +627,25 @@ TodoWrite({todos: [
 // **Key Concept**: SlashCommand invocation ATTACHES tasks to current workflow.
 // Orchestrator EXECUTES these attached tasks itself, not waiting for external completion.
 //
-// Phase 2-4 SlashCommand Invocation Pattern:
-// 1. SlashCommand invocation ATTACHES sub-command tasks to TodoWrite
-// 2. TodoWrite expands to include attached tasks
-// 3. Orchestrator EXECUTES attached tasks sequentially
-// 4. After all attached tasks complete, COLLAPSE them into phase summary
-// 5. Update next phase to in_progress
-// 6. IMMEDIATELY execute next phase SlashCommand (auto-continue)
+// Phase 2-4 SlashCommand Invocation Pattern (when tasks are attached):
+// Example - Phase 2 with sub-tasks:
+// [
+//   {"content": "Phase 0: Initialize and Detect Design Source", "status": "completed", "activeForm": "Initializing"},
+//   {"content": "Phase 2: Style Extraction", "status": "in_progress", "activeForm": "Extracting style"},
+//   {"content": "  → Analyze design references", "status": "in_progress", "activeForm": "Analyzing references"},
+//   {"content": "  → Generate design tokens", "status": "pending", "activeForm": "Generating tokens"},
+//   {"content": "  → Create style guide", "status": "pending", "activeForm": "Creating guide"},
+//   {"content": "Phase 2.3: Animation Extraction", "status": "pending", "activeForm": "Extracting animation"},
+//   ...
+// ]
+//
+// After sub-tasks complete, COLLAPSE back to:
+// [
+//   {"content": "Phase 0: Initialize and Detect Design Source", "status": "completed", "activeForm": "Initializing"},
+//   {"content": "Phase 2: Style Extraction", "status": "completed", "activeForm": "Extracting style"},
+//   {"content": "Phase 2.3: Animation Extraction", "status": "in_progress", "activeForm": "Extracting animation"},
+//   ...
+// ]
 //
 ```
 

.claude/commands/workflow/ui-design/import-from-code.md

@@ -43,6 +43,25 @@ Extract design system tokens from source code files (CSS/SCSS/JS/TS/HTML) using
 
 ## Execution Process
 
+```
+Input Parsing:
+   ├─ Parse flags: --design-id, --session, --source
+   └─ Decision (base path resolution):
+      ├─ --design-id provided → Exact match by design ID
+      ├─ --session provided → Latest design run in session
+      └─ Neither → ERROR: Must provide --design-id or --session
+
+Phase 0: Setup & File Discovery
+   ├─ Step 1: Resolve base path
+   ├─ Step 2: Initialize directories
+   └─ Step 3: Discover files using script
+
+Phase 1: Parallel Agent Analysis (3 agents)
+   ├─ Style Agent → design-tokens.json + code_snippets
+   ├─ Animation Agent → animation-tokens.json + code_snippets
+   └─ Layout Agent → layout-templates.json + code_snippets
+```
+
 ### Step 1: Setup & File Discovery
 
 **Purpose**: Initialize session, discover and categorize code files

.claude/commands/workflow/ui-design/layout-extract.md

@@ -23,6 +23,39 @@ This command separates the "scaffolding" (HTML structure and CSS layout) from th
 - **Device-Aware**: Optimized for specific device types (desktop, mobile, tablet, responsive)
 - **Token-Based**: CSS uses `var()` placeholders for spacing and breakpoints
 
+## Execution Process
+
+```
+Input Parsing:
+   ├─ Parse flags: --design-id, --session, --images, --prompt, --targets, --variants, --device-type, --interactive, --refine
+   └─ Decision (mode detection):
+      ├─ --refine flag → Refinement Mode (variants_count = 1)
+      └─ No --refine → Exploration Mode (variants_count = --variants OR 3)
+
+Phase 0: Setup & Input Validation
+   ├─ Step 1: Detect input, mode & targets
+   ├─ Step 2: Load inputs & create directories
+   └─ Step 3: Memory check (skip if cached)
+
+Phase 1: Layout Concept/Refinement Options Generation
+   ├─ Step 0.5: Load existing layout (Refinement Mode only)
+   ├─ Step 1: Generate options (Agent Task 1)
+   │  └─ Decision:
+   │     ├─ Exploration Mode → Generate contrasting layout concepts
+   │     └─ Refinement Mode → Generate refinement options
+   └─ Step 2: Verify options file created
+
+Phase 1.5: User Confirmation (Optional)
+   └─ Decision (--interactive flag):
+      ├─ --interactive present → Present options, capture selection
+      └─ No --interactive → Skip to Phase 2
+
+Phase 2: Layout Template Generation
+   ├─ Step 1: Load user selections or default to all
+   ├─ Step 2: Launch parallel agent tasks
+   └─ Step 3: Verify output files
+```
+
 ## Phase 0: Setup & Input Validation
 
 ### Step 1: Detect Input, Mode & Targets

.claude/commands/workflow/ui-design/reference-page-generator.md

@@ -33,6 +33,29 @@ Converts design run extraction results into shareable reference package with:
 
 ## Execution Process
 
+```
+Input Parsing:
+   ├─ Parse flags: --design-run, --package-name, --output-dir
+   └─ Validation:
+      ├─ --design-run and --package-name REQUIRED
+      └─ Package name format: lowercase, alphanumeric, hyphens only
+
+Phase 0: Setup & Validation
+   ├─ Step 1: Validate required parameters
+   ├─ Step 2: Validate package name format
+   ├─ Step 3: Validate design run exists
+   ├─ Step 4: Check required extraction files (design-tokens.json, layout-templates.json)
+   └─ Step 5: Setup output directory
+
+Phase 1: Prepare Component Data
+   ├─ Step 1: Copy layout templates
+   ├─ Step 2: Copy design tokens
+   └─ Step 3: Copy animation tokens (optional)
+
+Phase 2: Preview Generation (Agent)
+   └─ Generate preview.html + preview.css via ui-design-agent
+```
+
 ### Phase 0: Setup & Validation
 
 **Purpose**: Validate inputs, prepare output directory

.claude/commands/workflow/ui-design/style-extract.md

@@ -19,6 +19,43 @@ Extract design style from reference images or text prompts using Claude's built-
 - **Dual Mode**: Exploration (multiple contrasting variants) or Refinement (single design fine-tuning)
 - **Production-Ready**: WCAG AA compliant, OKLCH colors, semantic naming
 
+## Execution Process
+
+```
+Input Parsing:
+   ├─ Parse flags: --design-id, --session, --images, --prompt, --variants, --interactive, --refine
+   └─ Decision (mode detection):
+      ├─ --refine flag → Refinement Mode (variants_count = 1)
+      └─ No --refine → Exploration Mode (variants_count = --variants OR 3)
+
+Phase 0: Setup & Input Validation
+   ├─ Step 1: Detect input mode, extraction mode & base path
+   ├─ Step 2: Load inputs
+   └─ Step 3: Memory check (skip if exists)
+
+Phase 1: Design Direction/Refinement Options Generation
+   ├─ Step 1: Load project context
+   ├─ Step 2: Generate options (Agent Task 1)
+   │  └─ Decision:
+   │     ├─ Exploration Mode → Generate contrasting design directions
+   │     └─ Refinement Mode → Generate refinement options
+   └─ Step 3: Verify options file created
+
+Phase 1.5: User Confirmation (Optional)
+   └─ Decision (--interactive flag):
+      ├─ --interactive present → Present options, capture selection
+      └─ No --interactive → Skip to Phase 2
+
+Phase 2: Design System Generation
+   ├─ Step 1: Load user selection or default to all
+   ├─ Step 2: Create output directories
+   └─ Step 3: Launch agent tasks (parallel)
+
+Phase 3: Verify Output
+   ├─ Step 1: Check files created
+   └─ Step 2: Verify file sizes
+```
+
 ## Phase 0: Setup & Input Validation
 
 ### Step 1: Detect Input Mode, Extraction Mode & Base Path

.claude/workflows/cli-templates/fix-plan-template.json

@@ -0,0 +1,75 @@
+{
+  "_template_description": "Template for fix planning output. Planning agent reads this template and generates actual fix-plan.json",
+  "_usage": "Planning agent should follow this structure when analyzing findings and creating fix plan",
+
+  "plan_id": "<string: plan-{timestamp}>",
+  "created_at": "<string: ISO8601 timestamp>",
+  "total_findings": "<number: total findings to fix>",
+
+  "execution_strategy": {
+    "approach": "<string: hybrid|parallel|serial>",
+    "parallel_limit": "<number: max concurrent agents, default 3>",
+    "total_stages": "<number: how many stages in timeline>",
+    "rationale": "<string: explain why this strategy was chosen>"
+  },
+
+  "groups": [
+    {
+      "group_id": "<string: unique group identifier like G1, G2, ...>",
+      "group_name": "<string: descriptive name for this group>",
+      "findings": ["<array of finding IDs>"],
+
+      "fix_strategy": {
+        "approach": "<string: high-level fix approach>",
+        "rationale": "<string: why these findings were grouped together>",
+        "complexity": "<string: low|medium|high>",
+        "estimated_duration_minutes": "<number: estimated time>",
+        "test_pattern": "<string: test file glob pattern like tests/auth/**/*.test.*>",
+        "rollback_plan": "<string: what to do if fix fails>"
+      },
+
+      "risk_assessment": {
+        "level": "<string: low|medium|high|critical>",
+        "concerns": ["<array of strings: potential risks>"],
+        "mitigation": "<string: how to mitigate risks>"
+      }
+    }
+  ],
+
+  "timeline": [
+    {
+      "stage": "<number: stage number 1-indexed>",
+      "groups": ["<array of group IDs to execute in this stage>"],
+      "execution_mode": "<string: parallel|serial>",
+      "depends_on": ["<optional: array of group IDs this stage depends on>"],
+      "rationale": "<string: why these groups are in this stage with this mode>"
+    }
+  ],
+
+  "_instructions": {
+    "grouping_principles": [
+      "Group findings in the same file with same dimension",
+      "Group findings with similar root causes (high semantic similarity)",
+      "Consider file dependencies and execution order",
+      "Balance group sizes for efficient parallel execution"
+    ],
+    "execution_strategy_guidelines": [
+      "Use parallel for independent groups in different files",
+      "Use serial for dependent changes (e.g., shared utilities)",
+      "Limit parallelism to 3 concurrent agents to avoid resource contention",
+      "High-risk groups should be isolated for careful monitoring"
+    ],
+    "test_strategy_guidelines": [
+      "Identify test files related to changed code",
+      "Use specific patterns for faster test execution",
+      "Ensure test coverage captures all fix impacts",
+      "Define clear pass criteria (usually 100% pass rate)"
+    ],
+    "risk_assessment_guidelines": [
+      "Low: Simple fixes with comprehensive test coverage",
+      "Medium: Moderate changes affecting multiple components",
+      "High: Core logic changes or security-critical fixes",
+      "Critical: Database schema changes or breaking API changes"
+    ]
+  }
+}

.claude/workflows/cli-templates/fix-progress-template.json

@@ -0,0 +1,48 @@
+{
+  "$schema": "fix-progress-template.json",
+  "$comment": "Template for fix-progress-{N}.json - one per group, initialized by planning agent, updated by execution agent",
+
+  "progress_id": "fix-progress-N",
+  "group_id": "GN",
+  "group_name": "Group name from fix plan",
+  "status": "pending",
+  "phase": "waiting",
+
+  "assigned_agent": null,
+  "started_at": null,
+  "last_update": "ISO 8601 timestamp",
+
+  "findings": [
+    {
+      "finding_id": "finding-uuid",
+      "finding_title": "Finding title from review",
+      "file": "path/to/file.ts",
+      "line": 0,
+      "status": "pending",
+      "result": null,
+      "attempts": 0,
+      "started_at": null,
+      "completed_at": null,
+      "commit_hash": null,
+      "test_passed": null
+    }
+  ],
+
+  "summary": {
+    "total_findings": 0,
+    "pending": 0,
+    "in_progress": 0,
+    "fixed": 0,
+    "failed": 0,
+    "percent_complete": 0.0
+  },
+
+  "current_finding": null,
+
+  "flow_control": {
+    "implementation_approach": [],
+    "current_step": null
+  },
+
+  "errors": []
+}

.claude/workflows/cli-templates/schemas/explore-json-schema.json

@@ -80,6 +80,22 @@
           "const": "cli-explore-agent",
           "description": "Agent that performed exploration"
         },
+        "exploration_angle": {
+          "type": "string",
+          "description": "Agent-chosen exploration angle (e.g., 'architecture', 'security', 'dataflow')"
+        },
+        "exploration_index": {
+          "type": "integer",
+          "minimum": 1,
+          "maximum": 4,
+          "description": "Exploration index (1-4) in parallel exploration set"
+        },
+        "total_explorations": {
+          "type": "integer",
+          "minimum": 1,
+          "maximum": 4,
+          "description": "Total number of parallel explorations"
+        },
         "duration_seconds": {
           "type": "integer",
           "description": "Exploration duration in seconds"

.claude/workflows/cli-templates/schemas/plan-json-schema.json

@@ -23,12 +23,17 @@
     },
     "tasks": {
       "type": "array",
-      "minItems": 3,
+      "minItems": 1,
       "maxItems": 10,
       "items": {
         "type": "object",
-        "required": ["title", "file", "action", "description", "implementation", "reference", "acceptance"],
+        "required": ["id", "title", "file", "action", "description", "implementation", "acceptance"],
         "properties": {
+          "id": {
+            "type": "string",
+            "pattern": "^T[0-9]+$",
+            "description": "Task identifier (T1, T2, T3...)"
+          },
           "title": {
             "type": "string",
             "description": "Task title (action verb + target)"
@@ -39,23 +44,44 @@
           },
           "action": {
             "type": "string",
-            "enum": ["Create", "Update", "Implement", "Refactor", "Add", "Delete", "Configure", "Test"],
+            "enum": ["Create", "Update", "Implement", "Refactor", "Add", "Delete", "Configure", "Test", "Fix"],
             "description": "Primary action type"
           },
           "description": {
             "type": "string",
             "description": "What to implement (1-2 sentences)"
           },
+          "modification_points": {
+            "type": "array",
+            "items": {
+              "type": "object",
+              "required": ["file", "target", "change"],
+              "properties": {
+                "file": {
+                  "type": "string",
+                  "description": "File path"
+                },
+                "target": {
+                  "type": "string",
+                  "description": "Function/class/line range (e.g., 'validateToken:45-60')"
+                },
+                "change": {
+                  "type": "string",
+                  "description": "Brief description of change"
+                }
+              }
+            },
+            "description": "Precise modification points with file:target:change format"
+          },
           "implementation": {
             "type": "array",
             "items": {"type": "string"},
-            "minItems": 3,
+            "minItems": 2,
             "maxItems": 7,
             "description": "Step-by-step implementation guide"
           },
           "reference": {
             "type": "object",
-            "required": ["pattern", "files", "examples"],
             "properties": {
               "pattern": {
                 "type": "string",
@@ -71,18 +97,74 @@
                 "description": "Specific guidance or example references"
               }
             },
-            "description": "Reference materials for implementation"
+            "description": "Reference materials for implementation (optional)"
           },
           "acceptance": {
             "type": "array",
             "items": {"type": "string"},
-            "minItems": 2,
+            "minItems": 1,
             "maxItems": 4,
-            "description": "Verification criteria for task completion"
+            "description": "Verification criteria (quantified, testable)"
+          },
+          "depends_on": {
+            "type": "array",
+            "items": {
+              "type": "string",
+              "pattern": "^T[0-9]+$"
+            },
+            "description": "Task IDs this task depends on (e.g., ['T1', 'T2'])"
           }
         }
       },
-      "description": "Structured task breakdown (3-10 tasks)"
+      "description": "Structured task breakdown (1-10 tasks)"
+    },
+    "flow_control": {
+      "type": "object",
+      "properties": {
+        "execution_order": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "properties": {
+              "phase": {
+                "type": "string",
+                "description": "Phase name (e.g., 'parallel-1', 'sequential-1')"
+              },
+              "tasks": {
+                "type": "array",
+                "items": {"type": "string"},
+                "description": "Task IDs in this phase"
+              },
+              "type": {
+                "type": "string",
+                "enum": ["parallel", "sequential"],
+                "description": "Execution type"
+              }
+            }
+          },
+          "description": "Ordered execution phases"
+        },
+        "exit_conditions": {
+          "type": "object",
+          "properties": {
+            "success": {
+              "type": "string",
+              "description": "Condition for successful completion"
+            },
+            "failure": {
+              "type": "string",
+              "description": "Condition that indicates failure"
+            }
+          },
+          "description": "Conditions for workflow termination"
+        }
+      },
+      "description": "Execution flow control (optional, auto-inferred from depends_on if not provided)"
+    },
+    "focus_paths": {
+      "type": "array",
+      "items": {"type": "string"},
+      "description": "Key file paths affected by this plan (aggregated from tasks)"
     },
     "estimated_time": {
       "type": "string",
@@ -100,7 +182,7 @@
     },
     "_metadata": {
       "type": "object",
-      "required": ["timestamp", "source", "planning_mode"],
+      "required": ["timestamp", "source"],
       "properties": {
         "timestamp": {
           "type": "string",
@@ -117,6 +199,11 @@
           "enum": ["direct", "agent-based"],
           "description": "Planning execution mode"
         },
+        "exploration_angles": {
+          "type": "array",
+          "items": {"type": "string"},
+          "description": "Exploration angles used for context"
+        },
         "duration_seconds": {
           "type": "integer",
           "description": "Planning duration in seconds"

.claude/workflows/cli-templates/schemas/review-deep-dive-results-schema.json

@@ -0,0 +1,82 @@
+[
+  {
+    "finding_id": "sec-001-a1b2c3d4",
+    "original_dimension": "security",
+    "iteration": 1,
+    "analysis_timestamp": "2025-01-25T14:40:15Z",
+    "cli_tool_used": "gemini",
+    "root_cause": {
+      "summary": "Legacy code from v1 migration, pre-ORM implementation",
+      "details": "Query builder was ported from old codebase without security review. Team unaware of injection risks in string concatenation pattern. Code review at migration time focused on functionality, not security.",
+      "affected_scope": "All query-builder.ts methods using string template literals (15 methods total)",
+      "similar_patterns": [
+        "src/database/user-queries.ts:buildEmailQuery",
+        "src/database/order-queries.ts:buildOrderSearch"
+      ]
+    },
+    "remediation_plan": {
+      "approach": "Migrate to ORM prepared statements with input validation layer",
+      "priority": "P0 - Critical (security vulnerability)",
+      "estimated_effort": "4 hours development + 2 hours testing",
+      "risk_level": "low",
+      "steps": [
+        {
+          "step": 1,
+          "action": "Replace direct string concatenation with ORM query builder",
+          "files": ["src/database/query-builder.ts:buildUserQuery:140-150"],
+          "commands": [
+            "Replace: const query = `SELECT * FROM users WHERE id = ${userId}`;",
+            "With: return db('users').where('id', userId).first();"
+          ],
+          "rationale": "ORM automatically parameterizes queries, eliminating injection risk",
+          "validation": "Run: npm test -- src/database/query-builder.test.ts"
+        },
+        {
+          "step": 2,
+          "action": "Add input validation layer before ORM",
+          "files": ["src/database/validators.ts:validateUserId:NEW"],
+          "commands": [
+            "Create validator: export function validateUserId(id: unknown): number { ... }",
+            "Add schema: z.number().positive().int()"
+          ],
+          "rationale": "Defense in depth - validate types and ranges before database layer",
+          "validation": "Run: npm test -- src/database/validators.test.ts"
+        },
+        {
+          "step": 3,
+          "action": "Apply pattern to all 15 similar methods",
+          "files": ["src/database/query-builder.ts:ALL_METHODS"],
+          "commands": ["Bulk replace string templates with ORM syntax"],
+          "rationale": "Prevent similar vulnerabilities in other query methods",
+          "validation": "Run: npm test -- src/database/"
+        }
+      ],
+      "rollback_strategy": "Git commit before each step, revert if tests fail. Staged rollout: dev → staging → production with monitoring."
+    },
+    "impact_assessment": {
+      "files_affected": [
+        "src/database/query-builder.ts (modify)",
+        "src/database/validators.ts (new)",
+        "src/database/user-queries.ts (modify)",
+        "src/database/order-queries.ts (modify)"
+      ],
+      "tests_required": [
+        "src/database/query-builder.test.ts (update existing)",
+        "src/database/validators.test.ts (new)",
+        "integration/security/sql-injection.test.ts (new)"
+      ],
+      "breaking_changes": false,
+      "dependencies_updated": ["knex@2.5.1 (ORM library)"],
+      "deployment_notes": "No downtime required. Database migrations not needed."
+    },
+    "reassessed_severity": "high",
+    "severity_change_reason": "Found existing WAF rules partially mitigate risk in production. Input validation at API gateway layer provides additional defense. Downgrade from critical to high, but still requires immediate fix.",
+    "confidence_score": 0.95,
+    "references": [
+      "Project ORM migration guide: docs/architecture/orm-guide.md",
+      "Knex.js parameterization: https://knexjs.org/guide/query-builder.html#where",
+      "Similar incident: TICKET-1234 (previous SQL injection fix)"
+    ],
+    "status": "remediation_plan_ready"
+  }
+]

.claude/workflows/cli-templates/schemas/review-dimension-results-schema.json

@@ -0,0 +1,51 @@
+[
+  {
+    "dimension": "security",
+    "review_id": "review-20250125-143022",
+    "analysis_timestamp": "2025-01-25T14:30:22Z",
+    "cli_tool_used": "gemini",
+    "model": "gemini-2.5-pro",
+    "analysis_duration_ms": 2145000,
+    "summary": {
+      "total_findings": 15,
+      "critical": 2,
+      "high": 4,
+      "medium": 6,
+      "low": 3,
+      "files_analyzed": 47,
+      "lines_reviewed": 8932
+    },
+    "findings": [
+      {
+        "id": "sec-001-a1b2c3d4",
+        "title": "SQL Injection vulnerability in user query",
+        "severity": "critical",
+        "category": "injection",
+        "description": "Direct string concatenation in SQL query allows injection attacks. User input is not sanitized before query execution.",
+        "file": "src/database/query-builder.ts",
+        "line": 145,
+        "snippet": "const query = `SELECT * FROM users WHERE id = ${userId}`;",
+        "recommendation": "Use parameterized queries: db.query('SELECT * FROM users WHERE id = ?', [userId])",
+        "references": [
+          "OWASP Top 10 - A03:2021 Injection",
+          "https://owasp.org/www-community/attacks/SQL_Injection"
+        ],
+        "impact": "Potential data breach, unauthorized access to user records, data manipulation",
+        "metadata": {
+          "cwe_id": "CWE-89",
+          "owasp_category": "A03:2021-Injection"
+        },
+        "iteration": 0,
+        "status": "pending_remediation",
+        "cross_references": []
+      }
+    ],
+    "cross_references": [
+      {
+        "finding_id": "sec-001-a1b2c3d4",
+        "related_dimensions": ["quality", "architecture"],
+        "reason": "Same file flagged in multiple dimensions"
+      }
+    ]
+  }
+]

.claude/workflows/review-directory-specification.md

@@ -0,0 +1,336 @@
+# Review Directory Specification
+
+## Overview
+
+Unified directory structure for all review commands (session-based and module-based) within workflow sessions.
+
+## Core Principles
+
+1. **Session-Based**: All reviews run within a workflow session context
+2. **Unified Structure**: Same directory layout for all review types
+3. **Type Differentiation**: Review type indicated by metadata, not directory structure
+4. **Progressive Creation**: Directories created on-demand during review execution
+5. **Archive Support**: Reviews archived with their parent session
+
+## Directory Structure
+
+### Base Location
+```
+.workflow/active/WFS-{session-id}/.review/
+```
+
+### Complete Structure
+```
+.workflow/active/WFS-{session-id}/.review/
+├── review-state.json              # Review orchestrator state machine
+├── review-progress.json           # Real-time progress for dashboard polling
+├── review-metadata.json           # Review configuration and scope
+├── dimensions/                    # Per-dimension analysis results
+│   ├── security.json
+│   ├── architecture.json
+│   ├── quality.json
+│   ├── action-items.json
+│   ├── performance.json
+│   ├── maintainability.json
+│   └── best-practices.json
+├── iterations/                    # Deep-dive iteration results
+│   ├── iteration-1-finding-{uuid}.json
+│   ├── iteration-2-finding-{uuid}.json
+│   └── ...
+├── reports/                       # Human-readable reports
+│   ├── security-analysis.md
+│   ├── security-cli-output.txt
+│   ├── architecture-analysis.md
+│   ├── architecture-cli-output.txt
+│   ├── ...
+│   ├── deep-dive-1-{uuid}.md
+│   └── deep-dive-2-{uuid}.md
+├── REVIEW-SUMMARY.md              # Final consolidated summary
+└── dashboard.html                 # Interactive review dashboard
+```
+
+## Review Metadata Schema
+
+**File**: `review-metadata.json`
+
+```json
+{
+  "review_id": "review-20250125-143022",
+  "review_type": "module|session",
+  "session_id": "WFS-auth-system",
+  "created_at": "2025-01-25T14:30:22Z",
+  "scope": {
+    "type": "module|session",
+    "module_scope": {
+      "target_pattern": "src/auth/**",
+      "resolved_files": [
+        "src/auth/service.ts",
+        "src/auth/validator.ts"
+      ],
+      "file_count": 2
+    },
+    "session_scope": {
+      "commit_range": "abc123..def456",
+      "changed_files": [
+        "src/auth/service.ts",
+        "src/payment/processor.ts"
+      ],
+      "file_count": 2
+    }
+  },
+  "dimensions": ["security", "architecture", "quality", "action-items", "performance", "maintainability", "best-practices"],
+  "max_iterations": 3,
+  "cli_tools": {
+    "primary": "gemini",
+    "fallback": ["qwen", "codex"]
+  }
+}
+```
+
+## Review State Schema
+
+**File**: `review-state.json`
+
+```json
+{
+  "review_id": "review-20250125-143022",
+  "phase": "init|parallel|aggregate|iterate|complete",
+  "current_iteration": 1,
+  "dimensions_status": {
+    "security": "pending|in_progress|completed|failed",
+    "architecture": "completed",
+    "quality": "in_progress",
+    "action-items": "pending",
+    "performance": "pending",
+    "maintainability": "pending",
+    "best-practices": "pending"
+  },
+  "severity_distribution": {
+    "critical": 2,
+    "high": 5,
+    "medium": 12,
+    "low": 8
+  },
+  "critical_files": [
+    "src/auth/service.ts",
+    "src/payment/processor.ts"
+  ],
+  "iterations": [
+    {
+      "iteration": 1,
+      "findings_selected": ["uuid-1", "uuid-2", "uuid-3"],
+      "completed_at": "2025-01-25T15:30:00Z"
+    }
+  ],
+  "completion_criteria": {
+    "critical_count": 0,
+    "high_count_threshold": 5,
+    "max_iterations": 3
+  },
+  "next_action": "execute_parallel_reviews|aggregate_findings|execute_deep_dive|generate_final_report|complete"
+}
+```
+
+## Session Integration
+
+### Session Discovery
+
+**review-session-cycle** (auto-discover):
+```bash
+# Auto-detect active session
+/workflow:review-session-cycle
+
+# Or specify session explicitly
+/workflow:review-session-cycle WFS-auth-system
+```
+
+**review-module-cycle** (require session):
+```bash
+# Must have active session or specify one
+/workflow:review-module-cycle src/auth/** --session WFS-auth-system
+
+# Or use active session
+/workflow:review-module-cycle src/auth/**
+```
+
+### Session Creation Logic
+
+**For review-module-cycle**:
+
+1. **Check Active Session**: Search `.workflow/active/WFS-*`
+2. **If Found**: Use active session's `.review/` directory
+3. **If Not Found**:
+   - **Option A** (Recommended): Prompt user to create session first
+   - **Option B**: Auto-create review-only session: `WFS-review-{pattern-hash}`
+
+**Recommended Flow**:
+```bash
+# Step 1: Start session
+/workflow:session:start --new "Review auth module"
+# Creates: .workflow/active/WFS-review-auth-module/
+
+# Step 2: Run review
+/workflow:review-module-cycle src/auth/**
+# Creates: .workflow/active/WFS-review-auth-module/.review/
+```
+
+## Command Phase 1 Requirements
+
+### Both Commands Must:
+
+1. **Session Discovery**:
+   ```javascript
+   // Check for active session
+   const sessions = Glob('.workflow/active/WFS-*');
+   if (sessions.length === 0) {
+     // Prompt user to create session first
+     error("No active session found. Please run /workflow:session:start first");
+   }
+   const sessionId = sessions[0].match(/WFS-[^/]+/)[0];
+   ```
+
+2. **Create .review/ Structure**:
+   ```javascript
+   const reviewDir = `.workflow/active/${sessionId}/.review/`;
+
+   // Create directory structure
+   Bash(`mkdir -p ${reviewDir}/dimensions`);
+   Bash(`mkdir -p ${reviewDir}/iterations`);
+   Bash(`mkdir -p ${reviewDir}/reports`);
+   ```
+
+3. **Initialize Metadata**:
+   ```javascript
+   // Write review-metadata.json
+   Write(`${reviewDir}/review-metadata.json`, JSON.stringify({
+     review_id: `review-${timestamp}`,
+     review_type: "module|session",
+     session_id: sessionId,
+     created_at: new Date().toISOString(),
+     scope: {...},
+     dimensions: [...],
+     max_iterations: 3,
+     cli_tools: {...}
+   }));
+
+   // Write review-state.json
+   Write(`${reviewDir}/review-state.json`, JSON.stringify({
+     review_id: `review-${timestamp}`,
+     phase: "init",
+     current_iteration: 0,
+     dimensions_status: {},
+     severity_distribution: {},
+     critical_files: [],
+     iterations: [],
+     completion_criteria: {},
+     next_action: "execute_parallel_reviews"
+   }));
+   ```
+
+4. **Generate Dashboard**:
+   ```javascript
+   const template = Read('~/.claude/templates/review-cycle-dashboard.html');
+   const dashboard = template
+     .replace('{{SESSION_ID}}', sessionId)
+     .replace('{{REVIEW_TYPE}}', reviewType)
+     .replace('{{REVIEW_DIR}}', reviewDir);
+   Write(`${reviewDir}/dashboard.html`, dashboard);
+
+   // Output to user
+   console.log(`📊 Review Dashboard: file://${absolutePath(reviewDir)}/dashboard.html`);
+   console.log(`📂 Review Output: ${reviewDir}`);
+   ```
+
+## Archive Strategy
+
+### On Session Completion
+
+When `/workflow:session:complete` is called:
+
+1. **Preserve Review Directory**:
+   ```javascript
+   // Move entire session including .review/
+   Bash(`mv .workflow/active/${sessionId} .workflow/archives/${sessionId}`);
+   ```
+
+2. **Review Archive Structure**:
+   ```
+   .workflow/archives/WFS-auth-system/
+   ├── workflow-session.json
+   ├── IMPL_PLAN.md
+   ├── TODO_LIST.md
+   ├── .task/
+   ├── .summaries/
+   └── .review/                    # Review results preserved
+       ├── review-metadata.json
+       ├── REVIEW-SUMMARY.md
+       └── dashboard.html
+   ```
+
+3. **Access Archived Reviews**:
+   ```bash
+   # Open archived dashboard
+   start .workflow/archives/WFS-auth-system/.review/dashboard.html
+   ```
+
+## Benefits
+
+### 1. Unified Structure
+- Same directory layout for all review types
+- Consistent file naming and schemas
+- Easier maintenance and tooling
+
+### 2. Session Integration
+- Review history tracked with implementation
+- Easy correlation between code changes and reviews
+- Simplified archiving and retrieval
+
+### 3. Progressive Creation
+- Directories created only when needed
+- No upfront overhead
+- Clean session initialization
+
+### 4. Type Flexibility
+- Module-based and session-based reviews in same structure
+- Type indicated by metadata, not directory layout
+- Easy to add new review types
+
+### 5. Dashboard Consistency
+- Same dashboard template for both types
+- Unified progress tracking
+- Consistent user experience
+
+## Migration Path
+
+### For Existing Commands
+
+**review-session-cycle**:
+1. Change output from `.workflow/.reviews/session-{id}/` to `.workflow/active/{session-id}/.review/`
+2. Update Phase 1 to use session discovery
+3. Add review-metadata.json creation
+
+**review-module-cycle**:
+1. Add session requirement (or auto-create)
+2. Change output from `.workflow/.reviews/module-{hash}/` to `.workflow/active/{session-id}/.review/`
+3. Update Phase 1 to use session discovery
+4. Add review-metadata.json creation
+
+### Backward Compatibility
+
+**For existing standalone reviews** in `.workflow/.reviews/`:
+- Keep for reference
+- Document migration in README
+- Provide migration script if needed
+
+## Implementation Checklist
+
+- [ ] Update workflow-architecture.md with .review/ structure
+- [ ] Update review-session-cycle.md command specification
+- [ ] Update review-module-cycle.md command specification
+- [ ] Update review-cycle-dashboard.html template
+- [ ] Create review-metadata.json schema validation
+- [ ] Update /workflow:session:complete to preserve .review/
+- [ ] Update documentation examples
+- [ ] Test both review types with new structure
+- [ ] Validate dashboard compatibility
+- [ ] Document migration path for existing reviews

.claude/workflows/workflow-architecture.md

@@ -718,6 +718,15 @@ All workflows use the same file structure definition regardless of complexity. *
 │       ├── [.summaries/]               # Task completion summaries (created when tasks complete)
 │       │   ├── IMPL-*-summary.md      # Main task summaries
 │       │   └── IMPL-*.*-summary.md    # Subtask summaries
+│       ├── [.review/]                  # Code review results (created by review commands)
+│       │   ├── review-metadata.json    # Review configuration and scope
+│       │   ├── review-state.json       # Review state machine
+│       │   ├── review-progress.json    # Real-time progress tracking
+│       │   ├── dimensions/             # Per-dimension analysis results
+│       │   ├── iterations/             # Deep-dive iteration results
+│       │   ├── reports/                # Human-readable reports and CLI outputs
+│       │   ├── REVIEW-SUMMARY.md       # Final consolidated summary
+│       │   └── dashboard.html          # Interactive review dashboard
 │       ├── [design-*/]                 # UI design outputs (created by ui-design workflows)
 │       │   ├── .intermediates/         # Intermediate analysis files
 │       │   │   ├── style-analysis/     # Style analysis data
@@ -750,6 +759,7 @@ All workflows use the same file structure definition regardless of complexity. *
 - **Dynamic Files**: Subtask JSON files created during task decomposition
 - **Scratchpad Usage**: `.scratchpad/` created when CLI commands run without active session
 - **Design Usage**: `design-{timestamp}/` created by UI design workflows in `.workflow/` directly for standalone design runs
+- **Review Usage**: `.review/` created by review commands (`/workflow:review-module-cycle`, `/workflow:review-session-cycle`) for comprehensive code quality analysis
 - **Intermediate Files**: `.intermediates/` contains analysis data (style/layout) separate from final deliverables
 - **Layout Templates**: `layout-extraction/layout-templates.json` contains structural templates for UI assembly
 

README.md

@@ -2,7 +2,7 @@
 
 <div align="center">
 
-[![Version](https://img.shields.io/badge/version-v5.9.2-blue.svg)](https://github.com/catlog22/Claude-Code-Workflow/releases)
+[![Version](https://img.shields.io/badge/version-v5.9.3-blue.svg)](https://github.com/catlog22/Claude-Code-Workflow/releases)
 [![License](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
 [![Platform](https://img.shields.io/badge/platform-Windows%20%7C%20Linux%20%7C%20macOS-lightgrey.svg)]()
 
@@ -14,18 +14,18 @@
 
 **Claude Code Workflow (CCW)** transforms AI development from simple prompt chaining into a powerful, context-first orchestration system. It solves execution uncertainty and error accumulation through structured planning, deterministic execution, and intelligent multi-model orchestration.
 
-> **🎉 Version 5.9.2: Lite-Fix Workflow Enhancement & Session Management**
+> **🎉 Version 5.9.3: Documentation Enhancement & Context Management**
 >
 > **Core Improvements**:
-> - ✨ **Lite-Fix Session Artifacts** (`/workflow:lite-fix`) - Complete bug fix workflow tracking
->   - **Session Folder Structure**: Organized artifact storage in `.workflow/.lite-fix/{bug-slug}-{timestamp}/`
->   - **Phase Artifacts**: `diagnosis.json`, `impact.json`, `fix-plan.json`, `task.json`
->   - **CLI/Agent Access**: All intermediate results accessible for execution tools
->   - **Follow-up Tasks**: Auto-generated comprehensive fix and postmortem tasks (hotfix mode)
->   - **Enhanced Task JSON**: Complete context package with diagnosis, impact, and fix plan
-> - 🔄 **Consistent Architecture** - Aligned with lite-plan session management patterns
-> - 📊 **Better Audit Trail** - Natural history tracking for all bug fixes
-> - 🎯 **Improved Reusability** - Task JSON files can be re-executed with `/workflow:lite-execute`
+> - ✨ **Enhanced JSON Schemas** - Added exploration and plan JSON schemas for better task context and planning
+> - 🎯 **Agent-Task Execution Rules** - Enforced one-agent-per-task constraint for reliable execution
+> - 📚 **Documentation Overhaul** - Comprehensive updates to workflow initialization, task generation, and agent documentation
+>   - **Progressive Loading Strategy**: Improved context management for large codebases
+>   - **Smart Artifact Selection**: Better task JSON generation with context awareness
+>   - **Framework Integration**: Enhanced test infrastructure documentation
+> - 🔧 **Path-Based Context Loading** - Migrated agents to path-based context loading for better performance
+> - 🎨 **UI Design Templates** - Consolidated workflow commands with new UI design templates
+> - 🐛 **Bug Fixes** - Corrected spelling errors and clarified execution behavior
 >
 > See [CHANGELOG.md](CHANGELOG.md) for complete details.
 

README_CN.md

@@ -2,7 +2,7 @@
 
 <div align="center">
 
-[![Version](https://img.shields.io/badge/version-v5.9.2-blue.svg)](https://github.com/catlog22/Claude-Code-Workflow/releases)
+[![Version](https://img.shields.io/badge/version-v5.9.3-blue.svg)](https://github.com/catlog22/Claude-Code-Workflow/releases)
 [![License](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
 [![Platform](https://img.shields.io/badge/platform-Windows%20%7C%20Linux%20%7C%20macOS-lightgrey.svg)]()
 
@@ -14,18 +14,18 @@
 
 **Claude Code Workflow (CCW)** 将 AI 开发从简单的提示词链接转变为一个强大的、上下文优先的编排系统。它通过结构化规划、确定性执行和智能多模型编排，解决了执行不确定性和误差累积的问题。
 
-> **🎉 版本 5.9.2: Lite-Fix 工作流增强与会话管理**
+> **🎉 版本 5.9.3: 文档增强与上下文管理**
 >
 > **核心改进**:
-> - ✨ **Lite-Fix 会话产物** (`/workflow:lite-fix`) - 完整的 Bug 修复工作流跟踪
->   - **会话文件夹结构**: 在 `.workflow/.lite-fix/{bug-slug}-{timestamp}/` 中组织产物存储
->   - **阶段产物**: `diagnosis.json`、`impact.json`、`fix-plan.json`、`task.json`
->   - **CLI/智能体访问**: 所有中间结果可供执行工具访问
->   - **跟进任务**: 自动生成全面修复和事后分析任务（热修复模式）
->   - **增强任务 JSON**: 包含诊断、影响和修复计划的完整上下文包
-> - 🔄 **统一架构** - 与 lite-plan 会话管理模式保持一致
-> - 📊 **更好的审计跟踪** - 所有 Bug 修复的自然历史记录
-> - 🎯 **改进的可重用性** - 任务 JSON 文件可通过 `/workflow:lite-execute` 重新执行
+> - ✨ **增强的 JSON 模式** - 新增探索和计划 JSON 模式，改进任务上下文和规划
+> - 🎯 **智能体-任务执行规则** - 强制每个任务对应一个智能体，确保可靠执行
+> - 📚 **文档全面更新** - 工作流初始化、任务生成和智能体文档的综合更新
+>   - **渐进式加载策略**: 改进大型代码库的上下文管理
+>   - **智能工件选择**: 更好的任务 JSON 生成和上下文感知
+>   - **框架集成**: 增强测试基础设施文档
+> - 🔧 **基于路径的上下文加载** - 智能体迁移到基于路径的上下文加载，提升性能
+> - 🎨 **UI 设计模板** - 整合工作流命令并新增 UI 设计模板
+> - 🐛 **Bug 修复** - 修正拼写错误并阐明执行行为
 >
 > 详见 [CHANGELOG.md](CHANGELOG.md)。