refactor: consolidate agent architecture and archive legacy templates

- Remove general-purpose agent in favor of universal-executor
- Enhance workflow session completion with better state management
- Improve context-gather with advanced filtering and validation
- Archive legacy prompt templates for reference

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

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

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

@@ -28,7 +28,7 @@ You are a pure execution agent specialized in creating actionable implementation
   - `analysis_results`: Analysis recommendations and task breakdown
   - `artifacts_inventory`: Detected brainstorming outputs (role analyses, guidance-specification, role analyses)
   - `context_package`: Project context and assets
-  - `mcp_capabilities`: Available MCP tools (code-index, exa-code, exa-web)
+  - `mcp_capabilities`: Available MCP tools (exa-code, exa-web)
   - `mcp_analysis`: Optional pre-executed MCP analysis results
 
 **Legacy Support** (backward compatibility):
@@ -46,8 +46,8 @@ Phase 1: Context Validation & Enhancement (Discovery Results Provided)
    → artifacts_inventory: Use provided list (from memory or scan)
    → mcp_analysis: Use provided results (optional)
 3. Optional MCP enhancement (if not pre-executed):
-   → mcp__code-index__find_files() for codebase structure
    → mcp__exa__get_code_context_exa() for best practices
+   → mcp__exa__web_search_exa() for external research
 4. Assess task complexity (simple/medium/complex) from analysis
 
 Phase 2: Document Generation (Autonomous Output)
@@ -89,12 +89,10 @@ Phase 2: Document Generation (Autonomous Output)
     "focus_areas": [...]
   },
   "mcp_capabilities": {
-    "code_index": true,
     "exa_code": true,
     "exa_web": true
   },
   "mcp_analysis": {
-    "code_structure": "...",
     "external_research": "..."
   }
 }
@@ -108,21 +106,6 @@ Phase 2: Document Generation (Autonomous Output)
 
 ### MCP Integration Guidelines
 
-**Code Index MCP** (`mcp_capabilities.code_index = true`):
-```javascript
-// Discover relevant files
-mcp__code-index__find_files(pattern="*auth*")
-
-// Search for patterns
-mcp__code-index__search_code_advanced(
-  pattern="authentication|oauth|jwt",
-  file_pattern="*.{ts,js}"
-)
-
-// Get file summary
-mcp__code-index__get_file_summary(file_path="src/auth/index.ts")
-```
-
 **Exa Code Context** (`mcp_capabilities.exa_code = true`):
 ```javascript
 // Get best practices and examples
@@ -135,9 +118,12 @@ mcp__exa__get_code_context_exa(
 **Integration in flow_control.pre_analysis**:
 ```json
 {
-  "step": "mcp_codebase_exploration",
+  "step": "local_codebase_exploration",
   "action": "Explore codebase structure",
-  "command": "mcp__code-index__find_files(pattern=\"[task_patterns]\") && mcp__code-index__search_code_advanced(pattern=\"[relevant_patterns]\")",
+  "commands": [
+    "bash(rg '^(function|class|interface).*[task_keyword]' --type ts -n --max-count 15)",
+    "bash(find . -name '*[task_keyword]*' -type f | grep -v node_modules | head -10)"
+  ],
   "output_to": "codebase_structure"
 }
 ```
@@ -282,7 +268,7 @@ Generate `TODO_LIST.md` at `.workflow/{session_id}/TODO_LIST.md`:
 - Completed tasks → summaries: `[✅](./.summaries/IMPL-XXX-summary.md)`
 - Consistent ID schemes: IMPL-XXX, IMPL-XXX.Y (max 2 levels)
 
-**Format Specifications**: @~/.claude/workflows/workflow-architecture.md
+
 
 ### 5. Complexity Assessment & Document Structure
 Use `analysis_results.complexity` or task count to determine structure:
@@ -313,7 +299,6 @@ Use `analysis_results.complexity` or task count to determine structure:
 - Directory structure follows complexity (Level 0/1/2)
 
 **Document Standards:**
-- All formats follow @~/.claude/workflows/workflow-architecture.md
 - Proper linking between documents
 - Consistent navigation and references
 

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

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

.claude/agents/code-developer.md

@@ -92,11 +92,14 @@ ELIF context insufficient OR task has flow control marker:
 
 **Rule**: Before referencing modules/components, use `rg` or search to verify existence first.
 
-**MCP Tools Integration**: Use Code Index and Exa for comprehensive development:
-- Find existing patterns: `mcp__code-index__search_code_advanced(pattern="auth.*function")`
-- Locate files: `mcp__code-index__find_files(pattern="src/**/*.ts")`
+**MCP Tools Integration**: Use Exa for external research and best practices:
 - Get API examples: `mcp__exa__get_code_context_exa(query="React authentication hooks", tokensNum="dynamic")`
-- Update after changes: `mcp__code-index__refresh_index()`
+- Research patterns: `mcp__exa__web_search_exa(query="TypeScript authentication patterns")`
+
+**Local Search Tools**:
+- Find patterns: `rg "auth.*function" --type ts -n`
+- Locate files: `find . -name "*.ts" -type f | grep -v node_modules`
+- Content search: `rg -i "authentication" src/ -C 3`
 
 **Implementation Approach Execution**:
 When task JSON contains `flow_control.implementation_approach` array:
@@ -251,7 +254,7 @@ When step contains `command` field with Codex CLI, execute via Bash tool. For Co
    ## Status: ✅ Complete
    ```
 
-   **Summary Naming Convention** (per workflow-architecture.md):
+   **Summary Naming Convention**:
    - **Main tasks**: `IMPL-[task-id]-summary.md` (e.g., `IMPL-001-summary.md`)
    - **Subtasks**: `IMPL-[task-id].[subtask-id]-summary.md` (e.g., `IMPL-001.1-summary.md`)
    - **Location**: Always in `.summaries/` directory within session workflow folder
@@ -305,3 +308,5 @@ Before completing any task, verify:
 - Keep functions small and focused
 - Generate detailed summary documents with complete component/method listings
 - Document all new interfaces, types, and constants for dependent task reference
+### Windows Path Format Guidelines
+- **Quick Ref**: `C:\Users` → MCP: `C:\\Users` | Bash: `/c/Users` or `C:/Users`

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

@@ -231,19 +231,24 @@ Generate documents according to loaded role template specifications:
 
 **Required Files**:
 - **analysis.md**: Main role perspective analysis incorporating user context and role template
-  - **Auto-split if large**: If content >800 lines, split to `analysis-1.md`, `analysis-2.md` (or `analysis-3.md` if >1600 lines, max 3 files)
-- **recommendations.md**: Role-specific strategic recommendations and action items
-- **[role-deliverables]/**: Directory for specialized role outputs as defined in planning role template
+  - **File Naming**: MUST start with `analysis` prefix (e.g., `analysis.md`, `analysis-1.md`, `analysis-2.md`)
+  - **FORBIDDEN**: Never create `recommendations.md` or any file not starting with `analysis` prefix
+  - **Auto-split if large**: If content >800 lines, split to `analysis-1.md`, `analysis-2.md` (max 3 files: analysis.md, analysis-1.md, analysis-2.md)
+  - **Content**: Includes both analysis AND recommendations sections within analysis files
+- **[role-deliverables]/**: Directory for specialized role outputs as defined in planning role template (optional)
 
 **File Structure Example**:
 ```
 .workflow/WFS-[session]/.brainstorming/system-architect/
-├── analysis.md                    # Main system architecture analysis
-├── recommendations.md             # Architecture recommendations
-└── deliverables/
+├── analysis.md                    # Main system architecture analysis with recommendations
+├── analysis-1.md                  # (Optional) Continuation if content >800 lines
+└── deliverables/                  # (Optional) Additional role-specific outputs
     ├── technical-architecture.md  # System design specifications
     ├── technology-stack.md        # Technology selection rationale
     └── scalability-plan.md        # Scaling strategy
+
+NOTE: ALL brainstorming output files MUST start with 'analysis' prefix
+FORBIDDEN: recommendations.md, recommendations-*.md, or any non-'analysis' prefixed files
 ```
 
 ## Role-Specific Planning Process
@@ -264,9 +269,13 @@ Generate documents according to loaded role template specifications:
 
 ### 3. Brainstorming Documentation Phase
 - **Create analysis.md**: Generate comprehensive role perspective analysis in designated output directory
-- **Create recommendations.md**: Generate role-specific strategic recommendations and action items
-- **Generate Role Deliverables**: Create specialized outputs as defined in planning role template
+  - **File Naming**: MUST start with `analysis` prefix (e.g., `analysis.md`, `analysis-1.md`, `analysis-2.md`)
+  - **FORBIDDEN**: Never create `recommendations.md` or any file not starting with `analysis` prefix
+  - **Content**: Include both analysis AND recommendations sections within analysis files
+  - **Auto-split**: If content >800 lines, split to `analysis-1.md`, `analysis-2.md` (max 3 files total)
+- **Generate Role Deliverables**: Create specialized outputs as defined in planning role template (optional)
 - **Validate Output Structure**: Ensure all files saved to correct `.brainstorming/[role]/` directory
+- **Naming Validation**: Verify NO files with `recommendations` prefix exist
 - **Quality Review**: Ensure outputs meet role template standards and user requirements
 
 ## Role-Specific Analysis Framework
@@ -315,4 +324,5 @@ When analysis is complete, ensure:
 - **Relevance**: Directly addresses user's specified requirements
 - **Actionability**: Provides concrete next steps and recommendations
 
-Your role is to execute the **assigned single planning role** completely for brainstorming workflow integration. Embody the assigned role perspective to provide deep domain expertise through template-driven analysis. Think strategically from the assigned role's viewpoint and create clear actionable analysis that addresses user requirements gathered during interactive questioning. Focus on conceptual "what" and "why" from your assigned role's expertise while generating structured documentation in the designated brainstorming directory for synthesis and action planning integration.
+### Windows Path Format Guidelines
+- **Quick Ref**: `C:\Users` → MCP: `C:\\Users` | Bash: `/c/Users` or `C:/Users`

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

@@ -0,0 +1,509 @@
+---
+name: context-search-agent
+description: |
+  Intelligent context collector for development tasks. Executes multi-layer file discovery, dependency analysis, and generates standardized context packages with conflict risk assessment.
+
+  Examples:
+  - Context: Task with session metadata
+    user: "Gather context for implementing user authentication"
+    assistant: "I'll analyze project structure, discover relevant files, and generate context package"
+    commentary: Execute autonomous discovery with 3-source strategy
+
+  - Context: External research needed
+    user: "Collect context for Stripe payment integration"
+    assistant: "I'll search codebase, use Exa for API patterns, and build dependency graph"
+    commentary: Combine local search with external research
+color: green
+---
+
+You are a context discovery specialist focused on gathering relevant project information for development tasks. Execute multi-layer discovery autonomously to build comprehensive context packages.
+
+## Core Execution Philosophy
+
+- **Autonomous Discovery** - Self-directed exploration using native tools
+- **Multi-Layer Search** - Breadth-first coverage with depth-first enrichment
+- **3-Source Strategy** - Merge reference docs, web examples, and existing code
+- **Intelligent Filtering** - Multi-factor relevance scoring
+- **Standardized Output** - Generate context-package.json
+
+## Tool Arsenal
+
+### 1. Reference Documentation (Project Standards)
+**Tools**:
+- `Read()` - Load CLAUDE.md, README.md, architecture docs
+- `Bash(~/.claude/scripts/get_modules_by_depth.sh)` - Project structure
+- `Glob()` - Find documentation files
+
+**Use**: Phase 0 foundation setup
+
+### 2. Web Examples & Best Practices (MCP)
+**Tools**:
+- `mcp__exa__get_code_context_exa(query, tokensNum)` - API examples
+- `mcp__exa__web_search_exa(query, numResults)` - Best practices
+
+**Use**: Unfamiliar APIs/libraries/patterns
+
+### 3. Existing Code Discovery
+**Primary (Code-Index MCP)**:
+- `mcp__code-index__set_project_path()` - Initialize index
+- `mcp__code-index__find_files(pattern)` - File pattern matching
+- `mcp__code-index__search_code_advanced()` - Content search
+- `mcp__code-index__get_file_summary()` - File structure analysis
+- `mcp__code-index__refresh_index()` - Update index
+
+**Fallback (CLI)**:
+- `rg` (ripgrep) - Fast content search
+- `find` - File discovery
+- `Grep` - Pattern matching
+
+**Priority**: Code-Index MCP > ripgrep > find > grep
+
+## Simplified Execution Process (3 Phases)
+
+### Phase 1: Initialization & Pre-Analysis
+
+**1.1 Context-Package Detection** (execute FIRST):
+```javascript
+// Early exit if valid package exists
+const contextPackagePath = `.workflow/${session_id}/.process/context-package.json`;
+if (file_exists(contextPackagePath)) {
+  const existing = Read(contextPackagePath);
+  if (existing?.metadata?.session_id === session_id) {
+    console.log("✅ Valid context-package found, returning existing");
+    return existing; // Immediate return, skip all processing
+  }
+}
+```
+
+**1.2 Foundation Setup**:
+```javascript
+// 1. Initialize Code Index (if available)
+mcp__code-index__set_project_path(process.cwd())
+mcp__code-index__refresh_index()
+
+// 2. Project Structure
+bash(~/.claude/scripts/get_modules_by_depth.sh)
+
+// 3. Load Documentation (if not in memory)
+if (!memory.has("CLAUDE.md")) Read(CLAUDE.md)
+if (!memory.has("README.md")) Read(README.md)
+```
+
+**1.3 Task Analysis & Scope Determination**:
+- Extract technical keywords (auth, API, database)
+- Identify domain context (security, payment, user)
+- Determine action verbs (implement, refactor, fix)
+- Classify complexity (simple, medium, complex)
+- Map keywords to modules/directories
+- Identify file types (*.ts, *.py, *.go)
+- Set search depth and priorities
+
+### Phase 2: Multi-Source Context Discovery
+
+Execute all 3 tracks in parallel for comprehensive coverage.
+
+#### Track 1: Reference Documentation
+
+Extract from Phase 0 loaded docs:
+- Coding standards and conventions
+- Architecture patterns
+- Tech stack and dependencies
+- Module hierarchy
+
+#### Track 2: Web Examples (when needed)
+
+**Trigger**: Unfamiliar tech OR need API examples
+
+```javascript
+// Get code examples
+mcp__exa__get_code_context_exa({
+  query: `${library} ${feature} implementation examples`,
+  tokensNum: 5000
+})
+
+// Research best practices
+mcp__exa__web_search_exa({
+  query: `${tech_stack} ${domain} best practices 2025`,
+  numResults: 5
+})
+```
+
+#### Track 3: Codebase Analysis
+
+**Layer 1: File Pattern Discovery**
+```javascript
+// Primary: Code-Index MCP
+const files = mcp__code-index__find_files("*{keyword}*")
+// Fallback: find . -iname "*{keyword}*" -type f
+```
+
+**Layer 2: Content Search**
+```javascript
+// Primary: Code-Index MCP
+mcp__code-index__search_code_advanced({
+  pattern: "{keyword}",
+  file_pattern: "*.ts",
+  output_mode: "files_with_matches"
+})
+// Fallback: rg "{keyword}" -t ts --files-with-matches
+```
+
+**Layer 3: Semantic Patterns**
+```javascript
+// Find definitions (class, interface, function)
+mcp__code-index__search_code_advanced({
+  pattern: "^(export )?(class|interface|type|function) .*{keyword}",
+  regex: true,
+  output_mode: "content",
+  context_lines: 2
+})
+```
+
+**Layer 4: Dependencies**
+```javascript
+// Get file summaries for imports/exports
+for (const file of discovered_files) {
+  const summary = mcp__code-index__get_file_summary(file)
+  // summary: {imports, functions, classes, line_count}
+}
+```
+
+**Layer 5: Config & Tests**
+```javascript
+// Config files
+mcp__code-index__find_files("*.config.*")
+mcp__code-index__find_files("package.json")
+
+// Tests
+mcp__code-index__search_code_advanced({
+  pattern: "(describe|it|test).*{keyword}",
+  file_pattern: "*.{test,spec}.*"
+})
+```
+
+### Phase 3: Synthesis, Assessment & Packaging
+
+**3.1 Relevance Scoring**
+
+```javascript
+score = (0.4 × direct_match) +      // Filename/path match
+        (0.3 × content_density) +    // Keyword frequency
+        (0.2 × structural_pos) +     // Architecture role
+        (0.1 × dependency_link)      // Connection strength
+
+// Filter: Include only score > 0.5
+```
+
+**3.2 Dependency Graph**
+
+Build directed graph:
+- Direct dependencies (explicit imports)
+- Transitive dependencies (max 2 levels)
+- Optional dependencies (type-only, dev)
+- Integration points (shared modules)
+- Circular dependencies (flag as risk)
+
+**3.3 3-Source Synthesis**
+
+Merge with conflict resolution:
+
+```javascript
+const context = {
+  // Priority: Project docs > Existing code > Web examples
+  architecture: ref_docs.patterns || code.structure,
+
+  conventions: {
+    naming: ref_docs.standards || code.actual_patterns,
+    error_handling: ref_docs.standards || code.patterns || web.best_practices
+  },
+
+  tech_stack: {
+    // Actual (package.json) takes precedence
+    language: code.actual.language,
+    frameworks: merge_unique([ref_docs.declared, code.actual]),
+    libraries: code.actual.libraries
+  },
+
+  // Web examples fill gaps
+  supplemental: web.examples,
+  best_practices: web.industry_standards
+}
+```
+
+**Conflict Resolution**:
+1. Architecture: Docs > Code > Web
+2. Conventions: Declared > Actual > Industry
+3. Tech Stack: Actual (package.json) > Declared
+4. Missing: Use web examples
+
+**3.5 Brainstorm Artifacts Integration**
+
+If `.workflow/{session}/.brainstorming/` exists, read and include content:
+```javascript
+const brainstormDir = `.workflow/${session}/.brainstorming`;
+if (dir_exists(brainstormDir)) {
+  const artifacts = {
+    guidance_specification: {
+      path: `${brainstormDir}/guidance-specification.md`,
+      exists: file_exists(`${brainstormDir}/guidance-specification.md`),
+      content: Read(`${brainstormDir}/guidance-specification.md`) || null
+    },
+    role_analyses: glob(`${brainstormDir}/*/analysis*.md`).map(file => ({
+      role: extract_role_from_path(file),
+      files: [{
+        path: file,
+        type: file.includes('analysis.md') ? 'primary' : 'supplementary',
+        content: Read(file)
+      }]
+    })),
+    synthesis_output: {
+      path: `${brainstormDir}/synthesis-specification.md`,
+      exists: file_exists(`${brainstormDir}/synthesis-specification.md`),
+      content: Read(`${brainstormDir}/synthesis-specification.md`) || null
+    }
+  };
+}
+```
+
+**3.6 Conflict Detection**
+
+Calculate risk level based on:
+- Existing file count (<5: low, 5-15: medium, >15: high)
+- API/architecture/data model changes
+- Breaking changes identification
+
+**3.7 Context Packaging & Output**
+
+**Output**: `.workflow/{session-id}/.process/context-package.json`
+
+**Note**: Task JSONs reference via `context_package_path` field (not in `artifacts`)
+
+**Schema**:
+```json
+{
+  "metadata": {
+    "task_description": "Implement user authentication with JWT",
+    "timestamp": "2025-10-25T14:30:00Z",
+    "keywords": ["authentication", "JWT", "login"],
+    "complexity": "medium",
+    "session_id": "WFS-user-auth"
+  },
+  "project_context": {
+    "architecture_patterns": ["MVC", "Service layer", "Repository pattern"],
+    "coding_conventions": {
+      "naming": {"functions": "camelCase", "classes": "PascalCase"},
+      "error_handling": {"pattern": "centralized middleware"},
+      "async_patterns": {"preferred": "async/await"}
+    },
+    "tech_stack": {
+      "language": "typescript",
+      "frameworks": ["express", "typeorm"],
+      "libraries": ["jsonwebtoken", "bcrypt"],
+      "testing": ["jest"]
+    }
+  },
+  "assets": {
+    "documentation": [
+      {
+        "path": "CLAUDE.md",
+        "scope": "project-wide",
+        "contains": ["coding standards", "architecture principles"],
+        "relevance_score": 0.95
+      },
+      {"path": "docs/api/auth.md", "scope": "api-spec", "relevance_score": 0.92}
+    ],
+    "source_code": [
+      {
+        "path": "src/auth/AuthService.ts",
+        "role": "core-service",
+        "dependencies": ["UserRepository", "TokenService"],
+        "exports": ["login", "register", "verifyToken"],
+        "relevance_score": 0.99
+      },
+      {
+        "path": "src/models/User.ts",
+        "role": "data-model",
+        "exports": ["User", "UserSchema"],
+        "relevance_score": 0.94
+      }
+    ],
+    "config": [
+      {"path": "package.json", "relevance_score": 0.80},
+      {"path": ".env.example", "relevance_score": 0.78}
+    ],
+    "tests": [
+      {"path": "tests/auth/login.test.ts", "relevance_score": 0.95}
+    ]
+  },
+  "dependencies": {
+    "internal": [
+      {
+        "from": "AuthController.ts",
+        "to": "AuthService.ts",
+        "type": "service-dependency"
+      }
+    ],
+    "external": [
+      {
+        "package": "jsonwebtoken",
+        "version": "^9.0.0",
+        "usage": "JWT token operations"
+      },
+      {
+        "package": "bcrypt",
+        "version": "^5.1.0",
+        "usage": "password hashing"
+      }
+    ]
+  },
+  "brainstorm_artifacts": {
+    "guidance_specification": {
+      "path": ".workflow/WFS-xxx/.brainstorming/guidance-specification.md",
+      "exists": true,
+      "content": "# [Project] - Confirmed Guidance Specification\n\n**Metadata**: ...\n\n## 1. Project Positioning & Goals\n..."
+    },
+    "role_analyses": [
+      {
+        "role": "system-architect",
+        "files": [
+          {
+            "path": "system-architect/analysis.md",
+            "type": "primary",
+            "content": "# System Architecture Analysis\n\n## Overview\n..."
+          }
+        ]
+      }
+    ],
+    "synthesis_output": {
+      "path": ".workflow/WFS-xxx/.brainstorming/synthesis-specification.md",
+      "exists": true,
+      "content": "# Synthesis Specification\n\n## Cross-Role Integration\n..."
+    }
+  },
+  "conflict_detection": {
+    "risk_level": "medium",
+    "risk_factors": {
+      "existing_implementations": ["src/auth/AuthService.ts", "src/models/User.ts"],
+      "api_changes": true,
+      "architecture_changes": false,
+      "data_model_changes": true,
+      "breaking_changes": ["Login response format changes", "User schema modification"]
+    },
+    "affected_modules": ["auth", "user-model", "middleware"],
+    "mitigation_strategy": "Incremental refactoring with backward compatibility"
+  }
+}
+```
+
+## 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
+
+Before completion verify:
+- [ ] context-package.json in `.workflow/{session}/.process/`
+- [ ] Valid JSON with all required fields
+- [ ] Metadata complete (description, keywords, complexity)
+- [ ] Project context documented (patterns, conventions, tech stack)
+- [ ] Assets organized by type with metadata
+- [ ] Dependencies mapped (internal + external)
+- [ ] Conflict detection with risk level and mitigation
+- [ ] File relevance >80%
+- [ ] No sensitive data exposed
+
+## Performance Limits
+
+**File Counts**:
+- Max 30 high-priority (score >0.8)
+- Max 20 medium-priority (score 0.5-0.8)
+- Total limit: 50 files
+
+**Size Filtering**:
+- Skip files >10MB
+- Flag files >1MB for review
+- Prioritize files <100KB
+
+**Depth Control**:
+- Direct dependencies: Always include
+- Transitive: Max 2 levels
+- Optional: Only if score >0.7
+
+**Tool Priority**: Code-Index > ripgrep > find > grep
+
+## Output Report
+
+```
+✅ Context Gathering Complete
+
+Task: {description}
+Keywords: {keywords}
+Complexity: {level}
+
+Assets:
+- Documentation: {count}
+- Source Code: {high}/{medium} priority
+- Configuration: {count}
+- Tests: {count}
+
+Dependencies:
+- Internal: {count}
+- External: {count}
+
+Conflict Detection:
+- Risk: {level}
+- Affected: {modules}
+- Mitigation: {strategy}
+
+Output: .workflow/{session}/.process/context-package.json
+(Referenced in task JSONs via top-level `context_package_path` field)
+```
+
+## Key Reminders
+
+**NEVER**:
+- Skip Phase 0 setup
+- Include files without scoring
+- Expose sensitive data (credentials, keys)
+- Exceed file limits (50 total)
+- Include binaries/generated files
+- Use ripgrep if code-index available
+
+**ALWAYS**:
+- Initialize code-index in Phase 0
+- Execute get_modules_by_depth.sh
+- Load CLAUDE.md/README.md (unless in memory)
+- Execute all 3 discovery tracks
+- Use code-index MCP as primary
+- Fallback to ripgrep only when needed
+- Use Exa for unfamiliar APIs
+- Apply multi-factor scoring
+- Build dependency graphs
+- Synthesize all 3 sources
+- Calculate conflict risk
+- Generate valid JSON output
+- Report completion with stats
+
+### Windows Path Format Guidelines
+- **Quick Ref**: `C:\Users` → MCP: `C:\\Users` | Bash: `/c/Users` or `C:/Users`
+- **Context Package**: Use project-relative paths (e.g., `src/auth/service.ts`)

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

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

@@ -213,3 +213,5 @@ All tests pass - code is ready for deployment.
 **Your ultimate responsibility**: Ensure all tests pass. When they do, the code is automatically approved and ready for production. You are the final quality gate.
 
 **Tests passing = Code approved = Mission complete** ✅
+### Windows Path Format Guidelines
+- **Quick Ref**: `C:\Users` → MCP: `C:\\Users` | Bash: `/c/Users` or `C:/Users`

.claude/commands/cli/analyze.md

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

.claude/commands/cli/chat.md

@@ -9,141 +9,117 @@ allowed-tools: SlashCommand(*), Bash(*), Task(*)
 
 ## Purpose
 
-Direct Q&A interaction with CLI tools for codebase analysis. **Analysis only - does NOT modify code**.
+Direct Q&A interaction with CLI tools for codebase analysis. **Read-only - does NOT modify code**.
 
-**Intent**: Ask questions, get explanations, understand codebase structure
-**Supported Tools**: codex, gemini (default), qwen
-
-## Core Behavior
-
-1. **Conversational Analysis**: Direct question-answer interaction about codebase
-2. **Read-Only**: This command ONLY provides information and analysis
-3. **No Code Modification**: Results are explanations and insights
-4. **Flexible Context**: Choose specific files or entire codebase
+**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)
+- `--agent` - Use cli-execution-agent for automated context discovery
+- `--enhance` - Enhance inquiry with `/enhance-prompt`
 - `<inquiry>` (Required) - Question or analysis request
-- `--agent` - Use cli-execution-agent for automated context discovery (5-phase intelligent mode)
-- `--tool <codex|gemini|qwen>` - Select CLI tool (default: gemini, ignored in agent mode)
-- `--enhance` - Enhance inquiry with `/enhance-prompt` first
-- `--save-session` - Save interaction to workflow session
+
+## Tool Usage
+
+**Gemini** (Primary):
+```bash
+--tool gemini  # or omit (default)
+```
+
+**Qwen** (Fallback):
+```bash
+--tool qwen
+```
+
+**Codex** (Alternative):
+```bash
+--tool codex
+```
 
 ## Execution Flow
 
