refactor: enhance conflict resolution command with modification suggestions for custom handling

- Updated synthesis tool to enhance user interaction with multi-select options and improved question presentation in Chinese.
- Revised conflict resolution tool to allow batch processing of conflicts, increasing the limit from 4 to 10 per round and changing user interaction from AskUserQuestion to text output.
- Added context_package_path to task generation tools for better context management.
- Improved task generation schema to include context_package_path for enhanced context delivery.
- Updated CLI templates to reflect changes in task JSON schema, ensuring context_package_path is included.

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

@@ -26,9 +26,9 @@ You are a pure execution agent specialized in creating actionable implementation
   - `session_id`: Workflow session identifier (WFS-[topic])
   - `session_metadata`: Session configuration and state
   - `analysis_results`: Analysis recommendations and task breakdown
-  - `artifacts_inventory`: Detected brainstorming outputs (synthesis-spec, topic-framework, role analyses)
+  - `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)
@@ -77,8 +77,8 @@ Phase 2: Document Generation (Autonomous Output)
     "dependencies": [...]
   },
   "artifacts_inventory": {
-    "synthesis_specification": ".workflow/WFS-auth/.brainstorming/synthesis-specification.md",
-    "topic_framework": ".workflow/WFS-auth/.brainstorming/topic-framework.md",
+    "synthesis_specification": ".workflow/WFS-auth/.brainstorming/role analysis documents",
+    "topic_framework": ".workflow/WFS-auth/.brainstorming/guidance-specification.md",
     "role_analyses": [
       ".workflow/WFS-auth/.brainstorming/system-architect/analysis.md",
       ".workflow/WFS-auth/.brainstorming/subject-matter-expert/analysis.md"
@@ -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"
 }
 ```
@@ -194,17 +180,17 @@ Generate individual `.task/IMPL-*.json` files with:
     "implementation_approach": [
       {
         "step": 1,
-        "title": "Load and analyze synthesis specification",
-        "description": "Load synthesis specification from artifacts and extract requirements",
-        "modification_points": ["Load synthesis specification", "Extract requirements and design patterns"],
-        "logic_flow": ["Read synthesis specification from artifacts", "Parse architecture decisions", "Extract implementation requirements"],
+        "title": "Load and analyze role analyses",
+        "description": "Load role analyses from artifacts and extract requirements",
+        "modification_points": ["Load role analyses", "Extract requirements and design patterns"],
+        "logic_flow": ["Read role analyses from artifacts", "Parse architecture decisions", "Extract implementation requirements"],
         "depends_on": [],
         "output": "synthesis_requirements"
       },
       {
         "step": 2,
         "title": "Implement following specification",
-        "description": "Implement task requirements following consolidated synthesis specification",
+        "description": "Implement task requirements following consolidated role analyses",
         "modification_points": ["Apply requirements from [synthesis_requirements]", "Modify target files", "Integrate with existing code"],
         "logic_flow": ["Apply changes based on [synthesis_requirements]", "Implement core logic", "Validate against acceptance criteria"],
         "depends_on": [1],
@@ -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,23 +1,23 @@
 ---
 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.
+  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 Exa 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
+    commentary: Agent autonomously discovers context via ripgrep/find, researches best practices via MCP Exa, 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
+    commentary: Agent discovers API files via local search, 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
+    commentary: Agent loads task JSON, discovers code context via local search, routes output to workflow session
 color: purple
 ---
 
@@ -88,7 +88,7 @@ Score < 2 → Simple
 
 ## Phase 2: Context Discovery
 
-### Multi-Tool Parallel Strategy
+### Context Discovery Strategy
 
 **1. Project Structure Analysis**:
 ```bash
@@ -96,27 +96,7 @@ Score < 2 → Simple
 ```
 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 (ripgrep)**:
 ```bash
 # Function/class definitions
 rg "^(function|def|func|class|interface).*{keyword}" \
@@ -130,7 +110,7 @@ find . \( -name "*{keyword}*test*" -o -name "*{keyword}*spec*" \) \
    -type f | grep -E "\.(js|ts|py|go)$" | head -10
 ```
 
-**4. External Research (MCP Exa - Optional)**:
+**3. External Research (MCP Exa - Optional)**:
 ```javascript
 // Best practices for complex tasks
 mcp__exa__get_code_context_exa(
@@ -172,10 +152,18 @@ score = 0
 "analyze" → "Code understanding and pattern identification"
 ```
 
+
 **2. Context Assembly**:
 ```bash
+# Default: comprehensive context
+CONTEXT: @**/*
+
+# Or specific patterns
 CONTEXT: @CLAUDE.md @{discovered_file1} @{discovered_file2} ...
 
+# Cross-directory references (requires --include-directories)
+CONTEXT: @**/* @../shared/**/* @../types/**/*
+
 ## Discovered Context
 - **Project Structure**: {module_summary}
 - **Relevant Files**: {top_files_with_scores}
@@ -187,6 +175,12 @@ CONTEXT: @CLAUDE.md @{discovered_file1} @{discovered_file2} ...
 {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**:
 ```
 intent=analyze → ~/.claude/workflows/cli-templates/prompts/analysis/pattern.txt
@@ -194,6 +188,14 @@ intent=execute + complex → ~/.claude/workflows/cli-templates/prompts/developme
 intent=plan → ~/.claude/workflows/cli-templates/prompts/planning/task-breakdown.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 \"...\")`
+
 **4. Structured Prompt**:
 ```bash
 PURPOSE: {enhanced_intent}
@@ -234,36 +236,91 @@ ELSE IF intent = 'discuss':
 # User --tool flag overrides auto-selection
 ```
 
+### Model Selection
+
+**Gemini Models**:
+- `gemini-2.5-pro` - Analysis tasks (default)
+- `gemini-2.5-flash` - Documentation updates
+
+**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)**:
 ```bash
-cd {directory} && ~/.claude/scripts/{tool}-wrapper -p "
+# 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
-cd {directory} && ~/.claude/scripts/{tool}-wrapper --approval-mode yolo -p "
+# 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}
-" --skip-git-repo-check -s danger-full-access
+" -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 "
+PURPOSE: {goal}
+CONTEXT: @**/* @../shared/**/* @../types/**/*
+...
+" --include-directories ../shared,../types
+```
+
+### 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
@@ -361,30 +418,6 @@ if (activeSession.exists) {
 
 ## MCP Integration Guidelines
 
-### Code Index Usage
-
-**Project Setup**:
-```javascript
-mcp__code-index__set_project_path(path="{project_root}")
-mcp__code-index__refresh_index()
-```
-
-**File Discovery**:
-```javascript
-// Find by pattern
-mcp__code-index__find_files(pattern="*auth*")
-
-// Search content
-mcp__code-index__search_code_advanced(
-  pattern="function.*authenticate",
-  file_pattern="*.ts",
-  context_lines=3
-)
-
-// Get structure
-mcp__code-index__get_file_summary(file_path="src/auth/index.ts")
-```
-
 ### Exa Research Usage
 
 **Best Practices**:
@@ -407,13 +440,11 @@ mcp__exa__get_code_context_exa(
 
 ### Graceful Degradation
 
-**MCP Unavailable**:
+**MCP Exa 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
+# Fallback to local search only
+find . -name "*{keyword}*" -type f | grep -v node_modules
+rg "{keyword}" --type ts --max-count 20
 ```
 
 **Tool Unavailable**:
@@ -476,3 +507,5 @@ Before completing execution:
 - Leave partial results without documentation
 
 
+### Windows Path Format Guidelines
+- **Quick Ref**: `C:\Users` → MCP: `C:\\Users` | Bash: `/c/Users` or `C:/Users`

.claude/agents/code-developer.md

@@ -33,6 +33,14 @@ You are a code execution specialist focused on implementing high-quality, produc
 - User-provided task description and context
 - Existing documentation and code examples
 - Project CLAUDE.md standards
+- **context-package.json** (when available in workflow tasks)
+
+**Context Package** (CCW Workflow):
+`context-package.json` provides artifact paths - extract dynamically using `jq`:
+```bash
+# Get role analysis paths from context package
+jq -r '.brainstorm_artifacts.role_analyses[].files[].path' context-package.json
+```
 
 **Pre-Analysis: Smart Tech Stack Loading**:
 ```bash
@@ -84,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:
@@ -243,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
@@ -297,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

@@ -14,11 +14,11 @@ description: |
   Examples:
   - Context: Auto brainstorm assigns system-architect role
     auto.md: Assigns dedicated agent with ASSIGNED_ROLE: system-architect
-    agent: "I'll execute system-architect analysis for this topic, creating architecture-focused conceptual analysis in .brainstorming/system-architect/ directory"
+    agent: "I'll execute system-architect analysis for this topic, creating architecture-focused conceptual analysis in OUTPUT_LOCATION"
 
   - Context: Auto brainstorm assigns ui-designer role
     auto.md: Assigns dedicated agent with ASSIGNED_ROLE: ui-designer
-    agent: "I'll execute ui-designer analysis for this topic, creating UX-focused conceptual analysis in .brainstorming/ui-designer/ directory"
+    agent: "I'll execute ui-designer analysis for this topic, creating UX-focused conceptual analysis in OUTPUT_LOCATION"
 
 color: purple
 ---
@@ -99,7 +99,7 @@ This agent processes **simplified inline [FLOW_CONTROL]** format from brainstorm
 ### Flow Control Steps
 1. **load_topic_framework**
    - Action: Load structured topic framework
-   - Command: Read(.workflow/WFS-{session}/.brainstorming/topic-framework.md)
+   - Command: Read(.workflow/WFS-{session}/.brainstorming/guidance-specification.md)
    - Output: topic_framework
 
 2. **load_role_template**
@@ -166,7 +166,7 @@ When called, you receive:
 - **User Context**: Specific requirements, constraints, and expectations from user discussion
 - **Output Location**: Directory path for generated analysis files
 - **Role Hint** (optional): Suggested role or role selection guidance
-- **GEMINI_ANALYSIS_REQUIRED** (optional): Flag to trigger Gemini CLI analysis
+- **context-package.json** (CCW Workflow): Artifact paths catalog - extract using `jq -r '.brainstorm_artifacts.role_analyses[].files[].path'`
 - **ASSIGNED_ROLE** (optional): Specific role assignment
 - **ANALYSIS_DIMENSIONS** (optional): Role-specific analysis dimensions
 
@@ -231,18 +231,24 @@ Generate documents according to loaded role template specifications:
 
 **Required Files**:
 - **analysis.md**: Main role perspective analysis incorporating user context and role template
-- **recommendations.md**: Role-specific strategic recommendations and action items
-- **[role-deliverables]/**: Directory for specialized role outputs as defined in planning role template
+  - **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
@@ -263,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
@@ -314,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/general-purpose.md

@@ -1,5 +1,5 @@
 ---
-name: general-purpose
+name: universal-executor
 description: |
   Versatile execution agent for implementing any task efficiently. Adapts to any domain while maintaining quality standards and systematic execution. Can handle analysis, implementation, documentation, research, and complex multi-step workflows.
 

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

@@ -68,6 +68,7 @@ When task JSON contains implementation_approach array:
 ### 1. Context Assessment & Test Discovery
 - Analyze task context to identify test files and source code paths
 - Load test framework configuration (Jest, Pytest, Mocha, etc.)
+- **context-package.json** (CCW Workflow): Extract artifact paths using `jq -r '.brainstorm_artifacts.role_analyses[].files[].path'`
 - Identify test command from project configuration
 
 ```bash
@@ -212,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/agents/ui-design-agent.md

@@ -35,7 +35,7 @@ You are a specialized **UI Design Agent** that executes design generation tasks
 ### 2. Layout Strategy Generation
 
 **Invoked by**: `consolidate.md` Phase 2.5
-**Input**: Project context from synthesis-specification.md
+**Input**: Project context from role analysis documents
 **Task**: Research and generate adaptive layout strategies via Exa MCP (2024-2025 trends)
 
 **Output**: layout-strategies.json with strategy definitions and rationale

.claude/commands/cli/analyze.md

@@ -147,5 +147,4 @@ RULES: [auto-selected template] | Focus on [analysis aspect]
 ## Notes
 
 - Command templates, file patterns, and best practices: see intelligent-tools-strategy.md (loaded in memory)
-- Scratchpad directory details: see workflow-architecture.md
 - Scratchpad files can be promoted to workflow sessions if analysis proves valuable

.claude/commands/cli/chat.md

@@ -145,5 +145,4 @@ RULES: Focus on clarity and accuracy
 ## Notes
 
 - Command templates and file patterns: see intelligent-tools-strategy.md (loaded in memory)
-- Scratchpad directory details: see workflow-architecture.md
 - Scratchpad conversations preserved for future reference

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

@@ -32,7 +32,7 @@ Creates tool-specific configuration directories:
 - `.gemini/settings.json`:
 ```json
 {
-  "contextfilename": "CLAUDE.md"
+  "contextfilename": ["CLAUDE.md","GEMINI.md"]
 }
 ```
 
@@ -40,7 +40,7 @@ Creates tool-specific configuration directories:
 - `.qwen/settings.json`:
 ```json
 {
-  "contextfilename": "CLAUDE.md"
+  "contextfilename": ["CLAUDE.md","QWEN.md"]
 }
 ```
 

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

@@ -138,7 +138,7 @@ RULES: $(cat ~/.claude/prompt-templates/bug-fix.md) | Bug: token validation fail
 ```bash
 # 1. Find bug-related files
 rg "error_keyword" --files-with-matches
-mcp__code-index__search_code_advanced(pattern="error|exception", file_pattern="*.ts")
+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"
@@ -159,6 +159,5 @@ mcp__code-index__search_code_advanced(pattern="error|exception", file_pattern="*
 ## 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

@@ -141,7 +141,7 @@ RULES: $(cat ~/.claude/prompt-templates/code-analysis.md) | Focus on security
 ```bash
 # 1. Find entry points and related files
 rg "function.*authenticate|class.*AuthService" --files-with-matches
-mcp__code-index__search_code_advanced(pattern="authenticate|login", file_pattern="*.ts")
+rg "authenticate|login" -g "*.ts"
 
 # 2. Build call graph understanding
 # entry → middleware → service → repository
@@ -165,6 +165,5 @@ mcp__code-index__search_code_advanced(pattern="authenticate|login", file_pattern
 ## 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

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

@@ -139,7 +139,7 @@ RULES: $(cat ~/.claude/prompt-templates/plan.md) | Maintain backward compatibili
 ```bash
 # 1. Discover project structure
 ~/.claude/scripts/get_modules_by_depth.sh
-mcp__code-index__find_files(pattern="*.ts")
+find . -name "*.ts" -type f
 
 # 2. Gather existing architecture info
 rg "architecture|design" --files-with-matches
@@ -163,6 +163,5 @@ rg "architecture|design" --files-with-matches
 ## 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

.claude/commands/memory/docs.md

@@ -9,9 +9,10 @@ argument-hint: "[path] [--tool <gemini|qwen|codex>] [--mode <full|partial>] [--c
 ## Overview
 Lightweight planner that analyzes project structure, decomposes documentation work into tasks, and generates execution plans. Does NOT generate documentation content itself - delegates to doc-generator agent.
 
-**Documentation Output**: All generated documentation is placed in `.workflow/docs/` directory with **mirrored project structure**. For example:
-- Source: `src/modules/auth/index.ts` → Docs: `.workflow/docs/src/modules/auth/API.md`
-- Source: `lib/core/utils.js` → Docs: `.workflow/docs/lib/core/README.md`
+**Documentation Output**: All generated documentation is placed in `.workflow/docs/{project_name}/` directory with **mirrored project structure**. For example:
+- Project: `my_app`
+- Source: `my_app/src/core/` → Docs: `.workflow/docs/my_app/src/core/API.md`
+- Source: `my_app/src/modules/auth/` → Docs: `.workflow/docs/my_app/src/modules/auth/API.md`
 
 **Two Execution Modes**:
 - **Default**: CLI analyzes in `pre_analysis` (MODE=analysis), agent writes docs in `implementation_approach`
@@ -19,14 +20,13 @@ Lightweight planner that analyzes project structure, decomposes documentation wo
 
 ## Path Mirroring Strategy
 
-**Principle**: Documentation structure **mirrors** source code structure.
+**Principle**: Documentation structure **mirrors** source code structure under project-specific directory.
 
-| Source Path | Documentation Path |
-|------------|-------------------|
-| `src/modules/auth/index.ts` | `.workflow/docs/src/modules/auth/API.md` |
-| `src/modules/auth/middleware/` | `.workflow/docs/src/modules/auth/middleware/README.md` |
-| `lib/core/utils.js` | `.workflow/docs/lib/core/API.md` |
-| `lib/core/helpers/` | `.workflow/docs/lib/core/helpers/README.md` |
+| Source Path | Project Name | Documentation Path |
+|------------|--------------|-------------------|
+| `my_app/src/core/` | `my_app` | `.workflow/docs/my_app/src/core/API.md` |
+| `my_app/src/modules/auth/` | `my_app` | `.workflow/docs/my_app/src/modules/auth/API.md` |
+| `another_project/lib/utils/` | `another_project` | `.workflow/docs/another_project/lib/utils/API.md` |
 
 **Benefits**:
 - Easy to locate documentation for any source file
@@ -92,6 +92,9 @@ bash(
     target_path=$(cd "$path" 2>/dev/null && pwd || echo "$PWD/$path")
   fi
 
+  # Extract project name from target_path
+  project_name=$(basename "$target_path")
+
   # Create session
   timestamp=$(date +%Y%m%d-%H%M%S)
   session="WFS-docs-${timestamp}"
@@ -106,6 +109,7 @@ bash(
   "path": "${path}",
   "target_path": "${target_path}",
   "project_root": "${project_root}",
+  "project_name": "${project_name}",
   "mode": "${mode}",
   "tool": "${tool}",
   "cli_generate": ${cli_generate}
@@ -191,41 +195,48 @@ bash(jq '. + {analysis: {total: "15", code: "8", navigation: "7", top_level: "3"
 
 ### Phase 3: Detect Update Mode
 
-#### Step 1: Count Existing Documentation in .workflow/docs/
+#### Step 1: Count Existing Documentation in .workflow/docs/{project_name}/
 ```bash
-# Check .workflow/docs/ directory and count existing files
-bash(if [[ -d ".workflow/docs" ]]; then
-  find .workflow/docs -name "*.md" 2>/dev/null | wc -l
-else
-  echo "0"
-fi)
+# Check .workflow/docs/{project_name}/ directory and count existing files
+bash(
+  project_name=$(jq -r '.project_name' .workflow/WFS-docs-20240120/.process/config.json)
+  if [[ -d ".workflow/docs/${project_name}" ]]; then
+    find .workflow/docs/${project_name} -name "*.md" 2>/dev/null | wc -l
+  else
+    echo "0"
+  fi
+)
 ```
 
-**Output**: `5` (existing docs in .workflow/docs/)
+**Output**: `5` (existing docs in .workflow/docs/{project_name}/)
 
 #### Step 2: List Existing Documentation
 ```bash
-# List existing files in .workflow/docs/ (for task context)
-bash(if [[ -d ".workflow/docs" ]]; then
-  find .workflow/docs -name "*.md" 2>/dev/null > .workflow/WFS-docs-20240120/.process/existing-docs.txt
-else
-  touch .workflow/WFS-docs-20240120/.process/existing-docs.txt
-fi)
+# List existing files in .workflow/docs/{project_name}/ (for task context)
+bash(
+  project_name=$(jq -r '.project_name' .workflow/WFS-docs-20240120/.process/config.json)
+  if [[ -d ".workflow/docs/${project_name}" ]]; then
+    find .workflow/docs/${project_name} -name "*.md" 2>/dev/null > .workflow/WFS-docs-20240120/.process/existing-docs.txt
+  else
+    touch .workflow/WFS-docs-20240120/.process/existing-docs.txt
+  fi
+)
 ```
 
 **Output** (existing-docs.txt):
 ```
-.workflow/docs/src/modules/auth/API.md
-.workflow/docs/src/modules/auth/README.md
-.workflow/docs/lib/core/README.md
-.workflow/docs/README.md
+.workflow/docs/my_app/src/modules/auth/API.md
+.workflow/docs/my_app/src/modules/auth/README.md
+.workflow/docs/my_app/lib/core/README.md
+.workflow/docs/my_app/README.md
 ```
 
 #### Step 3: Update Config with Update Status
 ```bash
 # Determine update status (create or update) and update config
 bash(
-  existing_count=$(find .workflow/docs -name "*.md" 2>/dev/null | wc -l)
+  project_name=$(jq -r '.project_name' .workflow/WFS-docs-20240120/.process/config.json)
+  existing_count=$(find .workflow/docs/${project_name} -name "*.md" 2>/dev/null | wc -l)
   if [[ $existing_count -gt 0 ]]; then
     jq ". + {update_mode: \"update\", existing_docs: $existing_count}" .workflow/WFS-docs-20240120/.process/config.json > .workflow/WFS-docs-20240120/.process/config.json.tmp && mv .workflow/WFS-docs-20240120/.process/config.json.tmp .workflow/WFS-docs-20240120/.process/config.json
   else
@@ -353,7 +364,8 @@ bash(
   if [[ "$tool" == "codex" ]]; then
     echo "codex -C \${dir} --full-auto exec \"...\" --skip-git-repo-check -s danger-full-access"
   else
-    echo "bash(cd \${dir} && ~/.claude/scripts/${tool}-wrapper ${approval_flag} -p \"...\")"
+    echo "bash(cd \${dir} && ${tool} ${approval_flag} -p \"...\")"
+    # Direct CLI commands for gemini/qwen
   fi
 )
 ```
@@ -362,7 +374,10 @@ bash(
 
 ### Level 1: Module Tree Task
 
-**Path Mapping**: Source `src/modules/` → Output `.workflow/docs/src/modules/`
+**Path Mapping**:
+- Project: `{project_name}` (extracted from target_path)
+- Source: `{project_name}/src/modules/`
+- Output: `.workflow/docs/{project_name}/src/modules/`
 
 **Default Mode (cli_generate=false)**:
 ```json
@@ -376,12 +391,12 @@ bash(
     "tool": "gemini",
     "cli_generate": false,
     "source_path": "src/modules",
-    "output_path": ".workflow/docs/src/modules"
+    "output_path": ".workflow/docs/${project_name}/src/modules"
   },
   "context": {
     "requirements": [
       "Analyze source code in src/modules/",
-      "Generate docs to .workflow/docs/src/modules/ (mirrored structure)",
+      "Generate docs to .workflow/docs/${project_name}/src/modules/ (mirrored structure)",
       "For code folders: generate API.md + README.md",
       "For navigation folders: generate README.md only"
     ],
@@ -392,7 +407,7 @@ bash(
     "pre_analysis": [
       {
         "step": "load_existing_docs",
-        "command": "bash(find .workflow/docs/${top_dir} -name '*.md' 2>/dev/null | xargs cat || echo 'No existing docs')",
+        "command": "bash(find .workflow/docs/${project_name}/${top_dir} -name '*.md' 2>/dev/null | xargs cat || echo 'No existing docs')",
         "output_to": "existing_module_docs"
       },
       {
@@ -415,7 +430,7 @@ bash(
         "modification_points": [
           "Parse folder types from [target_folders]",
           "Parse structure from [tree_outline]",
-          "For src/modules/auth/ → write to .workflow/docs/src/modules/auth/",
+          "For src/modules/auth/ → write to .workflow/docs/${project_name}/src/modules/auth/",
           "Generate API.md for code folders",
           "Generate README.md for all folders"
         ],
@@ -423,7 +438,7 @@ bash(
           "Parse [target_folders] to get folder types",
           "Parse [tree_outline] for structure",
           "For each folder in source:",
-          "  - Map source_path to .workflow/docs/{source_path}",
+          "  - Map source_path to .workflow/docs/${project_name}/{source_path}",
           "  - If type == 'code': Generate API.md + README.md",
           "  - Elif type == 'navigation': Generate README.md only"
         ],
@@ -432,8 +447,8 @@ bash(
       }
     ],
     "target_files": [
-      ".workflow/docs/${top_dir}/*/API.md",
-      ".workflow/docs/${top_dir}/*/README.md"
+      ".workflow/docs/${project_name}/${top_dir}/*/API.md",
+      ".workflow/docs/${project_name}/${top_dir}/*/README.md"
     ]
   }
 }
@@ -451,12 +466,12 @@ bash(
     "tool": "gemini",
     "cli_generate": true,
     "source_path": "src/modules",
-    "output_path": ".workflow/docs/src/modules"
+    "output_path": ".workflow/docs/${project_name}/src/modules"
   },
   "context": {
     "requirements": [
       "Analyze source code in src/modules/",
-      "Generate docs to .workflow/docs/src/modules/ (mirrored structure)",
+      "Generate docs to .workflow/docs/${project_name}/src/modules/ (mirrored structure)",
       "CLI generates documentation files directly"
     ],
     "focus_paths": ["src/modules"]
@@ -465,7 +480,7 @@ bash(
     "pre_analysis": [
       {
         "step": "load_existing_docs",
-        "command": "bash(find .workflow/docs/${top_dir} -name '*.md' 2>/dev/null | xargs cat || echo 'No existing docs')",
+        "command": "bash(find .workflow/docs/${project_name}/${top_dir} -name '*.md' 2>/dev/null | xargs cat || echo 'No existing docs')",
         "output_to": "existing_module_docs"
       },
       {
@@ -490,22 +505,22 @@ bash(
         "description": "Call CLI to generate docs to .workflow/docs/ with mirrored structure using MODE=write",
         "modification_points": [
           "Execute CLI generation command",
-          "Generate files to .workflow/docs/src/modules/ (mirrored path)",
+          "Generate files to .workflow/docs/${project_name}/src/modules/ (mirrored path)",
           "Generate API.md and README.md files"
         ],
         "logic_flow": [
           "CLI analyzes source code in src/modules/",
-          "CLI writes documentation to .workflow/docs/src/modules/",
+          "CLI writes documentation to .workflow/docs/${project_name}/src/modules/",
           "Maintains directory structure mirroring"
         ],
-        "command": "bash(cd src/modules && gemini --approval-mode yolo \"PURPOSE: Generate module docs\\nTASK: Create documentation files in .workflow/docs/src/modules/\\nMODE: write\\nCONTEXT: @**/* [target_folders] [existing_module_docs]\\nEXPECTED: API.md and README.md in .workflow/docs/src/modules/\\nRULES: Mirror source structure, generate complete docs\")",
+        "command": "bash(cd src/modules && gemini --approval-mode yolo \"PURPOSE: Generate module docs\\nTASK: Create documentation files in .workflow/docs/${project_name}/src/modules/\\nMODE: write\\nCONTEXT: @**/* [target_folders] [existing_module_docs]\\nEXPECTED: API.md and README.md in .workflow/docs/${project_name}/src/modules/\\nRULES: Mirror source structure, generate complete docs\")",
         "depends_on": [1],
         "output": "generated_docs"
       }
     ],
     "target_files": [
-      ".workflow/docs/${top_dir}/*/API.md",
-      ".workflow/docs/${top_dir}/*/README.md"
+      ".workflow/docs/${project_name}/${top_dir}/*/API.md",
+      ".workflow/docs/${project_name}/${top_dir}/*/README.md"
     ]
   }
 }
@@ -530,12 +545,12 @@ bash(
     "pre_analysis": [
       {
         "step": "load_existing_readme",
-        "command": "bash(cat .workflow/docs/README.md 2>/dev/null || echo 'No existing README')",
+        "command": "bash(cat .workflow/docs/${project_name}/README.md 2>/dev/null || echo 'No existing README')",
         "output_to": "existing_readme"
       },
       {
         "step": "load_module_docs",
-        "command": "bash(find .workflow/docs -type f -name '*.md' ! -path '.workflow/docs/README.md' ! -path '.workflow/docs/ARCHITECTURE.md' ! -path '.workflow/docs/EXAMPLES.md' ! -path '.workflow/docs/api/*' | xargs cat)",
+        "command": "bash(find .workflow/docs/${project_name} -type f -name '*.md' ! -path '.workflow/docs/${project_name}/README.md' ! -path '.workflow/docs/${project_name}/ARCHITECTURE.md' ! -path '.workflow/docs/${project_name}/EXAMPLES.md' ! -path '.workflow/docs/${project_name}/api/*' | xargs cat)",
         "output_to": "all_module_docs",
         "note": "Load all module docs from mirrored structure"
       },
@@ -556,7 +571,7 @@ bash(
         "output": "project_readme"
       }
     ],
-    "target_files": [".workflow/docs/README.md"]
+    "target_files": [".workflow/docs/${project_name}/README.md"]
   }
 }
 ```
@@ -580,12 +595,12 @@ bash(
     "pre_analysis": [
       {
         "step": "load_existing_docs",
-        "command": "bash(cat .workflow/docs/ARCHITECTURE.md 2>/dev/null || echo 'No existing ARCHITECTURE'; echo '---SEPARATOR---'; cat .workflow/docs/EXAMPLES.md 2>/dev/null || echo 'No existing EXAMPLES')",
+        "command": "bash(cat .workflow/docs/${project_name}/ARCHITECTURE.md 2>/dev/null || echo 'No existing ARCHITECTURE'; echo '---SEPARATOR---'; cat .workflow/docs/${project_name}/EXAMPLES.md 2>/dev/null || echo 'No existing EXAMPLES')",
         "output_to": "existing_arch_examples"
       },
       {
         "step": "load_all_docs",
-        "command": "bash(cat .workflow/docs/README.md && find .workflow/docs -type f -name '*.md' ! -path '.workflow/docs/README.md' ! -path '.workflow/docs/ARCHITECTURE.md' ! -path '.workflow/docs/EXAMPLES.md' ! -path '.workflow/docs/api/*' | xargs cat)",
+        "command": "bash(cat .workflow/docs/${project_name}/README.md && find .workflow/docs/${project_name} -type f -name '*.md' ! -path '.workflow/docs/${project_name}/README.md' ! -path '.workflow/docs/${project_name}/ARCHITECTURE.md' ! -path '.workflow/docs/${project_name}/EXAMPLES.md' ! -path '.workflow/docs/${project_name}/api/*' | xargs cat)",
         "output_to": "all_docs",
         "note": "Load README + all module docs from mirrored structure"
       },
@@ -617,8 +632,8 @@ bash(
       }
     ],
     "target_files": [
-      ".workflow/docs/ARCHITECTURE.md",
-      ".workflow/docs/EXAMPLES.md"
+      ".workflow/docs/${project_name}/ARCHITECTURE.md",
+      ".workflow/docs/${project_name}/EXAMPLES.md"
     ]
   }
 }
@@ -643,12 +658,12 @@ bash(
     "pre_analysis": [
       {
         "step": "discover_api_endpoints",
-        "command": "mcp__code-index__search_code_advanced(pattern='router\\.|@(Get|Post)', file_pattern='*.{ts,js}')",
+        "command": "bash(rg 'router\\.| @(Get|Post)' -g '*.{ts,js}')",
         "output_to": "endpoint_discovery"
       },
       {
         "step": "load_existing_api_docs",
-        "command": "bash(cat .workflow/docs/api/README.md 2>/dev/null || echo 'No existing API docs')",
+        "command": "bash(cat .workflow/docs/${project_name}/api/README.md 2>/dev/null || echo 'No existing API docs')",
         "output_to": "existing_api_docs"
       },
       {
@@ -668,7 +683,7 @@ bash(
         "output": "api_docs"
       }
     ],
-    "target_files": [".workflow/docs/api/README.md"]
+    "target_files": [".workflow/docs/${project_name}/api/README.md"]
   }
 }
 ```
@@ -701,8 +716,9 @@ bash(
   "session_id": "WFS-docs-20240120-143022",
   "timestamp": "2024-01-20T14:30:22+08:00",
   "path": ".",
-  "target_path": "/d/Claude_dms3",
-  "project_root": "/d/Claude_dms3",
+  "target_path": "/home/user/projects/my_app",
+  "project_root": "/home/user/projects",
+  "project_name": "my_app",
   "mode": "full",
   "tool": "gemini",
   "cli_generate": false,
@@ -719,33 +735,34 @@ bash(
 
 ## Generated Documentation
 
-**Structure mirrors project source directories**:
+**Structure mirrors project source directories under project-specific folder**:
 
 ```
 .workflow/docs/
-├── src/                               # Mirrors src/ directory
-│   ├── modules/                       # Level 1 output
-│   │   ├── README.md                  # Navigation for src/modules/
-│   │   ├── auth/
-│   │   │   ├── API.md                 # Auth module API signatures
-│   │   │   ├── README.md              # Auth module documentation
-│   │   │   └── middleware/
-│   │   │       ├── API.md             # Middleware API
-│   │   │       └── README.md          # Middleware docs
-│   │   └── api/
-│   │       ├── API.md                 # API module signatures
-│   │       └── README.md              # API module docs
-│   └── utils/                         # Level 1 output
-│       └── README.md                  # Utils navigation
-├── lib/                               # Mirrors lib/ directory
-│   └── core/
-│       ├── API.md
-│       └── README.md
-├── README.md                          # Level 2 output (root only)
-├── ARCHITECTURE.md                    # Level 3 output (root only)
-├── EXAMPLES.md                        # Level 3 output (root only)
-└── api/                               # Level 3 output (optional)
-    └── README.md                      # HTTP API reference
+└── {project_name}/                    # Project-specific root (e.g., my_app/)
+    ├── src/                           # Mirrors src/ directory
+    │   ├── modules/                   # Level 1 output
+    │   │   ├── README.md              # Navigation for src/modules/
+    │   │   ├── auth/
+    │   │   │   ├── API.md             # Auth module API signatures
+    │   │   │   ├── README.md          # Auth module documentation
+    │   │   │   └── middleware/
+    │   │   │       ├── API.md         # Middleware API
+    │   │   │       └── README.md      # Middleware docs
+    │   │   └── api/
+    │   │       ├── API.md             # API module signatures
+    │   │       └── README.md          # API module docs
+    │   └── utils/                     # Level 1 output
+    │       └── README.md              # Utils navigation
+    ├── lib/                           # Mirrors lib/ directory
+    │   └── core/
+    │       ├── API.md
+    │       └── README.md
+    ├── README.md                      # Level 2 output (project root only)
+    ├── ARCHITECTURE.md                # Level 3 output (project root only)
+    ├── EXAMPLES.md                    # Level 3 output (project root only)
+    └── api/                           # Level 3 output (optional)
+        └── README.md                  # HTTP API reference
 ```
 
 ## Execution Commands
@@ -792,11 +809,11 @@ bash(ls .workflow/WFS-docs-20240120/.task/*.json)
 # Discover and classify folders (scans project source)
 bash(~/.claude/scripts/get_modules_by_depth.sh | ~/.claude/scripts/classify-folders.sh)
 
-# Count existing docs (in .workflow/docs/ directory)
-bash(if [[ -d ".workflow/docs" ]]; then find .workflow/docs -name "*.md" 2>/dev/null | wc -l; else echo "0"; fi)
+# Count existing docs (in .workflow/docs/{project_name}/ directory)
+bash(if [[ -d ".workflow/docs/${project_name}" ]]; then find .workflow/docs/${project_name} -name "*.md" 2>/dev/null | wc -l; else echo "0"; fi)
 
-# List existing documentation (in .workflow/docs/ directory)
-bash(if [[ -d ".workflow/docs" ]]; then find .workflow/docs -name "*.md" 2>/dev/null; fi)
+# List existing documentation (in .workflow/docs/{project_name}/ directory)
+bash(if [[ -d ".workflow/docs/${project_name}" ]]; then find .workflow/docs/${project_name} -name "*.md" 2>/dev/null; fi)
 ```
 
 ## Template Reference

.claude/commands/memory/load.md

@@ -12,10 +12,10 @@ examples:
 
 ## 1. Overview
 
-The `memory:load` command **delegates to a general-purpose agent** to analyze the project and return a structured "Core Content Pack". This pack is loaded into the main thread's memory, providing essential context for subsequent agent operations while minimizing token consumption.
+The `memory:load` command **delegates to a universal-executor agent** to analyze the project and return a structured "Core Content Pack". This pack is loaded into the main thread's memory, providing essential context for subsequent agent operations while minimizing token consumption.
 
 **Core Philosophy**:
-- **Agent-Driven**: Fully delegates execution to general-purpose agent
+- **Agent-Driven**: Fully delegates execution to universal-executor agent
 - **Read-Only Analysis**: Does not modify code, only extracts context
 - **Structured Output**: Returns standardized JSON content package
 - **Memory Optimization**: Package loaded directly into main thread memory
@@ -34,7 +34,7 @@ The `memory:load` command **delegates to a general-purpose agent** to analyze th
 
 ## 3. Agent-Driven Execution Flow
 
-The command fully delegates to **general-purpose agent**, which autonomously:
+The command fully delegates to **universal-executor agent**, which autonomously:
 
 1. **Analyzes Project Structure**: Executes `get_modules_by_depth.sh` to understand architecture
 2. **Loads Documentation**: Reads CLAUDE.md, README.md and other key docs
@@ -94,14 +94,14 @@ The command fully delegates to **general-purpose agent**, which autonomously:
 
 ```javascript
 Task(
-  subagent_type="general-purpose",
+  subagent_type="universal-executor",
   description="Load project memory: ${task_description}",
   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
 
@@ -121,14 +121,14 @@ Task(
 ### Step 2: Keyword Extraction & File Discovery
 
 1. Extract core keywords from task description
-2. Discover relevant files using MCP code-index or rg:
-   \`\`\`javascript
-   // Prefer MCP tools
-   mcp__code-index__find_files(pattern="*{keyword}*")
-   mcp__code-index__search_code_advanced(pattern="{keyword}", context_lines=2)
+2. Discover relevant files using ripgrep and find:
+   \`\`\`bash
+   # Find files by name
+   find . -name "*{keyword}*" -type f
 
-   // Fallback: use rg
-   bash(rg -l "{keyword}" --type ts --type md)
+   # Search content with ripgrep
+   rg "{keyword}" --type ts --type md -C 2
+   rg -l "{keyword}" --type ts --type md  # List files only
    \`\`\`
 
 ### Step 3: Deep Analysis via CLI
@@ -136,7 +136,7 @@ Task(
 Execute Gemini/Qwen CLI for deep analysis (saves main thread tokens):
 
 \`\`\`bash
-cd . && ~/.claude/scripts/${tool}-wrapper -p "
+cd . && ${tool} -p "
 PURPOSE: Extract project core context for task: ${task_description}
 TASK: Analyze project architecture, tech stack, key patterns, relevant files
 MODE: analysis

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

@@ -153,6 +153,10 @@ Update Plan:
   - Layer 3 (depth ≥3): @**/* (all files)
   - Layer 2 (depth 1-2): @*/CLAUDE.md + current code files
   - Layer 1 (depth 0): @*/CLAUDE.md + current code files
+  
+  Auto-skipped: ./tests, __pycache__, setup.py (15 paths)
+  Execution order: Layer 2 → Layer 1
+  Estimated time: ~5-10 minutes
 
   Agent allocation (by LAYER):
   - Layer 3 (14 modules, depth ≥3): 4 agents [4, 4, 4, 2]
@@ -246,7 +250,7 @@ TOOLS (try in order): {{tool_1}}, {{tool_2}}, {{tool_3}}
 
 EXECUTION SCRIPT: ~/.claude/scripts/update_module_claude.sh
   - Accepts strategy parameter: multi-layer | single-layer
-  - Tool execution via CLI wrapper (gemini/qwen/codex)
+  - Tool execution via direct CLI commands (gemini/qwen/codex)
 
 EXECUTION FLOW (for each module):
   1. Tool fallback loop (exit on first success):

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

@@ -40,10 +40,7 @@ Orchestrates context-aware CLAUDE.md updates for changed modules using batched a
 ## Phase 1: Change Detection & Analysis
 
 ```bash
-# Refresh code index
-bash(mcp__code-index__refresh_index)
-
-# Detect changed modules
+# Detect changed modules (no index refresh needed)
 bash(~/.claude/scripts/detect_changed_modules.sh list)
 
 # Cache git changes

.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)
 
@@ -99,7 +98,7 @@ Files updated: .task/IMPL-1.json + 2 subtask files + TODO_LIST.md
 - **Implementation** → `@code-developer`
 - **Testing** → `@code-developer` (type: "test-gen")
 - **Test Validation** → `@test-fix-agent` (type: "test-fix")
-- **Review** → `@general-purpose` (optional)
+- **Review** → `@universal-executor` (optional)
 
 ### Context Inheritance
 - Subtasks inherit parent requirements
@@ -138,7 +137,6 @@ Files updated: .task/IMPL-1.json + 2 subtask files + TODO_LIST.md
 
 ## Implementation Details
 
-See @~/.claude/workflows/workflow-architecture.md for:
 - Complete task JSON schema
 - Implementation field structure
 - Context inheritance rules

.claude/commands/task/create.md

@@ -104,7 +104,7 @@ Based on task type and title keywords:
 - **Design/Plan** → @planning-agent
 - **Test Generation** → @code-developer (type: "test-gen")
 - **Test Execution/Fix** → @test-fix-agent (type: "test-fix")
-- **Review/Audit** → @general-purpose (optional, only when explicitly requested)
+- **Review/Audit** → @universal-executor (optional, only when explicitly requested)
 
 ## Validation Rules
 

.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**
 
@@ -19,7 +19,7 @@ argument-hint: "task-id"
     -   Executes step-by-step, requiring user confirmation at each checkpoint.
     -   Allows for dynamic adjustments and manual review during the process.
 -   **review**
-    -   Optional manual review using `@general-purpose`.
+    -   Optional manual review using `@universal-executor`.
     -   Used only when explicitly requested by user.
 
 ### 🤖 **Agent Selection Logic**
@@ -45,7 +45,7 @@ FUNCTION select_agent(task, agent_override):
             WHEN CONTAINS "Execute tests", "Fix tests", "Validate":
                 RETURN "@test-fix-agent" // type: test-fix
             WHEN CONTAINS "Review code":
-                RETURN "@general-purpose" // Optional manual review
+                RETURN "@universal-executor" // Optional manual review
             DEFAULT:
                 RETURN "@code-developer" // Default agent
         END CASE
@@ -236,7 +236,7 @@ Different agents receive context tailored to their function, including implement
 - Error conditions to validate from implementation.context_notes.error_handling
 - Performance requirements from implementation.context_notes.performance_considerations
 
-**`@general-purpose`**:
+**`@universal-executor`**:
 - Used for optional manual reviews when explicitly requested
 - Code quality standards and implementation patterns
 - Security considerations from implementation.context_notes.risks

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

@@ -15,13 +15,13 @@ You **MUST** consider the user input before proceeding (if not empty).
 
 ## Goal
 
-Identify inconsistencies, duplications, ambiguities, and underspecified items between action planning artifacts (`IMPL_PLAN.md`, `task.json`) and brainstorming artifacts (`synthesis-specification.md`) before implementation. This command MUST run only after `/workflow:plan` has successfully produced complete `IMPL_PLAN.md` and task JSON files.
+Identify inconsistencies, duplications, ambiguities, and underspecified items between action planning artifacts (`IMPL_PLAN.md`, `task.json`) and brainstorming artifacts (`role analysis documents`) before implementation. This command MUST run only after `/workflow:plan` has successfully produced complete `IMPL_PLAN.md` and task JSON files.
 
 ## Operating Constraints
 
 **STRICTLY READ-ONLY**: Do **not** modify any files. Output a structured analysis report. Offer an optional remediation plan (user must explicitly approve before any follow-up editing commands).
 
-**Synthesis Authority**: The `synthesis-specification.md` is **authoritative** for requirements and design decisions. Any conflicts between IMPL_PLAN/tasks and synthesis are automatically CRITICAL and require adjustment of the plan/tasks—not reinterpretation of requirements.
+**Synthesis Authority**: The `role analysis documents` is **authoritative** for requirements and design decisions. Any conflicts between IMPL_PLAN/tasks and synthesis are automatically CRITICAL and require adjustment of the plan/tasks—not reinterpretation of requirements.
 
 ## Execution Steps
 
@@ -45,13 +45,13 @@ brainstorm_dir = session_dir/.brainstorming
 task_dir = session_dir/.task
 
 # Validate required artifacts
-SYNTHESIS = brainstorm_dir/synthesis-specification.md
+SYNTHESIS = brainstorm_dir/role analysis documents
 IMPL_PLAN = session_dir/IMPL_PLAN.md
 TASK_FILES = Glob(task_dir/*.json)
 
 # Abort if missing
 IF NOT EXISTS(SYNTHESIS):
-    ERROR: "synthesis-specification.md not found. Run /workflow:brainstorm:synthesis first"
+    ERROR: "role analysis documents not found. Run /workflow:brainstorm:synthesis first"
     EXIT
 
 IF NOT EXISTS(IMPL_PLAN):
@@ -72,7 +72,7 @@ Load only minimal necessary context from each artifact:
 - User's stated goals and objectives
 - User's scope definition
 
-**From synthesis-specification.md**:
+**From role analysis documents**:
 - Functional Requirements (IDs, descriptions, acceptance criteria)
 - Non-Functional Requirements (IDs, targets)
 - Business Requirements (IDs, success metrics)
@@ -210,7 +210,7 @@ Output a Markdown report (no file writes) with the following structure:
 
 **Session**: WFS-{session-id}
 **Generated**: {timestamp}
-**Artifacts Analyzed**: synthesis-specification.md, IMPL_PLAN.md, {N} task files
+**Artifacts Analyzed**: role analysis documents, IMPL_PLAN.md, {N} task files
 
 ---
 
@@ -324,44 +324,40 @@ Output a Markdown report (no file writes) with the following structure:
 
 **If CRITICAL Issues Exist**:
 - ❌ **BLOCK EXECUTION** - Resolve critical issues before proceeding
-- Use `/task:create` for missing requirements coverage
+- Use TodoWrite to track all required fixes
 - Fix broken dependencies and circular references
 
 **If Only HIGH/MEDIUM/LOW Issues**:
 - ⚠️ **PROCEED WITH CAUTION** - Fix high-priority issues first
-- Use batch replan mode to apply all task improvements systematically
+- Use TodoWrite to systematically track and complete all improvements
 
-#### Batch Remediation
+#### TodoWrite-Based Remediation Workflow
 
 **Report Location**: `.workflow/WFS-{session}/.process/ACTION_PLAN_VERIFICATION.md`
 
-**Apply All Task Improvements** (Recommended):
-```bash
-# Batch process all task replan recommendations
-/task:replan --batch .workflow/WFS-{session}/.process/ACTION_PLAN_VERIFICATION.md
+**Recommended Workflow**:
+1. **Create TodoWrite Task List**: Extract all findings from report
+2. **Process by Priority**: CRITICAL → HIGH → MEDIUM → LOW
+3. **Complete Each Fix**: Mark tasks as in_progress/completed as you work
+4. **Validate Changes**: Verify each modification against requirements
 
-# Or with auto-confirmation (no prompts)
-/task:replan --batch ACTION_PLAN_VERIFICATION.md --auto-confirm
-```
-
-**Manual Selective Fixes**:
-```bash
-# Fix critical coverage gaps first
-/task:create "Implement user authentication (FR-03)"
-/task:create "Add performance optimization (NFR-01)"
-
-# Then apply task refinements individually
-/task:replan IMPL-1.2 "Add context.artifacts and target_files"
+**TodoWrite Task Structure Example**:
+```markdown
+Priority Order:
+1. Fix coverage gaps (CRITICAL)
+2. Resolve consistency conflicts (CRITICAL/HIGH)
+3. Add missing specifications (MEDIUM)
+4. Improve task quality (LOW)
 ```
 
 **Notes**:
-- Batch mode extracts all `/task:replan` commands from report
-- Processes by priority: CRITICAL → HIGH → MEDIUM → LOW
-- Creates TodoWrite tracking for all modifications
+- TodoWrite provides real-time progress tracking
+- Each finding becomes a trackable todo item
+- User can monitor progress throughout remediation
 - Architecture drift in IMPL_PLAN requires manual editing
 ```
 
-### 7. Save Report and Provide Remediation Options
+### 7. Save Report and Execute TodoWrite-Based Remediation
 
 **Save Analysis Report**:
 ```bash
@@ -369,14 +365,53 @@ report_path = ".workflow/WFS-{session}/.process/ACTION_PLAN_VERIFICATION.md"
 Write(report_path, full_report_content)
 ```
 
-At end of report, provide batch remediation guidance:
+**After Report Generation**:
+
+1. **Extract Findings**: Parse all issues by severity
+2. **Create TodoWrite Task List**: Convert findings to actionable todos
+3. **Execute Fixes**: Process each todo systematically
+4. **Update Task Files**: Apply modifications directly to task JSON files
+5. **Update IMPL_PLAN**: Apply strategic changes if needed
+
+At end of report, provide remediation guidance:
 
 ```markdown
-### 🔧 Remediation Options
+### 🔧 Remediation Workflow
 
-**Recommended Workflow**:
-1. **TodoWrite Tracking**: Create task list for all fixes
-2. **Agent-Based Fixes**: Call action-planning-agent to regenerate task files
-3. **User Confirmation**: Wait for approval before executing fixes
+**Recommended Approach**:
+1. **Initialize TodoWrite**: Create comprehensive task list from all findings
+2. **Process by Severity**: Start with CRITICAL, then HIGH, MEDIUM, LOW
+3. **Apply Fixes Directly**: Modify task.json files and IMPL_PLAN.md as needed
+4. **Track Progress**: Mark todos as completed after each fix
 
-**Note**: All fixes require explicit user confirmation.
+**TodoWrite Execution Pattern**:
+```bash
+# Step 1: Create task list from verification report
+TodoWrite([
+  { content: "Fix FR-03 coverage gap - add authentication task", status: "pending", activeForm: "Fixing FR-03 coverage gap" },
+  { content: "Fix IMPL-1.2 consistency - align with ADR-02", status: "pending", activeForm: "Fixing IMPL-1.2 consistency" },
+  { content: "Add context.artifacts to IMPL-1.2", status: "pending", activeForm: "Adding context.artifacts to IMPL-1.2" },
+  # ... additional todos for each finding
+])
+
+# Step 2: Process each todo systematically
+# Mark as in_progress when starting
+# Apply fix using Read/Edit tools
+# Mark as completed when done
+# Move to next priority item
+```
+
+**File Modification Workflow**:
+```bash
+# For task JSON modifications:
+1. Read(.workflow/WFS-{session}/.task/IMPL-X.Y.json)
+2. Edit() to apply fixes
+3. Mark todo as completed
+
+# For IMPL_PLAN modifications:
+1. Read(.workflow/WFS-{session}/IMPL_PLAN.md)
+2. Edit() to apply strategic changes
+3. Mark todo as completed
+```
+
+**Note**: All fixes execute immediately after user confirmation without additional commands.

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

@@ -1,6 +1,6 @@
 ---
 name: api-designer
-description: Generate or update api-designer/analysis.md addressing topic-framework discussion points
+description: Generate or update api-designer/analysis.md addressing guidance-specification discussion points
 argument-hint: "optional topic - uses existing framework if available"
 allowed-tools: Task(conceptual-planning-agent), TodoWrite(*), Read(*), Write(*)
 ---
@@ -8,10 +8,10 @@ allowed-tools: Task(conceptual-planning-agent), TodoWrite(*), Read(*), Write(*)
 ## 🔌 **API Designer Analysis Generator**
 
 ### Purpose
-**Specialized command for generating api-designer/analysis.md** that addresses topic-framework.md discussion points from backend API design perspective. Creates or updates role-specific analysis with framework references.
+**Specialized command for generating api-designer/analysis.md** that addresses guidance-specification.md discussion points from backend API design perspective. Creates or updates role-specific analysis with framework references.
 
 ### Core Function
-- **Framework-based Analysis**: Address each discussion point in topic-framework.md
+- **Framework-based Analysis**: Address each discussion point in guidance-specification.md
 - **API Design Focus**: RESTful/GraphQL API design, endpoint structure, and contract definition
 - **Update Mechanism**: Create new or update existing analysis.md
 - **Agent Delegation**: Use conceptual-planning-agent for analysis generation
@@ -51,7 +51,7 @@ IF active_session EXISTS:
     session_id = get_active_session()
     brainstorm_dir = .workflow/WFS-{session}/.brainstorming/
 
-    CHECK: brainstorm_dir/topic-framework.md
+    CHECK: brainstorm_dir/guidance-specification.md
     IF EXISTS:
         framework_mode = true
         load_framework = true
@@ -78,20 +78,20 @@ ELSE:
 ```
 
 ### Phase 3: Agent Task Generation
-**Framework-Based Analysis** (when topic-framework.md exists):
+**Framework-Based Analysis** (when guidance-specification.md exists):
 ```bash
 Task(subagent_type="conceptual-planning-agent",
      prompt="Generate API designer analysis addressing topic framework
 
      ## Framework Integration Required
-     **MANDATORY**: Load and address topic-framework.md discussion points
-     **Framework Reference**: @{session.brainstorm_dir}/topic-framework.md
+     **MANDATORY**: Load and address guidance-specification.md discussion points
+     **Framework Reference**: @{session.brainstorm_dir}/guidance-specification.md
      **Output Location**: {session.brainstorm_dir}/api-designer/analysis.md
 
      ## Analysis Requirements
-     1. **Load Topic Framework**: Read topic-framework.md completely
+     1. **Load Topic Framework**: Read guidance-specification.md completely
      2. **Address Each Discussion Point**: Respond to all 5 framework sections from API design perspective
-     3. **Include Framework Reference**: Start analysis.md with @../topic-framework.md
+     3. **Include Framework Reference**: Start analysis.md with @../guidance-specification.md
      4. **API Design Focus**: Emphasize endpoint structure, data contracts, versioning strategies
      5. **Structured Response**: Use framework structure for analysis organization
 
@@ -106,7 +106,7 @@ Task(subagent_type="conceptual-planning-agent",
      ```markdown
      # API Designer Analysis: [Topic]
 
-     **Framework Reference**: @../topic-framework.md
+     **Framework Reference**: @../guidance-specification.md
      **Role Focus**: Backend API Design and Contract Definition
 
      ## Core Requirements Analysis
@@ -140,14 +140,14 @@ IF update_mode = "incremental":
 
          ## Current Analysis Context
          **Existing Analysis**: @{session.brainstorm_dir}/api-designer/analysis.md
-         **Framework Reference**: @{session.brainstorm_dir}/topic-framework.md
+         **Framework Reference**: @{session.brainstorm_dir}/guidance-specification.md
 
          ## Update Requirements
          1. **Preserve Structure**: Maintain existing analysis structure
          2. **Add New Insights**: Integrate new API design insights and recommendations
          3. **Framework Alignment**: Ensure continued alignment with topic framework
          4. **API Updates**: Add new endpoint patterns, versioning strategies, documentation improvements
-         5. **Maintain References**: Keep @../topic-framework.md reference
+         5. **Maintain References**: Keep @../guidance-specification.md reference
 
          ## Update Instructions
          - Read existing analysis completely
@@ -163,14 +163,14 @@ IF update_mode = "incremental":
 ### Output Files
 ```
 .workflow/WFS-[topic]/.brainstorming/
-├── topic-framework.md          # Input: Framework (if exists)
+├── guidance-specification.md          # Input: Framework (if exists)
 └── api-designer/
     └── analysis.md            # ★ OUTPUT: Framework-based analysis
 ```
 
 ### Analysis Structure
 **Required Elements**:
-- **Framework Reference**: @../topic-framework.md (if framework exists)
+- **Framework Reference**: @../guidance-specification.md (if framework exists)
 - **Role Focus**: Backend API Design and Contract Definition perspective
 - **5 Framework Sections**: Address each framework discussion point
 - **API Design Recommendations**: Endpoint-specific insights and solutions

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

@@ -1,373 +1,605 @@
 ---
 name: artifacts
-description: Generate role-specific topic-framework.md dynamically based on selected roles
-argument-hint: "topic or challenge description for framework generation"
-allowed-tools: TodoWrite(*), Read(*), Write(*), Bash(*), Glob(*)
+description: Interactive clarification generating confirmed guidance specification
+argument-hint: "topic or challenge description [--count N]"
+allowed-tools: TodoWrite(*), Read(*), Write(*), Glob(*)
 ---
 
-# Topic Framework Generator Command
+## Overview
 
-## Usage
-```bash
-/workflow:brainstorm:artifacts "<topic>" [--roles "role1,role2,role3"]
+Six-phase workflow: **Automatic project context collection** → Extract topic challenges → Select roles → Generate task-specific questions → Detect conflicts → Generate confirmed guidance (declarative statements only).
+
+**Input**: `"GOAL: [objective] SCOPE: [boundaries] CONTEXT: [background]" [--count N]`
+**Output**: `.workflow/WFS-{topic}/.brainstorming/guidance-specification.md` (CONFIRMED/SELECTED format)
+**Core Principle**: Questions dynamically generated from project context + topic keywords/challenges, NOT from generic templates
+
+**Parameters**:
+- `topic` (required): Topic or challenge description (structured format recommended)
+- `--count N` (optional): Number of roles user WANTS to select (system will recommend N+2 options for user to choose from, default: 3)
+
+## Task Tracking
+
+**⚠️ TodoWrite Rule**: EXTEND auto-parallel's task list (NOT replace/overwrite)
+
+**When called from auto-parallel**:
+- Find the artifacts parent task: "Execute artifacts command for interactive framework generation"
+- Mark parent task as "in_progress"
+- APPEND artifacts sub-tasks AFTER the parent task (Phase 0-5)
+- Mark each sub-task as it completes
+- When Phase 5 completes, mark parent task as "completed"
+- **PRESERVE all other auto-parallel tasks** (role agents, synthesis)
+
+**Standalone Mode**:
+```json
+[
+  {"content": "Initialize session (.workflow/.active-* check, parse --count parameter)", "status": "pending", "activeForm": "Initializing"},
+  {"content": "Phase 0: Automatic project context collection (call context-gather)", "status": "pending", "activeForm": "Phase 0 context collection"},
+  {"content": "Phase 1: Extract challenges, output 2-4 task-specific questions, wait for user input", "status": "pending", "activeForm": "Phase 1 topic analysis"},
+  {"content": "Phase 2: Recommend count+2 roles, output role selection, wait for user input", "status": "pending", "activeForm": "Phase 2 role selection"},
+  {"content": "Phase 3: Generate 3-4 questions per role, output and wait for answers (max 10 per round)", "status": "pending", "activeForm": "Phase 3 role questions"},
+  {"content": "Phase 4: Detect conflicts, output clarifications, wait for answers (max 10 per round)", "status": "pending", "activeForm": "Phase 4 conflict resolution"},
+  {"content": "Phase 5: Transform Q&A to declarative statements, write guidance-specification.md", "status": "pending", "activeForm": "Phase 5 document generation"}
+]
 ```
 
-**Recommended Structured Format**:
-```bash
-/workflow:brainstorm:artifacts "GOAL: [objective] SCOPE: [boundaries] CONTEXT: [background]" [--roles "..."]
-```
+## User Interaction Protocol
 
-## Purpose
-**Generate dynamic topic-framework.md tailored to selected roles**. Creates role-specific discussion frameworks that address relevant perspectives. If no roles specified, generates comprehensive framework covering common analysis areas.
+### Question Output Format
 
-**⚠️ User Intent Preservation**: Topic description is stored in session metadata and serves as authoritative reference throughout workflow lifecycle.
+All questions output as structured text (detailed format with descriptions):
 
-## Role-Based Framework Generation
-
-**Dynamic Generation**: Framework content adapts based on selected roles
-- **With roles**: Generate targeted discussion points for specified roles only
-- **Without roles**: Generate comprehensive framework covering all common areas
-
-## Core Workflow
-
-### Topic Framework Generation Process
-
-**Phase 1: Session Management** ⚠️ FIRST STEP
-- **Active session detection**: Check `.workflow/.active-*` markers
-- **Session selection**: Prompt user if multiple active sessions found
-- **Auto-creation**: Create `WFS-[topic-slug]` only if no active session exists
-- **Framework check**: Check if `topic-framework.md` exists (update vs create mode)
-
-**Phase 2: Role Analysis** ⚠️ NEW
-- **Parse roles parameter**: Extract roles from `--roles "role1,role2,role3"` if provided
-- **Role validation**: Verify each role is valid (matches available role commands)
-- **Store role list**: Save selected roles to session metadata for reference
-- **Default behavior**: If no roles specified, use comprehensive coverage
-
-**Phase 3: Dynamic Topic Analysis**
-- **Scope definition**: Define topic boundaries and objectives
-- **Stakeholder identification**: Identify key users and stakeholders based on selected roles
-- **Requirements gathering**: Extract requirements relevant to selected roles
-- **Context collection**: Gather context appropriate for role perspectives
-
-**Phase 4: Role-Specific Framework Generation**
-- **Discussion points creation**: Generate 3-5 discussion areas **tailored to selected roles**
-- **Role-targeted questions**: Create questions specifically for chosen roles
-- **Framework document**: Generate `topic-framework.md` with role-specific sections
-- **Validation check**: Ensure framework addresses all selected role perspectives
-
-**Phase 5: Metadata Storage**
-- **Save role assignment**: Store selected roles in session metadata
-- **Framework versioning**: Track which roles framework addresses
-- **Update tracking**: Maintain role evolution if framework updated
-
-## Implementation Standards
-
-### Discussion-Driven Analysis
-**Interactive Approach**: Direct conversation and exploration without predefined role constraints
-
-**Process Flow**:
-1. **Topic introduction**: Understanding scope and context
-2. **Exploratory questioning**: Open-ended investigation
-3. **Component identification**: Breaking down into manageable pieces
-4. **Relationship analysis**: Understanding connections and dependencies
-5. **Documentation generation**: Structured capture of insights
-
-**Key Areas of Investigation**:
-- **Functional aspects**: What the topic needs to accomplish
-- **Technical considerations**: Implementation constraints and requirements
-- **User perspectives**: How different stakeholders are affected
-- **Business implications**: Cost, timeline, and strategic considerations
-- **Risk assessment**: Potential challenges and mitigation strategies
-
-### Document Generation Standards
-
-**Always Created**:
-- **discussion-summary.md**: Main conversation points and key insights
-- **component-analysis.md**: Detailed breakdown of topic components
-
-## Document Generation
-
-**Primary Output**: Single structured `topic-framework.md` document
-
-**Document Structure**:
-```
-.workflow/WFS-[topic]/.brainstorming/
-└── topic-framework.md          # ★ STRUCTURED FRAMEWORK DOCUMENT
-```
-
-**Note**: `workflow-session.json` is located at `.workflow/WFS-[topic]/workflow-session.json` (session root), not inside `.brainstorming/`.
-
-## Framework Template Structures
-
-### Dynamic Role-Based Framework
-
-Framework content adapts based on `--roles` parameter:
-
-#### Option 1: Specific Roles Provided
 ```markdown
-# [Topic] - Discussion Framework
+【问题{N} - {短标签}】{问题文本}
+a) {选项标签}
+   说明：{选项说明和影响}
+b) {选项标签}
+   说明：{选项说明和影响}
+c) {选项标签}
+   说明：{选项说明和影响}
 
-## Topic Overview
-- **Scope**: [Topic boundaries relevant to selected roles]
-- **Objectives**: [Goals from perspective of selected roles]
-- **Context**: [Background focusing on role-specific concerns]
-- **Target Roles**: ui-designer, system-architect, subject-matter-expert
-
-## Role-Specific Discussion Points
-
-### For UI Designer
-1. **User Interface Requirements**
-   - What interface components are needed?
-   - What user interactions must be supported?
-   - What visual design considerations apply?
-
-2. **User Experience Challenges**
-   - What are the key user journeys?
-   - What accessibility requirements exist?
-   - How to balance aesthetics with functionality?
-
-### For System Architect
-1. **Architecture Decisions**
-   - What architectural patterns fit this solution?
-   - What scalability requirements exist?
-   - How does this integrate with existing systems?
-
-2. **Technical Implementation**
-   - What technology stack is appropriate?
-   - What are the performance requirements?
-   - What dependencies must be managed?
-
-### For Subject Matter Expert
-1. **Domain Expertise & Standards**
-   - What industry standards and best practices apply?
-   - What regulatory compliance requirements exist?
-   - What domain-specific patterns should be followed?
-
-2. **Technical Quality & Risk**
-   - What technical debt considerations exist?
-   - What scalability and maintenance implications apply?
-   - What knowledge transfer and documentation is needed?
-
-## Cross-Role Integration Points
-- How do UI decisions impact architecture?
-- How does architecture constrain UI possibilities?
-- What domain standards affect both UI and architecture?
-
-## Framework Usage
-**For Role Agents**: Address your specific section + integration points
-**Reference Format**: @../topic-framework.md in your analysis.md
-**Update Process**: Use /workflow:brainstorm:artifacts to update
-
----
-*Generated for roles: ui-designer, system-architect, subject-matter-expert*
-*Last updated: [timestamp]*
+请回答：{N}a 或 {N}b 或 {N}c
 ```
 
-#### Option 2: No Roles Specified (Comprehensive)
+**Multi-select format** (Phase 2 role selection):
 ```markdown
-# [Topic] - Discussion Framework
+【角色选择】请选择 {count} 个角色参与头脑风暴分析
 
-## Topic Overview
-- **Scope**: [Comprehensive topic boundaries]
-- **Objectives**: [All-encompassing goals]
-- **Context**: [Full background and constraints]
-- **Stakeholders**: [All relevant parties]
+a) {role-name} ({中文名})
+   推荐理由：{基于topic的相关性说明}
+b) {role-name} ({中文名})
+   推荐理由：{基于topic的相关性说明}
+...
 
-## Core Discussion Areas
+支持格式：
+- 分别选择：2a 2c 2d (选择第2题的a、c、d选项)
+- 合并语法：2acd (选择a、c、d)
+- 逗号分隔：2a,c,d
 
-### 1. Requirements & Objectives
-- What are the fundamental requirements?
-- What are the critical success factors?
-- What constraints must be considered?
-
-### 2. Technical & Architecture
-- What are the technical challenges?
-- What architectural decisions are needed?
-- What integration points exist?
-
-### 3. User Experience & Design
-- Who are the primary users?
-- What are the key user journeys?
-- What usability requirements exist?
-
-### 4. Security & Compliance
-- What security requirements exist?
-- What compliance considerations apply?
-- What data protection is needed?
-
-### 5. Implementation & Operations
-- What are the implementation risks?
-- What resources are required?
-- How will this be maintained?
-
-## Available Role Perspectives
-Framework supports analysis from any of these roles:
-- **Technical**: system-architect, data-architect, subject-matter-expert
-- **Product & Design**: ui-designer, ux-expert, product-manager, product-owner
-- **Agile & Quality**: scrum-master, test-strategist
-
----
-*Comprehensive framework - adaptable to any role*
-*Last updated: [timestamp]*
+请输入选择：
 ```
 
-## Role-Specific Content Generation
+### Input Parsing Rules
 
-### Available Roles and Their Focus Areas
+**Supported formats** (intelligent parsing):
 
-**Technical Roles**:
-- `system-architect`: Architecture patterns, scalability, technology stack, integration
-- `data-architect`: Data modeling, processing workflows, analytics, storage
-- `subject-matter-expert`: Domain expertise, industry standards, compliance, best practices
+1. **Space-separated**: `1a 2b 3c` → Q1:a, Q2:b, Q3:c
+2. **Comma-separated**: `1a,2b,3c` → Q1:a, Q2:b, Q3:c
+3. **Multi-select combined**: `2abc` → Q2: options a,b,c
+4. **Multi-select spaces**: `2 a b c` → Q2: options a,b,c
+5. **Multi-select comma**: `2a,b,c` → Q2: options a,b,c
+6. **Natural language**: `问题1选a` → 1a (fallback parsing)
 
-**Product & Design Roles**:
-- `ui-designer`: User interface, visual design, interaction patterns, accessibility
-- `ux-expert`: User experience optimization, usability testing, interaction design, design systems
-- `product-manager`: Business value, feature prioritization, market positioning, roadmap
-- `product-owner`: Backlog management, user stories, acceptance criteria, stakeholder alignment
+**Parsing algorithm**:
+- Extract question numbers and option letters
+- Validate question numbers match output
+- Validate option letters exist for each question
+- If ambiguous/invalid, output example format and request re-input
 
-**Agile & Quality Roles**:
-- `scrum-master`: Sprint planning, team dynamics, process optimization, delivery management
-- `test-strategist`: Testing strategies, quality assurance, test automation, validation approaches
+**Error handling** (lenient):
+- Recognize common variations automatically
+- If parsing fails, show example and wait for clarification
+- Support re-input without penalty
 
-### Dynamic Discussion Point Generation
+### Batching Strategy
 
-**For each selected role, generate**:
-1. **2-3 core discussion areas** specific to that role's perspective
-2. **3-5 targeted questions** per discussion area
-3. **Cross-role integration points** showing how roles interact
+**Batch limits**:
+- **Default**: Maximum 10 questions per round
+- **Phase 2 (role selection)**: Display all recommended roles at once (count+2 roles)
+- **Auto-split**: If questions > 10, split into multiple rounds with clear round indicators
 
-**Example mapping**:
+**Round indicators**:
+```markdown
+===== 第 1 轮问题 (共2轮) =====
+【问题1 - ...】...
+【问题2 - ...】...
+...
+【问题10 - ...】...
+
+请回答 (格式: 1a 2b ... 10c)：
+```
+
+### Interaction Flow
+
+**Standard flow**:
+1. Output questions in formatted text
+2. Output expected input format example
+3. Wait for user input
+4. Parse input with intelligent matching
+5. If parsing succeeds → Store answers and continue
+6. If parsing fails → Show error, example, and wait for re-input
+
+**No question/option limits**: Text-based interaction removes previous 4-question and 4-option restrictions
+
+## Execution Phases
+
+### Session Management
+- Check `.workflow/.active-*` markers first
+- Multiple sessions → Prompt selection | Single → Use it | None → Create `WFS-[topic-slug]`
+- Parse `--count N` parameter from user input (default: 3 if not specified)
+- Store decisions in `workflow-session.json` including count parameter
+
+### Phase 0: Automatic Project Context Collection
+
+**Goal**: Gather project architecture, documentation, and relevant code context BEFORE user interaction
+
+**Detection Mechanism** (execute first):
 ```javascript
-// If roles = ["ui-designer", "system-architect"]
-Generate:
-- UI Designer section: UI Requirements, UX Challenges
-- System Architect section: Architecture Decisions, Technical Implementation
-- Integration Points: UI↔Architecture dependencies
+// Check if context-package already exists
+const contextPackagePath = `.workflow/WFS-{session-id}/.process/context-package.json`;
+
+if (file_exists(contextPackagePath)) {
+  // Validate package
+  const package = Read(contextPackagePath);
+  if (package.metadata.session_id === session_id) {
+    console.log("✅ Valid context-package found, skipping Phase 0");
+    return; // Skip to Phase 1
+  }
+}
 ```
 
-### Framework Generation Examples
+**Implementation**: Invoke `context-search-agent` only if package doesn't exist
 
-#### Example 1: Architecture-Heavy Topic
-```bash
-/workflow:brainstorm:artifacts "Design scalable microservices platform" --roles "system-architect,data-architect,subject-matter-expert"
+```javascript
+Task(
+  subagent_type="context-search-agent",
+  description="Gather project context for brainstorm",
+  prompt=`
+You are executing as context-search-agent (.claude/agents/context-search-agent.md).
+
+## Execution Mode
+**BRAINSTORM MODE** (Lightweight) - Phase 1-2 only (skip deep analysis)
+
+## Session Information
+- **Session ID**: ${session_id}
+- **Task Description**: ${task_description}
+- **Output Path**: .workflow/${session_id}/.process/context-package.json
+
+## Mission
+Execute complete context-search-agent workflow for implementation planning:
+
+### Phase 1: Initialization & Pre-Analysis
+1. **Detection**: Check for existing context-package (early exit if valid)
+2. **Foundation**: Initialize code-index, get project structure, load docs
+3. **Analysis**: Extract keywords, determine scope, classify complexity
+
+### Phase 2: Multi-Source Context Discovery
+Execute all 3 discovery tracks:
+- **Track 1**: Reference documentation (CLAUDE.md, architecture docs)
+- **Track 2**: Web examples (use Exa MCP for unfamiliar tech/APIs)
+- **Track 3**: Codebase analysis (5-layer discovery: files, content, patterns, deps, config/tests)
+
+### Phase 3: Synthesis, Assessment & Packaging
+1. Apply relevance scoring and build dependency graph
+2. Synthesize 3-source data (docs > code > web)
+3. Integrate brainstorm artifacts (if .brainstorming/ exists, read content)
+4. Perform conflict detection with risk assessment
+5. Generate and validate context-package.json
+
+## Output Requirements
+Complete context-package.json with:
+- **metadata**: task_description, keywords, complexity, tech_stack, session_id
+- **project_context**: architecture_patterns, coding_conventions, tech_stack
+- **assets**: {documentation[], source_code[], config[], tests[]} with relevance scores
+- **dependencies**: {internal[], external[]} with dependency graph
+- **brainstorm_artifacts**: {guidance_specification, role_analyses[], synthesis_output} with content
+- **conflict_detection**: {risk_level, risk_factors, affected_modules[], mitigation_strategy}
+
+## Quality Validation
+Before completion verify:
+- [ ] Valid JSON format with all required fields
+- [ ] File relevance accuracy >80%
+- [ ] Dependency graph complete (max 2 transitive levels)
+- [ ] Conflict risk level calculated correctly
+- [ ] No sensitive data exposed
+- [ ] Total files ≤50 (prioritize high-relevance)
+
+Execute autonomously following agent documentation.
+Report completion with statistics.
+`
+)
 ```
-**Generated framework focuses on**:
-- Service architecture and communication patterns
-- Data flow and storage strategies
-- Domain standards and best practices
 
-#### Example 2: User-Focused Topic
-```bash
-/workflow:brainstorm:artifacts "Improve user onboarding experience" --roles "ui-designer,ux-expert,product-manager"
+**Graceful Degradation**:
+- If agent fails: Log warning, continue to Phase 1 without project context
+- If package invalid: Re-run context-search-agent
+
+### Phase 1: Topic Analysis & Intent Classification
+
+**Goal**: Extract keywords/challenges to drive all subsequent question generation, **enriched by Phase 0 project context**
+
+**Steps**:
+1. **Load Phase 0 context** (if available):
+   - Read `.workflow/WFS-{session-id}/.process/context-package.json`
+   - Extract: tech_stack, existing modules, conflict_risk, relevant files
+
+2. **Deep topic analysis** (context-aware):
+   - Extract technical entities from topic + existing codebase
+   - Identify core challenges considering existing architecture
+   - Consider constraints (timeline/budget/compliance)
+   - Define success metrics based on current project state
+
+3. **Generate 2-4 context-aware probing questions**:
+   - Reference existing tech stack in questions
+   - Consider integration with existing modules
+   - Address identified conflict risks from Phase 0
+   - Target root challenges and trade-off priorities
+
+4. **User interaction**: Output questions using text format (see User Interaction Protocol), wait for user input
+
+5. **Parse user answers**: Use intelligent parsing to extract answers from user input (support multiple formats)
+
+6. **Storage**: Store answers to `session.intent_context` with `{extracted_keywords, identified_challenges, user_answers, project_context_used}`
+
+**Example Output**:
+```markdown
+===== Phase 1: 项目意图分析 =====
+
+【问题1 - 核心挑战】实时协作平台的主要技术挑战？
+a) 实时数据同步
+   说明：100+用户同时在线，状态同步复杂度高
+b) 可扩展性架构
+   说明：用户规模增长时的系统扩展能力
+c) 冲突解决机制
+   说明：多用户同时编辑的冲突处理策略
+
+【问题2 - 优先级】MVP阶段最关注的指标？
+a) 功能完整性
+   说明：实现所有核心功能
+b) 用户体验
+   说明：流畅的交互体验和响应速度
+c) 系统稳定性
+   说明：高可用性和数据一致性
+
+请回答 (格式: 1a 2b)：
 ```
-**Generated framework focuses on**:
-- Onboarding flow and UI components
-- User experience optimization and usability
-- Business value and success metrics
 
-#### Example 3: Agile Delivery Topic
-```bash
-/workflow:brainstorm:artifacts "Optimize sprint delivery process" --roles "scrum-master,product-owner,test-strategist"
+**User input examples**:
+- `1a 2c` → Q1:a, Q2:c
+- `1a,2c` → Q1:a, Q2:c
+
+**⚠️ CRITICAL**: Questions MUST reference topic keywords. Generic "Project type?" violates dynamic generation.
+
+### Phase 2: Role Selection
+
+**⚠️ CRITICAL**: User MUST interact to select roles. NEVER auto-select without user confirmation.
+
+**Available Roles**:
+- data-architect (数据架构师)
+- product-manager (产品经理)
+- product-owner (产品负责人)
+- scrum-master (敏捷教练)
+- subject-matter-expert (领域专家)
+- system-architect (系统架构师)
+- test-strategist (测试策略师)
+- ui-designer (UI 设计师)
+- ux-expert (UX 专家)
+
+**Steps**:
+1. **Intelligent role recommendation** (AI analysis):
+   - Analyze Phase 1 extracted keywords and challenges
+   - Use AI reasoning to determine most relevant roles for the specific topic
+   - Recommend count+2 roles (e.g., if user wants 3 roles, recommend 5 options)
+   - Provide clear rationale for each recommended role based on topic context
+
+2. **User selection** (text interaction):
+   - Output all recommended roles at once (no batching needed for count+2 roles)
+   - Display roles with labels and relevance rationale
+   - Wait for user input in multi-select format
+   - Parse user input (support multiple formats)
+   - **Storage**: Store selections to `session.selected_roles`
+
+**Example Output**:
+```markdown
+===== Phase 2: 角色选择 =====
+
+【角色选择】请选择 3 个角色参与头脑风暴分析
+
+a) system-architect (系统架构师)
+   推荐理由：实时同步架构设计和技术选型的核心角色
+b) ui-designer (UI设计师)
+   推荐理由：协作界面用户体验和实时状态展示
+c) product-manager (产品经理)
+   推荐理由：功能优先级和MVP范围决策
+d) data-architect (数据架构师)
+   推荐理由：数据同步模型和存储方案设计
+e) ux-expert (UX专家)
+   推荐理由：多用户协作交互流程优化
+
+支持格式：
+- 分别选择：2a 2c 2d (选择a、c、d)
+- 合并语法：2acd (选择a、c、d)
+- 逗号分隔：2a,c,d (选择a、c、d)
+
+请输入选择：
 ```
-**Generated framework focuses on**:
-- Sprint planning and team collaboration
-- Backlog management and prioritization
-- Quality assurance and testing strategies
 
-#### Example 4: Comprehensive Analysis
-```bash
-/workflow:brainstorm:artifacts "Build real-time collaboration feature"
+**User input examples**:
+- `2acd` → Roles: a, c, d (system-architect, product-manager, data-architect)
+- `2a 2c 2d` → Same result
+- `2a,c,d` → Same result
+
+**Role Recommendation Rules**:
+- NO hardcoded keyword-to-role mappings
+- Use intelligent analysis of topic, challenges, and requirements
+- Consider role synergies and coverage gaps
+- Explain WHY each role is relevant to THIS specific topic
+- Default recommendation: count+2 roles for user to choose from
+
+### Phase 3: Role-Specific Questions (Dynamic Generation)
+
+**Goal**: Generate deep questions mapping role expertise to Phase 1 challenges
+
+**Algorithm**:
 ```
-**Generated framework covers** all aspects (no roles specified)
+FOR each selected role:
+  1. Map Phase 1 challenges to role domain:
+     - "real-time sync" + system-architect → State management pattern
+     - "100 users" + system-architect → Communication protocol
+     - "low latency" + system-architect → Conflict resolution
 
-## Session Management ⚠️ CRITICAL
-- **⚡ FIRST ACTION**: Check for all `.workflow/.active-*` markers before processing
-- **Multiple sessions support**: Different Claude instances can have different active sessions
-- **User selection**: If multiple active sessions found, prompt user to select which one to work with
-- **Auto-session creation**: `WFS-[topic-slug]` only if no active session exists
-- **Session continuity**: MUST use selected active session for all processing
-- **Context preservation**: All discussion and analysis stored in session directory
-- **Session isolation**: Each session maintains independent state
+  2. Generate 3-4 questions per role probing implementation depth, trade-offs, edge cases:
+     Q: "How handle real-time state sync for 100+ users?" (explores approach)
+     Q: "How resolve conflicts when 2 users edit simultaneously?" (explores edge case)
+     Options: [Event Sourcing/Centralized/CRDT] (concrete, explain trade-offs for THIS use case)
 
-## Discussion Areas
+  3. Output questions in text format per role:
+     - Display all questions for current role (3-4 questions, no 10-question limit)
+     - Questions in Chinese (用中文提问)
+     - Wait for user input
+     - Parse answers using intelligent parsing
+     - Store answers to session.role_decisions[role]
+```
 
-### Core Investigation Topics
-- **Purpose & Goals**: What are we trying to achieve?
-- **Scope & Boundaries**: What's included and excluded?
-- **Success Criteria**: How do we measure success?
-- **Constraints**: What limitations exist?
-- **Stakeholders**: Who is affected or involved?
+**Batching Strategy**:
+- Each role outputs all its questions at once (typically 3-4 questions)
+- No need to split per role (within 10-question batch limit)
+- Multiple roles processed sequentially (one role at a time for clarity)
 
-### Technical Considerations
-- **Requirements**: What must the solution provide?
-- **Dependencies**: What does it rely on?
-- **Integration**: How does it connect to existing systems?
-- **Performance**: What are the speed/scale requirements?
-- **Security**: What protection is needed?
+**Output Format**: Follow standard format from "User Interaction Protocol" section (single-choice question format)
 
-### Implementation Factors
-- **Timeline**: When is it needed?
-- **Resources**: What people/budget/tools are available?
-- **Risks**: What could go wrong?
-- **Alternatives**: What other approaches exist?
-- **Migration**: How do we transition from current state?
+**Example Topic-Specific Questions** (system-architect role for "real-time collaboration platform"):
+- "100+ 用户实时状态同步方案?" → Options: Event Sourcing / 集中式状态管理 / CRDT
+- "两个用户同时编辑冲突如何解决?" → Options: 自动合并 / 手动解决 / 版本控制
+- "低延迟通信协议选择?" → Options: WebSocket / SSE / 轮询
+- "系统扩展性架构方案?" → Options: 微服务 / 单体+缓存 / Serverless
 
-## Update Mechanism ⚠️ SMART UPDATES
+**Quality Requirements**: See "Question Generation Guidelines" section for detailed rules
 
-### Framework Update Logic
-```bash
-# Check existing framework
-IF topic-framework.md EXISTS:
-    SHOW current framework to user
-    ASK: "Framework exists. Do you want to:"
-    OPTIONS:
-      1. "Replace completely" → Generate new framework
-      2. "Add discussion points" → Append to existing
-      3. "Refine existing points" → Interactive editing
-      4. "Cancel" → Exit without changes
+### Phase 4: Cross-Role Clarification (Conflict Detection)
+
+**Goal**: Resolve ACTUAL conflicts from Phase 3 answers, not pre-defined relationships
+
+**Algorithm**:
+```
+1. Analyze Phase 3 answers for conflicts:
+   - Contradictory choices: product-manager "fast iteration" vs system-architect "complex Event Sourcing"
+   - Missing integration: ui-designer "Optimistic updates" but system-architect didn't address conflict handling
+   - Implicit dependencies: ui-designer "Live cursors" but no auth approach defined
+
+2. FOR each detected conflict:
+   Generate clarification questions referencing SPECIFIC Phase 3 choices
+
+3. Output clarification questions in text format:
+   - Batch conflicts into rounds (max 10 questions per round)
+   - Display questions with context from Phase 3 answers
+   - Questions in Chinese (用中文提问)
+   - Wait for user input
+   - Parse answers using intelligent parsing
+   - Store answers to session.cross_role_decisions
+
+4. If NO conflicts: Skip Phase 4 (inform user: "未检测到跨角色冲突，跳过Phase 4")
+```
+
+**Batching Strategy**:
+- Maximum 10 clarification questions per round
+- If conflicts > 10, split into multiple rounds
+- Prioritize most critical conflicts first
+
+**Output Format**: Follow standard format from "User Interaction Protocol" section (single-choice question format with background context)
+
+**Example Conflict Detection** (from Phase 3 answers):
+- **Architecture Conflict**: "CRDT 与 UI 回滚期望冲突，如何解决?"
+  - Background: system-architect chose CRDT, ui-designer expects rollback UI
+  - Options: 采用 CRDT / 显示合并界面 / 切换到 OT
+- **Integration Gap**: "实时光标功能缺少身份认证方案"
+  - Background: ui-designer chose live cursors, no auth defined
+  - Options: OAuth 2.0 / JWT Token / Session-based
+
+**Quality Requirements**: See "Question Generation Guidelines" section for conflict-specific rules
+
+### Phase 5: Generate Guidance Specification
+
+**Steps**:
+1. Load all decisions: `intent_context` + `selected_roles` + `role_decisions` + `cross_role_decisions`
+2. Transform Q&A pairs to declarative: Questions → Headers, Answers → CONFIRMED/SELECTED statements
+3. Generate guidance-specification.md (template below) - **PRIMARY OUTPUT FILE**
+4. Update workflow-session.json with **METADATA ONLY**:
+   - session_id (e.g., "WFS-topic-slug")
+   - selected_roles[] (array of role names, e.g., ["system-architect", "ui-designer", "product-manager"])
+   - topic (original user input string)
+   - timestamp (ISO-8601 format)
+   - phase_completed: "artifacts"
+   - count_parameter (number from --count flag)
+5. Validate: No interrogative sentences in .md file, all decisions traceable, no content duplication in .json
+
+**⚠️ CRITICAL OUTPUT SEPARATION**:
+- **guidance-specification.md**: Full guidance content (decisions, rationale, integration points)
+- **workflow-session.json**: Session metadata ONLY (no guidance content, no decisions, no Q&A pairs)
+- **NO content duplication**: Guidance stays in .md, metadata stays in .json
+
+## Output Document Template
+
+**File**: `.workflow/WFS-{topic}/.brainstorming/guidance-specification.md`
+
+```markdown
+# [Project] - Confirmed Guidance Specification
+
+**Metadata**: [timestamp, type, focus, roles]
+
+## 1. Project Positioning & Goals
+**CONFIRMED Objectives**: [from topic + Phase 1]
+**CONFIRMED Success Criteria**: [from Phase 1 answers]
+
+## 2-N. [Role] Decisions
+### SELECTED Choices
+**[Question topic]**: [User's answer]
+- **Rationale**: [From option description]
+- **Impact**: [Implications]
+
+### Cross-Role Considerations
+**[Conflict resolved]**: [Resolution from Phase 4]
+- **Affected Roles**: [Roles involved]
+
+## Cross-Role Integration
+**CONFIRMED Integration Points**: [API/Data/Auth from multiple roles]
+
+## Risks & Constraints
+**Identified Risks**: [From answers] → Mitigation: [Approach]
+
+## Next Steps
+**⚠️ Automatic Continuation** (when called from auto-parallel):
+- auto-parallel will assign agents to generate role-specific analysis documents
+- Each selected role gets dedicated conceptual-planning-agent
+- Agents read this guidance-specification.md for framework context
+
+## Appendix: Decision Tracking
+| Decision ID | Category | Question | Selected | Phase | Rationale |
+|-------------|----------|----------|----------|-------|-----------|
+| D-001 | Intent | [Q] | [A] | 1 | [Why] |
+| D-002 | Roles | [Selected] | [Roles] | 2 | [Why] |
+| D-003+ | [Role] | [Q] | [A] | 3 | [Why] |
+```
+
+## Question Generation Guidelines
+
+### Core Principle: Developer-Facing Questions with User Context
+
+**Target Audience**: 开发者（理解技术但需要从用户需求出发）
+
+**Generation Philosophy**:
+1. **Phase 1**: 用户场景、业务约束、优先级（建立上下文）
+2. **Phase 2**: 基于话题分析的智能角色推荐（非关键词映射）
+3. **Phase 3**: 业务需求 + 技术选型（需求驱动的技术决策）
+4. **Phase 4**: 技术冲突的业务权衡（帮助开发者理解影响）
+
+### Universal Quality Rules
+
+**Question Structure** (all phases):
+```
+[业务场景/需求前提] + [技术关注点]
+```
+
+**Option Structure** (all phases):
+```
+标签：[技术方案简称] + (业务特征)
+说明：[业务影响] + [技术权衡]
+```
+
+**MUST Include** (all phases):
+- ✅ All questions in Chinese (用中文提问)
+- ✅ 业务场景作为问题前提
+- ✅ 技术选项的业务影响说明
+- ✅ 量化指标和约束条件
+
+**MUST Avoid** (all phases):
+- ❌ 纯技术选型无业务上下文
+- ❌ 过度抽象的用户体验问题
+- ❌ 脱离话题的通用架构问题
+
+### Phase-Specific Requirements
+
+**Phase 1 Requirements**:
+- Questions MUST reference topic keywords (NOT generic "Project type?")
+- Focus: 用户使用场景（谁用？怎么用？多频繁？）、业务约束（预算、时间、团队、合规）
+- Success metrics: 性能指标、用户体验目标
+- Priority ranking: MVP vs 长期规划
+
+**Phase 3 Requirements**:
+- Questions MUST reference Phase 1 keywords (e.g., "real-time", "100 users")
+- Options MUST be concrete approaches with relevance to topic
+- Each option includes trade-offs specific to this use case
+- Include 业务需求驱动的技术问题、量化指标（并发数、延迟、可用性）
+
+**Phase 4 Requirements**:
+- Questions MUST reference SPECIFIC Phase 3 choices in background context
+- Options address the detected conflict directly
+- Each option explains impact on both conflicting roles
+- NEVER use static "Cross-Role Matrix" - ALWAYS analyze actual Phase 3 answers
+- Focus: 技术冲突的业务权衡、帮助开发者理解不同选择的影响
+
+## Validation Checklist
+
+Generated guidance-specification.md MUST:
+- ✅ No interrogative sentences (use CONFIRMED/SELECTED)
+- ✅ Every decision traceable to user answer
+- ✅ Cross-role conflicts resolved or documented
+- ✅ Next steps concrete and specific
+- ✅ All Phase 1-4 decisions in session metadata
+
+## Update Mechanism
+
+```
+IF guidance-specification.md EXISTS:
+  Prompt: "Regenerate completely / Update sections / Cancel"
 ELSE:
-    CREATE new framework
+  Run full Phase 1-5 flow
 ```
 
-### Update Strategies
+## Governance Rules
 
-**1. Complete Replacement**
-- Backup existing framework as `topic-framework-[timestamp].md.backup`
-- Generate completely new framework
-- Preserve role-specific analysis points from previous version
+**Output Requirements**:
+- All decisions MUST use CONFIRMED/SELECTED (NO "?" in decision sections)
+- Every decision MUST trace to user answer
+- Conflicts MUST be resolved (not marked "TBD")
+- Next steps MUST be actionable
+- Topic preserved as authoritative reference in session
 
-**2. Incremental Addition**
-- Load existing framework
-- Identify new discussion areas through user interaction
-- Add new sections while preserving existing structure
-- Update framework usage instructions
+**CRITICAL**: Guidance is single source of truth for downstream phases. Ambiguity violates governance.
 
-**3. Refinement Mode**
-- Interactive editing of existing discussion points
-- Allow modification of scope, objectives, and questions
-- Preserve framework structure and role assignments
-- Update timestamp and version info
+## Storage Validation
 
-### Version Control
-- **Backup Creation**: Always backup before major changes
-- **Change Tracking**: Include change summary in framework footer
-- **Rollback Support**: Keep previous version accessible
+**workflow-session.json** (metadata only):
+```json
+{
+  "session_id": "WFS-{topic-slug}",
+  "type": "brainstorming",
+  "topic": "{original user input}",
+  "selected_roles": ["system-architect", "ui-designer", "product-manager"],
+  "phase_completed": "artifacts",
+  "timestamp": "2025-10-24T10:30:00Z",
+  "count_parameter": 3
+}
+```
 
-## Error Handling
-- **Session creation failure**: Provide clear error message and retry option
-- **Discussion stalling**: Offer structured prompts to continue exploration
-- **Documentation issues**: Graceful handling of file creation problems
-- **Missing context**: Prompt for additional information when needed
+**⚠️ Rule**: Session JSON stores ONLY metadata (session_id, selected_roles[], topic, timestamps). All guidance content goes to guidance-specification.md.
 
-## Reference Information
+## File Structure
 
-### File Structure Reference
-**Architecture**: @~/.claude/workflows/workflow-architecture.md
-**Session Management**: Standard workflow session protocols
+```
+.workflow/WFS-[topic]/
+├── .active-brainstorming
+├── workflow-session.json              # Session metadata ONLY
+└── .brainstorming/
+    └── guidance-specification.md      # Full guidance content
+```
 
-### Integration Points
-- **Compatible with**: Other brainstorming commands in the same session
-- **Builds foundation for**: More detailed planning and implementation phases
-- **Outputs used by**: `/workflow:brainstorm:synthesis` command for cross-analysis integration

.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,360 +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"))
+Task(conceptual-planning-agent): "
+[FLOW_CONTROL]
+
+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-{session}/.brainstorming/guidance-specification.md)
+   - Output: topic_framework_content
+
+2. **load_role_template**
+   - Action: Load {role-name} planning template
+   - Command: Read(~/.claude/workflows/cli-templates/planning-roles/{role}.md)
+   - Output: role_template_guidelines
+
+3. **load_session_metadata**
+   - Action: Load session metadata and original user intent
+   - Command: Read(.workflow/WFS-{session}/workflow-session.json)
+   - Output: session_context (contains original user prompt as PRIMARY reference)
+
+## Analysis Requirements
+**Primary Reference**: Original user prompt from workflow-session.json is authoritative
+**Framework Source**: Address all discussion points in guidance-specification.md from {role-name} perspective
+**Role Focus**: {role-name} domain expertise aligned with user intent
+**Structured Approach**: Create analysis.md addressing framework discussion points
+**Template Integration**: Apply role template guidelines within framework structure
+
+## Expected Deliverables
+1. **analysis.md**: Comprehensive {role-name} analysis addressing all framework discussion points
+   - **File Naming**: MUST start with `analysis` prefix (e.g., `analysis.md`, `analysis-1.md`, `analysis-2.md`)
+   - **FORBIDDEN**: Never use `recommendations.md` or any filename not starting with `analysis`
+   - **Auto-split if large**: If content >800 lines, split to `analysis-1.md`, `analysis-2.md` (max 3 files: analysis.md, analysis-1.md, analysis-2.md)
+   - **Content**: Includes both analysis AND recommendations sections within analysis files
+2. **Framework Reference**: Include @../guidance-specification.md reference in analysis
+3. **User Intent Alignment**: Validate analysis aligns with original user objectives from session_context
+
+## Completion Criteria
+- Address each discussion point from guidance-specification.md with {role-name} expertise
+- Provide actionable recommendations from {role-name} perspective within analysis files
+- All output files MUST start with `analysis` prefix (no recommendations.md or other naming)
+- Reference framework document using @ notation for integration
+- Update workflow-session.json with completion status
+"
 ```
 
-## Core Workflow
+**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
 
-### Structured Topic Processing → Role Analysis → Synthesis
-The command follows a structured three-phase approach with dedicated document types:
+**Input**:
+- `selected_roles[]` from Phase 1
+- `session_id` from Phase 1
+- guidance-specification.md path
 
-**Phase 1: Framework Generation** ⚠️ COMMAND EXECUTION
-- **Role selection**: Auto-select N roles based on topic keywords and --count parameter (default: 3, see Role Selection Logic)
-- **Call artifacts command**: Execute `/workflow:brainstorm:artifacts "{topic}" --roles "{role1,role2,...,roleN}"` using SlashCommand tool
-- **Role-specific framework**: Generate framework with sections tailored to selected roles
-- **⚠️ User intent storage**: Topic saved in workflow-session.json as primary reference for all downstream phases
+**Validation**:
+- 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
 
-**Phase 2: Role Analysis Execution** ⚠️ PARALLEL AGENT ANALYSIS
-- **Parallel execution**: Multiple roles execute simultaneously for faster completion
-- **Independent agents**: Each role gets dedicated conceptual-planning-agent running in parallel
-- **Shared framework**: All roles reference the same topic framework for consistency
-- **Concurrent generation**: Role-specific analysis documents generated simultaneously
-- **Progress tracking**: Parallel agents update progress independently
+**TodoWrite**: Mark all N role agent tasks completed, phase 3 in_progress
 
-**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
+**After Phase 2**: Auto-continue to Phase 3 (synthesis)
 
-## Implementation Standards
+---
 
-### Simplified Command Orchestration ⚠️ STREAMLINED
-Auto command coordinates independent specialized commands:
+### Phase 3: Synthesis Generation
 
-**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)
+**Command**: `SlashCommand(command="/workflow:brainstorm:synthesis --session {sessionId}")`
 
-**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
+**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
 
-**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)
+**Input**: `sessionId` from Phase 1
 
-### Parameter Parsing
+**Validation**:
+- `.workflow/WFS-{topic}/.brainstorming/synthesis-specification.md` exists
+- Synthesis references all role analyses
 
-**Count Parameter Handling**:
-```bash
-# Parse --count parameter from user input
+**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
+```
+
+## TodoWrite Pattern
+
+```javascript
+// 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"}
+]})
+
+// 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"}
+]})
+
+// 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"}
+]})
+```
+
+## Input Processing
+
+**Count Parameter Parsing**:
+```javascript
+// Extract --count from user input
 IF user_input CONTAINS "--count":
     EXTRACT count_value FROM "--count N" pattern
     IF count_value > 9:
-        count_value = 9  # Cap at maximum 9 roles
-    END IF
+        count_value = 9  // Cap at maximum 9 roles
 ELSE:
-    count_value = 3  # Default to 3 roles
-END IF
+    count_value = 3  // Default to 3 roles
+
+// Pass to artifacts command
+EXECUTE: /workflow:brainstorm:artifacts "{topic}" --count {count_value}
 ```
 
-**Role Selection with Count**:
-1. **Analyze topic keywords**: Identify relevant role categories
-2. **Rank roles by relevance**: Score based on keyword matches
-3. **Select top N roles**: Pick N most relevant roles (N = count_value)
-4. **Ensure diversity**: Balance across different expertise areas
-5. **Minimum guarantee**: Always include at least one role (default to product-manager if no matches)
+**Topic Structuring**:
+1. **Already Structured** → Pass directly to artifacts
+   ```
+   User: "GOAL: Build platform SCOPE: 100 users CONTEXT: Real-time"
+   → Pass as-is to artifacts
+   ```
 
-### Simplified Processing Standards
+2. **Simple Text** → Pass directly (artifacts handles structuring)
+   ```
+   User: "Build collaboration platform"
+   → artifacts will analyze and structure
+   ```
 
-**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
+## Session Management
 
-**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
+**⚡ FIRST ACTION**: Check for `.workflow/.active-*` markers before Phase 1
 
-**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
+**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 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
+**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
 
-## Document Generation
+## Output Structure
 
-**Command Coordination Workflow**: artifacts → parallel role analysis → synthesis
+**Phase 1 Output**:
+- `.workflow/WFS-{topic}/.brainstorming/guidance-specification.md` (framework content)
+- `.workflow/WFS-{topic}/workflow-session.json` (metadata: selected_roles[], topic, timestamps)
 
-**Output Structure**: Coordinated commands generate framework, role analyses, and synthesis documents as defined in their respective command specifications.
+**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)
 
-## Agent Prompt Templates
+**⚠️ Storage Separation**: Guidance content in .md files, metadata in .json (no duplication)
 
-### Task Agent Invocation Template
+## Available Roles
 
+- data-architect (数据架构师)
+- product-manager (产品经理)
+- product-owner (产品负责人)
+- scrum-master (敏捷教练)
+- subject-matter-expert (领域专家)
+- system-architect (系统架构师)
+- test-strategist (测试策略师)
+- ui-designer (UI 设计师)
+- ux-expert (UX 专家)
 
-```bash
-Task(subagent_type="conceptual-planning-agent",
-     prompt="Execute brainstorming analysis: {role-name} perspective for {topic}
+**Role Selection**: Handled by artifacts command (intelligent recommendation + user selection)
 
-     ## Role Assignment
-     **ASSIGNED_ROLE**: {role-name}
-     **TOPIC**: {user-provided-topic}
-     **OUTPUT_LOCATION**: .workflow/WFS-{topic}/.brainstorming/{role}/
+## Error Handling
 
-     ## Execution Instructions
-     [FLOW_CONTROL]
-
-     ### Flow Control Steps
-     **AGENT RESPONSIBILITY**: Execute these pre_analysis steps sequentially with context accumulation:
-
-     1. **load_topic_framework**
-        - Action: Load structured topic discussion framework
-        - Command: bash(cat .workflow/WFS-{topic}/.brainstorming/topic-framework.md 2>/dev/null || echo 'Topic framework not found')
-        - Output: topic_framework
-
-     2. **load_role_template**
-        - Action: Load {role-name} planning template
-        - Command: bash($(cat "~/.claude/workflows/cli-templates/planning-roles/{role}.md"))
-        - Output: role_template
-
-     3. **load_session_metadata**
-        - Action: Load session metadata and original user intent
-        - Command: bash(cat .workflow/WFS-{topic}/workflow-session.json 2>/dev/null || echo '{}')
-        - Output: session_metadata (contains original user prompt in 'project' or 'description' field)
-
-     ### Implementation Context
-     **⚠️ User Intent Authority**: Original user prompt from session_metadata.project is PRIMARY reference
-     **Topic Framework**: Use loaded topic-framework.md for structured analysis
-     **Role Focus**: {role-name} domain expertise and perspective aligned with user intent
-     **Analysis Type**: Address framework discussion points from role perspective, filtered by user objectives
-     **Template Framework**: Combine role template with topic framework structure
-     **Structured Approach**: Create analysis.md addressing all topic framework points relevant to user's goals
-
-     ### Session Context
-     **Workflow Directory**: .workflow/WFS-{topic}/.brainstorming/
-     **Output Directory**: .workflow/WFS-{topic}/.brainstorming/{role}/
-     **Session JSON**: .workflow/WFS-{topic}/workflow-session.json
-
-     ### Dependencies & Context
-     **Topic**: {user-provided-topic}
-     **Role Template**: "~/.claude/workflows/cli-templates/planning-roles/{role}.md"
-     **User Requirements**: To be gathered through interactive questioning
-
-     ## Completion Requirements
-     1. Execute all flow control steps in sequence (load topic framework, role template, session metadata with user intent)
-     2. **⚠️ User Intent Alignment**: Validate analysis aligns with original user objectives from session_metadata
-     3. **Address Topic Framework**: Respond to all discussion points in topic-framework.md from role perspective
-     4. **Filter by User Goals**: Prioritize insights directly relevant to user's stated objectives
-     5. Apply role template guidelines within topic framework structure
-     6. Generate structured role analysis addressing framework points aligned with user intent
-     7. Create single comprehensive deliverable in OUTPUT_LOCATION:
-        - analysis.md (structured analysis addressing all topic framework points with role-specific insights filtered by user goals)
-     8. Include framework reference: @../topic-framework.md in analysis.md
-     9. Update workflow-session.json with completion status",
-     description="Execute {role-name} brainstorming analysis")
-```
-
-### Parallel Role Agent调用示例
-```bash
-# Execute N roles in parallel using single message with multiple Task calls
-# (N determined by --count parameter, default 3, shown below with 3 roles as example)
-
-Task(subagent_type="conceptual-planning-agent",
-     prompt="Execute brainstorming analysis: {role-1} perspective for {topic}...",
-     description="Execute {role-1} brainstorming analysis")
-
-Task(subagent_type="conceptual-planning-agent",
-     prompt="Execute brainstorming analysis: {role-2} perspective for {topic}...",
-     description="Execute {role-2} brainstorming analysis")
-
-Task(subagent_type="conceptual-planning-agent",
-     prompt="Execute brainstorming analysis: {role-3} perspective for {topic}...",
-     description="Execute {role-3} brainstorming analysis")
-
-# ... repeat for remaining N-3 roles if --count > 3
-```
-
-### Direct Synthesis Process (Command-Driven)
-**Synthesis execution**: Use SlashCommand to execute `/workflow:brainstorm:synthesis` after role completion
-
-
-## TodoWrite Control Flow ⚠️ CRITICAL
-
-### Workflow Progress Tracking
-**MANDATORY**: Use Claude Code's built-in TodoWrite tool throughout entire brainstorming workflow:
-
-```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"
-    }
-  ]
-});
-
-// 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
-  ]
-});
-
-// 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"
-    }
-  ]
-});
-```
-
-**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
+- **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/data-architect.md

@@ -1,6 +1,6 @@
 ---
 name: data-architect
-description: Generate or update data-architect/analysis.md addressing topic-framework discussion points
+description: Generate or update data-architect/analysis.md addressing guidance-specification discussion points
 argument-hint: "optional topic - uses existing framework if available"
 allowed-tools: Task(conceptual-planning-agent), TodoWrite(*), Read(*), Write(*)
 ---
@@ -8,10 +8,10 @@ allowed-tools: Task(conceptual-planning-agent), TodoWrite(*), Read(*), Write(*)
 ## 📊 **Data Architect Analysis Generator**
 
 ### Purpose
-**Specialized command for generating data-architect/analysis.md** that addresses topic-framework.md discussion points from data architecture perspective. Creates or updates role-specific analysis with framework references.
+**Specialized command for generating data-architect/analysis.md** that addresses guidance-specification.md discussion points from data architecture perspective. Creates or updates role-specific analysis with framework references.
 
 ### Core Function
-- **Framework-based Analysis**: Address each discussion point in topic-framework.md
+- **Framework-based Analysis**: Address each discussion point in guidance-specification.md
 - **Data Architecture Focus**: Data models, pipelines, governance, and analytics perspective
 - **Update Mechanism**: Create new or update existing analysis.md
 - **Agent Delegation**: Use conceptual-planning-agent for analysis generation
@@ -52,7 +52,7 @@ IF active_session EXISTS:
     session_id = get_active_session()
     brainstorm_dir = .workflow/WFS-{session}/.brainstorming/
 
-    CHECK: brainstorm_dir/topic-framework.md
+    CHECK: brainstorm_dir/guidance-specification.md
     IF EXISTS:
         framework_mode = true
         load_framework = true
@@ -93,7 +93,7 @@ ANALYSIS_MODE: {framework_mode ? "framework_based" : "standalone"}
 ## Flow Control Steps
 1. **load_topic_framework**
    - Action: Load structured topic discussion framework
-   - Command: Read(.workflow/WFS-{session}/.brainstorming/topic-framework.md)
+   - Command: Read(.workflow/WFS-{session}/.brainstorming/guidance-specification.md)
    - Output: topic_framework_content
 
 2. **load_role_template**
@@ -107,17 +107,17 @@ ANALYSIS_MODE: {framework_mode ? "framework_based" : "standalone"}
    - Output: session_context
 
 ## Analysis Requirements
-**Framework Reference**: Address all discussion points in topic-framework.md from data architecture perspective
+**Framework Reference**: Address all discussion points in guidance-specification.md from data architecture perspective
 **Role Focus**: Data models, pipelines, governance, analytics platforms
 **Structured Approach**: Create analysis.md addressing framework discussion points
 **Template Integration**: Apply role template guidelines within framework structure
 
 ## Expected Deliverables
 1. **analysis.md**: Comprehensive data architecture analysis addressing all framework discussion points
-2. **Framework Reference**: Include @../topic-framework.md reference in analysis
+2. **Framework Reference**: Include @../guidance-specification.md reference in analysis
 
 ## Completion Criteria
-- Address each discussion point from topic-framework.md with data architecture expertise
+- Address each discussion point from guidance-specification.md with data architecture expertise
 - Provide data model designs, pipeline architectures, and governance strategies
 - Include scalability, performance, and quality considerations
 - Reference framework document using @ notation for integration
@@ -136,7 +136,7 @@ TodoWrite({
       activeForm: "Detecting session and framework"
     },
     {
-      content: "Load topic-framework.md and session metadata for context",
+      content: "Load guidance-specification.md and session metadata for context",
       status: "pending",
       activeForm: "Loading framework and session context"
     },
@@ -164,7 +164,7 @@ TodoWrite({
 ### Framework-Based Analysis
 ```
 .workflow/WFS-{session}/.brainstorming/data-architect/
-└── analysis.md    # Structured analysis addressing topic-framework.md discussion points
+└── analysis.md    # Structured analysis addressing guidance-specification.md discussion points
 ```
 
 ### Analysis Document Structure
@@ -172,11 +172,11 @@ TodoWrite({
 # Data Architect Analysis: [Topic from Framework]
 
 ## Framework Reference
-**Topic Framework**: @../topic-framework.md
+**Topic Framework**: @../guidance-specification.md
 **Role Focus**: Data Architecture perspective
 
 ## Discussion Points Analysis
-[Address each point from topic-framework.md with data architecture expertise]
+[Address each point from guidance-specification.md with data architecture expertise]
 
 ### Core Requirements (from framework)
 [Data architecture perspective on requirements]
@@ -209,12 +209,12 @@ TodoWrite({
     "status": "completed",
     "framework_addressed": true,
     "output_location": ".workflow/WFS-{session}/.brainstorming/data-architect/analysis.md",
-    "framework_reference": "@../topic-framework.md"
+    "framework_reference": "@../guidance-specification.md"
   }
 }
 ```
 
 ### Integration Points
-- **Framework Reference**: @../topic-framework.md for structured discussion points
+- **Framework Reference**: @../guidance-specification.md for structured discussion points
 - **Cross-Role Synthesis**: Data architecture insights available for synthesis-report.md integration
 - **Agent Autonomy**: Independent execution with framework guidance

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

@@ -1,6 +1,6 @@
 ---
 name: product-manager
-description: Generate or update product-manager/analysis.md addressing topic-framework discussion points
+description: Generate or update product-manager/analysis.md addressing guidance-specification discussion points
 argument-hint: "optional topic - uses existing framework if available"
 allowed-tools: Task(conceptual-planning-agent), TodoWrite(*), Read(*), Write(*)
 ---
@@ -8,10 +8,10 @@ allowed-tools: Task(conceptual-planning-agent), TodoWrite(*), Read(*), Write(*)
 ## 🎯 **Product Manager Analysis Generator**
 
 ### Purpose
-**Specialized command for generating product-manager/analysis.md** that addresses topic-framework.md discussion points from product strategy perspective. Creates or updates role-specific analysis with framework references.
+**Specialized command for generating product-manager/analysis.md** that addresses guidance-specification.md discussion points from product strategy perspective. Creates or updates role-specific analysis with framework references.
 
 ### Core Function
-- **Framework-based Analysis**: Address each discussion point in topic-framework.md
+- **Framework-based Analysis**: Address each discussion point in guidance-specification.md
 - **Product Strategy Focus**: User needs, business value, and market positioning
 - **Update Mechanism**: Create new or update existing analysis.md
 - **Agent Delegation**: Use conceptual-planning-agent for analysis generation
@@ -32,7 +32,7 @@ IF active_session EXISTS:
     session_id = get_active_session()
     brainstorm_dir = .workflow/WFS-{session}/.brainstorming/
 
-    CHECK: brainstorm_dir/topic-framework.md
+    CHECK: brainstorm_dir/guidance-specification.md
     IF EXISTS:
         framework_mode = true
         load_framework = true
@@ -73,7 +73,7 @@ ANALYSIS_MODE: {framework_mode ? "framework_based" : "standalone"}
 ## Flow Control Steps
 1. **load_topic_framework**
    - Action: Load structured topic discussion framework
-   - Command: Read(.workflow/WFS-{session}/.brainstorming/topic-framework.md)
+   - Command: Read(.workflow/WFS-{session}/.brainstorming/guidance-specification.md)
    - Output: topic_framework_content
 
 2. **load_role_template**
@@ -87,17 +87,17 @@ ANALYSIS_MODE: {framework_mode ? "framework_based" : "standalone"}
    - Output: session_context
 
 ## Analysis Requirements
-**Framework Reference**: Address all discussion points in topic-framework.md from product strategy perspective
+**Framework Reference**: Address all discussion points in guidance-specification.md from product strategy perspective
 **Role Focus**: User value, business impact, market positioning, product strategy
 **Structured Approach**: Create analysis.md addressing framework discussion points
 **Template Integration**: Apply role template guidelines within framework structure
 
 ## Expected Deliverables
 1. **analysis.md**: Comprehensive product strategy analysis addressing all framework discussion points
-2. **Framework Reference**: Include @../topic-framework.md reference in analysis
+2. **Framework Reference**: Include @../guidance-specification.md reference in analysis
 
 ## Completion Criteria
-- Address each discussion point from topic-framework.md with product management expertise
+- Address each discussion point from guidance-specification.md with product management expertise
 - Provide actionable business strategies and user value propositions
 - Include market analysis and competitive positioning insights
 - Reference framework document using @ notation for integration
@@ -116,7 +116,7 @@ TodoWrite({
       activeForm: "Detecting session and framework"
     },
     {
-      content: "Load topic-framework.md and session metadata for context",
+      content: "Load guidance-specification.md and session metadata for context",
       status: "pending",
       activeForm: "Loading framework and session context"
     },
@@ -144,7 +144,7 @@ TodoWrite({
 ### Framework-Based Analysis
 ```
 .workflow/WFS-{session}/.brainstorming/product-manager/
-└── analysis.md    # Structured analysis addressing topic-framework.md discussion points
+└── analysis.md    # Structured analysis addressing guidance-specification.md discussion points
 ```
 
 ### Analysis Document Structure
@@ -152,11 +152,11 @@ TodoWrite({
 # Product Manager Analysis: [Topic from Framework]
 
 ## Framework Reference
-**Topic Framework**: @../topic-framework.md
+**Topic Framework**: @../guidance-specification.md
 **Role Focus**: Product Strategy perspective
 
 ## Discussion Points Analysis
-[Address each point from topic-framework.md with product management expertise]
+[Address each point from guidance-specification.md with product management expertise]
 
 ### Core Requirements (from framework)
 [Product strategy perspective on user needs and requirements]
@@ -189,12 +189,12 @@ TodoWrite({
     "status": "completed",
     "framework_addressed": true,
     "output_location": ".workflow/WFS-{session}/.brainstorming/product-manager/analysis.md",
-    "framework_reference": "@../topic-framework.md"
+    "framework_reference": "@../guidance-specification.md"
   }
 }
 ```
 
 ### Integration Points
-- **Framework Reference**: @../topic-framework.md for structured discussion points
+- **Framework Reference**: @../guidance-specification.md for structured discussion points
 - **Cross-Role Synthesis**: Product strategy insights available for synthesis-report.md integration
 - **Agent Autonomy**: Independent execution with framework guidance

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

@@ -1,6 +1,6 @@
 ---
 name: product-owner
-description: Generate or update product-owner/analysis.md addressing topic-framework discussion points
+description: Generate or update product-owner/analysis.md addressing guidance-specification discussion points
 argument-hint: "optional topic - uses existing framework if available"
 allowed-tools: Task(conceptual-planning-agent), TodoWrite(*), Read(*), Write(*)
 ---
@@ -8,10 +8,10 @@ allowed-tools: Task(conceptual-planning-agent), TodoWrite(*), Read(*), Write(*)
 ## 🎯 **Product Owner Analysis Generator**
 
 ### Purpose
-**Specialized command for generating product-owner/analysis.md** that addresses topic-framework.md discussion points from product backlog and feature prioritization perspective. Creates or updates role-specific analysis with framework references.
+**Specialized command for generating product-owner/analysis.md** that addresses guidance-specification.md discussion points from product backlog and feature prioritization perspective. Creates or updates role-specific analysis with framework references.
 
 ### Core Function
-- **Framework-based Analysis**: Address each discussion point in topic-framework.md
+- **Framework-based Analysis**: Address each discussion point in guidance-specification.md
 - **Product Backlog Focus**: Feature prioritization, user stories, and acceptance criteria
 - **Update Mechanism**: Create new or update existing analysis.md
 - **Agent Delegation**: Use conceptual-planning-agent for analysis generation
@@ -32,7 +32,7 @@ IF active_session EXISTS:
     session_id = get_active_session()
     brainstorm_dir = .workflow/WFS-{session}/.brainstorming/
 
-    CHECK: brainstorm_dir/topic-framework.md
+    CHECK: brainstorm_dir/guidance-specification.md
     IF EXISTS:
         framework_mode = true
         load_framework = true
@@ -73,7 +73,7 @@ ANALYSIS_MODE: {framework_mode ? "framework_based" : "standalone"}
 ## Flow Control Steps
 1. **load_topic_framework**
    - Action: Load structured topic discussion framework
-   - Command: Read(.workflow/WFS-{session}/.brainstorming/topic-framework.md)
+   - Command: Read(.workflow/WFS-{session}/.brainstorming/guidance-specification.md)
    - Output: topic_framework_content
 
 2. **load_role_template**
@@ -87,17 +87,17 @@ ANALYSIS_MODE: {framework_mode ? "framework_based" : "standalone"}
    - Output: session_context
 
 ## Analysis Requirements
-**Framework Reference**: Address all discussion points in topic-framework.md from product backlog and feature prioritization perspective
+**Framework Reference**: Address all discussion points in guidance-specification.md from product backlog and feature prioritization perspective
 **Role Focus**: Backlog management, stakeholder alignment, feature prioritization, acceptance criteria
 **Structured Approach**: Create analysis.md addressing framework discussion points
 **Template Integration**: Apply role template guidelines within framework structure
 
 ## Expected Deliverables
 1. **analysis.md**: Comprehensive product ownership analysis addressing all framework discussion points
-2. **Framework Reference**: Include @../topic-framework.md reference in analysis
+2. **Framework Reference**: Include @../guidance-specification.md reference in analysis
 
 ## Completion Criteria
-- Address each discussion point from topic-framework.md with product ownership expertise
+- Address each discussion point from guidance-specification.md with product ownership expertise
 - Provide actionable user stories and acceptance criteria definitions
 - Include feature prioritization and stakeholder alignment strategies
 - Reference framework document using @ notation for integration
@@ -116,7 +116,7 @@ TodoWrite({
       activeForm: "Detecting session and framework"
     },
     {
-      content: "Load topic-framework.md and session metadata for context",
+      content: "Load guidance-specification.md and session metadata for context",
       status: "pending",
       activeForm: "Loading framework and session context"
     },
@@ -144,7 +144,7 @@ TodoWrite({
 ### Framework-Based Analysis
 ```
 .workflow/WFS-{session}/.brainstorming/product-owner/
-└── analysis.md    # Structured analysis addressing topic-framework.md discussion points
+└── analysis.md    # Structured analysis addressing guidance-specification.md discussion points
 ```
 
 ### Analysis Document Structure
@@ -152,11 +152,11 @@ TodoWrite({
 # Product Owner Analysis: [Topic from Framework]
 
 ## Framework Reference
-**Topic Framework**: @../topic-framework.md
+**Topic Framework**: @../guidance-specification.md
 **Role Focus**: Product Backlog & Feature Prioritization perspective
 
 ## Discussion Points Analysis
-[Address each point from topic-framework.md with product ownership expertise]
+[Address each point from guidance-specification.md with product ownership expertise]
 
 ### Core Requirements (from framework)
 [User story formulation and backlog refinement perspective]
@@ -189,12 +189,12 @@ TodoWrite({
     "status": "completed",
     "framework_addressed": true,
     "output_location": ".workflow/WFS-{session}/.brainstorming/product-owner/analysis.md",
-    "framework_reference": "@../topic-framework.md"
+    "framework_reference": "@../guidance-specification.md"
   }
 }
 ```
 
 ### Integration Points
-- **Framework Reference**: @../topic-framework.md for structured discussion points
+- **Framework Reference**: @../guidance-specification.md for structured discussion points
 - **Cross-Role Synthesis**: Product ownership insights available for synthesis-report.md integration
 - **Agent Autonomy**: Independent execution with framework guidance

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

@@ -1,6 +1,6 @@
 ---
 name: scrum-master
-description: Generate or update scrum-master/analysis.md addressing topic-framework discussion points
+description: Generate or update scrum-master/analysis.md addressing guidance-specification discussion points
 argument-hint: "optional topic - uses existing framework if available"
 allowed-tools: Task(conceptual-planning-agent), TodoWrite(*), Read(*), Write(*)
 ---
@@ -8,10 +8,10 @@ allowed-tools: Task(conceptual-planning-agent), TodoWrite(*), Read(*), Write(*)
 ## 🎯 **Scrum Master Analysis Generator**
 
 ### Purpose
-**Specialized command for generating scrum-master/analysis.md** that addresses topic-framework.md discussion points from agile process and team collaboration perspective. Creates or updates role-specific analysis with framework references.
+**Specialized command for generating scrum-master/analysis.md** that addresses guidance-specification.md discussion points from agile process and team collaboration perspective. Creates or updates role-specific analysis with framework references.
 
 ### Core Function
-- **Framework-based Analysis**: Address each discussion point in topic-framework.md
+- **Framework-based Analysis**: Address each discussion point in guidance-specification.md
 - **Agile Process Focus**: Sprint planning, team dynamics, and delivery optimization
 - **Update Mechanism**: Create new or update existing analysis.md
 - **Agent Delegation**: Use conceptual-planning-agent for analysis generation
@@ -32,7 +32,7 @@ IF active_session EXISTS:
     session_id = get_active_session()
     brainstorm_dir = .workflow/WFS-{session}/.brainstorming/
 
-    CHECK: brainstorm_dir/topic-framework.md
+    CHECK: brainstorm_dir/guidance-specification.md
     IF EXISTS:
         framework_mode = true
         load_framework = true
@@ -73,7 +73,7 @@ ANALYSIS_MODE: {framework_mode ? "framework_based" : "standalone"}
 ## Flow Control Steps
 1. **load_topic_framework**
    - Action: Load structured topic discussion framework
-   - Command: Read(.workflow/WFS-{session}/.brainstorming/topic-framework.md)
+   - Command: Read(.workflow/WFS-{session}/.brainstorming/guidance-specification.md)
    - Output: topic_framework_content
 
 2. **load_role_template**
@@ -87,17 +87,17 @@ ANALYSIS_MODE: {framework_mode ? "framework_based" : "standalone"}
    - Output: session_context
 
 ## Analysis Requirements
-**Framework Reference**: Address all discussion points in topic-framework.md from agile process and team collaboration perspective
+**Framework Reference**: Address all discussion points in guidance-specification.md from agile process and team collaboration perspective
 **Role Focus**: Sprint planning, team dynamics, process optimization, delivery management
 **Structured Approach**: Create analysis.md addressing framework discussion points
 **Template Integration**: Apply role template guidelines within framework structure
 
 ## Expected Deliverables
 1. **analysis.md**: Comprehensive agile process analysis addressing all framework discussion points
-2. **Framework Reference**: Include @../topic-framework.md reference in analysis
+2. **Framework Reference**: Include @../guidance-specification.md reference in analysis
 
 ## Completion Criteria
-- Address each discussion point from topic-framework.md with scrum mastery expertise
+- Address each discussion point from guidance-specification.md with scrum mastery expertise
 - Provide actionable sprint planning and team facilitation strategies
 - Include process optimization and impediment removal insights
 - Reference framework document using @ notation for integration
@@ -116,7 +116,7 @@ TodoWrite({
       activeForm: "Detecting session and framework"
     },
     {
-      content: "Load topic-framework.md and session metadata for context",
+      content: "Load guidance-specification.md and session metadata for context",
       status: "pending",
       activeForm: "Loading framework and session context"
     },
@@ -144,7 +144,7 @@ TodoWrite({
 ### Framework-Based Analysis
 ```
 .workflow/WFS-{session}/.brainstorming/scrum-master/
-└── analysis.md    # Structured analysis addressing topic-framework.md discussion points
+└── analysis.md    # Structured analysis addressing guidance-specification.md discussion points
 ```
 
 ### Analysis Document Structure
@@ -152,11 +152,11 @@ TodoWrite({
 # Scrum Master Analysis: [Topic from Framework]
 
 ## Framework Reference
-**Topic Framework**: @../topic-framework.md
+**Topic Framework**: @../guidance-specification.md
 **Role Focus**: Agile Process & Team Collaboration perspective
 
 ## Discussion Points Analysis
-[Address each point from topic-framework.md with scrum mastery expertise]
+[Address each point from guidance-specification.md with scrum mastery expertise]
 
 ### Core Requirements (from framework)
 [Sprint planning and iteration breakdown perspective]
@@ -189,12 +189,12 @@ TodoWrite({
     "status": "completed",
     "framework_addressed": true,
     "output_location": ".workflow/WFS-{session}/.brainstorming/scrum-master/analysis.md",
-    "framework_reference": "@../topic-framework.md"
+    "framework_reference": "@../guidance-specification.md"
   }
 }
 ```
 
 ### Integration Points
-- **Framework Reference**: @../topic-framework.md for structured discussion points
+- **Framework Reference**: @../guidance-specification.md for structured discussion points
 - **Cross-Role Synthesis**: Agile process insights available for synthesis-report.md integration
 - **Agent Autonomy**: Independent execution with framework guidance

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

@@ -1,6 +1,6 @@
 ---
 name: subject-matter-expert
-description: Generate or update subject-matter-expert/analysis.md addressing topic-framework discussion points
+description: Generate or update subject-matter-expert/analysis.md addressing guidance-specification discussion points
 argument-hint: "optional topic - uses existing framework if available"
 allowed-tools: Task(conceptual-planning-agent), TodoWrite(*), Read(*), Write(*)
 ---
@@ -8,10 +8,10 @@ allowed-tools: Task(conceptual-planning-agent), TodoWrite(*), Read(*), Write(*)
 ## 🎯 **Subject Matter Expert Analysis Generator**
 
 ### Purpose
-**Specialized command for generating subject-matter-expert/analysis.md** that addresses topic-framework.md discussion points from domain knowledge and technical expertise perspective. Creates or updates role-specific analysis with framework references.
+**Specialized command for generating subject-matter-expert/analysis.md** that addresses guidance-specification.md discussion points from domain knowledge and technical expertise perspective. Creates or updates role-specific analysis with framework references.
 
 ### Core Function
-- **Framework-based Analysis**: Address each discussion point in topic-framework.md
+- **Framework-based Analysis**: Address each discussion point in guidance-specification.md
 - **Domain Expertise Focus**: Deep technical knowledge, industry standards, and best practices
 - **Update Mechanism**: Create new or update existing analysis.md
 - **Agent Delegation**: Use conceptual-planning-agent for analysis generation
@@ -32,7 +32,7 @@ IF active_session EXISTS:
     session_id = get_active_session()
     brainstorm_dir = .workflow/WFS-{session}/.brainstorming/
 
-    CHECK: brainstorm_dir/topic-framework.md
+    CHECK: brainstorm_dir/guidance-specification.md
     IF EXISTS:
         framework_mode = true
         load_framework = true
@@ -73,7 +73,7 @@ ANALYSIS_MODE: {framework_mode ? "framework_based" : "standalone"}
 ## Flow Control Steps
 1. **load_topic_framework**
    - Action: Load structured topic discussion framework
-   - Command: Read(.workflow/WFS-{session}/.brainstorming/topic-framework.md)
+   - Command: Read(.workflow/WFS-{session}/.brainstorming/guidance-specification.md)
    - Output: topic_framework_content
 
 2. **load_role_template**
@@ -87,17 +87,17 @@ ANALYSIS_MODE: {framework_mode ? "framework_based" : "standalone"}
    - Output: session_context
 
 ## Analysis Requirements
-**Framework Reference**: Address all discussion points in topic-framework.md from domain expertise and technical standards perspective
+**Framework Reference**: Address all discussion points in guidance-specification.md from domain expertise and technical standards perspective
 **Role Focus**: Domain knowledge, technical standards, risk assessment, knowledge transfer
 **Structured Approach**: Create analysis.md addressing framework discussion points
 **Template Integration**: Apply role template guidelines within framework structure
 
 ## Expected Deliverables
 1. **analysis.md**: Comprehensive domain expertise analysis addressing all framework discussion points
-2. **Framework Reference**: Include @../topic-framework.md reference in analysis
+2. **Framework Reference**: Include @../guidance-specification.md reference in analysis
 
 ## Completion Criteria
-- Address each discussion point from topic-framework.md with subject matter expertise
+- Address each discussion point from guidance-specification.md with subject matter expertise
 - Provide actionable technical standards and best practices recommendations
 - Include risk assessment and compliance considerations
 - Reference framework document using @ notation for integration
@@ -116,7 +116,7 @@ TodoWrite({
       activeForm: "Detecting session and framework"
     },
     {
-      content: "Load topic-framework.md and session metadata for context",
+      content: "Load guidance-specification.md and session metadata for context",
       status: "pending",
       activeForm: "Loading framework and session context"
     },
@@ -144,7 +144,7 @@ TodoWrite({
 ### Framework-Based Analysis
 ```
 .workflow/WFS-{session}/.brainstorming/subject-matter-expert/
-└── analysis.md    # Structured analysis addressing topic-framework.md discussion points
+└── analysis.md    # Structured analysis addressing guidance-specification.md discussion points
 ```
 
 ### Analysis Document Structure
@@ -152,11 +152,11 @@ TodoWrite({
 # Subject Matter Expert Analysis: [Topic from Framework]
 
 ## Framework Reference
-**Topic Framework**: @../topic-framework.md
+**Topic Framework**: @../guidance-specification.md
 **Role Focus**: Domain Expertise & Technical Standards perspective
 
 ## Discussion Points Analysis
-[Address each point from topic-framework.md with subject matter expertise]
+[Address each point from guidance-specification.md with subject matter expertise]
 
 ### Core Requirements (from framework)
 [Domain-specific requirements and industry standards perspective]
@@ -189,12 +189,12 @@ TodoWrite({
     "status": "completed",
     "framework_addressed": true,
     "output_location": ".workflow/WFS-{session}/.brainstorming/subject-matter-expert/analysis.md",
-    "framework_reference": "@../topic-framework.md"
+    "framework_reference": "@../guidance-specification.md"
   }
 }
 ```
 
 ### Integration Points
-- **Framework Reference**: @../topic-framework.md for structured discussion points
+- **Framework Reference**: @../guidance-specification.md for structured discussion points
 - **Cross-Role Synthesis**: Domain expertise insights available for synthesis-report.md integration
 - **Agent Autonomy**: Independent execution with framework guidance

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

@@ -1,378 +1,438 @@
 ---
 name: synthesis
-description: Generate synthesis-specification.md from topic-framework and role analyses with @ references using conceptual-planning-agent
+description: Clarify and refine role analyses through intelligent Q&A and targeted updates
 argument-hint: "[optional: --session session-id]"
-allowed-tools: Task(conceptual-planning-agent), TodoWrite(*), Read(*), Write(*)
+allowed-tools: Task(conceptual-planning-agent), TodoWrite(*), Read(*), Write(*), Edit(*), Glob(*)
 ---
 
-## 🧩 **Synthesis Document Generator**
+## Overview
 
-### Core Function
-**Specialized command for generating synthesis-specification.md** that integrates topic-framework.md and all role analysis.md files using @ reference system. Creates comprehensive implementation specification with cross-role insights.
+Three-phase workflow to eliminate ambiguities and enhance conceptual depth in role analyses:
 
-**Dynamic Role Discovery**: Automatically detects which roles participated in brainstorming by scanning for `*/analysis.md` files. Synthesizes only actual participating roles, not predefined lists.
+**Phase 1-2 (Main Flow)**: Session detection → File discovery → Path preparation
 
-### Primary Capabilities
-- **Dynamic Role Discovery**: Automatically identifies participating roles at runtime
-- **Framework Integration**: Reference topic-framework.md discussion points across all discovered roles
-- **Role Analysis Integration**: Consolidate all discovered role/analysis.md files using @ references
-- **Cross-Framework Comparison**: Compare how each participating role addressed framework discussion points
-- **@ Reference System**: Create structured references to source documents
-- **Update Detection**: Smart updates when new role analyses are added
-- **Flexible Participation**: Supports any subset of available roles (1 to 9+)
+**Phase 3A (Analysis Agent)**: Cross-role analysis → Generate recommendations
 
-### Document Integration Model
-**Three-Document Reference System**:
-1. **topic-framework.md** → Structured discussion framework (input)
-2. **[role]/analysis.md** → Role-specific analyses addressing framework (input)
-3. **synthesis-specification.md** → Complete integrated specification (output)
+**Phase 4 (Main Flow)**: User selects enhancements → User answers clarifications → Build update plan
 
-## ⚙️ **Execution Protocol**
+**Phase 5 (Parallel Update Agents)**: Each agent updates ONE role document → Parallel execution
 
-### ⚠️ Agent Execution with Flow Control
-**Execution Model**: Uses conceptual-planning-agent for synthesis generation with structured file loading.
+**Phase 6 (Main Flow)**: Metadata update → Completion report
 
-**Rationale**:
-- **Autonomous Execution**: Agent independently loads and processes all required documents
-- **Flow Control**: Structured document loading ensures systematic analysis
-- **Complex Cognitive Analysis**: Leverages agent's analytical capabilities for cross-role synthesis
-- **Conceptual Focus**: Agent specializes in conceptual analysis and multi-perspective integration
+**Key Features**:
+- Multi-agent architecture (analysis agent + parallel update agents)
+- Clear separation: Agent analysis vs Main flow interaction
+- Parallel document updates (one agent per role)
+- User intent alignment validation
 
-**Agent Responsibility**: All file reading and synthesis generation performed by conceptual-planning-agent with FLOW_CONTROL instructions.
+**Document Flow**:
+- Input: `[role]/analysis*.md`, `guidance-specification.md`, session metadata
+- Output: Updated `[role]/analysis*.md` with Enhancements + Clarifications sections
+
+## Task Tracking
 
-### 📋 Task Tracking Protocol
-Initialize synthesis task tracking using TodoWrite at command start:
 ```json
 [
-  {"content": "Detect active session and validate topic-framework.md existence", "status": "in_progress", "activeForm": "Detecting session and validating framework"},
-  {"content": "Discover participating role analyses dynamically", "status": "pending", "activeForm": "Discovering role analyses"},
-  {"content": "Check existing synthesis and confirm user action", "status": "pending", "activeForm": "Checking update mechanism"},
-  {"content": "Execute synthesis generation using conceptual-planning-agent with FLOW_CONTROL", "status": "pending", "activeForm": "Executing agent-based synthesis generation"},
-  {"content": "Agent performs cross-role analysis and generates synthesis-specification.md", "status": "pending", "activeForm": "Agent analyzing and generating synthesis"},
-  {"content": "Update workflow-session.json with synthesis completion status", "status": "pending", "activeForm": "Updating session metadata"}
+  {"content": "Detect session and validate analyses", "status": "in_progress", "activeForm": "Detecting session"},
+  {"content": "Discover role analysis file paths", "status": "pending", "activeForm": "Discovering paths"},
+  {"content": "Execute analysis agent (cross-role analysis)", "status": "pending", "activeForm": "Executing analysis agent"},
+  {"content": "Present enhancements for user selection", "status": "pending", "activeForm": "Presenting enhancements"},
+  {"content": "Generate and present clarification questions", "status": "pending", "activeForm": "Clarifying with user"},
+  {"content": "Build update plan from user input", "status": "pending", "activeForm": "Building update plan"},
+  {"content": "Execute parallel update agents (one per role)", "status": "pending", "activeForm": "Updating documents in parallel"},
+  {"content": "Update session metadata and generate report", "status": "pending", "activeForm": "Finalizing session"}
 ]
 ```
 
-### Phase 1: Document Discovery & Validation
-```bash
-# Detect active brainstorming session
-IF --session parameter provided:
-    session_id = provided session
-ELSE:
-    CHECK: .workflow/.active-* marker files
-    IF active_session EXISTS:
-        session_id = get_active_session()
-    ELSE:
-        ERROR: "No active brainstorming session found"
-        EXIT
+## Execution Phases
 
-brainstorm_dir = .workflow/WFS-{session}/.brainstorming/
+### Phase 1: Discovery & Validation
 
-# Validate required documents
-CHECK: brainstorm_dir/topic-framework.md
-IF NOT EXISTS:
-    ERROR: "topic-framework.md not found. Run /workflow:brainstorm:artifacts first"
-    EXIT
+1. **Detect Session**: Use `--session` parameter or `.workflow/.active-*` marker
+2. **Validate Files**:
+   - `guidance-specification.md` (optional, warn if missing)
+   - `*/analysis*.md` (required, error if empty)
+3. **Load User Intent**: Extract from `workflow-session.json` (project/description field)
 
-# Load user's original prompt from session metadata
-session_metadata = Read(.workflow/WFS-{session}/workflow-session.json)
-original_user_prompt = session_metadata.project || session_metadata.description
-IF NOT original_user_prompt:
-    WARN: "No original user prompt found in session metadata"
-    original_user_prompt = "Not available"
-```
+### Phase 2: Role Discovery & Path Preparation
 
-### Phase 2: Role Analysis Discovery
-```bash
-# Dynamically discover available role analyses
-SCAN_DIRECTORY: .workflow/WFS-{session}/.brainstorming/
-FIND_ANALYSES: [
-    Scan all subdirectories for */analysis.md files
-    Extract role names from directory names
-]
+**Main flow prepares file paths for Agent**:
 
-# Available roles (for reference, actual participation is dynamic):
-# - product-manager
-# - product-owner
-# - scrum-master
-# - system-architect
-# - ui-designer
-# - ux-expert
-# - data-architect
-# - subject-matter-expert
-# - test-strategist
+1. **Discover Analysis Files**:
+   - Glob(.workflow/WFS-{session}/.brainstorming/*/analysis*.md)
+   - Supports: analysis.md, analysis-1.md, analysis-2.md, analysis-3.md
+   - Validate: At least one file exists (error if empty)
 
-LOAD_DOCUMENTS: {
-    "original_user_prompt": original_user_prompt (from session metadata),
-    "topic_framework": topic-framework.md,
-    "role_analyses": [dynamically discovered analysis.md files],
-    "participating_roles": [extract role names from discovered directories],
-    "existing_synthesis": synthesis-specification.md (if exists)
-}
+2. **Extract Role Information**:
+   - `role_analysis_paths`: Relative paths from brainstorm_dir
+   - `participating_roles`: Role names extracted from directory paths
 
-# Note: Not all roles participate in every brainstorming session
-# Only synthesize roles that actually produced analysis.md files
-# CRITICAL: Original user prompt MUST be primary reference for synthesis
-```
+3. **Pass to Agent** (Phase 3):
+   - `session_id`
+   - `brainstorm_dir`: .workflow/WFS-{session}/.brainstorming/
+   - `role_analysis_paths`: ["product-manager/analysis.md", "system-architect/analysis-1.md", ...]
+   - `participating_roles`: ["product-manager", "system-architect", ...]
 
-### Phase 3: Update Mechanism Check
-```bash
-# Check for existing synthesis
-IF synthesis-specification.md EXISTS:
-    SHOW current synthesis summary to user
-    ASK: "Synthesis exists. Do you want to:"
-    OPTIONS:
-      1. "Regenerate completely" → Create new synthesis
-      2. "Update with new analyses" → Integrate new role analyses
-      3. "Preserve existing" → Exit without changes
-ELSE:
-    CREATE new synthesis
-```
+**Main Flow Responsibility**: File discovery and path preparation only (NO file content reading)
 
-### Phase 4: Agent Execution with Flow Control
-**Synthesis Generation using conceptual-planning-agent**
+### Phase 3A: Analysis & Enhancement Agent
 
-Delegate synthesis generation to conceptual-planning-agent with structured file loading:
+**First agent call**: Cross-role analysis and generate enhancement recommendations
 
 ```bash
 Task(conceptual-planning-agent): "
+## Agent Mission
+Analyze role documents, identify conflicts/gaps, and generate enhancement recommendations
+
+## Input from Main Flow
+- brainstorm_dir: {brainstorm_dir}
+- role_analysis_paths: {role_analysis_paths}
+- participating_roles: {participating_roles}
+
+## Execution Instructions
 [FLOW_CONTROL]
 
-Execute comprehensive synthesis generation from topic framework and role analyses
+### Flow Control Steps
+**AGENT RESPONSIBILITY**: Execute these analysis steps sequentially with context accumulation:
 
-## Context Loading
-OUTPUT_FILE: synthesis-specification.md
-OUTPUT_PATH: .workflow/WFS-{session}/.brainstorming/synthesis-specification.md
-SESSION_ID: {session_id}
-ANALYSIS_MODE: cross_role_synthesis
+1. **load_session_metadata**
+   - Action: Load original user intent as primary reference
+   - Command: Read({brainstorm_dir}/../workflow-session.json)
+   - Output: original_user_intent (from project/description field)
 
-## ⚠️ CRITICAL: User Intent Authority
-**ORIGINAL USER PROMPT IS THE PRIMARY REFERENCE**: {original_user_prompt}
-All synthesis MUST align with user's original intent. Topic framework and role analyses are supplementary context.
+2. **load_role_analyses**
+   - Action: Load all role analysis documents
+   - Command: For each path in role_analysis_paths: Read({brainstorm_dir}/{path})
+   - Output: role_analyses_content_map = {role_name: content}
 
-## Flow Control Steps
-1. **load_original_user_prompt**
-   - Action: Load user's original intent from session metadata
-   - Command: Read(.workflow/WFS-{session}/workflow-session.json)
-   - Extract: project field or description field
-   - Output: original_user_prompt (PRIMARY REFERENCE)
-   - Priority: HIGHEST - This is the authoritative source of user intent
+3. **cross_role_analysis**
+   - Action: Identify consensus themes, conflicts, gaps, underspecified areas
+   - Output: consensus_themes, conflicting_views, gaps_list, ambiguities
 
-2. **load_topic_framework**
-   - Action: Load structured topic discussion framework
-   - Command: Read(.workflow/WFS-{session}/.brainstorming/topic-framework.md)
-   - Output: topic_framework_content
-   - Note: Validate alignment with original_user_prompt
+4. **generate_recommendations**
+   - Action: Convert cross-role analysis findings into structured enhancement recommendations
+   - Format: EP-001, EP-002, ... (sequential numbering)
+   - Fields: id, title, affected_roles, category, current_state, enhancement, rationale, priority
+   - Taxonomy: Map to 9 categories (User Intent, Requirements, Architecture, UX, Feasibility, Risk, Process, Decisions, Terminology)
+   - Output: enhancement_recommendations (JSON array)
 
-3. **discover_role_analyses**
-   - Action: Dynamically discover all participating role analysis files
-   - Command: Glob(.workflow/WFS-{session}/.brainstorming/*/analysis.md)
-   - Output: role_analysis_paths, participating_roles
+### Output to Main Flow
+Return JSON array:
+[
+  {
+    \"id\": \"EP-001\",
+    \"title\": \"API Contract Specification\",
+    \"affected_roles\": [\"system-architect\", \"api-designer\"],
+    \"category\": \"Architecture\",
+    \"current_state\": \"High-level API descriptions\",
+    \"enhancement\": \"Add detailed contract definitions with request/response schemas\",
+    \"rationale\": \"Enables precise implementation and testing\",
+    \"priority\": \"High\"
+  },
+  ...
+]
 
-4. **load_role_analyses**
-   - Action: Load all discovered role analysis documents
-   - Command: Read(each path from role_analysis_paths)
-   - Output: role_analyses_content
-   - Note: Filter insights relevant to original_user_prompt
-
-5. **check_existing_synthesis**
-   - Action: Check if synthesis-specification.md already exists
-   - Command: Read(.workflow/WFS-{session}/.brainstorming/synthesis-specification.md) [if exists]
-   - Output: existing_synthesis_content [optional]
-
-6. **load_synthesis_template**
-   - Action: Load synthesis role template for structure and guidelines
-   - Command: Read(~/.claude/workflows/cli-templates/planning-roles/synthesis-role.md)
-   - Output: synthesis_template_guidelines
-
-## Synthesis Requirements
-
-### ⚠️ PRIMARY REQUIREMENT: User Intent Alignment
-**User's Original Goal is Supreme**: Synthesis MUST directly address {original_user_prompt}
-**Intent Validation**: Every requirement, design decision, and recommendation must trace back to user's original intent
-**Deviation Detection**: Flag any role analysis points that drift from user's stated goals
-**Refocus Mechanism**: When role discussions diverge, explicitly refocus on original user prompt
-**Traceability**: Each section should reference how it fulfills user's original intent
-
-### Core Integration
-**Cross-Role Analysis**: Integrate all discovered role analyses with comprehensive coverage
-**Framework Integration**: Address how each role responded to topic-framework.md discussion points
-**User Intent Filter**: Prioritize insights that directly serve user's original prompt
-**Decision Transparency**: Document both adopted solutions and rejected alternatives with rationale
-**Process Integration**: Include team capability gaps, process risks, and collaboration patterns
-**Visual Documentation**: Include key diagrams (architecture, data model, user journey) via Mermaid
-**Priority Matrix**: Create quantified recommendation matrix aligned with user's goals
-**Actionable Plan**: Provide phased implementation roadmap addressing user's original objectives
-
-### Cross-Role Analysis Process (Agent Internal Execution)
-Perform systematic cross-role analysis following these steps:
-
-1. **Data Collection**: Extract key insights, recommendations, concerns, and diagrams from each discovered role analysis
-2. **Consensus Identification**: Identify common themes and agreement areas across all participating roles
-3. **Disagreement Analysis**: Document conflicting views and track which specific roles disagree on each point
-4. **Innovation Extraction**: Identify breakthrough ideas and cross-role synergy opportunities
-5. **Priority Scoring**: Calculate multi-dimensional priority scores (impact, feasibility, effort, risk) for each recommendation
-6. **Decision Matrix**: Create comprehensive evaluation matrix and sort recommendations by priority
-
-## Synthesis Quality Standards
-Follow synthesis-specification.md structure defined in synthesis-role.md template:
-- Use template structure for comprehensive document organization
-- Apply analysis guidelines for cross-role synthesis process
-- Include all required sections from template (Executive Summary, Key Designs, Requirements, etc.)
-- Follow @ reference system for traceability to source role analyses
-- Apply quality standards from template (completeness, visual clarity, decision transparency)
-- Validate output against template's output validation checklist
-
-## Expected Deliverables
-1. **synthesis-specification.md**: Complete integrated specification consolidating all role perspectives
-2. **@ References**: Include cross-references to source role analyses
-3. **Session Metadata Update**: Update workflow-session.json with synthesis completion status
-
-## Completion Criteria
-- ⚠️ **USER INTENT ALIGNMENT**: Synthesis directly addresses user's original prompt
-- All discovered role analyses integrated without gaps
-- Framework discussion points addressed across all roles
-- **Intent traceability**: Each major section references user's original goals
-- Controversial points documented with dissenting roles identified
-- Process concerns (team capabilities, risks, collaboration) captured
-- Quantified priority recommendations aligned with user's objectives
-- Actionable implementation plan addressing user's stated goals
-- Comprehensive risk assessment with mitigation strategies
-- **Deviation warnings**: Any significant departures from user intent flagged explicitly
-
-## Execution Notes
-- Dynamic role participation: Only synthesize roles that produced analysis.md files
-- Update mechanism: If synthesis exists, prompt user for regenerate/update/preserve decision
-- Timeout allocation: Complex synthesis task (60-90 min recommended)
-- Reference @intelligent-tools-strategy.md for timeout guidelines
 "
 ```
 
-## 📊 **Output Specification**
+### Phase 4: Main Flow User Interaction
 
-### Output Location
-The synthesis process creates **one consolidated document** that integrates all role perspectives:
+**Main flow handles all user interaction via text output**:
 
-```
-.workflow/WFS-{topic-slug}/.brainstorming/
-├── topic-framework.md          # Input: Framework structure
-├── [role]/analysis.md          # Input: Role analyses (multiple)
-└── synthesis-specification.md  # ★ OUTPUT: Complete integrated specification
+**⚠️ 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）：
 ```
 
-#### synthesis-specification.md Structure
+2. **Generate Clarification Questions** (based on analysis agent output):
+   - ✅ **ALL questions in Chinese (所有问题必须用中文)**
+   - Use 9-category taxonomy scan results
+   - Prioritize most critical questions (no hard limit)
+   - Each with 2-4 options + descriptions
 
-**Document Purpose**: Defines **"WHAT"** to build - comprehensive requirements and design blueprint.
-**Scope**: High-level features, requirements, and design specifications. Does NOT include executable task breakdown (that's IMPL_PLAN.md's responsibility).
+3. **Interactive Clarification Loop** (max 10 questions per round):
+```markdown
+===== Clarification 问题 (第 1/2 轮) =====
 
-**Template Reference**: Complete document structure and content guidelines available in `synthesis-role.md` template, including:
-- Executive Summary with strategic overview
-- Key Designs & Decisions (architecture diagrams, ADRs, user journeys)
-- Controversial Points & Alternatives (decision transparency)
-- Requirements & Acceptance Criteria (Functional, Non-Functional, Business)
-- Design Specifications (UI/UX, Architecture, Domain Expertise)
-- Process & Collaboration Concerns (team skills, risks, patterns, constraints)
-- Implementation Roadmap (high-level phases)
-- Risk Assessment & Mitigation strategies
+【问题1 - 用户意图】MVP 阶段的核心目标是什么？
+a) 快速验证市场需求
+   说明：最小功能集，快速上线获取反馈
+b) 建立技术壁垒
+   说明：完善架构，为长期发展打基础
+c) 实现功能完整性
+   说明：覆盖所有规划功能，延迟上线
 
-**Agent Usage**: The conceptual-planning-agent loads this template to understand expected structure and quality standards.
+【问题2 - 架构决策】技术栈选择的优先考虑因素？
+a) 团队熟悉度
+   说明：使用现有技术栈，降低学习成本
+b) 技术先进性
+   说明：采用新技术，提升竞争力
+c) 生态成熟度
+   说明：选择成熟方案，保证稳定性
 
-## 🔄 **Session Integration**
+...（最多10个问题）
 
-### Streamlined Status Synchronization
-Upon completion, update `workflow-session.json`:
+请回答 (格式: 1a 2b 3c...)：
+```
 
-**Dynamic Role Participation**: The `participating_roles` and `roles_synthesized` values are determined at runtime based on actual analysis.md files discovered.
+Wait for user input → Parse all answers in batch → Continue to next round if needed
 
+4. **Build Update Plan**:
+```
+update_plan = {
+  "role1": {
+    "enhancements": [EP-001, EP-003],
+    "clarifications": [
+      {"question": "...", "answer": "...", "category": "..."},
+      ...
+    ]
+  },
+  "role2": {
+    "enhancements": [EP-002],
+    "clarifications": [...]
+  },
+  ...
+}
+```
+
+### Phase 5: Parallel Document Update Agents
+
+**Parallel agent calls** (one per role needing updates):
+
+```bash
+# Execute in parallel using single message with multiple Task calls
+
+Task(conceptual-planning-agent): "
+## Agent Mission
+Apply user-confirmed enhancements and clarifications to {role1} analysis document
+
+## Agent Intent
+- **Goal**: Integrate synthesis results into role-specific analysis
+- **Scope**: Update ONLY {role1}/analysis.md (isolated, no cross-role dependencies)
+- **Constraints**: Preserve original insights, add refinements without deletion
+
+## Input from Main Flow
+- role: {role1}
+- analysis_path: {brainstorm_dir}/{role1}/analysis.md
+- enhancements: [EP-001, EP-003] (user-selected improvements)
+- clarifications: [{question, answer, category}, ...] (user-confirmed answers)
+- original_user_intent: {from session metadata}
+
+## Execution Instructions
+[FLOW_CONTROL]
+
+### Flow Control Steps
+**AGENT RESPONSIBILITY**: Execute these update steps sequentially:
+
+1. **load_current_analysis**
+   - Action: Load existing role analysis document
+   - Command: Read({brainstorm_dir}/{role1}/analysis.md)
+   - Output: current_analysis_content
+
+2. **add_clarifications_section**
+   - Action: Insert Clarifications section with Q&A
+   - Format: \"## Clarifications\\n### Session {date}\\n- **Q**: {question} (Category: {category})\\n  **A**: {answer}\"
+   - Output: analysis_with_clarifications
+
+3. **apply_enhancements**
+   - Action: Integrate EP-001, EP-003 into relevant sections
+   - Strategy: Locate section by category (Architecture → Architecture section, UX → User Experience section)
+   - Output: analysis_with_enhancements
+
+4. **resolve_contradictions**
+   - Action: Remove conflicts between original content and clarifications/enhancements
+   - Output: contradiction_free_analysis
+
+5. **enforce_terminology_consistency**
+   - Action: Align all terminology with user-confirmed choices from clarifications
+   - Output: terminology_consistent_analysis
+
+6. **validate_user_intent_alignment**
+   - Action: Verify all updates support original_user_intent
+   - Output: validated_analysis
+
+7. **write_updated_file**
+   - Action: Save final analysis document
+   - Command: Write({brainstorm_dir}/{role1}/analysis.md, validated_analysis)
+   - Output: File update confirmation
+
+### Output
+Updated {role1}/analysis.md with Clarifications section + enhanced content
+")
+
+Task(conceptual-planning-agent): "
+## Agent Mission
+Apply user-confirmed enhancements and clarifications to {role2} analysis document
+
+## Agent Intent
+- **Goal**: Integrate synthesis results into role-specific analysis
+- **Scope**: Update ONLY {role2}/analysis.md (isolated, no cross-role dependencies)
+- **Constraints**: Preserve original insights, add refinements without deletion
+
+## Input from Main Flow
+- role: {role2}
+- analysis_path: {brainstorm_dir}/{role2}/analysis.md
+- enhancements: [EP-002] (user-selected improvements)
+- clarifications: [{question, answer, category}, ...] (user-confirmed answers)
+- original_user_intent: {from session metadata}
+
+## Execution Instructions
+[FLOW_CONTROL]
+
+### Flow Control Steps
+**AGENT RESPONSIBILITY**: Execute same 7 update steps as {role1} agent (load → clarifications → enhancements → contradictions → terminology → validation → write)
+
+### Output
+Updated {role2}/analysis.md with Clarifications section + enhanced content
+")
+
+# ... repeat for each role in update_plan
+```
+
+**Agent Characteristics**:
+- **Intent**: Integrate user-confirmed synthesis results (NOT generate new analysis)
+- **Isolation**: Each agent updates exactly ONE role (parallel execution safe)
+- **Context**: Minimal - receives only role-specific enhancements + clarifications
+- **Dependencies**: Zero cross-agent dependencies (full parallelism)
+- **Validation**: All updates must align with original_user_intent
+
+### Phase 6: Completion & Metadata Update
+
+**Main flow finalizes**:
+
+1. Wait for all parallel agents to complete
+2. Update workflow-session.json:
 ```json
 {
   "phases": {
     "BRAINSTORM": {
-      "status": "completed",
-      "synthesis_completed": true,
+      "status": "clarification_completed",
+      "clarification_completed": true,
       "completed_at": "timestamp",
-      "participating_roles": ["<dynamically-discovered-role-1>", "<dynamically-discovered-role-2>", "..."],
-      "available_roles": ["product-manager", "product-owner", "scrum-master", "system-architect", "ui-designer", "ux-expert", "data-architect", "subject-matter-expert", "test-strategist"],
-      "consolidated_output": {
-        "synthesis_specification": ".workflow/WFS-{topic}/.brainstorming/synthesis-specification.md"
+      "participating_roles": [...],
+      "clarification_results": {
+        "enhancements_applied": ["EP-001", "EP-002", ...],
+        "questions_asked": 3,
+        "categories_clarified": ["Architecture", "UX", ...],
+        "roles_updated": ["role1", "role2", ...],
+        "outstanding_items": []
       },
-      "synthesis_quality": {
-        "role_integration": "complete",
+      "quality_metrics": {
+        "user_intent_alignment": "validated",
         "requirement_coverage": "comprehensive",
-        "decision_transparency": "alternatives_documented",
-        "process_risks_identified": true,
-        "implementation_readiness": "ready"
-      },
-      "content_metrics": {
-        "roles_synthesized": "<COUNT(participating_roles)>",
-        "functional_requirements": "<dynamic-count>",
-        "non_functional_requirements": "<dynamic-count>",
-        "business_requirements": "<dynamic-count>",
-        "architecture_decisions": "<dynamic-count>",
-        "controversial_points": "<dynamic-count>",
-        "diagrams_included": "<dynamic-count>",
-        "process_risks": "<dynamic-count>",
-        "team_skill_gaps": "<dynamic-count>",
-        "implementation_phases": "<dynamic-count>",
-        "risk_factors_identified": "<dynamic-count>"
+        "ambiguity_resolution": "complete",
+        "terminology_consistency": "enforced"
       }
     }
   }
 }
 ```
 
-**Example with actual values**:
+3. Generate completion report (show to user):
+```markdown
+## ✅ Clarification Complete
+
+**Enhancements Applied**: EP-001, EP-002, EP-003
+**Questions Answered**: 3/5
+**Roles Updated**: role1, role2, role3
+
+### Next Steps
+✅ PROCEED: `/workflow:plan --session WFS-{session-id}`
+```
+
+## Output
+
+**Location**: `.workflow/WFS-{session}/.brainstorming/[role]/analysis*.md` (in-place updates)
+
+**Updated Structure**:
+```markdown
+## Clarifications
+### Session {date}
+- **Q**: {question} (Category: {category})
+  **A**: {answer}
+
+## {Existing Sections}
+{Refined content based on clarifications}
+```
+
+**Changes**:
+- User intent validated/corrected
+- Requirements more specific/measurable
+- Architecture with rationale
+- Ambiguities resolved, placeholders removed
+- Consistent terminology
+
+## Session Metadata
+
+Update `workflow-session.json`:
+
 ```json
 {
   "phases": {
     "BRAINSTORM": {
-      "status": "completed",
-      "participating_roles": ["product-manager", "system-architect", "ui-designer", "ux-expert", "scrum-master"],
-      "content_metrics": {
-        "roles_synthesized": 5,
-        "functional_requirements": 18,
-        "controversial_points": 2
+      "status": "clarification_completed",
+      "clarification_completed": true,
+      "completed_at": "timestamp",
+      "participating_roles": ["product-manager", "system-architect", ...],
+      "clarification_results": {
+        "questions_asked": 3,
+        "categories_clarified": ["Architecture & Design", ...],
+        "roles_updated": ["system-architect", "ui-designer", ...],
+        "outstanding_items": []
+      },
+      "quality_metrics": {
+        "user_intent_alignment": "validated",
+        "requirement_coverage": "comprehensive",
+        "ambiguity_resolution": "complete",
+        "terminology_consistency": "enforced",
+        "decision_transparency": "documented"
       }
     }
   }
 }
 ```
 
-## ✅ **Quality Assurance**
+## Quality Checklist
 
-Verify synthesis output meets these standards (detailed criteria in `synthesis-role.md` template):
+**Content**:
+- All role analyses loaded/analyzed
+- Cross-role analysis (consensus, conflicts, gaps)
+- 9-category ambiguity scan
+- Questions prioritized
+- Clarifications documented
 
-### Content Completeness
-- [ ] All discovered role analyses integrated without gaps
-- [ ] Key designs documented (architecture diagrams, ADRs, user journeys via Mermaid)
-- [ ] Controversial points captured with alternatives and rationale
-- [ ] Process concerns included (team skills, risks, collaboration patterns)
-- [ ] Requirements documented (Functional, Non-Functional, Business) with sources
+**Analysis**:
+- User intent validated
+- Cross-role synthesis complete
+- Ambiguities resolved
+- Correct roles updated
+- Terminology consistent
+- Contradictions removed
 
-### Analysis Quality
-- [ ] Cross-role synthesis identifies consensus and conflicts
-- [ ] Decision transparency documents both adopted and rejected alternatives
-- [ ] Priority recommendations with multi-dimensional evaluation
-- [ ] Implementation roadmap with phased approach
-- [ ] Risk assessment with mitigation strategies
-- [ ] @ references to source role analyses throughout
+**Documents**:
+- Clarifications section formatted
+- Sections reflect answers
+- No placeholders (TODO/TBD)
+- Valid Markdown
+- Cross-references maintained
 
-## 🚀 **Recommended Next Steps**
 
-After synthesis completion, proceed to action planning:
-
-### Standard Workflow (Recommended)
-```bash
-/workflow:concept-clarify --session WFS-{session-id}  # Optional: Clarify ambiguities
-/workflow:plan --session WFS-{session-id}             # Generate IMPL_PLAN.md and tasks
-/workflow:action-plan-verify --session WFS-{session-id}  # Optional: Verify plan quality
-/workflow:execute --session WFS-{session-id}          # Start implementation
-```
-
-### TDD Workflow
-```bash
-/workflow:concept-clarify --session WFS-{session-id}  # Optional: Clarify ambiguities
-/workflow:tdd-plan --session WFS-{session-id} "Feature description"
-/workflow:action-plan-verify --session WFS-{session-id}  # Optional: Verify plan quality
-/workflow:execute --session WFS-{session-id}
-```

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

@@ -1,6 +1,6 @@
 ---
 name: system-architect
-description: Generate or update system-architect/analysis.md addressing topic-framework discussion points
+description: Generate or update system-architect/analysis.md addressing guidance-specification discussion points
 argument-hint: "optional topic - uses existing framework if available"
 allowed-tools: Task(conceptual-planning-agent), TodoWrite(*), Read(*), Write(*)
 ---
@@ -8,10 +8,10 @@ allowed-tools: Task(conceptual-planning-agent), TodoWrite(*), Read(*), Write(*)
 ## 🏗️ **System Architect Analysis Generator**
 
 ### Purpose
-**Specialized command for generating system-architect/analysis.md** that addresses topic-framework.md discussion points from system architecture perspective. Creates or updates role-specific analysis with framework references.
+**Specialized command for generating system-architect/analysis.md** that addresses guidance-specification.md discussion points from system architecture perspective. Creates or updates role-specific analysis with framework references.
 
 ### Core Function
-- **Framework-based Analysis**: Address each discussion point in topic-framework.md
+- **Framework-based Analysis**: Address each discussion point in guidance-specification.md
 - **Architecture Focus**: Technical architecture, scalability, and system design perspective
 - **Update Mechanism**: Create new or update existing analysis.md
 - **Agent Delegation**: Use conceptual-planning-agent for analysis generation
@@ -51,7 +51,7 @@ IF active_session EXISTS:
     session_id = get_active_session()
     brainstorm_dir = .workflow/WFS-{session}/.brainstorming/
 
-    CHECK: brainstorm_dir/topic-framework.md
+    CHECK: brainstorm_dir/guidance-specification.md
     IF EXISTS:
         framework_mode = true
         load_framework = true
@@ -78,20 +78,20 @@ ELSE:
 ```
 
 ### Phase 3: Agent Task Generation
-**Framework-Based Analysis** (when topic-framework.md exists):
+**Framework-Based Analysis** (when guidance-specification.md exists):
 ```bash
 Task(subagent_type="conceptual-planning-agent",
      prompt="Generate system architect analysis addressing topic framework
 
      ## Framework Integration Required
-     **MANDATORY**: Load and address topic-framework.md discussion points
-     **Framework Reference**: @{session.brainstorm_dir}/topic-framework.md
+     **MANDATORY**: Load and address guidance-specification.md discussion points
+     **Framework Reference**: @{session.brainstorm_dir}/guidance-specification.md
      **Output Location**: {session.brainstorm_dir}/system-architect/analysis.md
 
      ## Analysis Requirements
-     1. **Load Topic Framework**: Read topic-framework.md completely
+     1. **Load Topic Framework**: Read guidance-specification.md completely
      2. **Address Each Discussion Point**: Respond to all 5 framework sections from system architecture perspective
-     3. **Include Framework Reference**: Start analysis.md with @../topic-framework.md
+     3. **Include Framework Reference**: Start analysis.md with @../guidance-specification.md
      4. **Technical Focus**: Emphasize scalability, architecture patterns, technology decisions
      5. **Structured Response**: Use framework structure for analysis organization
 
@@ -106,7 +106,7 @@ Task(subagent_type="conceptual-planning-agent",
      ```markdown
      # System Architect Analysis: [Topic]
 
-     **Framework Reference**: @../topic-framework.md
+     **Framework Reference**: @../guidance-specification.md
      **Role Focus**: System Architecture and Technical Design
 
      ## Core Requirements Analysis
@@ -140,14 +140,14 @@ IF update_mode = "incremental":
 
          ## Current Analysis Context
          **Existing Analysis**: @{session.brainstorm_dir}/system-architect/analysis.md
-         **Framework Reference**: @{session.brainstorm_dir}/topic-framework.md
+         **Framework Reference**: @{session.brainstorm_dir}/guidance-specification.md
 
          ## Update Requirements
          1. **Preserve Structure**: Maintain existing analysis structure
          2. **Add New Insights**: Integrate new technical insights and recommendations
          3. **Framework Alignment**: Ensure continued alignment with topic framework
          4. **Technical Updates**: Add new architecture patterns, technology considerations
-         5. **Maintain References**: Keep @../topic-framework.md reference
+         5. **Maintain References**: Keep @../guidance-specification.md reference
 
          ## Update Instructions
          - Read existing analysis completely
@@ -163,14 +163,14 @@ IF update_mode = "incremental":
 ### Output Files
 ```
 .workflow/WFS-[topic]/.brainstorming/
-├── topic-framework.md          # Input: Framework (if exists)
+├── guidance-specification.md          # Input: Framework (if exists)
 └── system-architect/
     └── analysis.md            # ★ OUTPUT: Framework-based analysis
 ```
 
 ### Analysis Structure
 **Required Elements**:
-- **Framework Reference**: @../topic-framework.md (if framework exists)
+- **Framework Reference**: @../guidance-specification.md (if framework exists)
 - **Role Focus**: System Architecture and Technical Design perspective
 - **5 Framework Sections**: Address each framework discussion point
 - **Technical Recommendations**: Architecture-specific insights and solutions

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

@@ -1,6 +1,6 @@
 ---
 name: ui-designer
-description: Generate or update ui-designer/analysis.md addressing topic-framework discussion points
+description: Generate or update ui-designer/analysis.md addressing guidance-specification discussion points
 argument-hint: "optional topic - uses existing framework if available"
 allowed-tools: Task(conceptual-planning-agent), TodoWrite(*), Read(*), Write(*)
 ---
@@ -8,10 +8,10 @@ allowed-tools: Task(conceptual-planning-agent), TodoWrite(*), Read(*), Write(*)
 ## 🎨 **UI Designer Analysis Generator**
 
 ### Purpose
-**Specialized command for generating ui-designer/analysis.md** that addresses topic-framework.md discussion points from UI/UX design perspective. Creates or updates role-specific analysis with framework references.
+**Specialized command for generating ui-designer/analysis.md** that addresses guidance-specification.md discussion points from UI/UX design perspective. Creates or updates role-specific analysis with framework references.
 
 ### Core Function
-- **Framework-based Analysis**: Address each discussion point in topic-framework.md
+- **Framework-based Analysis**: Address each discussion point in guidance-specification.md
 - **UI/UX Focus**: User experience, interface design, and accessibility perspective
 - **Update Mechanism**: Create new or update existing analysis.md
 - **Agent Delegation**: Use conceptual-planning-agent for analysis generation
@@ -53,7 +53,7 @@ IF active_session EXISTS:
     session_id = get_active_session()
     brainstorm_dir = .workflow/WFS-{session}/.brainstorming/
 
-    CHECK: brainstorm_dir/topic-framework.md
+    CHECK: brainstorm_dir/guidance-specification.md
     IF EXISTS:
         framework_mode = true
         load_framework = true
@@ -94,7 +94,7 @@ ANALYSIS_MODE: {framework_mode ? "framework_based" : "standalone"}
 ## Flow Control Steps
 1. **load_topic_framework**
    - Action: Load structured topic discussion framework
-   - Command: Read(.workflow/WFS-{session}/.brainstorming/topic-framework.md)
+   - Command: Read(.workflow/WFS-{session}/.brainstorming/guidance-specification.md)
    - Output: topic_framework_content
 
 2. **load_role_template**
@@ -108,17 +108,17 @@ ANALYSIS_MODE: {framework_mode ? "framework_based" : "standalone"}
    - Output: session_context
 
 ## Analysis Requirements
-**Framework Reference**: Address all discussion points in topic-framework.md from UI/UX perspective
+**Framework Reference**: Address all discussion points in guidance-specification.md from UI/UX perspective
 **Role Focus**: User experience design, interface optimization, accessibility compliance
 **Structured Approach**: Create analysis.md addressing framework discussion points
 **Template Integration**: Apply role template guidelines within framework structure
 
 ## Expected Deliverables
 1. **analysis.md**: Comprehensive UI/UX analysis addressing all framework discussion points
-2. **Framework Reference**: Include @../topic-framework.md reference in analysis
+2. **Framework Reference**: Include @../guidance-specification.md reference in analysis
 
 ## Completion Criteria
-- Address each discussion point from topic-framework.md with UI/UX design expertise
+- Address each discussion point from guidance-specification.md with UI/UX design expertise
 - Provide actionable design recommendations and interface solutions
 - Include accessibility considerations and WCAG compliance planning
 - Reference framework document using @ notation for integration
@@ -137,7 +137,7 @@ TodoWrite({
       activeForm: "Detecting session and framework"
     },
     {
-      content: "Load topic-framework.md and session metadata for context",
+      content: "Load guidance-specification.md and session metadata for context",
       status: "pending",
       activeForm: "Loading framework and session context"
     },
@@ -165,7 +165,7 @@ TodoWrite({
 ### Framework-Based Analysis
 ```
 .workflow/WFS-{session}/.brainstorming/ui-designer/
-└── analysis.md    # Structured analysis addressing topic-framework.md discussion points
+└── analysis.md    # Structured analysis addressing guidance-specification.md discussion points
 ```
 
 ### Analysis Document Structure
@@ -173,11 +173,11 @@ TodoWrite({
 # UI Designer Analysis: [Topic from Framework]
 
 ## Framework Reference
-**Topic Framework**: @../topic-framework.md
+**Topic Framework**: @../guidance-specification.md
 **Role Focus**: UI/UX Design perspective
 
 ## Discussion Points Analysis
-[Address each point from topic-framework.md with UI/UX expertise]
+[Address each point from guidance-specification.md with UI/UX expertise]
 
 ### Core Requirements (from framework)
 [UI/UX perspective on requirements]
@@ -210,12 +210,12 @@ TodoWrite({
     "status": "completed",
     "framework_addressed": true,
     "output_location": ".workflow/WFS-{session}/.brainstorming/ui-designer/analysis.md",
-    "framework_reference": "@../topic-framework.md"
+    "framework_reference": "@../guidance-specification.md"
   }
 }
 ```
 
 ### Integration Points
-- **Framework Reference**: @../topic-framework.md for structured discussion points
+- **Framework Reference**: @../guidance-specification.md for structured discussion points
 - **Cross-Role Synthesis**: UI/UX insights available for synthesis-report.md integration
 - **Agent Autonomy**: Independent execution with framework guidance

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

@@ -1,6 +1,6 @@
 ---
 name: ux-expert
-description: Generate or update ux-expert/analysis.md addressing topic-framework discussion points
+description: Generate or update ux-expert/analysis.md addressing guidance-specification discussion points
 argument-hint: "optional topic - uses existing framework if available"
 allowed-tools: Task(conceptual-planning-agent), TodoWrite(*), Read(*), Write(*)
 ---
@@ -8,10 +8,10 @@ allowed-tools: Task(conceptual-planning-agent), TodoWrite(*), Read(*), Write(*)
 ## 🎯 **UX Expert Analysis Generator**
 
 ### Purpose
-**Specialized command for generating ux-expert/analysis.md** that addresses topic-framework.md discussion points from user experience and interface design perspective. Creates or updates role-specific analysis with framework references.
+**Specialized command for generating ux-expert/analysis.md** that addresses guidance-specification.md discussion points from user experience and interface design perspective. Creates or updates role-specific analysis with framework references.
 
 ### Core Function
-- **Framework-based Analysis**: Address each discussion point in topic-framework.md
+- **Framework-based Analysis**: Address each discussion point in guidance-specification.md
 - **UX Design Focus**: User interface, interaction patterns, and usability optimization
 - **Update Mechanism**: Create new or update existing analysis.md
 - **Agent Delegation**: Use conceptual-planning-agent for analysis generation
@@ -53,7 +53,7 @@ IF active_session EXISTS:
     session_id = get_active_session()
     brainstorm_dir = .workflow/WFS-{session}/.brainstorming/
 
-    CHECK: brainstorm_dir/topic-framework.md
+    CHECK: brainstorm_dir/guidance-specification.md
     IF EXISTS:
         framework_mode = true
         load_framework = true
@@ -94,7 +94,7 @@ ANALYSIS_MODE: {framework_mode ? "framework_based" : "standalone"}
 ## Flow Control Steps
 1. **load_topic_framework**
    - Action: Load structured topic discussion framework
-   - Command: Read(.workflow/WFS-{session}/.brainstorming/topic-framework.md)
+   - Command: Read(.workflow/WFS-{session}/.brainstorming/guidance-specification.md)
    - Output: topic_framework_content
 
 2. **load_role_template**
@@ -108,17 +108,17 @@ ANALYSIS_MODE: {framework_mode ? "framework_based" : "standalone"}
    - Output: session_context
 
 ## Analysis Requirements
-**Framework Reference**: Address all discussion points in topic-framework.md from user experience and interface design perspective
+**Framework Reference**: Address all discussion points in guidance-specification.md from user experience and interface design perspective
 **Role Focus**: UI design, interaction patterns, usability optimization, design systems
 **Structured Approach**: Create analysis.md addressing framework discussion points
 **Template Integration**: Apply role template guidelines within framework structure
 
 ## Expected Deliverables
 1. **analysis.md**: Comprehensive UX design analysis addressing all framework discussion points
-2. **Framework Reference**: Include @../topic-framework.md reference in analysis
+2. **Framework Reference**: Include @../guidance-specification.md reference in analysis
 
 ## Completion Criteria
-- Address each discussion point from topic-framework.md with UX design expertise
+- Address each discussion point from guidance-specification.md with UX design expertise
 - Provide actionable interface design and usability optimization strategies
 - Include accessibility considerations and interaction pattern recommendations
 - Reference framework document using @ notation for integration
@@ -137,7 +137,7 @@ TodoWrite({
       activeForm: "Detecting session and framework"
     },
     {
-      content: "Load topic-framework.md and session metadata for context",
+      content: "Load guidance-specification.md and session metadata for context",
       status: "pending",
       activeForm: "Loading framework and session context"
     },
@@ -165,7 +165,7 @@ TodoWrite({
 ### Framework-Based Analysis
 ```
 .workflow/WFS-{session}/.brainstorming/ux-expert/
-└── analysis.md    # Structured analysis addressing topic-framework.md discussion points
+└── analysis.md    # Structured analysis addressing guidance-specification.md discussion points
 ```
 
 ### Analysis Document Structure
@@ -173,11 +173,11 @@ TodoWrite({
 # UX Expert Analysis: [Topic from Framework]
 
 ## Framework Reference
-**Topic Framework**: @../topic-framework.md
+**Topic Framework**: @../guidance-specification.md
 **Role Focus**: User Experience & Interface Design perspective
 
 ## Discussion Points Analysis
-[Address each point from topic-framework.md with UX design expertise]
+[Address each point from guidance-specification.md with UX design expertise]
 
 ### Core Requirements (from framework)
 [User interface and interaction design requirements perspective]
@@ -210,12 +210,12 @@ TodoWrite({
     "status": "completed",
     "framework_addressed": true,
     "output_location": ".workflow/WFS-{session}/.brainstorming/ux-expert/analysis.md",
-    "framework_reference": "@../topic-framework.md"
+    "framework_reference": "@../guidance-specification.md"
   }
 }
 ```
 
 ### Integration Points
-- **Framework Reference**: @../topic-framework.md for structured discussion points
+- **Framework Reference**: @../guidance-specification.md for structured discussion points
 - **Cross-Role Synthesis**: UX design insights available for synthesis-report.md integration
 - **Agent Autonomy**: Independent execution with framework guidance

.claude/commands/workflow/concept-clarify.md

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

.claude/commands/workflow/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,18 +404,19 @@ 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:
 
 #### Context Sources (Priority Order)
 1. **Complete Task JSON**: Full task definition including all fields and artifacts
-2. **Artifacts Context**: Brainstorming outputs and synthesis specifications from task.context.artifacts
+2. **Artifacts Context**: Brainstorming outputs and role analysess from task.context.artifacts
 3. **Flow Control Context**: Accumulated outputs from pre_analysis steps (including artifact loading)
 4. **Dependency Summaries**: Previous task completion summaries
 5. **Session Context**: Workflow paths and session metadata
@@ -370,10 +437,10 @@ TodoWrite({
 {
   "task": { /* Complete task JSON with artifacts array */ },
   "artifacts": {
-    "synthesis_specification": { "path": ".workflow/WFS-session/.brainstorming/synthesis-specification.md", "priority": "highest" },
-    "topic_framework": { "path": ".workflow/WFS-session/.brainstorming/topic-framework.md", "priority": "medium" },
-    "role_analyses": [ /* Individual role analysis files */ ],
-    "available_artifacts": [ /* All detected brainstorming artifacts */ ]
+    "synthesis_specification": { "path": "{{from context-package.json → brainstorm_artifacts.synthesis_output.path}}", "priority": "highest" },
+    "guidance_specification": { "path": "{{from context-package.json → brainstorm_artifacts.guidance_specification.path}}", "priority": "medium" },
+    "role_analyses": [ /* From context-package.json → brainstorm_artifacts.role_analyses[] */ ],
+    "conflict_resolution": { "path": "{{from context-package.json → brainstorm_artifacts.conflict_resolution.path}}", "conditional": true }
   },
   "flow_context": {
     "step_outputs": {
@@ -385,7 +452,7 @@ TodoWrite({
   },
   "session": {
     "workflow_dir": ".workflow/WFS-session/",
-    "brainstorming_dir": ".workflow/WFS-session/.brainstorming/",
+    "context_package_path": ".workflow/WFS-session/.process/context-package.json",
     "todo_list_path": ".workflow/WFS-session/TODO_LIST.md",
     "summaries_dir": ".workflow/WFS-session/.summaries/",
     "task_json_path": ".workflow/WFS-session/.task/IMPL-1.1.json"
@@ -397,10 +464,10 @@ TodoWrite({
 
 #### Context Validation Rules
 - **Task JSON Complete**: All 5 fields present and valid, including artifacts array in context
-- **Artifacts Available**: Synthesis specifications and brainstorming outputs accessible
+- **Artifacts Available**: All artifacts loaded from context-package.json
 - **Flow Control Ready**: All pre_analysis steps completed including artifact loading steps
 - **Dependencies Loaded**: All depends_on summaries available
-- **Session Paths Valid**: All workflow paths exist and accessible, including .brainstorming directory
+- **Session Paths Valid**: All workflow paths exist and accessible (verified via context-package.json)
 - **Agent Assignment**: Valid agent type specified in meta.agent
 
 ### 4. Agent Execution Pattern
@@ -417,13 +484,13 @@ Task(subagent_type="{meta.agent}",
      ## Instructions
      1. **Load Complete Task JSON**: Read and validate all fields (id, title, status, meta, context, flow_control)
      2. **Execute Flow Control**: If `flow_control.pre_analysis` exists, execute steps sequentially:
-        - Load artifacts (synthesis-specification.md, role analyses) using commands in each step
+        - Load artifacts (role analysis documents, role analyses) using commands in each step
         - Accumulate context from step outputs using variable substitution [variable_name]
         - Handle errors per step.on_error (skip_optional | fail | retry_once)
      3. **Implement Solution**: Follow `flow_control.implementation_approach` using accumulated context
      4. **Complete Task**:
         - Update task status: `jq '.status = \"completed\"' {session.task_json_path} > temp.json && mv temp.json {session.task_json_path}`
-        - Update TODO list: {session.todo_list_path}
+        - 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
 
@@ -466,7 +533,7 @@ Task(subagent_type="{meta.agent}",
   "status": "pending|active|completed|blocked",
   "meta": {
     "type": "feature|bugfix|refactor|test-gen|test-fix|docs",
-    "agent": "@code-developer|@test-fix-agent|@general-purpose"
+    "agent": "@code-developer|@test-fix-agent|@universal-executor"
   },
   "context": {
     "requirements": ["req1", "req2"],
@@ -477,15 +544,16 @@ Task(subagent_type="{meta.agent}",
     "artifacts": [
       {
         "type": "synthesis_specification",
-        "source": "brainstorm_synthesis",
-        "path": ".workflow/WFS-[session]/.brainstorming/synthesis-specification.md",
+        "source": "context-package.json → brainstorm_artifacts.synthesis_output",
+        "path": "{{loaded dynamically from context-package.json}}",
         "priority": "highest",
         "contains": "complete_integrated_specification"
       },
       {
         "type": "individual_role_analysis",
-        "source": "brainstorm_roles",
-        "path": ".workflow/WFS-[session]/.brainstorming/[role]/analysis.md",
+        "source": "context-package.json → brainstorm_artifacts.role_analyses[]",
+        "path": "{{loaded dynamically from context-package.json}}",
+        "note": "Supports analysis*.md pattern (analysis.md, analysis-01.md, analysis-api.md, etc.)",
         "priority": "low",
         "contains": "role_specific_analysis_fallback"
       }
@@ -495,10 +563,11 @@ Task(subagent_type="{meta.agent}",
     "pre_analysis": [
       {
         "step": "load_synthesis_specification",
-        "action": "Load consolidated synthesis specification from brainstorming",
+        "action": "Load synthesis specification from context-package.json",
         "commands": [
-          "bash(ls .workflow/WFS-[session]/.brainstorming/synthesis-specification.md 2>/dev/null || echo 'synthesis specification not found')",
-          "Read(.workflow/WFS-[session]/.brainstorming/synthesis-specification.md)"
+          "Read(.workflow/WFS-[session]/.process/context-package.json)",
+          "Extract(brainstorm_artifacts.synthesis_output.path)",
+          "Read(extracted path)"
         ],
         "output_to": "synthesis_specification",
         "on_error": "skip_optional"
@@ -513,16 +582,16 @@ Task(subagent_type="{meta.agent}",
     "implementation_approach": [
       {
         "step": 1,
-        "title": "Implement task following synthesis specification",
-        "description": "Implement '[title]' following synthesis specification. PRIORITY: Use synthesis-specification.md as primary requirement source. When implementation needs technical details (e.g., API schemas, caching configs, design tokens), refer to artifacts[] for detailed specifications from original role analyses.",
+        "title": "Implement task following role analyses",
+        "description": "Implement '[title]' following role analyses. PRIORITY: Use role analysis documents as primary requirement source. When implementation needs technical details (e.g., API schemas, caching configs, design tokens), refer to artifacts[] for detailed specifications from original role analyses.",
         "modification_points": [
-          "Apply consolidated requirements from synthesis-specification.md",
+          "Apply consolidated requirements from role analysis documents",
           "Follow technical guidelines from synthesis",
           "Consult artifacts for implementation details when needed",
           "Integrate with existing patterns"
         ],
         "logic_flow": [
-          "Load synthesis specification",
+          "Load role analyses",
           "Parse architecture and requirements",
           "Implement following specification",
           "Consult artifacts for technical details when needed",
@@ -552,7 +621,7 @@ meta.agent missing → Infer from meta.type:
   - "feature" → @code-developer
   - "test-gen" → @code-developer
   - "test-fix" → @test-fix-agent
-  - "review" → @general-purpose
+  - "review" → @universal-executor
   - "docs" → @doc-generator
 ```
 

.claude/commands/workflow/plan.md

@@ -13,20 +13,19 @@ allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*)
 
 **Execution Model - Auto-Continue Workflow with Quality Gate**:
 
-This workflow runs **mostly autonomously** once triggered, with one interactive quality gate (Phase 3.5). Phases 3 and 4 are delegated to specialized agents for complex analysis and task generation.
+This workflow runs **fully autonomously** once triggered. Phase 3 (conflict resolution) and Phase 4 (task generation) are delegated to specialized agents.
+
 
 1. **User triggers**: `/workflow:plan "task"`
 2. **Phase 1 executes** → Session discovery → Auto-continues
 3. **Phase 2 executes** → Context gathering → Auto-continues
-4. **Phase 3 executes** (cli-execution-agent) → Intelligent analysis → Auto-continues
-5. **Phase 3.5 executes** → **Pauses for user Q&A** → User answers clarification questions → Auto-continues
-6. **Phase 4 executes** (task-generate-agent if --agent) → Task generation → Reports final summary
+4. **Phase 3 executes** (optional, if conflict_risk ≥ medium) → Conflict resolution → Auto-continues
+5. **Phase 4 executes** (task-generate-agent if --agent) → Task generation → Reports final summary
 
 **Auto-Continue Mechanism**:
 - TodoList tracks current phase status
 - After each phase completion, automatically executes next pending phase
-- **Phase 3.5 requires user interaction** - answers clarification questions (up to 5)
-- If no ambiguities found, Phase 3.5 auto-skips and continues to Phase 4
+- All phases run autonomously without user interaction (clarification handled in brainstorm phase)
 - Progress updates shown at each phase for visibility
 
 **Execution Modes**:
@@ -96,23 +95,31 @@ CONTEXT: Existing user database schema, REST API endpoints
 
 ---
 
-### Phase 3: Intelligent Analysis
+### Phase 3: Conflict Resolution (Optional - auto-triggered by conflict risk)
 
-**Command**: `SlashCommand(command="/workflow:tools:concept-enhanced --session [sessionId] --context [contextPath]")`
+**Trigger**: Only execute when context-package.json indicates conflict_risk is "medium" or "high"
 
-**Input**: `sessionId` from Phase 1, `contextPath` from Phase 2
+**Command**: `SlashCommand(command="/workflow:tools:conflict-resolution --session [sessionId] --context [contextPath]")`
+
+**Input**:
+- sessionId from Phase 1
+- contextPath from Phase 2
+- conflict_risk from context-package.json
 
 **Parse Output**:
-- Extract: Execution status (success/failed)
-- Verify: ANALYSIS_RESULTS.md file path
+- Extract: Execution status (success/skipped/failed)
+- Verify: CONFLICT_RESOLUTION.md file path (if executed)
 
 **Validation**:
-- File `.workflow/[sessionId]/.process/ANALYSIS_RESULTS.md` exists
+- File `.workflow/[sessionId]/.process/CONFLICT_RESOLUTION.md` exists (if executed)
 
+**Skip Behavior**:
+- If conflict_risk is "none" or "low", skip directly to Phase 3.5
+- Display: "No significant conflicts detected, proceeding to clarification"
 
-**TodoWrite**: Mark phase 3 completed, phase 3.5 in_progress
+**TodoWrite**: Mark phase 3 completed (if executed) or skipped, phase 3.5 in_progress
 
-**After Phase 3**: Return to user showing Phase 3 results, then auto-continue to Phase 3.5
+**After Phase 3**: Return to user showing conflict resolution results (if executed) and selected strategies, then auto-continue to Phase 3.5
 
 **Memory State Check**:
 - Evaluate current context window usage and memory state
@@ -124,47 +131,33 @@ CONTEXT: Existing user database schema, REST API endpoints
 
 ---
 
-### Phase 3.5: Concept Clarification (Quality Gate)
+### Phase 3.5: Pre-Task Generation Validation (Optional Quality Gate)
 
-**Command**: `SlashCommand(command="/workflow:concept-clarify --session [sessionId]")`
+**Purpose**: Optional quality gate before task generation - primarily handled by brainstorm synthesis phase
 
-**Purpose**: Quality gate to verify and clarify analysis results before task generation
 
-**Input**: `sessionId` from Phase 1
+**Current Behavior**: Auto-skip to Phase 4 (Task Generation)
 
-**Behavior**:
-- Auto-detects plan mode (ANALYSIS_RESULTS.md exists)
-- Interactively asks up to 5 targeted questions to resolve ambiguities
-- Updates ANALYSIS_RESULTS.md with clarifications
-- Pauses workflow for user input (breaks auto-continue temporarily)
+**Future Enhancement**: Could add additional validation steps like:
+- Cross-reference checks between conflict resolution and brainstorm analyses
+- Final sanity checks before task generation
+- User confirmation prompt for proceeding
 
-**Parse Output**:
-- Verify clarifications added to ANALYSIS_RESULTS.md
-- Check recommendation: "PROCEED" or "ADDRESS_OUTSTANDING"
+**TodoWrite**: Mark phase 3.5 completed (auto-skip), phase 4 in_progress
 
-**Validation**:
-- ANALYSIS_RESULTS.md updated with `## Clarifications` section
-- All critical ambiguities resolved or documented as outstanding
-
-**TodoWrite**: Mark phase 3.5 completed, phase 4 in_progress
-
-**After Phase 3.5**: Return to user showing clarification summary, then auto-continue to Phase 4
-
-**Skip Conditions**:
-- If `/workflow:concept-clarify` reports "No critical ambiguities detected", automatically proceed to Phase 4
-- User can skip by responding "skip" or "proceed" immediately
+**After Phase 3.5**: Auto-continue to Phase 4 immediately
 
 ---
 
 ### Phase 4: Task Generation
 
 **Relationship with Brainstorm Phase**:
-- If brainstorm synthesis exists (synthesis-specification.md), Phase 3 analysis incorporates it as input
-- **⚠️ User's original intent is ALWAYS primary**: New or refined user goals override synthesis recommendations
-- **synthesis-specification.md defines "WHAT"**: Requirements, design specs, high-level features
+- If brainstorm role analyses exist ([role]/analysis.md files), Phase 3 analysis incorporates them as input
+- **⚠️ User's original intent is ALWAYS primary**: New or refined user goals override brainstorm recommendations
+- **Role analysis.md files define "WHAT"**: Requirements, design specs, role-specific insights
 - **IMPL_PLAN.md defines "HOW"**: Executable task breakdown, dependencies, implementation sequence
-- Task generation translates high-level specifications into concrete, actionable work items
-- **Intent priority**: Current user prompt > synthesis-specification.md > topic-framework.md
+- Task generation translates high-level role analyses into concrete, actionable work items
+- **Intent priority**: Current user prompt > role analysis.md files > guidance-specification.md
 
 **Command Selection**:
 - Manual: `SlashCommand(command="/workflow:tools:task-generate --session [sessionId]")`
@@ -211,24 +204,36 @@ Plan: .workflow/[sessionId]/IMPL_PLAN.md
 
 ```javascript
 // Initialize (before Phase 1)
+// Note: Phase 3 todo only added dynamically after Phase 2 if conflict_risk ≥ medium
 TodoWrite({todos: [
   {"content": "Execute session discovery", "status": "in_progress", "activeForm": "Executing session discovery"},
   {"content": "Execute context gathering", "status": "pending", "activeForm": "Executing context gathering"},
-  {"content": "Execute intelligent analysis", "status": "pending", "activeForm": "Executing intelligent analysis"},
-  {"content": "Execute concept clarification", "status": "pending", "activeForm": "Executing concept clarification"},
+  // Phase 3 todo added dynamically after Phase 2 if conflict_risk ≥ medium
   {"content": "Execute task generation", "status": "pending", "activeForm": "Executing task generation"}
 ]})
 
-// After Phase 1
+// After Phase 2 (if conflict_risk ≥ medium, insert Phase 3 todo)
 TodoWrite({todos: [
   {"content": "Execute session discovery", "status": "completed", "activeForm": "Executing session discovery"},
-  {"content": "Execute context gathering", "status": "in_progress", "activeForm": "Executing context gathering"},
-  {"content": "Execute intelligent analysis", "status": "pending", "activeForm": "Executing intelligent analysis"},
-  {"content": "Execute concept clarification", "status": "pending", "activeForm": "Executing concept clarification"},
+  {"content": "Execute context gathering", "status": "completed", "activeForm": "Executing context gathering"},
+  {"content": "Resolve conflicts and apply fixes", "status": "in_progress", "activeForm": "Resolving conflicts"},
   {"content": "Execute task generation", "status": "pending", "activeForm": "Executing task generation"}
 ]})
 
-// Continue pattern for Phase 2, 3, 3.5, 4...
+// After Phase 2 (if conflict_risk is none/low, skip Phase 3, go directly to Phase 4)
+TodoWrite({todos: [
+  {"content": "Execute session discovery", "status": "completed", "activeForm": "Executing session discovery"},
+  {"content": "Execute context gathering", "status": "completed", "activeForm": "Executing context gathering"},
+  {"content": "Execute task generation", "status": "in_progress", "activeForm": "Executing task generation"}
+]})
+
+// After Phase 3 (if executed), continue to Phase 4
+TodoWrite({todos: [
+  {"content": "Execute session discovery", "status": "completed", "activeForm": "Executing session discovery"},
+  {"content": "Execute context gathering", "status": "completed", "activeForm": "Executing context gathering"},
+  {"content": "Resolve conflicts and apply fixes", "status": "completed", "activeForm": "Resolving conflicts"},
+  {"content": "Execute task generation", "status": "in_progress", "activeForm": "Executing task generation"}
+]})
 ```
 
 ## Input Processing
@@ -277,20 +282,22 @@ Phase 1: session:start --auto "structured-description"
     ↓
 Phase 2: context-gather --session sessionId "structured-description"
     ↓ Input: sessionId + session memory + structured description
-    ↓ Output: contextPath (context-package.json)
+    ↓ Output: contextPath (context-package.json) + conflict_risk
     ↓
-Phase 3: cli-execution-agent (Intelligent Analysis)
-    ↓ Input: sessionId + contextPath + task description
-    ↓ Agent discovers context, enhances prompt, executes with Gemini
-    ↓ Output: ANALYSIS_RESULTS.md + execution log
-    ↓
-Phase 3.5: concept-clarify --session sessionId (Quality Gate)
-    ↓ Input: sessionId + ANALYSIS_RESULTS.md (auto-detected)
-    ↓ Interactive: User answers clarification questions
-    ↓ Output: Updated ANALYSIS_RESULTS.md with clarifications
+Phase 3: conflict-resolution [AUTO-TRIGGERED if conflict_risk ≥ medium]
+    ↓ Input: sessionId + contextPath + conflict_risk
+    ↓ CLI-powered conflict detection (JSON output)
+    ↓ AskUserQuestion: Present conflicts + resolution strategies
+    ↓ User selects strategies (or skip)
+    ↓ Apply modifications via Edit tool:
+    ↓   - Update guidance-specification.md
+    ↓   - Update role analyses (*.md)
+    ↓   - Mark context-package.json as "resolved"
+    ↓ Output: Modified brainstorm artifacts (NO report file)
+    ↓ Skip if conflict_risk is none/low → proceed directly to Phase 4
     ↓
 Phase 4: task-generate[--agent] --session sessionId
-    ↓ Input: sessionId + clarified ANALYSIS_RESULTS.md + session memory
+    ↓ Input: sessionId + resolved brainstorm artifacts + session memory
     ↓ Output: IMPL_PLAN.md, task JSONs, TODO_LIST.md
     ↓
 Return summary to user
@@ -299,7 +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
+- Brainstorming artifacts (potentially modified by Phase 3)
 - Session-specific configuration
 
 **Structured Description Benefits**:
@@ -317,25 +324,22 @@ Return summary to user
 ## Coordinator Checklist
 
 ✅ **Pre-Phase**: Convert user input to structured format (GOAL/SCOPE/CONTEXT)
-✅ Initialize TodoWrite before any command (include Phase 3.5)
+✅ Initialize TodoWrite before any command (Phase 3 added dynamically after Phase 2)
 ✅ Execute Phase 1 immediately with structured description
 ✅ Parse session ID from Phase 1 output, store in memory
 ✅ Pass session ID and structured description to Phase 2 command
 ✅ Parse context path from Phase 2 output, store in memory
-✅ **Launch Phase 3 agent**: Build Task prompt with sessionId and contextPath
-✅ Wait for agent completion, parse execution log path
-✅ Verify ANALYSIS_RESULTS.md created by agent
-✅ **Execute Phase 3.5**: Pass session ID to `/workflow:concept-clarify`
-✅ Wait for user interaction (clarification Q&A)
-✅ Verify ANALYSIS_RESULTS.md updated with clarifications
-✅ Check recommendation: proceed if "PROCEED", otherwise alert user
+✅ **Extract conflict_risk from context-package.json**: Determine Phase 3 execution
+✅ **If conflict_risk ≥ medium**: Launch Phase 3 conflict-resolution with sessionId and contextPath
+✅ Wait for Phase 3 completion (if executed), verify CONFLICT_RESOLUTION.md created
+✅ **If conflict_risk is none/low**: Skip Phase 3, proceed directly to Phase 4
 ✅ **Build Phase 4 command** based on flags:
   - Base command: `/workflow:tools:task-generate` (or `-agent` if `--agent` flag)
   - Add `--session [sessionId]`
   - Add `--cli-execute` if flag present
 ✅ Pass session ID to Phase 4 command
 ✅ Verify all Phase 4 outputs
-✅ Update TodoWrite after each phase
+✅ Update TodoWrite after each phase (dynamically adjust for Phase 3 presence)
 ✅ After each phase, automatically continue to next phase based on TodoList status
 
 ## Structure Template Reference

.claude/commands/workflow/review.md

@@ -92,10 +92,10 @@ After bash validation, the model takes control to:
 2. **Perform Specialized Review**: Based on `review_type`
 
    **Security Review** (`--type=security`):
-   - Use MCP code search for security patterns:
+   - Use ripgrep for security patterns:
      ```bash
-     mcp__code-index__search_code_advanced(pattern="password|token|secret|auth", file_pattern="*.{ts,js,py}")
-     mcp__code-index__search_code_advanced(pattern="eval|exec|innerHTML|dangerouslySetInnerHTML", file_pattern="*.{ts,js,tsx}")
+     rg "password|token|secret|auth" -g "*.{ts,js,py}"
+     rg "eval|exec|innerHTML|dangerouslySetInnerHTML" -g "*.{ts,js,tsx}"
      ```
    - Use Gemini for security analysis:
      ```bash

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

@@ -20,12 +20,12 @@ allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*)
 1. **Start Immediately**: First action is TodoWrite initialization, second action is Phase 1 execution
 2. **No Preliminary Analysis**: Do not read files before Phase 1
 3. **Parse Every Output**: Extract required data for next phase
-4. **Sequential Execution**: Each phase depends on previous output
-5. **Complete All Phases**: Do not return until Phase 7 completes (with concept verification)
+4. **Auto-Continue via TodoList**: Check TodoList status to execute next pending phase automatically
+5. **Track Progress**: Update TodoWrite after every phase completion
 6. **TDD Context**: All descriptions include "TDD:" prefix
-7. **Quality Gate**: Phase 5 concept verification ensures clarity before task generation
+7. **Quality Gate**: Phase 4 conflict resolution (optional, auto-triggered) validates compatibility before task generation
 
-## 7-Phase Execution (with Concept Verification)
+## 6-Phase Execution (with Conflict Resolution)
 
 ### Phase 1: Session Discovery
 **Command**: `/workflow:session:start --auto "TDD: [structured-description]"`
@@ -41,10 +41,32 @@ TEST_FOCUS: [Test scenarios]
 
 **Parse**: Extract sessionId
 
+**TodoWrite**: Mark phase 1 completed, phase 2 in_progress
+
+**After Phase 1**: Return to user showing Phase 1 results, then auto-continue to Phase 2
+
+---
+
 ### Phase 2: Context Gathering
 **Command**: `/workflow:tools:context-gather --session [sessionId] "TDD: [structured-description]"`
 
-**Parse**: Extract contextPath
+**Use Same Structured Description**: Pass the same structured format from Phase 1
+
+**Input**: `sessionId` from Phase 1
+
+**Parse Output**:
+- Extract: context-package.json path (store as `contextPath`)
+- Typical pattern: `.workflow/[sessionId]/.process/context-package.json`
+
+**Validation**:
+- Context package path extracted
+- File exists and is valid JSON
+
+**TodoWrite**: Mark phase 2 completed, phase 3 in_progress
+
+**After Phase 2**: Return to user showing Phase 2 results, then auto-continue to Phase 3
+
+---
 
 ### Phase 3: Test Coverage Analysis
 **Command**: `/workflow:tools:test-context-gather --session [sessionId]`
@@ -63,34 +85,49 @@ TEST_FOCUS: [Test scenarios]
 - Prevents duplicate test creation
 - Enables integration with existing tests
 
-### Phase 4: TDD Analysis
-**Command**: `/workflow:tools:concept-enhanced --session [sessionId] --context [contextPath]`
+**TodoWrite**: Mark phase 3 completed, phase 4 in_progress
 
-**Note**: Generates ANALYSIS_RESULTS.md with TDD-specific structure:
-- Feature list with testable requirements
-- Test cases for Red phase
-- Implementation requirements for Green phase
-- Refactoring opportunities
-- Task dependencies and execution order
+**After Phase 3**: Return to user showing test coverage results, then auto-continue to Phase 4
 
-**Parse**: Verify ANALYSIS_RESULTS.md contains TDD breakdown sections
+---
 
-### Phase 5: Concept Verification (NEW QUALITY GATE)
-**Command**: `/workflow:concept-verify --session [sessionId]`
+### Phase 4: Conflict Resolution (Optional - auto-triggered by conflict risk)
 
-**Purpose**: Verify conceptual clarity before TDD task generation
-- Clarify test requirements and acceptance criteria
-- Resolve ambiguities in expected behavior
-- Validate TDD approach is appropriate
+**Trigger**: Only execute when context-package.json indicates conflict_risk is "medium" or "high"
 
-**Behavior**:
-- If no ambiguities found → Auto-proceed to Phase 6
-- If ambiguities exist → Interactive clarification (up to 5 questions)
-- After clarifications → Auto-proceed to Phase 6
+**Command**: `SlashCommand(command="/workflow:tools:conflict-resolution --session [sessionId] --context [contextPath]")`
 
-**Parse**: Verify concept verification completed (check for clarifications section in ANALYSIS_RESULTS.md or synthesis file if exists)
+**Input**:
+- sessionId from Phase 1
+- contextPath from Phase 2
+- conflict_risk from context-package.json
 
-### Phase 6: TDD Task Generation
+**Parse Output**:
+- Extract: Execution status (success/skipped/failed)
+- Verify: CONFLICT_RESOLUTION.md file path (if executed)
+
+**Validation**:
+- File `.workflow/[sessionId]/.process/CONFLICT_RESOLUTION.md` exists (if executed)
+
+**Skip Behavior**:
+- If conflict_risk is "none" or "low", skip directly to Phase 5
+- Display: "No significant conflicts detected, proceeding to TDD task generation"
+
+**TodoWrite**: Mark phase 4 completed (if executed) or skipped, phase 5 in_progress
+
+**After Phase 4**: Return to user showing conflict resolution results (if executed) and selected strategies, then auto-continue to Phase 5
+
+**Memory State Check**:
+- Evaluate current context window usage and memory state
+- If memory usage is high (>110K tokens or approaching context limits):
+  - **Command**: `SlashCommand(command="/compact")`
+  - This optimizes memory before proceeding to Phase 5
+- Memory compaction is particularly important after analysis phase which may generate extensive documentation
+- Ensures optimal performance and prevents context overflow
+
+---
+
+### Phase 5: TDD Task Generation
 **Command**:
 - Manual: `/workflow:tools:task-generate-tdd --session [sessionId]`
 - Agent: `/workflow:tools:task-generate-tdd --session [sessionId] --agent`
@@ -108,7 +145,7 @@ TEST_FOCUS: [Test scenarios]
 - IMPL_PLAN.md contains workflow_type: "tdd" in frontmatter
 - Task count ≤10 (compliance with task limit)
 
-### Phase 7: TDD Structure Validation & Action Plan Verification (RECOMMENDED)
+### Phase 6: TDD Structure Validation & Action Plan Verification (RECOMMENDED)
 **Internal validation first, then recommend external verification**
 
 **Internal Validation**:
@@ -166,18 +203,44 @@ TDD Configuration:
 ## TodoWrite Pattern
 
 ```javascript
-// Initialize (7 phases now with concept verification)
-[
-  {content: "Execute session discovery", status: "in_progress", activeForm: "Executing session discovery"},
-  {content: "Execute context gathering", status: "pending", activeForm": "Executing context gathering"},
-  {content: "Execute test coverage analysis", status: "pending", activeForm": "Executing test coverage analysis"},
-  {content: "Execute TDD analysis", status: "pending", activeForm": "Executing TDD analysis"},
-  {content: "Execute concept verification", status: "pending", activeForm": "Executing concept verification"},
-  {content: "Execute TDD task generation", status: "pending", activeForm: "Executing TDD task generation"},
-  {content: "Validate TDD structure", status: "pending", activeForm: "Validating TDD structure"}
-]
+// Initialize (Phase 4 added dynamically after Phase 3 if conflict_risk ≥ medium)
+TodoWrite({todos: [
+  {"content": "Execute session discovery", "status": "in_progress", "activeForm": "Executing session discovery"},
+  {"content": "Execute context gathering", "status": "pending", "activeForm": "Executing context gathering"},
+  {"content": "Execute test coverage analysis", "status": "pending", "activeForm": "Executing test coverage analysis"},
+  // Phase 4 todo added dynamically after Phase 3 if conflict_risk ≥ medium
+  {"content": "Execute TDD task generation", "status": "pending", "activeForm": "Executing TDD task generation"},
+  {"content": "Validate TDD structure", "status": "pending", "activeForm": "Validating TDD structure"}
+]})
 
-// Update after each phase: mark current "completed", next "in_progress"
+// After Phase 3 (if conflict_risk ≥ medium, insert Phase 4 todo)
+TodoWrite({todos: [
+  {"content": "Execute session discovery", "status": "completed", "activeForm": "Executing session discovery"},
+  {"content": "Execute context gathering", "status": "completed", "activeForm": "Executing context gathering"},
+  {"content": "Execute test coverage analysis", "status": "completed", "activeForm": "Executing test coverage analysis"},
+  {"content": "Execute conflict resolution", "status": "in_progress", "activeForm": "Executing conflict resolution"},
+  {"content": "Execute TDD task generation", "status": "pending", "activeForm": "Executing TDD task generation"},
+  {"content": "Validate TDD structure", "status": "pending", "activeForm": "Validating TDD structure"}
+]})
+
+// After Phase 3 (if conflict_risk is none/low, skip Phase 4, go directly to Phase 5)
+TodoWrite({todos: [
+  {"content": "Execute session discovery", "status": "completed", "activeForm": "Executing session discovery"},
+  {"content": "Execute context gathering", "status": "completed", "activeForm": "Executing context gathering"},
+  {"content": "Execute test coverage analysis", "status": "completed", "activeForm": "Executing test coverage analysis"},
+  {"content": "Execute TDD task generation", "status": "in_progress", "activeForm": "Executing TDD task generation"},
+  {"content": "Validate TDD structure", "status": "pending", "activeForm": "Validating TDD structure"}
+]})
+
+// After Phase 4 (if executed), continue to Phase 5
+TodoWrite({todos: [
+  {"content": "Execute session discovery", "status": "completed", "activeForm": "Executing session discovery"},
+  {"content": "Execute context gathering", "status": "completed", "activeForm": "Executing context gathering"},
+  {"content": "Execute test coverage analysis", "status": "completed", "activeForm": "Executing test coverage analysis"},
+  {"content": "Execute conflict resolution", "status": "completed", "activeForm": "Executing conflict resolution"},
+  {"content": "Execute TDD task generation", "status": "in_progress", "activeForm": "Executing TDD task generation"},
+  {"content": "Validate TDD structure", "status": "pending", "activeForm": "Validating TDD structure"}
+]})
 ```
 
 ## Input Processing

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

@@ -237,7 +237,7 @@ Final Score: Max(0, Base Score - Deductions)
 
 ### Command Chain
 - **Called After**: `/workflow:execute` (when TDD tasks completed)
-- **Calls**: `/workflow:tools:tdd-coverage-analysis`, Gemini wrapper
+- **Calls**: `/workflow:tools:tdd-coverage-analysis`, Gemini CLI
 - **Related**: `/workflow:tdd-plan`, `/workflow:status`
 
 ### Basic Usage

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

@@ -10,6 +10,12 @@ allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*), Task(*)
 ## Overview
 Orchestrates dynamic test-fix workflow execution through iterative cycles of testing, analysis, and fixing. **Unlike standard execute, this command dynamically generates intermediate tasks** during execution based on test results and CLI analysis, enabling adaptive problem-solving.
 
+**⚠️ CRITICAL - Orchestrator Boundary**:
+- This command is the **ONLY place** where test failures are handled
+- All CLI analysis (Gemini/Qwen), fix task generation (IMPL-fix-N.json), and iteration management happen HERE
+- Agents (@test-fix-agent) only execute single tasks and return results
+- **Do NOT handle test failures in main workflow or other commands** - always delegate to this orchestrator
+
 **Resume Mode**: When called with `--resume-session` flag, skips discovery and continues from interruption point.
 
 ## Core Philosophy
@@ -53,7 +59,7 @@ Orchestrates dynamic test-fix workflow execution through iterative cycles of tes
 
 ## Responsibility Matrix
 
-**Clear division of labor between orchestrator and agents:**
+**⚠️ CRITICAL - Clear division of labor between orchestrator and agents:**
 
 | Responsibility | test-cycle-execute (Orchestrator) | @test-fix-agent (Executor) |
 |----------------|----------------------------|---------------------------|
@@ -62,12 +68,14 @@ Orchestrates dynamic test-fix workflow execution through iterative cycles of tes
 | Generate IMPL-fix-N.json | ✅ Creates task files | ❌ Not involved |
 | Run tests | ❌ Delegates to agent | ✅ Executes test command |
 | Apply fixes | ❌ Delegates to agent | ✅ Modifies code |
-| Detect test failures | ✅ Analyzes agent output | ✅ Reports results |
+| Detect test failures | ✅ Analyzes results and decides next action | ✅ Executes tests and reports outcomes |
 | Add tasks to queue | ✅ Manages queue | ❌ Not involved |
-| Update iteration state | ✅ Maintains state files | ✅ Updates task status |
+| Update iteration state | ✅ Maintains overall iteration state | ✅ Updates individual task status only |
 
 **Key Principle**: Orchestrator manages the "what" and "when"; agents execute the "how".
 
+**⚠️ ENFORCEMENT**: If test failures occur outside this orchestrator, do NOT handle them inline - always call `/workflow:test-cycle-execute` instead.
+
 ## Execution Lifecycle
 
 ### Phase 1: Discovery & Initialization
@@ -217,13 +225,15 @@ Iteration N (managed by test-cycle-execute orchestrator):
 **Orchestrator executes CLI analysis between agent tasks:**
 
 #### When Test Failures Occur
-1. **[Orchestrator]** Detects failures from agent output
+1. **[Orchestrator]** Detects failures from agent test execution output
 2. **[Orchestrator]** Collects failure context from `.process/test-results.json` and logs
-3. **[Orchestrator]** Runs Gemini/Qwen wrapper with failure context
-4. **[CLI Tool]** Analyzes failures and generates fix strategy
+3. **[Orchestrator]** Executes Gemini/Qwen CLI tool with failure context
+4. **[Orchestrator]** Interprets CLI tool output to extract fix strategy
 5. **[Orchestrator]** Saves analysis to `.process/iteration-N-analysis.md`
 6. **[Orchestrator]** Generates `IMPL-fix-N.json` with strategy content (not just path)
 
+**Note**: The orchestrator executes CLI analysis tools and processes their output. CLI tools provide analysis, orchestrator manages the workflow.
+
 #### CLI Analysis Command (executed by orchestrator)
 ```bash
 cd {project_root} && gemini -p "
@@ -516,15 +526,16 @@ Task(subagent_type="{meta.agent}",
      ### For test-fix (IMPL-002):
      - Run test suite: {test_command}
      - Collect results to .process/test-results.json
-     - If failures: Save context, return to orchestrator
+     - Report results to orchestrator (do NOT analyze failures)
+     - Orchestrator will handle failure detection and iteration decisions
      - If success: Mark complete
 
      ### For test-fix-iteration (IMPL-fix-N):
      - Load fix strategy from context.fix_strategy (CONTENT, not path)
      - Apply surgical fixes to identified files
-     - Run tests to verify
-     - If still failures: Save context with new failure data
-     - Update iteration state
+     - Return results to orchestrator
+     - Do NOT run tests independently - orchestrator manages all test execution
+     - Do NOT handle failures - orchestrator analyzes and decides next iteration
 
      ## STEP 4: Implementation Context (From JSON)
      **Requirements**: {context.requirements}

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

@@ -13,7 +13,11 @@ allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*)
 
 This command creates an independent test-fix workflow session for existing code. It orchestrates a 5-phase process to analyze implementation, generate test requirements, and create executable test generation and fix tasks.
 
-**⚠️ Command Scope**: Prepares test workflow artifacts only. Task execution requires separate commands (`/workflow:test-cycle-execute` or `/workflow:execute`).
+**⚠️ CRITICAL - Command Scope**:
+- **This command ONLY generates task JSON files** (IMPL-001.json, IMPL-002.json)
+- **Does NOT execute tests or apply fixes** - all execution happens in separate orchestrator
+- **Must call `/workflow:test-cycle-execute`** after this command to actually run tests and fixes
+- **Test failure handling happens in test-cycle-execute**, not here
 
 ### Dual-Mode Support
 
@@ -44,12 +48,15 @@ fi
 
 ### Coordinator Role
 
-This command is a **pure orchestrator**:
+This command is a **pure planning coordinator**:
 - Does NOT analyze code directly
 - Does NOT generate tests or documentation
-- ONLY coordinates slash commands in sequence
+- Does NOT execute tests or apply fixes
+- Does NOT handle test failures or iterations
+- ONLY coordinates slash commands to generate task JSON files
 - Parses outputs to pass data between phases
 - Creates independent test workflow session
+- **All execution delegated to `/workflow:test-cycle-execute`**
 
 ---
 
@@ -267,14 +274,20 @@ Review artifacts:
 - Test plan: .workflow/[testSessionId]/IMPL_PLAN.md
 - Task list: .workflow/[testSessionId]/TODO_LIST.md
 
-Next Steps:
-- Review IMPL_PLAN.md
-- Execute: /workflow:test-cycle-execute [testSessionId]
+⚠️ CRITICAL - Next Steps:
+1. Review IMPL_PLAN.md
+2. **MUST execute: /workflow:test-cycle-execute**
+   - This command only generated task JSON files
+   - Test execution and fix iterations happen in test-cycle-execute
+   - Do NOT attempt to run tests or fixes in main workflow
 ```
 
 **TodoWrite**: Mark phase 5 completed
 
-**Note**: Command completes here. Task execution requires separate workflow commands.
+**⚠️ BOUNDARY NOTE**:
+- Command completes here - only task JSON files generated
+- All test execution, failure detection, CLI analysis, fix generation happens in `/workflow:test-cycle-execute`
+- This command does NOT handle test failures or apply fixes
 
 ---
 
@@ -329,7 +342,9 @@ Generates minimum 2 tasks (expandable for complex projects):
 
 **Agent**: `@test-fix-agent`
 
-**Purpose**: Execute tests and apply iterative fixes (max 5 iterations)
+**Purpose**: Execute initial tests and trigger orchestrator-managed fix cycles
+
+**Note**: This task executes tests and reports results. The test-cycle-execute orchestrator manages all fix iterations, CLI analysis, and fix task generation.
 
 **Task Configuration**:
 - Task ID: `IMPL-002`
@@ -340,11 +355,12 @@ Generates minimum 2 tasks (expandable for complex projects):
 - `context.requirements`: Execute and fix tests
 
 **Test-Fix Cycle Specification**:
-- **Cycle Pattern**: test → gemini_diagnose → manual_fix (or codex) → retest
-- **Tools Configuration**:
+**Note**: This specification describes what test-cycle-execute orchestrator will do. The agent only executes single tasks.
+- **Cycle Pattern** (orchestrator-managed): test → gemini_diagnose → manual_fix (or codex) → retest
+- **Tools Configuration** (orchestrator-controlled):
   - Gemini for analysis with bug-fix template → surgical fix suggestions
   - Manual fix application (default) OR Codex if `--use-codex` flag (resume mechanism)
-- **Exit Conditions**:
+- **Exit Conditions** (orchestrator-enforced):
   - Success: All tests pass
   - Failure: Max iterations reached (5)
 

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

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

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

@@ -0,0 +1,471 @@
+---
+name: conflict-resolution
+description: Detect and resolve conflicts between plan and existing codebase using CLI-powered analysis
+argument-hint: "--session WFS-session-id --context path/to/context-package.json"
+examples:
+  - /workflow:tools:conflict-resolution --session WFS-auth --context .workflow/WFS-auth/.process/context-package.json
+  - /workflow:tools:conflict-resolution --session WFS-payment --context .workflow/WFS-payment/.process/context-package.json
+---
+
+# Conflict Resolution Command
+
+## Purpose
+Analyzes conflicts between implementation plans and existing codebase, generating multiple resolution strategies.
+
+**Scope**: Detection and strategy generation only - NO code modification or task creation.
+
+**Trigger**: Auto-executes in `/workflow:plan` Phase 3 when `conflict_risk ≥ medium`.
+
+## Core Responsibilities
+
+| Responsibility | Description |
+|---------------|-------------|
+| **Detect Conflicts** | Analyze plan vs existing code inconsistencies |
+| **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 Categories
+
+### 1. Architecture Conflicts
+- Incompatible design patterns
+- Module structure changes
+- Pattern migration requirements
+
+### 2. API Conflicts
+- Breaking contract changes
+- Signature modifications
+- Public interface impacts
+
+### 3. Data Model Conflicts
+- Schema modifications
+- Type breaking changes
+- Data migration needs
+
+### 4. Dependency Conflicts
+- Version incompatibilities
+- Setup conflicts
+- Breaking updates
+
+## Execution Flow
+
+### Phase 1: Validation
+```
+1. Verify session directory exists
+2. Load context-package.json
+3. Check conflict_risk (skip if none/low)
+4. Prepare agent task prompt
+```
+
+### Phase 2: CLI-Powered Analysis
+
+**Agent Delegation**:
+```javascript
+Task(subagent_type="cli-execution-agent", prompt=`
+  ## Context
+  - Session: {session_id}
+  - Risk: {conflict_risk}
+  - Files: {existing_files_list}
+
+  ## Analysis Steps
+
+  ### 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
+
+  ### 2. Execute CLI Analysis
+
+  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
+  "
+
+  Fallback: Qwen (same prompt) → Claude (manual analysis)
+
+  ### 3. Generate Strategies (2-4 per conflict)
+
+  Template per conflict:
+  - Severity: Critical/High/Medium
+  - Category: Architecture/API/Data/Dependency
+  - Affected files + impact
+  - Options with pros/cons, effort, risk
+  - Recommended strategy + rationale
+
+  ### 4. Return Structured Conflict Data
+
+  ⚠️ DO NOT generate CONFLICT_RESOLUTION.md file
+
+  Return JSON format for programmatic processing:
+
+  \`\`\`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
+    }
+  }
+  \`\`\`
+
+  ⚠️ 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
+===== 冲突解决 (第 1/1 轮) =====
+
+【问题1 - Architecture】CON-001: 现有认证系统与计划不兼容
+a) 渐进式迁移
+   说明：保留现有系统，逐步迁移到新方案
+   复杂度: Medium | 风险: Low | 工作量: 3-5天
+b) 完全重写
+   说明：废弃旧系统，从零实现新认证
+   复杂度: High | 风险: Medium | 工作量: 7-10天
+c) 自定义修改
+   说明：根据修改建议自行处理，不应用预设策略
+   修改建议：
+   - 评估现有认证系统的兼容性，考虑是否可以通过适配器模式桥接
+   - 检查JWT token格式和验证逻辑是否需要调整
+   - 确保用户会话管理与新架构保持一致
+
+【问题2 - Data】CON-002: 数据库 schema 冲突
+a) 添加迁移脚本
+   说明：创建数据库迁移脚本处理 schema 变更
+   复杂度: Low | 风险: Low | 工作量: 1-2天
+b) 自定义修改
+   说明：根据修改建议自行处理，不应用预设策略
+   修改建议：
+   - 检查现有表结构是否支持新增字段，避免破坏性变更
+   - 考虑使用数据库版本控制工具（如Flyway或Liquibase）
+   - 准备数据迁移和回滚策略
+
+请回答 (格式: 1a 2b)：
+```
+
+**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)
+
+### Phase 4: Apply Modifications
+
+```javascript
+// 1. Extract modifications from selected strategies
+const modifications = [];
+selectedStrategies.forEach(strategy => {
+  if (strategy !== "skip") {
+    modifications.push(...strategy.modifications);
+  }
+});
+
+// 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
+});
+
+// 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));
+
+// 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
+};
+```
+
+**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/
+```
+
+## Output Format: Agent JSON Response
+
+**Focus**: Structured conflict data with actionable modifications for programmatic processing.
+
+**Format**: JSON to stdout (NO file generation)
+
+**Structure**: Defined in Phase 2, Step 4 (agent prompt)
+
+### Key Requirements
+| Requirement | Details |
+|------------|---------|
+| **Conflict batching** | Max 10 conflicts per round (no total limit) |
+| **Strategy count** | 2-4 strategies per conflict |
+| **Modifications** | Each strategy includes file paths, old_content, new_content |
+| **User-facing text** | Chinese (brief, strategy names, pros/cons) |
+| **Technical fields** | English (severity, category, complexity, risk) |
+| **old_content precision** | 20-100 chars for unique Edit tool matching |
+| **File targets** | guidance-specification.md, role analyses (*.md) |
+
+## Error Handling
+
+### Recovery Strategy
+```
+1. Pre-check: Verify conflict_risk ≥ medium
+2. Monitor: Track agent via Task tool
+3. Validate: Parse agent JSON output
+4. Recover:
+   - Agent failure → check logs + report error
+   - Invalid JSON → retry once with Claude fallback
+   - CLI failure → fallback to Claude analysis
+   - Edit tool failure → report affected files + rollback option
+   - User cancels → mark as "unresolved", continue to task-generate
+5. Degrade: If all fail, generate minimal conflict report and skip modifications
+```
+
+### Rollback Handling
+```
+If Edit tool fails mid-application:
+1. Log all successfully applied modifications
+2. Output rollback option via text interaction
+3. If rollback selected: restore files from git or backups
+4. If continue: mark partial resolution in context-package.json
+```
+
+## Integration
+
+### Interface
+**Input**:
+- `--session` (required): WFS-{session-id}
+- `--context` (required): context-package.json path
+- Requires: `conflict_risk ≥ medium`
+
+**Output**:
+- 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
+
+**User Interaction**:
+- Text-based strategy selection (max 10 conflicts per round)
+- Each conflict: 2-4 strategy options + "自定义修改" option (with suggestions)
+
+### 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
+| 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,353 +1,175 @@
 ---
 name: gather
-description: Intelligently collect project context using general-purpose agent based on task description and package into standardized JSON
+description: Intelligently collect project context using context-search-agent based on task description 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 general-purpose agent for autonomous operation
-- **Two-Phase Flow**: Discovery (context loading) → Execution (context gathering and packaging)
-- **Memory-First**: Reuse loaded documents from conversation memory
-- **MCP-Enhanced**: Use MCP tools for advanced code analysis and file discovery
-- **Intelligent Collection**: Auto-identify relevant resources based on keyword analysis
-- **Comprehensive Coverage**: Collect code, documentation, configurations, and dependencies
-- **Standardized Output**: Generate unified format context-package.json
 
-## Execution Lifecycle
+- **Agent Delegation**: Delegate all discovery to `context-search-agent` for autonomous execution
+- **Detection-First**: Check for existing context-package before executing
+- **Plan Mode**: Full comprehensive analysis (vs lightweight brainstorm mode)
+- **Standardized Output**: Generate `.workflow/{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
-  },
-  "mcp_capabilities": {
-    // Agent will use these tools to discover project context
-    "code_index": true,
-    "exa_code": true,
-    "exa_web": true
+const contextPackagePath = `.workflow/${session_id}/.process/context-package.json`;
+
+if (file_exists(contextPackagePath)) {
+  const existing = Read(contextPackagePath);
+
+  // Validate package belongs to current session
+  if (existing?.metadata?.session_id === session_id) {
+    console.log("✅ Valid context-package found for session:", session_id);
+    console.log("📊 Stats:", existing.statistics);
+    console.log("⚠️  Conflict Risk:", existing.conflict_detection.risk_level);
+    return existing; // Skip execution, return existing
+  } else {
+    console.warn("⚠️ Invalid session_id in existing package, re-generating...");
   }
 }
-
-// Agent will autonomously execute:
-// - Project structure analysis: bash(~/.claude/scripts/get_modules_by_depth.sh)
-// - Documentation loading: Read(CLAUDE.md), Read(README.md)
 ```
 
-**Discovery Actions**:
-1. **Load Session Context** (if not in memory)
-   ```javascript
-   if (!memory.has("workflow-session.json")) {
-     Read(.workflow/{session-id}/workflow-session.json)
-   }
-   ```
+### Step 2: 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="general-purpose",
-  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:
 
-### MCP Capabilities
-- code-index: Available for file discovery and code search
-- 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 3 discovery tracks:
+- **Track 1**: Reference documentation (CLAUDE.md, architecture docs)
+- **Track 2**: Web examples (use Exa MCP for unfamiliar tech/APIs)
+- **Track 3**: Codebase analysis (5-layer discovery: files, content, patterns, deps, config/tests)
 
-### Core Responsibilities
-1. **Project Structure Analysis**: Execute get_modules_by_depth.sh for architecture overview
-2. **Documentation Loading**: Load CLAUDE.md, README.md and relevant documentation
-3. **Keyword Extraction**: Extract core keywords from task description
-4. **Smart File Discovery**: Use MCP code-index tools to locate relevant files
-5. **Code Structure Analysis**: Analyze project structure to identify relevant modules
-6. **Dependency Discovery**: Identify tech stack and dependency relationships
-7. **Context Packaging**: Generate standardized JSON context package
+### Phase 3: Synthesis, Assessment & Packaging
+1. Apply relevance scoring and build dependency graph
+2. Synthesize 3-source data (docs > code > web)
+3. Integrate brainstorm artifacts (if .brainstorming/ exists, read content)
+4. Perform conflict detection with risk assessment
+5. Generate and validate context-package.json
 
-### 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}
 
-#### Step 0: Foundation Setup (Execute First)
-1. **Project Structure Analysis**
-   Execute to get comprehensive architecture overview:
-   \`\`\`javascript
-   bash(~/.claude/scripts/get_modules_by_depth.sh)
-   \`\`\`
-
-2. **Load Project Documentation** (if not in memory)
-   Load core project documentation:
-   \`\`\`javascript
-   Read(CLAUDE.md)
-   Read(README.md)
-   // Load other relevant documentation based on session context
-   \`\`\`
-
-#### Step 1: Task Analysis
-1. **Keyword Extraction**
-   - Parse task description to extract core keywords
-   - Identify technical domain (auth, API, frontend, backend, etc.)
-   - Determine complexity level (simple, medium, complex)
-
-2. **Scope Determination**
-   - Define collection scope based on keywords
-   - Identify potentially involved modules and components
-   - Set file type filters
-
-#### Step 2: MCP-Enhanced File Discovery
-1. **Code File Location**
-   Use MCP code-index tools:
-   \`\`\`javascript
-   // Find files by pattern
-   mcp__code-index__find_files(pattern="*{keyword}*")
-
-   // Search code content
-   mcp__code-index__search_code_advanced(
-     pattern="{keyword_patterns}",
-     file_pattern="*.{ts,js,py,go,md}",
-     context_lines=3
-   )
-
-   // Get file summaries
-   mcp__code-index__get_file_summary(file_path="relevant/file.ts")
-   \`\`\`
-
-2. **Configuration Files Discovery**
-   Locate: package.json, requirements.txt, Cargo.toml, tsconfig.json, etc.
-
-3. **Test Files Location**
-   Find test files related to task keywords
-
-#### Step 3: Intelligent Filtering & Association
-1. **Relevance Scoring**
-   - Score based on keyword match degree
-   - Score based on file path relevance
-   - Score based on code content relevance
-
-2. **Dependency Analysis**
-   - Analyze import/require statements
-   - Identify inter-module dependencies
-   - Determine core and optional dependencies
-
-#### Step 4: Context Packaging
-Generate standardized context-package.json following the format below
-
-### Required Output
-
-**Output Location**: \`.workflow/{session-id}/.process/context-package.json\`
-
-**Output Format**:
-\`\`\`json
-{
-  "metadata": {
-    "task_description": "Implement user authentication system",
-    "timestamp": "2025-09-29T10:30:00Z",
-    "keywords": ["user", "authentication", "JWT", "login"],
-    "complexity": "medium",
-    "tech_stack": ["typescript", "node.js", "express"],
-    "session_id": "WFS-user-auth"
-  },
-  "assets": [
-    {
-      "type": "documentation",
-      "path": "CLAUDE.md",
-      "relevance": "Project development standards and conventions",
-      "priority": "high"
-    },
-    {
-      "type": "documentation",
-      "path": ".workflow/docs/architecture/security.md",
-      "relevance": "Security architecture design guidance",
-      "priority": "high"
-    },
-    {
-      "type": "source_code",
-      "path": "src/auth/AuthService.ts",
-      "relevance": "Existing authentication service implementation",
-      "priority": "high"
-    },
-    {
-      "type": "source_code",
-      "path": "src/models/User.ts",
-      "relevance": "User data model definition",
-      "priority": "medium"
-    },
-    {
-      "type": "config",
-      "path": "package.json",
-      "relevance": "Project dependencies and tech stack",
-      "priority": "medium"
-    },
-    {
-      "type": "test",
-      "path": "tests/auth/*.test.ts",
-      "relevance": "Authentication related test cases",
-      "priority": "medium"
-    }
-  ],
-  "tech_stack": {
-    "frameworks": ["express", "typescript"],
-    "libraries": ["jsonwebtoken", "bcrypt"],
-    "testing": ["jest", "supertest"]
-  },
-  "statistics": {
-    "total_files": 15,
-    "source_files": 8,
-    "docs_files": 4,
-    "config_files": 2,
-    "test_files": 1
-  }
-}
-\`\`\`
-
-### Quality Validation
-
-Before completion, verify:
-- [ ] context-package.json created in correct location
+## 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 MCP tools for efficient discovery
-
-**MCP Tools Integration**:
-Agent should use MCP code-index tools when available:
-\`\`\`javascript
-// Set project path
-mcp__code-index__set_project_path(path="{current_project_path}")
-
-// Refresh index
-mcp__code-index__refresh_index()
-
-// Find files by pattern
-mcp__code-index__find_files(pattern="*{keyword}*")
-
-// Search code content
-mcp__code-index__search_code_advanced(
-  pattern="{keyword_patterns}",
-  file_pattern="*.{ts,js,py,go,md}",
-  context_lines=3
+Execute autonomously following agent documentation.
+Report completion with statistics.
+`
 )
-\`\`\`
+```
 
-**Fallback Strategy**:
-When MCP tools unavailable, agent should use traditional commands:
-- \`find\` for file discovery
-- \`rg\` or \`grep\` for content search
-- Bash commands from project structure analysis
+### Step 3: Output Verification
 
-## Output
+After agent completes, verify 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
-\`
-)
-\`\`\`
+```javascript
+// Verify file was created
+const outputPath = `.workflow/${session_id}/.process/context-package.json`;
+if (!file_exists(outputPath)) {
+  throw new Error("❌ Agent failed to generate context-package.json");
+}
+```
 
-## Command Integration
+## Parameter Reference
 
-### Usage
+| 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
+
+## Usage Examples
+
+### Basic 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]\\"")
+/workflow:tools:context-gather --session WFS-auth-feature "Implement JWT authentication with refresh tokens"
 ```
-
-### Agent Context Passing
-
-**Memory-Aware Context Assembly**:
-```javascript
-// Assemble minimal context package for agent
-// Agent will execute project structure analysis and documentation loading
-const agentContext = {
-  session_id: "WFS-[id]",
-  task_description: "[user provided task description]",
-
-  // Use memory if available, else load
-  session_metadata: memory.has("workflow-session.json")
-    ? memory.get("workflow-session.json")
-    : Read(.workflow/WFS-[id]/workflow-session.json),
-
-  // MCP capabilities - agent will use these tools
-  mcp_capabilities: {
-    code_index: true,
-    exa_code: true,
-    exa_web: true
-  }
-}
-
-// 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
-
-### Session ID Usage
-- **Required Parameter**: `--session WFS-session-id`
-- **Session Context Loading**: Load existing session state and metadata
-- **Session Continuity**: Maintain context across workflow pipeline phases
-
-### Session Validation
-```javascript
-// Validate session exists
-const sessionPath = `.workflow/${session_id}`;
-if (!fs.existsSync(sessionPath)) {
-  console.error(`❌ Session ${session_id} not found`);
-  process.exit(1);
-}
-```
-
 ## 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
 
+- ✅ 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

@@ -37,17 +37,19 @@ Autonomous task JSON and IMPL_PLAN.md generation using action-planning-agent wit
     // If in memory: use cached content
     // Else: Load from .workflow/{session-id}/workflow-session.json
   },
-  "analysis_results": {
-    // If in memory: use cached content
-    // Else: Load from .workflow/{session-id}/.process/ANALYSIS_RESULTS.md
-  },
-  "artifacts_inventory": {
-    // If in memory: use cached list
-    // Else: Scan .workflow/{session-id}/.brainstorming/ directory
-    "synthesis_specification": "path or null",
-    "topic_framework": "path or null",
-    "role_analyses": ["paths"]
+  "brainstorm_artifacts": {
+    // Loaded from context-package.json → brainstorm_artifacts section
+    "role_analyses": [
+      {
+        "role": "system-architect",
+        "files": [{"path": "...", "type": "primary|supplementary"}]
+      }
+    ],
+    "guidance_specification": {"path": "...", "exists": true},
+    "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
@@ -68,31 +70,38 @@ Autonomous task JSON and IMPL_PLAN.md generation using action-planning-agent wit
    }
    ```
 
-2. **Load Analysis Results** (if not in memory)
+2. **Load Context Package** (if not in memory)
    ```javascript
-   if (!memory.has("ANALYSIS_RESULTS.md")) {
-     Read(.workflow/{session-id}/.process/ANALYSIS_RESULTS.md)
+   if (!memory.has("context-package.json")) {
+     Read(.workflow/{session-id}/.process/context-package.json)
    }
    ```
 
-3. **Discover Artifacts** (if not in memory)
+3. **Extract & Load Role Analyses** (from context-package.json)
    ```javascript
-   if (!memory.has("artifacts_inventory")) {
-     bash(find .workflow/{session-id}/.brainstorming/ -name "*.md" -type f)
+   // Extract role analysis paths from context package
+   const roleAnalysisPaths = contextPackage.brainstorm_artifacts.role_analyses
+     .flatMap(role => role.files.map(f => f.path));
+
+   // Load each role analysis file
+   roleAnalysisPaths.forEach(path => Read(path));
+   ```
+
+4. **Load Conflict Resolution** (from context-package.json, if exists)
+   ```javascript
+   if (contextPackage.brainstorm_artifacts.conflict_resolution?.exists) {
+     Read(contextPackage.brainstorm_artifacts.conflict_resolution.path)
    }
    ```
 
-4. **MCP Code Analysis** (optional - enhance understanding)
-   ```javascript
-   // Find relevant files for task context
-   mcp__code-index__find_files(pattern="*auth*")
-   mcp__code-index__search_code_advanced(
-     pattern="authentication|oauth",
-     file_pattern="*.ts"
-   )
+5. **Code Analysis with Native Tools** (optional - enhance understanding)
+   ```bash
+   # Find relevant files for task context
+   find . -name "*auth*" -type f
+   rg "authentication|oauth" -g "*.ts"
    ```
 
-5. **MCP External Research** (optional - gather best practices)
+6. **MCP External Research** (optional - gather best practices)
    ```javascript
    // Get external examples for implementation
    mcp__exa__get_code_context_exa(
@@ -128,16 +137,24 @@ Task(
 ### Session Metadata
 {session_metadata_content}
 
-### Analysis Results
-{analysis_results_content}
+### Role Analyses (Enhanced by Synthesis)
+{role_analyses_content}
+- Includes requirements, design specs, enhancements, and clarifications from synthesis phase
 
 ### Artifacts Inventory
-- **Synthesis Specification**: {synthesis_spec_path}
-- **Topic Framework**: {topic_framework_path}
+- **Guidance Specification**: {guidance_spec_path}
 - **Role Analyses**: {role_analyses_list}
 
 ### Context Package
 {context_package_summary}
+- Includes conflict_risk assessment
+
+### Conflict Resolution (Conditional)
+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}
@@ -189,8 +206,9 @@ $(cat ~/.claude/workflows/cli-templates/prompts/workflow/impl-plan-template.txt)
 - Use the template above for IMPL_PLAN.md generation
 - Replace all {placeholder} variables with actual session-specific values
 - Populate CCW Workflow Context based on actual phase progression
-- Extract content from ANALYSIS_RESULTS.md and context-package.json
-- List all detected brainstorming artifacts with correct paths
+- Extract content from role analyses and context-package.json
+- List all detected brainstorming artifacts with correct paths (role analyses, guidance-specification.md)
+- Include conflict resolution status if CONFLICT_RESOLUTION.md exists
 
 #### 3. TODO_LIST.md
 **Location**: .workflow/{session-id}/TODO_LIST.md
@@ -222,9 +240,11 @@ $(cat ~/.claude/workflows/cli-templates/prompts/workflow/impl-plan-template.txt)
 - This template is already the correct one based on execution mode
 
 **Step 2: Extract and Decompose Tasks**
-- Parse ANALYSIS_RESULTS.md for task recommendations
+- Parse role analysis.md files for requirements, design specs, and task recommendations
+- Review synthesis enhancements and clarifications in role analyses
+- Apply conflict resolution strategies (if CONFLICT_RESOLUTION.md exists)
 - Apply task merging rules (merge when possible, decompose only when necessary)
-- Map artifacts to tasks based on domain (UI/Backend/Data)
+- Map artifacts to tasks based on domain (UI → ui-designer, Backend → system-architect, Data → data-architect)
 - Ensure task count ≤10
 
 **Step 3: Generate Task JSON Files**
@@ -254,18 +274,13 @@ $(cat ~/.claude/workflows/cli-templates/prompts/workflow/impl-plan-template.txt)
 **Code Index Usage**:
 \`\`\`javascript
 // Discover authentication-related files
-mcp__code-index__find_files(pattern="*auth*")
+bash(find . -name "*auth*" -type f)
 
 // Search for OAuth patterns
-mcp__code-index__search_code_advanced(
-  pattern="oauth|jwt|authentication",
-  file_pattern="*.{ts,js}"
-)
+bash(rg "oauth|jwt|authentication" -g "*.{ts,js}")
 
 // Get file summary for key components
-mcp__code-index__get_file_summary(
-  file_path="src/auth/index.ts"
-)
+bash(rg "^(class|function|export|interface)" src/auth/index.ts)
 \`\`\`
 
 **Exa Research Usage**:
@@ -301,7 +316,7 @@ Before completion, verify:
 
 Generate all three documents and report completion status:
 - Task JSON files created: N files
-- Artifacts integrated: synthesis-spec, topic-framework, N role analyses
+- Artifacts integrated: synthesis-spec, guidance-specification, N role analyses
 - MCP enhancements: code-index, exa-research
 - Session ready for execution: /workflow:execute
 `
@@ -322,17 +337,24 @@ const agentContext = {
     ? memory.get("workflow-session.json")
     : Read(.workflow/WFS-[id]/workflow-session.json),
 
-  analysis_results: memory.has("ANALYSIS_RESULTS.md")
-    ? memory.get("ANALYSIS_RESULTS.md")
-    : Read(.workflow/WFS-[id]/.process/ANALYSIS_RESULTS.md),
-
-  artifacts_inventory: memory.has("artifacts_inventory")
-    ? memory.get("artifacts_inventory")
-    : discoverArtifacts(),
+  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),
+
+  // Load role analyses using paths from context package
+  role_analyses: brainstorm_artifacts.role_analyses
+    .flatMap(role => role.files)
+    .map(file => Read(file.path)),
+
+  // Load conflict resolution if exists (from context package)
+  conflict_resolution: brainstorm_artifacts.conflict_resolution?.exists
+    ? Read(brainstorm_artifacts.conflict_resolution.path)
+    : null,
 
   // Optional MCP enhancements
   mcp_analysis: executeMcpDiscovery()

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

@@ -72,25 +72,35 @@ Generate TDD-specific tasks from analysis results with complete Red-Green-Refact
    - If session metadata in memory → Skip loading
    - Else: Load `.workflow/{session_id}/workflow-session.json`
 
-2. **Analysis Results Loading**
-   - If ANALYSIS_RESULTS.md in memory → Skip loading
-   - Else: Read `.workflow/{session_id}/.process/ANALYSIS_RESULTS.md`
+2. **Conflict Resolution Check** (NEW - Priority Input)
+   - If CONFLICT_RESOLUTION.md exists → Load selected strategies
+   - Else: Skip to brainstorming artifacts
+   - Path: `.workflow/{session_id}/.process/CONFLICT_RESOLUTION.md`
 
 3. **Artifact Discovery**
    - If artifact inventory in memory → Skip scanning
    - Else: Scan `.workflow/{session_id}/.brainstorming/` directory
-   - Detect: synthesis-specification.md, topic-framework.md, role analyses
+   - Detect: role analysis documents, guidance-specification.md, role analyses
+
+4. **Context Package Loading**
+   - Load `.workflow/{session_id}/.process/context-package.json`
+   - Load `.workflow/{session_id}/.process/test-context-package.json` (if exists)
 
 ### Phase 2: TDD Task JSON Generation
 
-**Input**: Use `.process/ANALYSIS_RESULTS.md` directly (enhanced with TDD structure from concept-enhanced phase)
+**Input Sources** (priority order):
+1. **Conflict Resolution** (if exists): `.process/CONFLICT_RESOLUTION.md` - Selected resolution strategies
+2. **Brainstorming Artifacts**: Role analysis documents (system-architect, product-owner, etc.)
+3. **Context Package**: `.process/context-package.json` - Project structure and requirements
+4. **Test Context**: `.process/test-context-package.json` - Existing test patterns
 
-**ANALYSIS_RESULTS.md includes**:
+**TDD Task Structure includes**:
 - Feature list with testable requirements
 - Test cases for Red phase
-- Implementation requirements for Green phase
+- Implementation requirements for Green phase (with test-fix cycle)
 - Refactoring opportunities
 - Task dependencies and execution order
+- Conflict resolution decisions (if applicable)
 
 ### Phase 3: Task JSON & IMPL_PLAN.md Generation
 
@@ -124,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
@@ -247,13 +258,15 @@ Generate IMPL_PLAN.md with 8-section structure:
 ---
 identifier: WFS-{session-id}
 source: "User requirements" | "File: path"
-analysis: .workflow/{session-id}/.process/ANALYSIS_RESULTS.md
+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:
-  concept_verify: "passed | skipped | pending"
+  conflict_resolution: "executed | skipped" # based on conflict_risk
   action_plan_verify: "pending"
-phase_progression: "brainstorm → context → test_context → analysis → concept_verify → tdd_planning"
+phase_progression: "brainstorm → context → test_context → conflict_resolution → tdd_planning"
 feature_count: N
 task_count: N  # ≤10 total
 task_breakdown:
@@ -283,10 +296,10 @@ tdd_workflow: true
 
 ## 3. Brainstorming Artifacts Reference
 - Artifact Usage Strategy
-  - synthesis-specification.md (primary reference)
+  - CONFLICT_RESOLUTION.md (if exists - selected resolution strategies)
+  - role analysis documents (primary reference)
   - test-context-package.json (test patterns)
   - context-package.json (smart context)
-  - ANALYSIS_RESULTS.md (technical analysis)
 - Artifact Priority in Development
 
 ## 4. Implementation Strategy
@@ -397,9 +410,10 @@ Update workflow-session.json with TDD metadata:
 │   ├── IMPL-3.2.json                # Complex feature subtask (if needed)
 │   └── ...
 └── .process/
-    ├── ANALYSIS_RESULTS.md          # Enhanced with TDD breakdown from concept-enhanced
+    ├── 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
 ```
 
@@ -438,7 +452,7 @@ Update workflow-session.json with TDD metadata:
 | Error | Cause | Resolution |
 |-------|-------|------------|
 | Session not found | Invalid session ID | Verify session exists |
-| Analysis missing | Incomplete planning | Run concept-enhanced first |
+| Context missing | Incomplete planning | Run context-gather first |
 
 ### TDD Generation Errors
 | Error | Cause | Resolution |
@@ -452,7 +466,7 @@ Update workflow-session.json with TDD metadata:
 
 ### Command Chain
 - **Called By**: `/workflow:tdd-plan` (Phase 4)
-- **Calls**: Gemini wrapper for TDD breakdown
+- **Calls**: Gemini CLI for TDD breakdown
 - **Followed By**: `/workflow:execute`, `/workflow:tdd-verify`
 
 ### Basic Usage

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

@@ -10,7 +10,7 @@ examples:
 # Task Generation Command
 
 ## 1. Overview
-This command generates task JSON files and an `IMPL_PLAN.md` from `ANALYSIS_RESULTS.md`. It automatically detects and integrates brainstorming artifacts, creating a structured and context-rich plan for implementation. The command supports two primary execution modes: a default agent-based mode for seamless context handling and a `--cli-execute` mode that leverages the Codex CLI for complex, autonomous development tasks. Its core function is to translate analysis into actionable, executable tasks, ensuring all necessary context, dependencies, and implementation steps are defined upfront.
+This command generates task JSON files and an `IMPL_PLAN.md` from brainstorming role analyses. It automatically detects and integrates all brainstorming artifacts (role-specific `analysis.md` files and `guidance-specification.md`), creating a structured and context-rich plan for implementation. The command supports two primary execution modes: a default agent-based mode for seamless context handling and a `--cli-execute` mode that leverages the Codex CLI for complex, autonomous development tasks. Its core function is to translate requirements and design specifications from role analyses into actionable, executable tasks, ensuring all necessary context, dependencies, and implementation steps are defined upfront.
 
 ## 2. Execution Modes
 
@@ -37,8 +37,8 @@ When the `--cli-execute` flag is used, each step in `implementation_approach` **
 ## 3. Core Principles
 This command is built on a set of core principles to ensure efficient and reliable task generation.
 
-- **Analysis-Driven**: All generated tasks originate from `ANALYSIS_RESULTS.md`, ensuring a direct link between analysis and implementation
-- **Artifact-Aware**: Automatically detects and integrates brainstorming outputs (`synthesis-specification.md`, role analyses) to enrich task context
+- **Role Analysis-Driven**: All generated tasks originate from role-specific `analysis.md` files (enhanced in synthesis phase), ensuring direct link between requirements/design and implementation
+- **Artifact-Aware**: Automatically detects and integrates all brainstorming outputs (role analyses, guidance-specification.md, enhancements) to enrich task context
 - **Context-Rich**: Embeds comprehensive context (requirements, focus paths, acceptance criteria, artifact references) directly into each task JSON
 - **Flow-Control Ready**: Pre-defines clear execution sequence (`pre_analysis`, `implementation_approach`) within each task
 - **Memory-First**: Prioritizes using documents already loaded in conversation memory to avoid redundant file operations
@@ -52,8 +52,9 @@ The command follows a streamlined, three-step process to convert analysis into e
 ### Step 1: Input & Discovery
 The process begins by gathering all necessary inputs. It follows a **Memory-First Rule**, skipping file reads if documents are already in the conversation memory.
 1.  **Session Validation**: Loads and validates the session from `.workflow/{session_id}/workflow-session.json`.
-2.  **Analysis Loading**: Reads the primary input, `.workflow/{session_id}/.process/ANALYSIS_RESULTS.md`.
-3.  **Artifact Discovery**: Scans the `.workflow/{session_id}/.brainstorming/` directory to find `synthesis-specification.md`, `topic-framework.md`, and various role analyses.
+2.  **Context Package Loading** (primary source): Reads `.workflow/{session_id}/.process/context-package.json` for smart context and artifact catalog.
+3.  **Brainstorm Artifacts Extraction**: Extracts role analysis paths from `context-package.json` → `brainstorm_artifacts.role_analyses[]` (supports `analysis*.md` automatically).
+4.  **Document Loading**: Reads role analyses, guidance specification, synthesis output, and conflict resolution (if exists) using paths from context package.
 
 ### Step 2: Task Decomposition & Grouping
 Once all inputs are loaded, the command analyzes the tasks defined in the analysis results and groups them based on shared context.
@@ -172,9 +173,10 @@ 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|@general-purpose",
+    "agent": "@code-developer|@test-fix-agent|@universal-executor",
     "execution_group": "group-id|null",
     "context_signature": "hash-of-focus_paths-and-artifacts"
   },
@@ -188,67 +190,60 @@ This enhanced 5-field schema embeds all necessary context, artifacts, and execut
     "shared_context": {"tech_stack": [], "conventions": []},
     "artifacts": [
       {
-        "type": "synthesis_specification",
-        "source": "brainstorm_synthesis",
-        "path": ".workflow/WFS-[session]/.brainstorming/synthesis-specification.md",
+        "path": "{{from context-package.json → brainstorm_artifacts.role_analyses[].files[].path}}",
         "priority": "highest",
-        "usage": "Primary requirement source - use for consolidated requirements and cross-role alignment"
+        "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."
       },
       {
-        "type": "role_analysis",
-        "source": "brainstorm_roles",
-        "path": ".workflow/WFS-[session]/.brainstorming/[role-name]/analysis.md",
+        "path": ".workflow/WFS-[session]/.brainstorming/guidance-specification.md",
         "priority": "high",
-        "usage": "Technical/design/business details from specific roles. Common roles: system-architect (ADRs, APIs, caching), ui-designer (design tokens, layouts), product-manager (user stories, metrics)",
-        "note": "Dynamically discovered - multiple role analysis files may be included based on brainstorming results"
-      },
-      {
-        "type": "topic_framework",
-        "source": "brainstorm_framework",
-        "path": ".workflow/WFS-[session]/.brainstorming/topic-framework.md",
-        "priority": "low",
-        "usage": "Discussion context and framework structure"
+        "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"
       }
     ]
   },
   "flow_control": {
     "pre_analysis": [
       {
-        "step": "load_synthesis_specification",
-        "action": "Load consolidated synthesis specification",
+        "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": [
-          "bash(ls .workflow/WFS-[session]/.brainstorming/synthesis-specification.md 2>/dev/null || echo 'not found')",
-          "Read(.workflow/WFS-[session]/.brainstorming/synthesis-specification.md)"
+          "Read({{context_package_path}})"
         ],
-        "output_to": "synthesis_specification",
-        "on_error": "skip_optional"
+        "output_to": "context_package",
+        "on_error": "fail"
       },
       {
         "step": "load_role_analysis_artifacts",
-        "action": "Load role-specific analysis documents for technical details",
-        "note": "These artifacts contain implementation details not in synthesis. Consult when needing: API schemas, caching configs, design tokens, ADRs, performance metrics.",
+        "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": [
-          "bash(find .workflow/WFS-[session]/.brainstorming/ -name 'analysis.md' 2>/dev/null | head -8)",
-          "Read(.workflow/WFS-[session]/.brainstorming/system-architect/analysis.md)",
-          "Read(.workflow/WFS-[session]/.brainstorming/ui-designer/analysis.md)",
-          "Read(.workflow/WFS-[session]/.brainstorming/product-manager/analysis.md)"
+          "Read({{context_package_path}})",
+          "Extract(brainstorm_artifacts.role_analyses[].files[].path)",
+          "Read(each extracted path)"
         ],
         "output_to": "role_analysis_artifacts",
         "on_error": "skip_optional"
       },
       {
         "step": "load_planning_context",
-        "action": "Load plan-generated analysis",
+        "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/ANALYSIS_RESULTS.md)",
-          "Read(.workflow/WFS-[session]/.process/context-package.json)"
+          "Read({{context_package_path}})",
+          "Read(.workflow/WFS-[session]/.brainstorming/guidance-specification.md)"
         ],
-        "output_to": "planning_context"
+        "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 status (resolved/none/low)",
+          "guidance-specification.md": "Use for finalized design decisions (includes applied conflict resolutions if any)"
+        }
       },
       {
-        "step": "mcp_codebase_exploration",
-        "action": "Explore codebase using MCP tools",
-        "command": "mcp__code-index__find_files(pattern=\"[patterns]\") && mcp__code-index__search_code_advanced(pattern=\"[patterns]\")",
+        "step": "codebase_exploration",
+        "action": "Explore codebase using native tools",
+        "command": "bash(find . -name \"[patterns]\" -type f && rg \"[patterns]\")",
         "output_to": "codebase_structure"
       },
       {
@@ -256,7 +251,7 @@ This enhanced 5-field schema embeds all necessary context, artifacts, and execut
         "action": "Analyze existing code patterns and identify modification targets",
         "commands": [
           "bash(cd \"[focus_paths]\")",
-          "bash(gemini \"PURPOSE: Identify modification targets TASK: Analyze '[title]' and locate specific files/functions/lines to modify CONTEXT: [synthesis_specification] [individual_artifacts] EXPECTED: Code locations in format 'file:function:lines' RULES: Prioritize synthesis-specification.md, identify exact modification points\")"
+          "bash(gemini \"PURPOSE: Identify modification targets TASK: Analyze '[title]' and locate specific files/functions/lines to modify CONTEXT: [role_analyses] [individual_artifacts] EXPECTED: Code locations in format 'file:function:lines' RULES: Consult role analyses for requirements, identify exact modification points\")"
         ],
         "output_to": "task_context_with_targets",
         "on_error": "fail"
@@ -265,20 +260,26 @@ This enhanced 5-field schema embeds all necessary context, artifacts, and execut
     "implementation_approach": [
       {
         "step": 1,
-        "title": "Implement task following synthesis specification",
-        "description": "Implement '[title]' following synthesis specification. PRIORITY: Use synthesis-specification.md as primary requirement source. When implementation needs technical details (e.g., API schemas, caching configs, design tokens), refer to artifacts[] for detailed specifications from original role analyses.",
+        "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) 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 consolidated requirements from synthesis-specification.md",
-          "Follow technical guidelines from synthesis",
-          "Consult artifacts for implementation details when needed",
+          "Apply requirements and design specs from role analysis documents",
+          "Use enhancements and clarifications from synthesis phase",
+          "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 synthesis specification",
-          "Extract requirements and design",
-          "Analyze existing patterns",
-          "Implement following specification",
-          "Consult artifacts for technical details when needed",
+          "Load role analyses (requirements, design, enhancements from synthesis)",
+          "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",
+          "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",
           "Validate against acceptance criteria"
         ],
         "depends_on": [],
@@ -297,14 +298,16 @@ This document provides a high-level overview of the entire implementation plan.
 ---
 identifier: WFS-{session-id}
 source: "User requirements" | "File: path" | "Issue: ISS-001"
-analysis: .workflow/{session-id}/.process/ANALYSIS_RESULTS.md
+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
+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
-  concept_verify: "passed | skipped | pending"
+  synthesis_clarify: "passed | skipped | pending"  # Brainstorm phase clarification
   action_plan_verify: "pending"
-phase_progression: "brainstorm → context → analysis → concept_verify → 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}
@@ -323,14 +326,14 @@ Core requirements, objectives, technical approach summary (2-3 paragraphs max).
 
 ### CCW Workflow Context
 **Phase Progression**:
-- ✅ Phase 1: Brainstorming (synthesis-specification.md generated)
-- ✅ Phase 2: Context Gathering (context-package.json: {N} files, {M} modules analyzed)
-- ✅ Phase 3: Enhanced Analysis (ANALYSIS_RESULTS.md: Gemini/Qwen/Codex parallel insights)
-- ✅ Phase 4: Concept Verification ({X} clarifications answered, synthesis updated | skipped)
-- ⏳ Phase 5: Action Planning (current phase - generating IMPL_PLAN.md)
+- ✅ Phase 1: Brainstorming (role analyses generated by participating roles)
+- ✅ Phase 2: Synthesis (concept enhancement + clarification, {N} questions answered, role analyses refined)
+- ✅ Phase 3: Context Gathering (context-package.json: {N} files, {M} modules analyzed, conflict_risk: {level})
+- ✅ Phase 4: Conflict Resolution ({status}: {conflict_count} conflicts detected and resolved | skipped if no conflicts)
+- ⏳ Phase 5: Task Generation (current phase - generating IMPL_PLAN.md and task JSONs)
 
 **Quality Gates**:
-- concept-verify: ✅ Passed (0 ambiguities remaining) | ⏭️ Skipped (user decision) | ⏳ Pending
+- synthesis-clarify: ✅ Passed ({N} ambiguities resolved, {M} enhancements applied)
 - action-plan-verify: ⏳ Pending (recommended before /workflow:execute)
 
 **Context Package Summary**:
@@ -364,40 +367,42 @@ Core requirements, objectives, technical approach summary (2-3 paragraphs max).
 ## 3. Brainstorming Artifacts Reference
 
 ### Artifact Usage Strategy
-**Primary Reference (synthesis-specification.md)**:
-- **What**: Comprehensive implementation blueprint from multi-role synthesis
-- **When**: Every task references this first for requirements and design decisions
-- **How**: Extract architecture decisions, UI/UX patterns, functional requirements, non-functional requirements
-- **Priority**: Authoritative - overrides role-specific analyses when conflicts arise
-- **CCW Value**: Consolidates insights from all brainstorming roles into single source of truth
+**Primary Reference (Role Analyses)**:
+- **What**: Role-specific analyses from brainstorming phase providing multi-perspective insights
+- **When**: Every task references relevant role analyses for requirements and design decisions
+- **How**: Extract requirements, architecture decisions, UI/UX patterns from applicable role documents
+- **Priority**: Collective authoritative source - multiple role perspectives provide comprehensive coverage
+- **CCW Value**: Maintains role-specific expertise while enabling cross-role integration during planning
 
 **Context Intelligence (context-package.json)**:
 - **What**: Smart context gathered by CCW's context-gather phase
-- **Content**: Focus paths, dependency graph, existing patterns, module structure
-- **Usage**: Tasks load this via `flow_control.preparatory_steps` for environment setup
+- **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
 
-**Technical Analysis (ANALYSIS_RESULTS.md)**:
-- **What**: Gemini/Qwen/Codex parallel analysis results
-- **Content**: Optimization strategies, risk assessment, architecture review, implementation patterns
-- **Usage**: Referenced in task planning for technical guidance and risk mitigation
-- **CCW Value**: Multi-model parallel analysis providing comprehensive technical intelligence
+**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
 
-### Integrated Specifications (Highest Priority)
-- **synthesis-specification.md**: Comprehensive implementation blueprint
-  - Contains: Architecture design, UI/UX guidelines, functional/non-functional requirements, implementation roadmap, risk assessment
+### Role Analysis Documents (Highest Priority)
+Role analyses provide specialized perspectives on the implementation:
+- **system-architect/analysis.md**: Architecture design, ADRs, API specifications, caching strategies
+- **ui-designer/analysis.md**: Design tokens, layout specifications, component patterns
+- **ux-expert/analysis.md**: User journeys, interaction flows, accessibility requirements
+- **guidance-specification/analysis.md**: Product vision, user stories, business requirements, success metrics
+- **data-architect/analysis.md**: Data models, schemas, database design, migration strategies
+- **api-designer/analysis.md**: API contracts, endpoint specifications, integration patterns
 
 ### Supporting Artifacts (Reference)
 - **topic-framework.md**: Role-specific discussion points and analysis framework
-- **system-architect/analysis.md**: Detailed architecture specifications
-- **ui-designer/analysis.md**: Layout and component specifications
-- **product-manager/analysis.md**: Product vision and user stories
 
 **Artifact Priority in Development**:
-1. synthesis-specification.md (primary reference for all tasks)
-2. context-package.json (smart context for execution environment)
-3. ANALYSIS_RESULTS.md (technical analysis and optimization strategies)
-4. Role-specific analyses (fallback for detailed specifications)
+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
 
@@ -414,7 +419,7 @@ Core requirements, objectives, technical approach summary (2-3 paragraphs max).
 
 ### Architectural Approach
 **Key Architecture Decisions**:
-- [ADR references from synthesis]
+- [ADR references from role analyses]
 - [Justification for architecture patterns]
 
 **Integration Strategy**:
@@ -506,7 +511,7 @@ Core requirements, objectives, technical approach summary (2-3 paragraphs max).
 ## 8. Success Criteria
 
 **Functional Completeness**:
-- [ ] All requirements from synthesis-specification.md implemented
+- [ ] All requirements from role analysis documents implemented
 - [ ] All acceptance criteria from task.json files met
 
 **Technical Quality**:
@@ -520,7 +525,7 @@ Core requirements, objectives, technical approach summary (2-3 paragraphs max).
 - [ ] Documentation complete
 
 **Business Metrics**:
-- [ ] [Key business metrics from synthesis]
+- [ ] [Key business metrics from role analyses]
 ```
 
 ### 6.3. TODO_LIST.md Structure
@@ -553,40 +558,38 @@ The command organizes outputs into a standard directory structure.
 │   ├── IMPL-1.json                  # Container task
 │   ├── IMPL-1.1.json                # Leaf task with flow_control
 │   └── IMPL-1.2.json                # Leaf task with flow_control
-├── .brainstorming/                  # Input artifacts
-│   ├── synthesis-specification.md
-│   ├── topic-framework.md
-│   └── {role}/analysis.md
+├── .brainstorming              # Input artifacts from brainstorm + synthesis
+│   ├── guidance-specification.md    # Finalized decisions (with resolved conflicts if any)
+│   └── {role}/analysis*.md          # Role analyses (enhanced by synthesis, with resolved conflicts if any)
 └── .process/
-    ├── ANALYSIS_RESULTS.md          # Input from concept-enhanced
-    └── context-package.json         # Input from context-gather
+    └── 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.  **synthesis-specification.md** (highest): The complete, integrated specification that serves as the primary source of truth.
-2.  **topic-framework.md** (medium): The discussion framework that provides high-level structure.
-3.  **role/analysis.md** (low): Individual role-based analyses that offer detailed, perspective-specific insights.
+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.
-- **synthesis-specification.md**: Included in all tasks as the primary reference.
-- **ui-designer/analysis.md**: Mapped to UI/Frontend tasks.
-- **system-architect/analysis.md**: Mapped to Architecture/Backend tasks.
-- **subject-matter-expert/analysis.md**: Mapped to tasks related to domain logic or standards.
-- **data-architect/analysis.md**: Mapped to tasks involving data models or APIs.
+- **Role analysis.md files**: Primary requirements source - all relevant role analyses included based on task type
+- **ui-designer/analysis.md**: Mapped to UI/Frontend tasks for design tokens, layouts, components
+- **system-architect/analysis.md**: Mapped to Architecture/Backend tasks for ADRs, APIs, patterns
+- **subject-matter-expert/analysis.md**: Mapped to tasks related to domain logic or standards
+- **data-architect/analysis.md**: Mapped to tasks involving data models, schemas, or APIs
+- **product-manager/analysis.md**: Mapped to all tasks for business requirements and user stories
 
-This ensures that each task has access to the most relevant and detailed specifications, from the high-level synthesis down to the role-specific details.
+This ensures that each task has access to the most relevant and detailed specifications from role-specific analyses.
 
 ## 8. CLI Execute Mode Details
 When using `--cli-execute`, each step in `implementation_approach` includes a `command` field with the execution command.
 
 **Key Points**:
 - **Sequential Steps**: Steps execute in order defined in `implementation_approach` array
-- **Context Delivery**: Each codex command receives context via CONTEXT field: `@{.workflow/{session}/.process/context-package.json}` and `@{.workflow/{session}/.brainstorming/synthesis-specification.md}`
-- **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)
@@ -594,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"],
@@ -607,16 +611,20 @@ When using `--cli-execute`, each step in `implementation_approach` includes a `c
   "flow_control": {
     "pre_analysis": [
       {
-        "step": "load_synthesis",
-        "action": "Load synthesis specification for requirements",
-        "commands": ["Read(.workflow/WFS-session/.brainstorming/synthesis-specification.md)"],
-        "output_to": "synthesis_spec",
+        "step": "load_role_analyses",
+        "action": "Load role analyses from context-package.json",
+        "commands": [
+          "Read({{context_package_path}})",
+          "Extract(brainstorm_artifacts.role_analyses[].files[].path)",
+          "Read(each extracted path)"
+        ],
+        "output_to": "role_analyses",
         "on_error": "fail"
       },
       {
         "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"
       }
@@ -625,7 +633,7 @@ When using `--cli-execute`, each step in `implementation_approach` includes a `c
       {
         "step": 1,
         "title": "Implement JWT-based authentication",
-        "description": "Create authentication module using JWT following [synthesis_spec] requirements and [context_pkg] patterns",
+        "description": "Create authentication module using JWT following [role_analyses] requirements and [context_pkg] patterns",
         "modification_points": [
           "Create auth service with JWT generation",
           "Implement login endpoint with credential validation",
@@ -651,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"],
@@ -660,10 +669,14 @@ When using `--cli-execute`, each step in `implementation_approach` includes a `c
   "flow_control": {
     "pre_analysis": [
       {
-        "step": "load_synthesis",
-        "action": "Load synthesis specification",
-        "commands": ["Read(.workflow/WFS-session/.brainstorming/synthesis-specification.md)"],
-        "output_to": "synthesis_spec",
+        "step": "load_role_analyses",
+        "action": "Load role analyses from context-package.json",
+        "commands": [
+          "Read({{context_package_path}})",
+          "Extract(brainstorm_artifacts.role_analyses[].files[].path)",
+          "Read(each extracted path)"
+        ],
+        "output_to": "role_analyses",
         "on_error": "fail"
       }
     ],
@@ -672,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} @{.workflow/WFS-session/.brainstorming/synthesis-specification.md} EXPECTED: Complete auth module with tests RULES: Follow synthesis specification\" --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": [],
@@ -689,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"],
@@ -699,10 +713,11 @@ When using `--cli-execute`, each step in `implementation_approach` includes a `c
     "pre_analysis": [
       {
         "step": "load_context",
-        "action": "Load context and synthesis",
+        "action": "Load context and role analyses from context-package.json",
         "commands": [
-          "Read(.workflow/WFS-session/.process/context-package.json)",
-          "Read(.workflow/WFS-session/.brainstorming/synthesis-specification.md)"
+          "Read({{context_package_path}})",
+          "Extract(brainstorm_artifacts.role_analyses[].files[].path)",
+          "Read(each extracted path)"
         ],
         "output_to": "full_context",
         "on_error": "fail"
@@ -713,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} @{.workflow/WFS-session/.brainstorming/synthesis-specification.md} EXPECTED: Models with migrations RULES: Follow synthesis spec\" --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": [],
@@ -762,7 +777,7 @@ When using `--cli-execute`, each step in `implementation_approach` includes a `c
 | Error | Cause | Resolution |
 |-------|-------|------------|
 | Session not found | Invalid session ID | Verify session exists |
-| Analysis missing | Incomplete planning | Run concept-enhanced first |
+| Context missing | Incomplete planning | Run context-gather first |
 | Invalid format | Corrupted results | Regenerate analysis |
 
 ### Task Generation Errors
@@ -795,5 +810,5 @@ When using `--cli-execute`, each step in `implementation_approach` includes a `c
 - `/workflow:plan` - Orchestrates entire planning
 - `/workflow:plan --cli-execute` - Planning with CLI execution mode
 - `/workflow:tools:context-gather` - Provides context package
-- `/workflow:tools:concept-enhanced` - Provides analysis results
+- `/workflow:tools:conflict-resolution` - Provides conflict resolution strategies (optional)
 - `/workflow:execute` - Executes generated tasks

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

@@ -17,11 +17,11 @@ Specialized context collector for test generation workflows that analyzes test c
 - **Gap Identification**: Locate implementation files without corresponding tests
 - **Source Context Loading**: Import implementation summaries from source session
 - **Framework Detection**: Auto-detect test framework and patterns
-- **MCP-Powered**: Leverage code-index tools for precise analysis
+- **Ripgrep-Powered**: Leverage ripgrep and native tools for precise analysis
 
 ## Core Responsibilities
 - Load source session implementation context
-- Analyze current test coverage using MCP tools
+- Analyze current test coverage using ripgrep
 - Identify files requiring test generation
 - Detect test framework and conventions
 - Package test context for analysis phase
@@ -41,21 +41,17 @@ Specialized context collector for test generation workflows that analyzes test c
    - Extract changed files and implementation scope
    - Identify implementation patterns and tech stack
 
-### Phase 2: Test Coverage Analysis (MCP Tools)
+### Phase 2: Test Coverage Analysis (Ripgrep)
 
 1. **Existing Test Discovery**
    ```bash
    # Find all test files
-   mcp__code-index__find_files(pattern="*.test.*")
-   mcp__code-index__find_files(pattern="*.spec.*")
-   mcp__code-index__find_files(pattern="*test_*.py")
+   find . -name "*.test.*" -type f
+   find . -name "*.spec.*" -type f
+   find . -name "*test_*.py" -type f
 
    # Search for test patterns
-   mcp__code-index__search_code_advanced(
-     pattern="describe|it|test|@Test",
-     file_pattern="*.test.*",
-     context_lines=0
-   )
+   rg "describe|it|test|@Test" -g "*.test.*"
    ```
 
 2. **Coverage Gap Analysis**
@@ -80,18 +76,10 @@ Specialized context collector for test generation workflows that analyzes test c
 1. **Framework Identification**
    ```bash
    # Check package.json or requirements.txt
-   mcp__code-index__search_code_advanced(
-     pattern="jest|mocha|jasmine|pytest|unittest|rspec",
-     file_pattern="package.json|requirements.txt|Gemfile",
-     context_lines=2
-   )
+   rg "jest|mocha|jasmine|pytest|unittest|rspec" -g "package.json" -g "requirements.txt" -g "Gemfile" -C 2
 
    # Analyze existing test patterns
-   mcp__code-index__search_code_advanced(
-     pattern="describe\\(|it\\(|test\\(|def test_",
-     file_pattern="*.test.*",
-     context_lines=3
-   )
+   rg "describe\(|it\(|test\(|def test_" -g "*.test.*" -C 3
    ```
 
 2. **Convention Analysis**
@@ -207,33 +195,26 @@ Generate `test-context-package.json`:
 .workflow/{test_session_id}/.process/test-context-package.json
 ```
 
-## MCP Tools Usage
+## Native Tools Usage
 
 ### File Discovery
 ```bash
 # Test files
-mcp__code-index__find_files(pattern="*.test.*")
-mcp__code-index__find_files(pattern="*.spec.*")
+find . -name "*.test.*" -type f
+find . -name "*.spec.*" -type f
 
 # Implementation files
-mcp__code-index__find_files(pattern="*.ts")
-mcp__code-index__find_files(pattern="*.js")
+find . -name "*.ts" -type f
+find . -name "*.js" -type f
 ```
 
 ### Content Search
 ```bash
 # Test framework detection
-mcp__code-index__search_code_advanced(
-  pattern="jest|mocha|pytest",
-  file_pattern="package.json|requirements.txt"
-)
+rg "jest|mocha|pytest" -g "package.json" -g "requirements.txt"
 
 # Test pattern analysis
-mcp__code-index__search_code_advanced(
-  pattern="describe|it|test",
-  file_pattern="*.test.*",
-  context_lines=2
-)
+rg "describe|it|test" -g "*.test.*" -C 2
 ```
 
 ### Coverage Analysis
@@ -249,7 +230,7 @@ test_file_patterns=(
 
 # Search for test file
 for pattern in "${test_file_patterns[@]}"; do
-  if mcp__code-index__find_files(pattern="$pattern") | grep -q .; then
+  if [ -f "$pattern" ]; then
     echo "✅ Test exists: $pattern"
     break
   fi
@@ -262,10 +243,9 @@ done
 |-------|-------|------------|
 | Source session not found | Invalid source_session reference | Verify test session metadata |
 | No implementation summaries | Source session incomplete | Complete source session first |
-| MCP tools unavailable | MCP not configured | Fallback to bash find/grep |
 | No test framework detected | Missing test dependencies | Request user to specify framework |
 
-## Fallback Strategy (No MCP)
+## Native Tools Implementation
 
 ```bash
 # File discovery
@@ -287,8 +267,8 @@ done
 - `/workflow:test-gen` (Phase 3: Context Gathering)
 
 ### Calls
-- MCP code-index tools for analysis
-- Bash file operations for fallback
+- Ripgrep and find for file analysis
+- Bash file operations for coverage analysis
 
 ### Followed By
 - `/workflow:tools:test-concept-enhanced` - Analyzes context and plans test generation
@@ -296,7 +276,7 @@ done
 ## Success Criteria
 
 - ✅ Source session context loaded successfully
-- ✅ Test coverage gaps identified with MCP tools
+- ✅ Test coverage gaps identified with ripgrep
 - ✅ Test framework detected and documented
 - ✅ Valid test-context-package.json generated
 - ✅ All missing tests catalogued with priority

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

@@ -146,9 +146,9 @@ Generate **TWO task JSON files**:
         "step": "load_existing_test_patterns",
         "action": "Study existing tests for pattern reference",
         "commands": [
-          "mcp__code-index__find_files(pattern=\"*.test.*\")",
+          "bash(find . -name \"*.test.*\" -type f)",
           "bash(# Read first 2 existing test files as examples)",
-          "bash(test_files=$(mcp__code-index__find_files(pattern=\"*.test.*\") | head -2))",
+          "bash(test_files=$(find . -name \"*.test.*\" -type f | head -2))",
           "bash(for f in $test_files; do echo \"=== $f ===\"&& cat \"$f\"; done)"
         ],
         "output_to": "existing_test_patterns",
@@ -282,11 +282,11 @@ Generate **TWO task JSON files**:
         "step": "analyze_test_coverage",
         "action": "Analyze test coverage and identify missing tests",
         "commands": [
-          "mcp__code-index__find_files(pattern=\"*.test.*\")",
-          "mcp__code-index__search_code_advanced(pattern=\"test|describe|it|def test_\", file_pattern=\"*.test.*\")",
+          "bash(find . -name \"*.test.*\" -type f)",
+          "bash(rg \"test|describe|it|def test_\" -g \"*.test.*\")",
           "bash(# Count implementation files vs test files)",
           "bash(impl_count=$(find [changed_files_dirs] -type f \\( -name '*.ts' -o -name '*.js' -o -name '*.py' \\) ! -name '*.test.*' 2>/dev/null | wc -l))",
-          "bash(test_count=$(mcp__code-index__find_files(pattern=\"*.test.*\") | wc -l))",
+          "bash(test_count=$(find . -name \"*.test.*\" -type f | wc -l))",
           "bash(echo \"Implementation files: $impl_count, Test files: $test_count\")"
         ],
         "output_to": "test_coverage_analysis",

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

@@ -205,7 +205,7 @@ ELSE IF --prompt:
     target_source = "prompt_analysis"
 
 # Step 4: Session synthesis
-ELSE IF --session AND exists(synthesis-specification.md):
+ELSE IF --session AND exists(role analysis documents):
     target_list = extract_targets_from_synthesis(); target_type = "page"; target_source = "synthesis"
 
 # Step 5: Fallback

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

@@ -154,7 +154,7 @@ IF exists: SKIP to completion
 ### Step 2: Load Project Context (Explore Mode)
 ```bash
 # Load brainstorming context if available
-bash(test -f {base_path}/.brainstorming/synthesis-specification.md && cat it)
+bash(test -f {base_path}/.brainstorming/role analysis documents && cat it)
 ```
 
 ### Step 3: Generate Design Direction Options (Agent Task 1)
@@ -541,7 +541,7 @@ bash(cat {base_path}/style-extraction/style-1/design-tokens.json | grep -q "colo
 ### File Operations
 ```bash
 # Load brainstorming context
-bash(test -f .brainstorming/synthesis-specification.md && cat it)
+bash(test -f .brainstorming/role analysis documents && cat it)
 
 # Create directories
 bash(mkdir -p {base_path}/style-extraction/style-{{1..3}})

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

@@ -15,7 +15,7 @@ Synchronize finalized design system references to brainstorming artifacts, prepa
 
 - **Reference-Only Updates**: Use @ references, no content duplication
 - **Main Claude Execution**: Direct updates by main Claude (no Agent handoff)
-- **Synthesis Alignment**: Update synthesis-specification.md UI/UX Guidelines section
+- **Synthesis Alignment**: Update role analysis documents UI/UX Guidelines section
 - **Plan-Ready Output**: Ensure design artifacts discoverable by task-generate
 - **Minimal Reading**: Verify file existence, don't read design content
 
@@ -50,8 +50,8 @@ REPORT: "Found {count} design artifacts, {prototype_count} prototypes"
 ### Phase 1.1: Memory Check (Skip if Already Updated)
 
 ```bash
-# Check if synthesis-specification.md contains current design run reference
-synthesis_spec_path = ".workflow/WFS-{session}/.brainstorming/synthesis-specification.md"
+# Check if role analysis documents contains current design run reference
+synthesis_spec_path = ".workflow/WFS-{session}/.brainstorming/role analysis documents"
 current_design_run = basename(latest_design)  # e.g., "design-run-20250109-143022"
 
 IF exists(synthesis_spec_path):
@@ -68,7 +68,7 @@ IF exists(synthesis_spec_path):
 
 ```bash
 # Load target brainstorming artifacts (files to be updated)
-Read(.workflow/WFS-{session}/.brainstorming/synthesis-specification.md)
+Read(.workflow/WFS-{session}/.brainstorming/role analysis documents)
 IF exists(.workflow/WFS-{session}/.brainstorming/ui-designer/analysis.md): Read(analysis.md)
 
 # Optional: Read prototype notes for descriptions (minimal context)
@@ -80,7 +80,7 @@ FOR each selected_prototype IN selected_list:
 
 ### Phase 3: Update Synthesis Specification
 
-Update `.brainstorming/synthesis-specification.md` with design system references.
+Update `.brainstorming/role analysis documents` with design system references.
 
 **Target Section**: `## UI/UX Guidelines`
 
@@ -113,7 +113,7 @@ Update `.brainstorming/synthesis-specification.md` with design system references
 **Implementation**:
 ```bash
 # Option 1: Edit existing section
-Edit(file_path=".workflow/WFS-{session}/.brainstorming/synthesis-specification.md",
+Edit(file_path=".workflow/WFS-{session}/.brainstorming/role analysis documents",
      old_string="## UI/UX Guidelines\n[existing content]",
      new_string="## UI/UX Guidelines\n\n[new design reference content]")
 
@@ -122,12 +122,77 @@ IF section not found:
     Edit(file_path="...", old_string="[end of document]", new_string="\n\n## UI/UX Guidelines\n\n[new design reference content]")
 ```
 
-### Phase 4: Update UI Designer Style Guide
+### Phase 4A: Update Relevant Role Analysis Documents
 
-Create or update `.brainstorming/ui-designer/style-guide.md`:
+**Discovery**: Find role analysis.md files affected by design outputs
+
+```bash
+# Always update ui-designer
+ui_designer_files = Glob(".workflow/WFS-{session}/.brainstorming/ui-designer/analysis*.md")
+
+# Conditionally update other roles
+has_animations = exists({latest_design}/animation-extraction/animation-tokens.json)
+has_layouts = exists({latest_design}/layout-extraction/layout-templates.json)
+
+IF has_animations: ux_expert_files = Glob(".workflow/WFS-{session}/.brainstorming/ux-expert/analysis*.md")
+IF has_layouts: architect_files = Glob(".workflow/WFS-{session}/.brainstorming/system-architect/analysis*.md")
+IF selected_list: pm_files = Glob(".workflow/WFS-{session}/.brainstorming/product-manager/analysis*.md")
+```
+
+**Content Templates**:
+
+**ui-designer/analysis.md** (append if not exists):
+```markdown
+## Design System Implementation Reference
+
+**Design Tokens**: @../../design-{run_id}/{design_tokens_path}
+**Style Guide**: @../../design-{run_id}/{style_guide_path}
+**Prototypes**: {FOR each: @../../design-{run_id}/prototypes/{prototype}.html}
+
+*Reference added by /workflow:ui-design:update*
+```
+
+**ux-expert/analysis.md** (if animations):
+```markdown
+## Animation & Interaction Reference
+
+**Animations**: @../../design-{run_id}/animation-extraction/animation-tokens.json
+**Prototypes**: {FOR each: @../../design-{run_id}/prototypes/{prototype}.html}
+
+*Reference added by /workflow:ui-design:update*
+```
+
+**system-architect/analysis.md** (if layouts):
+```markdown
+## Layout Structure Reference
+
+**Layout Templates**: @../../design-{run_id}/layout-extraction/layout-templates.json
+
+*Reference added by /workflow:ui-design:update*
+```
+
+**product-manager/analysis.md** (if prototypes):
+```markdown
+## Prototype Validation Reference
+
+**Prototypes**: {FOR each: @../../design-{run_id}/prototypes/{prototype}.html}
+
+*Reference added by /workflow:ui-design:update*
+```
+
+**Implementation**:
+```bash
+FOR file IN [ui_designer_files, ux_expert_files, architect_files, pm_files]:
+  IF file exists AND section_not_exists(file):
+    Edit(file, old_string="[end of document]", new_string="\n\n{role-specific section}")
+```
+
+### Phase 4B: Create UI Designer Design System Reference
+
+Create or update `.brainstorming/ui-designer/design-system-reference.md`:
 
 ```markdown
-# UI Designer Style Guide
+# UI Designer Design System Reference
 
 ## Design System Integration
 This style guide references the finalized design system from the design refinement phase.
@@ -158,7 +223,7 @@ For complete token definitions and usage examples, see:
 
 **Implementation**:
 ```bash
-Write(file_path=".workflow/WFS-{session}/.brainstorming/ui-designer/style-guide.md",
+Write(file_path=".workflow/WFS-{session}/.brainstorming/ui-designer/design-system-reference.md",
       content="[generated content with @ references]")
 ```
 
@@ -168,8 +233,9 @@ Write(file_path=".workflow/WFS-{session}/.brainstorming/ui-designer/style-guide.
 TodoWrite({todos: [
   {content: "Validate session and design system artifacts", status: "completed", activeForm: "Validating artifacts"},
   {content: "Load target brainstorming artifacts", status: "completed", activeForm: "Loading target files"},
-  {content: "Update synthesis-specification.md with design references", status: "completed", activeForm: "Updating synthesis spec"},
-  {content: "Create/update ui-designer/style-guide.md", status: "completed", activeForm: "Updating UI designer guide"}
+  {content: "Update role analysis documents with design references", status: "completed", activeForm: "Updating synthesis spec"},
+  {content: "Update relevant role analysis.md documents", status: "completed", activeForm: "Updating role analysis files"},
+  {content: "Create/update ui-designer/design-system-reference.md", status: "completed", activeForm: "Creating design system reference"}
 ]});
 ```
 
@@ -178,8 +244,9 @@ TodoWrite({todos: [
 ✅ Design system references updated for session: WFS-{session}
 
 Updated artifacts:
-✓ synthesis-specification.md - UI/UX Guidelines section with @ references
-✓ ui-designer/style-guide.md - Design system reference guide
+✓ role analysis documents - UI/UX Guidelines section with @ references
+✓ {role_count} role analysis.md files - Design system references
+✓ ui-designer/design-system-reference.md - Design system reference guide
 
 Design system assets ready for /workflow:plan:
 - design-tokens.json | style-guide.md | {prototype_count} reference prototypes
@@ -193,31 +260,43 @@ Next: /workflow:plan [--agent] "<task description>"
 **Updated Files**:
 ```
 .workflow/WFS-{session}/.brainstorming/
-├── synthesis-specification.md       # Updated with UI/UX Guidelines section
-└── ui-designer/
-    └── style-guide.md               # New or updated design reference guide
+├── role analysis documents              # Updated with UI/UX Guidelines section
+├── ui-designer/
+│   ├── analysis*.md                     # Updated with design system references
+│   └── design-system-reference.md       # New or updated design reference guide
+├── ux-expert/analysis*.md               # Updated if animations exist
+├── product-manager/analysis*.md         # Updated if prototypes exist
+└── system-architect/analysis*.md        # Updated if layouts exist
 ```
 
-**@ Reference Format** (synthesis-specification.md):
+**@ Reference Format** (role analysis documents):
 ```
 @../design-{run_id}/style-extraction/style-1/design-tokens.json
 @../design-{run_id}/style-extraction/style-1/style-guide.md
 @../design-{run_id}/prototypes/{prototype}.html
 ```
 
-**@ Reference Format** (ui-designer/style-guide.md):
+**@ Reference Format** (ui-designer/design-system-reference.md):
 ```
 @../../design-{run_id}/style-extraction/style-1/design-tokens.json
 @../../design-{run_id}/style-extraction/style-1/style-guide.md
 @../../design-{run_id}/prototypes/{prototype}.html
 ```
 
+**@ Reference Format** (role analysis.md files):
+```
+@../../design-{run_id}/style-extraction/style-1/design-tokens.json
+@../../design-{run_id}/animation-extraction/animation-tokens.json
+@../../design-{run_id}/layout-extraction/layout-templates.json
+@../../design-{run_id}/prototypes/{prototype}.html
+```
+
 ## Integration with /workflow:plan
 
 After this update, `/workflow:plan` will discover design assets through:
 
 **Phase 3: Intelligent Analysis** (`/workflow:tools:concept-enhanced`)
-- Reads synthesis-specification.md → Discovers @ references → Includes design system context in ANALYSIS_RESULTS.md
+- Reads role analysis documents → Discovers @ references → Includes design system context in ANALYSIS_RESULTS.md
 
 **Phase 4: Task Generation** (`/workflow:tools:task-generate`)
 - Reads ANALYSIS_RESULTS.md → Discovers design assets → Includes design system paths in task JSON files
@@ -239,7 +318,7 @@ After this update, `/workflow:plan` will discover design assets through:
 ## Error Handling
 
 - **Missing design artifacts**: Error with message "Run /workflow:ui-design:style-extract and /workflow:ui-design:generate first"
-- **synthesis-specification.md not found**: Warning, create minimal version with just UI/UX Guidelines
+- **role analysis documents not found**: Warning, create minimal version with just UI/UX Guidelines
 - **ui-designer/ directory missing**: Create directory and file
 - **Edit conflicts**: Preserve existing content, append or replace only UI/UX Guidelines section
 - **Invalid prototype names**: Skip invalid entries, continue with valid ones
@@ -247,9 +326,11 @@ After this update, `/workflow:plan` will discover design assets through:
 ## Validation Checks
 
 After update, verify:
-- [ ] synthesis-specification.md contains UI/UX Guidelines section
+- [ ] role analysis documents contains UI/UX Guidelines section
 - [ ] UI/UX Guidelines include @ references (not content duplication)
-- [ ] ui-designer/style-guide.md created or updated
+- [ ] ui-designer/analysis*.md updated with design system references
+- [ ] ui-designer/design-system-reference.md created or updated
+- [ ] Relevant role analysis.md files updated (ux-expert, product-manager, system-architect)
 - [ ] All @ referenced files exist and are accessible
 - [ ] @ reference paths are relative and correct
 
@@ -264,7 +345,7 @@ After update, verify:
 ## Integration Points
 
 - **Input**: Design system artifacts from `/workflow:ui-design:style-extract` and `/workflow:ui-design:generate`
-- **Output**: Updated synthesis-specification.md, ui-designer/style-guide.md with @ references
+- **Output**: Updated role analysis documents, role analysis.md files, ui-designer/design-system-reference.md with @ references
 - **Next Phase**: `/workflow:plan` discovers and utilizes design system through @ references
 - **Auto Integration**: Automatically triggered by `/workflow:ui-design:auto` workflow
 

.claude/workflows/cli-templates/planning-roles/synthesis-role.md

@@ -1,4 +1,25 @@
-# Synthesis Role Template
+# ⚠️ DEPRECATED: Synthesis Role Template
+
+## DEPRECATION NOTICE
+
+**This template is DEPRECATED and no longer used.**
+
+### Why Deprecated
+The `/workflow:brainstorm:synthesis` command has been redesigned:
+- **Old behavior**: Generated synthesis-specification.md consolidating all role analyses
+- **New behavior**: Performs cross-role analysis, identifies ambiguities, interacts with user for clarification, and updates role analysis.md files directly
+
+### Migration
+- **Role analyses are the source of truth**: Each role's analysis.md file is updated directly
+- **Planning reads role documents**: The planning phase dynamically reads all role analysis.md files
+- **No template needed**: The clarification workflow doesn't require a document template
+
+### Historical Context
+This template was used to guide the generation of synthesis-specification.md from multiple role perspectives. It is preserved for historical reference but should not be used in the new architecture.
+
+---
+
+# Original Template (Historical Reference)
 
 ## Purpose
 Generate comprehensive synthesis-specification.md that consolidates all role perspectives from brainstorming into actionable implementation specification.
@@ -18,7 +39,7 @@ Generate comprehensive synthesis-specification.md that consolidates all role per
 ```markdown
 # [Topic] - Integrated Implementation Specification
 
-**Framework Reference**: @topic-framework.md | **Generated**: [timestamp] | **Session**: WFS-[topic-slug]
+**Framework Reference**: @guidance-specification.md | **Generated**: [timestamp] | **Session**: WFS-[topic-slug]
 **Source Integration**: All brainstorming role perspectives consolidated
 **Document Type**: Requirements & Design Specification (WHAT to build)
 
@@ -344,7 +365,7 @@ Document known constraints that affect planning:
 
 ### Cross-Role Synthesis Process
 
-1. **Load All Role Analyses**: Read topic-framework.md and all discovered */analysis.md files
+1. **Load All Role Analyses**: Read guidance-specification.md and all discovered */analysis.md files
 2. **Extract Key Insights**: Identify main recommendations, concerns, and innovations from each role
 3. **Identify Consensus Areas**: Find common themes across multiple roles
 4. **Document Disagreements**: Capture controversial points where roles differ
@@ -371,7 +392,7 @@ Document known constraints that affect planning:
 Use @ references to link back to source role analyses:
 - `@role/analysis.md` - Reference entire role analysis
 - `@role/analysis.md#section` - Reference specific section
-- `@topic-framework.md#point-3` - Reference framework discussion point
+- `@guidance-specification.md#point-3` - Reference framework discussion point
 
 ### Dynamic Role Handling
 

.claude/workflows/cli-templates/prompts/workflow/analysis-results-structure.txt

@@ -187,8 +187,8 @@ Generate ANALYSIS_RESULTS.md with comprehensive solution design and technical an
 
 ### Analysis Priority Sources
 1. **PRIMARY**: Individual role analysis.md files (system-architect, ui-designer, etc.) - technical details, ADRs, decision context
-2. **SECONDARY**: synthesis-specification.md - integrated requirements, cross-role alignment
-3. **REFERENCE**: topic-framework.md - discussion context
+2. **SECONDARY**: role analysis documents - multi-perspective requirements and design specs
+3. **REFERENCE**: guidance-specification.md - discussion context
 
 ### Focus Areas
 - **SOLUTION IMPROVEMENTS**: How to enhance current design

.claude/workflows/cli-templates/prompts/workflow/gemini-solution-design.txt

@@ -15,12 +15,12 @@ Analyze and design optimal solution with comprehensive architecture evaluation a
    - Architecture Decision Records (ADRs)
    - Design decision context and rationale
 
-2. **SECONDARY**: synthesis-specification.md
+2. **SECONDARY**: role analysis documents
    - Integrated requirements across roles
    - Cross-role alignment and dependencies
    - Unified feature specifications
 
-3. **REFERENCE**: topic-framework.md
+3. **REFERENCE**: guidance-specification.md
    - Discussion context and background
    - Initial problem framing
 
@@ -104,8 +104,8 @@ For each target:
 ### Brainstorm Context
 If brainstorming artifacts exist:
 - Prioritize individual role analysis.md files
-- Use synthesis-specification.md for integrated view
-- Reference topic-framework.md for context
+- Use role analysis documents for integrated view
+- Reference guidance-specification.md for context
 
 ### Codebase Context
 - Identify similar patterns in existing code

.claude/workflows/cli-templates/prompts/workflow/impl-plan-template.txt

@@ -35,10 +35,10 @@ Core requirements, objectives, technical approach summary (2-3 paragraphs max).
 
 ### CCW Workflow Context
 **Phase Progression**:
-- ✅ Phase 1: Brainstorming (synthesis-specification.md generated)
+- ✅ Phase 1: Brainstorming (role analyses generated)
 - ✅ Phase 2: Context Gathering (context-package.json: {N} files, {M} modules analyzed)
 - ✅ Phase 3: Enhanced Analysis (ANALYSIS_RESULTS.md: Gemini/Qwen/Codex parallel insights)
-- ✅ Phase 4: Concept Verification ({X} clarifications answered, synthesis updated | skipped)
+- ✅ Phase 4: Concept Verification ({X} clarifications answered, role analyses updated | skipped)
 - ⏳ Phase 5: Action Planning (current phase - generating IMPL_PLAN.md)
 
 **Quality Gates**:
@@ -76,12 +76,12 @@ Core requirements, objectives, technical approach summary (2-3 paragraphs max).
 ## 3. Brainstorming Artifacts Reference
 
 ### Artifact Usage Strategy
-**Primary Reference (synthesis-specification.md)**:
-- **What**: Comprehensive implementation blueprint from multi-role synthesis
-- **When**: Every task references this first for requirements and design decisions
-- **How**: Extract architecture decisions, UI/UX patterns, functional requirements, non-functional requirements
-- **Priority**: Authoritative - overrides role-specific analyses when conflicts arise
-- **CCW Value**: Consolidates insights from all brainstorming roles into single source of truth
+**Primary Reference (role analyses)**:
+- **What**: Role-specific analyses from brainstorming providing multi-perspective insights
+- **When**: Every task references relevant role analyses for requirements and design decisions
+- **How**: Extract requirements, architecture decisions, UI/UX patterns from applicable role documents
+- **Priority**: Collective authoritative source - multiple role perspectives provide comprehensive coverage
+- **CCW Value**: Maintains role-specific expertise while enabling cross-role integration during planning
 
 **Context Intelligence (context-package.json)**:
 - **What**: Smart context gathered by CCW's context-gather phase
@@ -96,17 +96,17 @@ Core requirements, objectives, technical approach summary (2-3 paragraphs max).
 - **CCW Value**: Multi-model parallel analysis providing comprehensive technical intelligence
 
 ### Integrated Specifications (Highest Priority)
-- **synthesis-specification.md**: Comprehensive implementation blueprint
+- **role analyses**: Comprehensive implementation blueprint
   - Contains: Architecture design, UI/UX guidelines, functional/non-functional requirements, implementation roadmap, risk assessment
 
 ### Supporting Artifacts (Reference)
-- **topic-framework.md**: Role-specific discussion points and analysis framework
+- **guidance-specification.md**: Role-specific discussion points and analysis framework
 - **system-architect/analysis.md**: Detailed architecture specifications
 - **ui-designer/analysis.md**: Layout and component specifications
 - **product-manager/analysis.md**: Product vision and user stories
 
 **Artifact Priority in Development**:
-1. synthesis-specification.md (primary reference for all tasks)
+1. role analyses (primary reference for all tasks)
 2. context-package.json (smart context for execution environment)
 3. ANALYSIS_RESULTS.md (technical analysis and optimization strategies)
 4. Role-specific analyses (fallback for detailed specifications)
@@ -126,7 +126,7 @@ Core requirements, objectives, technical approach summary (2-3 paragraphs max).
 
 ### Architectural Approach
 **Key Architecture Decisions**:
-- [ADR references from synthesis]
+- [ADR references from role analyses]
 - [Justification for architecture patterns]
 
 **Integration Strategy**:
@@ -218,7 +218,7 @@ Core requirements, objectives, technical approach summary (2-3 paragraphs max).
 ## 8. Success Criteria
 
 **Functional Completeness**:
-- [ ] All requirements from synthesis-specification.md implemented
+- [ ] All requirements from role analyses implemented
 - [ ] All acceptance criteria from task.json files met
 
 **Technical Quality**:
@@ -232,7 +232,7 @@ Core requirements, objectives, technical approach summary (2-3 paragraphs max).
 - [ ] Documentation complete
 
 **Business Metrics**:
-- [ ] [Key business metrics from synthesis]
+- [ ] [Key business metrics from role analyses]
 
 ## Template Usage Guidelines
 
@@ -269,7 +269,7 @@ Core requirements, objectives, technical approach summary (2-3 paragraphs max).
    - Create dependency graph visualization
 
 7. **Set Success Criteria**:
-   - Extract from synthesis-specification.md
+   - Extract from role analyses
    - Include measurable metrics
    - Define quality gates
 

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

@@ -7,9 +7,10 @@ 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|@general-purpose"
+    "agent": "@code-developer|@test-fix-agent|@universal-executor"
   },
   "context": {
     "requirements": ["extracted from analysis"],
@@ -34,8 +35,8 @@ Task JSON Schema - Agent Mode (No Command Field)
   "flow_control": {
     "pre_analysis": [
       {
-        "step": "load_synthesis_specification",
-        "action": "Load consolidated synthesis specification",
+        "step": "load_role_analyses_specification",
+        "action": "Load consolidated role analyses",
         "commands": [
           "Read({synthesis_spec_path})"
         ],
@@ -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"
       }
@@ -62,16 +66,16 @@ Task JSON Schema - Agent Mode (No Command Field)
     "implementation_approach": [
       {
         "step": 1,
-        "title": "Implement task following synthesis specification",
-        "description": "Implement '{title}' following [synthesis_specification] requirements and [context_pkg] patterns. Use synthesis-specification.md as primary source, consult artifacts for technical details.",
+        "title": "Implement task following role analyses",
+        "description": "Implement '{title}' following [synthesis_specification] requirements and [context_pkg] patterns. Use role analyses as primary source, consult artifacts for technical details.",
         "modification_points": [
-          "Apply consolidated requirements from synthesis-specification.md",
+          "Apply consolidated requirements from role analyses",
           "Follow technical guidelines from synthesis",
           "Consult artifacts for implementation details when needed",
           "Integrate with existing patterns"
         ],
         "logic_flow": [
-          "Load synthesis specification and context package",
+          "Load role analyses and context package",
           "Analyze existing patterns from [codebase_structure]",
           "Implement following specification",
           "Consult artifacts for technical details when needed",

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

@@ -7,9 +7,10 @@ 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|@general-purpose"
+    "agent": "@code-developer|@test-fix-agent|@universal-executor"
   },
   "context": {
     "requirements": ["extracted from analysis"],
@@ -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/context-search-strategy.md

@@ -8,89 +8,61 @@ type: search-guideline
 
 ## ⚡ Execution Environment
 
-**CRITICAL**: All commands execute in **Bash environment** (Git Bash on Windows, Bash on Linux/macOS)
+**CRITICAL**: All commands execute in **Bash environment** (Git Bash on Windows)
 
-**❌ Forbidden**: Windows-specific commands (`findstr`, `dir`, `where`, `type`, `copy`, `del`) - Use Bash equivalents (`grep`, `find`, `which`, `cat`, `cp`, `rm`)
+**❌ Forbidden**: Windows commands (`findstr`, `dir`, `where`) - Use Bash (`grep`, `find`, `cat`)
 
 ## ⚡ Core Search Tools
 
 **codebase-retrieval**: Semantic file discovery via Gemini CLI with all files analysis
 **rg (ripgrep)**: Fast content search with regex support
 **find**: File/directory location by name patterns
-**grep**: Built-in pattern matching in files
-**get_modules_by_depth.sh**: Program architecture analysis and structural discovery
+**grep**: Built-in pattern matching (fallback when rg unavailable)
+**get_modules_by_depth.sh**: Program architecture analysis (MANDATORY before planning)
 
-### Decision Principles
-- **Use codebase-retrieval for semantic discovery** - Intelligent file discovery based on task context
-- **Use rg for content** - Fastest for searching within files
-- **Use find for files** - Locate files/directories by name
-- **Use grep sparingly** - Only when rg unavailable
-- **Use get_modules_by_depth.sh first** - MANDATORY for program architecture analysis before planning
-- **Always use Bash commands** - NEVER use Windows cmd/PowerShell commands
-
-### Tool Selection Matrix
+## 📋 Tool Selection Matrix
 
 | Need | Tool | Use Case |
 |------|------|----------|
-| **Semantic file discovery** | codebase-retrieval | Find files relevant to task/feature context |
+| **Semantic discovery** | codebase-retrieval | Find files relevant to task/feature context |
 | **Pattern matching** | rg | Search code content with regex |
 | **File name lookup** | find | Locate files by name patterns |
-| **Architecture analysis** | get_modules_by_depth.sh | Understand program structure |
+| **Architecture** | get_modules_by_depth.sh | Understand program structure |
+
+## 🔧 Quick Command Reference
 
-### Quick Command Reference
 ```bash
 # Semantic File Discovery (codebase-retrieval)
-gemini "CONTEXT: @**/* List all files relevant to: [task/feature description]"
-bash(gemini "CONTEXT: @**/* List all files relevant to: [task/feature description]")
+cd [directory] && gemini -p "
+PURPOSE: Discover files relevant to task/feature
+TASK: List all files related to [task/feature description]
+MODE: analysis
+CONTEXT: @**/*
+EXPECTED: Relevant file paths with relevance explanation
+RULES: Focus on direct relevance to task requirements
+"
 
-# Program Architecture Analysis (MANDATORY FIRST)
-~/.claude/scripts/get_modules_by_depth.sh  # Discover program architecture
-bash(~/.claude/scripts/get_modules_by_depth.sh)  # Analyze structural hierarchy
+# Program Architecture (MANDATORY FIRST)
+~/.claude/scripts/get_modules_by_depth.sh
 
 # Content Search (rg preferred)
-rg "pattern" --type js          # Search in JS files
-rg -i "case-insensitive"        # Ignore case
-rg -n "show-line-numbers"       # Show line numbers
-rg -A 3 -B 3 "context-lines"    # Show 3 lines before/after
+rg "pattern" --type js -n        # Search JS files with line numbers
+rg -i "case-insensitive"         # Ignore case
+rg -C 3 "context"                # Show 3 lines before/after
 
-# File Search (find)
-find . -name "*.ts" -type f     # Find TypeScript files
+# File Search
+find . -name "*.ts" -type f      # Find TypeScript files
 find . -path "*/node_modules" -prune -o -name "*.js" -print
 
-# Built-in alternatives
-grep -r "pattern" .             # Recursive search (slower)
-grep -n -i "pattern" file.txt   # Line numbers, case-insensitive
+# Workflow Examples
+rg "IMPL-\d+" .workflow/ --type json                    # Find task IDs
+find .workflow/ -name "*.json" -path "*/.task/*"        # Locate task files
+rg "status.*pending" .workflow/.task/                   # Find pending tasks
 ```
 
-### Workflow Integration Examples
-```bash
-# Semantic Discovery → Content Search → Analysis (Recommended Pattern)
-gemini "CONTEXT: @**/* List all files relevant to: [task/feature]"  # Get relevant files
-rg "[pattern]" --type [filetype]  # Then search within discovered files
+## ⚡ Performance Tips
 
-# Program Architecture Analysis (MANDATORY BEFORE PLANNING)
-~/.claude/scripts/get_modules_by_depth.sh  # Discover program architecture
-bash(~/.claude/scripts/get_modules_by_depth.sh)  # Analyze structural hierarchy
-
-# Search for task definitions
-rg "IMPL-\d+" .workflow/ --type json        # Find task IDs
-find .workflow/ -name "*.json" -path "*/.task/*"  # Locate task files
-
-# Analyze workflow structure
-rg "status.*pending" .workflow/.task/      # Find pending tasks
-rg "depends_on" .workflow/.task/ -A 2      # Show dependencies
-
-# Find workflow sessions
-find .workflow/ -name ".active-*"          # Active sessions
-rg "WFS-" .workflow/ --type json           # Session references
-
-# Content analysis for planning
-rg "flow_control" .workflow/ -B 2 -A 5     # Flow control patterns
-find . -name "IMPL_PLAN.md" -exec grep -l "requirements" {} \;
-```
-
-### Performance Tips
 - **rg > grep** for content search
 - **Use --type filters** to limit file types
-- **Exclude common dirs**: `--glob '!node_modules'`
-- **Use -F for literal** strings (no regex)
+- **Exclude dirs**: `--glob '!node_modules'`
+- **Use -F** for literal strings (no regex)

.claude/workflows/intelligent-tools-strategy.md

@@ -89,6 +89,9 @@ gemini -p "analysis prompt"
 qwen -p "analysis prompt"
 ```
 
+#### Error Handling
+**⚠️ Gemini 429 Behavior**: May show HTTP 429 error but still return results - ignore error messages, only check if results exist (results present = success, no results = retry/fallback to Qwen)
+
 ---
 
 ### Codex

.claude/workflows/mcp-tool-strategy.md

@@ -1,176 +1,11 @@
-# MCP Tool Strategy: Triggers & Workflows
+# MCP Tool Strategy: Exa Usage
 
-## ⚡ Triggering Mechanisms
+## ⚡ Exa Triggering Mechanisms
 
-**Auto-Trigger Scenarios**:
+**Auto-Trigger**:
 - User mentions "exa-code" or code-related queries → `mcp__exa__get_code_context_exa`
 - Need current web information → `mcp__exa__web_search_exa`
-- Finding code patterns/files → `mcp__code-index__search_code_advanced`
-- Locating specific files → `mcp__code-index__find_files`
 
-**Manual Trigger Rules**:
+**Manual Trigger**:
 - Complex API research → Exa Code Context
-- Architecture pattern discovery → Exa Code Context + Gemini analysis
 - Real-time information needs → Exa Web Search
-- Codebase exploration → Code Index tools first, then Gemini analysis
-
-## 🎯 Available MCP Tools
-
-### Exa Code Context (mcp__exa__get_code_context_exa)
-**Purpose**: Search and get relevant context for programming tasks
-**Strengths**: Highest quality context for libraries, SDKs, and APIs
-**Best For**: Code examples, API patterns, learning frameworks
-
-**Usage**:
-```bash
-mcp__exa__get_code_context_exa(
-  query="React useState hook examples",
-  tokensNum="dynamic"  # or 1000-50000
-)
-```
-
-**Examples**: "React useState", "Python pandas filtering", "Express.js middleware"
-
-### Exa Web Search (mcp__exa__web_search_exa)
-**Purpose**: Real-time web searches with content scraping
-**Best For**: Current information, research, recent solutions
-
-**Usage**:
-```bash
-mcp__exa__web_search_exa(
-  query="latest React 18 features",
-  numResults=5  # default: 5
-)
-```
-
-
-### Code Index Tools (mcp__code-index__)
-**核心方法**: `search_code_advanced`, `find_files`, `refresh_index`
-
-**核心搜索**:
-```bash
-mcp__code-index__search_code_advanced(pattern="function.*auth", file_pattern="*.ts")
-mcp__code-index__find_files(pattern="*.test.js")
-mcp__code-index__refresh_index()  # git操作后刷新
-```
-
-**实用场景**:
-- **查找代码**: `search_code_advanced(pattern="old.*API")`
-- **定位文件**: `find_files(pattern="src/**/*.tsx")`
-- **更新索引**: `refresh_index()` (git操作后)
-
-**文件搜索测试结果**:
-- ✅ `find_files(pattern="*.md")` - 搜索所有 Markdown 文件
-- ✅ `find_files(pattern="*complete*")` - 通配符匹配文件名
-- ❌ `find_files(pattern="complete.md")` - 精确匹配可能失败
-- 📝 建议使用通配符模式获得更好的搜索结果
-
-## 📊 Tool Selection Matrix
-
-| Task | MCP Tool | Use Case | Integration |
-|------|----------|----------|-------------|
-| **Code Context** | Exa Code | API examples, patterns | → Gemini analysis |
-| **Research** | Exa Web | Current info, trends | → Planning phase |
-| **Code Search** | Code Index | Pattern discovery, file location | → Gemini analysis |
-| **Navigation** | Code Index | File exploration, structure | → Architecture phase |
-
-## 🚀 Integration Patterns
-
-### Standard Workflow
-```bash
-# 1. Explore codebase structure
-mcp__code-index__find_files(pattern="*async*")
-mcp__code-index__search_code_advanced(pattern="async.*function", file_pattern="*.ts")
-
-# 2. Get external context
-mcp__exa__get_code_context_exa(query="TypeScript async patterns", tokensNum="dynamic")
-
-# 3. Analyze with Gemini
-cd "src/async" && gemini "
-PURPOSE: Understand async patterns
-CONTEXT: Code index results + Exa context + @src/async/**/*
-EXPECTED: Pattern analysis
-RULES: Focus on TypeScript best practices
-"
-
-# 4. Implement with Codex
-codex -C src/async --full-auto exec "Apply modern async patterns" -s danger-full-access
-```
-
-### Enhanced Planning
-1. **Explore codebase** with Code Index tools
-2. **Research** with Exa Web Search
-3. **Get code context** with Exa Code Context
-4. **Analyze** with Gemini
-5. **Architect** with Qwen
-6. **Implement** with Codex
-
-## 🔧 Best Practices
-
-### Code Index
-- **Search first** - Use before external tools for codebase exploration
-- **Refresh after git ops** - Keep index synchronized
-- **Pattern specificity** - Use precise regex patterns for better results
-- **File patterns** - Combine with glob patterns for targeted search
-- **Glob pattern matching** - Use `*.md`, `*complete*` patterns for file discovery
-- **Exact vs wildcard** - Exact names may fail, use wildcards for better results
-
-### Exa Code Context
-- **Use "dynamic" tokens** for efficiency
-- **Be specific** - include technology stack
-- **MANDATORY** when user mentions exa-code or code queries
-
-### Exa Web Search
-- **Default 5 results** usually sufficient
-- **Use for current info** - supplement knowledge cutoff
-
-
-
-## 🎯 Common Scenarios
-
-### Learning New Technology
-```bash
-# Explore existing patterns + get examples + research + analyze
-mcp__code-index__search_code_advanced(pattern="router|routing", file_pattern="*.ts")
-mcp__exa__get_code_context_exa(query="Next.js 14 app router", tokensNum="dynamic")
-mcp__exa__web_search_exa(query="Next.js 14 best practices 2024", numResults=3)
-cd "src/app" && gemini "Learn Next.js patterns"
-```
-
-### Debugging
-```bash
-# Find similar patterns + solutions + fix
-mcp__code-index__search_code_advanced(pattern="similar.*error", file_pattern="*.ts")
-mcp__exa__get_code_context_exa(query="TypeScript generic constraints", tokensNum="dynamic")
-codex --full-auto exec "Fix TypeScript issues" -s danger-full-access
-```
-
-### Codebase Exploration
-```bash
-# Comprehensive codebase understanding workflow
-mcp__code-index__set_project_path(path="/current/project")  # 设置项目路径
-mcp__code-index__refresh_index()  # 刷新索引
-mcp__code-index__find_files(pattern="*auth*")  # Find auth-related files
-mcp__code-index__search_code_advanced(pattern="function.*auth", file_pattern="*.ts")  # Find auth functions
-mcp__code-index__get_file_summary(file_path="src/auth/index.ts")  # Understand structure
-cd "src/auth" && gemini "Analyze auth architecture"
-```
-
-### Project Setup Workflow
-```bash
-# 新项目初始化流程
-mcp__code-index__set_project_path(path="/path/to/new/project")
-mcp__code-index__get_settings_info()  # 确认设置
-mcp__code-index__refresh_index()  # 建立索引
-mcp__code-index__configure_file_watcher(enabled=true)  # 启用文件监控
-mcp__code-index__get_file_watcher_status()  # 确认监控状态
-```
-
-## ⚡ Performance Tips
-
-- **Code Index first** → explore codebase before external tools
-- **Use "dynamic" tokens** for Exa Code Context
-- **MCP first** → gather context before analysis
-- **Focus queries** - avoid overly broad searches
-- **Integrate selectively** - use relevant context only
-- **Refresh index** after major git operations

.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
 {
@@ -14,7 +14,7 @@ All task files use this simplified 5-field schema (aligned with workflow-archite
 
   "meta": {
     "type": "feature|bugfix|refactor|test-gen|test-fix|docs",
-    "agent": "@code-developer|@action-planning-agent|@test-fix-agent|@general-purpose"
+    "agent": "@code-developer|@action-planning-agent|@test-fix-agent|@universal-executor"
   },
 
   "context": {
@@ -155,14 +155,14 @@ Tasks inherit from:
 - **@code-developer**: Implementation tasks, coding, test writing
 - **@action-planning-agent**: Design, architecture planning
 - **@test-fix-agent**: Test execution, failure diagnosis, code fixing
-- **@general-purpose**: Optional manual review (only when explicitly requested)
+- **@universal-executor**: Optional manual review (only when explicitly requested)
 
 ### Agent Context Filtering
 Each agent receives tailored context:
 - **@code-developer**: Complete implementation details, test requirements
 - **@action-planning-agent**: High-level requirements, risks, architecture
 - **@test-fix-agent**: Test execution, failure diagnosis, code fixing
-- **@general-purpose**: Quality standards, security considerations (when requested)
+- **@universal-executor**: Quality standards, security considerations (when requested)
 
 ## Deprecated Fields
 

.claude/workflows/workflow-architecture.md

@@ -104,17 +104,18 @@ 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",
-    "agent": "@code-developer|@action-planning-agent|@test-fix-agent|@general-purpose"
+    "agent": "@code-developer|@action-planning-agent|@test-fix-agent|@universal-executor"
   },
 
   "context": {
@@ -132,11 +133,11 @@ All task files use this unified 5-field schema with optional artifacts enhanceme
     },
     "artifacts": [
       {
-        "type": "synthesis_specification",
-        "source": "brainstorm_synthesis",
-        "path": ".workflow/WFS-session/.brainstorming/synthesis-specification.md",
+        "type": "role_analyses",
+        "source": "brainstorm_clarification",
+        "path": ".workflow/WFS-session/.brainstorming/*/analysis*.md",
         "priority": "highest",
-        "contains": "complete_integrated_specification"
+        "contains": "role_specific_requirements_and_design"
       }
     ]
   },
@@ -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"]`
@@ -241,15 +249,15 @@ Optional field referencing brainstorming outputs for task execution:
 ```json
 "artifacts": [
   {
-    "type": "synthesis_specification|topic_framework|individual_role_analysis",
-    "source": "brainstorm_synthesis|brainstorm_framework|brainstorm_roles",
+    "type": "role_analyses|topic_framework|individual_role_analysis",
+    "source": "brainstorm_clarification|brainstorm_framework|brainstorm_roles",
     "path": ".workflow/WFS-session/.brainstorming/document.md",
     "priority": "highest|high|medium|low"
   }
 ]
 ```
 
-**Types & Priority**: synthesis_specification (highest) → topic_framework (medium) → individual_role_analysis (low)
+**Types & Priority**: role_analyses (highest) → topic_framework (medium) → individual_role_analysis (low)
 
 #### Flow Control Configuration
 The **flow_control** field manages task execution through structured sequential steps. For complete format specifications and usage guidelines, see [Flow Control Format Guide](#flow-control-format-guide) below.
@@ -296,7 +304,7 @@ The `[FLOW_CONTROL]` marker indicates that a task or prompt contains flow contro
 
 1. **load_topic_framework**
    - Action: Load structured topic discussion framework
-   - Command: Read(.workflow/WFS-{session}/.brainstorming/topic-framework.md)
+   - Command: Read(.workflow/WFS-{session}/.brainstorming/guidance-specification.md)
    - Output: topic_framework
 
 2. **load_role_template**
@@ -332,19 +340,23 @@ The `[FLOW_CONTROL]` marker indicates that a task or prompt contains flow contro
 "flow_control": {
   "pre_analysis": [
     {
-      "step": "load_synthesis_specification",
-      "action": "Load consolidated synthesis specification",
+      "step": "load_role_analyses",
+      "action": "Load role analysis documents from brainstorming",
       "commands": [
-        "bash(ls .workflow/WFS-{session}/.brainstorming/synthesis-specification.md 2>/dev/null || echo 'not found')",
-        "Read(.workflow/WFS-{session}/.brainstorming/synthesis-specification.md)"
+        "bash(ls .workflow/WFS-{session}/.brainstorming/*/analysis*.md 2>/dev/null || echo 'not found')",
+        "Glob(.workflow/WFS-{session}/.brainstorming/*/analysis*.md)",
+        "Read(each discovered role analysis file)"
       ],
-      "output_to": "synthesis_specification",
+      "output_to": "role_analyses",
       "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"
     }
   ],
@@ -352,14 +364,14 @@ The `[FLOW_CONTROL]` marker indicates that a task or prompt contains flow contro
     {
       "step": 1,
       "title": "Setup infrastructure",
-      "description": "Install JWT library and create config following [synthesis_specification]",
+      "description": "Install JWT library and create config following [role_analyses]",
       "modification_points": [
         "Add JWT library dependencies to package.json",
         "Create auth configuration file"
       ],
       "logic_flow": [
         "Install jsonwebtoken library via npm",
-        "Configure JWT secret from [synthesis_specification]",
+        "Configure JWT secret from [role_analyses]",
         "Export auth config for use by [jwt_generator]"
       ],
       "depends_on": [],
@@ -406,7 +418,7 @@ The `[FLOW_CONTROL]` marker indicates that a task or prompt contains flow contro
 **Structure**: Array of step objects with sequential execution
 
 **Step Fields**:
-- **step**: Step identifier (string, e.g., "load_synthesis_specification")
+- **step**: Step identifier (string, e.g., "load_role_analyses")
 - **action**: Human-readable description of the step
 - **command** or **commands**: Single command string or array of command strings
 - **output_to**: Variable name for storing step output
@@ -415,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**:
@@ -540,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
 
@@ -567,7 +577,7 @@ Both formats use `[variable_name]` syntax for referencing outputs from previous
 **Examples**:
 ```json
 // Reference pre_analysis output
-"description": "Install JWT library following [synthesis_specification]"
+"description": "Install JWT library following [role_analyses]"
 
 // Reference previous step output
 "description": "Create middleware using [auth_config] and [jwt_generator]"
@@ -636,7 +646,7 @@ Both formats use `[variable_name]` syntax for referencing outputs:
 ```json
 {
   "step": 2,
-  "description": "Implement following [synthesis_specification] and [codebase_structure]",
+  "description": "Implement following [role_analyses] and [codebase_structure]",
   "depends_on": [1],
   "output": "implementation"
 }
@@ -912,7 +922,7 @@ Based on task type and title keywords:
 - **Planning tasks** → @action-planning-agent
 - **Implementation** → @code-developer (code + tests)
 - **Test execution/fixing** → @test-fix-agent
-- **Review** → @general-purpose (optional, only when explicitly requested)
+- **Review** → @universal-executor (optional, only when explicitly requested)
 
 ### Execution Context
 Agents receive complete task JSON plus workflow context:

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
 

CLAUDE.md

@@ -72,6 +72,7 @@ For all CLI tool usage, command syntax, and integration guidelines:
 ## Platform-Specific Guidelines
 
 ### Windows Path Format Guidelines
+- always use complete absolute Windows paths with drive letters and backslashes for ALL file operations
 - **MCP Tools**: Use double backslash `D:\\path\\file.txt` (MCP doesn't support POSIX `/d/path`)
 - **Bash Commands**: Use forward slash `D:/path/file.txt` or POSIX `/d/path/file.txt`
 - **Relative Paths**: No conversion needed `./src`, `../config`

COMMAND_REFERENCE.md

@@ -2,6 +2,8 @@
 
 This document provides a comprehensive reference for all commands available in the Claude Code Workflow (CCW) system.
 
+> **Version 5.0 Update**: Streamlined command structure focusing on essential tools. Removed MCP code-index dependency for better stability and performance.
+
 ## Unified CLI Commands (`/cli:*`)
 
 These commands provide direct access to AI tools for quick analysis and interaction without initiating a full workflow.
@@ -45,24 +47,23 @@ These commands orchestrate complex, multi-phase development processes, from plan
 
 | Command | Description |
 |---|---|
-| `/workflow:brainstorm:artifacts` | Generate role-specific topic-framework.md dynamically based on selected roles. |
+| `/workflow:brainstorm:artifacts` | Generate role-specific guidance-specification.md dynamically based on selected roles. |
 | `/workflow:brainstorm:auto-parallel` | Parallel brainstorming automation with dynamic role selection and concurrent execution. |
-| `/workflow:brainstorm:synthesis` | Generate synthesis-specification.md from topic-framework and role analyses with @ references using conceptual-planning-agent. |
-| `/workflow:brainstorm:api-designer` | Generate or update api-designer/analysis.md addressing topic-framework discussion points. |
-| `/workflow:brainstorm:data-architect` | Generate or update data-architect/analysis.md addressing topic-framework discussion points. |
-| `/workflow:brainstorm:product-manager` | Generate or update product-manager/analysis.md addressing topic-framework discussion points. |
-| `/workflow:brainstorm:product-owner` | Generate or update product-owner/analysis.md addressing topic-framework discussion points. |
-| `/workflow:brainstorm:scrum-master` | Generate or update scrum-master/analysis.md addressing topic-framework discussion points. |
-| `/workflow:brainstorm:subject-matter-expert` | Generate or update subject-matter-expert/analysis.md addressing topic-framework discussion points. |
-| `/workflow:brainstorm:system-architect` | Generate or update system-architect/analysis.md addressing topic-framework discussion points. |
-| `/workflow:brainstorm:ui-designer` | Generate or update ui-designer/analysis.md addressing topic-framework discussion points. |
-| `/workflow:brainstorm:ux-expert` | Generate or update ux-expert/analysis.md addressing topic-framework discussion points. |
+| `/workflow:brainstorm:synthesis` | Clarify and refine role analyses through intelligent Q&A and targeted updates. |
+| `/workflow:brainstorm:api-designer` | Generate or update api-designer/analysis.md addressing guidance-specification discussion points. |
+| `/workflow:brainstorm:data-architect` | Generate or update data-architect/analysis.md addressing guidance-specification discussion points. |
+| `/workflow:brainstorm:product-manager` | Generate or update product-manager/analysis.md addressing guidance-specification discussion points. |
+| `/workflow:brainstorm:product-owner` | Generate or update product-owner/analysis.md addressing guidance-specification discussion points. |
+| `/workflow:brainstorm:scrum-master` | Generate or update scrum-master/analysis.md addressing guidance-specification discussion points. |
+| `/workflow:brainstorm:subject-matter-expert` | Generate or update subject-matter-expert/analysis.md addressing guidance-specification discussion points. |
+| `/workflow:brainstorm:system-architect` | Generate or update system-architect/analysis.md addressing guidance-specification discussion points. |
+| `/workflow:brainstorm:ui-designer` | Generate or update ui-designer/analysis.md addressing guidance-specification discussion points. |
+| `/workflow:brainstorm:ux-expert` | Generate or update ux-expert/analysis.md addressing guidance-specification discussion points. |
 
 ### Quality & Verification
 
 | Command | Description |
 |---|---|
-| `/workflow:concept-clarify` | Identify underspecified areas in brainstorming artifacts through targeted clarification questions before action planning. |
 | `/workflow:action-plan-verify`| Perform non-destructive cross-artifact consistency and quality analysis of IMPL_PLAN.md and task.json before execution. |
 
 ### Test-Driven Development (TDD)
@@ -76,9 +77,9 @@ These commands orchestrate complex, multi-phase development processes, from plan
 
 | Command | Description |
 |---|---|
-| `/workflow:test-gen` | Create independent test-fix workflow session by analyzing completed implementation. |
-| `/workflow:test-fix-gen` | Create independent test-fix workflow session from existing implementation (session or prompt-based). |
-| `/workflow:test-cycle-execute` | Execute test-fix workflow with dynamic task generation and iterative fix cycles. |
+| `/workflow:test-gen` | Generate test plan and tasks by analyzing completed implementation. Use `/workflow:execute` to run generated tasks. |
+| `/workflow:test-fix-gen` | Generate test-fix plan and tasks from existing implementation or prompt. Use `/workflow:execute` to run generated tasks. |
+| `/workflow:test-cycle-execute` | Execute test-fix workflow with dynamic task generation and iterative fix cycles. Tasks are executed by `/workflow:execute`. |
 
 ### UI Design Workflow
 
@@ -102,7 +103,8 @@ These commands are primarily used internally by other workflow commands but can
 | Command | Description |
 |---|---|
 | `/workflow:tools:concept-enhanced` | Enhanced intelligent analysis with parallel CLI execution and design blueprint generation. |
-| `/workflow:tools:context-gather` | Intelligently collect project context using general-purpose agent based on task description and package into standardized JSON. |
+| `/workflow:tools:conflict-resolution` | Detect and resolve conflicts between plan and existing codebase using CLI-powered analysis. |
+| `/workflow:tools:context-gather` | Intelligently collect project context using universal-executor agent based on task description and package into standardized JSON. |
 | `/workflow:tools:task-generate` | Generate task JSON files and IMPL_PLAN.md from analysis results with artifacts integration. |
 | `/workflow:tools:task-generate-agent` | Autonomous task generation using action-planning-agent with discovery and output phases. |
 | `/workflow:tools:task-generate-tdd` | Generate TDD task chains with Red-Green-Refactor dependencies. |

COMMAND_SPEC.md

@@ -1,13 +1,15 @@
 
 # Claude Code Workflow (CCW) - Command Specification
 
-**Version**: 4.6.0
-**Generated**: 2025年10月18日星期六
+**Version**: 5.0.0
+**Updated**: 2025年10月24日星期六
 
 ## 1. Introduction
 
 This document provides a detailed technical specification for every command available in the Claude Code Workflow (CCW) system. It is intended for advanced users and developers who wish to understand the inner workings of CCW, customize commands, or build new workflows.
 
+> **Version 5.0 Changes**: Removed MCP code-index dependency, streamlined TDD workflow with conflict resolution, and refocused brainstorming on role analysis instead of synthesis documents.
+
 For a user-friendly overview, please see [COMMAND_REFERENCE.md](COMMAND_REFERENCE.md).
 
 ## 2. Command Categories
@@ -308,7 +310,7 @@ Commands for managing individual tasks within a workflow session.
 - **Agent-Driven Execution**: Fully delegates to general-purpose agent which autonomously:
   1. Analyzes project structure and documentation
   2. Extracts keywords from task description
-  3. Discovers relevant files using MCP code-index or search tools
+  3. Discovers relevant files using ripgrep/find search tools
   4. Executes Gemini/Qwen CLI for deep analysis
   5. Generates structured JSON content package
 - **Core Philosophy**: Read-only analysis, token-efficient (CLI analysis in agent), structured output
@@ -384,8 +386,8 @@ Specialized workflow for UI/UX design, from style extraction to prototype genera
 
 ### **/workflow:ui-design:capture**
 - **Syntax**: `/workflow:ui-design:capture --url-map "target:url,..." ...`
-- **Responsibilities**: Batch screenshot capture tool with MCP-first strategy and local fallbacks.
-- **Agent Calls**: None directly, uses MCP tools.
+- **Responsibilities**: Batch screenshot capture tool using MCP Chrome DevTools with multi-tier fallback strategy (MCP → Playwright → Chrome → Manual).
+- **Agent Calls**: None directly, uses MCP Chrome DevTools or browser automation as fallback.
 - **Example**:
   ```bash
   /workflow:ui-design:capture --url-map "home:https://linear.app"
@@ -394,7 +396,7 @@ Specialized workflow for UI/UX design, from style extraction to prototype genera
 ### **/workflow:ui-design:explore-layers**
 - **Syntax**: `/workflow:ui-design:explore-layers --url <url> --depth <1-5> ...`
 - **Responsibilities**: Performs a deep, interactive UI capture of a single URL, exploring layers from the full page down to the Shadow DOM.
-- **Agent Calls**: None directly, uses MCP tools.
+- **Agent Calls**: None directly, uses MCP Chrome DevTools for layer exploration.
 - **Example**:
   ```bash
   /workflow:ui-design:explore-layers --url https://linear.app --depth 3
@@ -489,8 +491,9 @@ Workflows for Test-Driven Development (TDD) and post-implementation test generat
 
 ### **/workflow:test-cycle-execute**
 - **Syntax**: `/workflow:test-cycle-execute [--resume-session="session-id"] [--max-iterations=N]`
-- **Responsibilities**: Executes a dynamic test-fix workflow, creating intermediate fix tasks based on test results and analysis.
-- **Agent Calls**: `@code-developer`, `@test-fix-agent`.
+- **Responsibilities**: Executes a test-fix workflow by delegating to `/workflow:execute`. Generates test tasks dynamically and creates intermediate fix tasks based on test results.
+- **Agent Calls**: Delegates to `/workflow:execute` which invokes `@test-fix-agent` for task execution.
+- **Note**: This command generates tasks; actual execution is performed by `/workflow:execute`.
 - **Example**:
   ```bash
   /workflow:test-cycle-execute --resume-session="WFS-test-user-auth"

GETTING_STARTED.md

@@ -1,7 +1,11 @@
 
 # 🚀 Claude Code Workflow (CCW) - Getting Started Guide
 
-Welcome to Claude Code Workflow (CCW) v4.5.0! This guide will help you get up and running in 5 minutes and experience AI-driven automated software development with our latest workflow system optimizations.
+Welcome to Claude Code Workflow (CCW) v5.0! This guide will help you get up and running in 5 minutes and experience AI-driven automated software development with our streamlined, dependency-free workflow system.
+
+**Project Repository**: [catlog22/Claude-Code-Workflow](https://github.com/catlog22/Claude-Code-Workflow)
+
+> **🎉 What's New in v5.0**: Less is more! We've removed external MCP dependencies and simplified workflows. CCW now uses standard tools (ripgrep/find) for better stability and performance. The brainstorming workflow focuses on role analysis for clearer planning.
 
 ---
 
@@ -13,17 +17,7 @@ Let's build a "Hello World" web application from scratch with a simple example.
 
 First, make sure you have installed CCW according to the [Installation Guide](INSTALL.md).
 
-### Step 2: Start a Workflow Session
-
-Think of a "session" as a dedicated project folder. CCW will store all files related to your current task here.
-
-```bash
-/workflow:session:start "My First Web App"
-```
-
-You will see that the system has created a new session, for example, `WFS-my-first-web-app`.
-
-### Step 3: Create an Execution Plan
+### Step 2: Create an Execution Plan (Automatically Starts a Session)
 
 Now, tell CCW what you want to do. CCW will analyze your request and automatically generate a detailed, executable task plan.
 
@@ -31,12 +25,14 @@ Now, tell CCW what you want to do. CCW will analyze your request and automatical
 /workflow:plan "Create a simple Express API that returns Hello World at the root path"
 ```
 
+> **💡 Note**: `/workflow:plan` automatically creates and starts a workflow session. No need to manually run `/workflow:session:start`. The session will be auto-named based on your task description, e.g., `WFS-create-a-simple-express-api`.
+
 This command kicks off a fully automated planning process, which includes:
 1.  **Context Gathering**: Analyzing your project environment.
 2.  **Agent Analysis**: AI agents think about the best implementation path.
 3.  **Task Generation**: Creating specific task files (in `.json` format).
 
-### Step 4: Execute the Plan
+### Step 3: Execute the Plan
 
 Once the plan is created, you can command the AI agents to start working.
 
@@ -46,7 +42,7 @@ Once the plan is created, you can command the AI agents to start working.
 
 You will see CCW's agents (like `@code-developer`) begin to execute tasks one by one. It will automatically create files, write code, and install dependencies.
 
-### Step 5: Check the Status
+### Step 4: Check the Status
 
 Want to know the progress? You can check the status of the current workflow at any time.
 
@@ -144,7 +140,43 @@ For complex features requiring thorough analysis, use the complete workflow: **b
 - Architectural decisions with significant impact
 - When you need thorough requirements before implementation
 
-### Scenario 4: Bug Fixing
+### Scenario 4: Quality Assurance - Action Plan Verification
+
+After planning, validate your implementation plan for consistency and completeness:
+
+```bash
+# After /workflow:plan completes, verify task quality
+/workflow:action-plan-verify
+
+# The command will:
+# 1. Check requirements coverage (all requirements have tasks)
+# 2. Validate task dependencies (no circular or broken dependencies)
+# 3. Ensure synthesis alignment (tasks match architectural decisions)
+# 4. Assess task specification quality
+# 5. Generate detailed verification report with remediation todos
+```
+
+**The verification report includes**:
+- Requirements coverage analysis
+- Dependency graph validation
+- Synthesis alignment checks
+- Task specification quality assessment
+- Prioritized remediation recommendations
+
+**When to Use**:
+- After `/workflow:plan` generates IMPL_PLAN.md and task files
+- Before starting `/workflow:execute`
+- When working on complex projects with many dependencies
+- When you want to ensure high-quality task specifications
+
+**Benefits**:
+- Catches planning errors before execution
+- Ensures complete requirements coverage
+- Validates architectural consistency
+- Identifies resource conflicts and skill gaps
+- Provides actionable remediation plan with TodoWrite integration
+
+### Scenario 6: Bug Fixing
 
 Quick bug analysis and fix workflow:
 
@@ -152,8 +184,7 @@ Quick bug analysis and fix workflow:
 # Analyze the bug
 /cli:mode:bug-index "Incorrect success message with wrong password"
 
-# Generate and execute fix plan
-/workflow:execute
+# Claude will analyze and then directly implement the fix based on the analysis
 ```
 
 ---
@@ -247,12 +278,12 @@ Suitable for large-scale refactoring, architectural changes, or first-time CCW u
 
 ```bash
 # Rebuild entire project documentation index
-/update-memory-full
+/memory:update-full
 
 # Use specific tool for indexing
-/update-memory-full --tool gemini   # Comprehensive analysis (recommended)
-/update-memory-full --tool qwen     # Architecture focus
-/update-memory-full --tool codex    # Implementation details
+/memory:update-full --tool gemini   # Comprehensive analysis (recommended)
+/memory:update-full --tool qwen     # Architecture focus
+/memory:update-full --tool codex    # Implementation details
 ```
 
 **When to Execute**:
@@ -292,10 +323,10 @@ Suitable for daily development, updating only modules affected by changes:
 
 ```bash
 # Update recently modified related documentation
-/update-memory-related
+/memory:update-related
 
 # Specify tool for update
-/update-memory-related --tool gemini
+/memory:update-related --tool gemini
 ```
 
 **When to Execute**:

GETTING_STARTED_CN.md

@@ -1,7 +1,11 @@
 
 # 🚀 Claude Code Workflow (CCW) - 快速上手指南
 
-欢迎来到 Claude Code Workflow (CCW) v4.6.2！本指南将帮助您在 5 分钟内快速入门，体验由 AI 驱动的自动化软件开发流程，以及我们最新的工作流系统优化。
+欢迎来到 Claude Code Workflow (CCW) v5.0！本指南将帮助您在 5 分钟内快速入门，体验由 AI 驱动的自动化软件开发流程，以及我们全新的精简化、零外部依赖的工作流系统。
+
+**项目地址**：[catlog22/Claude-Code-Workflow](https://github.com/catlog22/Claude-Code-Workflow)
+
+> **🎉 v5.0 新特性：少即是多**！我们移除了外部 MCP 依赖，简化了工作流程。CCW 现在使用标准工具（ripgrep/find）以获得更好的稳定性和性能。头脑风暴工作流专注于角色分析，使规划更加清晰。
 
 ---
 
@@ -136,7 +140,43 @@
 - 具有重大影响的架构决策
 - 实现前需要详尽需求分析
 
-### 场景 4：Bug 修复
+### 场景 4：质量保证 - 行动计划验证
+
+规划后，验证您的实现计划的一致性和完整性：
+
+```bash
+# /workflow:plan 完成后，验证任务质量
+/workflow:action-plan-verify
+
+# 该命令将：
+# 1. 检查需求覆盖率（所有需求都有任务）
+# 2. 验证任务依赖关系（无循环或损坏的依赖）
+# 3. 确保综合对齐（任务符合架构决策）
+# 4. 评估任务规范质量
+# 5. 生成详细的验证报告和修复待办事项
+```
+
+**验证报告包括**：
+- 需求覆盖率分析
+- 依赖关系图验证
+- 综合对齐检查
+- 任务规范质量评估
+- 优先级修复建议
+
+**使用时机**：
+- 在 `/workflow:plan` 生成 IMPL_PLAN.md 和任务文件后
+- 在开始 `/workflow:execute` 之前
+- 处理具有许多依赖关系的复杂项目时
+- 当您想确保高质量的任务规范时
+
+**优势**：
+- 在执行前捕获规划错误
+- 确保完整的需求覆盖
+- 验证架构一致性
+- 识别资源冲突和技能差距
+- 提供可执行的修复计划，集成 TodoWrite
+
+### 场景 6：Bug 修复
 
 快速 Bug 分析和修复工作流：
 
@@ -144,8 +184,7 @@
 # 分析 Bug
 /cli:mode:bug-index "密码错误时仍显示成功消息"
 
-# 生成并执行修复计划
-/workflow:execute
+# Claude 会分析后直接根据分析结果实现修复
 ```
 
 ---
@@ -239,12 +278,12 @@ CCW 使用分层的 CLAUDE.md 文档系统维护项目上下文。定期更新
 
 ```bash
 # 重建整个项目的文档索引
-/update-memory-full
+/memory:update-full
 
 # 使用特定工具进行索引
-/update-memory-full --tool gemini   # 全面分析（推荐）
-/update-memory-full --tool qwen     # 架构重点
-/update-memory-full --tool codex    # 实现细节
+/memory:update-full --tool gemini   # 全面分析（推荐）
+/memory:update-full --tool qwen     # 架构重点
+/memory:update-full --tool codex    # 实现细节
 ```
 
 **执行时机**：
@@ -284,10 +323,10 @@ CCW 使用分层的 CLAUDE.md 文档系统维护项目上下文。定期更新
 
 ```bash
 # 更新最近修改相关的文档
-/update-memory-related
+/memory:update-related
 
 # 指定工具进行更新
-/update-memory-related --tool gemini
+/memory:update-related --tool gemini
 ```
 
 **执行时机**：

INSTALL_CN.md

@@ -4,6 +4,8 @@
 
 Claude Code Agent 工作流协调和分布式内存系统的交互式安装指南。
 
+> **版本 5.0：精简化安装** - 移除了外部 MCP 依赖，安装更简单、更稳定。使用标准工具（ripgrep/find）提供更好的性能和兼容性。
+
 ## ⚡ 一键远程安装（推荐）
 
 ### 所有平台 - 远程 PowerShell 安装

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!
 
@@ -73,18 +79,18 @@ The best way to get started is to follow the 5-minute tutorial in the [**Getting
 
 Here is a quick example of a common development workflow:
 
-1.  **Start a Session**:
-    ```bash
-    /workflow:session:start "Implement user login feature"
-    ```
-2.  **Create a Plan**:
+1.  **Create a Plan** (automatically starts a session):
     ```bash
     /workflow:plan "Implement JWT-based user login and registration"
     ```
-3.  **Execute the Plan**:
+2.  **Execute the Plan**:
     ```bash
     /workflow:execute
     ```
+3.  **Check Status** (optional):
+    ```bash
+    /workflow:status
+    ```
 
 ---
 

README_CN.md

@@ -2,10 +2,9 @@
 
 <div align="center">
 
-[![Version](https://img.shields.io/badge/version-v4.6.0-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)
 
 **语言:** [English](README.md) | [中文](README_CN.md)
 
@@ -15,7 +14,14 @@
 
 **Claude Code Workflow (CCW)** 将 AI 开发从简单的提示词链接转变为一个强大的、上下文优先的编排系统。它通过结构化规划、确定性执行和智能多模型编排，解决了执行不确定性和误差累积的问题。
 
-> **🎉 最新版本: v4.6.0** - 概念澄清与智能体驱动分析。详见 [CHANGELOG.md](CHANGELOG.md)。
+> **🎉 版本 5.0: 少即是多**
+>
+> **核心改进**:
+> - ✅ **移除外部依赖** - 使用标准 ripgrep/find 替代 MCP code-index，提升稳定性
+> - ✅ **简化工作流** - 优化 TDD 流程，引入冲突解决机制
+> - ✅ **专注角色分析** - 以角色文档为核心，简化规划架构
+>
+> 详见 [CHANGELOG.md](CHANGELOG.md)。
 
 > 📚 **第一次使用 CCW？** 查看 [**快速上手指南**](GETTING_STARTED_CN.md) 获取新手友好的 5 分钟教程！
 
@@ -73,18 +79,18 @@ CCW 提供了一套丰富的命令，用于管理工作流、任务以及与 AI
 
 以下是一个常见开发工作流的快速示例：
 
-1.  **启动会话**:
-    ```bash
-    /workflow:session:start "实现用户登录功能"
-    ```
-2.  **创建计划**:
+1.  **创建计划**（自动启动会话）:
     ```bash
     /workflow:plan "实现基于 JWT 的用户登录和注册"
     ```
-3.  **执行计划**:
+2.  **执行计划**:
     ```bash
     /workflow:execute
     ```
+3.  **查看状态**（可选）:
+    ```bash
+    /workflow:status
+    ```
 
 ---
 

install-remote.ps1

@@ -153,7 +153,22 @@ function Test-Prerequisites {
         Write-ColorOutput "✓ Network connection OK" $ColorSuccess
     } catch {
         Write-ColorOutput "ERROR: Cannot connect to GitHub" $ColorError
-        Write-ColorOutput "Please check your network connection: $($_.Exception.Message)" $ColorError
+        Write-ColorOutput "Please check your network connection and try again." $ColorError
+        Write-Host ""
+        Write-ColorOutput "Common causes:" $ColorInfo
+        Write-Host "  • Internet connection is down or unstable"
+        Write-Host "  • Firewall or proxy is blocking GitHub access"
+        Write-Host "  • DNS resolution issues"
+        Write-Host "  • GitHub is temporarily unavailable"
+        Write-Host ""
+        Write-ColorOutput "Troubleshooting steps:" $ColorInfo
+        Write-Host "  1. Check your internet connection"
+        Write-Host "  2. Try accessing https://github.com in your browser"
+        Write-Host "  3. If using a proxy, configure it properly"
+        Write-Host "  4. Check firewall settings"
+        Write-Host "  5. Wait a few minutes and try again"
+        Write-Host ""
+        Write-ColorOutput "Error details: $($_.Exception.Message)" $ColorError
         return $false
     }
 
@@ -172,10 +187,12 @@ function Get-TempDirectory {
 function Get-LatestRelease {
     try {
         $apiUrl = "https://api.github.com/repos/catlog22/Claude-Code-Workflow/releases/latest"
-        $response = Invoke-RestMethod -Uri $apiUrl -UseBasicParsing
+        $response = Invoke-RestMethod -Uri $apiUrl -UseBasicParsing -TimeoutSec 10
         return $response.tag_name
     } catch {
-        Write-ColorOutput "WARNING: Failed to fetch latest release, using 'main' branch" $ColorWarning
+        Write-ColorOutput "WARNING: Failed to fetch latest release" $ColorWarning
+        Write-ColorOutput "Reason: $($_.Exception.Message)" $ColorWarning
+        Write-ColorOutput "Falling back to 'main' branch" $ColorInfo
         return $null
     }
 }
@@ -229,19 +246,40 @@ function Download-Repository {
         $progressPreference = $ProgressPreference
         $ProgressPreference = 'SilentlyContinue'
 
-        Invoke-WebRequest -Uri $zipUrl -OutFile $zipPath -UseBasicParsing
+        Invoke-WebRequest -Uri $zipUrl -OutFile $zipPath -UseBasicParsing -TimeoutSec 300
 
         $ProgressPreference = $progressPreference
 
         if (Test-Path $zipPath) {
             $fileSize = (Get-Item $zipPath).Length
+            if ($fileSize -eq 0) {
+                throw "Downloaded file is empty (0 bytes)"
+            }
             Write-ColorOutput "Download complete ($([math]::Round($fileSize/1024/1024, 2)) MB)" $ColorSuccess
             return $zipPath
         } else {
             throw "Downloaded file does not exist"
         }
     } catch {
-        Write-ColorOutput "Download failed: $($_.Exception.Message)" $ColorError
+        Write-Host ""
+        Write-ColorOutput "ERROR: Download failed" $ColorError
+        Write-Host ""
+        Write-ColorOutput "Common causes:" $ColorInfo
+        Write-Host "  • Network connection interrupted during download"
+        Write-Host "  • GitHub API rate limit exceeded"
+        Write-Host "  • Invalid version tag or branch name"
+        Write-Host "  • Temporary GitHub service issues"
+        Write-Host ""
+        Write-ColorOutput "Troubleshooting steps:" $ColorInfo
+        Write-Host "  1. Check your internet connection stability"
+        Write-Host "  2. Wait a few minutes and try again (rate limit resets)"
+        Write-Host "  3. Verify the version tag or branch name is correct"
+        Write-Host "  4. Try a different version (stable/latest)"
+        Write-Host "  5. Check GitHub status at https://www.githubstatus.com"
+        Write-Host ""
+        Write-ColorOutput "Download URL: $zipUrl" $ColorInfo
+        Write-ColorOutput "Error details: $($_.Exception.Message)" $ColorError
+        Write-Host ""
         return $null
     }
 }
@@ -255,14 +293,24 @@ function Extract-Repository {
     Write-ColorOutput "Extracting files..." $ColorInfo
     
     try {
+        # Verify zip file exists and is not empty
+        if (-not (Test-Path $ZipPath)) {
+            throw "ZIP file not found: $ZipPath"
+        }
+
+        $zipSize = (Get-Item $ZipPath).Length
+        if ($zipSize -eq 0) {
+            throw "ZIP file is empty (0 bytes)"
+        }
+
         # Use .NET to extract zip
         Add-Type -AssemblyName System.IO.Compression.FileSystem
         [System.IO.Compression.ZipFile]::ExtractToDirectory($ZipPath, $TempDir)
-        
+
         # Find the extracted directory (usually repo-name-branch)
         $extractedDirs = Get-ChildItem -Path $TempDir -Directory
         $repoDir = $extractedDirs | Where-Object { $_.Name -like "Claude-Code-Workflow-*" } | Select-Object -First 1
-        
+
         if ($repoDir) {
             Write-ColorOutput "Extraction complete: $($repoDir.FullName)" $ColorSuccess
             return $repoDir.FullName
@@ -270,7 +318,27 @@ function Extract-Repository {
             throw "Could not find extracted repository directory"
         }
     } catch {
-        Write-ColorOutput "Extraction failed: $($_.Exception.Message)" $ColorError
+        Write-Host ""
+        Write-ColorOutput "ERROR: Extraction failed" $ColorError
+        Write-Host ""
+        Write-ColorOutput "Common causes:" $ColorInfo
+        Write-Host "  • Downloaded file is corrupted or incomplete"
+        Write-Host "  • ZIP file format is invalid"
+        Write-Host "  • Insufficient disk space"
+        Write-Host "  • Permission issues on temporary directory"
+        Write-Host ""
+        Write-ColorOutput "Troubleshooting steps:" $ColorInfo
+        Write-Host "  1. Try downloading again (network may have interrupted)"
+        Write-Host "  2. Check available disk space"
+        Write-Host "  3. Verify temporary directory permissions"
+        Write-Host "  4. Try running as administrator"
+        Write-Host ""
+        Write-ColorOutput "ZIP file: $ZipPath" $ColorInfo
+        if (Test-Path $ZipPath) {
+            Write-ColorOutput "ZIP size: $([math]::Round($zipSize/1024/1024, 2)) MB" $ColorInfo
+        }
+        Write-ColorOutput "Error details: $($_.Exception.Message)" $ColorError
+        Write-Host ""
         return $null
     }
 }

install-remote.sh

@@ -74,7 +74,21 @@ function test_prerequisites() {
         write_color "✓ Network connection OK" "$COLOR_SUCCESS"
     else
         write_color "ERROR: Cannot connect to GitHub" "$COLOR_ERROR"
-        write_color "Please check your network connection" "$COLOR_ERROR"
+        write_color "Please check your network connection and try again." "$COLOR_ERROR"
+        echo ""
+        write_color "Common causes:" "$COLOR_INFO"
+        echo "  • Internet connection is down or unstable"
+        echo "  • Firewall or proxy is blocking GitHub access"
+        echo "  • DNS resolution issues"
+        echo "  • GitHub is temporarily unavailable"
+        echo ""
+        write_color "Troubleshooting steps:" "$COLOR_INFO"
+        echo "  1. Check your internet connection"
+        echo "  2. Try accessing https://github.com in your browser"
+        echo "  3. If using a proxy, configure it properly"
+        echo "  4. Check firewall settings"
+        echo "  5. Wait a few minutes and try again"
+        echo ""
         return 1
     fi
 
@@ -108,7 +122,8 @@ function get_latest_release() {
         fi
     fi
 
-    write_color "WARNING: Failed to fetch latest release, using 'main' branch" "$COLOR_WARNING" >&2
+    write_color "WARNING: Failed to fetch latest release" "$COLOR_WARNING" >&2
+    write_color "Falling back to 'main' branch" "$COLOR_INFO" >&2
     return 1
 }
 
@@ -163,11 +178,34 @@ function download_repository() {
     write_color "Type: $download_type" "$COLOR_INFO" >&2
 
     # Download with curl
-    if curl -fsSL -o "$zip_path" "$zip_url" 2>&1 >&2; then
+    local download_error=""
+    if download_error=$(curl -fsSL -o "$zip_path" "$zip_url" 2>&1); then
         # Verify the download
         if [ -f "$zip_path" ]; then
             local file_size
             file_size=$(du -h "$zip_path" 2>/dev/null | cut -f1)
+
+            # Check if file is empty
+            if [ ! -s "$zip_path" ]; then
+                echo "" >&2
+                write_color "ERROR: Downloaded file is empty (0 bytes)" "$COLOR_ERROR" >&2
+                echo "" >&2
+                write_color "Common causes:" "$COLOR_INFO" >&2
+                echo "  • Network connection was interrupted" >&2
+                echo "  • Invalid version tag or branch name" >&2
+                echo "  • GitHub API or server issues" >&2
+                echo "" >&2
+                write_color "Troubleshooting steps:" "$COLOR_INFO" >&2
+                echo "  1. Verify the version tag or branch name is correct" >&2
+                echo "  2. Wait a few minutes and try again" >&2
+                echo "  3. Try a different version (stable/latest)" >&2
+                echo "  4. Check GitHub status at https://www.githubstatus.com" >&2
+                echo "" >&2
+                write_color "Download URL: $zip_url" "$COLOR_INFO" >&2
+                echo "" >&2
+                return 1
+            fi
+
             write_color "✓ Download complete ($file_size)" "$COLOR_SUCCESS" >&2
 
             # Output path to stdout for capture
@@ -178,7 +216,29 @@ function download_repository() {
             return 1
         fi
     else
+        echo "" >&2
         write_color "ERROR: Download failed" "$COLOR_ERROR" >&2
+        echo "" >&2
+        write_color "Common causes:" "$COLOR_INFO" >&2
+        echo "  • Network connection interrupted during download" >&2
+        echo "  • GitHub API rate limit exceeded" >&2
+        echo "  • Invalid version tag or branch name" >&2
+        echo "  • Temporary GitHub service issues" >&2
+        echo "  • Firewall or proxy blocking the download" >&2
+        echo "" >&2
+        write_color "Troubleshooting steps:" "$COLOR_INFO" >&2
+        echo "  1. Check your internet connection stability" >&2
+        echo "  2. Wait a few minutes and try again (rate limit resets)" >&2
+        echo "  3. Verify the version tag or branch name is correct" >&2
+        echo "  4. Try a different version (stable/latest)" >&2
+        echo "  5. Check GitHub status at https://www.githubstatus.com" >&2
+        echo "  6. If using a proxy, verify it's configured correctly" >&2
+        echo "" >&2
+        write_color "Download URL: $zip_url" "$COLOR_INFO" >&2
+        if [ -n "$download_error" ]; then
+            write_color "Error details: $download_error" "$COLOR_ERROR" >&2
+        fi
+        echo "" >&2
         return 1
     fi
 }
@@ -195,8 +255,27 @@ function extract_repository() {
         return 1
     fi
 
+    # Verify zip file is not empty
+    if [ ! -s "$zip_path" ]; then
+        echo "" >&2
+        write_color "ERROR: ZIP file is empty (0 bytes)" "$COLOR_ERROR" >&2
+        echo "" >&2
+        write_color "Common causes:" "$COLOR_INFO" >&2
+        echo "  • Download was interrupted" >&2
+        echo "  • Network connection issues during download" >&2
+        echo "  • Server-side issues" >&2
+        echo "" >&2
+        write_color "Troubleshooting steps:" "$COLOR_INFO" >&2
+        echo "  1. Try downloading again" >&2
+        echo "  2. Check your network connection" >&2
+        echo "  3. Wait a few minutes and retry" >&2
+        echo "" >&2
+        return 1
+    fi
+
     # Extract with unzip
-    if unzip -q "$zip_path" -d "$temp_dir" >&2 2>&1; then
+    local extract_error=""
+    if extract_error=$(unzip -q "$zip_path" -d "$temp_dir" 2>&1); then
         # Find the extracted directory
         local repo_dir
         repo_dir=$(find "$temp_dir" -maxdepth 1 -type d -name "Claude-Code-Workflow-*" 2>/dev/null | head -n 1)
@@ -207,13 +286,39 @@ function extract_repository() {
             echo "$repo_dir"
             return 0
         else
+            echo "" >&2
             write_color "ERROR: Could not find extracted repository directory" "$COLOR_ERROR" >&2
             write_color "Temp directory contents:" "$COLOR_INFO" >&2
             ls -la "$temp_dir" >&2
+            echo "" >&2
             return 1
         fi
     else
+        echo "" >&2
         write_color "ERROR: Extraction failed" "$COLOR_ERROR" >&2
+        echo "" >&2
+        write_color "Common causes:" "$COLOR_INFO" >&2
+        echo "  • Downloaded file is corrupted or incomplete" >&2
+        echo "  • ZIP file format is invalid" >&2
+        echo "  • Insufficient disk space" >&2
+        echo "  • Permission issues on temporary directory" >&2
+        echo "" >&2
+        write_color "Troubleshooting steps:" "$COLOR_INFO" >&2
+        echo "  1. Try downloading again (network may have interrupted)" >&2
+        echo "  2. Check available disk space: df -h" >&2
+        echo "  3. Verify temporary directory permissions" >&2
+        echo "  4. Check if 'unzip' command is working: unzip -v" >&2
+        echo "" >&2
+        write_color "ZIP file: $zip_path" "$COLOR_INFO" >&2
+        if [ -f "$zip_path" ]; then
+            local zip_size
+            zip_size=$(du -h "$zip_path" 2>/dev/null | cut -f1)
+            write_color "ZIP size: $zip_size" "$COLOR_INFO" >&2
+        fi
+        if [ -n "$extract_error" ]; then
+            write_color "Error details: $extract_error" "$COLOR_ERROR" >&2
+        fi
+        echo "" >&2
         return 1
     fi
 }

skills.md

@@ -1,598 +0,0 @@
-# Agent Skills
-
-> Create, manage, and share Skills to extend Claude's capabilities in Claude Code.
-
-This guide shows you how to create, use, and manage Agent Skills in Claude Code. Skills are modular capabilities that extend Claude's functionality through organized folders containing instructions, scripts, and resources.
-
-## Prerequisites
-
-* Claude Code version 1.0 or later
-* Basic familiarity with [Claude Code](/en/docs/claude-code/quickstart)
-
-## What are Agent Skills?
-
-Agent Skills package expertise into discoverable capabilities. Each Skill consists of a `SKILL.md` file with instructions that Claude reads when relevant, plus optional supporting files like scripts and templates.
-
-**How Skills are invoked**: Skills are **model-invoked**—Claude autonomously decides when to use them based on your request and the Skill's description. This is different from slash commands, which are **user-invoked** (you explicitly type `/command` to trigger them).
-
-**Benefits**:
-
-* Extend Claude's capabilities for your specific workflows
-* Share expertise across your team via git
-* Reduce repetitive prompting
-* Compose multiple Skills for complex tasks
-
-Learn more in the [Agent Skills overview](/en/docs/agents-and-tools/agent-skills/overview).
-
-<Note>
-  For a deep dive into the architecture and real-world applications of Agent Skills, read our engineering blog: [Equipping agents for the real world with Agent Skills](https://www.anthropic.com/engineering/equipping-agents-for-the-real-world-with-agent-skills).
-</Note>
-
-## Create a Skill
-
-Skills are stored as directories containing a `SKILL.md` file.
-
-### Personal Skills
-
-Personal Skills are available across all your projects. Store them in `~/.claude/skills/`:
-
-```bash  theme={null}
-mkdir -p ~/.claude/skills/my-skill-name
-```
-
-**Use personal Skills for**:
-
-* Your individual workflows and preferences
-* Experimental Skills you're developing
-* Personal productivity tools
-
-### Project Skills
-
-Project Skills are shared with your team. Store them in `.claude/skills/` within your project:
-
-```bash  theme={null}
-mkdir -p .claude/skills/my-skill-name
-```
-
-**Use project Skills for**:
-
-* Team workflows and conventions
-* Project-specific expertise
-* Shared utilities and scripts
-
-Project Skills are checked into git and automatically available to team members.
-
-### Plugin Skills
-
-Skills can also come from [Claude Code plugins](/en/docs/claude-code/plugins). Plugins may bundle Skills that are automatically available when the plugin is installed. These Skills work the same way as personal and project Skills.
-
-## Write SKILL.md
-
-Create a `SKILL.md` file with YAML frontmatter and Markdown content:
-
-```yaml  theme={null}
----
-name: Your Skill Name
-description: Brief description of what this Skill does and when to use it
----
-
-# Your Skill Name
-
-## Instructions
-Provide clear, step-by-step guidance for Claude.
-
-## Examples
-Show concrete examples of using this Skill.
-```
-
-The `description` field is critical for Claude to discover when to use your Skill. It should include both what the Skill does and when Claude should use it.
-
-See the [best practices guide](/en/docs/agents-and-tools/agent-skills/best-practices) for complete authoring guidance.
-
-## Add supporting files
-
-Create additional files alongside SKILL.md:
-
-```
-my-skill/
-├── SKILL.md (required)
-├── reference.md (optional documentation)
-├── examples.md (optional examples)
-├── scripts/
-│   └── helper.py (optional utility)
-└── templates/
-    └── template.txt (optional template)
-```
-
-Reference these files from SKILL.md:
-
-````markdown  theme={null}
-For advanced usage, see [reference.md](reference.md).
-
-Run the helper script:
-```bash
-python scripts/helper.py input.txt
-```
-````
-
-Claude reads these files only when needed, using progressive disclosure to manage context efficiently.
-
-## Restrict tool access with allowed-tools
-
-Use the `allowed-tools` frontmatter field to limit which tools Claude can use when a Skill is active:
-
-```yaml  theme={null}
----
-name: Safe File Reader
-description: Read files without making changes. Use when you need read-only file access.
-allowed-tools: Read, Grep, Glob
----
-
-# Safe File Reader
-
-This Skill provides read-only file access.
-
-## Instructions
-1. Use Read to view file contents
-2. Use Grep to search within files
-3. Use Glob to find files by pattern
-```
-
-When this Skill is active, Claude can only use the specified tools (Read, Grep, Glob) without needing to ask for permission. This is useful for:
-
-* Read-only Skills that shouldn't modify files
-* Skills with limited scope (e.g., only data analysis, no file writing)
-* Security-sensitive workflows where you want to restrict capabilities
-
-If `allowed-tools` is not specified, Claude will ask for permission to use tools as normal, following the standard permission model.
-
-<Note>
-  `allowed-tools` is only supported for Skills in Claude Code.
-</Note>
-
-## View available Skills
-
-Skills are automatically discovered by Claude from three sources:
-
-* Personal Skills: `~/.claude/skills/`
-* Project Skills: `.claude/skills/`
-* Plugin Skills: bundled with installed plugins
-
-**To view all available Skills**, ask Claude directly:
-
-```
-What Skills are available?
-```
-
-or
-
-```
-List all available Skills
-```
-
-This will show all Skills from all sources, including plugin Skills.
-
-**To inspect a specific Skill**, you can also check the filesystem:
-
-```bash  theme={null}
-# List personal Skills
-ls ~/.claude/skills/
-
-# List project Skills (if in a project directory)
-ls .claude/skills/
-
-# View a specific Skill's content
-cat ~/.claude/skills/my-skill/SKILL.md
-```
-
-## Test a Skill
-
-After creating a Skill, test it by asking questions that match your description.
-
-**Example**: If your description mentions "PDF files":
-
-```
-Can you help me extract text from this PDF?
-```
-
-Claude autonomously decides to use your Skill if it matches the request—you don't need to explicitly invoke it. The Skill activates automatically based on the context of your question.
-
-## Debug a Skill
-
-If Claude doesn't use your Skill, check these common issues:
-
-### Make description specific
-
-**Too vague**:
-
-```yaml  theme={null}
-description: Helps with documents
-```
-
-**Specific**:
-
-```yaml  theme={null}
-description: Extract text and tables from PDF files, fill forms, merge documents. Use when working with PDF files or when the user mentions PDFs, forms, or document extraction.
-```
-
-Include both what the Skill does and when to use it in the description.
-
-### Verify file path
-
-**Personal Skills**: `~/.claude/skills/skill-name/SKILL.md`
-**Project Skills**: `.claude/skills/skill-name/SKILL.md`
-
-Check the file exists:
-
-```bash  theme={null}
-# Personal
-ls ~/.claude/skills/my-skill/SKILL.md
-
-# Project
-ls .claude/skills/my-skill/SKILL.md
-```
-
-### Check YAML syntax
-
-Invalid YAML prevents the Skill from loading. Verify the frontmatter:
-
-```bash  theme={null}
-cat SKILL.md | head -n 10
-```
-
-Ensure:
-
-* Opening `---` on line 1
-* Closing `---` before Markdown content
-* Valid YAML syntax (no tabs, correct indentation)
-
-### View errors
-
-Run Claude Code with debug mode to see Skill loading errors:
-
-```bash  theme={null}
-claude --debug
-```
-
-## Share Skills with your team
-
-**Recommended approach**: Distribute Skills through [plugins](/en/docs/claude-code/plugins).
-
-To share Skills via plugin:
-
-1. Create a plugin with Skills in the `skills/` directory
-2. Add the plugin to a marketplace
-3. Team members install the plugin
-
-For complete instructions, see [Add Skills to your plugin](/en/docs/claude-code/plugins#add-skills-to-your-plugin).
-
-You can also share Skills directly through project repositories:
-
-### Step 1: Add Skill to your project
-
-Create a project Skill:
-
-```bash  theme={null}
-mkdir -p .claude/skills/team-skill
-# Create SKILL.md
-```
-
-### Step 2: Commit to git
-
-```bash  theme={null}
-git add .claude/skills/
-git commit -m "Add team Skill for PDF processing"
-git push
-```
-
-### Step 3: Team members get Skills automatically
-
-When team members pull the latest changes, Skills are immediately available:
-
-```bash  theme={null}
-git pull
-claude  # Skills are now available
-```
-
-## Update a Skill
-
-Edit SKILL.md directly:
-
-```bash  theme={null}
-# Personal Skill
-code ~/.claude/skills/my-skill/SKILL.md
-
-# Project Skill
-code .claude/skills/my-skill/SKILL.md
-```
-
-Changes take effect the next time you start Claude Code. If Claude Code is already running, restart it to load the updates.
-
-## Remove a Skill
-
-Delete the Skill directory:
-
-```bash  theme={null}
-# Personal
-rm -rf ~/.claude/skills/my-skill
-
-# Project
-rm -rf .claude/skills/my-skill
-git commit -m "Remove unused Skill"
-```
-
-## Best practices
-
-### Keep Skills focused
-
-One Skill should address one capability:
-
-**Focused**:
-
-* "PDF form filling"
-* "Excel data analysis"
-* "Git commit messages"
-
-**Too broad**:
-
-* "Document processing" (split into separate Skills)
-* "Data tools" (split by data type or operation)
-
-### Write clear descriptions
-
-Help Claude discover when to use Skills by including specific triggers in your description:
-
-**Clear**:
-
-```yaml  theme={null}
-description: Analyze Excel spreadsheets, create pivot tables, and generate charts. Use when working with Excel files, spreadsheets, or analyzing tabular data in .xlsx format.
-```
-
-**Vague**:
-
-```yaml  theme={null}
-description: For files
-```
-
-### Test with your team
-
-Have teammates use Skills and provide feedback:
-
-* Does the Skill activate when expected?
-* Are the instructions clear?
-* Are there missing examples or edge cases?
-
-### Document Skill versions
-
-You can document Skill versions in your SKILL.md content to track changes over time. Add a version history section:
-
-```markdown  theme={null}
-# My Skill
-
-## Version History
-- v2.0.0 (2025-10-01): Breaking changes to API
-- v1.1.0 (2025-09-15): Added new features
-- v1.0.0 (2025-09-01): Initial release
-```
-
-This helps team members understand what changed between versions.
-
-## Troubleshooting
-
-### Claude doesn't use my Skill
-
-**Symptom**: You ask a relevant question but Claude doesn't use your Skill.
-
-**Check**: Is the description specific enough?
-
-Vague descriptions make discovery difficult. Include both what the Skill does and when to use it, with key terms users would mention.
-
-**Too generic**:
-
-```yaml  theme={null}
-description: Helps with data
-```
-
-**Specific**:
-
-```yaml  theme={null}
-description: Analyze Excel spreadsheets, generate pivot tables, create charts. Use when working with Excel files, spreadsheets, or .xlsx files.
-```
-
-**Check**: Is the YAML valid?
-
-Run validation to check for syntax errors:
-
-```bash  theme={null}
-# View frontmatter
-cat .claude/skills/my-skill/SKILL.md | head -n 15
-
-# Check for common issues
-# - Missing opening or closing ---
-# - Tabs instead of spaces
-# - Unquoted strings with special characters
-```
-
-**Check**: Is the Skill in the correct location?
-
-```bash  theme={null}
-# Personal Skills
-ls ~/.claude/skills/*/SKILL.md
-
-# Project Skills
-ls .claude/skills/*/SKILL.md
-```
-
-### Skill has errors
-
-**Symptom**: The Skill loads but doesn't work correctly.
-
-**Check**: Are dependencies available?
-
-Claude will automatically install required dependencies (or ask for permission to install them) when it needs them.
-
-**Check**: Do scripts have execute permissions?
-
-```bash  theme={null}
-chmod +x .claude/skills/my-skill/scripts/*.py
-```
-
-**Check**: Are file paths correct?
-
-Use forward slashes (Unix style) in all paths:
-
-**Correct**: `scripts/helper.py`
-**Wrong**: `scripts\helper.py` (Windows style)
-
-### Multiple Skills conflict
-
-**Symptom**: Claude uses the wrong Skill or seems confused between similar Skills.
-
-**Be specific in descriptions**: Help Claude choose the right Skill by using distinct trigger terms in your descriptions.
-
-Instead of:
-
-```yaml  theme={null}
-# Skill 1
-description: For data analysis
-
-# Skill 2
-description: For analyzing data
-```
-
-Use:
-
-```yaml  theme={null}
-# Skill 1
-description: Analyze sales data in Excel files and CRM exports. Use for sales reports, pipeline analysis, and revenue tracking.
-
-# Skill 2
-description: Analyze log files and system metrics data. Use for performance monitoring, debugging, and system diagnostics.
-```
-
-## Examples
-
-### Simple Skill (single file)
-
-```
-commit-helper/
-└── SKILL.md
-```
-
-```yaml  theme={null}
----
-name: Generating Commit Messages
-description: Generates clear commit messages from git diffs. Use when writing commit messages or reviewing staged changes.
----
-
-# Generating Commit Messages
-
-## Instructions
-
-1. Run `git diff --staged` to see changes
-2. I'll suggest a commit message with:
-   - Summary under 50 characters
-   - Detailed description
-   - Affected components
-
-## Best practices
-
-- Use present tense
-- Explain what and why, not how
-```
-
-### Skill with tool permissions
-
-```
-code-reviewer/
-└── SKILL.md
-```
-
-```yaml  theme={null}
----
-name: Code Reviewer
-description: Review code for best practices and potential issues. Use when reviewing code, checking PRs, or analyzing code quality.
-allowed-tools: Read, Grep, Glob
----
-
-# Code Reviewer
-
-## Review checklist
-
-1. Code organization and structure
-2. Error handling
-3. Performance considerations
-4. Security concerns
-5. Test coverage
-
-## Instructions
-
-1. Read the target files using Read tool
-2. Search for patterns using Grep
-3. Find related files using Glob
-4. Provide detailed feedback on code quality
-```
-
-### Multi-file Skill
-
-```
-pdf-processing/
-├── SKILL.md
-├── FORMS.md
-├── REFERENCE.md
-└── scripts/
-    ├── fill_form.py
-    └── validate.py
-```
-
-**SKILL.md**:
-
-````yaml  theme={null}
----
-name: PDF Processing
-description: Extract text, fill forms, merge PDFs. Use when working with PDF files, forms, or document extraction. Requires pypdf and pdfplumber packages.
----
-
-# PDF Processing
-
-## Quick start
-
-Extract text:
-```python
-import pdfplumber
-with pdfplumber.open("doc.pdf") as pdf:
-    text = pdf.pages[0].extract_text()
-```
-
-For form filling, see [FORMS.md](FORMS.md).
-For detailed API reference, see [REFERENCE.md](REFERENCE.md).
-
-## Requirements
-
-Packages must be installed in your environment:
-```bash
-pip install pypdf pdfplumber
-```
-````
-
-<Note>
-  List required packages in the description. Packages must be installed in your environment before Claude can use them.
-</Note>
-
-Claude loads additional files only when needed.
-
-## Next steps
-
-<CardGroup cols={2}>
-  <Card title="Authoring best practices" icon="lightbulb" href="/en/docs/agents-and-tools/agent-skills/best-practices">
-    Write Skills that Claude can use effectively
-  </Card>
-
-  <Card title="Agent Skills overview" icon="book" href="/en/docs/agents-and-tools/agent-skills/overview">
-    Learn how Skills work across Claude products
-  </Card>
-
-  <Card title="Get started with Agent Skills" icon="rocket" href="/en/docs/agents-and-tools/agent-skills/quickstart">
-    Create your first Skill
-  </Card>
-</CardGroup>