-### Standard Mode (Default)
-
+### Standard Mode
 1. Parse tool selection (default: gemini)
-2. If `--enhance`: Execute `/enhance-prompt` to expand user intent
-3. Assemble context: `@CLAUDE.md` + user-specified files or `@**/*` for entire codebase
-4. Execute CLI tool with assembled context (read-only, analysis mode)
-5. Return explanations and insights (NO code changes)
-6. Optionally save to workflow session
+2. Optional: enhance with `/enhance-prompt`
+3. Assemble context: `@CLAUDE.md` + inferred files
+4. Execute Q&A (read-only)
+5. Return answer
 
-### Agent Mode (`--agent` flag)
+### Agent Mode (`--agent`)
 
-Delegate inquiry to `cli-execution-agent` for intelligent Q&A with automated context discovery.
+Delegates to agent for intelligent Q&A:
 
-**Agent invocation**:
 ```javascript
 Task(
   subagent_type="cli-execution-agent",
-  description="Answer question with automated context discovery",
+  description="Codebase Q&A",
   prompt=`
     Task: ${inquiry}
-    Mode: analyze (Q&A)
-    Tool Preference: ${tool_flag || 'auto-select'}
+    Mode: chat (Q&A)
+    Tool: ${tool_flag || 'auto-select'}  // gemini|qwen|codex
+    Enhance: ${enhance_flag || false}
 
-    Agent will autonomously:
-    - Discover files relevant to the question
-    - Build Q&A prompt with precise context
-    - Execute and generate comprehensive answer
-    - Save conversation log
+    Agent responsibilities:
+    1. Context Discovery:
+       - Discover files relevant to question
+       - Identify key code sections
+       - Build precise context
+
+    2. CLI Command Generation:
+       - Build Gemini/Qwen/Codex command
+       - Include discovered context
+       - Apply Q&A template
+
+    3. Execution & Output:
+       - Execute Q&A analysis
+       - Generate detailed answer
+       - Save to .workflow/.chat/ or .scratchpad/
   `
 )
 ```
 
-The agent handles all phases internally.
+## Core Rules
 
-## Context Assembly
+- **Read-only**: Provides answers, does NOT modify code
+- **Context**: `@CLAUDE.md` + inferred or all files (`@**/*`)
+- **Output**: Saves to `.workflow/WFS-[id]/.chat/` or `.scratchpad/`
 
-**Always included**: `@CLAUDE.md @**/*CLAUDE.md` (project guidelines, space-separated)
-
-**Optional**:
-- User-explicit files from inquiry keywords
-- Use `@**/*` in CONTEXT for entire codebase
-
-For targeted analysis, use `rg` or MCP tools to discover relevant files first, then build precise CONTEXT field.
-
-## Command Template
+## CLI Command Templates
 
+**Gemini/Qwen**:
 ```bash
 cd . && gemini -p "
-PURPOSE: Answer user inquiry about codebase
-TASK: [user question]
+PURPOSE: Answer question
+TASK: [inquiry]
 MODE: analysis
-CONTEXT: @CLAUDE.md @**/*CLAUDE.md [inferred files or @**/* for all files]
-EXPECTED: Direct answer, explanation, insights (NO code modification)
-RULES: Focus on clarity and accuracy
+CONTEXT: @CLAUDE.md [inferred or @**/*]
+EXPECTED: Clear answer
+RULES: Focus on accuracy
 "
+# Qwen: Replace 'gemini' with 'qwen'
 ```
 
-## Examples
-
-**Basic Question (Standard Mode)**:
+**Codex**:
 ```bash
-/cli:chat "analyze the authentication flow"
-# Executes: Gemini analysis
-# Returns: Explanation of auth flow, components involved, data flow
+codex -C . --full-auto exec "
+PURPOSE: Answer question
+TASK: [inquiry]
+MODE: analysis
+CONTEXT: @CLAUDE.md [inferred or @**/*]
+EXPECTED: Detailed answer
+RULES: Technical depth
+" -m gpt-5 --skip-git-repo-check -s danger-full-access
 ```
 
-**Intelligent Q&A (Agent Mode)**:
-```bash
-/cli:chat --agent "how does JWT token refresh work in this codebase"
-# Phase 1: Understands inquiry = JWT refresh mechanism
-# Phase 2: Discovers JWT files, refresh logic, middleware patterns
-# Phase 3: Builds Q&A prompt with discovered implementation details
-# Phase 4: Executes Gemini with precise context for accurate answer
-# Phase 5: Saves conversation log with discovered context
-# Returns: Detailed answer with code references + execution log
-```
+## Output
 
-**Architecture Question**:
-```bash
-/cli:chat --tool qwen -p "how does React component optimization work here"
-# Executes: Qwen architecture analysis
-# Returns: Component structure explanation, optimization patterns used
-```
-
-**Security Analysis**:
-```bash
-/cli:chat --tool codex "review security vulnerabilities"
-# Executes: Codex security analysis
-# Returns: Vulnerability assessment, security recommendations (NO automatic fixes)
-```
-
-**Enhanced Inquiry**:
-```bash
-/cli:chat --enhance "explain the login issue"
-# Step 1: Enhance to expand login context
-# Step 2: Analysis with expanded understanding
-# Returns: Detailed explanation of login flow and potential issues
-```
-
-## Output Routing
-
-**Output Destination Logic**:
-- **Active session exists AND query is session-relevant**:
-  - Save to `.workflow/WFS-[id]/.chat/chat-[timestamp].md`
-- **No active session OR unrelated query**:
-  - Save to `.workflow/.scratchpad/chat-[description]-[timestamp].md`
-
-**Examples**:
-- During active session `WFS-api-refactor`, asking about API structure → `.chat/chat-20250105-143022.md`
-- No session, asking about build process → `.scratchpad/chat-build-process-20250105-143045.md`
+- **With session**: `.workflow/WFS-[id]/.chat/chat-[timestamp].md`
+- **No session**: `.workflow/.scratchpad/chat-[desc]-[timestamp].md`
 
 ## Notes
 
-- Command templates and file patterns: see intelligent-tools-strategy.md (loaded in memory)
-- Scratchpad directory details: see workflow-architecture.md
-- Scratchpad conversations preserved for future reference
+- See `intelligent-tools-strategy.md` for detailed tool usage and templates

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

@@ -515,6 +515,5 @@ AskUserQuestion({
 **Context Window**: `codex exec "..." resume --last` maintains conversation history, ensuring consistency across subtasks without redundant context injection.
 
 **Output Details**:
-- Output routing and scratchpad details: see workflow-architecture.md
 - Session management: see intelligent-tools-strategy.md
 - **⚠️ Code Modification**: This command performs multi-stage code modifications - execution log tracks all changes

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

@@ -317,5 +317,4 @@ Each round's output is structured as:
 -   **Priority System**: Ensures Gemini leads analysis, Codex provides critique, Claude synthesizes
 -   **Output Quality**: Multi-perspective discussion produces more robust plans than single-model analysis
 -   Command patterns and session management: see intelligent-tools-strategy.md (loaded in memory)
--   Output routing details: see workflow-architecture.md
 -   For implementation after discussion, use `/cli:execute` or `/cli:codex-execute` separately

.claude/commands/cli/execute.md

@@ -218,5 +218,4 @@ The agent handles all phases internally, including complexity-based tool selecti
 ## Notes
 
 - Command templates, YOLO mode details, and session management: see intelligent-tools-strategy.md (loaded in memory)
-- Output routing and scratchpad details: see workflow-architecture.md
 - **⚠️ Code Modification**: This command modifies code - execution logs document changes made

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

@@ -0,0 +1,130 @@
+---
+name: bug-diagnosis
+description: Bug diagnosis and fix suggestions using CLI tools with specialized template
+argument-hint: "[--agent] [--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/development/bug-diagnosis.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)
+- `--agent` - Use cli-execution-agent for automated context discovery
+- `--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
+
+### Standard Mode
+1. Parse tool selection (default: gemini)
+2. Optional: enhance with `/enhance-prompt`
+3. Detect directory from `--cd` or auto-infer
+4. Build command with bug-diagnosis template
+5. Execute diagnosis (read-only)
+6. Save to `.workflow/WFS-[id]/.chat/`
+
+### Agent Mode (`--agent`)
+
+Delegates to agent for intelligent diagnosis:
+
+```javascript
+Task(
+  subagent_type="cli-execution-agent",
+  description="Bug root cause diagnosis",
+  prompt=`
+    Task: ${bug_description}
+    Mode: bug-diagnosis
+    Tool: ${tool_flag || 'auto-select'}  // gemini|qwen|codex
+    Directory: ${cd_path || 'auto-detect'}
+    Template: bug-diagnosis
+
+    Agent responsibilities:
+    1. Context Discovery:
+       - Locate error traces and logs
+       - Find related code sections
+       - Identify data flow paths
+
+    2. CLI Command Generation:
+       - Build Gemini/Qwen/Codex command
+       - Include diagnostic context
+       - Apply bug-diagnosis.txt template
+
+    3. Execution & Output:
+       - Execute root cause analysis
+       - Generate fix suggestions
+       - Save to .workflow/.chat/
+  `
+)
+```
+
+## Core Rules
+
+- **Read-only**: Diagnoses bugs, does NOT modify code
+- **Template**: Uses `bug-diagnosis.txt` for root cause analysis
+- **Output**: Saves to `.workflow/WFS-[id]/.chat/`
+
+## CLI Command Templates
+
+**Gemini/Qwen** (default, diagnosis only):
+```bash
+cd [dir] && gemini -p "
+PURPOSE: [goal]
+TASK: Root cause analysis
+MODE: analysis
+CONTEXT: @**/*
+EXPECTED: Diagnosis, fix plan
+RULES: $(cat ~/.claude/workflows/cli-templates/prompts/development/bug-diagnosis.txt)
+"
+# Qwen: Replace 'gemini' with 'qwen'
+```
+
+**Codex** (diagnosis + potential fixes):
+```bash
+codex -C [dir] --full-auto exec "
+PURPOSE: [goal]
+TASK: Bug diagnosis
+MODE: analysis
+CONTEXT: @**/*
+EXPECTED: Diagnosis, fix suggestions
+RULES: $(cat ~/.claude/workflows/cli-templates/prompts/development/bug-diagnosis.txt)
+" -m gpt-5 --skip-git-repo-check -s danger-full-access
+```
+
+## Output
+
+- **With session**: `.workflow/WFS-[id]/.chat/bug-diagnosis-[timestamp].md`
+- **No session**: `.workflow/.scratchpad/bug-diagnosis-[desc]-[timestamp].md`
+
+## Notes
+
+- Template: `~/.claude/workflows/cli-templates/prompts/development/bug-diagnosis.txt`
+- See `intelligent-tools-strategy.md` for detailed tool usage

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

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

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

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

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

@@ -9,160 +9,121 @@ allowed-tools: SlashCommand(*), Bash(*), Task(*)
 
 ## Purpose
 
-Comprehensive planning and architecture analysis with strategic planning template (`~/.claude/prompt-templates/plan.md`).
+Strategic software architecture planning template (`~/.claude/workflows/cli-templates/prompts/planning/architecture-planning.txt`).
 
-**Supported Tools**: codex, gemini (default), qwen
-**Key Feature**: `--cd` flag for directory-scoped planning
+**Tool Selection**:
+- **gemini** (default) - Best for architecture planning
+- **qwen** - Fallback when Gemini unavailable
+- **codex** - Alternative for implementation planning
 
 ## Parameters
 
-- `--agent` - Use cli-execution-agent for automated context discovery (5-phase intelligent mode)
-- `--tool <codex|gemini|qwen>` - Tool selection (default: gemini, ignored in agent mode)
-- `--enhance` - Enhance topic with `/enhance-prompt` first
+- `--tool <gemini|qwen|codex>` - Tool selection (default: gemini)
+- `--agent` - Use cli-execution-agent for automated context discovery
+- `--enhance` - Enhance task with `/enhance-prompt`
 - `--cd "path"` - Target directory for focused planning
-- `<topic>` (Required) - Planning topic or architectural question
+- `<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
 
-### Standard Mode (Default)
+### Standard Mode
+1. Parse tool selection (default: gemini)
+2. Optional: enhance with `/enhance-prompt`
+3. Detect directory from `--cd` or auto-infer
+4. Build command with architecture-planning template
+5. Execute planning (read-only, no code generation)
+6. Save to `.workflow/WFS-[id]/.chat/`
 
-1. **Parse tool selection**: Extract `--tool` flag (default: gemini)
-2. **If `--enhance` flag present**: Execute `/enhance-prompt "[topic]"` first
-3. Parse topic (original or enhanced)
-4. Detect target directory (from `--cd` or auto-infer)
-5. Build command for selected tool with planning template
-6. Execute analysis (read-only, no code modification)
-7. Save to `.workflow/WFS-[id]/.chat/plan-[timestamp].md`
+### Agent Mode (`--agent`)
 
-### Agent Mode (`--agent` flag)
+Delegates to agent for intelligent planning:
 
-Delegate planning to `cli-execution-agent` for intelligent strategic planning with automated architecture discovery.
-
-**Agent invocation**:
 ```javascript
 Task(
   subagent_type="cli-execution-agent",
-  description="Create strategic plan with automated architecture discovery",
+  description="Architecture modification planning",
   prompt=`
-    Task: ${planning_topic}
-    Mode: plan (strategic planning)
-    Tool Preference: ${tool_flag || 'auto-select'}
-    ${cd_flag ? `Directory Scope: ${cd_path}` : ''}
-    Template: plan
+    Task: ${planning_task}
+    Mode: architecture-planning
+    Tool: ${tool_flag || 'auto-select'}  // gemini|qwen|codex
+    Directory: ${cd_path || 'auto-detect'}
+    Template: architecture-planning
 
-    Agent will autonomously:
-    - Discover project structure and existing architecture
-    - Build planning prompt with plan template
-    - Execute strategic planning analysis
-    - Generate implementation roadmap and save
+    Agent responsibilities:
+    1. Context Discovery:
+       - Analyze current architecture
+       - Identify affected components
+       - Map dependencies and impacts
+
+    2. CLI Command Generation:
+       - Build Gemini/Qwen/Codex command
+       - Include architecture context
+       - Apply architecture-planning.txt template
+
+    3. Execution & Output:
+       - Execute strategic planning
+       - Generate modification plan
+       - Save to .workflow/.chat/
   `
 )
 ```
 
-The agent handles all phases internally.
-
 ## Core Rules
 
-1. **Analysis Only**: This command provides planning recommendations and insights - it does NOT modify code
-2. **Enhance First (if flagged)**: Execute `/enhance-prompt` before planning
-3. **Directory Context**: Use `cd` when `--cd` provided or auto-detected
-4. **Template Required**: Always use planning template
-5. **Session Output**: Save analysis results to session chat
+- **Planning only**: Creates modification plans, does NOT generate code
+- **Template**: Uses `architecture-planning.txt` for strategic planning
+- **Output**: Saves to `.workflow/WFS-[id]/.chat/`
 
-## Planning Capabilities (via Template)
-
-- Strategic architecture insights and recommendations
-- Implementation roadmaps and suggestions
-- Key technical decisions analysis
-- Risk assessment
-- Resource planning
-
-## Command Template
+## CLI Command Templates
 
+**Gemini/Qwen** (default, planning only):
 ```bash
-cd [directory] && gemini -p "
-PURPOSE: [planning goal from topic]
-TASK: Comprehensive planning and architecture analysis
+cd [dir] && gemini -p "
+PURPOSE: [goal]
+TASK: Architecture planning
 MODE: analysis
-CONTEXT: @CLAUDE.md @**/*CLAUDE.md [entire codebase in directory]
-EXPECTED: Strategic insights, implementation recommendations, key decisions
-RULES: $(cat ~/.claude/prompt-templates/plan.md) | Focus on [topic area]
+CONTEXT: @**/*
+EXPECTED: Modification plan, impact analysis
+RULES: $(cat ~/.claude/workflows/cli-templates/prompts/planning/architecture-planning.txt)
 "
+# Qwen: Replace 'gemini' with 'qwen'
 ```
 
-## Examples
-
-**Basic Planning Analysis (Standard Mode)**:
+**Codex** (planning + implementation guidance):
 ```bash
-/cli:mode:plan "design user dashboard architecture"
-# Executes: Gemini with planning template
-# Returns: Architecture recommendations, component design, roadmap
-```
-
-**Intelligent Planning (Agent Mode)**:
-```bash
-/cli:mode:plan --agent "design microservices architecture for payment system"
-# Phase 1: Classifies as architectural planning, keywords ['microservices', 'payment', 'architecture']
-# Phase 2: MCP discovers existing services, payment flows, integration patterns
-# Phase 3: Builds planning prompt with plan template + current architecture context
-# Phase 4: Executes Gemini with comprehensive project understanding
-# Phase 5: Saves planning document with implementation roadmap and migration strategy
-# Returns: Strategic architecture plan + implementation roadmap + risk assessment
-```
-
-**Standard Template Example**:
-```bash
-cd . && gemini -p "
-PURPOSE: Design user dashboard architecture
-TASK: Plan dashboard component structure and data flow
+codex -C [dir] --full-auto exec "
+PURPOSE: [goal]
+TASK: Architecture planning
 MODE: analysis
-CONTEXT: @CLAUDE.md @**/*CLAUDE.md
-EXPECTED: Architecture recommendations, component design, data flow diagram
-RULES: $(cat ~/.claude/prompt-templates/plan.md) | Focus on scalability
-"
+CONTEXT: @**/*
+EXPECTED: Plan, implementation roadmap
+RULES: $(cat ~/.claude/workflows/cli-templates/prompts/planning/architecture-planning.txt)
+" -m gpt-5 --skip-git-repo-check -s danger-full-access
 ```
 
-**Directory-Specific Planning**:
-```bash
-cd src/api && gemini -p "
-PURPOSE: Plan API refactoring strategy
-TASK: Analyze current API structure and recommend improvements
-MODE: analysis
-CONTEXT: @CLAUDE.md @**/*CLAUDE.md
-EXPECTED: Refactoring roadmap, breaking change analysis, migration plan
-RULES: $(cat ~/.claude/prompt-templates/plan.md) | Maintain backward compatibility
-"
-```
+## Output
 
-## Planning Workflow
-
-```bash
-# 1. Discover project structure
-~/.claude/scripts/get_modules_by_depth.sh
-find . -name "*.ts" -type f
-
-# 2. Gather existing architecture info
-rg "architecture|design" --files-with-matches
-
-# 3. Execute planning analysis (analysis only, no code changes)
-/cli:mode:plan "topic for strategic planning"
-```
-
-## Output Routing
-
-**Output Destination Logic**:
-- **Active session exists AND planning is session-relevant**:
-  - Save to `.workflow/WFS-[id]/.chat/plan-[timestamp].md`
-- **No active session OR exploratory planning**:
-  - Save to `.workflow/.scratchpad/plan-[description]-[timestamp].md`
-
-**Examples**:
-- During active session `WFS-dashboard`, planning dashboard architecture → `.chat/plan-20250105-143022.md`
-- No session, exploring new feature idea → `.scratchpad/plan-feature-idea-20250105-143045.md`
+- **With session**: `.workflow/WFS-[id]/.chat/plan-[timestamp].md`
+- **No session**: `.workflow/.scratchpad/plan-[desc]-[timestamp].md`
 
 ## Notes
 
-- Command templates and file patterns: see intelligent-tools-strategy.md (loaded in memory)
-- Scratchpad directory details: see workflow-architecture.md
-- Template path: `~/.claude/prompt-templates/plan.md`
-- Uses `@**/*` for in CONTEXT field for comprehensive project context
+- Template: `~/.claude/workflows/cli-templates/prompts/planning/architecture-planning.txt`
+- See `intelligent-tools-strategy.md` for detailed tool usage

.claude/commands/memory/load.md

@@ -99,9 +99,9 @@ Task(
   prompt=`
 ## Mission: Load Project Memory Context
 
-**Task Context**: "${task_description}"
-**Mode**: Read-only analysis
-**Tool**: ${tool || 'gemini'}
+**Task**: Load project memory context for: "${task_description}"
+**Mode**: analysis
+**Tool Preference**: ${tool || 'gemini'}
 
 ## Execution Steps
 

.claude/commands/task/breakdown.md

@@ -10,7 +10,6 @@ argument-hint: "task-id"
 Breaks down complex tasks into executable subtasks with context inheritance and agent assignment.
 
 ## Core Principles
-**Task System:** @~/.claude/workflows/workflow-architecture.md
 **File Cohesion:** Related files must stay in same task
 **10-Task Limit:** Total tasks cannot exceed 10 (triggers re-scoping)
 
@@ -138,7 +137,6 @@ Files updated: .task/IMPL-1.json + 2 subtask files + TODO_LIST.md
 
 ## Implementation Details
 
-See @~/.claude/workflows/workflow-architecture.md for:
 - Complete task JSON schema
 - Implementation field structure
 - Context inheritance rules

.claude/commands/task/execute.md

@@ -7,7 +7,7 @@ argument-hint: "task-id"
 ### 🚀 **Command Overview: `/task:execute`**
 
 -   **Purpose**: Executes tasks using intelligent agent selection, context preparation, and progress tracking.
--   **Core Principles**: @~/.claude/workflows/workflow-architecture.md
+
 
 ### ⚙️ **Execution Modes**
 

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

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

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

@@ -2,7 +2,7 @@
 name: synthesis
 description: Clarify and refine role analyses through intelligent Q&A and targeted updates
 argument-hint: "[optional: --session session-id]"
-allowed-tools: Task(conceptual-planning-agent), TodoWrite(*), Read(*), Write(*), Edit(*), Glob(*), AskUserQuestion(*)
+allowed-tools: Task(conceptual-planning-agent), TodoWrite(*), Read(*), Write(*), Edit(*), Glob(*)
 ---
 
 ## Overview
@@ -11,7 +11,7 @@ Three-phase workflow to eliminate ambiguities and enhance conceptual depth in ro
 
 **Phase 1-2 (Main Flow)**: Session detection → File discovery → Path preparation
 
-**Phase 3A (Analysis Agent)**: Cross-role analysis → CLI concept enhancement → Generate recommendations
+**Phase 3A (Analysis Agent)**: Cross-role analysis → Generate recommendations
 
 **Phase 4 (Main Flow)**: User selects enhancements → User answers clarifications → Build update plan
 
@@ -22,7 +22,6 @@ Three-phase workflow to eliminate ambiguities and enhance conceptual depth in ro
 **Key Features**:
 - Multi-agent architecture (analysis agent + parallel update agents)
 - Clear separation: Agent analysis vs Main flow interaction
-- CLI-powered concept enhancement (Gemini)
 - Parallel document updates (one agent per role)
 - User intent alignment validation
 
@@ -36,7 +35,7 @@ Three-phase workflow to eliminate ambiguities and enhance conceptual depth in ro
 [
   {"content": "Detect session and validate analyses", "status": "in_progress", "activeForm": "Detecting session"},
   {"content": "Discover role analysis file paths", "status": "pending", "activeForm": "Discovering paths"},
-  {"content": "Execute analysis agent (cross-role + CLI enhancement)", "status": "pending", "activeForm": "Executing analysis agent"},
+  {"content": "Execute analysis agent (cross-role analysis)", "status": "pending", "activeForm": "Executing analysis agent"},
   {"content": "Present enhancements for user selection", "status": "pending", "activeForm": "Presenting enhancements"},
   {"content": "Generate and present clarification questions", "status": "pending", "activeForm": "Clarifying with user"},
   {"content": "Build update plan from user input", "status": "pending", "activeForm": "Building update plan"},
@@ -110,15 +109,8 @@ Analyze role documents, identify conflicts/gaps, and generate enhancement recomm
    - Action: Identify consensus themes, conflicts, gaps, underspecified areas
    - Output: consensus_themes, conflicting_views, gaps_list, ambiguities
 
-4. **cli_concept_enhancement**
-   - Action: Execute intelligent CLI analysis with fallback chain
-   - Dynamic Prompt: \"PURPOSE: Cross-role synthesis | TASK: conflicts/gaps/enhancements | MODE: analysis | CONTEXT: @**/* | EXPECTED: EP-001,EP-002,... | RULES: Eliminate ambiguities\"
-   - Fallback Chain: `cd {brainstorm_dir} && gemini -p \"$PROMPT\" -m gemini-2.5-pro` → (if fail) `qwen -p \"$PROMPT\"` → (if fail) `codex -C {brainstorm_dir} --full-auto exec \"$PROMPT\" -m gpt-5`
-   - Error Handling: Gemini 429 OK if results exist | 40min timeout | One attempt per tool
-   - Output: cli_enhancement_points
-
-5. **generate_recommendations**
-   - Action: Combine cross-role analysis + CLI enhancements into structured recommendations
+4. **generate_recommendations**
+   - Action: Convert cross-role analysis findings into structured enhancement recommendations
    - Format: EP-001, EP-002, ... (sequential numbering)
    - Fields: id, title, affected_roles, category, current_state, enhancement, rationale, priority
    - Taxonomy: Map to 9 categories (User Intent, Requirements, Architecture, UX, Feasibility, Risk, Process, Decisions, Terminology)
@@ -140,62 +132,72 @@ Return JSON array:
   ...
 ]
 
-### Agent Context Summary
-**Tools Used**: Gemini (primary) → Qwen (fallback) → Codex (last resort)
-**Mode**: analysis (read-only)
-**Timeout**: 40min
-**Dependencies**: @intelligent-tools-strategy.md
-**Validation**: Enhancement recommendations + 9-category taxonomy mapping
 "
 ```
 
 ### Phase 4: Main Flow User Interaction
 
-**Main flow handles all user interaction**:
+**Main flow handles all user interaction via text output**:
 
-1. **Present Enhancement Options**:
-```python
-AskUserQuestion(
-  questions=[{
-    "question": "Which enhancements would you like to apply?",
-    "header": "Enhancements",
-    "multiSelect": true,
-    "options": [
-      {"label": "EP-001: ...", "description": "... (affects: role1, role2)"},
-      {"label": "EP-002: ...", "description": "..."},
-      ...
-    ]
-  }]
-)
+**⚠️ CRITICAL**: ALL questions MUST use Chinese (所有问题必须用中文) for better user understanding
+
+1. **Present Enhancement Options** (multi-select):
+```markdown
+===== Enhancement 选择 =====
+
+请选择要应用的改进建议（可多选）：
+
+a) EP-001: API Contract Specification
+   影响角色：system-architect, api-designer
+   说明：添加详细的请求/响应 schema 定义
+
+b) EP-002: User Intent Validation
+   影响角色：product-manager, ux-expert
+   说明：明确用户需求优先级和验收标准
+
+c) EP-003: Error Handling Strategy
+   影响角色：system-architect
+   说明：统一异常处理和降级方案
+
+支持格式：1abc 或 1a 1b 1c 或 1a,b,c
+请输入选择（可跳过输入 skip）：
 ```
 
 2. **Generate Clarification Questions** (based on analysis agent output):
+   - ✅ **ALL questions in Chinese (所有问题必须用中文)**
    - Use 9-category taxonomy scan results
-   - Create max 5 prioritized questions
+   - Prioritize most critical questions (no hard limit)
    - Each with 2-4 options + descriptions
 
-3. **Interactive Clarification Loop**:
-```python
-# Present ONE question at a time
-FOR question in clarification_questions (max 5):
-  AskUserQuestion(
-    questions=[{
-      "question": "Question {N}/5: {text}",
-      "header": "Clarification",
-      "multiSelect": false,
-      "options": [
-        {"label": "Option A", "description": "..."},
-        {"label": "Option B", "description": "..."},
-        ...
-      ]
-    }]
-  )
-  # Record answer
-  # Continue to next question
+3. **Interactive Clarification Loop** (max 10 questions per round):
+```markdown
+===== Clarification 问题 (第 1/2 轮) =====
+
+【问题1 - 用户意图】MVP 阶段的核心目标是什么？
+a) 快速验证市场需求
+   说明：最小功能集，快速上线获取反馈
+b) 建立技术壁垒
+   说明：完善架构，为长期发展打基础
+c) 实现功能完整性
+   说明：覆盖所有规划功能，延迟上线
+
+【问题2 - 架构决策】技术栈选择的优先考虑因素？
+a) 团队熟悉度
+   说明：使用现有技术栈，降低学习成本
+b) 技术先进性
+   说明：采用新技术，提升竞争力
+c) 生态成熟度
+   说明：选择成熟方案，保证稳定性
+
+...（最多10个问题）
+
+请回答 (格式: 1a 2b 3c...)：
 ```
 
+Wait for user input → Parse all answers in batch → Continue to next round if needed
+
 4. **Build Update Plan**:
-```python
+```
 update_plan = {
   "role1": {
     "enhancements": [EP-001, EP-003],
@@ -433,19 +435,4 @@ Update `workflow-session.json`:
 - Valid Markdown
 - Cross-references maintained
 
-## Next Steps
-
-**Standard**:
-```bash
-/workflow:plan --session WFS-{session-id}
-/workflow:action-plan-verify --session WFS-{session-id}  # Optional
-/workflow:execute --session WFS-{session-id}
-```
-
-**TDD**:
-```bash
-/workflow:tdd-plan --session WFS-{session-id} "description"
-/workflow:action-plan-verify --session WFS-{session-id}  # Optional
-/workflow:execute --session WFS-{session-id}
-```
 

.claude/commands/workflow/execute.md

@@ -11,6 +11,17 @@ Orchestrates autonomous workflow execution through systematic task discovery, ag
 
 **Resume Mode**: When called with `--resume-session` flag, skips discovery phase and directly enters TodoWrite generation and agent execution for the specified session.
 
+## Performance Optimization Strategy
+
+**Lazy Loading**: Task JSONs read **on-demand** during execution, not upfront. TODO_LIST.md + IMPL_PLAN.md provide metadata for planning.
+
+| Metric | Before | After | Improvement |
+|--------|--------|-------|-------------|
+| **Initial Load** | All task JSONs (~2,300 lines) | TODO_LIST.md only (~650 lines) | **72% reduction** |
+| **Startup Time** | Seconds | Milliseconds | **~90% faster** |
+| **Memory** | All tasks | 1-2 tasks | **90% less** |
+| **Scalability** | 10-20 tasks | 100+ tasks | **5-10x** |
+
 ## Core Rules
 **Complete entire workflow autonomously without user interruption, using TodoWrite for comprehensive progress tracking.**
 **Execute all discovered pending tasks sequentially until workflow completion or blocking dependency.**
@@ -63,40 +74,69 @@ Orchestrates autonomous workflow execution through systematic task discovery, ag
 ### Phase 1: Discovery (Normal Mode Only)
 1. **Check Active Sessions**: Find `.workflow/.active-*` markers
 2. **Select Session**: If multiple found, prompt user selection
-3. **Load Session State**: Read `workflow-session.json` and `IMPL_PLAN.md`
-4. **Scan Tasks**: Analyze `.task/*.json` files for ready tasks
+3. **Load Session Metadata**: Read `workflow-session.json` ONLY (minimal context)
+4. **DO NOT read task JSONs yet** - defer until execution phase
 
 **Note**: In resume mode, this phase is completely skipped.
 
-### Phase 2: Analysis (Normal Mode Only)
-1. **Dependency Resolution**: Build execution order based on `depends_on`
-2. **Status Validation**: Filter tasks with `status: "pending"` and met dependencies
-3. **Agent Assignment**: Determine agent type from `meta.agent` or `meta.type`
-4. **Context Preparation**: Load dependency summaries and inherited context
+### Phase 2: Planning Document Analysis (Normal Mode Only)
+**Optimized to avoid reading all task JSONs upfront**
+
+1. **Read IMPL_PLAN.md**: Understand overall strategy, task breakdown summary, dependencies
+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
+
+**Key Optimization**: Use IMPL_PLAN.md and TODO_LIST.md as primary sources instead of reading all task JSONs
 
 **Note**: In resume mode, this phase is also skipped as session analysis was already completed by `/workflow:status`.
 
-### Phase 3: Planning (Resume Mode Entry Point)
+### Phase 3: TodoWrite Generation (Resume Mode Entry Point)
 **This is where resume mode directly enters after skipping Phases 1 & 2**
 
-1. **Create TodoWrite List**: Generate task list with status markers from session state
-2. **Mark Initial Status**: Set first pending task as `in_progress`
+1. **Create TodoWrite List**: Generate task list from TODO_LIST.md (not from task JSONs)
+   - Parse TODO_LIST.md to extract all tasks with current statuses
+   - Identify first pending task with met dependencies
+   - Generate comprehensive TodoWrite covering entire workflow
+2. **Mark Initial Status**: Set first ready task as `in_progress` in TodoWrite
 3. **Prepare Session Context**: Inject workflow paths for agent use (using provided session-id)
-4. **Prepare Complete Task JSON**: Include pre_analysis and flow control steps for agent consumption
-5. **Validate Prerequisites**: Ensure all required context is available from existing session
+4. **Validate Prerequisites**: Ensure IMPL_PLAN.md and TODO_LIST.md exist and are valid
 
 **Resume Mode Behavior**:
-- Load existing session state directly from `.workflow/{session-id}/`
-- Use session's task files and summaries without discovery
-- Generate TodoWrite from current session progress
-- Proceed immediately to agent execution
+- Load existing TODO_LIST.md directly from `.workflow/{session-id}/`
+- Extract current progress from TODO_LIST.md
+- Generate TodoWrite from TODO_LIST.md state
+- Proceed immediately to agent execution (Phase 4)
 
-### Phase 4: Execution
-1. **Pass Task with Flow Control**: Include complete task JSON with `pre_analysis` steps for agent execution
-2. **Launch Agent**: Invoke specialized agent with complete context including flow control steps
-3. **Monitor Progress**: Track agent execution and handle errors without user interruption
-4. **Collect Results**: Gather implementation results and outputs
-5. **Continue Workflow**: Automatically proceed to next pending task until completion
+### Phase 4: Execution (Lazy Task Loading)
+**Key Optimization**: Read task JSON **only when needed** for execution
+
+1. **Identify Next Task**: From TodoWrite, get the next `in_progress` task ID
+2. **Load Task JSON on Demand**: Read `.task/{task-id}.json` for current task ONLY
+3. **Validate Task Structure**: Ensure all 5 required fields exist (id, title, status, meta, context, flow_control)
+4. **Pass Task with Flow Control**: Include complete task JSON with `pre_analysis` steps for agent execution
+5. **Launch Agent**: Invoke specialized agent with complete context including flow control steps
+6. **Monitor Progress**: Track agent execution and handle errors without user interruption
+7. **Collect Results**: Gather implementation results and outputs
+8. **Update TODO_LIST.md**: Mark current task as completed in TODO_LIST.md
+9. **Continue Workflow**: Identify next pending task from TODO_LIST.md and repeat from step 1
+
+**Execution Loop Pattern**:
+```
+while (TODO_LIST.md has pending tasks) {
+  next_task_id = getTodoWriteInProgressTask()
+  task_json = Read(.workflow/{session}/.task/{next_task_id}.json)  // Lazy load
+  executeTaskWithAgent(task_json)
+  updateTodoListMarkCompleted(next_task_id)
+  advanceTodoWriteToNextTask()
+}
+```
+
+**Benefits**:
+- Reduces initial context loading by ~90%
+- Only reads task JSON when actually executing
+- Scales better for workflows with many tasks
+- Faster startup time for workflow execution
 
 ### Phase 5: Completion
 1. **Update Task Status**: Mark completed tasks in JSON files
@@ -108,27 +148,33 @@ Orchestrates autonomous workflow execution through systematic task discovery, ag
 
 ## Task Discovery & Queue Building
 
-### Session Discovery Process (Normal Mode)
+### Session Discovery Process (Normal Mode - Optimized)
 ```
 ├── Check for .active-* markers in .workflow/
 ├── If multiple active sessions found → Prompt user to select
 ├── Locate selected session's workflow folder
-├── Load selected session's workflow-session.json and IMPL_PLAN.md
-├── Scan selected session's .task/ directory for task JSON files
-├── Analyze task statuses and dependencies for selected session only
-└── Build execution queue of ready tasks from selected session
+├── Load session metadata: workflow-session.json (minimal context)
+├── Read IMPL_PLAN.md (strategy overview and task summary)
+├── Read TODO_LIST.md (current task statuses and dependencies)
+├── Parse TODO_LIST.md to extract task metadata (NO JSON loading)
+├── Build execution queue from TODO_LIST.md
+└── Generate TodoWrite from TODO_LIST.md state
 ```
 
-### Resume Mode Process (--resume-session flag)
+**Key Change**: Task JSONs are NOT loaded during discovery - they are loaded lazily during execution
+
+### Resume Mode Process (--resume-session flag - Optimized)
 ```
 ├── Use provided session-id directly (skip discovery)
 ├── Validate .workflow/{session-id}/ directory exists
-├── Load session's workflow-session.json and IMPL_PLAN.md directly
-├── Scan session's .task/ directory for task JSON files
-├── Use existing task statuses and dependencies (no re-analysis needed)
-└── Build execution queue from session state (prioritize pending/in-progress tasks)
+├── Read TODO_LIST.md for current progress
+├── Parse TODO_LIST.md to extract task IDs and statuses
+├── Generate TodoWrite from TODO_LIST.md (prioritize in-progress/pending tasks)
+└── Enter Phase 4 (Execution) with lazy task JSON loading
 ```
 
+**Key Change**: Completely skip IMPL_PLAN.md and task JSON loading - use TODO_LIST.md only
+
 ### Task Status Logic
 ```
 pending + dependencies_met → executable
@@ -141,52 +187,72 @@ blocked → skip until dependencies clear
 ### Parallel Execution Algorithm
 **Core principle**: Execute independent tasks concurrently in batches based on dependency graph.
 
-#### Algorithm Steps
+#### Algorithm Steps (Optimized with Lazy Loading)
 ```javascript
 function executeBatchWorkflow(sessionId) {
-  // 1. Build dependency graph from task JSONs
-  const graph = buildDependencyGraph(`.workflow/${sessionId}/.task/*.json`);
+  // 1. Build dependency graph from TODO_LIST.md (NOT task JSONs)
+  const graph = buildDependencyGraphFromTodoList(`.workflow/${sessionId}/TODO_LIST.md`);
 
   // 2. Process batches until graph is empty
   while (!graph.isEmpty()) {
     // 3. Identify current batch (tasks with in-degree = 0)
     const batch = graph.getNodesWithInDegreeZero();
 
-    // 4. Check for parallel execution opportunities
-    const parallelGroups = groupByExecutionGroup(batch);
+    // 4. Load task JSONs ONLY for current batch (lazy loading)
+    const batchTaskJsons = batch.map(taskId =>
+      Read(`.workflow/${sessionId}/.task/${taskId}.json`)
+    );
 
-    // 5. Execute batch concurrently
+    // 5. Check for parallel execution opportunities
+    const parallelGroups = groupByExecutionGroup(batchTaskJsons);
+
+    // 6. Execute batch concurrently
     await Promise.all(
       parallelGroups.map(group => executeBatch(group))
     );
 
-    // 6. Update graph: remove completed tasks and their edges
+    // 7. Update graph: remove completed tasks and their edges
     graph.removeNodes(batch);
 
-    // 7. Update TodoWrite to reflect completed batch
+    // 8. Update TODO_LIST.md and TodoWrite to reflect completed batch
+    updateTodoListAfterBatch(batch);
     updateTodoWriteAfterBatch(batch);
   }
 
-  // 8. All tasks complete - auto-complete session
+  // 9. All tasks complete - auto-complete session
   SlashCommand("/workflow:session:complete");
 }
 
-function buildDependencyGraph(taskFiles) {
-  const tasks = loadAllTaskJSONs(taskFiles);
+function buildDependencyGraphFromTodoList(todoListPath) {
+  const todoContent = Read(todoListPath);
+  const tasks = parseTodoListTasks(todoContent);
   const graph = new DirectedGraph();
 
   tasks.forEach(task => {
-    graph.addNode(task.id, task);
-
-    // Add edges for dependencies
-    task.context.depends_on?.forEach(depId => {
-      graph.addEdge(depId, task.id); // Edge from dependency to task
-    });
+    graph.addNode(task.id, { id: task.id, title: task.title, status: task.status });
+    task.dependencies?.forEach(depId => graph.addEdge(depId, task.id));
   });
 
   return graph;
 }
 
+function parseTodoListTasks(todoContent) {
+  // Parse: - [ ] **IMPL-001**: Task title → [📋](./.task/IMPL-001.json)
+  const taskPattern = /- \[([ x])\] \*\*([A-Z]+-\d+(?:\.\d+)?)\*\*: (.+?) →/g;
+  const tasks = [];
+  let match;
+
+  while ((match = taskPattern.exec(todoContent)) !== null) {
+    tasks.push({
+      status: match[1] === 'x' ? 'completed' : 'pending',
+      id: match[2],
+      title: match[3]
+    });
+  }
+
+  return tasks;
+}
+
 function groupByExecutionGroup(tasks) {
   const groups = {};
 
@@ -338,11 +404,12 @@ TodoWrite({
 - **Workflow Completion Check**: When all tasks marked `completed`, auto-call `/workflow:session:complete`
 
 #### TODO_LIST.md Update Timing
-- **Before Agent Launch**: Update TODO_LIST.md to mark task as `in_progress` (⚠️)
-- **After Task Complete**: Update TODO_LIST.md to mark as `completed` (✅), advance to next
-- **On Error**: Keep as `in_progress` in TODO_LIST.md, add error note
-- **Workflow Complete**: When all tasks completed, call `/workflow:session:complete`
-- **Session End**: Sync all TODO_LIST.md statuses with JSON task files
+**Single source of truth for task status** - enables lazy loading by providing task metadata without reading JSONs
+
+- **Before Agent Launch**: Mark task as `in_progress` (⚠️)
+- **After Task Complete**: Mark as `completed` (✅), advance to next
+- **On Error**: Keep as `in_progress`, add error note
+- **Workflow Complete**: Call `/workflow:session:complete`
 
 ### 3. Agent Context Management
 **Comprehensive context preparation** for autonomous agent execution:
@@ -423,7 +490,7 @@ Task(subagent_type="{meta.agent}",
      3. **Implement Solution**: Follow `flow_control.implementation_approach` using accumulated context
      4. **Complete Task**:
         - Update task status: `jq '.status = \"completed\"' {session.task_json_path} > temp.json && mv temp.json {session.task_json_path}`
-        - Update TODO list: {session.todo_list_path}
+        - Update TODO_LIST.md: Mark task as [x] completed in {session.todo_list_path}
         - Generate summary: {session.summaries_dir}/{task.id}-summary.md
         - Check workflow completion and call `/workflow:session:complete` if all tasks done
 

.claude/commands/workflow/plan.md

@@ -216,7 +216,7 @@ TodoWrite({todos: [
 TodoWrite({todos: [
   {"content": "Execute session discovery", "status": "completed", "activeForm": "Executing session discovery"},
   {"content": "Execute context gathering", "status": "completed", "activeForm": "Executing context gathering"},
-  {"content": "Execute conflict resolution", "status": "in_progress", "activeForm": "Executing conflict resolution"},
+  {"content": "Resolve conflicts and apply fixes", "status": "in_progress", "activeForm": "Resolving conflicts"},
   {"content": "Execute task generation", "status": "pending", "activeForm": "Executing task generation"}
 ]})
 
@@ -231,7 +231,7 @@ TodoWrite({todos: [
 TodoWrite({todos: [
   {"content": "Execute session discovery", "status": "completed", "activeForm": "Executing session discovery"},
   {"content": "Execute context gathering", "status": "completed", "activeForm": "Executing context gathering"},
-  {"content": "Execute conflict resolution", "status": "completed", "activeForm": "Executing conflict resolution"},
+  {"content": "Resolve conflicts and apply fixes", "status": "completed", "activeForm": "Resolving conflicts"},
   {"content": "Execute task generation", "status": "in_progress", "activeForm": "Executing task generation"}
 ]})
 ```
@@ -286,12 +286,18 @@ Phase 2: context-gather --session sessionId "structured-description"
     ↓
 Phase 3: conflict-resolution [AUTO-TRIGGERED if conflict_risk ≥ medium]
     ↓ Input: sessionId + contextPath + conflict_risk
-    ↓ CLI-powered conflict detection and resolution strategy generation
-    ↓ Output: CONFLICT_RESOLUTION.md (if conflict_risk ≥ medium)
+    ↓ CLI-powered conflict detection (JSON output)
+    ↓ AskUserQuestion: Present conflicts + resolution strategies
+    ↓ User selects strategies (or skip)
+    ↓ Apply modifications via Edit tool:
+    ↓   - Update guidance-specification.md
+    ↓   - Update role analyses (*.md)
+    ↓   - Mark context-package.json as "resolved"
+    ↓ Output: Modified brainstorm artifacts (NO report file)
     ↓ Skip if conflict_risk is none/low → proceed directly to Phase 4
     ↓
 Phase 4: task-generate[--agent] --session sessionId
-    ↓ Input: sessionId + conflict resolution decisions (if exists) + session memory
+    ↓ Input: sessionId + resolved brainstorm artifacts + session memory
     ↓ Output: IMPL_PLAN.md, task JSONs, TODO_LIST.md
     ↓
 Return summary to user
@@ -300,8 +306,7 @@ Return summary to user
 **Session Memory Flow**: Each phase receives session ID, which provides access to:
 - Previous task summaries
 - Existing context and analysis
-- Brainstorming artifacts
-- Conflict resolution decisions (if Phase 3 executed)
+- Brainstorming artifacts (potentially modified by Phase 3)
 - Session-specific configuration
 
 **Structured Description Benefits**:

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

@@ -1,6 +1,6 @@
 ---
 name: complete
-description: Mark the active workflow session as complete and remove active flag
+description: Mark the active workflow session as complete, archive it with lessons learned, and remove active flag
 examples:
   - /workflow:session:complete
   - /workflow:session:complete --detailed
@@ -9,7 +9,7 @@ examples:
 # Complete Workflow Session (/workflow:session:complete)
 
 ## Overview
-Mark the currently active workflow session as complete, update its status, and remove the active flag marker.
+Mark the currently active workflow session as complete, analyze it for lessons learned, move it to the archive directory, and remove the active flag marker.
 
 ## Usage
 ```bash
@@ -19,87 +19,129 @@ Mark the currently active workflow session as complete, update its status, and r
 
 ## Implementation Flow
 
-### Step 1: Find Active Session
+### Phase 1: Prepare for Archival (Minimal Manual Operations)
+
+**Purpose**: Find active session, move to archive location, pass control to agent. Minimal operations.
+
+#### Step 1.1: Find Active Session and Get Name
 ```bash
-ls .workflow/.active-* 2>/dev/null | head -1
-```
+# Find active marker
+bash(find .workflow/ -name ".active-*" -type f | head -1)
 
-### Step 2: Get Session Name
+# Extract session name from marker path
+bash(basename .workflow/.active-WFS-session-name | sed 's/^\.active-//')
+```
+**Output**: Session name `WFS-session-name`
+
+#### Step 1.2: Move Session to Archive
 ```bash
-basename .workflow/.active-WFS-session-name | sed 's/^\.active-//'
+# Create archive directory if needed
+bash(mkdir -p .workflow/.archives/)
+
+# Move session to archive location
+bash(mv .workflow/WFS-session-name .workflow/.archives/WFS-session-name)
+```
+**Result**: Session now at `.workflow/.archives/WFS-session-name/`
+
+### Phase 2: Agent-Orchestrated Completion (All Data Processing)
+
+**Purpose**: Agent analyzes archived session, generates metadata, updates manifest, and removes active marker.
+
+#### Agent Invocation
+
+Invoke `universal-executor` agent to complete the archival process.
+
+**Agent Task**:
+```
+Task(
+  subagent_type="universal-executor",
+  description="Complete session archival",
+  prompt=`
+Complete workflow session archival. Session already moved to archive location.
+
+## Context
+- Session: .workflow/.archives/WFS-session-name/
+- Active marker: .workflow/.active-WFS-session-name
+
+## Tasks
+
+1. **Extract session data** from workflow-session.json (session_id, description/topic, started_at/timestamp, completed_at, status)
+   - If status != "completed", update it with timestamp
+
+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 (fallback: analyze files directly)
+   - Return: {successes, challenges, watch_patterns}
+
+4. **Build archive entry**:
+   - Calculate: duration_hours, success_rate, tags (3-5 keywords)
+   - Construct complete JSON with session_id, description, archived_at, archive_path, metrics, tags, lessons
+
+5. **Update manifest**: Initialize .workflow/.archives/manifest.json if needed, append entry
+
+6. **Remove active marker**
+
+7. **Return result**: {"status": "success", "session_id": "...", "archived_at": "...", "metrics": {...}, "lessons_summary": {...}}
+
+## Error Handling
+- On failure: return {"status": "error", "task": "...", "message": "..."}
+- Do NOT remove marker if failed
+  `
+)
 ```
 
-### Step 3: Update Session Status
+**Expected Output**:
+- Agent returns JSON result confirming successful archival
+- Display completion summary to user based on agent response
+
+## Workflow Execution Strategy
+
+### Two-Phase Approach (Optimized)
+
+**Phase 1: Minimal Manual Setup** (2 simple operations)
+- Find active session and extract name
+- Move session to archive location
+- **No data extraction** - agent handles all data processing
+- **No counting** - agent does this from archive location
+- **Total**: 2 bash commands (find + move)
+
+**Phase 2: Agent-Driven Completion** (1 agent invocation)
+- Extract all session data from archived location
+- Count tasks and summaries
+- Generate lessons learned analysis
+- Build complete archive metadata
+- Update manifest
+- Remove active marker
+- Return success/error result
+
+## Quick Commands
+
 ```bash
-jq '.status = "completed"' .workflow/WFS-session/workflow-session.json > temp.json
-mv temp.json .workflow/WFS-session/workflow-session.json
+# Phase 1: Find and move
+bash(find .workflow/ -name ".active-*" -type f | head -1)
+bash(basename .workflow/.active-WFS-session-name | sed 's/^\.active-//')
+bash(mkdir -p .workflow/.archives/)
+bash(mv .workflow/WFS-session-name .workflow/.archives/WFS-session-name)
+
+# Phase 2: Agent completes archival
+Task(subagent_type="universal-executor", description="Complete session archival", prompt=`...`)
 ```
 
-### Step 4: Add Completion Timestamp
+## Archive Query Commands
+
+After archival, you can query the manifest:
+
 ```bash
-jq '.completed_at = "'$(date -u +%Y-%m-%dT%H:%M:%SZ)'"' .workflow/WFS-session/workflow-session.json > temp.json
-mv temp.json .workflow/WFS-session/workflow-session.json
+# List all archived sessions
+jq '.archives[].session_id' .workflow/.archives/manifest.json
+
+# Find sessions by keyword
+jq '.archives[] | select(.description | test("auth"; "i"))' .workflow/.archives/manifest.json
+
+# Get specific session details
+jq '.archives[] | select(.session_id == "WFS-user-auth")' .workflow/.archives/manifest.json
+
+# List all watch patterns across sessions
+jq '.archives[].lessons.watch_patterns[]' .workflow/.archives/manifest.json
 ```
 
-### Step 5: Count Final Statistics
-```bash
-find .workflow/WFS-session/.task/ -name "*.json" -type f 2>/dev/null | wc -l
-find .workflow/WFS-session/.summaries/ -name "*.md" -type f 2>/dev/null | wc -l
-```
-
-### Step 6: Remove Active Marker
-```bash
-rm .workflow/.active-WFS-session-name
-```
-
-## Simple Bash Commands
-
-### Basic Operations
-- **Find active session**: `find .workflow/ -name ".active-*" -type f`
-- **Get session name**: `basename marker | sed 's/^\.active-//'`
-- **Update status**: `jq '.status = "completed"' session.json > temp.json`
-- **Add timestamp**: `jq '.completed_at = "'$(date -u +%Y-%m-%dT%H:%M:%SZ)'"'`
-- **Count tasks**: `find .task/ -name "*.json" -type f | wc -l`
-- **Count completed**: `find .summaries/ -name "*.md" -type f 2>/dev/null | wc -l`
-- **Remove marker**: `rm .workflow/.active-session`
-
-### Completion Result
-```
-Session WFS-user-auth completed
-- Status: completed
-- Started: 2025-09-15T10:00:00Z
-- Completed: 2025-09-15T16:30:00Z
-- Duration: 6h 30m
-- Total tasks: 8
-- Completed tasks: 8
-- Success rate: 100%
-```
-
-### Detailed Summary (--detailed flag)
-```
-Session Completion Summary:
-├── Session: WFS-user-auth
-├── Project: User authentication system
-├── Total time: 6h 30m
-├── Tasks completed: 8/8 (100%)
-├── Files generated: 24 files
-├── Summaries created: 8 summaries
-├── Status: All tasks completed successfully
-└── Location: .workflow/WFS-user-auth/
-```
-
-### Error Handling
-```bash
-# No active session
-find .workflow/ -name ".active-*" -type f 2>/dev/null || echo "No active session found"
-
-# Incomplete tasks
-task_count=$(find .task/ -name "*.json" -type f | wc -l)
-summary_count=$(find .summaries/ -name "*.md" -type f 2>/dev/null | wc -l)
-test $task_count -eq $summary_count || echo "Warning: Not all tasks completed"
-```
-
-## Related Commands
-- `/workflow:session:list` - View all sessions including completed
-- `/workflow:session:start` - Start new session
-- `/workflow:status` - Check completion status before completing

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

@@ -7,361 +7,465 @@ examples:
   - /workflow:tools:conflict-resolution --session WFS-payment --context .workflow/WFS-payment/.process/context-package.json
 ---
 
-# Conflict Resolution Command (/workflow:tools:conflict-resolution)
+# Conflict Resolution Command
 
-## Overview
-Analyzes potential conflicts between implementation plan and existing codebase, generating multiple resolution strategies for user selection.
+## Purpose
+Analyzes conflicts between implementation plans and existing codebase, generating multiple resolution strategies.
 
-**Trigger Condition**: Only execute when context-package.json indicates conflict_risk is "medium" or "high"
+**Scope**: Detection and strategy generation only - NO code modification or task creation.
 
-**Scope**: Conflict detection and resolution strategy generation only. Does NOT modify code or generate tasks.
+**Trigger**: Auto-executes in `/workflow:plan` Phase 3 when `conflict_risk ≥ medium`.
 
-**Usage**: Automatically triggered in `/workflow:plan` Phase 3 when conflict risk detected.
+## Core Responsibilities
 
-## Core Philosophy & Responsibilities
-- **Conflict Detection**: Analyze plan vs existing code architecture inconsistencies
-- **Multi-Strategy Generation**: Generate 2-4 resolution options per conflict
-- **CLI-Powered Analysis**: Use Gemini/Qwen/Codex for deep code analysis
-- **Graceful Fallback**: Use Claude analysis if CLI tools unavailable
-- **User Decision**: Present strategies for user selection, never auto-apply
-- **Single Output**: Generate CONFLICT_RESOLUTION.md with findings and options
+| Responsibility | Description |
+|---------------|-------------|
+| **Detect Conflicts** | Analyze plan vs existing code inconsistencies |
+| **Generate Strategies** | Provide 2-4 resolution options per conflict |
+| **CLI Analysis** | Use Gemini/Qwen (Claude fallback) |
+| **User Decision** | Present options, never auto-apply |
+| **Single Output** | `CONFLICT_RESOLUTION.md` with findings |
 
-## Conflict Detection Categories
+## Conflict Categories
 
-**Architecture Conflicts**:
-- New architecture incompatible with existing patterns
-- Module structure changes affecting existing components
-- Design pattern migrations required
+### 1. Architecture Conflicts
+- Incompatible design patterns
+- Module structure changes
+- Pattern migration requirements
 
-**API & Interface Conflicts**:
-- Breaking changes to existing API contracts
-- Function signature modifications
-- Public interface changes affecting dependents
+### 2. API Conflicts
+- Breaking contract changes
+- Signature modifications
+- Public interface impacts
 
-**Data Model Conflicts**:
-- Database schema modifications
-- Data type changes breaking compatibility
-- Migration requirements for existing data
+### 3. Data Model Conflicts
+- Schema modifications
+- Type breaking changes
+- Data migration needs
 
-**Dependency Conflicts**:
-- Version conflicts with existing dependencies
-- New dependencies incompatible with current setup
-- Breaking changes in dependency updates
+### 4. Dependency Conflicts
+- Version incompatibilities
+- Setup conflicts
+- Breaking updates
 
-## Execution Lifecycle
+## Execution Flow
 
-### Phase 1: Validation & Trigger Check
-1. **Session Validation**: Verify `.workflow/{session_id}/` exists
-2. **Context Package Loading**: Read and parse context-package.json
-3. **Conflict Risk Check**:
-   ```javascript
-   if (context_package.conflict_detection.conflict_risk in ["none", "low"]) {
-     SKIP: "No significant conflicts detected"
-     EXIT
-   }
-   ```
-4. **Agent Preparation**: Prepare agent task prompt with conflict analysis requirements
+### Phase 1: Validation
+```
+1. Verify session directory exists
+2. Load context-package.json
+3. Check conflict_risk (skip if none/low)
+4. Prepare agent task prompt
+```
 
-### Phase 2: Agent-Delegated Conflict Analysis
+### Phase 2: CLI-Powered Analysis
 
-**Agent Invocation**:
+**Agent Delegation**:
 ```javascript
-Task(
-  subagent_type="cli-execution-agent",
-  description="Detect and analyze code conflicts",
-  prompt=`
-## Execution Context
+Task(subagent_type="cli-execution-agent", prompt=`
+  ## Context
+  - Session: {session_id}
+  - Risk: {conflict_risk}
+  - Files: {existing_files_list}
 
-**Session ID**: {session_id}
-**Mode**: Conflict Detection and Resolution Strategy Generation
-**Conflict Risk**: {conflict_risk}
+  ## Analysis Steps
 
-## Input Context
+  ### 1. Load Context
+  - Read existing files from conflict_detection.existing_files
+  - Load plan from .workflow/{session_id}/.process/context-package.json
+  - Extract role analyses and requirements
 
-**Context Package**: {context_path}
-**Existing Files**: {existing_files_list}
-**Affected Modules**: {affected_modules}
+  ### 2. Execute CLI Analysis
 
-## Analysis Task
+  Primary (Gemini):
+  cd {project_root} && gemini -p "
+  PURPOSE: Detect conflicts between plan and codebase
+  TASK:
+  • Compare architectures
+  • Identify breaking API changes
+  • Detect data model incompatibilities
+  • Assess dependency conflicts
+  MODE: analysis
+  CONTEXT: @{existing_files} @.workflow/{session_id}/**/*
+  EXPECTED: Conflict list with severity ratings
+  RULES: Focus on breaking changes and migration needs
+  "
 
-### Step 1: Load Existing Codebase Context
-1. **Load Existing Files** (from context package existing_files)
-   - Read all files listed in conflict_detection.existing_files
-   - Analyze current architecture patterns
-   - Identify current API contracts and interfaces
+  Fallback: Qwen (same prompt) → Claude (manual analysis)
 
-2. **Load Plan Requirements** (from context-package.json)
-   - Read .workflow/{session_id}/.process/context-package.json
-   - Extract role analysis paths from brainstorm_artifacts.role_analyses[]
-   - Load each role analysis file
-   - Extract requirements and design decisions
-   - Identify planned changes
+  ### 3. Generate Strategies (2-4 per conflict)
 
-### Step 2: CLI-Powered Conflict Analysis
-Execute conflict analysis using CLI tools:
+  Template per conflict:
+  - Severity: Critical/High/Medium
+  - Category: Architecture/API/Data/Dependency
+  - Affected files + impact
+  - Options with pros/cons, effort, risk
+  - Recommended strategy + rationale
 
-**Primary Tool - Gemini Analysis**:
-\`\`\`bash
-cd {project_root} && gemini -p "
-PURPOSE: Analyze conflicts between plan and existing code
-TASK:
-• Compare existing architecture with planned changes
-• Identify API contract breaking changes
-• Detect data model incompatibilities
-• Assess dependency conflicts
-MODE: analysis
-CONTEXT: @{existing_files_pattern} @.workflow/{session_id}/**/*
-EXPECTED: Conflict list with severity and affected areas
-RULES: Focus on breaking changes and migration complexity
-"
-\`\`\`
+  ### 4. Return Structured Conflict Data
 
-**Fallback - Qwen Analysis** (if Gemini unavailable):
-Same prompt structure, replace 'gemini' with 'qwen'
+  ⚠️ DO NOT generate CONFLICT_RESOLUTION.md file
 
-**Fallback - Claude Analysis** (if CLI unavailable):
-- Manual file reading and comparison
-- Pattern matching for common conflict types
-- Heuristic-based conflict detection
+  Return JSON format for programmatic processing:
 
-### Step 3: Generate Resolution Strategies
-For each detected conflict, generate 2-4 resolution options:
+  \`\`\`json
+  {
+    "conflicts": [
+      {
+        "id": "CON-001",
+        "brief": "一行中文冲突摘要",
+        "severity": "Critical|High|Medium",
+        "category": "Architecture|API|Data|Dependency",
+        "affected_files": [
+          ".workflow/{session}/.brainstorm/guidance-specification.md",
+          ".workflow/{session}/.brainstorm/system-architect/analysis.md"
+        ],
+        "description": "详细描述冲突 - 什么不兼容",
+        "impact": {
+          "scope": "影响的模块/组件",
+          "compatibility": "Yes|No|Partial",
+          "migration_required": true|false,
+          "estimated_effort": "人天估计"
+        },
+        "strategies": [
+          {
+            "name": "策略名称（中文）",
+            "approach": "实现方法简述",
+            "complexity": "Low|Medium|High",
+            "risk": "Low|Medium|High",
+            "effort": "时间估计",
+            "pros": ["优点1", "优点2"],
+            "cons": ["缺点1", "缺点2"],
+            "modifications": [
+              {
+                "file": ".workflow/{session}/.brainstorm/guidance-specification.md",
+                "section": "## 2. System Architect Decisions",
+                "change_type": "update",
+                "old_content": "原始内容片段（用于定位）",
+                "new_content": "修改后的内容",
+                "rationale": "为什么这样改"
+              },
+              {
+                "file": ".workflow/{session}/.brainstorm/system-architect/analysis.md",
+                "section": "## Design Decisions",
+                "change_type": "update",
+                "old_content": "原始内容片段",
+                "new_content": "修改后的内容",
+                "rationale": "修改理由"
+              }
+            ]
+          },
+          {
+            "name": "策略2名称",
+            "approach": "...",
+            "complexity": "Medium",
+            "risk": "Low",
+            "effort": "1-2天",
+            "pros": ["优点"],
+            "cons": ["缺点"],
+            "modifications": [...]
+          }
+        ],
+        "recommended": 0,
+        "modification_suggestions": [
+          "建议1：具体的修改方向或注意事项",
+          "建议2：可能需要考虑的边界情况",
+          "建议3：相关的最佳实践或模式"
+        ]
+      }
+    ],
+    "summary": {
+      "total": 2,
+      "critical": 1,
+      "high": 1,
+      "medium": 0
+    }
+  }
+  \`\`\`
 
-**Strategy Template**:
+  ⚠️ CRITICAL Requirements for modifications field:
+  - old_content: Must be exact text from target file (20-100 chars for unique match)
+  - new_content: Complete replacement text (maintains formatting)
+  - change_type: "update" (replace), "add" (insert), "remove" (delete)
+  - file: Full path relative to project root
+  - section: Markdown heading for context (helps locate position)
+  - Minimum 2 strategies per conflict, max 4
+  - All text in Chinese for user-facing fields (brief, name, pros, cons)
+  - modification_suggestions: 2-5 actionable suggestions for custom handling (Chinese)
+
+  Quality Standards:
+  - Each strategy must have actionable modifications
+  - old_content must be precise enough for Edit tool matching
+  - new_content preserves markdown formatting and structure
+  - Recommended strategy (index) based on lowest complexity + risk
+  - modification_suggestions must be specific, actionable, and context-aware
+  - Each suggestion should address a specific aspect (compatibility, migration, testing, etc.)
+`)
+```
+
+**Agent Internal Flow**:
+```
+1. Load context package
+2. Check conflict_risk (exit if none/low)
+3. Read existing files + plan artifacts
+4. Run CLI analysis (Gemini→Qwen→Claude)
+5. Parse conflict findings
+6. Generate 2-4 strategies per conflict with modifications
+7. Return JSON to stdout (NOT file write)
+8. Return execution log path
+```
+
+### Phase 3: User Confirmation via Text Interaction
+
+**Command parses agent JSON output and presents conflicts to user via text**:
+
+```javascript
+// 1. Parse agent JSON output
+const conflictData = JSON.parse(agentOutput);
+const conflicts = conflictData.conflicts; // No 4-conflict limit
+
+// 2. Format conflicts as text output (max 10 per round)
+const batchSize = 10;
+const batches = chunkArray(conflicts, batchSize);
+
+for (const [batchIdx, batch] of batches.entries()) {
+  const totalBatches = batches.length;
+
+  // Output batch header
+  console.log(`===== 冲突解决 (第 ${batchIdx + 1}/${totalBatches} 轮) =====\n`);
+
+  // Output each conflict in batch
+  batch.forEach((conflict, idx) => {
+    const questionNum = batchIdx * batchSize + idx + 1;
+    console.log(`【问题${questionNum} - ${conflict.category}】${conflict.id}: ${conflict.brief}`);
+
+    conflict.strategies.forEach((strategy, sIdx) => {
+      const optionLetter = String.fromCharCode(97 + sIdx); // a, b, c, ...
+      console.log(`${optionLetter}) ${strategy.name}`);
+      console.log(`   说明：${strategy.approach}`);
+      console.log(`   复杂度: ${strategy.complexity} | 风险: ${strategy.risk} | 工作量: ${strategy.effort}`);
+    });
+
+    // Add custom option
+    const customLetter = String.fromCharCode(97 + conflict.strategies.length);
+    console.log(`${customLetter}) 自定义修改`);
+    console.log(`   说明：根据修改建议自行处理，不应用预设策略`);
+
+    // Show modification suggestions
+    if (conflict.modification_suggestions && conflict.modification_suggestions.length > 0) {
+      console.log(`   修改建议：`);
+      conflict.modification_suggestions.forEach(suggestion => {
+        console.log(`   - ${suggestion}`);
+      });
+    }
+    console.log();
+  });
+
+  console.log(`请回答 (格式: 1a 2b 3c...)：`);
+
+  // Wait for user input
+  const userInput = await readUserInput();
+
+  // Parse answers
+  const answers = parseUserAnswers(userInput, batch);
+}
+
+// 3. Build selected strategies (exclude custom selections)
+const selectedStrategies = answers.filter(a => !a.isCustom).map(a => a.strategy);
+const customConflicts = answers.filter(a => a.isCustom).map(a => ({
+  id: a.conflict.id,
+  brief: a.conflict.brief,
+  suggestions: a.conflict.modification_suggestions
+}));
+```
+
+**Text Output Example**:
 ```markdown
-### Conflict: {conflict_name}
-**Severity**: Critical | High | Medium
-**Category**: Architecture | API | Data Model | Dependency
-**Affected Files**: {file_list}
-**Impact**: {impact_description}
+===== 冲突解决 (第 1/1 轮) =====
 
-#### Option 1: {strategy_name}
-**Approach**: {brief_description}
-**Pros**:
-- {advantage_1}
-- {advantage_2}
-**Cons**:
-- {disadvantage_1}
-- {disadvantage_2}
-**Effort**: Low | Medium | High
-**Risk**: Low | Medium | High
+【问题1 - Architecture】CON-001: 现有认证系统与计划不兼容
+a) 渐进式迁移
+   说明：保留现有系统，逐步迁移到新方案
+   复杂度: Medium | 风险: Low | 工作量: 3-5天
+b) 完全重写
+   说明：废弃旧系统，从零实现新认证
+   复杂度: High | 风险: Medium | 工作量: 7-10天
+c) 自定义修改
+   说明：根据修改建议自行处理，不应用预设策略
+   修改建议：
+   - 评估现有认证系统的兼容性，考虑是否可以通过适配器模式桥接
+   - 检查JWT token格式和验证逻辑是否需要调整
+   - 确保用户会话管理与新架构保持一致
 
-#### Option 2: {strategy_name}
-...
+【问题2 - Data】CON-002: 数据库 schema 冲突
+a) 添加迁移脚本
+   说明：创建数据库迁移脚本处理 schema 变更
+   复杂度: Low | 风险: Low | 工作量: 1-2天
+b) 自定义修改
+   说明：根据修改建议自行处理，不应用预设策略
+   修改建议：
+   - 检查现有表结构是否支持新增字段，避免破坏性变更
+   - 考虑使用数据库版本控制工具（如Flyway或Liquibase）
+   - 准备数据迁移和回滚策略
 
-**Recommended**: Option {N} - {rationale}
+请回答 (格式: 1a 2b)：
 ```
 
-### Step 4: Generate CONFLICT_RESOLUTION.md
-Create comprehensive conflict resolution document:
+**User Input Examples**:
+- `1a 2a` → Conflict 1: 渐进式迁移, Conflict 2: 添加迁移脚本
+- `1b 2b` → Conflict 1: 完全重写, Conflict 2: 自定义修改
+- `1c 2c` → Both choose custom modification (user handles manually with suggestions)
 
-**Output Location**: \`.workflow/{session_id}/.process/CONFLICT_RESOLUTION.md\`
+### Phase 4: Apply Modifications
 
-**Required Structure**:
-1. **Executive Summary**: Total conflicts, severity distribution, overall risk
-2. **Conflict Analysis**: Detailed per-conflict analysis with categories
-3. **Resolution Strategies**: Multiple options per conflict with pros/cons
-4. **Recommended Actions**: Prioritized recommendations with rationale
-5. **Migration Considerations**: Data/API migration requirements if any
+```javascript
+// 1. Extract modifications from selected strategies
+const modifications = [];
+selectedStrategies.forEach(strategy => {
+  if (strategy !== "skip") {
+    modifications.push(...strategy.modifications);
+  }
+});
 
-### Output Requirements
+// 2. Apply each modification using Edit tool
+modifications.forEach(mod => {
+  if (mod.change_type === "update") {
+    Edit({
+      file_path: mod.file,
+      old_string: mod.old_content,
+      new_string: mod.new_content
+    });
+  }
+  // Handle "add" and "remove" similarly
+});
 
-**Quality Standards**:
-- Minimum 2 resolution options per conflict
-- Clear pros/cons for each strategy
-- Effort and risk estimates included
-- Recommended strategy with clear rationale
-- Actionable migration steps if required
+// 3. Update context-package.json
+const contextPackage = JSON.parse(Read(contextPath));
+contextPackage.conflict_detection.conflict_risk = "resolved";
+contextPackage.conflict_detection.resolved_conflicts = conflicts.map(c => c.id);
+contextPackage.conflict_detection.resolved_at = new Date().toISOString();
+Write(contextPath, JSON.stringify(contextPackage, null, 2));
 
-## Output
-Generate CONFLICT_RESOLUTION.md and report completion status:
-- Conflicts detected: {count}
-- Severity distribution: Critical: {N}, High: {N}, Medium: {N}
-- Resolution strategies: {total_options}
-- Output location: .workflow/{session_id}/.process/CONFLICT_RESOLUTION.md
-\`
-)
+// 4. Output custom conflict summary (if any)
+if (customConflicts.length > 0) {
+  console.log("\n===== 需要自定义处理的冲突 =====\n");
+  customConflicts.forEach(conflict => {
+    console.log(`【${conflict.id}】${conflict.brief}`);
+    console.log("修改建议：");
+    conflict.suggestions.forEach(suggestion => {
+      console.log(`  - ${suggestion}`);
+    });
+    console.log();
+  });
+}
+
+// 5. Return summary
+return {
+  resolved: modifications.length,
+  custom: customConflicts.length,
+  modified_files: [...new Set(modifications.map(m => m.file))],
+  custom_conflicts: customConflicts
+};
 ```
 
-**Agent Execution Flow** (Internal to cli-execution-agent):
-1. Parse session ID and context path, load context-package.json
-2. Check conflict_risk, exit if none/low
-3. Load existing codebase files from conflict_detection.existing_files
-4. Load plan requirements from session brainstorming artifacts
-5. Execute CLI tool analysis (Gemini/Qwen/Claude fallback)
-6. Parse conflict findings from CLI output
-7. Generate resolution strategies (2-4 options per conflict)
-8. Create CONFLICT_RESOLUTION.md with structured findings
-9. Verify output file exists at correct path
-10. Return execution log path
-
-**Command Execution**: Launch agent via Task tool, wait for completion
-
-### Phase 3: Output Validation
-1. **File Verification**: Confirm `.workflow/{session_id}/.process/CONFLICT_RESOLUTION.md` exists
-2. **Content Validation**: Verify required sections present
-3. **Strategy Quality**: Ensure minimum 2 options per conflict
-4. **Agent Log**: Retrieve agent execution log from `.workflow/{session_id}/.chat/`
-5. **Success Criteria**: File exists, contains all required sections, strategies actionable
-
-## CONFLICT_RESOLUTION.md Format
-
-**Template Reference**: Resolution document focuses on **conflict identification, impact analysis, and strategic options** (NOT implementation).
-
-### Required Structure
-
-```markdown
-# Conflict Resolution Report
-
-**Session**: WFS-{session-id}
-**Generated**: {timestamp}
-**Conflict Risk**: {medium|high}
-**Total Conflicts**: {count}
-
-## Executive Summary
-
-**Overall Assessment**: {summary_paragraph}
-
-**Severity Distribution**:
-- Critical: {count} - Blocking issues requiring immediate resolution
-- High: {count} - Significant issues affecting core functionality
-- Medium: {count} - Moderate issues with workarounds available
-
-**Recommended Priority**: {conflict_id_1}, {conflict_id_2}, ...
-
----
-
-## Conflict Analysis
-
-### Conflict 1: {conflict_name}
-**ID**: CON-001
-**Severity**: Critical | High | Medium
-**Category**: Architecture | API | Data Model | Dependency
-**Affected Files**:
-- {file_1}
-- {file_2}
-
-**Description**: {detailed_conflict_description}
-
-**Impact Analysis**:
-- **Scope**: {which_modules_affected}
-- **Backward Compatibility**: {yes/no/partial}
-- **Migration Required**: {yes/no}
-- **Estimated Effort**: {person-days}
-
-#### Resolution Strategies
-
-##### Option 1: {strategy_name}
-**Approach**: {implementation_approach}
-
-**Pros**:
-- {advantage_1}
-- {advantage_2}
-
-**Cons**:
-- {disadvantage_1}
-- {disadvantage_2}
-
-**Implementation Complexity**: Low | Medium | High
-**Risk Level**: Low | Medium | High
-**Estimated Effort**: {time_estimate}
-
-##### Option 2: {strategy_name}
-...
-
-**Recommended Strategy**: Option {N}
-**Rationale**: {why_this_option_is_best}
-
----
-
-## Recommended Actions
-
-### Priority 1: Address Critical Conflicts
-1. {conflict_id}: {brief_action} - {recommended_strategy}
-2. ...
-
-### Priority 2: Resolve High-Severity Issues
-1. {conflict_id}: {brief_action} - {recommended_strategy}
-2. ...
-
-### Priority 3: Handle Medium Issues
-1. {conflict_id}: {brief_action} - {recommended_strategy}
-2. ...
-
-## Migration Considerations
-
-**Data Migration**:
-- {migration_task_1}
-- {migration_task_2}
-
-**API Versioning**:
-- {versioning_strategy}
-
-**Rollback Strategy**:
-- {rollback_plan}
-
----
-
-## Next Steps
-
-**Before Implementation**:
-1. Review and select resolution strategies
-2. Update IMPL_PLAN.md with conflict resolution decisions
-3. Validate migration requirements
-
-**Proceed to**:
-- /workflow:plan continue → Proceed with task generation
+**Validation**:
+```
+✓ Agent returns valid JSON structure
+✓ Text output displays all conflicts (max 10 per round)
+✓ User selections captured correctly
+✓ Edit tool successfully applies modifications
+✓ guidance-specification.md updated
+✓ Role analyses (*.md) updated
+✓ context-package.json marked as resolved
+✓ Agent log saved to .workflow/{session_id}/.chat/
 ```
 
-### Content Focus
-- ✅ Conflict detection with severity classification
-- ✅ Multiple resolution strategies per conflict
-- ✅ Pros/cons analysis for each strategy
-- ✅ Effort and risk estimates
-- ✅ Migration considerations
-- ❌ Direct code changes or patches
-- ❌ Implementation details (save for IMPL_PLAN)
-- ❌ Task breakdowns (handled by task generation)
+## Output Format: Agent JSON Response
 
-## Execution Management
+**Focus**: Structured conflict data with actionable modifications for programmatic processing.
 
-### Error Handling & Recovery
-1. **Pre-execution**: Verify conflict_risk warrants execution
-2. **Agent Monitoring**: Track agent execution status via Task tool
-3. **Validation**: Check CONFLICT_RESOLUTION.md generation on completion
-4. **Error Recovery**:
-   - Agent execution failure → report error, check agent logs
-   - Missing output file → retry agent execution once
-   - CLI tool failure → fallback to Claude analysis
-5. **Graceful Degradation**: If all analysis methods fail, generate basic conflict report from heuristics
+**Format**: JSON to stdout (NO file generation)
 
-## Integration & Success Criteria
+**Structure**: Defined in Phase 2, Step 4 (agent prompt)
 
-### Input/Output Interface
+### Key Requirements
+| Requirement | Details |
+|------------|---------|
+| **Conflict batching** | Max 10 conflicts per round (no total limit) |
+| **Strategy count** | 2-4 strategies per conflict |
+| **Modifications** | Each strategy includes file paths, old_content, new_content |
+| **User-facing text** | Chinese (brief, strategy names, pros/cons) |
+| **Technical fields** | English (severity, category, complexity, risk) |
+| **old_content precision** | 20-100 chars for unique Edit tool matching |
+| **File targets** | guidance-specification.md, role analyses (*.md) |
+
+## Error Handling
+
+### Recovery Strategy
+```
+1. Pre-check: Verify conflict_risk ≥ medium
+2. Monitor: Track agent via Task tool
+3. Validate: Parse agent JSON output
+4. Recover:
+   - Agent failure → check logs + report error
+   - Invalid JSON → retry once with Claude fallback
+   - CLI failure → fallback to Claude analysis
+   - Edit tool failure → report affected files + rollback option
+   - User cancels → mark as "unresolved", continue to task-generate
+5. Degrade: If all fail, generate minimal conflict report and skip modifications
+```
+
+### Rollback Handling
+```
+If Edit tool fails mid-application:
+1. Log all successfully applied modifications
+2. Output rollback option via text interaction
+3. If rollback selected: restore files from git or backups
+4. If continue: mark partial resolution in context-package.json
+```
+
+## Integration
+
+### Interface
 **Input**:
-- `--session` (required): Session ID (e.g., WFS-auth)
-- `--context` (required): Context package path
-- Context package must have conflict_risk ≥ medium
+- `--session` (required): WFS-{session-id}
+- `--context` (required): context-package.json path
+- Requires: `conflict_risk ≥ medium`
 
 **Output**:
-- Single file: `CONFLICT_RESOLUTION.md` at `.workflow/{session_id}/.process/`
-- No code modifications
+- Modified files:
+  - `.workflow/{session_id}/.brainstorm/guidance-specification.md`
+  - `.workflow/{session_id}/.brainstorm/{role}/analysis.md`
+  - `.workflow/{session_id}/.process/context-package.json` (conflict_risk → resolved)
+- NO report file generation
 
-### Quality & Success Validation
-**Quality Checks**: Completeness, strategy diversity, actionability
+**User Interaction**:
+- Text-based strategy selection (max 10 conflicts per round)
+- Each conflict: 2-4 strategy options + "自定义修改" option (with suggestions)
 
-**Success Criteria**:
-- ✅ Conflict detection complete (all categories scanned)
-- ✅ Minimum 2 resolution strategies per conflict
-- ✅ Clear pros/cons for each strategy
-- ✅ Effort and risk estimates provided
-- ✅ Recommended strategy with rationale
-- ✅ Migration considerations documented
-- ✅ CLI-powered analysis (with fallback handling)
-- ✅ Robust error handling (validation, retry, degradation)
-- ✅ Agent execution log saved to session chat directory
+### Success Criteria
+```
+✓ CLI analysis returns valid JSON structure
+✓ Conflicts presented in batches (max 10 per round)
+✓ Min 2 strategies per conflict with modifications
+✓ Each conflict includes 2-5 modification_suggestions
+✓ Text output displays all conflicts correctly with suggestions
+✓ User selections captured and processed
+✓ Edit tool applies modifications successfully
+✓ Custom conflicts displayed with suggestions for manual handling
+✓ guidance-specification.md updated with resolved conflicts
+✓ Role analyses (*.md) updated with resolved conflicts
+✓ context-package.json marked as "resolved"
+✓ No CONFLICT_RESOLUTION.md file generated
+✓ Modification summary includes custom conflict count
+✓ Agent log saved to .workflow/{session_id}/.chat/
+✓ Error handling robust (validate/retry/degrade)
+```
 
 ## Related Commands
-- `/context:gather` - Generates conflict_detection data required by this command
-- `/workflow:plan` - Automatically calls this command when conflict_risk ≥ medium
-- `/task:create` - Creates tasks based on selected resolution strategies
+| Command | Relationship |
+|---------|--------------|
+| `/workflow:tools:context-gather` | Generates input conflict_detection data |
+| `/workflow:plan` | Auto-triggers this when risk ≥ medium |
+| `/workflow:tools:task-generate` | Uses resolved conflicts from updated brainstorm files |
+| `/workflow:brainstorm:artifacts` | Generates guidance-specification.md (modified by this command) |

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

@@ -1,422 +1,282 @@
 ---
 name: gather
-description: Intelligently collect project context using universal-executor agent based on task description and package into standardized JSON
+description: Intelligently collect project context using context-search-agent based on task description and package into standardized JSON
 argument-hint: "--session WFS-session-id \"task description\""
 examples:
   - /workflow:tools:context-gather --session WFS-user-auth "Implement user authentication system"
   - /workflow:tools:context-gather --session WFS-payment "Refactor payment module API"
   - /workflow:tools:context-gather --session WFS-bugfix "Fix login validation error"
+allowed-tools: Task(*), Read(*), Glob(*)
 ---
 
 # Context Gather Command (/workflow:tools:context-gather)
 
 ## Overview
-Agent-driven intelligent context collector that gathers relevant information from project codebase, documentation, and dependencies based on task descriptions, generating standardized context packages.
+
+Orchestrator command that invokes `context-search-agent` to gather comprehensive project context for implementation planning. Generates standardized `context-package.json` with codebase analysis, dependencies, and conflict detection.
+
+**Agent**: `context-search-agent` (`.claude/agents/context-search-agent.md`)
 
 ## Core Philosophy
-- **Agent-Driven**: Delegate execution to universal-executor agent for autonomous operation
-- **Two-Phase Flow**: Discovery (context loading) → Execution (context gathering and packaging)
-- **Memory-First**: Reuse loaded documents from conversation memory
-- **Ripgrep-Enhanced**: Use ripgrep and native tools for code analysis and file discovery
-- **Intelligent Collection**: Auto-identify relevant resources based on keyword analysis
-- **Comprehensive Coverage**: Collect code, documentation, configurations, and dependencies
-- **Standardized Output**: Generate unified format context-package.json
 
-## Execution Lifecycle
+- **Agent Delegation**: Delegate all discovery to `context-search-agent` for autonomous execution
+- **Detection-First**: Check for existing context-package before executing
+- **Plan Mode**: Full comprehensive analysis (vs lightweight brainstorm mode)
+- **Standardized Output**: Generate `.workflow/{session}/.process/context-package.json`
 
-### Phase 1: Discovery & Context Loading
-**⚡ Memory-First Rule**: Skip file loading if documents already in conversation memory
+## Execution Flow
+
+### Step 1: Context-Package Detection
+
+**Execute First** - Check if valid package already exists:
 
-**Agent Context Package**:
 ```javascript
-{
-  "session_id": "WFS-[session-id]",
-  "task_description": "[user provided task description]",
-  "session_metadata": {
-    // If in memory: use cached content
-    // Else: Load from .workflow/{session-id}/workflow-session.json
-  },
-  "search_tools": {
-    // Agent will use these native tools to discover project context
-    "ripgrep": true,
-    "find": true,
-    "exa_code": true,
-    "exa_web": true
+const contextPackagePath = `.workflow/${session_id}/.process/context-package.json`;
+
+if (file_exists(contextPackagePath)) {
+  const existing = Read(contextPackagePath);
+
+  // Validate package belongs to current session
+  if (existing?.metadata?.session_id === session_id) {
+    console.log("✅ Valid context-package found for session:", session_id);
+    console.log("📊 Stats:", existing.statistics);
+    console.log("⚠️  Conflict Risk:", existing.conflict_detection.risk_level);
+    return existing; // Skip execution, return existing
+  } else {
+    console.warn("⚠️ Invalid session_id in existing package, re-generating...");
   }
 }
-
-// Agent will autonomously execute:
-// - Project structure analysis: bash(~/.claude/scripts/get_modules_by_depth.sh)
-// - Documentation loading: Read(CLAUDE.md), Read(README.md)
 ```
 
-**Discovery Actions**:
-1. **Load Session Context** (if not in memory)
-   ```javascript
-   if (!memory.has("workflow-session.json")) {
-     Read(.workflow/{session-id}/workflow-session.json)
-   }
-   ```
+### Step 2: Invoke Context-Search Agent
 
-### Phase 2: Agent Execution (Context Gathering & Packaging)
+**Only execute if Step 1 finds no valid package**
 
-**Agent Invocation**:
 ```javascript
 Task(
-  subagent_type="universal-executor",
-  description="Gather project context and generate context package",
+  subagent_type="context-search-agent",
+  description="Gather comprehensive context for plan",
   prompt=`
-## Execution Context
+You are executing as context-search-agent (.claude/agents/context-search-agent.md).
 
-**Session ID**: WFS-{session-id}
-**Task Description**: {task_description}
-**Mode**: Agent-Driven Context Gathering
+## Execution Mode
+**PLAN MODE** (Comprehensive) - Full Phase 1-3 execution
 
-## Phase 1: Discovery Results (Provided Context)
+## Session Information
+- **Session ID**: ${session_id}
+- **Task Description**: ${task_description}
+- **Output Path**: .workflow/${session_id}/.process/context-package.json
 
-### Session Metadata
-{session_metadata_content}
+## Mission
+Execute complete context-search-agent workflow for implementation planning:
 
-### Search Tools
-- ripgrep: Available for content search and pattern matching
-- find: Available for file discovery
-- exa-code: Available for external research
-- exa-web: Available for web search
+### Phase 1: Initialization & Pre-Analysis
+1. **Detection**: Check for existing context-package (early exit if valid)
+2. **Foundation**: Initialize code-index, get project structure, load docs
+3. **Analysis**: Extract keywords, determine scope, classify complexity
 
-## Phase 2: Context Gathering Task
+### Phase 2: Multi-Source Context Discovery
+Execute all 4 discovery tracks:
+- **Track 1**: Historical archive analysis (query manifest.json for lessons learned)
+- **Track 2**: Reference documentation (CLAUDE.md, architecture docs)
+- **Track 3**: Web examples (use Exa MCP for unfamiliar tech/APIs)
+- **Track 4**: Codebase analysis (5-layer discovery: files, content, patterns, deps, config/tests)
 
-### Core Responsibilities
-1. **Project Structure Analysis**: Execute get_modules_by_depth.sh for architecture overview
-2. **Documentation Loading**: Load CLAUDE.md, README.md and relevant documentation
-3. **Keyword Extraction**: Extract core keywords from task description
-4. **Smart File Discovery**: Use ripgrep and find to locate relevant files
-5. **Code Structure Analysis**: Analyze project structure to identify relevant modules
-6. **Dependency Discovery**: Identify tech stack and dependency relationships
-7. **Context Packaging**: Generate standardized JSON context package
+### Phase 3: Synthesis, Assessment & Packaging
+1. Apply relevance scoring and build dependency graph
+2. Synthesize 4-source data (archive > docs > code > web)
+3. Integrate brainstorm artifacts (if .brainstorming/ exists, read content)
+4. Perform conflict detection with risk assessment
+5. **Inject historical conflicts** from archive analysis into conflict_detection
+6. Generate and validate context-package.json
 
-### Execution Process
+## Output Requirements
+Complete context-package.json with:
+- **metadata**: task_description, keywords, complexity, tech_stack, session_id
+- **project_context**: architecture_patterns, coding_conventions, tech_stack
+- **assets**: {documentation[], source_code[], config[], tests[]} with relevance scores
+- **dependencies**: {internal[], external[]} with dependency graph
+- **brainstorm_artifacts**: {guidance_specification, role_analyses[], synthesis_output} with content
+- **conflict_detection**: {risk_level, risk_factors, affected_modules[], mitigation_strategy, historical_conflicts[]}
 
-#### Step 0: Foundation Setup (Execute First)
-1. **Project Structure Analysis**
-   Execute to get comprehensive architecture overview:
-   \`\`\`javascript
-   bash(~/.claude/scripts/get_modules_by_depth.sh)
-   \`\`\`
-
-2. **Load Project Documentation** (if not in memory)
-   Load core project documentation:
-   \`\`\`javascript
-   Read(CLAUDE.md)
-   Read(README.md)
-   // Load other relevant documentation based on session context
-   \`\`\`
-
-#### Step 1: Task Analysis
-1. **Keyword Extraction**
-   - Parse task description to extract core keywords
-   - Identify technical domain (auth, API, frontend, backend, etc.)
-   - Determine complexity level (simple, medium, complex)
-
-2. **Scope Determination**
-   - Define collection scope based on keywords
-   - Identify potentially involved modules and components
-   - Set file type filters
-
-#### Step 2: File Discovery with Native Tools
-1. **Code File Location**
-   Use ripgrep and find commands:
-   \`\`\`bash
-   # Find files by pattern
-   find . -name "*{keyword}*" -type f
-
-   # Search code content with ripgrep
-   rg "{keyword_patterns}" --type-add 'custom:*.{ts,js,py,go,md}' -t custom -C 3
-
-   # Get file summaries (find function/class definitions)
-   rg "^(class|function|export|def|interface)" relevant/file.ts
-   \`\`\`
-
-2. **Configuration Files Discovery**
-   Locate: package.json, requirements.txt, Cargo.toml, tsconfig.json, etc.
-
-3. **Test Files Location**
-   Find test files related to task keywords
-
-#### Step 3: Intelligent Filtering & Association
-1. **Relevance Scoring**
-   - Score based on keyword match degree
-   - Score based on file path relevance
-   - Score based on code content relevance
-
-2. **Dependency Analysis**
-   - Analyze import/require statements
-   - Identify inter-module dependencies
-   - Determine core and optional dependencies
-
-#### Step 3.5: Brainstorm Artifacts Discovery
-Discover and catalog brainstorming documents (if `.brainstorming/` exists):
-- Guidance specification, role analyses (`*/analysis*.md`), synthesis output
-- Catalog role analyses by role with file type and timestamp
-
-#### Step 4: Context Packaging
-Generate standardized context-package.json following the format below
-
-#### Step 5: Conflict Detection & Risk Assessment
-**Purpose**: Analyze existing codebase to determine conflict risk level
-
-1. **Existing Code Detection**
-   - Count relevant existing source files discovered in Step 2
-   - Identify modules that overlap with task scope
-   - Flag existence of implementations related to task keywords
-
-2. **Architecture Analysis**
-   - Compare task requirements with existing architecture patterns
-   - Identify potential architectural changes required
-   - Detect breaking changes to current structure
-
-3. **API & Dependency Analysis**
-   - Check for existing API endpoints/contracts that may change
-   - Identify shared dependencies and interface changes
-   - Detect potential breaking changes to public APIs
-
-4. **Data Model Analysis**
-   - Identify existing data models/schemas in task scope
-   - Check for schema modification requirements
-   - Detect potential data migration needs
-
-5. **Risk Level Calculation**
-   Calculate conflict_risk based on:
-   - **none**: No existing code, new feature/module
-   - **low**: < 5 existing files, minimal changes
-   - **medium**: 5-15 existing files OR architectural changes OR API changes
-   - **high**: >15 existing files OR data model changes OR breaking changes
-
-### Required Output
-
-**Output Location**: \`.workflow/{session-id}/.process/context-package.json\`
-
-**Output Format**:
-\`\`\`json
-{
-  "metadata": {
-    "task_description": "Implement user authentication system",
-    "timestamp": "2025-09-29T10:30:00Z",
-    "keywords": ["user", "authentication", "JWT", "login"],
-    "complexity": "medium",
-    "tech_stack": ["typescript", "node.js", "express"],
-    "session_id": "WFS-user-auth"
-  },
-  "assets": [
-    {
-      "type": "documentation",
-      "path": "CLAUDE.md",
-      "relevance": "Project development standards and conventions",
-      "priority": "high"
-    },
-    {
-      "type": "documentation",
-      "path": ".workflow/docs/architecture/security.md",
-      "relevance": "Security architecture design guidance",
-      "priority": "high"
-    },
-    {
-      "type": "source_code",
-      "path": "src/auth/AuthService.ts",
-      "relevance": "Existing authentication service implementation",
-      "priority": "high"
-    },
-    {
-      "type": "source_code",
-      "path": "src/models/User.ts",
-      "relevance": "User data model definition",
-      "priority": "medium"
-    },
-    {
-      "type": "config",
-      "path": "package.json",
-      "relevance": "Project dependencies and tech stack",
-      "priority": "medium"
-    },
-    {
-      "type": "test",
-      "path": "tests/auth/*.test.ts",
-      "relevance": "Authentication related test cases",
-      "priority": "medium"
-    }
-  ],
-  "tech_stack": {
-    "frameworks": ["express", "typescript"],
-    "libraries": ["jsonwebtoken", "bcrypt"],
-    "testing": ["jest", "supertest"]
-  },
-  "statistics": {
-    "total_files": 15,
-    "source_files": 8,
-    "docs_files": 4,
-    "config_files": 2,
-    "test_files": 1
-  },
-  "brainstorm_artifacts": {
-    "guidance_specification": {
-      "path": ".workflow/WFS-user-auth/.brainstorming/guidance-specification.md",
-      "exists": true
-    },
-    "role_analyses": [
-      {
-        "role": "system-architect",
-        "files": [
-          {"path": ".workflow/WFS-user-auth/.brainstorming/system-architect/analysis.md", "type": "primary"},
-          {"path": ".workflow/WFS-user-auth/.brainstorming/system-architect/analysis-api.md", "type": "supplementary"}
-        ]
-      },
-      {
-        "role": "ui-designer",
-        "files": [
-          {"path": ".workflow/WFS-user-auth/.brainstorming/ui-designer/analysis.md", "type": "primary"}
-        ]
-      }
-    ],
-    "synthesis_output": {
-      "path": ".workflow/WFS-user-auth/.brainstorming/synthesis-specification.md",
-      "exists": true
-    }
-  },
-  "conflict_detection": {
-    "conflict_risk": "medium",
-    "existing_files": [
-      "src/auth/AuthService.ts",
-      "src/models/User.ts",
-      "src/middleware/auth.ts"
-    ],
-    "has_existing_code": true,
-    "affected_modules": ["auth", "user-model"],
-    "detection_criteria": {
-      "existing_code_count": 8,
-      "architecture_changes": false,
-      "api_changes": true,
-      "data_model_changes": false
-    },
-    "risk_rationale": "Medium risk due to existing auth code and potential API changes"
-  }
-}
-\`\`\`
-
-### Quality Validation
-
-Before completion, verify:
-- [ ] context-package.json created in correct location
+## Quality Validation
+Before completion verify:
 - [ ] Valid JSON format with all required fields
-- [ ] Metadata includes task description, keywords, complexity
-- [ ] Assets array contains relevant files with priorities
-- [ ] Tech stack accurately identified
-- [ ] Statistics section provides file counts
 - [ ] File relevance accuracy >80%
-- [ ] No sensitive information exposed
+- [ ] Dependency graph complete (max 2 transitive levels)
+- [ ] Conflict risk level calculated correctly
+- [ ] No sensitive data exposed
+- [ ] Total files ≤50 (prioritize high-relevance)
 
-### Performance Optimization
-
-**Large Project Optimization**:
-- File count limit: Maximum 50 files per type
-- Size filtering: Skip oversized files (>10MB)
-- Depth limit: Maximum search depth of 3 levels
-- Use ripgrep for efficient discovery
-
-**Native Tools Integration**:
-Agent should use ripgrep and find commands:
-\`\`\`bash
-# Find files by pattern
-find . -name "*{keyword}*" -type f
-
-# Search code content with ripgrep
-rg "{keyword_patterns}" --type ts --type js --type py --type go --type md -C 3
-
-# Alternative: use glob patterns
-rg "{keyword_patterns}" -g "*.{ts,js,py,go,md}" -C 3
-
-# Count matches
-rg "{keyword_patterns}" -c
-
-# List files with matches
-rg "{keyword_patterns}" --files-with-matches
-\`\`\`
-
-## Output
-
-Generate context-package.json and report completion:
-- Task description: {description}
-- Keywords extracted: {count}
-- Files collected: {total}
-  - Source files: {count}
-  - Documentation: {count}
-  - Configuration: {count}
-  - Tests: {count}
-- Tech stack identified: {frameworks/libraries}
-- Output location: .workflow/{session-id}/.process/context-package.json
-\`
+Execute autonomously following agent documentation.
+Report completion with statistics.
+`
 )
-\`\`\`
-
-## Command Integration
-
-### Usage
-```bash
-# Basic usage
-/workflow:tools:context-gather --session WFS-auth "Implement JWT authentication"
-
-# Called by /workflow:plan
-SlashCommand(command="/workflow:tools:context-gather --session WFS-[id] \\"[task description]\\"")
 ```
 
-### Agent Context Passing
+### Step 3: Output Verification
+
+After agent completes, verify output:
 
-**Memory-Aware Context Assembly**:
 ```javascript
-// Assemble minimal context package for agent
-// Agent will execute project structure analysis and documentation loading
-const agentContext = {
-  session_id: "WFS-[id]",
-  task_description: "[user provided task description]",
+// Verify file was created
+const outputPath = `.workflow/${session_id}/.process/context-package.json`;
+if (!file_exists(outputPath)) {
+  throw new Error("❌ Agent failed to generate context-package.json");
+}
+```
 
-  // Use memory if available, else load
-  session_metadata: memory.has("workflow-session.json")
-    ? memory.get("workflow-session.json")
-    : Read(.workflow/WFS-[id]/workflow-session.json),
+## Parameter Reference
 
-  // Search tools - agent will use these native tools
-  search_tools: {
-    ripgrep: true,
-    find: true,
-    exa_code: true,
-    exa_web: true
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `--session` | string | ✅ | Workflow session ID (e.g., WFS-user-auth) |
+| `task_description` | string | ✅ | Detailed task description for context extraction |
+
+## Output Schema
+
+Refer to `context-search-agent.md` Phase 3.7 for complete `context-package.json` schema.
+
+**Key Sections**:
+- **metadata**: Session info, keywords, complexity, tech stack
+- **project_context**: Architecture patterns, conventions, tech stack
+- **assets**: Categorized files with relevance scores (documentation, source_code, config, tests)
+- **dependencies**: Internal and external dependency graphs
+- **brainstorm_artifacts**: Brainstorm documents with full content (if exists)
+- **conflict_detection**: Risk assessment with mitigation strategies and historical conflicts
+
+## Historical Archive Analysis
+
+### Track 1: Query Archive Manifest
+
+The context-search-agent MUST perform historical archive analysis as Track 1 in Phase 2:
+
+**Step 1: Check for Archive Manifest**
+```bash
+# Check if archive manifest exists
+if [[ -f .workflow/.archives/manifest.json ]]; then
+  # Manifest available for querying
+fi
+```
+
+**Step 2: Extract Task Keywords**
+```javascript
+// From current task description, extract key entities and operations
+const keywords = extractKeywords(task_description);
+// Examples: ["User", "model", "authentication", "JWT", "reporting"]
+```
+
+**Step 3: Search Archive for Relevant Sessions**
+```javascript
+// Query manifest for sessions with matching tags or descriptions
+const relevantArchives = archives.filter(archive => {
+  return archive.tags.some(tag => keywords.includes(tag)) ||
+         keywords.some(kw => archive.description.toLowerCase().includes(kw.toLowerCase()));
+});
+```
+
+**Step 4: Extract Watch Patterns**
+```javascript
+// For each relevant archive, check watch_patterns for applicability
+const historicalConflicts = [];
+
+relevantArchives.forEach(archive => {
+  archive.lessons.watch_patterns?.forEach(pattern => {
+    // Check if pattern trigger matches current task
+    if (isPatternRelevant(pattern.pattern, task_description)) {
+      historicalConflicts.push({
+        source_session: archive.session_id,
+        pattern: pattern.pattern,
+        action: pattern.action,
+        files_to_check: pattern.related_files,
+        archived_at: archive.archived_at
+      });
+    }
+  });
+});
+```
+
+**Step 5: Inject into Context Package**
+```json
+{
+  "conflict_detection": {
+    "risk_level": "medium",
+    "risk_factors": ["..."],
+    "affected_modules": ["..."],
+    "mitigation_strategy": "...",
+    "historical_conflicts": [
+      {
+        "source_session": "WFS-auth-feature",
+        "pattern": "When modifying User model",
+        "action": "Check reporting-service and auditing-service dependencies",
+        "files_to_check": ["src/models/User.ts", "src/services/reporting.ts"],
+        "archived_at": "2025-09-16T09:00:00Z"
+      }
+    ]
   }
 }
-
-// Note: Agent will execute these steps autonomously:
-// - bash(~/.claude/scripts/get_modules_by_depth.sh) for project structure
-// - Read(CLAUDE.md) and Read(README.md) for documentation
 ```
 
-## Session ID Integration
+### Risk Level Escalation
 
-### Session ID Usage
-- **Required Parameter**: `--session WFS-session-id`
-- **Session Context Loading**: Load existing session state and metadata
-- **Session Continuity**: Maintain context across workflow pipeline phases
+If `historical_conflicts` array is not empty, minimum risk level should be "medium":
 
-### Session Validation
 ```javascript
-// Validate session exists
-const sessionPath = `.workflow/${session_id}`;
-if (!fs.existsSync(sessionPath)) {
-  console.error(`❌ Session ${session_id} not found`);
-  process.exit(1);
+if (historicalConflicts.length > 0 && currentRisk === "low") {
+  conflict_detection.risk_level = "medium";
+  conflict_detection.risk_factors.push(
+    `${historicalConflicts.length} historical conflict pattern(s) detected from past sessions`
+  );
 }
 ```
 
-## Success Criteria
-- Valid context-package.json generated in correct location
-- Contains sufficient relevant information (>80% relevance)
-- Execution completes within reasonable time (<2 minutes)
-- All required fields present and properly formatted
-- Agent reports completion status with statistics
+### Archive Query Algorithm
 
+```markdown
+1. IF .workflow/.archives/manifest.json does NOT exist → Skip Track 1, continue to Track 2
+2. IF manifest exists:
+   a. Load manifest.json
+   b. Extract keywords from task_description (nouns, verbs, technical terms)
+   c. Filter archives where:
+      - ANY tag matches keywords (case-insensitive) OR
+      - description contains keywords (case-insensitive substring match)
+   d. For each relevant archive:
+      - Read lessons.watch_patterns array
+      - Check if pattern.pattern keywords overlap with task_description
+      - If relevant: Add to historical_conflicts array
+   e. IF historical_conflicts.length > 0:
+      - Set risk_level = max(current_risk, "medium")
+      - Add to risk_factors
+3. Continue to Track 2 (reference documentation)
+```
+
+## Usage Examples
+
+### Basic Usage
+```bash
+/workflow:tools:context-gather --session WFS-auth-feature "Implement JWT authentication with refresh tokens"
+```
+## Success Criteria
+
+- ✅ Valid context-package.json generated in `.workflow/{session}/.process/`
+- ✅ Contains >80% relevant files based on task keywords
+- ✅ Execution completes within 2 minutes
+- ✅ All required schema fields present and valid
+- ✅ Conflict risk accurately assessed
+- ✅ Agent reports completion with statistics
+
+## Error Handling
+
+| Error | Cause | Resolution |
+|-------|-------|------------|
+| Package validation failed | Invalid session_id in existing package | Re-run agent to regenerate |
+| Agent execution timeout | Large codebase or slow MCP | Increase timeout, check code-index status |
+| Missing required fields | Agent incomplete execution | Check agent logs, verify schema compliance |
+| File count exceeds limit | Too many relevant files | Agent should auto-prioritize top 50 by relevance |
+
+## Notes
+
+- **Detection-first**: Always check for existing package before invoking agent
+- **Agent autonomy**: Agent handles all discovery logic per `.claude/agents/context-search-agent.md`
+- **No redundancy**: This command is a thin orchestrator, all logic in agent
+- **Plan-specific**: Use this for implementation planning; brainstorm mode uses direct agent call

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

@@ -49,6 +49,7 @@ Autonomous task JSON and IMPL_PLAN.md generation using action-planning-agent wit
     "synthesis_output": {"path": "...", "exists": true},
     "conflict_resolution": {"path": "...", "exists": true}  // if conflict_risk >= medium
   },
+  "context_package_path": ".workflow/{session-id}/.process/context-package.json",
   "context_package": {
     // If in memory: use cached content
     // Else: Load from .workflow/{session-id}/.process/context-package.json
@@ -149,9 +150,11 @@ Task(
 - Includes conflict_risk assessment
 
 ### Conflict Resolution (Conditional)
-{conflict_resolution_content}
-- Exists only if conflict_risk was medium/high
-- Contains conflict detection results and resolution strategies
+If conflict_risk was medium/high, modifications have been applied to:
+- **guidance-specification.md**: Design decisions updated to resolve conflicts
+- **Role analyses (*.md)**: Recommendations adjusted for compatibility
+- **context-package.json**: Marked as "resolved" with conflict IDs
+- NO separate CONFLICT_RESOLUTION.md file (conflicts resolved in-place)
 
 ### MCP Analysis Results (Optional)
 **Code Structure**: {mcp_code_index_results}
@@ -334,9 +337,11 @@ const agentContext = {
     ? memory.get("workflow-session.json")
     : Read(.workflow/WFS-[id]/workflow-session.json),
 
+  context_package_path: ".workflow/WFS-[id]/.process/context-package.json",
+
   context_package: memory.has("context-package.json")
     ? memory.get("context-package.json")
-    : Read(.workflow/WFS-[id]/.process/context-package.json),
+    : Read(".workflow/WFS-[id]/.process/context-package.json"),
 
   // Extract brainstorm artifacts from context package
   brainstorm_artifacts: extractBrainstormArtifacts(context_package),

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

@@ -134,6 +134,7 @@ For each feature, generate task(s) with ID format:
   "id": "IMPL-N",                                  // Task identifier
   "title": "Feature description with TDD",         // Human-readable title
   "status": "pending",                             // pending | in_progress | completed | container
+  "context_package_path": ".workflow/{session-id}/.process/context-package.json", // Path to smart context package
   "meta": {
     "type": "feature",                             // Task type
     "agent": "@code-developer",                    // Assigned agent
@@ -259,6 +260,7 @@ identifier: WFS-{session-id}
 source: "User requirements" | "File: path"
 conflict_resolution: .workflow/{session-id}/.process/CONFLICT_RESOLUTION.md  # if exists
 context_package: .workflow/{session-id}/.process/context-package.json
+context_package_path: .workflow/{session-id}/.process/context-package.json
 test_context: .workflow/{session-id}/.process/test-context-package.json  # if exists
 workflow_type: "tdd"
 verification_history:
@@ -411,6 +413,7 @@ Update workflow-session.json with TDD metadata:
     ├── CONFLICT_RESOLUTION.md       # Conflict resolution strategies (if conflict_risk ≥ medium)
     ├── test-context-package.json    # Test coverage analysis
     ├── context-package.json         # Input from context-gather
+    ├── context_package_path         # Path to smart context package
     └── green-fix-iteration-*.md     # Fix logs from Green phase test-fix cycles
 ```
 

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

@@ -173,6 +173,7 @@ This enhanced 5-field schema embeds all necessary context, artifacts, and execut
   "id": "IMPL-N[.M]",
   "title": "Descriptive task name",
   "status": "pending|active|completed|blocked|container",
+  "context_package_path": ".workflow/WFS-[session]/.process/context-package.json",
   "meta": {
     "type": "feature|bugfix|refactor|test-gen|test-fix|docs",
     "agent": "@code-developer|@test-fix-agent|@universal-executor",
@@ -193,20 +194,10 @@ This enhanced 5-field schema embeds all necessary context, artifacts, and execut
         "priority": "highest",
         "usage": "Role-specific requirements, design specs, enhanced by synthesis. Paths loaded dynamically from context-package.json (supports multiple files per role: analysis.md, analysis-01.md, analysis-api.md, etc.). Common roles: product-manager, system-architect, ui-designer, data-architect, ux-expert."
       },
-      {
-        "path": ".workflow/WFS-[session]/.process/context-package.json",
-        "priority": "critical",
-        "usage": "Smart context with focus paths, module structure, dependency graph, existing patterns, tech stack. Use for: environment setup, dependency resolution, pattern discovery, conflict detection results"
-      },
-      {
-        "path": ".workflow/WFS-[session]/.process/CONFLICT_RESOLUTION.md",
-        "priority": "high",
-        "usage": "Conflict resolution strategies and selected approaches (conditional, exists only if conflict_risk was medium/high). Use for: understanding code conflicts, applying resolution strategies, migration planning"
-      },
       {
         "path": ".workflow/WFS-[session]/.brainstorming/guidance-specification.md",
-        "priority": "medium",
-        "usage": "Discussion context and framework structure"
+        "priority": "high",
+        "usage": "Finalized design decisions (potentially modified by conflict resolution if conflict_risk was medium/high). Use for: understanding resolved requirements, design choices, conflict resolutions applied in-place"
       }
     ]
   },
@@ -215,8 +206,9 @@ This enhanced 5-field schema embeds all necessary context, artifacts, and execut
       {
         "step": "load_context_package",
         "action": "Load context package for artifact paths",
+        "note": "Context package path is now at top-level field: context_package_path",
         "commands": [
-          "Read(.workflow/WFS-[session]/.process/context-package.json)"
+          "Read({{context_package_path}})"
         ],
         "output_to": "context_package",
         "on_error": "fail"
@@ -226,7 +218,7 @@ This enhanced 5-field schema embeds all necessary context, artifacts, and execut
         "action": "Load role analyses from context-package.json (supports multiple files per role)",
         "note": "Paths loaded from context-package.json → brainstorm_artifacts.role_analyses[]. Supports analysis*.md automatically.",
         "commands": [
-          "Read(.workflow/WFS-[session]/.process/context-package.json)",
+          "Read({{context_package_path}})",
           "Extract(brainstorm_artifacts.role_analyses[].files[].path)",
           "Read(each extracted path)"
         ],
@@ -235,17 +227,17 @@ This enhanced 5-field schema embeds all necessary context, artifacts, and execut
       },
       {
         "step": "load_planning_context",
-        "action": "Load plan-generated context intelligence and conflict resolution",
-        "note": "CRITICAL: context-package.json provides smart context (focus paths, dependencies, patterns). CONFLICT_RESOLUTION.md (if exists) provides conflict resolution strategies.",
+        "action": "Load plan-generated context intelligence with resolved conflicts",
+        "note": "CRITICAL: context-package.json (from context_package_path) provides smart context (focus paths, dependencies, patterns) and conflict resolution status. If conflict_risk was medium/high, conflicts have been resolved in guidance-specification.md and role analyses.",
         "commands": [
-          "Read(.workflow/WFS-[session]/.process/context-package.json)",
-          "bash(test -f .workflow/WFS-[session]/.process/CONFLICT_RESOLUTION.md && cat .workflow/WFS-[session]/.process/CONFLICT_RESOLUTION.md || echo 'No conflicts detected')"
+          "Read({{context_package_path}})",
+          "Read(.workflow/WFS-[session]/.brainstorming/guidance-specification.md)"
         ],
         "output_to": "planning_context",
         "on_error": "fail",
         "usage_guidance": {
-          "context-package.json": "Use for focus_paths validation, dependency resolution, existing pattern discovery, module structure understanding, conflict_risk assessment",
-          "CONFLICT_RESOLUTION.md": "Apply selected conflict resolution strategies, understand migration requirements (conditional, may not exist if no conflicts)"
+          "context-package.json": "Use for focus_paths validation, dependency resolution, existing pattern discovery, module structure understanding, conflict_risk status (resolved/none/low)",
+          "guidance-specification.md": "Use for finalized design decisions (includes applied conflict resolutions if any)"
         }
       },
       {
@@ -269,22 +261,22 @@ This enhanced 5-field schema embeds all necessary context, artifacts, and execut
       {
         "step": 1,
         "title": "Implement task following role analyses and context",
-        "description": "Implement '[title]' following this priority: 1) role analysis.md files (requirements, design specs, enhancements from synthesis), 2) context-package.json (smart context, focus paths, patterns), 3) CONFLICT_RESOLUTION.md (if exists, conflict resolution strategies). Role analyses are enhanced by synthesis phase with concept improvements and clarifications.",
+        "description": "Implement '[title]' following this priority: 1) role analysis.md files (requirements, design specs, enhancements from synthesis), 2) guidance-specification.md (finalized decisions with resolved conflicts), 3) context-package.json (smart context, focus paths, patterns). Role analyses are enhanced by synthesis phase with concept improvements and clarifications. If conflict_risk was medium/high, conflict resolutions are already applied in-place.",
         "modification_points": [
           "Apply requirements and design specs from role analysis documents",
           "Use enhancements and clarifications from synthesis phase",
-          "Apply conflict resolution strategies (if conflicts were detected)",
+          "Use finalized decisions from guidance-specification.md (includes resolved conflicts)",
           "Use context-package.json for focus paths and dependency resolution",
           "Consult specific role artifacts for implementation details when needed",
           "Integrate with existing patterns"
         ],
         "logic_flow": [
           "Load role analyses (requirements, design, enhancements from synthesis)",
-          "Load context-package.json (smart context: focus paths, dependencies, patterns, conflict_risk)",
-          "Load CONFLICT_RESOLUTION.md (if exists, conflict resolution strategies)",
+          "Load guidance-specification.md (finalized decisions with resolved conflicts if any)",
+          "Load context-package.json (smart context: focus paths, dependencies, patterns, conflict_risk status)",
           "Extract requirements and design decisions from role documents",
           "Review synthesis enhancements and clarifications",
-          "Apply conflict resolution strategies (if applicable)",
+          "Use finalized decisions (conflicts already resolved if applicable)",
           "Identify modification targets using context package",
           "Implement following role requirements and design specs",
           "Consult role artifacts for detailed specifications when needed",
@@ -309,12 +301,13 @@ source: "User requirements" | "File: path" | "Issue: ISS-001"
 role_analyses: .workflow/{session-id}/.brainstorming/[role]/analysis*.md
 artifacts: .workflow/{session-id}/.brainstorming/
 context_package: .workflow/{session-id}/.process/context-package.json  # CCW smart context
-conflict_resolution: .workflow/{session-id}/.process/CONFLICT_RESOLUTION.md  # Conditional, if conflict_risk >= medium
+guidance_specification: .workflow/{session-id}/.brainstorming/guidance-specification.md  # Finalized decisions with resolved conflicts
 workflow_type: "standard | tdd | design"  # Indicates execution model
 verification_history:  # CCW quality gates
   synthesis_clarify: "passed | skipped | pending"  # Brainstorm phase clarification
   action_plan_verify: "pending"
-phase_progression: "brainstorm → synthesis → context → conflict_resolution → planning"  # CCW workflow phases
+  conflict_resolution: "resolved | none | low"  # Status from context-package.json
+phase_progression: "brainstorm → synthesis → context → conflict_resolution (if needed) → planning"  # CCW workflow phases
 ---
 
 # Implementation Plan: {Project Title}
@@ -383,15 +376,16 @@ Core requirements, objectives, technical approach summary (2-3 paragraphs max).
 
 **Context Intelligence (context-package.json)**:
 - **What**: Smart context gathered by CCW's context-gather phase
-- **Content**: Focus paths, dependency graph, existing patterns, module structure, tech stack, conflict_risk assessment
+- **Content**: Focus paths, dependency graph, existing patterns, module structure, tech stack, conflict_risk status
 - **Usage**: Tasks load this via `flow_control.preparatory_steps` for environment setup and conflict awareness
 - **CCW Value**: Automated intelligent context discovery replacing manual file exploration
 
-**Conflict Resolution (CONFLICT_RESOLUTION.md)**:
-- **What**: Conflict analysis and resolution strategies (conditional, exists only if conflict_risk >= medium)
-- **Content**: Conflict detection results, resolution options, selected strategies, migration requirements
-- **Usage**: Referenced in task planning for applying conflict resolution strategies and understanding code conflicts
-- **CCW Value**: CLI-powered conflict detection and strategic resolution guidance for complex codebases
+**Conflict Resolution Status**:
+- **What**: Conflict resolution applied in-place to brainstorm artifacts (if conflict_risk was >= medium)
+- **Location**: guidance-specification.md and role analyses (*.md) contain resolved conflicts
+- **Status**: Check context-package.json → conflict_detection.conflict_risk ("resolved" | "none" | "low")
+- **Usage**: Read finalized decisions from guidance-specification.md (includes applied resolutions)
+- **CCW Value**: Interactive conflict resolution with user confirmation, modifications applied automatically
 
 ### Role Analysis Documents (Highest Priority)
 Role analyses provide specialized perspectives on the implementation:
@@ -406,10 +400,9 @@ Role analyses provide specialized perspectives on the implementation:
 - **topic-framework.md**: Role-specific discussion points and analysis framework
 
 **Artifact Priority in Development**:
-1. context-package.json (primary source: smart context AND brainstorm artifact catalog in `brainstorm_artifacts`)
-2. role/analysis*.md (paths from context-package.json: requirements, design specs, enhanced by synthesis)
-3. CONFLICT_RESOLUTION.md (path from context-package.json: conflict strategies, if conflict_risk >= medium)
-4. guidance-specification.md (path from context-package.json: discussion framework)
+1. {context_package_path} (primary source: smart context AND brainstorm artifact catalog in `brainstorm_artifacts` + conflict_risk status)
+2. role/analysis*.md (paths from context-package.json: requirements, design specs, enhanced by synthesis, with resolved conflicts if any)
+3. guidance-specification.md (path from context-package.json: finalized decisions with resolved conflicts if any)
 
 ## 4. Implementation Strategy
 
@@ -566,21 +559,19 @@ The command organizes outputs into a standard directory structure.
 │   ├── IMPL-1.1.json                # Leaf task with flow_control
 │   └── IMPL-1.2.json                # Leaf task with flow_control
 ├── .brainstorming              # Input artifacts from brainstorm + synthesis
-│   ├── guidance-specification.md    # Discussion framework
-│   └── {role}/analysis*.md          # Role analyses (enhanced by synthesis, may have multiple files per role)
+│   ├── guidance-specification.md    # Finalized decisions (with resolved conflicts if any)
+│   └── {role}/analysis*.md          # Role analyses (enhanced by synthesis, with resolved conflicts if any)
 └── .process/
-    ├── context-package.json         # Input from context-gather (smart context + conflict_risk)
-    └── CONFLICT_RESOLUTION.md       # Input from conflict-resolution (conditional, if conflict_risk >= medium)
+    └── context-package.json         # Input from context-gather (smart context + conflict_risk status)
 ```
 
 ## 7. Artifact Integration
 The command intelligently detects and integrates artifacts from the `.brainstorming/` directory.
 
 #### Artifact Priority
-1.  **context-package.json** (critical): Primary source - smart context AND all brainstorm artifact paths in `brainstorm_artifacts` section
-2.  **role/analysis*.md** (highest): Paths from context-package.json → role-specific requirements, design specs, enhanced by synthesis
-3.  **CONFLICT_RESOLUTION.md** (high): Path from context-package.json → conflict strategies (conditional, if conflict_risk >= medium)
-4.  **guidance-specification.md** (medium): Path from context-package.json → discussion framework from brainstorming
+1.  **context-package.json** (critical): Primary source - smart context AND all brainstorm artifact paths in `brainstorm_artifacts` section + conflict_risk status
+2.  **role/analysis*.md** (highest): Paths from context-package.json → role-specific requirements, design specs, enhanced by synthesis, with resolved conflicts applied in-place
+3.  **guidance-specification.md** (high): Path from context-package.json → finalized decisions with resolved conflicts (if conflict_risk was >= medium)
 
 #### Artifact-Task Mapping
 Artifacts are mapped to tasks based on their relevance to the task's domain.
@@ -598,8 +589,7 @@ When using `--cli-execute`, each step in `implementation_approach` includes a `c
 
 **Key Points**:
 - **Sequential Steps**: Steps execute in order defined in `implementation_approach` array
-- **Context Delivery**: Each codex command receives context via CONTEXT field: `@.workflow/WFS-session/.process/context-package.json` (role analyses loaded dynamically from context package)
-- **Multi-Step Tasks**: First step provides full context, subsequent steps use `resume --last` to maintain session continuity
+    - **Context Delivery**: Each codex command receives context via CONTEXT field: `@{context_package_path}` (role analyses loaded dynamically from context package)- **Multi-Step Tasks**: First step provides full context, subsequent steps use `resume --last` to maintain session continuity
 - **Step Dependencies**: Later steps reference outputs from earlier steps via `depends_on` field
 
 ### Example 1: Agent Mode - Simple Task (Default, No Command)
@@ -607,6 +597,7 @@ When using `--cli-execute`, each step in `implementation_approach` includes a `c
 {
   "id": "IMPL-001",
   "title": "Implement user authentication module",
+  "context_package_path": ".workflow/WFS-session/.process/context-package.json",
   "context": {
     "depends_on": [],
     "focus_paths": ["src/auth"],
@@ -623,7 +614,7 @@ When using `--cli-execute`, each step in `implementation_approach` includes a `c
         "step": "load_role_analyses",
         "action": "Load role analyses from context-package.json",
         "commands": [
-          "Read(.workflow/WFS-session/.process/context-package.json)",
+          "Read({{context_package_path}})",
           "Extract(brainstorm_artifacts.role_analyses[].files[].path)",
           "Read(each extracted path)"
         ],
@@ -633,7 +624,7 @@ When using `--cli-execute`, each step in `implementation_approach` includes a `c
       {
         "step": "load_context",
         "action": "Load context package for project structure",
-        "commands": ["Read(.workflow/WFS-session/.process/context-package.json)"],
+        "commands": ["Read({{context_package_path}})"],
         "output_to": "context_pkg",
         "on_error": "fail"
       }
@@ -668,6 +659,7 @@ When using `--cli-execute`, each step in `implementation_approach` includes a `c
 {
   "id": "IMPL-002",
   "title": "Implement user authentication module",
+  "context_package_path": ".workflow/WFS-session/.process/context-package.json",
   "context": {
     "depends_on": [],
     "focus_paths": ["src/auth"],
@@ -680,7 +672,7 @@ When using `--cli-execute`, each step in `implementation_approach` includes a `c
         "step": "load_role_analyses",
         "action": "Load role analyses from context-package.json",
         "commands": [
-          "Read(.workflow/WFS-session/.process/context-package.json)",
+          "Read({{context_package_path}})",
           "Extract(brainstorm_artifacts.role_analyses[].files[].path)",
           "Read(each extracted path)"
         ],
@@ -693,7 +685,7 @@ When using `--cli-execute`, each step in `implementation_approach` includes a `c
         "step": 1,
         "title": "Implement authentication with Codex",
         "description": "Create JWT-based authentication module",
-        "command": "bash(codex -C src/auth --full-auto exec \"PURPOSE: Implement user authentication TASK: JWT-based auth with login/registration MODE: auto CONTEXT: @.workflow/WFS-session/.process/context-package.json EXPECTED: Complete auth module with tests RULES: Load role analyses from context-package.json → brainstorm_artifacts\" --skip-git-repo-check -s danger-full-access)",
+        "command": "bash(codex -C src/auth --full-auto exec \"PURPOSE: Implement user authentication TASK: JWT-based auth with login/registration MODE: auto CONTEXT: @{{context_package_path}} EXPECTED: Complete auth module with tests RULES: Load role analyses from context-package.json → brainstorm_artifacts\" --skip-git-repo-check -s danger-full-access)",
         "modification_points": ["Create auth service", "Implement endpoints", "Add JWT middleware"],
         "logic_flow": ["Validate credentials", "Generate JWT", "Return token"],
         "depends_on": [],
@@ -710,6 +702,7 @@ When using `--cli-execute`, each step in `implementation_approach` includes a `c
 {
   "id": "IMPL-003",
   "title": "Implement role-based access control",
+  "context_package_path": ".workflow/WFS-session/.process/context-package.json",
   "context": {
     "depends_on": ["IMPL-002"],
     "focus_paths": ["src/auth", "src/middleware"],
@@ -722,7 +715,7 @@ When using `--cli-execute`, each step in `implementation_approach` includes a `c
         "step": "load_context",
         "action": "Load context and role analyses from context-package.json",
         "commands": [
-          "Read(.workflow/WFS-session/.process/context-package.json)",
+          "Read({{context_package_path}})",
           "Extract(brainstorm_artifacts.role_analyses[].files[].path)",
           "Read(each extracted path)"
         ],
@@ -735,7 +728,7 @@ When using `--cli-execute`, each step in `implementation_approach` includes a `c
         "step": 1,
         "title": "Create RBAC models",
         "description": "Define role and permission data models",
-        "command": "bash(codex -C src/auth --full-auto exec \"PURPOSE: Create RBAC models TASK: Role and permission models MODE: auto CONTEXT: @.workflow/WFS-session/.process/context-package.json EXPECTED: Models with migrations RULES: Load role analyses from context-package.json → brainstorm_artifacts\" --skip-git-repo-check -s danger-full-access)",
+        "command": "bash(codex -C src/auth --full-auto exec \"PURPOSE: Create RBAC models TASK: Role and permission models MODE: auto CONTEXT: @{{context_package_path}} EXPECTED: Models with migrations RULES: Load role analyses from context-package.json → brainstorm_artifacts\" --skip-git-repo-check -s danger-full-access)",
         "modification_points": ["Define role model", "Define permission model", "Create migrations"],
         "logic_flow": ["Design schema", "Implement models", "Generate migrations"],
         "depends_on": [],

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

@@ -1,265 +1,188 @@
 ---
 name: test-context-gather
-description: Collect test coverage context and identify files requiring test generation
+description: Intelligently collect test coverage context using test-context-search-agent and package into standardized test-context JSON
 argument-hint: "--session WFS-test-session-id"
 examples:
   - /workflow:tools:test-context-gather --session WFS-test-auth
   - /workflow:tools:test-context-gather --session WFS-test-payment
+allowed-tools: Task(*), Read(*), Glob(*)
 ---
 
-# Test Context Gather Command
+# Test Context Gather Command (/workflow:tools:test-context-gather)
 
 ## Overview
-Specialized context collector for test generation workflows that analyzes test coverage, identifies missing tests, and packages implementation context from source sessions.
+
+Orchestrator command that invokes `test-context-search-agent` to gather comprehensive test coverage context for test generation workflows. Generates standardized `test-context-package.json` with coverage analysis, framework detection, and source implementation context.
+
+**Agent**: `test-context-search-agent` (`.claude/agents/test-context-search-agent.md`)
 
 ## Core Philosophy
-- **Coverage-First**: Analyze existing test coverage before planning
-- **Gap Identification**: Locate implementation files without corresponding tests
+
+- **Agent Delegation**: Delegate all test coverage analysis to `test-context-search-agent` for autonomous execution
+- **Detection-First**: Check for existing test-context-package before executing
+- **Coverage-First**: Analyze existing test coverage before planning new tests
 - **Source Context Loading**: Import implementation summaries from source session
-- **Framework Detection**: Auto-detect test framework and patterns
-- **Ripgrep-Powered**: Leverage ripgrep and native tools for precise analysis
+- **Standardized Output**: Generate `.workflow/{test_session_id}/.process/test-context-package.json`
 
-## Core Responsibilities
-- Load source session implementation context
-- Analyze current test coverage using ripgrep
-- Identify files requiring test generation
-- Detect test framework and conventions
-- Package test context for analysis phase
+## Execution Flow
 
-## Execution Lifecycle
+### Step 1: Test-Context-Package Detection
 
-### Phase 1: Session Validation & Source Loading
+**Execute First** - Check if valid package already exists:
 
-1. **Test Session Validation**
-   - Load `.workflow/{test_session_id}/workflow-session.json`
-   - Extract `meta.source_session` reference
-   - Validate test session type is "test-gen"
+```javascript
+const testContextPath = `.workflow/${test_session_id}/.process/test-context-package.json`;
 
-2. **Source Session Context Loading**
-   - Read `.workflow/{source_session_id}/workflow-session.json`
-   - Load implementation summaries from `.workflow/{source_session_id}/.summaries/`
-   - Extract changed files and implementation scope
-   - Identify implementation patterns and tech stack
+if (file_exists(testContextPath)) {
+  const existing = Read(testContextPath);
 
-### Phase 2: Test Coverage Analysis (Ripgrep)
-
-1. **Existing Test Discovery**
-   ```bash
-   # Find all test files
-   find . -name "*.test.*" -type f
-   find . -name "*.spec.*" -type f
-   find . -name "*test_*.py" -type f
-
-   # Search for test patterns
-   rg "describe|it|test|@Test" -g "*.test.*"
-   ```
-
-2. **Coverage Gap Analysis**
-   ```bash
-   # For each implementation file from source session
-   # Check if corresponding test file exists
-
-   # Example: src/auth/AuthService.ts -> tests/auth/AuthService.test.ts
-   #          src/utils/validator.py -> tests/test_validator.py
-
-   # Output: List of files without tests
-   ```
-
-3. **Test Statistics**
-   - Count total test files
-   - Count implementation files from source session
-   - Calculate coverage percentage
-   - Identify coverage gaps by module
-
-### Phase 3: Test Framework Detection
-
-1. **Framework Identification**
-   ```bash
-   # Check package.json or requirements.txt
-   rg "jest|mocha|jasmine|pytest|unittest|rspec" -g "package.json" -g "requirements.txt" -g "Gemfile" -C 2
-
-   # Analyze existing test patterns
-   rg "describe\(|it\(|test\(|def test_" -g "*.test.*" -C 3
-   ```
-
-2. **Convention Analysis**
-   - Test file naming patterns (*.test.ts vs *.spec.ts)
-   - Test directory structure (tests/ vs __tests__ vs src/**/*.test.*)
-   - Assertion library (expect, assert, should)
-   - Mocking framework (jest.fn, sinon, unittest.mock)
-
-### Phase 4: Context Packaging
-
-Generate `test-context-package.json`:
-
-```json
-{
-  "metadata": {
-    "test_session_id": "WFS-test-auth",
-    "source_session_id": "WFS-auth",
-    "timestamp": "2025-10-04T10:30:00Z",
-    "task_type": "test-generation",
-    "complexity": "medium"
-  },
-  "source_context": {
-    "implementation_summaries": [
-      {
-        "task_id": "IMPL-001",
-        "summary_path": ".workflow/WFS-auth/.summaries/IMPL-001-summary.md",
-        "changed_files": [
-          "src/auth/AuthService.ts",
-          "src/auth/TokenValidator.ts",
-          "src/middleware/auth.ts"
-        ],
-        "implementation_type": "feature"
-      }
-    ],
-    "tech_stack": ["typescript", "express", "jsonwebtoken"],
-    "project_patterns": {
-      "architecture": "layered",
-      "error_handling": "try-catch with custom errors",
-      "async_pattern": "async/await"
-    }
-  },
-  "test_coverage": {
-    "existing_tests": [
-      "tests/auth/AuthService.test.ts",
-      "tests/middleware/auth.test.ts"
-    ],
-    "missing_tests": [
-      {
-        "implementation_file": "src/auth/TokenValidator.ts",
-        "suggested_test_file": "tests/auth/TokenValidator.test.ts",
-        "priority": "high",
-        "reason": "New implementation without tests"
-      }
-    ],
-    "coverage_stats": {
-      "total_implementation_files": 3,
-      "files_with_tests": 2,
-      "files_without_tests": 1,
-      "coverage_percentage": 66.7
-    }
-  },
-  "test_framework": {
-    "framework": "jest",
-    "version": "^29.0.0",
-    "test_pattern": "**/*.test.ts",
-    "test_directory": "tests/",
-    "assertion_library": "expect",
-    "mocking_framework": "jest",
-    "conventions": {
-      "file_naming": "*.test.ts",
-      "test_structure": "describe/it blocks",
-      "setup_teardown": "beforeEach/afterEach"
-    }
-  },
-  "assets": [
-    {
-      "type": "implementation_summary",
-      "path": ".workflow/WFS-auth/.summaries/IMPL-001-summary.md",
-      "relevance": "Source implementation context",
-      "priority": "highest"
-    },
-    {
-      "type": "existing_test",
-      "path": "tests/auth/AuthService.test.ts",
-      "relevance": "Test pattern reference",
-      "priority": "high"
-    },
-    {
-      "type": "source_code",
-      "path": "src/auth/TokenValidator.ts",
-      "relevance": "Implementation requiring tests",
-      "priority": "high"
-    },
-    {
-      "type": "documentation",
-      "path": "CLAUDE.md",
-      "relevance": "Project conventions",
-      "priority": "medium"
-    }
-  ],
-  "focus_areas": [
-    "Generate comprehensive tests for TokenValidator",
-    "Follow existing Jest patterns from AuthService tests",
-    "Cover happy path, error cases, and edge cases",
-    "Include integration tests for middleware"
-  ]
+  // Validate package belongs to current test session
+  if (existing?.metadata?.test_session_id === test_session_id) {
+    console.log("✅ Valid test-context-package found for session:", test_session_id);
+    console.log("📊 Coverage Stats:", existing.test_coverage.coverage_stats);
+    console.log("🧪 Framework:", existing.test_framework.framework);
+    console.log("⚠️  Missing Tests:", existing.test_coverage.missing_tests.length);
+    return existing; // Skip execution, return existing
+  } else {
+    console.warn("⚠️ Invalid test_session_id in existing package, re-generating...");
+  }
 }
 ```
 
-## Output Location
+### Step 2: Invoke Test-Context-Search Agent
 
-```
-.workflow/{test_session_id}/.process/test-context-package.json
-```
+**Only execute if Step 1 finds no valid package**
 
-## Native Tools Usage
+```javascript
+Task(
+  subagent_type="test-context-search-agent",
+  description="Gather test coverage context",
+  prompt=`
+You are executing as test-context-search-agent (.claude/agents/test-context-search-agent.md).
 
-### File Discovery
-```bash
-# Test files
-find . -name "*.test.*" -type f
-find . -name "*.spec.*" -type f
+## Execution Mode
+**PLAN MODE** (Comprehensive) - Full Phase 1-3 execution
 
-# Implementation files
-find . -name "*.ts" -type f
-find . -name "*.js" -type f
-```
+## Session Information
+- **Test Session ID**: ${test_session_id}
+- **Output Path**: .workflow/${test_session_id}/.process/test-context-package.json
 
-### Content Search
-```bash
-# Test framework detection
-rg "jest|mocha|pytest" -g "package.json" -g "requirements.txt"
+## Mission
+Execute complete test-context-search-agent workflow for test generation planning:
 
-# Test pattern analysis
-rg "describe|it|test" -g "*.test.*" -C 2
-```
+### Phase 1: Session Validation & Source Context Loading
+1. **Detection**: Check for existing test-context-package (early exit if valid)
+2. **Test Session Validation**: Load test session metadata, extract source_session reference
+3. **Source Context Loading**: Load source session implementation summaries, changed files, tech stack
 
-### Coverage Analysis
-```bash
-# For each implementation file
-# Check if test exists
-implementation_file="src/auth/AuthService.ts"
-test_file_patterns=(
-  "tests/auth/AuthService.test.ts"
-  "src/auth/AuthService.test.ts"
-  "src/auth/__tests__/AuthService.test.ts"
+### Phase 2: Test Coverage Analysis
+Execute coverage discovery:
+- **Track 1**: Existing test discovery (find *.test.*, *.spec.* files)
+- **Track 2**: Coverage gap analysis (match implementation files to test files)
+- **Track 3**: Coverage statistics (calculate percentages, identify gaps by module)
+
+### Phase 3: Framework Detection & Packaging
+1. Framework identification from package.json/requirements.txt
+2. Convention analysis from existing test patterns
+3. Generate and validate test-context-package.json
+
+## Output Requirements
+Complete test-context-package.json with:
+- **metadata**: test_session_id, source_session_id, task_type, complexity
+- **source_context**: implementation_summaries, tech_stack, project_patterns
+- **test_coverage**: existing_tests[], missing_tests[], coverage_stats
+- **test_framework**: framework, version, test_pattern, conventions
+- **assets**: implementation_summary[], existing_test[], source_code[] with priorities
+- **focus_areas**: Test generation guidance based on coverage gaps
+
+## Quality Validation
+Before completion verify:
+- [ ] Valid JSON format with all required fields
+- [ ] Source session context loaded successfully
+- [ ] Test coverage gaps identified
+- [ ] Test framework detected (or marked as 'unknown')
+- [ ] Coverage percentage calculated correctly
+- [ ] Missing tests catalogued with priority
+- [ ] Execution time < 30 seconds (< 60s for large codebases)
+
+Execute autonomously following agent documentation.
+Report completion with coverage statistics.
+`
 )
-
-# Search for test file
-for pattern in "${test_file_patterns[@]}"; do
-  if [ -f "$pattern" ]; then
-    echo "✅ Test exists: $pattern"
-    break
-  fi
-done
 ```
 
+### Step 3: Output Verification
+
+After agent completes, verify output:
+
+```javascript
+// Verify file was created
+const outputPath = `.workflow/${test_session_id}/.process/test-context-package.json`;
+if (!file_exists(outputPath)) {
+  throw new Error("❌ Agent failed to generate test-context-package.json");
+}
+
+// Load and display summary
+const testContext = Read(outputPath);
+console.log("✅ Test context package generated successfully");
+console.log("📊 Coverage:", testContext.test_coverage.coverage_stats.coverage_percentage + "%");
+console.log("⚠️  Tests to generate:", testContext.test_coverage.missing_tests.length);
+```
+
+## Parameter Reference
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `--session` | string | ✅ | Test workflow session ID (e.g., WFS-test-auth) |
+
+## Output Schema
+
+Refer to `test-context-search-agent.md` Phase 3.2 for complete `test-context-package.json` schema.
+
+**Key Sections**:
+- **metadata**: Test session info, source session reference, complexity
+- **source_context**: Implementation summaries with changed files and tech stack
+- **test_coverage**: Existing tests, missing tests with priorities, coverage statistics
+- **test_framework**: Framework name, version, patterns, conventions
+- **assets**: Categorized files with relevance (implementation_summary, existing_test, source_code)
+- **focus_areas**: Test generation guidance based on analysis
+
+## Usage Examples
+
+### Basic Usage
+```bash
+/workflow:tools:test-context-gather --session WFS-test-auth
+```
+
+### Expected Output
+```
+✅ Valid test-context-package found for session: WFS-test-auth
+📊 Coverage Stats: { total: 3, with_tests: 2, without_tests: 1, percentage: 66.7 }
+🧪 Framework: jest
+⚠️  Missing Tests: 1
+```
+
+## Success Criteria
+
+- ✅ Valid test-context-package.json generated in `.workflow/{test_session_id}/.process/`
+- ✅ Source session context loaded successfully
+- ✅ Test coverage gaps identified (>90% accuracy)
+- ✅ Test framework detected and documented
+- ✅ Execution completes within 30 seconds (60s for large codebases)
+- ✅ All required schema fields present and valid
+- ✅ Coverage statistics calculated correctly
+- ✅ Agent reports completion with statistics
+
 ## Error Handling
 
 | Error | Cause | Resolution |
 |-------|-------|------------|
+| Package validation failed | Invalid test_session_id in existing package | Re-run agent to regenerate |
 | Source session not found | Invalid source_session reference | Verify test session metadata |
 | No implementation summaries | Source session incomplete | Complete source session first |
-| No test framework detected | Missing test dependencies | Request user to specify framework |
-
-## Native Tools Implementation
-
-```bash
-# File discovery
-find . -name "*.test.*" -o -name "*.spec.*" | grep -v node_modules
-
-# Framework detection
-grep -r "jest\|mocha\|pytest" package.json requirements.txt 2>/dev/null
-
-# Coverage analysis
-for impl_file in $(cat changed_files.txt); do
-  test_file=$(echo $impl_file | sed 's/src/tests/' | sed 's/\(.*\)\.\(ts\|js\|py\)$/\1.test.\2/')
-  [ ! -f "$test_file" ] && echo "$impl_file → MISSING TEST"
-done
-```
+| Agent execution timeout | Large codebase or slow analysis | Increase timeout, check file access |
+| Missing required fields | Agent incomplete execution | Check agent logs, verify schema compliance |
+| No test framework detected | Missing test dependencies | Agent marks as 'unknown', manual specification needed |
 
 ## Integration
 
@@ -267,20 +190,18 @@ done
 - `/workflow:test-gen` (Phase 3: Context Gathering)
 
 ### Calls
-- Ripgrep and find for file analysis
-- Bash file operations for coverage analysis
+- `test-context-search-agent` - Autonomous test coverage analysis
 
 ### Followed By
-- `/workflow:tools:test-concept-enhanced` - Analyzes context and plans test generation
+- `/workflow:tools:test-concept-enhanced` - Test generation analysis and planning
 
-## Success Criteria
+## Notes
 
-- ✅ Source session context loaded successfully
-- ✅ Test coverage gaps identified with ripgrep
-- ✅ Test framework detected and documented
-- ✅ Valid test-context-package.json generated
-- ✅ All missing tests catalogued with priority
-- ✅ Execution time < 20 seconds
+- **Detection-first**: Always check for existing test-context-package before invoking agent
+- **Agent autonomy**: Agent handles all coverage analysis logic per `.claude/agents/test-context-search-agent.md`
+- **No redundancy**: This command is a thin orchestrator, all logic in agent
+- **Framework agnostic**: Supports Jest, Mocha, pytest, RSpec, Go testing, etc.
+- **Coverage focus**: Primary goal is identifying implementation files without tests
 
 ## Related Commands
 

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

@@ -363,7 +363,7 @@ Generate **TWO task JSON files**:
         "               Source files: [focus_paths]",
         "               Implementation: [implementation_context]",
         "      EXPECTED: Root cause analysis, code path tracing, targeted fixes",
-        "      RULES: $(cat ~/.claude/prompt-templates/bug-fix.md) | Bug: [test_failure_description]",
+        "      RULES: $(cat ~/.claude/workflows/cli-templates/prompts/development/bug-diagnosis.txt) | Bug: [test_failure_description]",
         "             Minimal surgical fixes only - no refactoring",
         "      \" > fix-iteration-[N]-diagnosis.md)",
         "    - Parse diagnosis → extract fix_suggestion and target_files",
@@ -690,6 +690,6 @@ The `@test-fix-agent` will execute the task by following the `flow_control.imple
 6. **Phase 3**: Generate summary and certify code
 7. **Error Recovery**: Revert changes if max iterations reached
 
-**Bug Diagnosis Template**: Uses bug-fix.md template as referenced in bug-index.md for systematic root cause analysis, code path tracing, and targeted fix recommendations.
+**Bug Diagnosis Template**: Uses `~/.claude/workflows/cli-templates/prompts/development/bug-diagnosis.txt` template for systematic root cause analysis, code path tracing, and targeted fix recommendations.
 
 **Codex Usage**: The agent uses `codex exec "..." resume --last` pattern ONLY when meta.use_codex=true (--use-codex flag present) to maintain conversation context across multiple fix iterations, ensuring consistency and learning from previous attempts.

.claude/workflows/cli-templates/prompts/analysis/code-execution-tracing.txt

@@ -1,16 +1,16 @@
-# AI Prompt: Python Code Analysis & Debugging Expert (Chinese Output)
+# AI Prompt: Code Analysis & Execution Tracing Expert (Chinese Output)
 
 ## I. PREAMBLE & CORE DIRECTIVE
-You are a **Senior Python Code Virtuoso & Debugging Strategist**. Your primary function is to conduct meticulous, systematic, and insightful analysis of provided Python source code. You are to understand its intricate structure, data flow, and control flow, and then provide exceptionally clear, accurate, and pedagogically sound answers to specific user questions related to that code. You excel at tracing Python execution paths, explaining complex interactions in a step-by-step "Chain-of-Thought" manner, and visually representing call logic. Your responses **MUST** be in **Chinese (中文)**.
+You are a **Senior Code Virtuoso & Debugging Strategist**. Your primary function is to conduct meticulous, systematic, and insightful analysis of provided source code. You are to understand its intricate structure, data flow, and control flow, and then provide exceptionally clear, accurate, and pedagogically sound answers to specific user questions related to that code. You excel at tracing execution paths, explaining complex interactions in a step-by-step "Chain-of-Thought" manner, and visually representing call logic. Your responses **MUST** be in **Chinese (中文)**.
 
 ## II. ROLE DEFINITION & CORE CAPABILITIES
-1.  **Role**: Senior Python Code Virtuoso & Debugging Strategist.
+1.  **Role**: Senior Code Virtuoso & Debugging Strategist.
 2.  **Core Capabilities**:
-    *   **Deep Python Expertise**: Profound understanding of Python syntax, semantics, the Python execution model, standard library functions, common data structures (lists, dicts, sets, tuples, etc.), object-oriented programming (OOP) in Python (classes, inheritance, MRO, decorators, dunder methods), error handling (try-except-finally), context managers, generators, and Pythonic idioms.
+    *   **Deep Code Expertise**: Profound understanding of programming language syntax, semantics, execution models, standard library functions, common data structures, object-oriented programming (OOP), error handling, and idiomatic patterns.
     *   **Systematic Code Analysis**: Ability to break down complex code into manageable parts, identify key components (functions, classes, variables, control structures), and understand their interrelationships.
     *   **Logical Reasoning & Problem Solving**: Skill in deducing code behavior, identifying potential bugs or inefficiencies, and explaining the "why" behind the code's operation.
-    *   **Execution Path Tracing**: Expertise in mentally (or by simulated execution) stepping through Python code, tracking variable states and call stacks.
-    *   **Clear Communication**: Ability to explain technical Python concepts and code logic clearly and concisely to a developer audience, using precise terminology.
+    *   **Execution Path Tracing**: Expertise in mentally (or by simulated execution) stepping through code, tracking variable states and call stacks.
+    *   **Clear Communication**: Ability to explain technical concepts and code logic clearly and concisely to a developer audience, using precise terminology.
     *   **Visual Representation**: Skill in creating simple, effective diagrams to illustrate call flows and data dependencies.
 3.  **Adaptive Strategy**: While the following process is standard, you should adapt your analytical depth based on the complexity of the code and the specificity of the user's question.
 4.  **Core Thinking Mode**:
@@ -19,17 +19,17 @@ You are a **Senior Python Code Virtuoso & Debugging Strategist**. Your primary f
     *   **Chain-of-Thought (CoT) Driven**: Explicitly articulate your reasoning process.
 
 ## III. OBJECTIVES
-1.  **Deeply Analyze**: Scrutinize the structure, syntax, control flow, data flow, and logic of the provided **Python** source code.
+1.  **Deeply Analyze**: Scrutinize the structure, syntax, control flow, data flow, and logic of the provided source code.
 2.  **Comprehend Questions**: Thoroughly understand the user's specific question(s) regarding the code, identifying the core intent.
 3.  **Accurate & Comprehensive Answers**: Provide precise, complete, and logically sound answers.
-4.  **Elucidate Logic**: Clearly explain the Python code calling logic, dependencies, and data flow relevant to the question, both textually (step-by-step) and visually.
-5.  **Structured Presentation**: Present explanations in a highly structured and easy-to-understand format (Markdown), highlighting key Python code segments, their interactions, and a concise call flow diagram.
-6.  **Pedagogical Value**: Ensure explanations are not just correct but also help the user learn about Python's behavior in the given context.
+4.  **Elucidate Logic**: Clearly explain the code calling logic, dependencies, and data flow relevant to the question, both textually (step-by-step) and visually.
+5.  **Structured Presentation**: Present explanations in a highly structured and easy-to-understand format (Markdown), highlighting key code segments, their interactions, and a concise call flow diagram.
+6.  **Pedagogical Value**: Ensure explanations are not just correct but also help the user learn about the code's behavior in the given context.
 7.  **Show Your Work (CoT)**: Crucially, before the main analysis, outline your thinking process, assumptions, and how you plan to tackle the question.
 
 ## IV. INPUT SPECIFICATIONS
-1.  **Python Code Snippet**: A block of Python source code provided as text.
-2.  **Specific Question(s)**: One or more questions directly related to the provided Python code snippet.
+1.  **Code Snippet**: A block of source code provided as text.
+2.  **Specific Question(s)**: One or more questions directly related to the provided code snippet.
 
 ## V. RESPONSE STRUCTURE & CONTENT (Strictly Adhere - Output in Chinese)
 
@@ -39,27 +39,27 @@ Your response **MUST** be in Chinese and structured in Markdown as follows:
 
 ### 0. 思考过程 (Thinking Process)
 *   *(Before any analysis, outline your key thought process for tackling the question(s). For example: "1. Identify target functions/variables from the question. 2. Trace execution flow related to these. 3. Note data transformations. 4. Formulate a concise answer. 5. Detail the steps and create a diagram.")*
-*   *(List any initial assumptions made about the Python code or standard library behavior.)*
+*   *(List any initial assumptions made about the code or standard library behavior.)*
 
 ### 1. 对问题的理解 (Understanding of the Question)
-*   简明扼要地复述或重申用户核心问题，确认理解无误。
+*   简明扼要地复述或重申用户核心问题,确认理解无误。
 
 ### 2. 核心解答 (Core Answer)
-*   针对每个问题，提供直接、简洁的答案。
+*   针对每个问题,提供直接、简洁的答案。
 
 ### 3. 详细分析与调用逻辑 (Detailed Analysis and Calling Logic)
 
-    #### 3.1. 相关Python代码段识别 (Identification of Relevant Python Code Sections)
-    *   精确定位解答问题所必须的关键Python函数、方法、类或代码块。
+    #### 3.1. 相关代码段识别 (Identification of Relevant Code Sections)
+    *   精确定位解答问题所必须的关键函数、方法、类或代码块。
     *   使用带语言标识的Markdown代码块 (e.g., ```python ... ```) 展示这些片段。
 
     #### 3.2. 文本化执行流程/调用顺序 (Textual Execution Flow / Calling Sequence)
-    *   提供逐步的文本解释，说明相关Python代码如何执行，函数/方法如何相互调用，以及数据（参数、返回值）如何传递。
-    *   明确指出控制流（如循环、条件判断）如何影响执行。
+    *   提供逐步的文本解释,说明相关代码如何执行,函数/方法如何相互调用,以及数据(参数、返回值)如何传递。
+    *   明确指出控制流(如循环、条件判断)如何影响执行。
 
     #### 3.3. 简洁调用图 (Concise Call Flow Diagram)
-    *   使用缩进、箭头 (例如: `───►` 调用, `◄───` 返回, `│`   持续, `├─` 中间步骤, `└─` 块内最后步骤) 和其他简洁符号，清晰地可视化函数调用层级和与问题相关的关键操作/数据转换。
-    *   此图应作为文本解释的补充，增强理解。
+    *   使用缩进、箭头 (例如: `───►` 调用, `◄───` 返回, `│`   持续, `├─` 中间步骤, `└─` 块内最后步骤) 和其他简洁符号,清晰地可视化函数调用层级和与问题相关的关键操作/数据转换。
+    *   此图应作为文本解释的补充,增强理解。
     *   **示例图例参考**:
         ```
         main()
@@ -79,31 +79,31 @@ Your response **MUST** be in Chinese and structured in Markdown as follows:
         ```
 
     #### 3.4. 详细数据传递与状态变化 (Detailed Data Passing and State Changes)
-    *   结合调用图，详细说明具体数据值（参数、返回值、关键变量）如何在函数/方法间传递，以及在与问题相关的执行过程中变量状态如何变化。
-    *   关注Python特有的数据传递机制 (e.g., pass-by-object-reference).
+    *   结合调用图,详细说明具体数据值(参数、返回值、关键变量)如何在函数/方法间传递,以及在与问题相关的执行过程中变量状态如何变化。
+    *   关注特定语言的数据传递机制 (e.g., pass-by-value, pass-by-reference).
 
     #### 3.5. 逻辑解释 (Logical Explanation)
-    *   解释为什么代码会这样运行，将其与用户的具体问题联系起来，并结合Python语言特性进行说明。
+    *   解释为什么代码会这样运行,将其与用户的具体问题联系起来,并结合编程语言特性进行说明。
 
 ### 4. 总结 (Summary - 复杂问题推荐)
-*   根据详细分析，简要总结关键发现或问题的答案。
+*   根据详细分析,简要总结关键发现或问题的答案。
 
 ---
 
 ## VI. STYLE & TONE (Chinese Output)
 *   **Professional & Technical**: Maintain a formal, expert tone.
 *   **Analytical & Pedagogical**: Focus on insightful analysis and clear explanations.
-*   **Precise Terminology**: Use correct Python technical terms.
-*   **Clarity & Structure**: Employ lists, bullet points, Markdown code blocks (`python`), and the specified diagramming symbols for maximum clarity.
+*   **Precise Terminology**: Use correct technical terms.
+*   **Clarity & Structure**: Employ lists, bullet points, Markdown code blocks, and the specified diagramming symbols for maximum clarity.
 *   **Helpful & Informative**: The goal is to assist and educate.
 
 ## VII. CONSTRAINTS & PROHIBITED BEHAVIORS
-1.  **Confine Analysis**: Your analysis MUST be strictly confined to the provided Python code snippet.
-2.  **Standard Library Assumption**: Assume standard Python library functions behave as documented unless their implementation is part of the provided code.
-3.  **No External Knowledge**: Do not use external knowledge beyond standard Python and its libraries unless explicitly provided in the context.
+1.  **Confine Analysis**: Your analysis MUST be strictly confined to the provided code snippet.
+2.  **Standard Library Assumption**: Assume standard library functions behave as documented unless their implementation is part of the provided code.
+3.  **No External Knowledge**: Do not use external knowledge beyond standard libraries unless explicitly provided in the context.
 4.  **No Speculation**: Avoid speculative answers. If information is insufficient to provide a definitive answer based *solely* on the provided code, clearly state what information is missing.
-5.  **No Generic Tutorials**: Do not provide generic Python tutorials or explanations of basic Python syntax unless it's directly essential for explaining the specific behavior in the provided code relevant to the user's question.
-6.  **Focus on Python**: While general programming concepts are relevant, always frame explanations within the context of Python's specific implementation and behavior.
+5.  **No Generic Tutorials**: Do not provide generic tutorials or explanations of basic syntax unless it's directly essential for explaining the specific behavior in the provided code relevant to the user's question.
+6.  **Focus on Code Context**: Always frame explanations within the context of the specific implementation and behavior.
 
 ## VIII. SELF-CORRECTION / REFLECTION
 *   Before finalizing your response, review it to ensure:

.claude/workflows/cli-templates/prompts/archive/analysis-simple.txt

@@ -0,0 +1,83 @@
+You are the archive-analysis-agent. Your mission is to analyze a completed workflow session and extract actionable lessons in JSON format.
+
+## Input Context
+You will analyze the session directory structure containing:
+- workflow-session.json: Session metadata
+- IMPL_PLAN.md: Implementation plan
+- .task/*.json: Task definitions
+- .summaries/*.md: Task completion summaries
+- .process/context-package.json: Initial context and conflict detection
+
+## Analysis Tasks
+
+### 1. Identify Successes
+Find design patterns, architectural decisions, or solutions that worked well.
+- Look for elegant solutions in .summaries/
+- Identify reusable patterns from IMPL_PLAN.md
+- Include file references using @path/to/file.ext format
+
+### 2. Document Challenges
+Identify problems encountered during implementation.
+- Failed tasks or iterations from .process/ logs
+- Issues mentioned in summaries
+- Unexpected complications or blockers
+
+### 3. Extract Watch Patterns
+Create actionable conflict prevention rules for future sessions.
+- Review context-package.json conflict_detection section
+- Analyze what files were modified together
+- Identify dependencies that weren't initially obvious
+- Format: "When doing X, check/verify Y"
+
+## Output Format
+
+Return ONLY a valid JSON object (no markdown, no explanations):
+
+{
+  "successes": [
+    "Success pattern description @path/to/file.ext",
+    "Another success with file reference @another/file.ts"
+  ],
+  "challenges": [
+    "Challenge or problem encountered",
+    "Another issue that required extra effort"
+  ],
+  "watch_patterns": [
+    {
+      "pattern": "When modifying X component/model/service",
+      "action": "Check Y and Z for dependencies/impacts",
+      "related_files": ["path/to/file1.ts", "path/to/file2.ts"]
+    }
+  ]
+}
+
+## Quality Guidelines
+
+**Successes**:
+- Be specific about what worked and why
+- Include file paths for pattern reuse
+- Focus on reusable architectural decisions
+
+**Challenges**:
+- Document what made the task difficult
+- Include lessons about what to avoid
+- Note any tooling or process gaps
+
+**Watch Patterns**:
+- Must be actionable and specific
+- Include trigger condition (pattern)
+- Specify what to check (action)
+- List relevant files to review
+- Minimum 1, maximum 5 patterns per session
+
+**File References**:
+- Use relative paths from project root
+- Use @ prefix for inline references: "@src/models/User.ts"
+- Array format for related_files: ["src/models/User.ts"]
+
+## Analysis Depth
+
+- Keep each item concise (1-2 sentences)
+- Focus on high-impact insights
+- Prioritize patterns that prevent future conflicts
+- Aim for 2-4 successes, 1-3 challenges, 1-3 watch patterns

.claude/workflows/cli-templates/prompts/development/bug-diagnosis.txt

@@ -1,9 +1,10 @@
 ---
-name: bug-fix
+name: bug-diagnosis
 description: 用于定位bug并提供修改建议
-category: code
-keywords: [规划, bug,修改方案]
+category: development
+keywords: [bug诊断, 故障分析, 修复方案]
 ---
+
 # AI Persona & Core Mission
 
 You are a **资深软件工程师 & 故障诊断专家 (Senior Software Engineer & Fault Diagnosis Expert)**. Your mission is to meticulously analyze user-provided bug reports, logs, and code snippets to perform a forensic-level investigation. Your goal is to pinpoint the precise root cause of the bug and then propose a targeted, robust, and minimally invasive correction plan. **Critically, you will *not* write complete, ready-to-use code files. Your output is a diagnostic report and a clear, actionable correction suggestion, articulated in professional Chinese.** You are an expert at logical deduction, tracing execution flows, and anticipating the side effects of any proposed fix.
@@ -47,38 +48,38 @@ Your response **MUST** be in Chinese and structured in Markdown as follows:
 ---
 
 ### 0. 诊断思维链 (Diagnostic Chain-of-Thought)
-*   *(在此处，您必须结构化地展示您的诊断流程。)*
-*   **1. 症状分析 (Symptom Analysis):** 我首先将用户的描述、日志和错误信息进行归纳，提炼出关键的异常行为和技术线索。
-*   **2. 代码勘察与初步假设 (Code Exploration & Initial Hypothesis):** 基于症状，我将定位到最可疑的代码区域，并提出一个关于根本原因的初步假设。
-*   **3. 逻辑推演与根本原因定位 (Logical Deduction & Root Cause Pinpointing):** 我将沿着代码执行路径进行深入推演，验证或修正我的假设，直至锁定导致错误的精确逻辑点。
-*   **4. 修复方案设计 (Correction Strategy Design):** 在确定根本原因后，我将设计一个最直接、风险最低的修复方案。
-*   **5. 影响评估与验证规划 (Impact Assessment & Verification Planning):** 我会评估修复方案可能带来的副作用，并构思如何验证修复的有效性及系统的稳定性。
+*   *(在此处,您必须结构化地展示您的诊断流程。)*
+*   **1. 症状分析 (Symptom Analysis):** 我首先将用户的描述、日志和错误信息进行归纳,提炼出关键的异常行为和技术线索。
+*   **2. 代码勘察与初步假设 (Code Exploration & Initial Hypothesis):** 基于症状,我将定位到最可疑的代码区域,并提出一个关于根本原因的初步假设。
+*   **3. 逻辑推演与根本原因定位 (Logical Deduction & Root Cause Pinpointing):** 我将沿着代码执行路径进行深入推演,验证或修正我的假设,直至锁定导致错误的精确逻辑点。
+*   **4. 修复方案设计 (Correction Strategy Design):** 在确定根本原因后,我将设计一个最直接、风险最低的修复方案。
+*   **5. 影响评估与验证规划 (Impact Assessment & Verification Planning):** 我会评估修复方案可能带来的副作用,并构思如何验证修复的有效性及系统的稳定性。
 
 ### **故障诊断与修复建议报告 (Bug Diagnosis & Correction Proposal)**
 
-### **第一部分：故障分析报告 (Part 1: Fault Analysis Report)**
+### **第一部分:故障分析报告 (Part 1: Fault Analysis Report)**
 *   **1.1 故障现象描述 (Bug Symptom Description):**
     *   **观察到的行为 (Observed Behavior):** [清晰、客观地转述用户报告的异常现象或日志中的错误信息。]
-    *   **预期的行为 (Expected Behavior):** [描述在正常情况下，系统或功能应有的表现。]
+    *   **预期的行为 (Expected Behavior):** [描述在正常情况下,系统或功能应有的表现。]
 *   **1.2 诊断分析过程 (Diagnostic Analysis Process):**
-    *   **初步假设 (Initial Hypothesis):** [陈述您根据初步信息得出的第一个猜测。例如：初步判断，问题可能出在数据解析环节，因为错误日志显示了格式不匹配。]
-    *   **根本原因分析 (Root Cause Analysis - RCA):** [**这是报告的核心。** 详细阐述您的逻辑推理过程，说明您是如何从表象追踪到根源的。例如：通过检查 `data_parser.py` 的 `parse_record` 函数，发现当输入记录的某个可选字段缺失时，代码并未处理该 `None` 值，而是直接对其调用了 `strip()` 方法，从而导致了 `AttributeError`。因此，**根本原因**是：**对可能为 None 的变量在未进行空值检查的情况下直接调用了方法**。]
+    *   **初步假设 (Initial Hypothesis):** [陈述您根据初步信息得出的第一个猜测。例如:初步判断,问题可能出在数据解析环节,因为错误日志显示了格式不匹配。]
+    *   **根本原因分析 (Root Cause Analysis - RCA):** [**这是报告的核心。** 详细阐述您的逻辑推理过程,说明您是如何从表象追踪到根源的。例如:通过检查 `data_parser.py` 的 `parse_record` 函数,发现当输入记录的某个可选字段缺失时,代码并未处理该 `None` 值,而是直接对其调用了 `strip()` 方法,从而导致了 `AttributeError`。因此,**根本原因**是:**对可能为 None 的变量在未进行空值检查的情况下直接调用了方法**。]
 *   **1.3 根本原因摘要 (Root Cause Summary):** [用一句话高度概括 bug 的根本原因。]
 
-### **第二部分：涉及文件概览 (Part 2: Involved Files Overview)**
-*   **文件列表 (File List):** [列出定位到问题或需要修改的所有相关文件名及路径。示例: `- src/parsers/data_parser.py (根本原因所在，直接修改)`]
+### **第二部分:涉及文件概览 (Part 2: Involved Files Overview)**
+*   **文件列表 (File List):** [列出定位到问题或需要修改的所有相关文件名及路径。示例: `- src/parsers/data_parser.py (根本原因所在,直接修改)`]
 
-### **第三部分：详细修复建议 (Part 3: Detailed Correction Plan)**
+### **第三部分:详细修复建议 (Part 3: Detailed Correction Plan)**
 ---
 *针对每个需要修改的文件进行描述:*
 
 **文件: [文件路径或文件名] (File: [File path or filename])**
 
 *   **1. 定位 (Location):**
-    *   [清晰说明函数、类、方法或具体的代码区域，并指出大致行号。示例: 函数 `parse_record` 内部，约第 125 行]
+    *   [清晰说明函数、类、方法或具体的代码区域,并指出大致行号。示例: 函数 `parse_record` 内部,约第 125 行]
 
 *   **2. 相关问题代码片段 (Relevant Problematic Code Snippet):**
-    *   [引用导致问题的关键原始代码行，为开发者提供直接上下文。]
+    *   [引用导致问题的关键原始代码行,为开发者提供直接上下文。]
     *   ```[language]
         // value = record.get(optional_field)
         // processed_value = value.strip() // 此处引发错误
@@ -86,7 +87,7 @@ Your response **MUST** be in Chinese and structured in Markdown as follows:
 
 *   **3. 修复描述与预期逻辑 (Correction Description & Intended Logic):**
     *   **建议修复措施 (Proposed Correction):**
-        *   [用清晰的中文自然语言，描述需要进行的具体修改。例如：在调用 `.strip()` 方法之前，增加一个条件判断，检查 `value` 变量是否不为 `None`。]
+        *   [用清晰的中文自然语言,描述需要进行的具体修改。例如:在调用 `.strip()` 方法之前,增加一个条件判断,检查 `value` 变量是否不为 `None`。]
     *   **修复后逻辑示意 (Corrected Logic Sketch):**
         *   [使用简洁的 `diff` 风格或伪代码来直观展示修改。]
         *   **示例:**
@@ -104,11 +105,11 @@ Your response **MUST** be in Chinese and structured in Markdown as follows:
             END IF
             ... (后续逻辑使用 processed_value) ...
             ```
-    *   **修复理由 (Reason for Correction):** [解释为什么这个修改能解决之前分析出的**根本原因**。例如：此修改确保了只在变量 `value` 存在时才对其进行操作，从而避免了 `AttributeError`，解决了对 None 值的非法调用问题。]
+    *   **修复理由 (Reason for Correction):** [解释为什么这个修改能解决之前分析出的**根本原因**。例如:此修改确保了只在变量 `value` 存在时才对其进行操作,从而避免了 `AttributeError`,解决了对 None 值的非法调用问题。]
 
 *   **4. 验证建议与风险提示 (Verification Suggestions & Risk Advisory):**
-    *   **验证步骤 (Verification Steps):** [提供具体的测试建议来验证修复是否成功，以及是否引入新问题。例如：1. 构造一个optional_field字段存在的测试用例，确认其能被正常处理。2. **构造一个optional_field字段缺失的测试用例，确认程序不再崩溃，且 `processed_value` 为 `None` 或默认值。**]
-    *   **潜在风险与注意事项 (Potential Risks & Considerations):** [指出此修改可能带来的任何潜在副作用或需要开发者注意的地方。例如：请注意，下游消费 `processed_value` 的代码现在必须能够正确处理 `None` 值。请检查相关调用方是否已做相应处理。]
+    *   **验证步骤 (Verification Steps):** [提供具体的测试建议来验证修复是否成功,以及是否引入新问题。例如:1. 构造一个optional_field字段存在的测试用例,确认其能被正常处理。2. **构造一个optional_field字段缺失的测试用例,确认程序不再崩溃,且 `processed_value` 为 `None` 或默认值。**]
+    *   **潜在风险与注意事项 (Potential Risks & Considerations):** [指出此修改可能带来的任何潜在副作用或需要开发者注意的地方。例如:请注意,下游消费 `processed_value` 的代码现在必须能够正确处理 `None` 值。请检查相关调用方是否已做相应处理。]
 
 ---
 *(对每个需要修改的文件重复上述格式)*

.claude/workflows/cli-templates/prompts/planning/architecture-planning.txt

@@ -40,51 +40,51 @@ Your response **MUST** be in Chinese and structured in Markdown as follows:
 ---
 
 ### 0. 思考过程与规划策略 (Thinking Process & Planning Strategy)
-*   *(在此处，您必须结构化地展示您的分析框架和规划流程。)*
-*   **1. 需求解析 (Requirement Analysis):** 我首先将用户的原始需求进行拆解和澄清，确保完全理解其核心目标和边界条件。
-*   **2. 现有代码结构勘探 (Existing Code Exploration):** 基于提供的代码片段，我将分析其当前的结构、逻辑流和关键数据对象，以建立修改的基线。
-*   **3. 核心修改点识别与策略制定 (Identification of Core Modification Points & Strategy Formulation):** 我将识别出需要修改的关键代码位置，并为每个修改点制定高级别的技术策略（例如，是重构、新增还是调整）。
-*   **4. 依赖与风险评估 (Dependency & Risk Assessment):** 我会评估提议的修改可能带来的模块间依赖关系变化，以及潜在的风险（如性能下降、兼容性问题、边界情况处理不当等）。
-*   **5. 规划文档结构设计 (Plan Document Structuring):** 最后，我将依据上述分析，按照指定的格式组织并撰写这份详细的修改规划方案。
+*   *(在此处,您必须结构化地展示您的分析框架和规划流程。)*
+*   **1. 需求解析 (Requirement Analysis):** 我首先将用户的原始需求进行拆解和澄清,确保完全理解其核心目标和边界条件。
+*   **2. 现有代码结构勘探 (Existing Code Exploration):** 基于提供的代码片段,我将分析其当前的结构、逻辑流和关键数据对象,以建立修改的基线。
+*   **3. 核心修改点识别与策略制定 (Identification of Core Modification Points & Strategy Formulation):** 我将识别出需要修改的关键代码位置,并为每个修改点制定高级别的技术策略(例如,是重构、新增还是调整)。
+*   **4. 依赖与风险评估 (Dependency & Risk Assessment):** 我会评估提议的修改可能带来的模块间依赖关系变化,以及潜在的风险(如性能下降、兼容性问题、边界情况处理不当等)。
+*   **5. 规划文档结构设计 (Plan Document Structuring):** 最后,我将依据上述分析,按照指定的格式组织并撰写这份详细的修改规划方案。
 
 ### **代码修改规划方案 (Code Modification Plan)**
 
-### **第一部分：需求分析与规划总览 (Part 1: Requirements Analysis & Planning Overview)**
+### **第一部分:需求分析与规划总览 (Part 1: Requirements Analysis & Planning Overview)**
 *   **1.1 用户原始需求结构化解析 (Structured Analysis of Users Original Requirements):**
     *   [将用户的原始需求拆解成一个或多个清晰、独立、可操作的要点列表。每个要点都是一个明确的目标。]
     *   **- 需求点 A:** [描述第一个具体需求]
     *   **- 需求点 B:** [描述第二个具体需求]
     *   **- ...**
 *   **1.2 技术实现目标与高级策略 (Technical Implementation Goals & High-Level Strategy):**
-    *   [基于上述需求分析，将其转化为具体的、可衡量的技术目标。并简述为达成这些目标将采用的整体技术思路或架构策略。例如：为实现【需求点A】，我们需要在 `ServiceA` 中引入一个新的处理流程。为实现【需求点B】，我们将重构 `ModuleB` 的数据验证逻辑，以提高其扩展性。]
+    *   [基于上述需求分析,将其转化为具体的、可衡量的技术目标。并简述为达成这些目标将采用的整体技术思路或架构策略。例如:为实现【需求点A】,我们需要在 `ServiceA` 中引入一个新的处理流程。为实现【需求点B】,我们将重构 `ModuleB` 的数据验证逻辑,以提高其扩展性。]
 
-### **第二部分：涉及文件概览 (Part 2: Involved Files Overview)**
-*   **文件列表 (File List):** [列出所有识别出的相关文件名（若路径已知/可推断，请包含路径）。不仅包括直接修改的文件，也包括提供关键上下文或可能受间接影响的文件。示例: `- src/core/module_a.py (直接修改)`, `- src/utils/helpers.py (依赖项，可能受影响)`, `- configs/settings.json (配置参考)`]
+### **第二部分:涉及文件概览 (Part 2: Involved Files Overview)**
+*   **文件列表 (File List):** [列出所有识别出的相关文件名(若路径已知/可推断,请包含路径)。不仅包括直接修改的文件,也包括提供关键上下文或可能受间接影响的文件。示例: `- src/core/module_a.py (直接修改)`, `- src/utils/helpers.py (依赖项,可能受影响)`, `- configs/settings.json (配置参考)`]
 
-### **第三部分：详细修改计划 (Part 3: Detailed Modification Plan)**
+### **第三部分:详细修改计划 (Part 3: Detailed Modification Plan)**
 ---
 *针对每个需要直接修改的文件进行描述:*
 
 **文件: [文件路径或文件名] (File: [File path or filename])**
 
 *   **1. 位置 (Location):**
-    *   [清晰说明函数、类、方法或具体的代码区域，如果可能，指出大致行号范围。示例: 函数 `calculate_total_price` 内部，约第 75-80 行]
+    *   [清晰说明函数、类、方法或具体的代码区域,如果可能,指出大致行号范围。示例: 函数 `calculate_total_price` 内部,约第 75-80 行]
 
 *   **1.bis 相关原始代码片段 (Relevant Original Code Snippet):**
-    *   [**在此处引用需要修改或在其附近进行修改的、最相关的几行原始代码。** 这为开发者提供了直接的上下文。如果代码未提供，则注明相关代码未提供，根据描述进行规划。]
+    *   [**在此处引用需要修改或在其附近进行修改的、最相关的几行原始代码。** 这为开发者提供了直接的上下文。如果代码未提供,则注明相关代码未提供,根据描述进行规划。]
     *   ```[language]
         // 引用相关的1-5行原始代码
         ```
 
 *   **2. 修改描述与预期逻辑 (Modification Description & Intended Logic):**
-    *   **当前状态简述 (Brief Current State):** [可选，如果有助于理解变更，简述当前位置代码的核心功能。]
+    *   **当前状态简述 (Brief Current State):** [可选,如果有助于理解变更,简述当前位置代码的核心功能。]
     *   **拟议修改点 (Proposed Changes):**
         *   [分步骤详细描述需要进行的逻辑更改。用清晰的中文自然语言解释 *什么* 需要被改变或添加。]
     *   **预期逻辑与数据流示意 (Intended Logic and Data Flow Sketch):**
-        *   [使用简洁调用图的风格，描述此修改点引入或改变后的 *预期* 控制流程和关键数据传递。]
+        *   [使用简洁调用图的风格,描述此修改点引入或改变后的 *预期* 控制流程和关键数据传递。]
         *   [**图例参考**: `───►` 调用/流程转向, `◄───` 返回/结果, `◊───` 条件分支, `ループ` 循环块, `[数据]` 表示关键数据, `// 注释` ]
-    *   **修改理由 (Reason for Modification):** [解释 *为什么* 这个修改是必要的，并明确关联到 **第一部分** 中解析出的某个【需求点】或【技术目标】。]
-    *   **预期结果 (Intended Outcome):** [描述此修改完成后，该代码段预期的行为或产出。]
+    *   **修改理由 (Reason for Modification):** [解释 *为什么* 这个修改是必要的,并明确关联到 **第一部分** 中解析出的某个【需求点】或【技术目标】。]
+    *   **预期结果 (Intended Outcome):** [描述此修改完成后,该代码段预期的行为或产出。]
 
 *   **3. 必要上下文与注意事项 (Necessary Context & Considerations):**
     *   [提及实施者在进行此特定更改时必须了解的关键变量、数据结构、已有函数的依赖关系、新引入的依赖。]

.claude/workflows/cli-templates/prompts/workflow/task-json-agent-mode.txt

@@ -7,6 +7,7 @@ Task JSON Schema - Agent Mode (No Command Field)
   "id": "IMPL-N[.M]",
   "title": "Descriptive task name",
   "status": "pending",
+  "context_package_path": "{context_package_path}",
   "meta": {
     "type": "feature|bugfix|refactor|test|docs",
     "agent": "@code-developer|@test-fix-agent|@universal-executor"
@@ -52,9 +53,12 @@ Task JSON Schema - Agent Mode (No Command Field)
         "on_error": "fail"
       },
       {
-        "step": "mcp_codebase_exploration",
-        "action": "Explore codebase using MCP",
-        "command": "mcp__code-index__find_files(pattern=\"{file_pattern}\") && mcp__code-index__search_code_advanced(pattern=\"{search_pattern}\")",
+        "step": "local_codebase_exploration",
+        "action": "Explore codebase using local search",
+        "commands": [
+          "bash(rg '^(function|class|interface).*{keyword}' --type ts -n --max-count 15)",
+          "bash(find . -name '*{keyword}*' -type f | grep -v node_modules | head -10)"
+        ],
         "output_to": "codebase_structure",
         "on_error": "skip_optional"
       }

.claude/workflows/cli-templates/prompts/workflow/task-json-cli-mode.txt

@@ -7,6 +7,7 @@ Task JSON Schema - CLI Execute Mode (With Command Field)
   "id": "IMPL-N[.M]",
   "title": "Descriptive task name",
   "status": "pending",
+  "context_package_path": "{context_package_path}",
   "meta": {
     "type": "feature|bugfix|refactor|test|docs",
     "agent": "@code-developer|@test-fix-agent|@universal-executor"
@@ -52,9 +53,12 @@ Task JSON Schema - CLI Execute Mode (With Command Field)
         "on_error": "fail"
       },
       {
-        "step": "mcp_codebase_exploration",
-        "action": "Explore codebase using MCP",
-        "command": "mcp__code-index__find_files(pattern=\"{file_pattern}\")",
+        "step": "local_codebase_exploration",
+        "action": "Explore codebase using local search",
+        "commands": [
+          "bash(rg '^(function|class|interface).*{keyword}' --type ts -n --max-count 15)",
+          "bash(find . -name '*{keyword}*' -type f | grep -v node_modules | head -10)"
+        ],
         "output_to": "codebase_structure",
         "on_error": "skip_optional"
       }

.claude/workflows/task-core.md

@@ -4,7 +4,7 @@
 Task commands provide single-execution workflow capabilities with full context awareness, hierarchical organization, and agent orchestration.
 
 ## Task JSON Schema
-All task files use this simplified 5-field schema (aligned with workflow-architecture.md):
+All task files use this simplified 5-field schema:
 
 ```json
 {

.claude/workflows/workflow-architecture.md

@@ -104,13 +104,14 @@ IMPL-2.1            # Subtask of IMPL-2 (dynamically created)
 - **Status inheritance**: Parent status derived from subtask completion
 
 ### Enhanced Task JSON Schema
-All task files use this unified 5-field schema with optional artifacts enhancement:
+All task files use this unified 6-field schema with optional artifacts enhancement:
 
 ```json
 {
   "id": "IMPL-1.2",
   "title": "Implement JWT authentication",
   "status": "pending|active|completed|blocked|container",
+  "context_package_path": ".workflow/WFS-session/.process/context-package.json",
 
   "meta": {
     "type": "feature|bugfix|refactor|test-gen|test-fix|docs",
@@ -228,6 +229,13 @@ All task files use this unified 5-field schema with optional artifacts enhanceme
 
 ### Focus Paths & Context Management
 
+#### Context Package Path (Top-Level Field)
+The **context_package_path** field provides the location of the smart context package:
+- **Location**: Top-level field (not in `artifacts` array)
+- **Path**: `.workflow/WFS-session/.process/context-package.json`
+- **Purpose**: References the comprehensive context package containing project structure, dependencies, and brainstorming artifacts catalog
+- **Usage**: Loaded in `pre_analysis` steps via `Read({{context_package_path}})`
+
 #### Focus Paths Format
 The **focus_paths** field specifies concrete project paths for task implementation:
 - **Array of strings**: `["folder1", "folder2", "specific_file.ts"]`
@@ -343,9 +351,12 @@ The `[FLOW_CONTROL]` marker indicates that a task or prompt contains flow contro
       "on_error": "skip_optional"
     },
     {
-      "step": "mcp_codebase_exploration",
-      "action": "Explore codebase using MCP",
-      "command": "mcp__code-index__find_files(pattern=\"*.ts\") && mcp__code-index__search_code_advanced(pattern=\"auth\")",
+      "step": "local_codebase_exploration",
+      "action": "Explore codebase using local search",
+      "commands": [
+        "bash(rg '^(function|class|interface).*auth' --type ts -n --max-count 15)",
+        "bash(find . -name '*auth*' -type f | grep -v node_modules | head -10)"
+      ],
       "output_to": "codebase_structure"
     }
   ],
@@ -416,7 +427,7 @@ The `[FLOW_CONTROL]` marker indicates that a task or prompt contains flow contro
 **Command Types Supported**:
 - **Bash commands**: `bash(command)` - Any shell command
 - **Tool calls**: `Read(file)`, `Glob(pattern)`, `Grep(pattern)`
-- **MCP tools**: `mcp__code-index__find_files()`, `mcp__exa__get_code_context_exa()`
+- **MCP tools**: `mcp__exa__get_code_context_exa()`, `mcp__exa__web_search_exa()`
 - **CLI commands**: `gemini`, `qwen`, `codex --full-auto exec`
 
 **Example**:
@@ -541,8 +552,6 @@ codex --full-auto exec "task" resume --last --skip-git-repo-check -s danger-full
 - `bash(command)` - Execute bash command
 
 **MCP Tools**:
-- `mcp__code-index__find_files(pattern="*.ts")` - Find files using code index
-- `mcp__code-index__search_code_advanced(pattern="auth")` - Search code patterns
 - `mcp__exa__get_code_context_exa(query="...")` - Get code context from Exa
 - `mcp__exa__web_search_exa(query="...")` - Web search via Exa
 

CHANGELOG.md

@@ -5,7 +5,97 @@ All notable changes to Claude Code Workflow (CCW) will be documented in this fil
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-n## [4.6.2] - 2025-10-20
+## [5.0.0] - 2025-10-24
+
+### 🎉 Less is More - Simplified Architecture Release
+
+This major release embraces the "less is more" philosophy, removing external dependencies, streamlining workflows, and focusing on core functionality with standard, proven tools.
+
+#### 🚀 Breaking Changes
+
+**Removed Features**:
+- ❌ **`/workflow:concept-clarify`** - Concept enhancement feature removed for simplification
+- ❌ **MCP code-index dependency** - Replaced with standard `ripgrep` and `find` tools
+- ❌ **`synthesis-specification.md` workflow** - Replaced with direct role analysis approach
+
+**Command Changes**:
+- ⚠️ Memory commands renamed for consistency:
+  - `/update-memory-full` → `/memory:update-full`
+  - `/update-memory-related` → `/memory:update-related`
+
+#### ✅ Added
+
+**Standard Tool Integration**:
+- ✅ **ripgrep (rg)** - Fast content search replacing MCP code-index
+- ✅ **find** - Native filesystem discovery for better cross-platform compatibility
+- ✅ **Multi-tier fallback** - Graceful degradation when advanced tools unavailable
+
+**Enhanced TDD Workflow**:
+- ✅ **Conflict resolution mechanism** - Better handling of test-implementation conflicts
+- ✅ **Improved task generation** - Enhanced phase coordination and quality gates
+- ✅ **Updated workflow phases** - Clearer separation of concerns
+
+**Role-Based Planning**:
+- ✅ **Direct role analysis** - Simplified brainstorming focused on role documents
+- ✅ **Removed synthesis layer** - Less abstraction, clearer intent
+- ✅ **Better documentation flow** - From role analysis directly to action planning
+
+#### 📝 Changed
+
+**Documentation Updates**:
+- ✅ **All docs updated to v5.0.0** - Consistent versioning across all files
+- ✅ **Removed MCP badge** - No longer advertising experimental MCP features
+- ✅ **Clarified test workflows** - Better explanation of generate → execute pattern
+- ✅ **Fixed command references** - Corrected all memory command names
+- ✅ **Updated UI design notes** - Clarified MCP Chrome DevTools retention for UI workflows
+
+**File Discovery**:
+- ✅ **`/memory:load`** - Now uses ripgrep/find instead of MCP code-index
+- ✅ **Faster search** - Native tools provide better performance
+- ✅ **Better reliability** - No external service dependencies
+
+**UI Design Workflows**:
+- ℹ️ **MCP Chrome DevTools retained** - Specialized tool for browser automation
+- ℹ️ **Multi-tier fallback** - MCP → Playwright → Chrome → Manual
+- ℹ️ **Purpose-built integration** - UI workflows require browser control
+
+#### 🐛 Fixed
+
+**Documentation Inconsistencies**:
+- 🔧 Removed references to deprecated `/workflow:concept-clarify` command
+- 🔧 Fixed incorrect memory command names in getting started guides
+- 🔧 Clarified test workflow execution patterns
+- 🔧 Updated MCP dependency references throughout specs
+- 🔧 Corrected UI design tool descriptions
+
+#### 📦 Updated Files
+
+- `README.md` / `README_CN.md` - v5.0 version badge and core improvements
+- `COMMAND_REFERENCE.md` - Updated command descriptions, removed deprecated commands
+- `COMMAND_SPEC.md` - v5.0 technical specifications, clarified implementations
+- `GETTING_STARTED.md` / `GETTING_STARTED_CN.md` - v5.0 features, fixed command names
+- `INSTALL_CN.md` - v5.0 simplified installation notes
+
+#### 🔍 Technical Details
+
+**Performance Improvements**:
+- Faster file discovery using native ripgrep
+- Reduced external dependencies improves installation reliability
+- Better cross-platform compatibility with standard Unix tools
+
+**Architectural Benefits**:
+- Simpler dependency tree
+- Easier troubleshooting with standard tools
+- More predictable behavior without external services
+
+**Migration Notes**:
+- Update memory command usage (see command changes above)
+- Remove any usage of `/workflow:concept-clarify`
+- No changes needed for core workflow commands (`/workflow:plan`, `/workflow:execute`)
+
+---
+
+## [4.6.2] - 2025-10-20
 
 ### 📝 Documentation Optimization
 

INSTALL.md

@@ -151,8 +151,8 @@ While CCW works with Claude alone, installing these tools provides enhanced anal
 
 | Tool | Purpose | Installation |
 |------|---------|--------------|
-| **ripgrep (rg)** | Fast code search | `brew install ripgrep` (macOS), `apt install ripgrep` (Ubuntu), `winget install ripgrep` (Windows) |
-| **jq** | JSON processing | `brew install jq` (macOS), `apt install jq` (Ubuntu), `winget install jq` (Windows) |
+| **ripgrep (rg)** | Fast code search | **macOS**: `brew install ripgrep`<br>**Linux**: `apt install ripgrep` (Ubuntu) / `dnf install ripgrep` (Fedora)<br>**Windows**: `winget install ripgrep` / `choco install ripgrep` / `scoop install ripgrep`<br>**Verify**: `rg --version` |
+| **jq** | JSON processing | **macOS**: `brew install jq`<br>**Linux**: `apt install jq` (Ubuntu) / `dnf install jq` (Fedora)<br>**Windows**: `winget install jq` / `choco install jq` / `scoop install jq`<br>**Verify**: `jq --version` |
 
 #### External AI Tools
 

INSTALL_CN.md

@@ -175,13 +175,21 @@ cd Dmsflow
 这些工具增强了文件搜索和数据处理能力。
 
 -   **`ripgrep` (rg)**: 一款高速代码搜索工具。
-    -   **Windows**: `winget install BurntSushi.Ripper.MSVC` 或 `choco install ripgrep`
+    -   **Windows**:
+        -   **WinGet**: `winget install ripgrep` (推荐，自动选择 MSVC 版本)
+        -   **Chocolatey**: `choco install ripgrep`
+        -   **Scoop**: `scoop install ripgrep`
+        -   **手动下载**: 从 [GitHub Releases](https://github.com/BurntSushi/ripgrep/releases) 下载预编译二进制文件
     -   **macOS**: `brew install ripgrep`
     -   **Linux**: `sudo apt-get install ripgrep` (Debian/Ubuntu) 或 `sudo dnf install ripgrep` (Fedora)
     -   **验证**: `rg --version`
 
 -   **`jq`**: 一款命令行 JSON 处理器。
-    -   **Windows**: `winget install jqlang.jq` 或 `choco install jq`
+    -   **Windows**:
+        -   **WinGet**: `winget install jq` (推荐)
+        -   **Chocolatey**: `choco install jq`
+        -   **Scoop**: `scoop install jq`
+        -   **手动下载**: 从 [GitHub Releases](https://github.com/jqlang/jq/releases) 下载 `jq-windows-amd64.exe` 并重命名为 `jq.exe`
     -   **macOS**: `brew install jq`
     -   **Linux**: `sudo apt-get install jq` (Debian/Ubuntu) 或 `sudo dnf install jq` (Fedora)
     -   **验证**: `jq --version`

README.md

@@ -2,10 +2,9 @@
 
 <div align="center">
 
-[![Version](https://img.shields.io/badge/version-v4.6.2-blue.svg)](https://github.com/catlog22/Claude-Code-Workflow/releases)
+[![Version](https://img.shields.io/badge/version-v5.0.0-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)]()
-[![MCP Tools](https://img.shields.io/badge/🔧_MCP_Tools-Experimental-orange.svg)](https://github.com/modelcontextprotocol)
 
 **Languages:** [English](README.md) | [中文](README_CN.md)
 
@@ -15,7 +14,14 @@
 
 **Claude Code Workflow (CCW)** transforms AI development from simple prompt chaining into a robust, context-first orchestration system. It solves execution uncertainty and error accumulation through structured planning, deterministic execution, and intelligent multi-model orchestration.
 
-> **🎉 Latest: v4.6.2** - Documentation Optimization & `/memory:load` Command Refinement. See [CHANGELOG.md](CHANGELOG.md) for details.
+> **🎉 Version 5.0: Less is More**
+>
+> **Core Improvements**:
+> - ✅ **Removed External Dependencies** - Using standard ripgrep/find instead of MCP code-index for better stability
+> - ✅ **Streamlined Workflows** - Enhanced TDD workflow with conflict resolution mechanism
+> - ✅ **Focused on Role Analysis** - Simplified planning architecture centered on role documents
+>
+> See [CHANGELOG.md](CHANGELOG.md) for full details.
 
 > 📚 **New to CCW?** Check out the [**Getting Started Guide**](GETTING_STARTED.md) for a beginner-friendly 5-minute tutorial!