chore: Bump version to 6.3.52

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

.claude/CLAUDE.md

@@ -9,12 +9,7 @@
 
 **Strictly follow the cli-tools.json configuration**
 
-Available CLI endpoints are dynamically defined by the config file:
-- Built-in tools and their enable/disable status
-- Custom API endpoints registered via the Dashboard
-- Managed through the CCW Dashboard Status page
-
-
+Available CLI endpoints are dynamically defined by the config file
 ## Tool Execution
 
 - **Context Requirements**: @~/.claude/workflows/context-tools.md
@@ -25,9 +20,12 @@ Available CLI endpoints are dynamically defined by the config file:
 - **TaskOutput usage**: Only use `TaskOutput({ task_id: "xxx", block: false })` + sleep loop to poll completion status. NEVER read intermediate output during agent/CLI execution - wait for final result only
 
 ### CLI Tool Calls (ccw cli)
-- **Default: `run_in_background: true`** - Unless otherwise specified, always use background execution for CLI calls:
+- **Default: Use Bash `run_in_background: true`** - Unless otherwise specified, always execute CLI calls in background using Bash tool's background mode:
   ```
-  Bash({ command: "ccw cli -p '...' --tool gemini", run_in_background: true })
+  Bash({
+    command: "ccw cli -p '...' --tool gemini",
+    run_in_background: true  // Bash tool parameter, not ccw cli parameter
+  })
   ```
 - **After CLI call**: Stop output immediately - let CLI execute in background. **DO NOT use TaskOutput polling** - wait for hook callback to receive results
 

.claude/active_memory_config.json

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

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

@@ -55,6 +55,17 @@ color: yellow
 **Step-by-step execution**:
 
 ```
+0. Load planning notes → Extract phase-level constraints (NEW)
+   Commands: Read('.workflow/active/{session-id}/planning-notes.md')
+   Output: Consolidated constraints from all workflow phases
+   Structure:
+     - User Intent: Original GOAL, KEY_CONSTRAINTS
+     - Context Findings: Critical files, architecture notes, constraints
+     - Conflict Decisions: Resolved conflicts, modified artifacts
+     - Consolidated Constraints: Numbered list of ALL constraints (Phase 1-3)
+
+   USAGE: This is the PRIMARY source of constraints. All task generation MUST respect these constraints.
+
 1. Load session metadata → Extract user input
    - User description: Original task/feature requirements
    - Project scope: User-specified boundaries and goals
@@ -299,25 +310,22 @@ function computeCliStrategy(task, allTasks) {
 
 **execution_config Alignment Rules** (MANDATORY):
 ```
-userConfig.executionMethod → meta.execution_config + implementation_approach
+userConfig.executionMethod → meta.execution_config
 
 "agent" →
   meta.execution_config = { method: "agent", cli_tool: null, enable_resume: false }
-  implementation_approach steps: NO command field (agent direct execution)
-
-"hybrid" →
-  meta.execution_config = { method: "hybrid", cli_tool: userConfig.preferredCliTool }
-  implementation_approach steps: command field ONLY on complex steps
+  Execution: Agent executes pre_analysis, then directly implements implementation_approach
 
 "cli" →
-  meta.execution_config = { method: "cli", cli_tool: userConfig.preferredCliTool }
-  implementation_approach steps: command field on ALL steps
+  meta.execution_config = { method: "cli", cli_tool: userConfig.preferredCliTool, enable_resume: true }
+  Execution: Agent executes pre_analysis, then hands off context + implementation_approach to CLI
+
+"hybrid" →
+  meta.execution_config = { method: "hybrid", cli_tool: userConfig.preferredCliTool, enable_resume: true }
+  Execution: Agent decides which tasks to handoff to CLI based on complexity
 ```
 
-**Consistency Check**: `meta.execution_config.method` MUST match presence of `command` fields:
-- `method: "agent"` → 0 steps have command field
-- `method: "hybrid"` → some steps have command field
-- `method: "cli"` → all steps have command field
+**Note**: implementation_approach steps NO LONGER contain `command` fields. CLI execution is controlled by task-level `meta.execution_config` only.
 
 **Test Task Extensions** (for type="test-gen" or type="test-fix"):
 
@@ -638,32 +646,6 @@ Agent determines CLI tool usage per-step based on user semantics and task nature
     "output": "implementation"
   },
 
-  // === CLI MODE: Command Execution (optional command field) ===
-  {
-    "step": 3,
-    "title": "Execute implementation using CLI tool",
-    "description": "Use Codex/Gemini for complex autonomous execution",
-    "command": "ccw cli -p '[prompt]' --tool codex --mode write --cd [path]",
-    "modification_points": ["[Same as default mode]"],
-    "logic_flow": ["[Same as default mode]"],
-    "depends_on": [1, 2],
-    "output": "cli_implementation",
-    "cli_output_id": "step3_cli_id"  // Store execution ID for resume
-  },
-
-  // === CLI MODE with Resume: Continue from previous CLI execution ===
-  {
-    "step": 4,
-    "title": "Continue implementation with context",
-    "description": "Resume from previous step with accumulated context",
-    "command": "ccw cli -p '[continuation prompt]' --resume ${step3_cli_id} --tool codex --mode write",
-    "resume_from": "step3_cli_id",  // Reference previous step's CLI ID
-    "modification_points": ["[Continue from step 3]"],
-    "logic_flow": ["[Build on previous output]"],
-    "depends_on": [3],
-    "output": "continued_implementation",
-    "cli_output_id": "step4_cli_id"
-  }
 ]
 ```
 
@@ -785,13 +767,13 @@ Generate at `.workflow/active/{session_id}/TODO_LIST.md`:
 Use `analysis_results.complexity` or task count to determine structure:
 
 **Single Module Mode**:
-- **Simple Tasks** (≤5 tasks): Flat structure
-- **Medium Tasks** (6-12 tasks): Flat structure
-- **Complex Tasks** (>12 tasks): Re-scope required (maximum 12 tasks hard limit)
+- **Simple Tasks** (≤4 tasks): Flat structure
+- **Medium Tasks** (5-8 tasks): Flat structure
+- **Complex Tasks** (>8 tasks): Re-scope required (maximum 8 tasks hard limit)
 
 **Multi-Module Mode** (N+1 parallel planning):
-- **Per-module limit**: ≤9 tasks per module
-- **Total limit**: Sum of all module tasks ≤27 (3 modules × 9 tasks)
+- **Per-module limit**: ≤6 tasks per module
+- **Total limit**: No total limit (each module independently capped at 6 tasks)
 - **Task ID format**: `IMPL-{prefix}{seq}` (e.g., IMPL-A1, IMPL-B1)
 - **Structure**: Hierarchical by module in IMPL_PLAN.md and TODO_LIST.md
 
@@ -855,6 +837,7 @@ Use `analysis_results.complexity` or task count to determine structure:
 ### 3.3 Guidelines Checklist
 
 **ALWAYS:**
+- **Load planning-notes.md FIRST**: Read planning-notes.md before context-package.json. Use its Consolidated Constraints as primary constraint source for all task generation
 - **Search Tool Priority**: ACE (`mcp__ace-tool__search_context`) → CCW (`mcp__ccw-tools__smart_search`) / Built-in (`Grep`, `Glob`, `Read`)
 - Apply Quantification Requirements to all requirements, acceptance criteria, and modification points
 - Load IMPL_PLAN template: `Read(~/.claude/workflows/cli-templates/prompts/workflow/impl-plan-template.txt)` before generating IMPL_PLAN.md
@@ -865,7 +848,7 @@ Use `analysis_results.complexity` or task count to determine structure:
 - **Compute CLI execution strategy**: Based on `depends_on`, set `cli_execution.strategy` (new/resume/fork/merge_fork)
 - Map artifacts: Use artifacts_inventory to populate task.context.artifacts array
 - Add MCP integration: Include MCP tool steps in flow_control.pre_analysis when capabilities available
-- Validate task count: Maximum 12 tasks hard limit, request re-scope if exceeded
+- Validate task count: Maximum 8 tasks (single module) or 6 tasks per module (multi-module), request re-scope if exceeded
 - Use session paths: Construct all paths using provided session_id
 - Link documents properly: Use correct linking format (📋 for JSON, ✅ for summaries)
 - Run validation checklist: Verify all quantification requirements before finalizing task JSONs
@@ -879,7 +862,7 @@ Use `analysis_results.complexity` or task count to determine structure:
 - Load files directly (use provided context package instead)
 - Assume default locations (always use session_id in paths)
 - Create circular dependencies in task.depends_on
-- Exceed 12 tasks without re-scoping
+- Exceed 8 tasks (single module) or 6 tasks per module (multi-module) without re-scoping
 - Skip artifact integration when artifacts_inventory is provided
 - Ignore MCP capabilities when available
 - Use fixed pre-analysis steps without task-specific adaptation

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

@@ -61,6 +61,29 @@ Score = 0
 
 **Extract Keywords**: domains (auth, api, database, ui), technologies (react, typescript, node), actions (implement, refactor, test)
 
+**Plan Context Loading** (when executing from plan.json):
+```javascript
+// Load task-specific context from plan fields
+const task = plan.tasks.find(t => t.id === taskId)
+const context = {
+  // Base context
+  scope: task.scope,
+  modification_points: task.modification_points,
+  implementation: task.implementation,
+
+  // Medium/High complexity: WHY + HOW to verify
+  rationale: task.rationale?.chosen_approach,        // Why this approach
+  verification: task.verification?.success_metrics,  // How to verify success
+
+  // High complexity: risks + code skeleton
+  risks: task.risks?.map(r => r.mitigation),         // Risk mitigations to follow
+  code_skeleton: task.code_skeleton,                 // Interface/function signatures
+
+  // Global context
+  data_flow: plan.data_flow?.diagram                 // Data flow overview
+}
+```
+
 ---
 
 ## Phase 2: Context Discovery
@@ -129,6 +152,30 @@ EXPECTED: {clear_output_expectations}
 CONSTRAINTS: {constraints}
 ```
 
+**5. Plan-Aware Prompt Enhancement** (when executing from plan.json):
+```bash
+# Include rationale in PURPOSE (Medium/High)
+PURPOSE: {task.description}
+  Approach: {task.rationale.chosen_approach}
+  Decision factors: {task.rationale.decision_factors.join(', ')}
+
+# Include code skeleton in TASK (High)
+TASK: {task.implementation.join('\n')}
+  Key interfaces: {task.code_skeleton.interfaces.map(i => i.signature)}
+  Key functions: {task.code_skeleton.key_functions.map(f => f.signature)}
+
+# Include verification in EXPECTED
+EXPECTED: {task.acceptance.join(', ')}
+  Success metrics: {task.verification.success_metrics.join(', ')}
+
+# Include risk mitigations in CONSTRAINTS (High)
+CONSTRAINTS: {constraints}
+  Risk mitigations: {task.risks.map(r => r.mitigation).join('; ')}
+
+# Include data flow context (High)
+Memory: Data flow: {plan.data_flow.diagram}
+```
+
 ---
 
 ## Phase 4: Tool Selection & Execution
@@ -205,11 +252,25 @@ find .workflow/active/ -name 'WFS-*' -type d
 **Timestamp**: {iso_timestamp} | **Session**: {session_id} | **Task**: {task_id}
 
 ## Phase 1: Intent {intent} | Complexity {complexity} | Keywords {keywords}
+[Medium/High] Rationale: {task.rationale.chosen_approach}
+[High] Risks: {task.risks.map(r => `${r.description} → ${r.mitigation}`).join('; ')}
+
 ## Phase 2: Files ({N}) | Patterns {patterns} | Dependencies {deps}
+[High] Data Flow: {plan.data_flow.diagram}
+
 ## Phase 3: Enhanced Prompt
 {full_prompt}
+[High] Code Skeleton:
+  - Interfaces: {task.code_skeleton.interfaces.map(i => i.name).join(', ')}
+  - Functions: {task.code_skeleton.key_functions.map(f => f.signature).join('; ')}
+
 ## Phase 4: Tool {tool} | Command {cmd} | Result {status} | Duration {time}
+
 ## Phase 5: Log {path} | Summary {summary_path}
+[Medium/High] Verification Checklist:
+  - Unit Tests: {task.verification.unit_tests.join(', ')}
+  - Success Metrics: {task.verification.success_metrics.join(', ')}
+
 ## Next Steps: {actions}
 ```
 

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

@@ -13,6 +13,8 @@ color: cyan
 
 You are a generic planning agent that generates structured plan JSON for lite workflows. Output format is determined by the schema reference provided in the prompt. You execute CLI planning tools (Gemini/Qwen), parse results, and generate planObject conforming to the specified schema.
 
+**CRITICAL**: After generating plan.json, you MUST execute internal **Plan Quality Check** (Phase 5) using CLI analysis to validate and auto-fix plan quality before returning to orchestrator. Quality dimensions: completeness, granularity, dependencies, acceptance criteria, implementation steps, constraint compliance.
+
 
 ## Input Context
 
@@ -72,11 +74,28 @@ Phase 4: planObject Generation
 ├─ Build planObject conforming to schema
 ├─ Assign CLI execution IDs and strategies
 ├─ Generate flow_control from depends_on
-└─ Return to orchestrator
+└─ Write initial plan.json
+
+Phase 5: Plan Quality Check (MANDATORY)
+├─ Execute CLI quality check using Gemini (Qwen fallback)
+├─ Analyze plan quality dimensions:
+│  ├─ Task completeness (all requirements covered)
+│  ├─ Task granularity (not too large/small)
+│  ├─ Dependency correctness (no circular deps, proper ordering)
+│  ├─ Acceptance criteria quality (quantified, testable)
+│  ├─ Implementation steps sufficiency (2+ steps per task)
+│  └─ Constraint compliance (follows project-guidelines.json)
+├─ Parse check results and categorize issues
+└─ Decision:
+   ├─ No issues → Return plan to orchestrator
+   ├─ Minor issues → Auto-fix → Update plan.json → Return
+   └─ Critical issues → Report → Suggest regeneration
 ```
 
 ## CLI Command Template
 
+### Base Template (All Complexity Levels)
+
 ```bash
 ccw cli -p "
 PURPOSE: Generate plan for {task_description}
@@ -84,12 +103,18 @@ TASK:
 • Analyze task/bug description and context
 • Break down into tasks following schema structure
 • Identify dependencies and execution phases
+• Generate complexity-appropriate fields (rationale, verification, risks, code_skeleton, data_flow)
 MODE: analysis
 CONTEXT: @**/* | Memory: {context_summary}
 EXPECTED:
 ## Summary
 [overview]
 
+## Approach
+[high-level strategy]
+
+## Complexity: {Low|Medium|High}
+
 ## Task Breakdown
 ### T1: [Title] (or FIX1 for fix-plan)
 **Scope**: [module/feature path]
@@ -97,17 +122,54 @@ EXPECTED:
 **Description**: [what]
 **Modification Points**: - [file]: [target] - [change]
 **Implementation**: 1. [step]
-**Acceptance/Verification**: - [quantified criterion]
+**Reference**: - Pattern: [pattern] - Files: [files] - Examples: [guidance]
+**Acceptance**: - [quantified criterion]
 **Depends On**: []
 
+[MEDIUM/HIGH COMPLEXITY ONLY]
+**Rationale**:
+- Chosen Approach: [why this approach]
+- Alternatives Considered: [other options]
+- Decision Factors: [key factors]
+- Tradeoffs: [known tradeoffs]
+
+**Verification**:
+- Unit Tests: [test names]
+- Integration Tests: [test names]
+- Manual Checks: [specific steps]
+- Success Metrics: [quantified metrics]
+
+[HIGH COMPLEXITY ONLY]
+**Risks**:
+- Risk: [description] | Probability: [L/M/H] | Impact: [L/M/H] | Mitigation: [strategy] | Fallback: [alternative]
+
+**Code Skeleton**:
+- Interfaces: [name]: [definition] - [purpose]
+- Functions: [signature] - [purpose] - returns [type]
+- Classes: [name] - [purpose] - methods: [list]
+
+## Data Flow (HIGH COMPLEXITY ONLY)
+**Diagram**: [A → B → C]
+**Stages**:
+- Stage [name]: Input=[type] → Output=[type] | Component=[module] | Transforms=[list]
+**Dependencies**: [external deps]
+
+## Design Decisions (MEDIUM/HIGH)
+- Decision: [what] | Rationale: [why] | Tradeoff: [what was traded]
+
 ## Flow Control
 **Execution Order**: - Phase parallel-1: [T1, T2] (independent)
+**Exit Conditions**: - Success: [condition] - Failure: [condition]
 
 ## Time Estimate
 **Total**: [time]
 
 CONSTRAINTS:
 - Follow schema structure from {schema_path}
+- Complexity determines required fields:
+  * Low: base fields only
+  * Medium: + rationale + verification + design_decisions
+  * High: + risks + code_skeleton + data_flow
 - Acceptance/verification must be quantified
 - Dependencies use task IDs
 - analysis=READ-ONLY
@@ -127,43 +189,80 @@ function extractSection(cliOutput, header) {
 }
 
 // Parse structured tasks from CLI output
-function extractStructuredTasks(cliOutput) {
+function extractStructuredTasks(cliOutput, complexity) {
   const tasks = []
-  const taskPattern = /### (T\d+): (.+?)\n\*\*File\*\*: (.+?)\n\*\*Action\*\*: (.+?)\n\*\*Description\*\*: (.+?)\n\*\*Modification Points\*\*:\n((?:- .+?\n)*)\*\*Implementation\*\*:\n((?:\d+\. .+?\n)+)\*\*Reference\*\*:\n((?:- .+?\n)+)\*\*Acceptance\*\*:\n((?:- .+?\n)+)\*\*Depends On\*\*: (.+)/g
+  // Split by task headers
+  const taskBlocks = cliOutput.split(/### (T\d+):/).slice(1)
+
+  for (let i = 0; i < taskBlocks.length; i += 2) {
+    const taskId = taskBlocks[i].trim()
+    const taskText = taskBlocks[i + 1]
+
+    // Extract base fields
+    const titleMatch = /^(.+?)(?=\n)/.exec(taskText)
+    const scopeMatch = /\*\*Scope\*\*: (.+?)(?=\n)/.exec(taskText)
+    const actionMatch = /\*\*Action\*\*: (.+?)(?=\n)/.exec(taskText)
+    const descMatch = /\*\*Description\*\*: (.+?)(?=\n)/.exec(taskText)
+    const depsMatch = /\*\*Depends On\*\*: (.+?)(?=\n|$)/.exec(taskText)
 
-  let match
-  while ((match = taskPattern.exec(cliOutput)) !== null) {
     // Parse modification points
-    const modPoints = match[6].trim().split('\n').filter(s => s.startsWith('-')).map(s => {
-      const m = /- \[(.+?)\]: \[(.+?)\] - (.+)/.exec(s)
-      return m ? { file: m[1], target: m[2], change: m[3] } : null
-    }).filter(Boolean)
-
-    // Parse reference
-    const refText = match[8].trim()
-    const reference = {
-      pattern: (/- Pattern: (.+)/m.exec(refText) || [])[1]?.trim() || "No pattern",
-      files: ((/- Files: (.+)/m.exec(refText) || [])[1] || "").split(',').map(f => f.trim()).filter(Boolean),
-      examples: (/- Examples: (.+)/m.exec(refText) || [])[1]?.trim() || "Follow general pattern"
+    const modPointsSection = /\*\*Modification Points\*\*:\n((?:- .+?\n)*)/.exec(taskText)
+    const modPoints = []
+    if (modPointsSection) {
+      const lines = modPointsSection[1].split('\n').filter(s => s.trim().startsWith('-'))
+      lines.forEach(line => {
+        const m = /- \[(.+?)\]: \[(.+?)\] - (.+)/.exec(line)
+        if (m) modPoints.push({ file: m[1].trim(), target: m[2].trim(), change: m[3].trim() })
+      })
     }
 
-    // Parse depends_on
-    const depsText = match[10].trim()
-    const depends_on = depsText === '[]' ? [] : depsText.replace(/[\[\]]/g, '').split(',').map(s => s.trim()).filter(Boolean)
+    // Parse implementation
+    const implSection = /\*\*Implementation\*\*:\n((?:\d+\. .+?\n)+)/.exec(taskText)
+    const implementation = implSection
+      ? implSection[1].split('\n').map(s => s.replace(/^\d+\. /, '').trim()).filter(Boolean)
+      : []
 
-    tasks.push({
-      id: match[1].trim(),
-      title: match[2].trim(),
-      file: match[3].trim(),
-      action: match[4].trim(),
-      description: match[5].trim(),
+    // Parse reference
+    const refSection = /\*\*Reference\*\*:\n((?:- .+?\n)+)/.exec(taskText)
+    const reference = refSection ? {
+      pattern: (/- Pattern: (.+)/m.exec(refSection[1]) || [])[1]?.trim() || "No pattern",
+      files: ((/- Files: (.+)/m.exec(refSection[1]) || [])[1] || "").split(',').map(f => f.trim()).filter(Boolean),
+      examples: (/- Examples: (.+)/m.exec(refSection[1]) || [])[1]?.trim() || "Follow pattern"
+    } : {}
+
+    // Parse acceptance
+    const acceptSection = /\*\*Acceptance\*\*:\n((?:- .+?\n)+)/.exec(taskText)
+    const acceptance = acceptSection
+      ? acceptSection[1].split('\n').map(s => s.replace(/^- /, '').trim()).filter(Boolean)
+      : []
+
+    const task = {
+      id: taskId,
+      title: titleMatch?.[1].trim() || "Untitled",
+      scope: scopeMatch?.[1].trim() || "",
+      action: actionMatch?.[1].trim() || "Implement",
+      description: descMatch?.[1].trim() || "",
       modification_points: modPoints,
-      implementation: match[7].trim().split('\n').map(s => s.replace(/^\d+\. /, '')).filter(Boolean),
+      implementation,
       reference,
-      acceptance: match[9].trim().split('\n').map(s => s.replace(/^- /, '')).filter(Boolean),
-      depends_on
-    })
+      acceptance,
+      depends_on: depsMatch?.[1] === '[]' ? [] : (depsMatch?.[1] || "").replace(/[\[\]]/g, '').split(',').map(s => s.trim()).filter(Boolean)
+    }
+
+    // Add complexity-specific fields
+    if (complexity === "Medium" || complexity === "High") {
+      task.rationale = extractRationale(taskText)
+      task.verification = extractVerification(taskText)
+    }
+
+    if (complexity === "High") {
+      task.risks = extractRisks(taskText)
+      task.code_skeleton = extractCodeSkeleton(taskText)
+    }
+
+    tasks.push(task)
   }
+
   return tasks
 }
 
@@ -186,14 +285,155 @@ function extractFlowControl(cliOutput) {
   }
 }
 
+// Parse rationale section for a task
+function extractRationale(taskText) {
+  const rationaleMatch = /\*\*Rationale\*\*:\n- Chosen Approach: (.+?)\n- Alternatives Considered: (.+?)\n- Decision Factors: (.+?)\n- Tradeoffs: (.+)/s.exec(taskText)
+  if (!rationaleMatch) return null
+
+  return {
+    chosen_approach: rationaleMatch[1].trim(),
+    alternatives_considered: rationaleMatch[2].split(',').map(s => s.trim()).filter(Boolean),
+    decision_factors: rationaleMatch[3].split(',').map(s => s.trim()).filter(Boolean),
+    tradeoffs: rationaleMatch[4].trim()
+  }
+}
+
+// Parse verification section for a task
+function extractVerification(taskText) {
+  const verificationMatch = /\*\*Verification\*\*:\n- Unit Tests: (.+?)\n- Integration Tests: (.+?)\n- Manual Checks: (.+?)\n- Success Metrics: (.+)/s.exec(taskText)
+  if (!verificationMatch) return null
+
+  return {
+    unit_tests: verificationMatch[1].split(',').map(s => s.trim()).filter(Boolean),
+    integration_tests: verificationMatch[2].split(',').map(s => s.trim()).filter(Boolean),
+    manual_checks: verificationMatch[3].split(',').map(s => s.trim()).filter(Boolean),
+    success_metrics: verificationMatch[4].split(',').map(s => s.trim()).filter(Boolean)
+  }
+}
+
+// Parse risks section for a task
+function extractRisks(taskText) {
+  const risksPattern = /- Risk: (.+?) \| Probability: ([LMH]) \| Impact: ([LMH]) \| Mitigation: (.+?)(?: \| Fallback: (.+?))?(?=\n|$)/g
+  const risks = []
+  let match
+
+  while ((match = risksPattern.exec(taskText)) !== null) {
+    risks.push({
+      description: match[1].trim(),
+      probability: match[2] === 'L' ? 'Low' : match[2] === 'M' ? 'Medium' : 'High',
+      impact: match[3] === 'L' ? 'Low' : match[3] === 'M' ? 'Medium' : 'High',
+      mitigation: match[4].trim(),
+      fallback: match[5]?.trim() || undefined
+    })
+  }
+
+  return risks.length > 0 ? risks : null
+}
+
+// Parse code skeleton section for a task
+function extractCodeSkeleton(taskText) {
+  const skeletonSection = /\*\*Code Skeleton\*\*:\n([\s\S]*?)(?=\n\*\*|$)/.exec(taskText)
+  if (!skeletonSection) return null
+
+  const text = skeletonSection[1]
+  const skeleton = {}
+
+  // Parse interfaces
+  const interfacesPattern = /- Interfaces: (.+?): (.+?) - (.+?)(?=\n|$)/g
+  const interfaces = []
+  let match
+  while ((match = interfacesPattern.exec(text)) !== null) {
+    interfaces.push({ name: match[1].trim(), definition: match[2].trim(), purpose: match[3].trim() })
+  }
+  if (interfaces.length > 0) skeleton.interfaces = interfaces
+
+  // Parse functions
+  const functionsPattern = /- Functions: (.+?) - (.+?) - returns (.+?)(?=\n|$)/g
+  const functions = []
+  while ((match = functionsPattern.exec(text)) !== null) {
+    functions.push({ signature: match[1].trim(), purpose: match[2].trim(), returns: match[3].trim() })
+  }
+  if (functions.length > 0) skeleton.key_functions = functions
+
+  // Parse classes
+  const classesPattern = /- Classes: (.+?) - (.+?) - methods: (.+?)(?=\n|$)/g
+  const classes = []
+  while ((match = classesPattern.exec(text)) !== null) {
+    classes.push({
+      name: match[1].trim(),
+      purpose: match[2].trim(),
+      methods: match[3].split(',').map(s => s.trim()).filter(Boolean)
+    })
+  }
+  if (classes.length > 0) skeleton.classes = classes
+
+  return Object.keys(skeleton).length > 0 ? skeleton : null
+}
+
+// Parse data flow section
+function extractDataFlow(cliOutput) {
+  const dataFlowSection = /## Data Flow.*?\n([\s\S]*?)(?=\n## |$)/.exec(cliOutput)
+  if (!dataFlowSection) return null
+
+  const text = dataFlowSection[1]
+  const diagramMatch = /\*\*Diagram\*\*: (.+?)(?=\n|$)/.exec(text)
+  const depsMatch = /\*\*Dependencies\*\*: (.+?)(?=\n|$)/.exec(text)
+
+  // Parse stages
+  const stagesPattern = /- Stage (.+?): Input=(.+?) → Output=(.+?) \| Component=(.+?)(?: \| Transforms=(.+?))?(?=\n|$)/g
+  const stages = []
+  let match
+  while ((match = stagesPattern.exec(text)) !== null) {
+    stages.push({
+      stage: match[1].trim(),
+      input: match[2].trim(),
+      output: match[3].trim(),
+      component: match[4].trim(),
+      transformations: match[5] ? match[5].split(',').map(s => s.trim()).filter(Boolean) : undefined
+    })
+  }
+
+  return {
+    diagram: diagramMatch?.[1].trim() || null,
+    stages: stages.length > 0 ? stages : undefined,
+    dependencies: depsMatch ? depsMatch[1].split(',').map(s => s.trim()).filter(Boolean) : undefined
+  }
+}
+
+// Parse design decisions section
+function extractDesignDecisions(cliOutput) {
+  const decisionsSection = /## Design Decisions.*?\n([\s\S]*?)(?=\n## |$)/.exec(cliOutput)
+  if (!decisionsSection) return null
+
+  const decisionsPattern = /- Decision: (.+?) \| Rationale: (.+?)(?: \| Tradeoff: (.+?))?(?=\n|$)/g
+  const decisions = []
+  let match
+
+  while ((match = decisionsPattern.exec(decisionsSection[1])) !== null) {
+    decisions.push({
+      decision: match[1].trim(),
+      rationale: match[2].trim(),
+      tradeoff: match[3]?.trim() || undefined
+    })
+  }
+
+  return decisions.length > 0 ? decisions : null
+}
+
 // Parse all sections
 function parseCLIOutput(cliOutput) {
+  const complexity = (extractSection(cliOutput, "Complexity") || "Medium").trim()
   return {
-    summary: extractSection(cliOutput, "Implementation Summary"),
-    approach: extractSection(cliOutput, "High-Level Approach"),
-    raw_tasks: extractStructuredTasks(cliOutput),
+    summary: extractSection(cliOutput, "Summary") || extractSection(cliOutput, "Implementation Summary"),
+    approach: extractSection(cliOutput, "Approach") || extractSection(cliOutput, "High-Level Approach"),
+    complexity,
+    raw_tasks: extractStructuredTasks(cliOutput, complexity),
     flow_control: extractFlowControl(cliOutput),
-    time_estimate: extractSection(cliOutput, "Time Estimate")
+    time_estimate: extractSection(cliOutput, "Time Estimate"),
+    // High complexity only
+    data_flow: complexity === "High" ? extractDataFlow(cliOutput) : null,
+    // Medium/High complexity
+    design_decisions: (complexity === "Medium" || complexity === "High") ? extractDesignDecisions(cliOutput) : null
   }
 }
 ```
@@ -326,7 +566,8 @@ function inferFlowControl(tasks) {
 
 ```javascript
 function generatePlanObject(parsed, enrichedContext, input, schemaType) {
-  const tasks = validateAndEnhanceTasks(parsed.raw_tasks, enrichedContext)
+  const complexity = parsed.complexity || input.complexity || "Medium"
+  const tasks = validateAndEnhanceTasks(parsed.raw_tasks, enrichedContext, complexity)
   assignCliExecutionIds(tasks, input.session.id)  // MANDATORY: Assign CLI execution IDs
   const flow_control = parsed.flow_control?.execution_order?.length > 0 ? parsed.flow_control : inferFlowControl(tasks)
   const focus_paths = [...new Set(tasks.flatMap(t => [t.file || t.scope, ...t.modification_points.map(m => m.file)]).filter(Boolean))]
@@ -338,7 +579,7 @@ function generatePlanObject(parsed, enrichedContext, input, schemaType) {
     flow_control,
     focus_paths,
     estimated_time: parsed.time_estimate || `${tasks.length * 30} minutes`,
-    recommended_execution: (input.complexity === "Low" || input.severity === "Low") ? "Agent" : "Codex",
+    recommended_execution: (complexity === "Low" || input.severity === "Low") ? "Agent" : "Codex",
     _metadata: {
       timestamp: new Date().toISOString(),
       source: "cli-lite-planning-agent",
@@ -348,6 +589,15 @@ function generatePlanObject(parsed, enrichedContext, input, schemaType) {
     }
   }
 
+  // Add complexity-specific top-level fields
+  if (complexity === "Medium" || complexity === "High") {
+    base.design_decisions = parsed.design_decisions || []
+  }
+
+  if (complexity === "High") {
+    base.data_flow = parsed.data_flow || null
+  }
+
   // Schema-specific fields
   if (schemaType === 'fix-plan') {
     return {
@@ -361,10 +611,63 @@ function generatePlanObject(parsed, enrichedContext, input, schemaType) {
     return {
       ...base,
       approach: parsed.approach || "Step-by-step implementation",
-      complexity: input.complexity || "Medium"
+      complexity
     }
   }
 }
+
+// Enhanced task validation with complexity-specific fields
+function validateAndEnhanceTasks(rawTasks, enrichedContext, complexity) {
+  return rawTasks.map((task, idx) => {
+    const enhanced = {
+      id: task.id || `T${idx + 1}`,
+      title: task.title || "Unnamed task",
+      scope: task.scope || task.file || inferFile(task, enrichedContext),
+      action: task.action || inferAction(task.title),
+      description: task.description || task.title,
+      modification_points: task.modification_points?.length > 0
+        ? task.modification_points
+        : [{ file: task.scope || task.file, target: "main", change: task.description }],
+      implementation: task.implementation?.length >= 2
+        ? task.implementation
+        : [`Analyze ${task.scope || task.file}`, `Implement ${task.title}`, `Add error handling`],
+      reference: task.reference || { pattern: "existing patterns", files: enrichedContext.relevant_files.slice(0, 2), examples: "Follow existing structure" },
+      acceptance: task.acceptance?.length >= 1
+        ? task.acceptance
+        : [`${task.title} completed`, `Follows conventions`],
+      depends_on: task.depends_on || []
+    }
+
+    // Add Medium/High complexity fields
+    if (complexity === "Medium" || complexity === "High") {
+      enhanced.rationale = task.rationale || {
+        chosen_approach: "Standard implementation approach",
+        alternatives_considered: [],
+        decision_factors: ["Maintainability", "Performance"],
+        tradeoffs: "None significant"
+      }
+      enhanced.verification = task.verification || {
+        unit_tests: [`test_${task.id.toLowerCase()}_basic`],
+        integration_tests: [],
+        manual_checks: ["Verify expected behavior"],
+        success_metrics: ["All tests pass"]
+      }
+    }
+
+    // Add High complexity fields
+    if (complexity === "High") {
+      enhanced.risks = task.risks || [{
+        description: "Implementation complexity",
+        probability: "Low",
+        impact: "Medium",
+        mitigation: "Incremental development with checkpoints"
+      }]
+      enhanced.code_skeleton = task.code_skeleton || null
+    }
+
+    return enhanced
+  })
+}
 ```
 
 ### Error Handling
@@ -448,3 +751,78 @@ function validateTask(task) {
 - Skip task validation
 - **Skip CLI execution ID assignment**
 - **Ignore schema structure**
+- **Skip Phase 5 Plan Quality Check**
+
+---
+
+## Phase 5: Plan Quality Check (MANDATORY)
+
+### Overview
+
+After generating plan.json, **MUST** execute CLI quality check before returning to orchestrator. This is a mandatory step for ALL plans regardless of complexity.
+
+### Quality Dimensions
+
+| Dimension | Check Criteria | Critical? |
+|-----------|---------------|-----------|
+| **Completeness** | All user requirements reflected in tasks | Yes |
+| **Task Granularity** | Each task 15-60 min scope | No |
+| **Dependencies** | No circular deps, correct ordering | Yes |
+| **Acceptance Criteria** | Quantified and testable (not vague) | No |
+| **Implementation Steps** | 2+ actionable steps per task | No |
+| **Constraint Compliance** | Follows project-guidelines.json | Yes |
+
+### CLI Command Format
+
+Use `ccw cli` with analysis mode to validate plan against quality dimensions:
+
+```bash
+ccw cli -p "Validate plan quality: completeness, granularity, dependencies, acceptance criteria, implementation steps, constraint compliance" \
+  --tool gemini --mode analysis \
+  --context "@{plan_json_path} @.workflow/project-guidelines.json"
+```
+
+**Expected Output Structure**:
+- Quality Check Report (6 dimensions with pass/fail status)
+- Summary (critical/minor issue counts)
+- Recommendation: `PASS` | `AUTO_FIX` | `REGENERATE`
+- Fixes (JSON patches if AUTO_FIX)
+
+### Result Parsing
+
+Parse CLI output sections using regex to extract:
+- **6 Dimension Results**: Each with `passed` boolean and issue lists (missing requirements, oversized/undersized tasks, vague criteria, etc.)
+- **Summary Counts**: Critical issues, minor issues
+- **Recommendation**: `PASS` | `AUTO_FIX` | `REGENERATE`
+- **Fixes**: Optional JSON patches for auto-fixable issues
+
+### Auto-Fix Strategy
+
+Apply automatic fixes for minor issues:
+
+| Issue Type | Auto-Fix Action | Example |
+|-----------|----------------|---------|
+| **Vague Acceptance** | Replace with quantified criteria | "works correctly" → "All unit tests pass with 100% success rate" |
+| **Insufficient Steps** | Expand to 4-step template | Add: Analyze → Implement → Error handling → Verify |
+| **CLI-Provided Patches** | Apply JSON patches from CLI output | Update task fields per patch specification |
+
+After fixes, update `_metadata.quality_check` with fix log.
+
+### Execution Flow
+
+After Phase 4 planObject generation:
+
+1. **Write Initial Plan** → `${sessionFolder}/plan.json`
+2. **Execute CLI Check** → Gemini (Qwen fallback)
+3. **Parse Results** → Extract recommendation and issues
+4. **Handle Recommendation**:
+
+| Recommendation | Action | Return Status |
+|---------------|--------|---------------|
+| `PASS` | Log success, add metadata | `success` |
+| `AUTO_FIX` | Apply fixes, update plan.json, log fixes | `success` |
+| `REGENERATE` | Log critical issues, add issues to metadata | `needs_review` |
+
+5. **Return** → Plan with `_metadata.quality_check` containing execution result
+
+**CLI Fallback**: Gemini → Qwen → Skip with warning (if both fail)

.claude/agents/code-developer.md

@@ -186,34 +186,150 @@ output               → Variable name to store this step's result
 
 **Execution Flow**:
 ```
-FOR each step in implementation_approach[] (ordered by step number):
-  1. Check depends_on: Wait for all listed step numbers to complete
-  2. Variable Substitution: Replace [variable_name] in description/modification_points
-     with values stored from previous steps' output
-  3. Execute step (choose one):
+// Read task-level execution config (Single Source of Truth)
+const executionMethod = task.meta?.execution_config?.method || 'agent';
+const cliTool = task.meta?.execution_config?.cli_tool || getDefaultCliTool();  // See ~/.claude/cli-tools.json
 
-     IF step.command exists:
-       → Execute the CLI command via Bash tool
-       → Capture output
+// Phase 1: Execute pre_analysis (always by Agent)
+const preAnalysisResults = {};
+for (const step of task.flow_control.pre_analysis || []) {
+  const result = executePreAnalysisStep(step);
+  preAnalysisResults[step.output_to] = result;
+}
 
-     ELSE (no command - Agent direct implementation):
-       → Read modification_points[] as list of files to create/modify
-       → Read logic_flow[] as implementation sequence
-       → For each file in modification_points:
-         • If "Create new file: path" → Use Write tool to create
-         • If "Modify file: path" → Use Edit tool to modify
-         • If "Add to file: path" → Use Edit tool to append
-       → Follow logic_flow sequence for implementation logic
-       → Use [focus_paths] from context as working directory scope
+// Phase 2: Determine execution mode
+const hasLegacyCommands = task.flow_control.implementation_approach
+  .some(step => step.command);
 
-  4. Store result in [step.output] variable for later steps
-  5. Mark step complete, proceed to next
+IF hasLegacyCommands:
+  // Backward compatibility: Old mode with step.command fields
+  FOR each step in implementation_approach[]:
+    IF step.command exists:
+      → Execute via Bash: Bash({ command: step.command, timeout: 3600000 })
+    ELSE:
+      → Agent direct implementation
+
+ELSE IF executionMethod === 'cli':
+  // New mode: CLI Handoff
+  → const cliPrompt = buildCliHandoffPrompt(preAnalysisResults, task)
+  → const cliCommand = buildCliCommand(task, cliTool, cliPrompt)
+  → Bash({ command: cliCommand, run_in_background: false, timeout: 3600000 })
+
+ELSE IF executionMethod === 'hybrid':
+  // Hybrid mode: Agent decides based on task complexity
+  → IF task is complex (multiple files, complex logic):
+      Use CLI Handoff (same as cli mode)
+    ELSE:
+      Use Agent direct implementation
+
+ELSE (executionMethod === 'agent'):
+  // Default: Agent direct implementation
+  FOR each step in implementation_approach[]:
+    1. Variable Substitution: Replace [variable_name] with preAnalysisResults
+    2. Read modification_points[] as files to create/modify
+    3. Read logic_flow[] as implementation sequence
+    4. For each file in modification_points:
+       • If "Create new file: path" → Use Write tool
+       • If "Modify file: path" → Use Edit tool
+       • If "Add to file: path" → Use Edit tool (append)
+    5. Follow logic_flow sequence
+    6. Use [focus_paths] from context as working directory scope
+    7. Store result in [step.output] variable
 ```
 
-**CLI Command Execution (CLI Execute Mode)**:
-When step contains `command` field with Codex CLI, execute via CCW CLI. For Codex resume:
-- First task (`depends_on: []`): `ccw cli -p "..." --tool codex --mode write --cd [path]`
-- Subsequent tasks (has `depends_on`): Use CCW CLI with resume context to maintain session
+**CLI Handoff Functions**:
+
+```javascript
+// Get default CLI tool from cli-tools.json
+function getDefaultCliTool() {
+  // Read ~/.claude/cli-tools.json and return first enabled tool
+  // Fallback order: gemini → qwen → codex (first enabled in config)
+  return firstEnabledTool || 'gemini';  // System default fallback
+}
+
+// Build CLI prompt from pre-analysis results and task
+function buildCliHandoffPrompt(preAnalysisResults, task) {
+  const contextSection = Object.entries(preAnalysisResults)
+    .map(([key, value]) => `### ${key}\n${value}`)
+    .join('\n\n');
+
+  const approachSection = task.flow_control.implementation_approach
+    .map((step, i) => `
+### Step ${step.step}: ${step.title}
+${step.description}
+
+**Modification Points**:
+${step.modification_points?.map(m => `- ${m}`).join('\n') || 'N/A'}
+
+**Logic Flow**:
+${step.logic_flow?.map((l, j) => `${j + 1}. ${l}`).join('\n') || 'Follow modification points'}
+`).join('\n');
+
+  return `
+PURPOSE: ${task.title}
+Complete implementation based on pre-analyzed context.
+
+## PRE-ANALYSIS CONTEXT
+${contextSection}
+
+## REQUIREMENTS
+${task.context.requirements?.map(r => `- ${r}`).join('\n') || task.context.requirements}
+
+## IMPLEMENTATION APPROACH
+${approachSection}
+
+## ACCEPTANCE CRITERIA
+${task.context.acceptance?.map(a => `- ${a}`).join('\n') || task.context.acceptance}
+
+## TARGET FILES
+${task.flow_control.target_files?.map(f => `- ${f}`).join('\n') || 'See modification points above'}
+
+MODE: write
+CONSTRAINTS: Follow existing patterns | No breaking changes
+`.trim();
+}
+
+// Build CLI command with resume strategy
+function buildCliCommand(task, cliTool, cliPrompt) {
+  const cli = task.cli_execution || {};
+  const escapedPrompt = cliPrompt.replace(/"/g, '\\"');
+  const baseCmd = `ccw cli -p "${escapedPrompt}"`;
+
+  switch (cli.strategy) {
+    case 'new':
+      return `${baseCmd} --tool ${cliTool} --mode write --id ${task.cli_execution_id}`;
+    case 'resume':
+      return `${baseCmd} --resume ${cli.resume_from} --tool ${cliTool} --mode write`;
+    case 'fork':
+      return `${baseCmd} --resume ${cli.resume_from} --id ${task.cli_execution_id} --tool ${cliTool} --mode write`;
+    case 'merge_fork':
+      return `${baseCmd} --resume ${cli.merge_from.join(',')} --id ${task.cli_execution_id} --tool ${cliTool} --mode write`;
+    default:
+      // Fallback: no resume, no id
+      return `${baseCmd} --tool ${cliTool} --mode write`;
+  }
+}
+```
+
+**Execution Config Reference** (from task.meta.execution_config):
+| Field | Values | Description |
+|-------|--------|-------------|
+| `method` | `agent` / `cli` / `hybrid` | Execution mode (default: agent) |
+| `cli_tool` | See `~/.claude/cli-tools.json` | CLI tool preference (first enabled tool as default) |
+| `enable_resume` | `true` / `false` | Enable CLI session resume |
+
+**CLI Execution Reference** (from task.cli_execution):
+| Field | Values | Description |
+|-------|--------|-------------|
+| `strategy` | `new` / `resume` / `fork` / `merge_fork` | Resume strategy |
+| `resume_from` | `{session}-{task_id}` | Parent task CLI ID (resume/fork) |
+| `merge_from` | `[{id1}, {id2}]` | Parent task CLI IDs (merge_fork) |
+
+**Resume Strategy Examples**:
+- **New task** (no dependencies): `--id WFS-001-IMPL-001`
+- **Resume** (single dependency, single child): `--resume WFS-001-IMPL-001`
+- **Fork** (single dependency, multiple children): `--resume WFS-001-IMPL-001 --id WFS-001-IMPL-002`
+- **Merge** (multiple dependencies): `--resume WFS-001-IMPL-001,WFS-001-IMPL-002 --id WFS-001-IMPL-003`
 
 **Test-Driven Development**:
 - Write tests first (red → green → refactor)
@@ -389,7 +505,8 @@ Before completing any task, verify:
 - Use `run_in_background=false` for all Bash/CLI calls - agent cannot receive task hook callbacks
 - Set timeout ≥60 minutes for CLI commands (hooks don't propagate to subagents):
   ```javascript
-  Bash(command="ccw cli -p '...' --tool codex --mode write", timeout=3600000)  // 60 min
+  Bash(command="ccw cli -p '...' --tool <cli-tool> --mode write", timeout=3600000)  // 60 min
+  // <cli-tool>: First enabled tool from ~/.claude/cli-tools.json (e.g., gemini, qwen, codex)
   ```
 
 **ALWAYS:**

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

@@ -56,14 +56,61 @@ Phase 4: Validation & Output (15%)
 ccw issue status <issue-id> --json
 ```
 
-**Step 2**: Analyze and classify
+**Step 2**: Analyze failure history (if present)
+```javascript
+function analyzeFailureHistory(issue) {
+  if (!issue.feedback || issue.feedback.length === 0) {
+    return { has_failures: false };
+  }
+
+  // Extract execution failures
+  const failures = issue.feedback.filter(f => f.type === 'failure' && f.stage === 'execute');
+
+  if (failures.length === 0) {
+    return { has_failures: false };
+  }
+
+  // Parse failure details
+  const failureAnalysis = failures.map(f => {
+    const detail = JSON.parse(f.content);
+    return {
+      solution_id: detail.solution_id,
+      task_id: detail.task_id,
+      error_type: detail.error_type,       // test_failure, compilation, timeout, etc.
+      message: detail.message,
+      stack_trace: detail.stack_trace,
+      timestamp: f.created_at
+    };
+  });
+
+  // Identify patterns
+  const errorTypes = failureAnalysis.map(f => f.error_type);
+  const repeatedErrors = errorTypes.filter((e, i, arr) => arr.indexOf(e) !== i);
+
+  return {
+    has_failures: true,
+    failure_count: failures.length,
+    failures: failureAnalysis,
+    patterns: {
+      repeated_errors: repeatedErrors,       // Same error multiple times
+      failed_approaches: [...new Set(failureAnalysis.map(f => f.solution_id))]
+    }
+  };
+}
+```
+
+**Step 3**: Analyze and classify
 ```javascript
 function analyzeIssue(issue) {
+  const failureAnalysis = analyzeFailureHistory(issue);
+
   return {
     issue_id: issue.id,
     requirements: extractRequirements(issue.context),
     scope: inferScope(issue.title, issue.context),
-    complexity: determineComplexity(issue)  // Low | Medium | High
+    complexity: determineComplexity(issue),  // Low | Medium | High
+    failure_analysis: failureAnalysis,       // Failure context for planning
+    is_replan: failureAnalysis.has_failures  // Flag for replanning
   }
 }
 ```
@@ -104,6 +151,41 @@ mcp__ace-tool__search_context({
 
 #### Phase 3: Solution Planning
 
+**Failure-Aware Planning** (when `issue.failure_analysis.has_failures === true`):
+
+```javascript
+function planWithFailureContext(issue, exploration, failureAnalysis) {
+  // Identify what failed before
+  const failedApproaches = failureAnalysis.patterns.failed_approaches;
+  const rootCauses = failureAnalysis.failures.map(f => ({
+    error: f.error_type,
+    message: f.message,
+    task: f.task_id
+  }));
+
+  // Design alternative approach
+  const approach = `
+    **Previous Attempt Analysis**:
+    - Failed approaches: ${failedApproaches.join(', ')}
+    - Root causes: ${rootCauses.map(r => `${r.error} (${r.task}): ${r.message}`).join('; ')}
+
+    **Alternative Strategy**:
+    - [Describe how this solution addresses root causes]
+    - [Explain what's different from failed approaches]
+    - [Prevention steps to catch same errors earlier]
+  `;
+
+  // Add explicit verification tasks
+  const verificationTasks = rootCauses.map(rc => ({
+    verification_type: rc.error,
+    check: `Prevent ${rc.error}: ${rc.message}`,
+    method: `Add unit test / compile check / timeout limit`
+  }));
+
+  return { approach, verificationTasks };
+}
+```
+
 **Multi-Solution Generation**:
 
 Generate multiple candidate solutions when:
@@ -303,15 +385,17 @@ Each line is a solution JSON containing tasks. Schema: `cat .claude/workflows/cl
 **ALWAYS**:
 1. **Search Tool Priority**: ACE (`mcp__ace-tool__search_context`) → CCW (`mcp__ccw-tools__smart_search`) / Built-in (`Grep`, `Glob`, `Read`)
 2. Read schema first: `cat .claude/workflows/cli-templates/schemas/solution-schema.json`
-2. Use ACE semantic search as PRIMARY exploration tool
-3. Fetch issue details via `ccw issue status <id> --json`
-4. Quantify acceptance.criteria with testable conditions
-5. Validate DAG before output
-6. Evaluate each solution with `analysis` and `score`
-7. Write solutions to `.workflow/issues/solutions/{issue-id}.jsonl` (append mode)
-8. For HIGH complexity: generate 2-3 candidate solutions
-9. **Solution ID format**: `SOL-{issue-id}-{uid}` where uid is 4 random alphanumeric chars (e.g., `SOL-GH-123-a7x9`)
-10. **GitHub Reply Task**: If issue has `github_url` or `github_number`, add final task to comment on GitHub issue with completion summary
+3. Use ACE semantic search as PRIMARY exploration tool
+4. Fetch issue details via `ccw issue status <id> --json`
+5. **Analyze failure history**: Check `issue.feedback` for type='failure', stage='execute'
+6. **For replanning**: Reference previous failures in `solution.approach`, add prevention steps
+7. Quantify acceptance.criteria with testable conditions
+8. Validate DAG before output
+9. Evaluate each solution with `analysis` and `score`
+10. Write solutions to `.workflow/issues/solutions/{issue-id}.jsonl` (append mode)
+11. For HIGH complexity: generate 2-3 candidate solutions
+12. **Solution ID format**: `SOL-{issue-id}-{uid}` where uid is 4 random alphanumeric chars (e.g., `SOL-GH-123-a7x9`)
+13. **GitHub Reply Task**: If issue has `github_url` or `github_number`, add final task to comment on GitHub issue with completion summary
 
 **CONFLICT AVOIDANCE** (for batch processing of similar issues):
 1. **File isolation**: Each issue's solution should target distinct files when possible

.claude/agents/tdd-developer.md

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

.claude/commands/ccw-debug.md

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

.claude/commands/ccw.md

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

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

@@ -3,6 +3,7 @@ name: cli-init
 description: Generate .gemini/ and .qwen/ config directories with settings.json and ignore files based on workspace technology detection
 argument-hint: "[--tool gemini|qwen|all] [--output path] [--preview]"
 allowed-tools: Bash(*), Read(*), Write(*), Glob(*)
+group: cli
 ---
 
 # CLI Initialization Command (/cli:cli-init)

.claude/commands/enhance-prompt.md

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

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

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

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

@@ -1,10 +1,14 @@
 ---
 name: issue:discover-by-prompt
 description: Discover issues from user prompt with Gemini-planned iterative multi-agent exploration. Uses ACE semantic search for context gathering and supports cross-module comparison (e.g., frontend vs backend API contracts).
-argument-hint: "<prompt> [--scope=src/**] [--depth=standard|deep] [--max-iterations=5]"
+argument-hint: "[-y|--yes] <prompt> [--scope=src/**] [--depth=standard|deep] [--max-iterations=5]"
 allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*), Task(*), AskUserQuestion(*), Glob(*), Grep(*), mcp__ace-tool__search_context(*), mcp__exa__search(*)
 ---
 
+## Auto Mode
+
+When `--yes` or `-y`: Auto-continue all iterations, skip confirmations.
+
 # Issue Discovery by Prompt
 
 ## Quick Start

.claude/commands/issue/discover.md

@@ -1,10 +1,14 @@
 ---
 name: issue:discover
 description: Discover potential issues from multiple perspectives (bug, UX, test, quality, security, performance, maintainability, best-practices) using CLI explore. Supports Exa external research for security and best-practices perspectives.
-argument-hint: "<path-pattern> [--perspectives=bug,ux,...] [--external]"
+argument-hint: "[-y|--yes] <path-pattern> [--perspectives=bug,ux,...] [--external]"
 allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*), Task(*), AskUserQuestion(*), Glob(*), Grep(*)
 ---
 
+## Auto Mode
+
+When `--yes` or `-y`: Auto-select all perspectives, skip confirmations.
+
 # Issue Discovery Command
 
 ## Quick Start

.claude/commands/issue/execute.md

@@ -1,10 +1,14 @@
 ---
 name: execute
 description: Execute queue with DAG-based parallel orchestration (one commit per solution)
-argument-hint: "--queue <queue-id> [--worktree [<existing-path>]]"
+argument-hint: "[-y|--yes] --queue <queue-id> [--worktree [<existing-path>]]"
 allowed-tools: TodoWrite(*), Bash(*), Read(*), AskUserQuestion(*)
 ---
 
+## Auto Mode
+
+When `--yes` or `-y`: Auto-confirm execution, use recommended settings.
+
 # Issue Execute Command (/issue:execute)
 
 ## Overview
@@ -312,65 +316,60 @@ batch.forEach(id => updateTodo(id, 'completed'));
 function dispatchExecutor(solutionId, executorType, worktreePath = null) {
   // If worktree is provided, executor works in that directory
   // No per-solution worktree creation - ONE worktree for entire queue
-  const cdCommand = worktreePath ? `cd "${worktreePath}"` : '';
 
+  // Pre-defined values (replaced at dispatch time, NOT by executor)
+  const SOLUTION_ID = solutionId;
+  const WORK_DIR = worktreePath || null;
+
+  // Build prompt without markdown code blocks to avoid escaping issues
   const prompt = `
-## Execute Solution ${solutionId}
-${worktreePath ? `
-### Step 0: Enter Queue Worktree
-\`\`\`bash
-cd "${worktreePath}"
-\`\`\`
-` : ''}
-### Step 1: Get Solution (read-only)
-\`\`\`bash
-ccw issue detail ${solutionId}
-\`\`\`
+## Execute Solution: ${SOLUTION_ID}
+${WORK_DIR ? `Working Directory: ${WORK_DIR}` : ''}
+
+### Step 1: Get Solution Details
+Run this command to get the full solution with all tasks:
+  ccw issue detail ${SOLUTION_ID}
 
 ### Step 2: Execute All Tasks Sequentially
 The detail command returns a FULL SOLUTION with all tasks.
 Execute each task in order (T1 → T2 → T3 → ...):
 
 For each task:
-1. Follow task.implementation steps
-2. Run task.test commands
-3. Verify task.acceptance criteria
-(Do NOT commit after each task)
+- Follow task.implementation steps
+- Run task.test commands
+- Verify task.acceptance criteria
+- Do NOT commit after each task
 
 ### Step 3: Commit Solution (Once)
-After ALL tasks pass, commit once with formatted summary:
-\`\`\`bash
-git add <all-modified-files>
-git commit -m "[type](scope): [solution.description]
+After ALL tasks pass, commit once with formatted summary.
 
-## Solution Summary
-- Solution-ID: ${solutionId}
-- Tasks: T1, T2, ...
+Command:
+  git add -A
+  git commit -m "<type>(<scope>): <description>
 
-## Tasks Completed
-- [T1] task1.title: action
-- [T2] task2.title: action
+  Solution: ${SOLUTION_ID}
+  Tasks completed: <list task IDs>
 
-## Files Modified
-- file1.ts
-- file2.ts
+  Changes:
+  - <file1>: <what changed>
+  - <file2>: <what changed>
 
-## Verification
-- All tests passed
-- All acceptance criteria verified"
-\`\`\`
+  Verified: all tests passed"
+
+Replace <type> with: feat|fix|refactor|docs|test
+Replace <scope> with: affected module name
+Replace <description> with: brief summary from solution
 
 ### Step 4: Report Completion
-\`\`\`bash
-ccw issue done ${solutionId} --result '{"summary": "...", "files_modified": [...], "commit": {"hash": "...", "type": "feat"}, "tasks_completed": N}'
-\`\`\`
+On success, run:
+  ccw issue done ${SOLUTION_ID} --result '{"summary": "<brief>", "files_modified": ["<file1>", "<file2>"], "commit": {"hash": "<hash>", "type": "<type>"}, "tasks_completed": <N>}'
 
-If any task failed:
-\`\`\`bash
-ccw issue done ${solutionId} --fail --reason '{"task_id": "TX", "error_type": "test_failure", "message": "..."}'
-\`\`\`
+On failure, run:
+  ccw issue done ${SOLUTION_ID} --fail --reason '{"task_id": "<TX>", "error_type": "<test_failure|build_error|other>", "message": "<error details>"}'
 
-**Note**: Do NOT cleanup worktree after this solution. Worktree is shared by all solutions in the queue.
+### Important Notes
+- Do NOT cleanup worktree - it is shared by all solutions in the queue
+- Replace all <placeholder> values with actual values from your execution
 `;
 
   // For CLI tools, pass --cd to set working directory

.claude/commands/issue/from-brainstorm.md

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

.claude/commands/issue/new.md

@@ -1,10 +1,14 @@
 ---
 name: new
 description: Create structured issue from GitHub URL or text description
-argument-hint: "<github-url | text-description> [--priority 1-5]"
+argument-hint: "[-y|--yes] <github-url | text-description> [--priority 1-5]"
 allowed-tools: TodoWrite(*), Bash(*), Read(*), AskUserQuestion(*), mcp__ace-tool__search_context(*)
 ---
 
+## Auto Mode
+
+When `--yes` or `-y`: Skip clarification questions, create issue with inferred details.
+
 # Issue New Command (/issue:new)
 
 ## Core Principle
@@ -409,5 +413,4 @@ function parseMarkdownBody(body) {
 
 ## Related Commands
 
-- `/issue:plan` - Plan solution for issue
-
+- `/issue:plan` - Plan solution for issue

.claude/commands/issue/plan.md

@@ -1,10 +1,14 @@
 ---
 name: plan
 description: Batch plan issue resolution using issue-plan-agent (explore + plan closed-loop)
-argument-hint: "--all-pending <issue-id>[,<issue-id>,...] [--batch-size 3] "
+argument-hint: "[-y|--yes] --all-pending <issue-id>[,<issue-id>,...] [--batch-size 3]"
 allowed-tools: TodoWrite(*), Task(*), SlashCommand(*), AskUserQuestion(*), Bash(*), Read(*), Write(*)
 ---
 
+## Auto Mode
+
+When `--yes` or `-y`: Auto-bind solutions without confirmation, use recommended settings.
+
 # Issue Plan Command (/issue:plan)
 
 ## Overview
@@ -55,11 +59,11 @@ Unified planning command using **issue-plan-agent** that combines exploration an
 ## Execution Process
 
 ```
-Phase 1: Issue Loading
+Phase 1: Issue Loading & Intelligent Grouping
    ├─ Parse input (single, comma-separated, or --all-pending)
    ├─ Fetch issue metadata (ID, title, tags)
    ├─ Validate issues exist (create if needed)
-   └─ Group by similarity (shared tags or title keywords, max 3 per batch)
+   └─ Intelligent grouping via Gemini (semantic similarity, max 3 per batch)
 
 Phase 2: Unified Explore + Plan (issue-plan-agent)
    ├─ Launch issue-plan-agent per batch
@@ -119,46 +123,11 @@ if (useAllPending) {
 }
 // Note: Agent fetches full issue content via `ccw issue status <id> --json`
 
-// Semantic grouping via Gemini CLI (max 4 issues per group)
-async function groupBySimilarityGemini(issues) {
-  const issueSummaries = issues.map(i => ({
-    id: i.id, title: i.title, tags: i.tags
-  }));
+// Intelligent grouping: Analyze issues by title/tags, group semantically similar ones
+// Strategy: Same module/component, related bugs, feature clusters
+// Constraint: Max ${batchSize} issues per batch
 
-  const prompt = `
-PURPOSE: Group similar issues by semantic similarity for batch processing; maximize within-group coherence; max 4 issues per group
-TASK: • Analyze issue titles/tags semantically • Identify functional/architectural clusters • Assign each issue to one group
-MODE: analysis
-CONTEXT: Issue metadata only
-EXPECTED: JSON with groups array, each containing max 4 issue_ids, theme, rationale
-CONSTRAINTS: Each issue in exactly one group | Max 4 issues per group | Balance group sizes
-
-INPUT:
-${JSON.stringify(issueSummaries, null, 2)}
-
-OUTPUT FORMAT:
-{"groups":[{"group_id":1,"theme":"...","issue_ids":["..."],"rationale":"..."}],"ungrouped":[]}
-`;
-
-  const taskId = Bash({
-    command: `ccw cli -p "${prompt}" --tool gemini --mode analysis`,
-    run_in_background: true, timeout: 600000
-  });
-  const output = TaskOutput({ task_id: taskId, block: true });
-
-  // Extract JSON from potential markdown code blocks
-  function extractJsonFromMarkdown(text) {
-    const jsonMatch = text.match(/```json\s*\n([\s\S]*?)\n```/) ||
-                      text.match(/```\s*\n([\s\S]*?)\n```/);
-    return jsonMatch ? jsonMatch[1] : text;
-  }
-
-  const result = JSON.parse(extractJsonFromMarkdown(output));
-  return result.groups.map(g => g.issue_ids.map(id => issues.find(i => i.id === id)));
-}
-
-const batches = await groupBySimilarityGemini(issues);
-console.log(`Processing ${issues.length} issues in ${batches.length} batch(es) (max 4 issues/agent)`);
+console.log(`Processing ${issues.length} issues in ${batches.length} batch(es)`);
 
 TodoWrite({
   todos: batches.map((_, i) => ({
@@ -195,12 +164,28 @@ ${issueList}
 
 ### Workflow
 1. Fetch issue details: ccw issue status <id> --json
-2. Load project context files
-3. Explore codebase (ACE semantic search)
-4. Plan solution with tasks (schema: solution-schema.json)
-5. **If github_url exists**: Add final task to comment on GitHub issue
-6. Write solution to: .workflow/issues/solutions/{issue-id}.jsonl
-7. Single solution → auto-bind; Multiple → return for selection
+2. **Analyze failure history** (if issue.feedback exists):
+   - Extract failure details from issue.feedback (type='failure', stage='execute')
+   - Parse error_type, message, task_id, solution_id from content JSON
+   - Identify failure patterns: repeated errors, root causes, blockers
+   - **Constraint**: Avoid repeating failed approaches
+3. Load project context files
+4. Explore codebase (ACE semantic search)
+5. Plan solution with tasks (schema: solution-schema.json)
+   - **If previous solution failed**: Reference failure analysis in solution.approach
+   -  Add explicit verification steps to prevent same failure mode
+6. **If github_url exists**: Add final task to comment on GitHub issue
+7. Write solution to: .workflow/issues/solutions/{issue-id}.jsonl
+8. **CRITICAL - Binding Decision**:
+   - Single solution → **MUST execute**: ccw issue bind <issue-id> <solution-id>
+   - Multiple solutions → Return pending_selection only (no bind)
+
+### Failure-Aware Planning Rules
+- **Extract failure patterns**: Parse issue.feedback where type='failure' and stage='execute'
+- **Identify root causes**: Analyze error_type (test_failure, compilation, timeout, etc.)
+- **Design alternative approach**: Create solution that addresses root cause
+- **Add prevention steps**: Include explicit verification to catch same error earlier
+- **Document lessons**: Reference previous failures in solution.approach
 
 ### Rules
 - Solution ID format: SOL-{issue-id}-{uid} (uid: 4 random alphanumeric chars, e.g., a7x9)
@@ -251,35 +236,55 @@ for (let i = 0; i < agentTasks.length; i += MAX_PARALLEL) {
     }
     agentResults.push(summary);  // Store for Phase 3 conflict aggregation
 
+    // Verify binding for bound issues (agent should have executed bind)
     for (const item of summary.bound || []) {
-      console.log(`✓ ${item.issue_id}: ${item.solution_id} (${item.task_count} tasks)`);
+      const status = JSON.parse(Bash(`ccw issue status ${item.issue_id} --json`).trim());
+      if (status.bound_solution_id === item.solution_id) {
+        console.log(`✓ ${item.issue_id}: ${item.solution_id} (${item.task_count} tasks)`);
+      } else {
+        // Fallback: agent failed to bind, execute here
+        Bash(`ccw issue bind ${item.issue_id} ${item.solution_id}`);
+        console.log(`✓ ${item.issue_id}: ${item.solution_id} (${item.task_count} tasks) [recovered]`);
+      }
     }
-    // Collect and notify pending selections
+    // Collect pending selections for Phase 3
     for (const pending of summary.pending_selection || []) {
-      console.log(`⏳ ${pending.issue_id}: ${pending.solutions.length} solutions → awaiting selection`);
       pendingSelections.push(pending);
     }
-    if (summary.conflicts?.length > 0) {
-      console.log(`⚠ Conflicts: ${summary.conflicts.length} detected (will resolve in Phase 3)`);
-    }
     updateTodo(`Plan batch ${batchIndex + 1}`, 'completed');
   }
 }
 ```
 
-### Phase 3: Conflict Resolution & Solution Selection
+### Phase 3: Solution Selection (if pending)
 
-**Conflict Handling:**
-- Collect `conflicts` from all agent results
-- Low/Medium severity → auto-resolve with `recommended_resolution`
-- High severity → use `AskUserQuestion` to let user choose resolution
+```javascript
+// Handle multi-solution issues
+for (const pending of pendingSelections) {
+  if (pending.solutions.length === 0) continue;
 
-**Multi-Solution Selection:**
-- If `pending_selection` contains issues with multiple solutions:
-  - Use `AskUserQuestion` to present options (solution ID + task count + description)
-  - Extract selected solution ID from user response
-  - Verify solution file exists, recover from payload if missing
-  - Bind selected solution via `ccw issue bind <issue-id> <solution-id>`
+  const options = pending.solutions.slice(0, 4).map(sol => ({
+    label: `${sol.id} (${sol.task_count} tasks)`,
+    description: sol.description || sol.approach || 'No description'
+  }));
+
+  const answer = AskUserQuestion({
+    questions: [{
+      question: `Issue ${pending.issue_id}: which solution to bind?`,
+      header: pending.issue_id,
+      options: options,
+      multiSelect: false
+    }]
+  });
+
+  const selected = answer[Object.keys(answer)[0]];
+  if (!selected || selected === 'Other') continue;
+
+  const solId = selected.split(' ')[0];
+  Bash(`ccw issue bind ${pending.issue_id} ${solId}`);
+  console.log(`✓ ${pending.issue_id}: ${solId} bound`);
+}
+```
 
 ### Phase 4: Summary
 

.claude/commands/issue/queue.md

@@ -1,10 +1,14 @@
 ---
 name: queue
 description: Form execution queue from bound solutions using issue-queue-agent (solution-level)
-argument-hint: "[--queues <n>] [--issue <id>]"
+argument-hint: "[-y|--yes] [--queues <n>] [--issue <id>]"
 allowed-tools: TodoWrite(*), Task(*), Bash(*), Read(*), Write(*)
 ---
 
+## Auto Mode
+
+When `--yes` or `-y`: Auto-confirm queue formation, use recommended conflict resolutions.
+
 # Issue Queue Command (/issue:queue)
 
 ## Overview
@@ -28,12 +32,13 @@ Queue formation command using **issue-queue-agent** that analyzes all bound solu
 | Operation | Correct | Incorrect |
 |-----------|---------|-----------|
 | List issues (brief) | `ccw issue list --status planned --brief` | `Read('issues.jsonl')` |
+| **Batch solutions (NEW)** | `ccw issue solutions --status planned --brief` | Loop `ccw issue solution <id>` |
 | List queue (brief) | `ccw issue queue --brief` | `Read('queues/*.json')` |
 | Read issue details | `ccw issue status <id> --json` | `Read('issues.jsonl')` |
 | Get next item | `ccw issue next --json` | `Read('queues/*.json')` |
 | Update status | `ccw issue update <id> --status ...` | Direct file edit |
 | Sync from queue | `ccw issue update --from-queue` | Direct file edit |
-| **Read solution (brief)** | `ccw issue solution <id> --brief` | `Read('solutions/*.jsonl')` |
+| Read solution (single) | `ccw issue solution <id> --brief` | `Read('solutions/*.jsonl')` |
 
 **Output Options**:
 - `--brief`: JSON with minimal fields (id, status, counts)
@@ -131,24 +136,23 @@ Phase 7: Active Queue Check & Decision (REQUIRED)
 ### Phase 1: Solution Loading & Distribution
 
 **Data Loading:**
-- Use `ccw issue list --status planned --brief` to get planned issues with `bound_solution_id`
-- If no planned issues found → display message, suggest `/issue:plan`
-
-**Solution Brief Loading** (for each planned issue):
-```bash
-ccw issue solution <issue-id> --brief
-# Returns: [{ solution_id, is_bound, task_count, files_touched[] }]
-```
+- Use `ccw issue solutions --status planned --brief` to get all planned issues with solutions in **one call**
+- Returns: Array of `{ issue_id, solution_id, is_bound, task_count, files_touched[], priority }`
+- If no bound solutions found → display message, suggest `/issue:plan`
 
 **Build Solution Objects:**
-```json
-{
-  "issue_id": "ISS-xxx",
-  "solution_id": "SOL-ISS-xxx-1",
-  "task_count": 3,
-  "files_touched": ["src/auth.ts", "src/utils.ts"],
-  "priority": "medium"
+```javascript
+// Single CLI call replaces N individual queries
+const result = Bash(`ccw issue solutions --status planned --brief`).trim();
+const solutions = result ? JSON.parse(result) : [];
+
+if (solutions.length === 0) {
+  console.log('No bound solutions found. Run /issue:plan first.');
+  return;
 }
+
+// solutions already in correct format:
+// { issue_id, solution_id, is_bound, task_count, files_touched[], priority }
 ```
 
 **Multi-Queue Distribution** (if `--queues > 1`):

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

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

.claude/commands/memory/docs.md

@@ -1,615 +0,0 @@
----
-name: docs
-description: Plan documentation workflow with dynamic grouping (≤10 docs/task), generates IMPL tasks for parallel module trees, README, ARCHITECTURE, and HTTP API docs
-argument-hint: "[path] [--tool <gemini|qwen|codex>] [--mode <full|partial>] [--cli-execute]"
----
-
-# Documentation Workflow (/memory:docs)
-
-## Overview
-Lightweight planner that analyzes project structure, decomposes documentation work into tasks, and generates execution plans. Does NOT generate documentation content itself - delegates to doc-generator agent.
-
-**Execution Strategy**:
-- **Dynamic Task Grouping**: Level 1 tasks grouped by top-level directories with document count limit
-  - **Primary constraint**: Each task generates ≤10 documents (API.md + README.md count)
-  - **Optimization goal**: Prefer grouping 2 top-level directories per task for context sharing
-  - **Conflict resolution**: If 2 dirs exceed 10 docs, reduce to 1 dir/task; if 1 dir exceeds 10 docs, split by subdirectories
-  - **Context benefit**: Same-task directories analyzed together via single Gemini call
-- **Parallel Execution**: Multiple Level 1 tasks execute concurrently for faster completion
-- **Pre-computed Analysis**: Phase 2 performs unified analysis once, stored in `.process/` for reuse
-- **Efficient Data Loading**: All existing docs loaded once in Phase 2, shared across tasks
-
-**Path Mirroring**: Documentation structure mirrors source code under `.workflow/docs/{project_name}/`
-- Example: `my_app/src/core/` → `.workflow/docs/my_app/src/core/API.md`
-
-**Two Execution Modes**:
-- **Default (Agent Mode)**: CLI analyzes in `pre_analysis` (MODE=analysis), agent writes docs
-- **--cli-execute (CLI Mode)**: CLI generates docs in `implementation_approach` (MODE=write), agent executes CLI commands
-
-## Path Mirroring Strategy
-
-**Principle**: Documentation structure **mirrors** source code structure under project-specific directory.
-
-| Source Path | Project Name | Documentation Path |
-|------------|--------------|-------------------|
-| `my_app/src/core/` | `my_app` | `.workflow/docs/my_app/src/core/API.md` |
-| `my_app/src/modules/auth/` | `my_app` | `.workflow/docs/my_app/src/modules/auth/API.md` |
-| `another_project/lib/utils/` | `another_project` | `.workflow/docs/another_project/lib/utils/API.md` |
-
-
-## Parameters
-
-```bash
-/memory:docs [path] [--tool <gemini|qwen|codex>] [--mode <full|partial>] [--cli-execute]
-```
-
-- **path**: Source directory to analyze (default: current directory)
-  - Specifies the source code directory to be documented
-  - Documentation is generated in a separate `.workflow/docs/{project_name}/` directory at the workspace root, **not** within the source `path` itself
-  - The source path's structure is mirrored within the project-specific documentation folder
-  - Example: analyzing `src/modules` produces documentation at `.workflow/docs/{project_name}/src/modules/`
-- **--mode**: Documentation generation mode (default: full)
-  - `full`: Complete documentation (modules + README + ARCHITECTURE + EXAMPLES + HTTP API)
-  - `partial`: Module documentation only (API.md + README.md)
-- **--tool**: CLI tool selection (default: gemini)
-  - `gemini`: Comprehensive documentation, pattern recognition
-  - `qwen`: Architecture analysis, system design focus
-  - `codex`: Implementation validation, code quality
-- **--cli-execute**: Enable CLI-based documentation generation (optional)
-
-## Planning Workflow
-
-### Phase 1: Initialize Session
-
-```bash
-# Get target path, project name, and root
-bash(pwd && basename "$(pwd)" && git rev-parse --show-toplevel 2>/dev/null || pwd && date +%Y%m%d-%H%M%S)
-```
-
-```javascript
-// Create docs session (type: docs)
-SlashCommand(command="/workflow:session:start --type docs --new \"{project_name}-docs-{timestamp}\"")
-// Parse output to get sessionId
-```
-
-```bash
-# Update workflow-session.json with docs-specific fields
-bash(jq '. + {"target_path":"{target_path}","project_root":"{project_root}","project_name":"{project_name}","mode":"full","tool":"gemini","cli_execute":false}' .workflow/active/{sessionId}/workflow-session.json > tmp.json && mv tmp.json .workflow/active/{sessionId}/workflow-session.json)
-```
-
-### Phase 2: Analyze Structure
-
-**Smart filter**: Auto-detect and skip tests/build/config/vendor based on project tech stack.
-
-**Commands** (collect data with simple bash):
-
-```bash
-# 1. Run folder analysis
-bash(ccw tool exec get_modules_by_depth '{}' | ccw tool exec classify_folders '{}')
-
-# 2. Get top-level directories (first 2 path levels)
-bash(ccw tool exec get_modules_by_depth '{}' | ccw tool exec classify_folders '{}' | awk -F'|' '{print $1}' | sed 's|^\./||' | awk -F'/' '{if(NF>=2) print $1"/"$2; else if(NF==1) print $1}' | sort -u)
-
-# 3. Find existing docs (if directory exists)
-bash(if [ -d .workflow/docs/\${project_name} ]; then find .workflow/docs/\${project_name} -type f -name "*.md" ! -path "*/README.md" ! -path "*/ARCHITECTURE.md" ! -path "*/EXAMPLES.md" ! -path "*/api/*" 2>/dev/null; fi)
-
-# 4. Read existing docs content (if files exist)
-bash(if [ -d .workflow/docs/\${project_name} ]; then find .workflow/docs/\${project_name} -type f -name "*.md" ! -path "*/README.md" ! -path "*/ARCHITECTURE.md" ! -path "*/EXAMPLES.md" ! -path "*/api/*" 2>/dev/null | xargs cat 2>/dev/null; fi)
-```
-
-**Data Processing**: Parse bash outputs, calculate statistics, use **Write tool** to create `${session_dir}/.process/doc-planning-data.json` with structure:
-
-```json
-{
-  "metadata": {
-    "generated_at": "2025-11-03T16:57:30.469669",
-    "project_name": "project_name",
-    "project_root": "/path/to/project"
-  },
-  "folder_analysis": [
-    {"path": "./src/core", "type": "code", "code_count": 5, "dirs_count": 2}
-  ],
-  "top_level_dirs": ["src/modules", "lib/core"],
-  "existing_docs": {
-    "file_list": [".workflow/docs/project/src/core/API.md"],
-    "content": "... existing docs content ..."
-  },
-  "unified_analysis": [],
-  "statistics": {
-    "total": 15,
-    "code": 8,
-    "navigation": 7,
-    "top_level": 3
-  }
-}
-```
-
-**Then** use **Edit tool** to update `workflow-session.json` adding analysis field.
-
-**Output**: Single `doc-planning-data.json` with all analysis data (no temp files or Python scripts).
-
-**Auto-skipped**: Tests (`**/test/**`, `**/*.test.*`), Build (`**/node_modules/**`, `**/dist/**`), Config (root-level files), Vendor directories.
-
-### Phase 3: Detect Update Mode
-
-**Commands**:
-
-```bash
-# Count existing docs from doc-planning-data.json
-bash(cat .workflow/active/WFS-docs-{timestamp}/.process/doc-planning-data.json | jq '.existing_docs.file_list | length')
-```
-
-**Data Processing**: Use count result, then use **Edit tool** to update `workflow-session.json`:
-- Add `"update_mode": "update"` if count > 0, else `"create"`
-- Add `"existing_docs": <count>`
-
-### Phase 4: Decompose Tasks
-
-**Task Hierarchy** (Dynamic based on document count):
-
-```
-Small Projects (total ≤10 docs):
-  Level 1: IMPL-001 (all directories in single task, shared context)
-  Level 2: IMPL-002 (README, full mode only)
-  Level 3: IMPL-003 (ARCHITECTURE+EXAMPLES), IMPL-004 (HTTP API, optional)
-
-Medium Projects (Example: 7 top-level dirs, 18 total docs):
-  Step 1: Count docs per top-level dir
-    ├─ dir1: 3 docs, dir2: 4 docs → Group 1 (7 docs)
-    ├─ dir3: 5 docs, dir4: 3 docs → Group 2 (8 docs)
-    ├─ dir5: 2 docs → Group 3 (2 docs, can add more)
-
-  Step 2: Create tasks with ≤10 docs constraint
-  Level 1: IMPL-001 to IMPL-003 (parallel groups)
-    ├─ IMPL-001: Group 1 (dir1 + dir2, 7 docs, shared context)
-    ├─ IMPL-002: Group 2 (dir3 + dir4, 8 docs, shared context)
-    └─ IMPL-003: Group 3 (remaining dirs, ≤10 docs)
-  Level 2: IMPL-004 (README, depends on Level 1, full mode only)
-  Level 3: IMPL-005 (ARCHITECTURE+EXAMPLES), IMPL-006 (HTTP API, optional)
-
-Large Projects (single dir >10 docs):
-  Step 1: Detect oversized directory
-    └─ src/modules/: 15 subdirs → 30 docs (exceeds limit)
-
-  Step 2: Split by subdirectories
-  Level 1: IMPL-001 to IMPL-003 (split oversized dir)
-    ├─ IMPL-001: src/modules/ subdirs 1-5 (10 docs)
-    ├─ IMPL-002: src/modules/ subdirs 6-10 (10 docs)
-    └─ IMPL-003: src/modules/ subdirs 11-15 (10 docs)
-```
-
-**Grouping Algorithm**:
-1. Count total docs for each top-level directory
-2. Try grouping 2 directories (optimization for context sharing)
-3. If group exceeds 10 docs, split to 1 dir/task
-4. If single dir exceeds 10 docs, split by subdirectories
-5. Create parallel Level 1 tasks with ≤10 docs each
-
-
-**Commands**:
-
-```bash
-# 1. Get top-level directories from doc-planning-data.json
-bash(cat .workflow/active/WFS-docs-{timestamp}/.process/doc-planning-data.json | jq -r '.top_level_dirs[]')
-
-# 2. Get mode from workflow-session.json
-bash(cat .workflow/active/WFS-docs-{timestamp}/workflow-session.json | jq -r '.mode // "full"')
-
-# 3. Check for HTTP API
-bash(grep -r "router\.|@Get\|@Post" src/ 2>/dev/null && echo "API_FOUND" || echo "NO_API")
-```
-
-**Data Processing**:
-1. Count documents for each top-level directory (from folder_analysis):
-   - Code folders: 2 docs each (API.md + README.md)
-   - Navigation folders: 1 doc each (README.md only)
-2. Apply grouping algorithm with ≤10 docs constraint:
-   - Try grouping 2 directories, calculate total docs
-   - If total ≤10 docs: create group
-   - If total >10 docs: split to 1 dir/group or subdivide
-   - If single dir >10 docs: split by subdirectories
-3. Use **Edit tool** to update `doc-planning-data.json` adding groups field:
-   ```json
-   "groups": {
-     "count": 3,
-     "assignments": [
-       {"group_id": "001", "directories": ["src/modules", "src/utils"], "doc_count": 5},
-       {"group_id": "002", "directories": ["lib/core"], "doc_count": 6},
-       {"group_id": "003", "directories": ["lib/helpers"], "doc_count": 3}
-     ]
-   }
-   ```
-
-**Task ID Calculation**:
-```bash
-group_count=$(jq '.groups.count' .workflow/active/WFS-docs-{timestamp}/.process/doc-planning-data.json)
-readme_id=$((group_count + 1))   # Next ID after groups
-arch_id=$((group_count + 2))
-api_id=$((group_count + 3))
-```
-
-### Phase 5: Generate Task JSONs
-
-**CLI Strategy**:
-
-| Mode | cli_execute | Placement | CLI MODE | Approval Flag | Agent Role |
-|------|-------------|-----------|----------|---------------|------------|
-| **Agent** | false | pre_analysis | analysis | (none) | Generate docs in implementation_approach |
-| **CLI** | true | implementation_approach | write | --mode write | Execute CLI commands, validate output |
-
-**Command Patterns**:
-- Gemini/Qwen: `ccw cli -p "..." --tool gemini --mode analysis --cd dir`
-- CLI Mode: `ccw cli -p "..." --tool gemini --mode write --cd dir`
-- Codex: `ccw cli -p "..." --tool codex --mode write --cd dir`
-
-**Generation Process**:
-1. Read configuration values (tool, cli_execute, mode) from workflow-session.json
-2. Read group assignments from doc-planning-data.json
-3. Generate Level 1 tasks (IMPL-001 to IMPL-N, one per group)
-4. Generate Level 2+ tasks if mode=full (README, ARCHITECTURE, HTTP API)
-
-## Task Templates
-
-### Level 1: Module Trees Group Task (Unified)
-
-**Execution Model**: Each task processes assigned directory group (max 2 directories) using pre-analyzed data from Phase 2.
-
-```json
-{
-  "id": "IMPL-${group_number}",
-  "title": "Document Module Trees Group ${group_number}",
-  "status": "pending",
-  "meta": {
-    "type": "docs-tree-group",
-    "agent": "@doc-generator",
-    "tool": "gemini",
-    "cli_execute": false,
-    "group_number": "${group_number}",
-    "total_groups": "${total_groups}"
-  },
-  "context": {
-    "requirements": [
-      "Process directories from group ${group_number} in doc-planning-data.json",
-      "Generate docs to .workflow/docs/${project_name}/ (mirrored structure)",
-      "Code folders: API.md + README.md; Navigation folders: README.md only",
-      "Use pre-analyzed data from Phase 2 (no redundant analysis)"
-    ],
-    "focus_paths": ["${group_dirs_from_json}"],
-    "precomputed_data": {
-      "phase2_analysis": "${session_dir}/.process/doc-planning-data.json"
-    }
-  },
-  "flow_control": {
-    "pre_analysis": [
-      {
-        "step": "load_precomputed_data",
-        "action": "Load Phase 2 analysis and extract group directories",
-        "commands": [
-          "bash(cat ${session_dir}/.process/doc-planning-data.json)",
-          "bash(jq '.groups.assignments[] | select(.group_id == \"${group_number}\") | .directories' ${session_dir}/.process/doc-planning-data.json)"
-        ],
-        "output_to": "phase2_context",
-        "note": "Single JSON file contains all Phase 2 analysis results"
-      }
-    ],
-    "implementation_approach": [
-      {
-        "step": 1,
-        "title": "Generate documentation for assigned directory group",
-        "description": "Process directories in Group ${group_number} using pre-analyzed data",
-        "modification_points": [
-          "Read group directories from [phase2_context].groups.assignments[${group_number}].directories",
-          "For each directory: parse folder types from folder_analysis, parse structure from unified_analysis",
-          "Map source_path to .workflow/docs/${project_name}/{path}",
-          "Generate API.md for code folders, README.md for all folders",
-          "Preserve user modifications from [phase2_context].existing_docs.content"
-        ],
-        "logic_flow": [
-          "phase2 = parse([phase2_context])",
-          "dirs = phase2.groups.assignments[${group_number}].directories",
-          "for dir in dirs:",
-          "  folder_info = find(dir, phase2.folder_analysis)",
-          "  outline = find(dir, phase2.unified_analysis)",
-          "  if folder_info.type == 'code': generate API.md + README.md",
-          "  elif folder_info.type == 'navigation': generate README.md only",
-          "  write to .workflow/docs/${project_name}/{dir}/"
-        ],
-        "depends_on": [],
-        "output": "group_module_docs"
-      }
-    ],
-    "target_files": [
-      ".workflow/docs/${project_name}/*/API.md",
-      ".workflow/docs/${project_name}/*/README.md"
-    ]
-  }
-}
-```
-
-**CLI Execute Mode Note**: When `cli_execute=true`, add Step 2 in `implementation_approach`:
-```json
-{
-  "step": 2,
-  "title": "Batch generate documentation via CLI",
-  "command": "ccw cli -p 'PURPOSE: Generate module docs\\nTASK: Create documentation\\nMODE: write\\nCONTEXT: @**/* [phase2_context]\\nEXPECTED: API.md and README.md\\nRULES: Mirror structure' --tool gemini --mode write --cd ${dirs_from_group}",
-  "depends_on": [1],
-  "output": "generated_docs"
-}
-```
-
-### Level 2: Project README Task
-
-**Task ID**: `IMPL-${readme_id}` (where `readme_id = group_count + 1`)
-**Dependencies**: Depends on all Level 1 tasks completing.
-
-```json
-{
-  "id": "IMPL-${readme_id}",
-  "title": "Generate Project README",
-  "status": "pending",
-  "depends_on": ["IMPL-001", "...", "IMPL-${group_count}"],
-  "meta": {"type": "docs", "agent": "@doc-generator", "tool": "gemini", "cli_execute": false},
-  "flow_control": {
-    "pre_analysis": [
-      {
-        "step": "load_existing_readme",
-        "command": "bash(cat .workflow/docs/${project_name}/README.md 2>/dev/null || echo 'No existing README')",
-        "output_to": "existing_readme"
-      },
-      {
-        "step": "load_module_docs",
-        "command": "bash(find .workflow/docs/${project_name} -type f -name '*.md' ! -path '.workflow/docs/${project_name}/README.md' ! -path '.workflow/docs/${project_name}/ARCHITECTURE.md' ! -path '.workflow/docs/${project_name}/EXAMPLES.md' ! -path '.workflow/docs/${project_name}/api/*' | xargs cat)",
-        "output_to": "all_module_docs"
-      },
-      {
-        "step": "analyze_project",
-        "command": "bash(ccw cli -p \"PURPOSE: Analyze project structure\\nTASK: Extract overview from modules\\nMODE: analysis\\nCONTEXT: [all_module_docs]\\nEXPECTED: Project outline\" --tool gemini --mode analysis)",
-        "output_to": "project_outline"
-      }
-    ],
-    "implementation_approach": [
-      {
-        "step": 1,
-        "title": "Generate project README",
-        "description": "Generate project README with navigation links while preserving user modifications",
-        "modification_points": [
-          "Parse [project_outline] and [all_module_docs]",
-          "Generate README structure with navigation links",
-          "Preserve [existing_readme] user modifications"
-        ],
-        "logic_flow": ["Parse data", "Generate README with navigation", "Preserve modifications"],
-        "depends_on": [],
-        "output": "project_readme"
-      }
-    ],
-    "target_files": [".workflow/docs/${project_name}/README.md"]
-  }
-}
-```
-
-### Level 3: Architecture & Examples Documentation Task
-
-**Task ID**: `IMPL-${arch_id}` (where `arch_id = group_count + 2`)
-**Dependencies**: Depends on Level 2 (Project README).
-
-```json
-{
-  "id": "IMPL-${arch_id}",
-  "title": "Generate Architecture & Examples Documentation",
-  "status": "pending",
-  "depends_on": ["IMPL-${readme_id}"],
-  "meta": {"type": "docs", "agent": "@doc-generator", "tool": "gemini", "cli_execute": false},
-  "flow_control": {
-    "pre_analysis": [
-      {"step": "load_existing_docs", "command": "bash(cat .workflow/docs/${project_name}/{ARCHITECTURE,EXAMPLES}.md 2>/dev/null || echo 'No existing docs')", "output_to": "existing_arch_examples"},
-      {"step": "load_all_docs", "command": "bash(cat .workflow/docs/${project_name}/README.md && find .workflow/docs/${project_name} -type f -name '*.md' ! -path '*/README.md' ! -path '*/ARCHITECTURE.md' ! -path '*/EXAMPLES.md' ! -path '*/api/*' | xargs cat)", "output_to": "all_docs"},
-      {"step": "analyze_architecture", "command": "bash(ccw cli -p \"PURPOSE: Analyze system architecture\\nTASK: Synthesize architectural overview and examples\\nMODE: analysis\\nCONTEXT: [all_docs]\\nEXPECTED: Architecture + Examples outline\" --tool gemini --mode analysis)", "output_to": "arch_examples_outline"}
-    ],
-    "implementation_approach": [
-      {
-        "step": 1,
-        "title": "Generate architecture and examples documentation",
-        "modification_points": [
-          "Parse [arch_examples_outline] and [all_docs]",
-          "Generate ARCHITECTURE.md (system design, patterns)",
-          "Generate EXAMPLES.md (code snippets, usage)",
-          "Preserve [existing_arch_examples] modifications"
-        ],
-        "depends_on": [],
-        "output": "arch_examples_docs"
-      }
-    ],
-    "target_files": [".workflow/docs/${project_name}/ARCHITECTURE.md", ".workflow/docs/${project_name}/EXAMPLES.md"]
-  }
-}
-```
-
-### Level 4: HTTP API Documentation Task (Optional)
-
-**Task ID**: `IMPL-${api_id}` (where `api_id = group_count + 3`)
-**Dependencies**: Depends on Level 3.
-
-```json
-{
-  "id": "IMPL-${api_id}",
-  "title": "Generate HTTP API Documentation",
-  "status": "pending",
-  "depends_on": ["IMPL-${arch_id}"],
-  "meta": {"type": "docs", "agent": "@doc-generator", "tool": "gemini", "cli_execute": false},
-  "flow_control": {
-    "pre_analysis": [
-      {"step": "discover_api", "command": "bash(rg 'router\\.| @(Get|Post)' -g '*.{ts,js}')", "output_to": "endpoint_discovery"},
-      {"step": "load_existing_api", "command": "bash(cat .workflow/docs/${project_name}/api/README.md 2>/dev/null || echo 'No existing API docs')", "output_to": "existing_api_docs"},
-      {"step": "analyze_api", "command": "bash(ccw cli -p \"PURPOSE: Document HTTP API\\nTASK: Analyze endpoints\\nMODE: analysis\\nCONTEXT: @src/api/**/* [endpoint_discovery]\\nEXPECTED: API outline\" --tool gemini --mode analysis)", "output_to": "api_outline"}
-    ],
-    "implementation_approach": [
-      {
-        "step": 1,
-        "title": "Generate HTTP API documentation",
-        "modification_points": [
-          "Parse [api_outline] and [endpoint_discovery]",
-          "Document endpoints, request/response formats",
-          "Preserve [existing_api_docs] modifications"
-        ],
-        "depends_on": [],
-        "output": "api_docs"
-      }
-    ],
-    "target_files": [".workflow/docs/${project_name}/api/README.md"]
-  }
-}
-```
-
-## Session Structure
-
-**Unified Structure** (single JSON replaces multiple text files):
-
-```
-.workflow/active/
-└── WFS-docs-{timestamp}/
-    ├── workflow-session.json            # Session metadata
-    ├── IMPL_PLAN.md
-    ├── TODO_LIST.md
-    ├── .process/
-    │   └── doc-planning-data.json       # All Phase 2 analysis data (replaces 7+ files)
-    └── .task/
-        ├── IMPL-001.json                # Small: all modules | Large: group 1
-        ├── IMPL-00N.json                # (Large only: groups 2-N)
-        ├── IMPL-{N+1}.json              # README (full mode)
-        ├── IMPL-{N+2}.json              # ARCHITECTURE+EXAMPLES (full mode)
-        └── IMPL-{N+3}.json              # HTTP API (optional)
-```
-
-**doc-planning-data.json Structure**:
-```json
-{
-  "metadata": {
-    "generated_at": "2025-11-03T16:41:06+08:00",
-    "project_name": "Claude_dms3",
-    "project_root": "/d/Claude_dms3"
-  },
-  "folder_analysis": [
-    {"path": "./src/core", "type": "code", "code_count": 5, "dirs_count": 2},
-    {"path": "./src/utils", "type": "navigation", "code_count": 0, "dirs_count": 4}
-  ],
-  "top_level_dirs": ["src/modules", "src/utils", "lib/core"],
-  "existing_docs": {
-    "file_list": [".workflow/docs/project/src/core/API.md"],
-    "content": "... concatenated existing docs ..."
-  },
-  "unified_analysis": [
-    {"module_path": "./src/core", "outline_summary": "Core functionality"}
-  ],
-  "groups": {
-    "count": 4,
-    "assignments": [
-      {"group_id": "001", "directories": ["src/modules", "src/utils"], "doc_count": 6},
-      {"group_id": "002", "directories": ["lib/core", "lib/helpers"], "doc_count": 7}
-    ]
-  },
-  "statistics": {
-    "total": 15,
-    "code": 8,
-    "navigation": 7,
-    "top_level": 3
-  }
-}
-```
-
-**Workflow Session Structure** (workflow-session.json):
-```json
-{
-  "session_id": "WFS-docs-{timestamp}",
-  "project": "{project_name} documentation",
-  "status": "planning",
-  "timestamp": "2024-01-20T14:30:22+08:00",
-  "path": ".",
-  "target_path": "/path/to/project",
-  "project_root": "/path/to/project",
-  "project_name": "{project_name}",
-  "mode": "full",
-  "tool": "gemini",
-  "cli_execute": false,
-  "update_mode": "update",
-  "existing_docs": 5,
-  "analysis": {
-    "total": "15",
-    "code": "8",
-    "navigation": "7",
-    "top_level": "3"
-  }
-}
-```
-
-## Generated Documentation
-
-**Structure mirrors project source directories under project-specific folder**:
-
-```
-.workflow/docs/
-└── {project_name}/                    # Project-specific root
-    ├── src/                           # Mirrors src/ directory
-    │   ├── modules/
-    │   │   ├── README.md              # Navigation
-    │   │   ├── auth/
-    │   │   │   ├── API.md             # API signatures
-    │   │   │   ├── README.md          # Module docs
-    │   │   │   └── middleware/
-    │   │   │       ├── API.md
-    │   │   │       └── README.md
-    │   │   └── api/
-    │   │       ├── API.md
-    │   │       └── README.md
-    │   └── utils/
-    │       └── README.md
-    ├── lib/                           # Mirrors lib/ directory
-    │   └── core/
-    │       ├── API.md
-    │       └── README.md
-    ├── README.md                      # Project root
-    ├── ARCHITECTURE.md                # System design
-    ├── EXAMPLES.md                    # Usage examples
-    └── api/                           # Optional
-        └── README.md                  # HTTP API reference
-```
-
-## Execution Commands
-
-```bash
-# Execute entire workflow (auto-discovers active session)
-/workflow:execute
-
-# Or specify session
-/workflow:execute --resume-session="WFS-docs-yyyymmdd-hhmmss"
-
-# Individual task execution
-/task:execute IMPL-001
-```
-
-## Template Reference
-
-**Available Templates** (`~/.claude/workflows/cli-templates/prompts/documentation/`):
-- `api.txt`: Code API (Part A) + HTTP API (Part B)
-- `module-readme.txt`: Module purpose, usage, dependencies
-- `folder-navigation.txt`: Navigation README for folders with subdirectories
-- `project-readme.txt`: Project overview, getting started, navigation
-- `project-architecture.txt`: System structure, module map, design patterns
-- `project-examples.txt`: End-to-end usage examples
-
-## Execution Mode Summary
-
-| Mode | CLI Placement | CLI MODE | Approval Flag | Agent Role |
-|------|---------------|----------|---------------|------------|
-| **Agent (default)** | pre_analysis | analysis | (none) | Generates documentation content |
-| **CLI (--cli-execute)** | implementation_approach | write | --mode write | Executes CLI commands, validates output |
-
-**Execution Flow**:
-- **Phase 2**: Unified analysis once, results in `.process/`
-- **Phase 4**: Dynamic grouping (max 2 dirs per group)
-- **Level 1**: Parallel processing for module tree groups
-- **Level 2+**: Sequential execution for project-level docs
-
-## Related Commands
-- `/workflow:execute` - Execute documentation tasks
-- `/workflow:status` - View task progress
-- `/workflow:session:complete` - Mark session complete

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

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

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

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

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

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

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

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

.claude/commands/memory/tips.md

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

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

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

.claude/commands/task/breakdown.md

@@ -1,204 +0,0 @@
----
-name: breakdown
-description: Decompose complex task into subtasks with dependency mapping, creates child task JSONs with parent references and execution order
-argument-hint: "task-id"
----
-
-# Task Breakdown Command (/task:breakdown)
-
-## Overview
-Breaks down complex tasks into executable subtasks with context inheritance and agent assignment.
-
-## Core Principles
-**File Cohesion:** Related files must stay in same task
-**10-Task Limit:** Total tasks cannot exceed 10 (triggers re-scoping)
-
-## Core Features
-
-**CRITICAL**: Manual breakdown with safety controls to prevent file conflicts and task limit violations.
-
-### Breakdown Process
-1. **Session Check**: Verify active session contains parent task
-2. **Task Validation**: Ensure parent is `pending` status
-3. **10-Task Limit Check**: Verify breakdown won't exceed total limit
-4. **Manual Decomposition**: User defines subtasks with validation
-5. **File Conflict Detection**: Warn if same files appear in multiple subtasks
-6. **Similar Function Warning**: Alert if subtasks have overlapping functionality
-7. **Context Distribution**: Inherit parent requirements and scope
-8. **Agent Assignment**: Auto-assign agents based on subtask type
-9. **TODO_LIST Update**: Regenerate TODO_LIST.md with new structure
-
-### Breakdown Rules
-- Only `pending` tasks can be broken down
-- **Manual breakdown only**: Automated breakdown disabled to prevent violations
-- Parent becomes `container` status (not executable)
-- Subtasks use format: IMPL-N.M (max 2 levels)
-- Context flows from parent to subtasks
-- All relationships tracked in JSON
-- **10-task limit enforced**: Breakdown rejected if total would exceed 10 tasks
-- **File cohesion preserved**: Same files cannot be split across subtasks
-
-## Usage
-
-### Basic Breakdown
-```bash
-/task:breakdown impl-1
-```
-
-Interactive process:
-```
-Task: Build authentication module
-Current total tasks: 6/10
-
-MANUAL BREAKDOWN REQUIRED
-Define subtasks manually (remaining capacity: 4 tasks):
-
-1. Enter subtask title: User authentication core
-   Focus files: models/User.js, routes/auth.js, middleware/auth.js
-
-2. Enter subtask title: OAuth integration
-   Focus files: services/OAuthService.js, routes/oauth.js
-
-FILE CONFLICT DETECTED:
-   - routes/auth.js appears in multiple subtasks
-   - Recommendation: Merge related authentication routes
-
-SIMILAR FUNCTIONALITY WARNING:
-   - "User authentication" and "OAuth integration" both handle auth
-   - Consider combining into single task
-
-# Use AskUserQuestion for confirmation
-AskUserQuestion({
-  questions: [{
-    question: "File conflicts and/or similar functionality detected. How do you want to proceed?",
-    header: "Confirm",
-    options: [
-      { label: "Proceed with breakdown", description: "Accept the risks and create the subtasks as defined." },
-      { label: "Restart breakdown", description: "Discard current subtasks and start over." },
-      { label: "Cancel breakdown", description: "Abort the operation and leave the parent task as is." }
-    ],
-    multiSelect: false
-  }]
-})
-
-User selected: "Proceed with breakdown"
-
-Task IMPL-1 broken down:
-IMPL-1: Build authentication module (container)
-  ├── IMPL-1.1: User authentication core -> @code-developer
-  └── IMPL-1.2: OAuth integration -> @code-developer
-
-Files updated: .task/IMPL-1.json + 2 subtask files + TODO_LIST.md
-```
-
-## Decomposition Logic
-
-### Agent Assignment
-- **Design/Planning** → `@planning-agent`
-- **Implementation** → `@code-developer`
-- **Testing** → `@code-developer` (type: "test-gen")
-- **Test Validation** → `@test-fix-agent` (type: "test-fix")
-- **Review** → `@universal-executor` (optional)
-
-### Context Inheritance
-- Subtasks inherit parent requirements
-- Scope refined for specific subtask
-- Implementation details distributed appropriately
-
-## Safety Controls
-
-### File Conflict Detection
-**Validates file cohesion across subtasks:**
-- Scans `focus_paths` in all subtasks
-- Warns if same file appears in multiple subtasks
-- Suggests merging subtasks with overlapping files
-- Blocks breakdown if critical conflicts detected
-
-### Similar Functionality Detection
-**Prevents functional overlap:**
-- Analyzes subtask titles for similar keywords
-- Warns about potential functional redundancy
-- Suggests consolidation of related functionality
-- Examples: "user auth" + "login system" → merge recommendation
-
-### 10-Task Limit Enforcement
-**Hard limit compliance:**
-- Counts current total tasks in session
-- Calculates breakdown impact on total
-- Rejects breakdown if would exceed 10 tasks
-- Suggests re-scoping if limit reached
-
-### Manual Control Requirements
-**User-driven breakdown only:**
-- No automatic subtask generation
-- User must define each subtask title and scope
-- Real-time validation during input
-- Confirmation required before execution
-
-## Implementation Details
-
-- Complete task JSON schema
-- Implementation field structure
-- Context inheritance rules
-- Agent assignment logic
-
-## Validation
-
-### Pre-breakdown Checks
-1. Active session exists
-2. Task found in session
-3. Task status is `pending`
-4. Not already broken down
-5. **10-task limit compliance**: Total tasks + new subtasks ≤ 10
-6. **Manual mode enabled**: No automatic breakdown allowed
-
-### Post-breakdown Actions
-1. Update parent to `container` status
-2. Create subtask JSON files
-3. Update parent subtasks list
-4. Update session stats
-5. **Regenerate TODO_LIST.md** with new hierarchy
-6. Validate file paths in focus_paths
-7. Update session task count
-
-## Examples
-
-### Basic Breakdown
-```bash
-/task:breakdown impl-1
-
-impl-1: Build authentication (container)
-  ├── impl-1.1: Design schema -> @planning-agent
-  ├── impl-1.2: Implement logic + tests -> @code-developer
-  └── impl-1.3: Execute & fix tests -> @test-fix-agent
-```
-
-## Error Handling
-
-```bash
-# Task not found
-Task IMPL-5 not found
-
-# Already broken down
-Task IMPL-1 already has subtasks
-
-# Wrong status
-Cannot breakdown completed task IMPL-2
-
-# 10-task limit exceeded
-Breakdown would exceed 10-task limit (current: 8, proposed: 4)
-Suggestion: Re-scope project into smaller iterations
-
-# File conflicts detected
-File conflict: routes/auth.js appears in IMPL-1.1 and IMPL-1.2
-Recommendation: Merge subtasks or redistribute files
-
-# Similar functionality warning
-Similar functions detected: "user login" and "authentication"
-Consider consolidating related functionality
-
-# Manual breakdown required
-Automatic breakdown disabled. Use manual breakdown process.
-```
-
-**System ensures**: Manual breakdown control with file cohesion enforcement, similar functionality detection, and 10-task limit compliance

.claude/commands/task/create.md

@@ -1,152 +0,0 @@
----
-name: create
-description: Generate task JSON from natural language description with automatic file pattern detection, scope inference, and dependency analysis
-argument-hint: "\"task title\""
----
-
-# Task Create Command (/task:create)
-
-## Overview
-Creates new implementation tasks with automatic context awareness and ID generation.
-
-## Core Principles
-**Task System:** @~/.claude/workflows/task-core.md
-
-## Core Features
-
-### Automatic Behaviors
-- **ID Generation**: Auto-generates IMPL-N format (max 2 levels)
-- **Context Inheritance**: Inherits from active workflow session
-- **JSON Creation**: Creates task JSON in active session
-- **Status Setting**: Initial status = "pending"
-- **Agent Assignment**: Suggests agent based on task type
-- **Session Integration**: Updates workflow session stats
-
-### Context Awareness
-- Validates active workflow session exists
-- Avoids duplicate task IDs
-- Inherits session requirements and scope
-- Suggests task relationships
-
-## Usage
-
-### Basic Creation
-```bash
-/task:create "Build authentication module"
-```
-
-Output:
-```
-Task created: IMPL-1
-Title: Build authentication module
-Type: feature
-Agent: code-developer
-Status: pending
-```
-
-### Task Types
-- `feature` - New functionality (default)
-- `bugfix` - Bug fixes
-- `refactor` - Code improvements
-- `test` - Test implementation
-- `docs` - Documentation
-
-## Task Creation Process
-
-1. **Session Validation**: Check active workflow session
-2. **ID Generation**: Auto-increment IMPL-N
-3. **Context Inheritance**: Load workflow context
-4. **Implementation Setup**: Initialize implementation field
-5. **Agent Assignment**: Select appropriate agent
-6. **File Creation**: Save JSON to .task/ directory
-7. **Session Update**: Update workflow stats
-
-**Task Schema**: See @~/.claude/workflows/task-core.md for complete JSON structure
-
-## Implementation Field Setup
-
-### Auto-Population Strategy
-- **Detailed info**: Extract from task description and scope
-- **Missing info**: Mark `pre_analysis` as multi-step array format for later pre-analysis
-- **Basic structure**: Initialize with standard template
-
-### Analysis Triggers
-When implementation details incomplete:
-```bash
-Task requires analysis for implementation details
-Suggest running: gemini analysis for file locations and dependencies
-```
-
-## File Management
-
-### JSON Task File
-- **Location**: `.task/IMPL-[N].json` in active session
-- **Content**: Complete task with implementation field
-- **Updates**: Session stats only
-
-### Simple Process
-1. Validate session and inputs
-2. Generate task JSON
-3. Update session stats
-4. Notify completion
-
-## Context Inheritance
-
-Tasks inherit from:
-1. **Active Session** - Requirements and scope from workflow-session.json
-2. **Planning Document** - Context from IMPL_PLAN.md
-3. **Parent Task** - For subtasks (IMPL-N.M format)
-
-## Agent Assignment
-
-Based on task type and title keywords:
-- **Build/Implement** → @code-developer
-- **Design/Plan** → @planning-agent
-- **Test Generation** → @code-developer (type: "test-gen")
-- **Test Execution/Fix** → @test-fix-agent (type: "test-fix")
-- **Review/Audit** → @universal-executor (optional, only when explicitly requested)
-
-## Validation Rules
-
-1. **Session Check** - Active workflow session required
-2. **Duplicate Check** - Avoid similar task titles
-3. **ID Uniqueness** - Auto-increment task IDs
-4. **Schema Validation** - Ensure proper JSON structure
-
-## Error Handling
-
-```bash
-# No workflow session
-No active workflow found
-Use: /workflow init "project name"
-
-# Duplicate task
-Similar task exists: IMPL-3
-Continue anyway? (y/n)
-
-# Max depth exceeded
-Cannot create IMPL-1.2.1 (max 2 levels)
-Use: IMPL-2 for new main task
-```
-
-## Examples
-
-### Feature Task
-```bash
-/task:create "Implement user authentication"
-
-Created IMPL-1: Implement user authentication
-Type: feature
-Agent: code-developer
-Status: pending
-```
-
-### Bug Fix
-```bash
-/task:create "Fix login validation bug" --type=bugfix
-
-Created IMPL-2: Fix login validation bug
-Type: bugfix
-Agent: code-developer
-Status: pending
-```

.claude/commands/task/execute.md

@@ -1,270 +0,0 @@
----
-name: execute
-description: Execute task JSON using appropriate agent (@doc-generator/@implementation-agent/@test-agent) with pre-analysis context loading and status tracking
-argument-hint: "task-id"
----
-
-## Command Overview: /task:execute
-
-**Purpose**: Executes tasks using intelligent agent selection, context preparation, and progress tracking.
-
-
-## Execution Modes
-
--   **auto (Default)**
-    -   Fully autonomous execution with automatic agent selection.
-    -   Provides progress updates at each checkpoint.
-    -   Automatically completes the task when done.
--   **guided**
-    -   Executes step-by-step, requiring user confirmation at each checkpoint.
-    -   Allows for dynamic adjustments and manual review during the process.
--   **review**
-    -   Optional manual review using `@universal-executor`.
-    -   Used only when explicitly requested by user.
-
-## Agent Selection Logic
-
-The system determines the appropriate agent for a task using the following logic.
-
-```pseudo
-FUNCTION select_agent(task, agent_override):
-    // A manual override always takes precedence.
-    // Corresponds to the --agent=<agent-type> flag.
-    IF agent_override IS NOT NULL:
-        RETURN agent_override
-
-    // If no override, select based on keywords in the task title.
-    ELSE:
-        CASE task.title:
-            WHEN CONTAINS "Build API", "Implement":
-                RETURN "@code-developer"
-            WHEN CONTAINS "Design schema", "Plan":
-                RETURN "@planning-agent"
-            WHEN CONTAINS "Write tests", "Generate tests":
-                RETURN "@code-developer" // type: test-gen
-            WHEN CONTAINS "Execute tests", "Fix tests", "Validate":
-                RETURN "@test-fix-agent" // type: test-fix
-            WHEN CONTAINS "Review code":
-                RETURN "@universal-executor" // Optional manual review
-            DEFAULT:
-                RETURN "@code-developer" // Default agent
-        END CASE
-END FUNCTION
-```
-
-## Core Execution Protocol
-
-`Pre-Execution` -> `Execution` -> `Post-Execution`
-
-### Pre-Execution Protocol
-
-`Validate Task & Dependencies` **->** `Prepare Execution Context` **->** `Coordinate with TodoWrite`
-
--   **Validation**: Checks for the task's JSON file in `.task/` and resolves its dependencies.
--   **Context Preparation**: Loads task and workflow context, preparing it for the selected agent.
--   **Session Context Injection**: Provides workflow directory paths to agents for TODO_LIST.md and summary management.
--   **TodoWrite Coordination**: Generates execution Todos and checkpoints, syncing with `TODO_LIST.md`.
-
-### Post-Execution Protocol
-
-`Update Task Status` **->** `Generate Summary` **->** `Save Artifacts` **->** `Sync All Progress` **->** `Validate File Integrity`
-
--   Updates status in the task's JSON file and `TODO_LIST.md`.
--   Creates a summary in `.summaries/`.
--   Stores outputs and syncs progress across the entire workflow session.
-
-### Task & Subtask Execution Logic
-
-This logic defines how single, multiple, or parent tasks are handled.
-
-```pseudo
-FUNCTION execute_task_command(task_id, mode, parallel_flag):
-    // Handle parent tasks by executing their subtasks.
-    IF is_parent_task(task_id):
-        subtasks = get_subtasks(task_id)
-        EXECUTE_SUBTASK_BATCH(subtasks, mode)
-
-    // Handle wildcard execution (e.g., IMPL-001.*)
-    ELSE IF task_id CONTAINS "*":
-        subtasks = find_matching_tasks(task_id)
-        IF parallel_flag IS true:
-            EXECUTE_IN_PARALLEL(subtasks)
-        ELSE:
-            FOR each subtask in subtasks:
-                EXECUTE_SINGLE_TASK(subtask, mode)
-  
-    // Default case for a single task ID.
-    ELSE:
-        EXECUTE_SINGLE_TASK(task_id, mode)
-END FUNCTION
-```
-
-### Error Handling & Recovery Logic
-
-```pseudo
-FUNCTION pre_execution_check(task):
-    // Ensure dependencies are met before starting.
-    IF task.dependencies ARE NOT MET:
-        LOG_ERROR("Cannot execute " + task.id)
-        LOG_INFO("Blocked by: " + unmet_dependencies)
-        HALT_EXECUTION()
-
-FUNCTION on_execution_failure(checkpoint):
-    // Provide user with recovery options upon failure.
-    LOG_WARNING("Execution failed at checkpoint " + checkpoint)
-    PRESENT_OPTIONS([
-        "Retry from checkpoint",
-        "Retry from beginning",
-        "Switch to guided mode",
-        "Abort execution"
-    ])
-    AWAIT user_input
-    // System performs the selected action.
-END FUNCTION
-```
-
-
-### Simplified Context Structure (JSON)
-
-This is the simplified data structure loaded to provide context for task execution.
-
-```json
-{
-  "task": {
-    "id": "IMPL-1",
-    "title": "Build authentication module",
-    "type": "feature",
-    "status": "active",
-    "agent": "code-developer",
-    "context": {
-      "requirements": ["JWT authentication", "OAuth2 support"],
-      "scope": ["src/auth/*", "tests/auth/*"],
-      "acceptance": ["Module handles JWT tokens", "OAuth2 flow implemented"],
-      "inherited_from": "WFS-user-auth"
-    },
-    "relations": {
-      "parent": null,
-      "subtasks": ["IMPL-1.1", "IMPL-1.2"],
-      "dependencies": ["IMPL-0"]
-    },
-    "implementation": {
-      "files": [
-        {
-          "path": "src/auth/login.ts",
-          "location": {
-            "function": "authenticateUser",
-            "lines": "25-65",
-            "description": "Main authentication logic"
-          },
-          "original_code": "// Code snippet extracted via gemini analysis",
-          "modifications": {
-            "current_state": "Basic password authentication only",
-            "proposed_changes": [
-              "Add JWT token generation",
-              "Implement OAuth2 callback handling",
-              "Add multi-factor authentication support"
-            ],
-            "logic_flow": [
-              "validateCredentials() ───► checkUserExists()",
-              "◊─── if password ───► generateJWT() ───► return token",
-              "◊─── if OAuth ───► validateOAuthCode() ───► exchangeForToken()",
-              "◊─── if MFA ───► sendMFACode() ───► awaitVerification()"
-            ],
-            "reason": "Support modern authentication standards and security requirements",
-            "expected_outcome": "Comprehensive authentication system supporting multiple methods"
-          }
-        }
-      ],
-      "context_notes": {
-        "dependencies": ["jsonwebtoken", "passport", "speakeasy"],
-        "affected_modules": ["user-session", "auth-middleware", "api-routes"],
-        "risks": [
-          "Breaking changes to existing login endpoints",
-          "Token storage and rotation complexity",
-          "OAuth provider configuration dependencies"
-        ],
-        "performance_considerations": "JWT validation adds ~10ms per request, OAuth callbacks may timeout",
-        "error_handling": "Ensure sensitive authentication errors don't leak user enumeration data"
-      },
-      "pre_analysis": [
-        {
-          "action": "analyze patterns",
-          "template": "~/.claude/workflows/cli-templates/prompts/analysis/02-analyze-code-patterns.txt",
-          "method": "gemini"
-        }
-      ]
-    }
-  },
-  "workflow": {
-    "session": "WFS-user-auth",
-    "phase": "IMPLEMENT",
-    "session_context": {
-      "workflow_directory": ".workflow/active/WFS-user-auth/",
-      "todo_list_location": ".workflow/active/WFS-user-auth/TODO_LIST.md",
-      "summaries_directory": ".workflow/active/WFS-user-auth/.summaries/",
-      "task_json_location": ".workflow/active/WFS-user-auth/.task/"
-    }
-  },
-  "execution": {
-    "agent": "code-developer",
-    "mode": "auto",
-    "attempts": 0
-  }
-}
-```
-
-### Agent-Specific Context
-
-Different agents receive context tailored to their function, including implementation details:
-
-**`@code-developer`**: 
-- Complete implementation.files array with file paths and locations
-- original_code snippets and proposed_changes for precise modifications
-- logic_flow diagrams for understanding data flow
-- Dependencies and affected modules for integration planning
-- Performance and error handling considerations
-
-**`@planning-agent`**: 
-- High-level requirements, constraints, success criteria
-- Implementation risks and mitigation strategies
-- Architecture implications from implementation.context_notes
-
-**`@test-fix-agent`**:
-- Test files to execute from task.context.focus_paths
-- Source files to fix from implementation.files[].path
-- Expected behaviors from implementation.modifications.logic_flow
-- Error conditions to validate from implementation.context_notes.error_handling
-- Performance requirements from implementation.context_notes.performance_considerations
-
-**`@universal-executor`**:
-- Used for optional manual reviews when explicitly requested
-- Code quality standards and implementation patterns
-- Security considerations from implementation.context_notes.risks
-- Dependency validation from implementation.context_notes.dependencies
-- Architecture compliance checks
-
-### Simplified File Output
-
--   **Task JSON File (`.task/<task-id>.json`)**: Updated with status and last attempt time only.
--   **Session File (`workflow-session.json`)**: Updated task stats (completed count).
--   **Summary File**: Generated in `.summaries/` upon completion (optional).
-
-### Simplified Summary Template
-
-Optional summary file generated at `.summaries/IMPL-[task-id]-summary.md`.
-
-```markdown
-# Task Summary: IMPL-1 Build Authentication Module
-
-## What Was Done
-- Created src/auth/login.ts with JWT validation
-- Added tests in tests/auth.test.ts
-
-## Execution Results
-- **Agent**: code-developer
-- **Status**: completed
-
-## Files Modified
-- `src/auth/login.ts` (created)
-- `tests/auth.test.ts` (created)
-```

.claude/commands/task/replan.md

@@ -1,437 +0,0 @@
----
-name: replan
-description: Update task JSON with new requirements or batch-update multiple tasks from verification report, tracks changes in task-changes.json
-argument-hint: "task-id [\"text\"|file.md] | --batch [verification-report.md]"
-allowed-tools: Read(*), Write(*), Edit(*), TodoWrite(*), Glob(*), Bash(*)
----
-
-# Task Replan Command (/task:replan)
-
-> **⚠️ DEPRECATION NOTICE**: This command is maintained for backward compatibility. For new workflows, use `/workflow:replan` which provides:
-> - Session-level replanning with comprehensive artifact updates
-> - Interactive boundary clarification
-> - Updates to IMPL_PLAN.md, TODO_LIST.md, and session metadata
-> - Better integration with workflow sessions
->
-> **Migration**: Replace `/task:replan IMPL-1 "changes"` with `/workflow:replan IMPL-1 "changes"`
-
-## Overview
-Replans individual tasks or batch processes multiple tasks with change tracking and backup management.
-
-**Modes**:
-- **Single Task Mode**: Replan one task with specific changes
-- **Batch Mode**: Process multiple tasks from action-plan verification report
-
-## Key Features
-- **Single/Batch Operations**: Single task or multiple tasks from verification report
-- **Multiple Input Sources**: Text, files, or verification report
-- **Backup Management**: Automatic backup of previous versions
-- **Change Documentation**: Track all modifications
-- **Progress Tracking**: TodoWrite integration for batch operations
-
-**CRITICAL**: Validates active session before replanning
-
-## Operation Modes
-
-### Single Task Mode
-
-#### Direct Text (Default)
-```bash
-/task:replan IMPL-1 "Add OAuth2 authentication support"
-```
-
-#### File-based Input
-```bash
-/task:replan IMPL-1 updated-specs.md
-```
-Supports: .md, .txt, .json, .yaml
-
-#### Interactive Mode
-```bash
-/task:replan IMPL-1 --interactive
-```
-Guided step-by-step modification process with validation
-
-### Batch Mode
-
-#### From Verification Report
-```bash
-/task:replan --batch ACTION_PLAN_VERIFICATION.md
-```
-
-**Workflow**:
-1. Parse verification report to extract replan recommendations
-2. Create TodoWrite task list for all modifications
-3. Process each task sequentially with confirmation
-4. Track progress and generate summary report
-
-**Auto-detection**: If input file contains "Action Plan Verification Report" header, automatically enters batch mode
-
-## Replanning Process
-
-### Single Task Process
-
-1. **Load & Validate**: Read task JSON and validate session
-2. **Parse Input**: Process changes from input source
-3. **Create Backup**: Save previous version to backup folder
-4. **Update Task**: Modify JSON structure and relationships
-5. **Save Changes**: Write updated task and increment version
-6. **Update Session**: Reflect changes in workflow stats
-
-### Batch Process
-
-1. **Parse Verification Report**: Extract all replan recommendations
-2. **Initialize TodoWrite**: Create task list for tracking
-3. **For Each Task**:
-   - Mark todo as in_progress
-   - Load and validate task JSON
-   - Create backup
-   - Apply recommended changes
-   - Save updated task
-   - Mark todo as completed
-4. **Generate Summary**: Report all changes and backup locations
-
-## Backup Management
-
-### Backup Tracking
-Tasks maintain backup history:
-```json
-{
-  "id": "IMPL-1",
-  "version": "1.2",
-  "replan_history": [
-    {
-      "version": "1.2",
-      "reason": "Add OAuth2 support",
-      "input_source": "direct_text",
-      "backup_location": ".task/backup/IMPL-1-v1.1.json",
-      "timestamp": "2025-10-17T10:30:00Z"
-    }
-  ]
-}
-```
-
-**Complete schema**: See @~/.claude/workflows/task-core.md
-
-### File Structure
-```
-.task/
-├── IMPL-1.json                    # Current version
-├── backup/
-│   ├── IMPL-1-v1.0.json          # Original version
-│   ├── IMPL-1-v1.1.json          # Previous backup
-│   └── IMPL-1-v1.2.json          # Latest backup
-└── [new subtasks as needed]
-```
-
-**Backup Naming**: `{task-id}-v{version}.json`
-
-## Implementation Updates
-
-### Change Detection
-Tracks modifications to:
-- Files in implementation.files array
-- Dependencies and affected modules
-- Risk assessments and performance notes
-- Logic flows and code locations
-
-### Analysis Triggers
-May require gemini re-analysis when:
-- New files need code extraction
-- Function locations change
-- Dependencies require re-evaluation
-
-## Document Updates
-
-### Planning Document
-May update IMPL_PLAN.md sections when task structure changes significantly
-
-### TODO List Sync
-If TODO_LIST.md exists, synchronizes:
-- New subtasks (with [ ] checkbox)
-- Modified tasks (marked as updated)
-- Removed subtasks (deleted from list)
-
-## Change Documentation
-
-### Change Summary
-Generates brief change log with:
-- Version increment (1.1 → 1.2)
-- Input source and reason
-- Key modifications made
-- Files updated/created
-- Backup location
-
-## Session Updates
-
-Updates workflow-session.json with:
-- Modified task tracking
-- Task count changes (if subtasks added/removed)
-- Last modification timestamps
-
-## Rollback Support
-
-```bash
-/task:replan IMPL-1 --rollback v1.1
-
-Rollback to version 1.1:
-- Restore task from backup/.../IMPL-1-v1.1.json
-- Remove new subtasks if any
-- Update session stats
-
-# Use AskUserQuestion for confirmation
-AskUserQuestion({
-  questions: [{
-    question: "Are you sure you want to roll back this task to a previous version?",
-    header: "Confirm",
-    options: [
-      { label: "Yes, rollback", description: "Restore the task from the selected backup." },
-      { label: "No, cancel", description: "Keep the current version of the task." }
-    ],
-    multiSelect: false
-  }]
-})
-
-User selected: "Yes, rollback"
-
-Task rolled back to version 1.1
-```
-
-## Batch Processing with TodoWrite
-
-### Progress Tracking
-When processing multiple tasks, automatically creates TodoWrite task list:
-
-```markdown
-**Batch Replan Progress**:
-- [x] IMPL-002: Add FR-12 draft saving acceptance criteria
-- [x] IMPL-003: Add FR-14 history tracking acceptance criteria
-- [ ] IMPL-004: Add FR-09 response surface explicit coverage
-- [ ] IMPL-008: Add NFR performance validation steps
-```
-
-### Batch Report
-After completion, generates summary:
-```markdown
-## Batch Replan Summary
-
-**Total Tasks**: 4
-**Successful**: 3
-**Failed**: 1
-**Skipped**: 0
-
-### Changes Made
-- IMPL-002 v1.0 → v1.1: Added FR-12 acceptance criteria
-- IMPL-003 v1.0 → v1.1: Added FR-14 acceptance criteria
-- IMPL-004 v1.0 → v1.1: Added FR-09 explicit coverage
-
-### Backups Created
-- .task/backup/IMPL-002-v1.0.json
-- .task/backup/IMPL-003-v1.0.json
-- .task/backup/IMPL-004-v1.0.json
-
-### Errors
-- IMPL-008: File not found (task may have been renamed)
-```
-
-## Examples
-
-### Single Task - Text Input
-```bash
-/task:replan IMPL-1 "Add OAuth2 authentication support"
-
-Processing changes...
-Proposed updates:
-+ Add OAuth2 integration
-+ Update authentication flow
-
-# Use AskUserQuestion for confirmation
-AskUserQuestion({
-  questions: [{
-    question: "Do you want to apply these changes to the task?",
-    header: "Apply",
-    options: [
-      { label: "Yes, apply", description: "Create new version with these changes." },
-      { label: "No, cancel", description: "Discard changes and keep current version." }
-    ],
-    multiSelect: false
-  }]
-})
-
-User selected: "Yes, apply"
-
-Version 1.2 created
-Context updated
-Backup saved to .task/backup/IMPL-1-v1.1.json
-```
-
-### Single Task - File Input
-```bash
-/task:replan IMPL-2 requirements.md
-
-Loading requirements.md...
-Applying specification changes...
-
-Task updated with new requirements
-Version 1.1 created
-Backup saved to .task/backup/IMPL-2-v1.0.json
-```
-
-### Batch Mode - From Verification Report
-```bash
-/task:replan --batch .workflow/active/WFS-{session}/.process/ACTION_PLAN_VERIFICATION.md
-
-Parsing verification report...
-Found 4 tasks requiring replanning:
-- IMPL-002: Add FR-12 draft saving acceptance criteria
-- IMPL-003: Add FR-14 history tracking acceptance criteria
-- IMPL-004: Add FR-09 response surface explicit coverage
-- IMPL-008: Add NFR performance validation steps
-
-Creating task tracking list...
-
-Processing IMPL-002...
-Backup created: .task/backup/IMPL-002-v1.0.json
-Updated to v1.1
-
-Processing IMPL-003...
-Backup created: .task/backup/IMPL-003-v1.0.json
-Updated to v1.1
-
-Processing IMPL-004...
-Backup created: .task/backup/IMPL-004-v1.0.json
-Updated to v1.1
-
-Processing IMPL-008...
-Backup created: .task/backup/IMPL-008-v1.0.json
-Updated to v1.1
-
-Batch replan completed: 4/4 successful
-Summary report saved
-```
-
-### Batch Mode - Auto-detection
-```bash
-# If file contains "Action Plan Verification Report", auto-enters batch mode
-/task:replan ACTION_PLAN_VERIFICATION.md
-
-Detected verification report format
-Entering batch mode...
-[same as above]
-```
-
-## Error Handling
-
-### Single Task Errors
-```bash
-# Task not found
-Task IMPL-5 not found
-Check task ID with /workflow:status
-
-# Task completed
-Task IMPL-1 is completed (cannot replan)
-Create new task for additional work
-
-# File not found
-File requirements.md not found
-Check file path
-
-# No input provided
-Please specify changes needed
-Provide text, file, or verification report
-```
-
-### Batch Mode Errors
-```bash
-# Invalid verification report
-File does not contain valid verification report format
-Check report structure or use single task mode
-
-# Partial failures
-Batch completed with errors: 3/4 successful
-Review error details in summary report
-
-# No replan recommendations found
-Verification report contains no replan recommendations
-Check report content or use /workflow:action-plan-verify first
-```
-
-## Batch Mode Integration
-
-### Input Format Expectations
-Batch mode parses verification reports looking for:
-
-1. **Required Actions Section**: Commands like `/task:replan IMPL-X "changes"`
-2. **Findings Table**: Task IDs with recommendations
-3. **Next Actions Section**: Specific replan commands
-
-**Example Patterns**:
-```markdown
-#### 1. HIGH Priority - Address FR Coverage Gaps
-/task:replan IMPL-004 "
-Add explicit acceptance criteria:
-- FR-09: Response surface 3D visualization
-"
-
-#### 2. MEDIUM Priority - Enhance NFR Coverage
-/task:replan IMPL-008 "
-Add performance testing:
-- NFR-01: Load test API endpoints
-"
-```
-
-### Extraction Logic
-1. Scan for `/task:replan` commands in report
-2. Extract task ID and change description
-3. Group by priority (HIGH, MEDIUM, LOW)
-4. Process in priority order with TodoWrite tracking
-
-### Confirmation Behavior
-- **Default**: Confirm each task before applying
-- **With `--auto-confirm`**: Apply all changes without prompting
-  ```bash
-  /task:replan --batch report.md --auto-confirm
-  ```
-
-## Implementation Details
-
-### Backup Management
-```typescript
-// Backup file naming convention
-const backupPath = `.task/backup/${taskId}-v${previousVersion}.json`;
-
-// Backup metadata in task JSON
-{
-  "replan_history": [
-    {
-      "version": "1.2",
-      "timestamp": "2025-10-17T10:30:00Z",
-      "reason": "Add FR-09 explicit coverage",
-      "input_source": "batch_verification_report",
-      "backup_location": ".task/backup/IMPL-004-v1.1.json"
-    }
-  ]
-}
-```
-
-### TodoWrite Integration
-```typescript
-// Initialize tracking for batch mode
-TodoWrite({
-  todos: taskList.map(task => ({
-    content: `${task.id}: ${task.changeDescription}`,
-    status: "pending",
-    activeForm: `Replanning ${task.id}`
-  }))
-});
-
-// Update progress during processing
-TodoWrite({
-  todos: updateTaskStatus(taskId, "in_progress")
-});
-
-// Mark completed
-TodoWrite({
-  todos: updateTaskStatus(taskId, "completed")
-});
-```

.claude/commands/version.md

@@ -1,254 +0,0 @@
----
-name: version
-description: Display Claude Code version information and check for updates
-allowed-tools: Bash(*)
----
-
-# Version Command (/version)
-
-## Purpose
-Display local and global installation versions, check for the latest updates from GitHub, and provide upgrade recommendations.
-
-## Execution Flow
-1. **Local Version Check**: Read version information from `./.claude/version.json` if it exists.
-2. **Global Version Check**: Read version information from `~/.claude/version.json` if it exists.
-3. **Fetch Remote Versions**: Use GitHub API to get the latest stable release tag and the latest commit hash from the main branch.
-4. **Compare & Suggest**: Compare installed versions with the latest remote versions and provide upgrade suggestions if applicable.
-
-## Step 1: Check Local Version
-
-### Check if local version.json exists
-```bash
-bash(test -f ./.claude/version.json && echo "found" || echo "not_found")
-```
-
-### Read local version (if exists)
-```bash
-bash(cat ./.claude/version.json)
-```
-
-### Extract version with jq (preferred)
-```bash
-bash(cat ./.claude/version.json | grep -o '"version": *"[^"]*"' | cut -d'"' -f4)
-```
-
-### Extract installation date
-```bash
-bash(cat ./.claude/version.json | grep -o '"installation_date_utc": *"[^"]*"' | cut -d'"' -f4)
-```
-
-**Output Format**:
-```
-Local Version: 3.2.1
-Installed: 2025-10-03T12:00:00Z
-```
-
-## Step 2: Check Global Version
-
-### Check if global version.json exists
-```bash
-bash(test -f ~/.claude/version.json && echo "found" || echo "not_found")
-```
-
-### Read global version
-```bash
-bash(cat ~/.claude/version.json)
-```
-
-### Extract version
-```bash
-bash(cat ~/.claude/version.json | grep -o '"version": *"[^"]*"' | cut -d'"' -f4)
-```
-
-### Extract installation date
-```bash
-bash(cat ~/.claude/version.json | grep -o '"installation_date_utc": *"[^"]*"' | cut -d'"' -f4)
-```
-
-**Output Format**:
-```
-Global Version: 3.2.1
-Installed: 2025-10-03T12:00:00Z
-```
-
-## Step 3: Fetch Latest Stable Release
-
-### Call GitHub API for latest release (with timeout)
-```bash
-bash(curl -fsSL "https://api.github.com/repos/catlog22/Claude-Code-Workflow/releases/latest" 2>/dev/null, timeout: 30000)
-```
-
-### Extract tag name (version)
-```bash
-bash(curl -fsSL "https://api.github.com/repos/catlog22/Claude-Code-Workflow/releases/latest" 2>/dev/null | grep -o '"tag_name": *"[^"]*"' | head -1 | cut -d'"' -f4, timeout: 30000)
-```
-
-### Extract release name
-```bash
-bash(curl -fsSL "https://api.github.com/repos/catlog22/Claude-Code-Workflow/releases/latest" 2>/dev/null | grep -o '"name": *"[^"]*"' | head -1 | cut -d'"' -f4, timeout: 30000)
-```
-
-### Extract published date
-```bash
-bash(curl -fsSL "https://api.github.com/repos/catlog22/Claude-Code-Workflow/releases/latest" 2>/dev/null | grep -o '"published_at": *"[^"]*"' | cut -d'"' -f4, timeout: 30000)
-```
-
-**Output Format**:
-```
-Latest Stable: v3.2.2
-Release: v3.2.2: Independent Test-Gen Workflow with Cross-Session Context
-Published: 2025-10-03T04:10:08Z
-```
-
-## Step 4: Fetch Latest Main Branch
-
-### Call GitHub API for latest commit on main (with timeout)
-```bash
-bash(curl -fsSL "https://api.github.com/repos/catlog22/Claude-Code-Workflow/commits/main" 2>/dev/null, timeout: 30000)
-```
-
-### Extract commit SHA (short)
-```bash
-bash(curl -fsSL "https://api.github.com/repos/catlog22/Claude-Code-Workflow/commits/main" 2>/dev/null | grep -o '"sha": *"[^"]*"' | head -1 | cut -d'"' -f4 | cut -c1-7, timeout: 30000)
-```
-
-### Extract commit message (first line only)
-```bash
-bash(curl -fsSL "https://api.github.com/repos/catlog22/Claude-Code-Workflow/commits/main" 2>/dev/null | grep '"message":' | cut -d'"' -f4 | cut -d'\' -f1, timeout: 30000)
-```
-
-### Extract commit date
-```bash
-bash(curl -fsSL "https://api.github.com/repos/catlog22/Claude-Code-Workflow/commits/main" 2>/dev/null | grep -o '"date": *"[^"]*"' | head -1 | cut -d'"' -f4, timeout: 30000)
-```
-
-**Output Format**:
-```
-Latest Dev: a03415b
-Message: feat: Add version tracking and upgrade check system
-Date: 2025-10-03T04:46:44Z
-```
-
-## Step 5: Compare Versions and Suggest Upgrade
-
-### Normalize versions (remove 'v' prefix)
-```bash
-bash(echo "v3.2.1" | sed 's/^v//')
-```
-
-### Compare two versions
-```bash
-bash(printf "%s\n%s" "3.2.1" "3.2.2" | sort -V | tail -n 1)
-```
-
-### Check if versions are equal
-```bash
-# If equal: Up to date
-# If remote newer: Upgrade available
-# If local newer: Development version
-```
-
-**Output Scenarios**:
-
-**Scenario 1: Up to date**
-```
-You are on the latest stable version (3.2.1)
-```
-
-**Scenario 2: Upgrade available**
-```
-A newer stable version is available: v3.2.2
-Your version: 3.2.1
-
-To upgrade:
-PowerShell: iex (iwr -useb https://raw.githubusercontent.com/catlog22/Claude-Code-Workflow/main/install-remote.ps1)
-Bash: bash <(curl -fsSL https://raw.githubusercontent.com/catlog22/Claude-Code-Workflow/main/install-remote.sh)
-```
-
-**Scenario 3: Development version**
-```
-You are running a development version (3.4.0-dev)
-This is newer than the latest stable release (v3.3.0)
-```
-
-## Simple Bash Commands
-
-### Basic Operations
-```bash
-# Check local version file
-bash(test -f ./.claude/version.json && cat ./.claude/version.json)
-
-# Check global version file
-bash(test -f ~/.claude/version.json && cat ~/.claude/version.json)
-
-# Extract version from JSON
-bash(cat version.json | grep -o '"version": *"[^"]*"' | cut -d'"' -f4)
-
-# Extract date from JSON
-bash(cat version.json | grep -o '"installation_date_utc": *"[^"]*"' | cut -d'"' -f4)
-
-# Fetch latest release (with timeout)
-bash(curl -fsSL "https://api.github.com/repos/catlog22/Claude-Code-Workflow/releases/latest" 2>/dev/null, timeout: 30000)
-
-# Extract tag name
-bash(curl -fsSL "https://api.github.com/repos/catlog22/Claude-Code-Workflow/releases/latest" 2>/dev/null | grep -o '"tag_name": *"[^"]*"' | cut -d'"' -f4, timeout: 30000)
-
-# Extract release name
-bash(curl -fsSL "https://api.github.com/repos/catlog22/Claude-Code-Workflow/releases/latest" 2>/dev/null | grep -o '"name": *"[^"]*"' | head -1 | cut -d'"' -f4, timeout: 30000)
-
-# Fetch latest commit (with timeout)
-bash(curl -fsSL "https://api.github.com/repos/catlog22/Claude-Code-Workflow/commits/main" 2>/dev/null, timeout: 30000)
-
-# Extract commit SHA
-bash(curl -fsSL "https://api.github.com/repos/catlog22/Claude-Code-Workflow/commits/main" 2>/dev/null | grep -o '"sha": *"[^"]*"' | head -1 | cut -d'"' -f4 | cut -c1-7, timeout: 30000)
-
-# Extract commit message (first line)
-bash(curl -fsSL "https://api.github.com/repos/catlog22/Claude-Code-Workflow/commits/main" 2>/dev/null | grep '"message":' | cut -d'"' -f4 | cut -d'\' -f1, timeout: 30000)
-
-# Compare versions
-bash(printf "%s\n%s" "3.2.1" "3.2.2" | sort -V | tail -n 1)
-
-# Remove 'v' prefix
-bash(echo "v3.2.1" | sed 's/^v//')
-```
-
-## Error Handling
-
-### No installation found
-```
-WARNING: Claude Code Workflow not installed
-Install using:
-PowerShell: iex (iwr -useb https://raw.githubusercontent.com/catlog22/Claude-Code-Workflow/main/install-remote.ps1)
-```
-
-### Network error
-```
-ERROR: Could not fetch latest version from GitHub
-Check your network connection
-```
-
-### Invalid version.json
-```
-ERROR: version.json is invalid or corrupted
-```
-
-## Design Notes
-
-- Uses simple, direct bash commands instead of complex functions
-- Each step is independent and can be executed separately
-- Fallback to grep/sed for JSON parsing (no jq dependency required)
-- Network calls use curl with error suppression and 30-second timeout
-- Version comparison uses `sort -V` for accurate semantic versioning
-- Use `/commits/main` API instead of `/branches/main` for more reliable commit info
-- Extract first line of commit message using `cut -d'\' -f1` to handle JSON escape sequences
-
-## API Endpoints
-
-### GitHub API Used
-- **Latest Release**: `https://api.github.com/repos/catlog22/Claude-Code-Workflow/releases/latest`
-  - Fields: `tag_name`, `name`, `published_at`
-- **Latest Commit**: `https://api.github.com/repos/catlog22/Claude-Code-Workflow/commits/main`
-  - Fields: `sha`, `commit.message`, `commit.author.date`
-
-### Timeout Configuration
-All network calls should use `timeout: 30000` (30 seconds) to handle slow connections.

.claude/commands/view.md

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

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

@@ -1,447 +0,0 @@
----
-name: action-plan-verify
-description: Perform non-destructive cross-artifact consistency analysis between IMPL_PLAN.md and task JSONs with quality gate validation
-argument-hint: "[optional: --session session-id]"
-allowed-tools: Read(*), TodoWrite(*), Glob(*), Bash(*)
----
-
-## User Input
-
-```text
-$ARGUMENTS
-```
-
-You **MUST** consider the user input before proceeding (if not empty).
-
-## Goal
-
-Identify inconsistencies, duplications, ambiguities, and underspecified items between action planning artifacts (`IMPL_PLAN.md`, `task.json`) and brainstorming artifacts (`role analysis documents`) before implementation. This command MUST run only after `/workflow:plan` has successfully produced complete `IMPL_PLAN.md` and task JSON files.
-
-## Operating Constraints
-
-**STRICTLY READ-ONLY**: Do **not** modify any files. Output a structured analysis report. Offer an optional remediation plan (user must explicitly approve before any follow-up editing commands).
-
-**Synthesis Authority**: The `role analysis documents` is **authoritative** for requirements and design decisions. Any conflicts between IMPL_PLAN/tasks and synthesis are automatically CRITICAL and require adjustment of the plan/tasks—not reinterpretation of requirements.
-
-## Execution Steps
-
-### 1. Initialize Analysis Context
-
-```bash
-# Detect active workflow session
-IF --session parameter provided:
-    session_id = provided session
-ELSE:
-    # Auto-detect active session
-    active_sessions = bash(find .workflow/active/ -name "WFS-*" -type d 2>/dev/null)
-    IF active_sessions is empty:
-        ERROR: "No active workflow session found. Use --session <session-id>"
-        EXIT
-    ELSE IF active_sessions has multiple entries:
-        # Use most recently modified session
-        session_id = bash(ls -td .workflow/active/WFS-*/ 2>/dev/null | head -1 | xargs basename)
-    ELSE:
-        session_id = basename(active_sessions[0])
-
-# Derive absolute paths
-session_dir = .workflow/active/WFS-{session}
-brainstorm_dir = session_dir/.brainstorming
-task_dir = session_dir/.task
-
-# Validate required artifacts
-# Note: "role analysis documents" refers to [role]/analysis.md files (e.g., product-manager/analysis.md)
-SYNTHESIS_DIR = brainstorm_dir  # Contains role analysis files: */analysis.md
-IMPL_PLAN = session_dir/IMPL_PLAN.md
-TASK_FILES = Glob(task_dir/*.json)
-
-# Abort if missing
-SYNTHESIS_FILES = Glob(brainstorm_dir/*/analysis.md)
-IF SYNTHESIS_FILES.count == 0:
-    ERROR: "No role analysis documents found in .brainstorming/*/analysis.md. Run /workflow:brainstorm:synthesis first"
-    EXIT
-
-IF NOT EXISTS(IMPL_PLAN):
-    ERROR: "IMPL_PLAN.md not found. Run /workflow:plan first"
-    EXIT
-
-IF TASK_FILES.count == 0:
-    ERROR: "No task JSON files found. Run /workflow:plan first"
-    EXIT
-```
-
-### 2. Load Artifacts (Progressive Disclosure)
-
-Load only minimal necessary context from each artifact:
-
-**From workflow-session.json** (NEW - PRIMARY REFERENCE):
-- Original user prompt/intent (project or description field)
-- User's stated goals and objectives
-- User's scope definition
-
-**From role analysis documents**:
-- Functional Requirements (IDs, descriptions, acceptance criteria)
-- Non-Functional Requirements (IDs, targets)
-- Business Requirements (IDs, success metrics)
-- Key Architecture Decisions
-- Risk factors and mitigation strategies
-- Implementation Roadmap (high-level phases)
-
-**From IMPL_PLAN.md**:
-- Summary and objectives
-- Context Analysis
-- Implementation Strategy
-- Task Breakdown Summary
-- Success Criteria
-- Brainstorming Artifacts References (if present)
-
-**From task.json files**:
-- Task IDs
-- Titles and descriptions
-- Status
-- Dependencies (depends_on, blocks)
-- Context (requirements, focus_paths, acceptance, artifacts)
-- Flow control (pre_analysis, implementation_approach)
-- Meta (complexity, priority)
-
-### 3. Build Semantic Models
-
-Create internal representations (do not include raw artifacts in output):
-
-**Requirements inventory**:
-- Each functional/non-functional/business requirement with stable ID
-- Requirement text, acceptance criteria, priority
-
-**Architecture decisions inventory**:
-- ADRs from synthesis
-- Technology choices
-- Data model references
-
-**Task coverage mapping**:
-- Map each task to one or more requirements (by ID reference or keyword inference)
-- Map each requirement to covering tasks
-
-**Dependency graph**:
-- Task-to-task dependencies (depends_on, blocks)
-- Requirement-level dependencies (from synthesis)
-
-### 4. Detection Passes (Token-Efficient Analysis)
-
-Focus on high-signal findings. Limit to 50 findings total; aggregate remainder in overflow summary.
-
-#### A. User Intent Alignment (NEW - CRITICAL)
-
-- **Goal Alignment**: IMPL_PLAN objectives match user's original intent
-- **Scope Drift**: Plan covers user's stated scope without unauthorized expansion
-- **Success Criteria Match**: Plan's success criteria reflect user's expectations
-- **Intent Conflicts**: Tasks contradicting user's original objectives
-
-#### B. Requirements Coverage Analysis
-
-- **Orphaned Requirements**: Requirements in synthesis with zero associated tasks
-- **Unmapped Tasks**: Tasks with no clear requirement linkage
-- **NFR Coverage Gaps**: Non-functional requirements (performance, security, scalability) not reflected in tasks
-
-#### C. Consistency Validation
-
-- **Requirement Conflicts**: Tasks contradicting synthesis requirements
-- **Architecture Drift**: IMPL_PLAN architecture not matching synthesis ADRs
-- **Terminology Drift**: Same concept named differently across IMPL_PLAN and tasks
-- **Data Model Inconsistency**: Tasks referencing entities/fields not in synthesis data model
-
-#### D. Dependency Integrity
-
-- **Circular Dependencies**: Task A depends on B, B depends on C, C depends on A
-- **Missing Dependencies**: Task requires outputs from another task but no explicit dependency
-- **Broken Dependencies**: Task depends on non-existent task ID
-- **Logical Ordering Issues**: Implementation tasks before foundational setup without dependency note
-
-#### E. Synthesis Alignment
-
-- **Priority Conflicts**: High-priority synthesis requirements mapped to low-priority tasks
-- **Success Criteria Mismatch**: IMPL_PLAN success criteria not covering synthesis acceptance criteria
-- **Risk Mitigation Gaps**: Critical risks in synthesis without corresponding mitigation tasks
-
-#### F. Task Specification Quality
-
-- **Ambiguous Focus Paths**: Tasks with vague or missing focus_paths
-- **Underspecified Acceptance**: Tasks without clear acceptance criteria
-- **Missing Artifacts References**: Tasks not referencing relevant brainstorming artifacts in context.artifacts
-- **Weak Flow Control**: Tasks without clear implementation_approach or pre_analysis steps
-- **Missing Target Files**: Tasks without flow_control.target_files specification
-
-#### G. Duplication Detection
-
-- **Overlapping Task Scope**: Multiple tasks with nearly identical descriptions
-- **Redundant Requirements Coverage**: Same requirement covered by multiple tasks without clear partitioning
-
-#### H. Feasibility Assessment
-
-- **Complexity Misalignment**: Task marked "simple" but requires multiple file modifications
-- **Resource Conflicts**: Parallel tasks requiring same resources/files
-- **Skill Gap Risks**: Tasks requiring skills not in team capability assessment (from synthesis)
-
-### 5. Severity Assignment
-
-Use this heuristic to prioritize findings:
-
-- **CRITICAL**:
-  - Violates user's original intent (goal misalignment, scope drift)
-  - Violates synthesis authority (requirement conflict)
-  - Core requirement with zero coverage
-  - Circular dependencies
-  - Broken dependencies
-
-- **HIGH**:
-  - NFR coverage gaps
-  - Priority conflicts
-  - Missing risk mitigation tasks
-  - Ambiguous acceptance criteria
-
-- **MEDIUM**:
-  - Terminology drift
-  - Missing artifacts references
-  - Weak flow control
-  - Logical ordering issues
-
-- **LOW**:
-  - Style/wording improvements
-  - Minor redundancy not affecting execution
-
-### 6. Produce Compact Analysis Report
-
-**Report Generation**: Generate report content and save to file.
-
-Output a Markdown report with the following structure:
-
-```markdown
-## Action Plan Verification Report
-
-**Session**: WFS-{session-id}
-**Generated**: {timestamp}
-**Artifacts Analyzed**: role analysis documents, IMPL_PLAN.md, {N} task files
-
----
-
-### Executive Summary
-
-- **Overall Risk Level**: CRITICAL | HIGH | MEDIUM | LOW
-- **Recommendation**: (See decision matrix below)
-  - BLOCK_EXECUTION: Critical issues exist (must fix before proceeding)
-  - PROCEED_WITH_FIXES: High issues exist, no critical (fix recommended before execution)
-  - PROCEED_WITH_CAUTION: Medium issues only (proceed with awareness)
-  - PROCEED: Low issues only or no issues (safe to execute)
-- **Critical Issues**: {count}
-- **High Issues**: {count}
-- **Medium Issues**: {count}
-- **Low Issues**: {count}
-
----
-
-### Findings Summary
-
-| ID | Category | Severity | Location(s) | Summary | Recommendation |
-|----|----------|----------|-------------|---------|----------------|
-| C1 | Coverage | CRITICAL | synthesis:FR-03 | Requirement "User auth" has zero task coverage | Add authentication implementation task |
-| H1 | Consistency | HIGH | IMPL-1.2 vs synthesis:ADR-02 | Task uses REST while synthesis specifies GraphQL | Align task with ADR-02 decision |
-| M1 | Specification | MEDIUM | IMPL-2.1 | Missing context.artifacts reference | Add @synthesis reference |
-| L1 | Duplication | LOW | IMPL-3.1, IMPL-3.2 | Similar scope | Consider merging |
-
-(Add one row per finding; generate stable IDs prefixed by severity initial.)
-
----
-
-### Requirements Coverage Analysis
-
-| Requirement ID | Requirement Summary | Has Task? | Task IDs | Priority Match | Notes |
-|----------------|---------------------|-----------|----------|----------------|-------|
-| FR-01 | User authentication | Yes | IMPL-1.1, IMPL-1.2 | Match | Complete |
-| FR-02 | Data export | Yes | IMPL-2.3 | Mismatch | High req → Med priority task |
-| FR-03 | Profile management | No | - | - | **CRITICAL: Zero coverage** |
-| NFR-01 | Response time <200ms | No | - | - | **HIGH: No performance tasks** |
-
-**Coverage Metrics**:
-- Functional Requirements: 85% (17/20 covered)
-- Non-Functional Requirements: 40% (2/5 covered)
-- Business Requirements: 100% (5/5 covered)
-
----
-
-### Unmapped Tasks
-
-| Task ID | Title | Issue | Recommendation |
-|---------|-------|-------|----------------|
-| IMPL-4.5 | Refactor utils | No requirement linkage | Link to technical debt or remove |
-
----
-
-### Dependency Graph Issues
-
-**Circular Dependencies**: None detected
-
-**Broken Dependencies**:
-- IMPL-2.3 depends on "IMPL-2.4" (non-existent)
-
-**Logical Ordering Issues**:
-- IMPL-5.1 (integration test) has no dependency on IMPL-1.* (implementation tasks)
-
----
-
-### Synthesis Alignment Issues
-
-| Issue Type | Synthesis Reference | IMPL_PLAN/Task | Impact | Recommendation |
-|------------|---------------------|----------------|--------|----------------|
-| Architecture Conflict | synthesis:ADR-01 (JWT auth) | IMPL_PLAN uses session cookies | HIGH | Update IMPL_PLAN to use JWT |
-| Priority Mismatch | synthesis:FR-02 (High) | IMPL-2.3 (Medium) | MEDIUM | Elevate task priority |
-| Missing Risk Mitigation | synthesis:Risk-03 (API rate limits) | No mitigation tasks | HIGH | Add rate limiting implementation task |
-
----
-
-### Task Specification Quality Issues
-
-**Missing Artifacts References**: 12 tasks lack context.artifacts
-**Weak Flow Control**: 5 tasks lack implementation_approach
-**Missing Target Files**: 8 tasks lack flow_control.target_files
-
-**Sample Issues**:
-- IMPL-1.2: No context.artifacts reference to synthesis
-- IMPL-3.1: Missing flow_control.target_files specification
-- IMPL-4.2: Vague focus_paths ["src/"] - needs refinement
-
----
-
-### Feasibility Concerns
-
-| Concern | Tasks Affected | Issue | Recommendation |
-|---------|----------------|-------|----------------|
-| Skill Gap | IMPL-6.1, IMPL-6.2 | Requires Kubernetes expertise not in team | Add training task or external consultant |
-| Resource Conflict | IMPL-3.1, IMPL-3.2 | Both modify src/auth/service.ts in parallel | Add dependency or serialize |
-
----
-
-### Metrics
-
-- **Total Requirements**: 30 (20 functional, 5 non-functional, 5 business)
-- **Total Tasks**: 25
-- **Overall Coverage**: 77% (23/30 requirements with ≥1 task)
-- **Critical Issues**: 2
-- **High Issues**: 5
-- **Medium Issues**: 8
-- **Low Issues**: 3
-
----
-
-### Next Actions
-
-#### Action Recommendations
-
-**Recommendation Decision Matrix**:
-
-| Condition | Recommendation | Action |
-|-----------|----------------|--------|
-| Critical > 0 | BLOCK_EXECUTION | Must resolve all critical issues before proceeding |
-| Critical = 0, High > 0 | PROCEED_WITH_FIXES | Fix high-priority issues before execution |
-| Critical = 0, High = 0, Medium > 0 | PROCEED_WITH_CAUTION | Proceed with awareness of medium issues |
-| Only Low or None | PROCEED | Safe to execute workflow |
-
-**If CRITICAL Issues Exist** (BLOCK_EXECUTION):
-- Resolve all critical issues before proceeding
-- Use TodoWrite to track required fixes
-- Fix broken dependencies and circular references first
-
-**If HIGH Issues Exist** (PROCEED_WITH_FIXES):
-- Fix high-priority issues before execution
-- Use TodoWrite to systematically track and complete improvements
-
-**If Only MEDIUM/LOW Issues** (PROCEED_WITH_CAUTION / PROCEED):
-- Can proceed with execution
-- Address issues during or after implementation
-
-#### TodoWrite-Based Remediation Workflow
-
-**Report Location**: `.workflow/active/WFS-{session}/.process/ACTION_PLAN_VERIFICATION.md`
-
-**Recommended Workflow**:
-1. **Create TodoWrite Task List**: Extract all findings from report
-2. **Process by Priority**: CRITICAL → HIGH → MEDIUM → LOW
-3. **Complete Each Fix**: Mark tasks as in_progress/completed as you work
-4. **Validate Changes**: Verify each modification against requirements
-
-**TodoWrite Task Structure Example**:
-```markdown
-Priority Order:
-1. Fix coverage gaps (CRITICAL)
-2. Resolve consistency conflicts (CRITICAL/HIGH)
-3. Add missing specifications (MEDIUM)
-4. Improve task quality (LOW)
-```
-
-**Notes**:
-- TodoWrite provides real-time progress tracking
-- Each finding becomes a trackable todo item
-- User can monitor progress throughout remediation
-- Architecture drift in IMPL_PLAN requires manual editing
-```
-
-### 7. Save Report and Execute TodoWrite-Based Remediation
-
-**Step 7.1: Save Analysis Report**:
-```bash
-report_path = ".workflow/active/WFS-{session}/.process/ACTION_PLAN_VERIFICATION.md"
-Write(report_path, full_report_content)
-```
-
-**Step 7.2: Display Report Summary to User**:
-- Show executive summary with counts
-- Display recommendation (BLOCK/PROCEED_WITH_FIXES/PROCEED_WITH_CAUTION/PROCEED)
-- List critical and high issues if any
-
-**Step 7.3: After Report Generation**:
-
-1. **Extract Findings**: Parse all issues by severity
-2. **Create TodoWrite Task List**: Convert findings to actionable todos
-3. **Execute Fixes**: Process each todo systematically
-4. **Update Task Files**: Apply modifications directly to task JSON files
-5. **Update IMPL_PLAN**: Apply strategic changes if needed
-
-At end of report, provide remediation guidance:
-
-```markdown
-### 🔧 Remediation Workflow
-
-**Recommended Approach**:
-1. **Initialize TodoWrite**: Create comprehensive task list from all findings
-2. **Process by Severity**: Start with CRITICAL, then HIGH, MEDIUM, LOW
-3. **Apply Fixes Directly**: Modify task.json files and IMPL_PLAN.md as needed
-4. **Track Progress**: Mark todos as completed after each fix
-
-**TodoWrite Execution Pattern**:
-```bash
-# Step 1: Create task list from verification report
-TodoWrite([
-  { content: "Fix FR-03 coverage gap - add authentication task", status: "pending", activeForm: "Fixing FR-03 coverage gap" },
-  { content: "Fix IMPL-1.2 consistency - align with ADR-02", status: "pending", activeForm: "Fixing IMPL-1.2 consistency" },
-  { content: "Add context.artifacts to IMPL-1.2", status: "pending", activeForm: "Adding context.artifacts to IMPL-1.2" },
-  # ... additional todos for each finding
-])
-
-# Step 2: Process each todo systematically
-# Mark as in_progress when starting
-# Apply fix using Read/Edit tools
-# Mark as completed when done
-# Move to next priority item
-```
-
-**File Modification Workflow**:
-```bash
-# For task JSON modifications:
-1. Read(.workflow/active/WFS-{session}/.task/IMPL-X.Y.json)
-2. Edit() to apply fixes
-3. Mark todo as completed
-
-# For IMPL_PLAN modifications:
-1. Read(.workflow/active/WFS-{session}/IMPL_PLAN.md)
-2. Edit() to apply strategic changes
-3. Mark todo as completed
-```
-
-**Note**: All fixes execute immediately after user confirmation without additional commands.

.claude/commands/workflow/analyze-with-file.md

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

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

@@ -1,587 +0,0 @@
----
-name: api-designer
-description: Generate or update api-designer/analysis.md addressing guidance-specification discussion points for API design perspective
-argument-hint: "optional topic - uses existing framework if available"
-allowed-tools: Task(conceptual-planning-agent), TodoWrite(*), Read(*), Write(*)
----
-
-## 🔌 **API Designer Analysis Generator**
-
-### Purpose
-**Specialized command for generating api-designer/analysis.md** that addresses guidance-specification.md discussion points from backend API design perspective. Creates or updates role-specific analysis with framework references.
-
-### Core Function
-- **Framework-based Analysis**: Address each discussion point in guidance-specification.md
-- **API Design Focus**: RESTful/GraphQL API design, endpoint structure, and contract definition
-- **Update Mechanism**: Create new or update existing analysis.md
-- **Agent Delegation**: Use conceptual-planning-agent for analysis generation
-
-### Analysis Scope
-- **API Architecture**: RESTful/GraphQL design patterns and best practices
-- **Endpoint Design**: Resource modeling, URL structure, and HTTP method selection
-- **Data Contracts**: Request/response schemas, validation rules, and data transformation
-- **API Documentation**: OpenAPI/Swagger specifications and developer experience
-
-### Role Boundaries & Responsibilities
-
-#### **What This Role OWNS (API Contract Within Architectural Framework)**
-- **API Contract Definition**: Specific endpoint paths, HTTP methods, and status codes
-- **Resource Modeling**: Mapping domain entities to RESTful resources or GraphQL types
-- **Request/Response Schemas**: Detailed data contracts, validation rules, and error formats
-- **API Versioning Strategy**: Version management, deprecation policies, and migration paths
-- **Developer Experience**: API documentation (OpenAPI/Swagger), code examples, and SDKs
-
-#### **What This Role DOES NOT Own (Defers to Other Roles)**
-- **System Architecture Decisions**: Microservices vs monolithic, overall communication patterns → Defers to **System Architect**
-- **Canonical Data Model**: Underlying data schemas and entity relationships → Defers to **Data Architect**
-- **UI/Frontend Integration**: How clients consume the API → Defers to **UI Designer**
-
-#### **Handoff Points**
-- **FROM System Architect**: Receives architectural constraints (REST vs GraphQL, sync vs async) that define the design space
-- **FROM Data Architect**: Receives canonical data model and translates it into public API data contracts (as projection/view)
-- **TO Frontend Teams**: Provides complete API specifications, documentation, and integration guides
-
-## ⚙️ **Execution Protocol**
-
-### Phase 1: Session & Framework Detection
-```bash
-# Check active session and framework
-CHECK: find .workflow/active/ -name "WFS-*" -type d
-IF active_session EXISTS:
-    session_id = get_active_session()
-    brainstorm_dir = .workflow/active/WFS-{session}/.brainstorming/
-
-    CHECK: brainstorm_dir/guidance-specification.md
-    IF EXISTS:
-        framework_mode = true
-        load_framework = true
-    ELSE:
-        IF topic_provided:
-            framework_mode = false  # Create analysis without framework
-        ELSE:
-            ERROR: "No framework found and no topic provided"
-```
-
-### Phase 2: Analysis Mode Detection
-```bash
-# Check existing analysis
-CHECK: brainstorm_dir/api-designer/analysis.md
-IF EXISTS:
-    SHOW existing analysis summary
-    ASK: "Analysis exists. Do you want to:"
-    OPTIONS:
-      1. "Update with new insights" → Update existing
-      2. "Replace completely" → Generate new
-      3. "Cancel" → Exit without changes
-ELSE:
-    CREATE new analysis
-```
-
-### Phase 3: Agent Task Generation
-**Framework-Based Analysis** (when guidance-specification.md exists):
-```bash
-Task(subagent_type="conceptual-planning-agent",
-     run_in_background=false,
-     prompt="Generate API designer analysis addressing topic framework
-
-     ## Framework Integration Required
-     **MANDATORY**: Load and address guidance-specification.md discussion points
-     **Framework Reference**: @{session.brainstorm_dir}/guidance-specification.md
-     **Output Location**: {session.brainstorm_dir}/api-designer/analysis.md
-
-     ## Analysis Requirements
-     1. **Load Topic Framework**: Read guidance-specification.md completely
-     2. **Address Each Discussion Point**: Respond to all 5 framework sections from API design perspective
-     3. **Include Framework Reference**: Start analysis.md with @../guidance-specification.md
-     4. **API Design Focus**: Emphasize endpoint structure, data contracts, versioning strategies
-     5. **Structured Response**: Use framework structure for analysis organization
-
-     ## Framework Sections to Address
-     - Core Requirements (from API design perspective)
-     - Technical Considerations (detailed API architecture analysis)
-     - User Experience Factors (developer experience and API usability)
-     - Implementation Challenges (API design risks and solutions)
-     - Success Metrics (API performance metrics and adoption tracking)
-
-     ## Output Structure Required
-     ```markdown
-     # API Designer Analysis: [Topic]
-
-     **Framework Reference**: @../guidance-specification.md
-     **Role Focus**: Backend API Design and Contract Definition
-
-     ## Core Requirements Analysis
-     [Address framework requirements from API design perspective]
-
-     ## Technical Considerations
-     [Detailed API architecture and endpoint design analysis]
-
-     ## Developer Experience Factors
-     [API usability, documentation, and integration ease]
-
-     ## Implementation Challenges
-     [API design risks and mitigation strategies]
-
-     ## Success Metrics
-     [API performance metrics, adoption rates, and developer satisfaction]
-
-     ## API Design-Specific Recommendations
-     [Detailed API design recommendations and best practices]
-     ```",
-     description="Generate API designer framework-based analysis")
-```
-
-### Phase 4: Update Mechanism
-**Analysis Update Process**:
-```bash
-# For existing analysis updates
-IF update_mode = "incremental":
-    Task(subagent_type="conceptual-planning-agent",
-         run_in_background=false,
-         prompt="Update existing API designer analysis
-
-         ## Current Analysis Context
-         **Existing Analysis**: @{session.brainstorm_dir}/api-designer/analysis.md
-         **Framework Reference**: @{session.brainstorm_dir}/guidance-specification.md
-
-         ## Update Requirements
-         1. **Preserve Structure**: Maintain existing analysis structure
-         2. **Add New Insights**: Integrate new API design insights and recommendations
-         3. **Framework Alignment**: Ensure continued alignment with topic framework
-         4. **API Updates**: Add new endpoint patterns, versioning strategies, documentation improvements
-         5. **Maintain References**: Keep @../guidance-specification.md reference
-
-         ## Update Instructions
-         - Read existing analysis completely
-         - Identify areas for enhancement or new insights
-         - Add API design depth while preserving original structure
-         - Update recommendations with new API design patterns and approaches
-         - Maintain framework discussion point addressing",
-         description="Update API designer analysis incrementally")
-```
-
-## Document Structure
-
-### Output Files
-```
-.workflow/active/WFS-[topic]/.brainstorming/
-├── guidance-specification.md          # Input: Framework (if exists)
-└── api-designer/
-    └── analysis.md            # ★ OUTPUT: Framework-based analysis
-```
-
-### Analysis Structure
-**Required Elements**:
-- **Framework Reference**: @../guidance-specification.md (if framework exists)
-- **Role Focus**: Backend API Design and Contract Definition perspective
-- **5 Framework Sections**: Address each framework discussion point
-- **API Design Recommendations**: Endpoint-specific insights and solutions
-
-## ⚡ **Two-Step Execution Flow**
-
-### ⚠️ Session Management - FIRST STEP
-Session detection and selection:
-```bash
-# Check for active sessions
-active_sessions=$(find .workflow/active/ -name "WFS-*" -type d 2>/dev/null)
-if [ multiple_sessions ]; then
-  prompt_user_to_select_session()
-else
-  use_existing_or_create_new()
-fi
-```
-
-### Step 1: Context Gathering Phase
-**API Designer Perspective Questioning**
-
-Before agent assignment, gather comprehensive API design context:
-
-#### 📋 Role-Specific Questions
-1. **API Type & Architecture**
-   - RESTful, GraphQL, or hybrid API approach?
-   - Synchronous vs asynchronous communication patterns?
-   - Real-time requirements (WebSocket, Server-Sent Events)?
-
-2. **Resource Modeling & Endpoints**
-   - What are the core domain resources/entities?
-   - Expected CRUD operations for each resource?
-   - Complex query requirements (filtering, sorting, pagination)?
-
-3. **Data Contracts & Validation**
-   - Request/response data format requirements (JSON, XML, Protocol Buffers)?
-   - Input validation and sanitization requirements?
-   - Data transformation and mapping needs?
-
-4. **API Management & Governance**
-   - API versioning strategy requirements?
-   - Authentication and authorization mechanisms?
-   - Rate limiting and throttling requirements?
-   - API documentation and developer portal needs?
-
-5. **Integration & Compatibility**
-   - Client platforms consuming the API (web, mobile, third-party)?
-   - Backward compatibility requirements?
-   - External API integrations needed?
-
-#### Context Validation
-- **Minimum Response**: Each answer must be ≥50 characters
-- **Re-prompting**: Insufficient detail triggers follow-up questions
-- **Context Storage**: Save responses to `.brainstorming/api-designer-context.md`
-
-### Step 2: Agent Assignment with Flow Control
-**Dedicated Agent Execution**
-
-```bash
-Task(conceptual-planning-agent): "
-[FLOW_CONTROL]
-
-Execute dedicated api-designer conceptual analysis for: {topic}
-
-ASSIGNED_ROLE: api-designer
-OUTPUT_LOCATION: .brainstorming/api-designer/
-USER_CONTEXT: {validated_responses_from_context_gathering}
-
-Flow Control Steps:
-[
-  {
-    \"step\": \"load_role_template\",
-    \"action\": \"Load api-designer planning template\",
-    \"command\": \"bash($(cat ~/.claude/workflows/cli-templates/planning-roles/api-designer.md))\",
-    \"output_to\": \"role_template\"
-  }
-]
-
-Conceptual Analysis Requirements:
-- Apply api-designer perspective to topic analysis
-- Focus on endpoint design, data contracts, and API governance
-- Use loaded role template framework for analysis structure
-- Generate role-specific deliverables in designated output location
-- Address all user context from questioning phase
-
-Deliverables:
-- analysis.md: Main API design analysis
-- api-specification.md: Detailed endpoint specifications
-- data-contracts.md: Request/response schemas and validation rules
-- api-documentation.md: API documentation strategy and templates
-
-Embody api-designer role expertise for comprehensive conceptual planning."
-```
-
-### Progress Tracking
-TodoWrite tracking for two-step process:
-```json
-[
-  {"content": "Gather API designer context through role-specific questioning", "status": "in_progress", "activeForm": "Gathering context"},
-  {"content": "Validate context responses and save to api-designer-context.md", "status": "pending", "activeForm": "Validating context"},
-  {"content": "Load api-designer planning template via flow control", "status": "pending", "activeForm": "Loading template"},
-  {"content": "Execute dedicated conceptual-planning-agent for api-designer role", "status": "pending", "activeForm": "Executing agent"}
-]
-```
-
-## 📊 **Output Specification**
-
-### Output Location
-```
-.workflow/active/WFS-{topic-slug}/.brainstorming/api-designer/
-├── analysis.md                 # Primary API design analysis
-├── api-specification.md        # Detailed endpoint specifications (OpenAPI/Swagger)
-├── data-contracts.md           # Request/response schemas and validation rules
-├── versioning-strategy.md      # API versioning and backward compatibility plan
-└── developer-guide.md          # API usage documentation and integration examples
-```
-
-### Document Templates
-
-#### analysis.md Structure
-```markdown
-# API Design Analysis: {Topic}
-*Generated: {timestamp}*
-
-## Executive Summary
-[Key API design findings and recommendations overview]
-
-## API Architecture Overview
-### API Type Selection (REST/GraphQL/Hybrid)
-### Communication Patterns
-### Authentication & Authorization Strategy
-
-## Resource Modeling
-### Core Domain Resources
-### Resource Relationships
-### URL Structure and Naming Conventions
-
-## Endpoint Design
-### Resource Endpoints
-- GET /api/v1/resources
-- POST /api/v1/resources
-- GET /api/v1/resources/{id}
-- PUT /api/v1/resources/{id}
-- DELETE /api/v1/resources/{id}
-
-### Query Parameters
-- Filtering: ?filter[field]=value
-- Sorting: ?sort=field,-field2
-- Pagination: ?page=1&limit=20
-
-### HTTP Methods and Status Codes
-- Success responses (2xx)
-- Client errors (4xx)
-- Server errors (5xx)
-
-## Data Contracts
-### Request Schemas
-[JSON Schema or OpenAPI definitions]
-
-### Response Schemas
-[JSON Schema or OpenAPI definitions]
-
-### Validation Rules
-- Required fields
-- Data types and formats
-- Business logic constraints
-
-## API Versioning Strategy
-### Versioning Approach (URL/Header/Accept)
-### Version Lifecycle Management
-### Deprecation Policy
-### Migration Paths
-
-## Security & Governance
-### Authentication Mechanisms
-- OAuth 2.0 / JWT / API Keys
-### Authorization Patterns
-- RBAC / ABAC / Resource-based
-### Rate Limiting & Throttling
-### CORS and Security Headers
-
-## Error Handling
-### Standard Error Response Format
-```json
-{
-  "error": {
-    "code": "ERROR_CODE",
-    "message": "Human-readable error message",
-    "details": [],
-    "trace_id": "uuid"
-  }
-}
-```
-
-### Error Code Taxonomy
-### Validation Error Responses
-
-## API Documentation
-### OpenAPI/Swagger Specification
-### Developer Portal Requirements
-### Code Examples and SDKs
-### Changelog and Migration Guides
-
-## Performance Optimization
-### Response Caching Strategies
-### Compression (gzip, brotli)
-### Field Selection (sparse fieldsets)
-### Bulk Operations and Batch Endpoints
-
-## Monitoring & Observability
-### API Metrics
-- Request count, latency, error rates
-- Endpoint usage analytics
-### Logging Strategy
-### Distributed Tracing
-
-## Developer Experience
-### API Usability Assessment
-### Integration Complexity
-### SDK and Client Library Needs
-### Sandbox and Testing Environments
-```
-
-#### api-specification.md Structure
-```markdown
-# API Specification: {Topic}
-*OpenAPI 3.0 Specification*
-
-## API Information
-- **Title**: {API Name}
-- **Version**: 1.0.0
-- **Base URL**: https://api.example.com/v1
-- **Contact**: api-team@example.com
-
-## Endpoints
-
-### Users API
-
-#### GET /users
-**Description**: Retrieve a list of users
-
-**Parameters**:
-- `page` (query, integer): Page number (default: 1)
-- `limit` (query, integer): Items per page (default: 20, max: 100)
-- `sort` (query, string): Sort field (e.g., "created_at", "-updated_at")
-- `filter[status]` (query, string): Filter by user status
-
-**Response 200**:
-```json
-{
-  "data": [
-    {
-      "id": "uuid",
-      "username": "string",
-      "email": "string",
-      "created_at": "2025-10-15T00:00:00Z"
-    }
-  ],
-  "meta": {
-    "page": 1,
-    "limit": 20,
-    "total": 100
-  },
-  "links": {
-    "self": "/users?page=1",
-    "next": "/users?page=2",
-    "prev": null
-  }
-}
-```
-
-#### POST /users
-**Description**: Create a new user
-
-**Request Body**:
-```json
-{
-  "username": "string (required, 3-50 chars)",
-  "email": "string (required, valid email)",
-  "password": "string (required, min 8 chars)",
-  "profile": {
-    "first_name": "string (optional)",
-    "last_name": "string (optional)"
-  }
-}
-```
-
-**Response 201**:
-```json
-{
-  "data": {
-    "id": "uuid",
-    "username": "string",
-    "email": "string",
-    "created_at": "2025-10-15T00:00:00Z"
-  }
-}
-```
-
-**Response 400** (Validation Error):
-```json
-{
-  "error": {
-    "code": "VALIDATION_ERROR",
-    "message": "Request validation failed",
-    "details": [
-      {
-        "field": "email",
-        "message": "Invalid email format"
-      }
-    ]
-  }
-}
-```
-
-[Continue for all endpoints...]
-
-## Authentication
-
-### OAuth 2.0 Flow
-1. Client requests authorization
-2. User grants permission
-3. Client receives access token
-4. Client uses token in requests
-
-**Header Format**:
-```
-Authorization: Bearer {access_token}
-```
-
-## Rate Limiting
-
-**Headers**:
-- `X-RateLimit-Limit`: 1000
-- `X-RateLimit-Remaining`: 999
-- `X-RateLimit-Reset`: 1634270400
-
-**Response 429** (Too Many Requests):
-```json
-{
-  "error": {
-    "code": "RATE_LIMIT_EXCEEDED",
-    "message": "API rate limit exceeded",
-    "retry_after": 3600
-  }
-}
-```
-```
-
-## 🔄 **Session Integration**
-
-### Status Synchronization
-Upon completion, update `workflow-session.json`:
-```json
-{
-  "phases": {
-    "BRAINSTORM": {
-      "api_designer": {
-        "status": "completed",
-        "completed_at": "timestamp",
-        "output_directory": ".workflow/active/WFS-{topic}/.brainstorming/api-designer/",
-        "key_insights": ["endpoint_design", "versioning_strategy", "data_contracts"]
-      }
-    }
-  }
-}
-```
-
-### Cross-Role Collaboration
-API designer perspective provides:
-- **API Contract Specifications** → Frontend Developer
-- **Data Schema Requirements** → Data Architect
-- **Security Requirements** → Security Expert
-- **Integration Endpoints** → System Architect
-- **Performance Constraints** → DevOps Engineer
-
-## ✅ **Quality Assurance**
-
-### Required Analysis Elements
-- [ ] Complete endpoint inventory with HTTP methods and paths
-- [ ] Detailed request/response schemas with validation rules
-- [ ] Clear versioning strategy and backward compatibility plan
-- [ ] Comprehensive error handling and status code usage
-- [ ] API documentation strategy (OpenAPI/Swagger)
-
-### API Design Principles
-- [ ] **Consistency**: Uniform naming conventions and patterns across all endpoints
-- [ ] **Simplicity**: Intuitive resource modeling and URL structures
-- [ ] **Flexibility**: Support for filtering, sorting, pagination, and field selection
-- [ ] **Security**: Proper authentication, authorization, and input validation
-- [ ] **Performance**: Caching strategies, compression, and efficient data structures
-
-### Developer Experience Validation
-- [ ] API is self-documenting with clear endpoint descriptions
-- [ ] Error messages are actionable and helpful for debugging
-- [ ] Response formats are consistent and predictable
-- [ ] Code examples and integration guides are provided
-- [ ] Sandbox environment available for testing
-
-### Technical Completeness
-- [ ] **Resource Modeling**: All domain entities mapped to API resources
-- [ ] **CRUD Coverage**: Complete create, read, update, delete operations
-- [ ] **Query Capabilities**: Advanced filtering, sorting, and search functionality
-- [ ] **Versioning**: Clear version management and migration paths
-- [ ] **Monitoring**: API metrics, logging, and tracing strategies defined
-
-### Integration Readiness
-- [ ] **Client Compatibility**: API works with all target client platforms
-- [ ] **External Integration**: Third-party API dependencies identified
-- [ ] **Backward Compatibility**: Changes don't break existing clients
-- [ ] **Migration Path**: Clear upgrade paths for API consumers
-- [ ] **SDK Support**: Client libraries and code generation considered

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

@@ -1,10 +1,14 @@
 ---
 name: artifacts
 description: Interactive clarification generating confirmed guidance specification through role-based analysis and synthesis
-argument-hint: "topic or challenge description [--count N]"
+argument-hint: "[-y|--yes] topic or challenge description [--count N]"
 allowed-tools: TodoWrite(*), Read(*), Write(*), Glob(*), AskUserQuestion(*)
 ---
 
+## Auto Mode
+
+When `--yes` or `-y`: Auto-select recommended roles, skip all clarification questions, use default answers.
+
 ## Overview
 
 Seven-phase workflow: **Context collection** → **Topic analysis** → **Role selection** → **Role questions** → **Conflict resolution** → **Final check** → **Generate specification**

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

@@ -1,10 +1,14 @@
 ---
 name: auto-parallel
 description: Parallel brainstorming automation with dynamic role selection and concurrent execution across multiple perspectives
-argument-hint: "topic or challenge description" [--count N]
+argument-hint: "[-y|--yes] topic or challenge description [--count N]"
 allowed-tools: SlashCommand(*), Task(*), TodoWrite(*), Read(*), Write(*), Bash(*), Glob(*)
 ---
 
+## Auto Mode
+
+When `--yes` or `-y`: Auto-select recommended roles, skip all clarification questions, use default answers.
+
 # Workflow Brainstorm Parallel Auto Command
 
 ## Coordinator Role
@@ -128,55 +132,30 @@ SlashCommand(command="/workflow:brainstorm:artifacts \"{topic}\" --count {N}")
 
 ### Phase 2: Parallel Role Analysis Execution
 
-**For Each Selected Role**:
+**For Each Selected Role** (unified role-analysis command):
 ```bash
-Task(conceptual-planning-agent): "
-[FLOW_CONTROL]
-
-Execute {role-name} analysis for existing topic framework
-
-## Context Loading
-ASSIGNED_ROLE: {role-name}
-OUTPUT_LOCATION: .workflow/active/WFS-{session}/.brainstorming/{role}/
-TOPIC: {user-provided-topic}
-
-## Flow Control Steps
-1. load_topic_framework → .workflow/active/WFS-{session}/.brainstorming/guidance-specification.md
-2. load_role_template → ~/.claude/workflows/cli-templates/planning-roles/{role}.md
-3. load_session_metadata → .workflow/active/WFS-{session}/workflow-session.json
-4. load_style_skill (ui-designer only, if style_skill_package) → .claude/skills/style-{style_skill_package}/
-
-## Analysis Requirements
-**Primary Reference**: Original user prompt from workflow-session.json is authoritative
-**Framework Source**: Address all discussion points in guidance-specification.md from {role-name} perspective
-**Role Focus**: {role-name} domain expertise aligned with user intent
-**Structured Approach**: Create analysis.md addressing framework discussion points
-**Template Integration**: Apply role template guidelines within framework structure
-
-## Expected Deliverables
-1. **analysis.md** (optionally with analysis-{slug}.md sub-documents)
-2. **Framework Reference**: @../guidance-specification.md
-3. **User Intent Alignment**: Validate against session_context
-
-## Completion Criteria
-- Address each discussion point from guidance-specification.md with {role-name} expertise
-- Provide actionable recommendations from {role-name} perspective within analysis files
-- All output files MUST start with `analysis` prefix (no recommendations.md or other naming)
-- Reference framework document using @ notation for integration
-- Update workflow-session.json with completion status
-"
+SlashCommand(command="/workflow:brainstorm:role-analysis {role-name} --session {session-id} --skip-questions")
 ```
 
-**Parallel Execute**:
-- Launch N agents simultaneously (one message with multiple Task calls)
-- Each agent task **attached** to orchestrator's TodoWrite
-- All agents execute concurrently, each attaching their own analysis sub-tasks
-- Each agent operates independently reading same guidance-specification.md
+**What It Does**:
+- Unified command execution for each role
+- Loads topic framework from guidance-specification.md
+- Applies role-specific template and context
+- Generates analysis.md addressing framework discussion points
+- Supports optional interactive context gathering (via --include-questions flag)
+
+**Parallel Execution**:
+- Launch N SlashCommand calls simultaneously (one message with multiple SlashCommand invokes)
+- Each role command **attached** to orchestrator's TodoWrite
+- All roles execute concurrently, each reading same guidance-specification.md
+- Each role operates independently
+- For ui-designer only: append `--style-skill {style_skill_package}` if provided
 
 **Input**:
 - `selected_roles[]` from Phase 1
 - `session_id` from Phase 1
-- guidance-specification.md path
+- `guidance-specification.md` (framework reference)
+- `style_skill_package` (for ui-designer only)
 
 **Validation**:
 - Each role creates `.workflow/active/WFS-{topic}/.brainstorming/{role}/analysis.md`
@@ -185,6 +164,7 @@ TOPIC: {user-provided-topic}
 - **FORBIDDEN**: `recommendations.md` or any non-`analysis` prefixed files
 - All N role analyses completed
 
+
 **TodoWrite Update (Phase 2 agents executed - tasks attached in parallel)**:
 ```json
 [
@@ -451,4 +431,3 @@ CONTEXT_VARS:
 ```
 
 **Template Source**: `~/.claude/workflows/cli-templates/planning-roles/`
-

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

@@ -1,220 +0,0 @@
----
-name: data-architect
-description: Generate or update data-architect/analysis.md addressing guidance-specification discussion points for data architecture perspective
-argument-hint: "optional topic - uses existing framework if available"
-allowed-tools: Task(conceptual-planning-agent), TodoWrite(*), Read(*), Write(*)
----
-
-## 📊 **Data Architect Analysis Generator**
-
-### Purpose
-**Specialized command for generating data-architect/analysis.md** that addresses guidance-specification.md discussion points from data architecture perspective. Creates or updates role-specific analysis with framework references.
-
-### Core Function
-- **Framework-based Analysis**: Address each discussion point in guidance-specification.md
-- **Data Architecture Focus**: Data models, pipelines, governance, and analytics perspective
-- **Update Mechanism**: Create new or update existing analysis.md
-- **Agent Delegation**: Use conceptual-planning-agent for analysis generation
-
-### Analysis Scope
-- **Data Model Design**: Efficient and scalable data models and schemas
-- **Data Flow Design**: Data collection, processing, and storage workflows
-- **Data Quality Management**: Data accuracy, completeness, and consistency
-- **Analytics and Insights**: Data analysis and business intelligence solutions
-
-### Role Boundaries & Responsibilities
-
-#### **What This Role OWNS (Canonical Data Model - Source of Truth)**
-- **Canonical Data Model**: The authoritative, system-wide data schema representing domain entities and relationships
-- **Entity-Relationship Design**: Defining entities, attributes, relationships, and constraints
-- **Data Normalization & Optimization**: Ensuring data integrity, reducing redundancy, and optimizing storage
-- **Database Schema Design**: Physical database structures, indexes, partitioning strategies
-- **Data Pipeline Architecture**: ETL/ELT processes, data warehousing, and analytics pipelines
-- **Data Governance**: Data quality standards, retention policies, and compliance requirements
-
-#### **What This Role DOES NOT Own (Defers to Other Roles)**
-- **API Data Contracts**: Public-facing request/response schemas exposed by APIs → Defers to **API Designer**
-- **System Integration Patterns**: How services communicate at the macro level → Defers to **System Architect**
-- **UI Data Presentation**: How data is displayed to users → Defers to **UI Designer**
-
-#### **Handoff Points**
-- **TO API Designer**: Provides canonical data model that API Designer translates into public API data contracts (as projection/view)
-- **TO System Architect**: Provides data flow requirements and storage constraints to inform system design
-- **FROM System Architect**: Receives system-level integration requirements and scalability constraints
-
-## ⚙️ **Execution Protocol**
-
-### Phase 1: Session & Framework Detection
-```bash
-# Check active session and framework
-CHECK: find .workflow/active/ -name "WFS-*" -type d
-IF active_session EXISTS:
-    session_id = get_active_session()
-    brainstorm_dir = .workflow/active/WFS-{session}/.brainstorming/
-
-    CHECK: brainstorm_dir/guidance-specification.md
-    IF EXISTS:
-        framework_mode = true
-        load_framework = true
-    ELSE:
-        IF topic_provided:
-            framework_mode = false  # Create analysis without framework
-        ELSE:
-            ERROR: "No framework found and no topic provided"
-```
-
-### Phase 2: Analysis Mode Detection
-```bash
-# Determine execution mode
-IF framework_mode == true:
-    mode = "framework_based_analysis"
-    topic_ref = load_framework_topic()
-    discussion_points = extract_framework_points()
-ELSE:
-    mode = "standalone_analysis"
-    topic_ref = provided_topic
-    discussion_points = generate_basic_structure()
-```
-
-### Phase 3: Agent Execution with Flow Control
-**Framework-Based Analysis Generation**
-
-```bash
-Task(conceptual-planning-agent): "
-[FLOW_CONTROL]
-
-Execute data-architect analysis for existing topic framework
-
-## Context Loading
-ASSIGNED_ROLE: data-architect
-OUTPUT_LOCATION: .workflow/active/WFS-{session}/.brainstorming/data-architect/
-ANALYSIS_MODE: {framework_mode ? "framework_based" : "standalone"}
-
-## Flow Control Steps
-1. **load_topic_framework**
-   - Action: Load structured topic discussion framework
-   - Command: Read(.workflow/active/WFS-{session}/.brainstorming/guidance-specification.md)
-   - Output: topic_framework_content
-
-2. **load_role_template**
-   - Action: Load data-architect planning template
-   - Command: bash($(cat ~/.claude/workflows/cli-templates/planning-roles/data-architect.md))
-   - Output: role_template_guidelines
-
-3. **load_session_metadata**
-   - Action: Load session metadata and existing context
-   - Command: Read(.workflow/active/WFS-{session}/workflow-session.json)
-   - Output: session_context
-
-## Analysis Requirements
-**Framework Reference**: Address all discussion points in guidance-specification.md from data architecture perspective
-**Role Focus**: Data models, pipelines, governance, analytics platforms
-**Structured Approach**: Create analysis.md addressing framework discussion points
-**Template Integration**: Apply role template guidelines within framework structure
-
-## Expected Deliverables
-1. **analysis.md**: Comprehensive data architecture analysis addressing all framework discussion points
-2. **Framework Reference**: Include @../guidance-specification.md reference in analysis
-
-## Completion Criteria
-- Address each discussion point from guidance-specification.md with data architecture expertise
-- Provide data model designs, pipeline architectures, and governance strategies
-- Include scalability, performance, and quality considerations
-- Reference framework document using @ notation for integration
-"
-```
-
-## 📋 **TodoWrite Integration**
-
-### Workflow Progress Tracking
-```javascript
-TodoWrite({
-  todos: [
-    {
-      content: "Detect active session and locate topic framework",
-      status: "in_progress",
-      activeForm: "Detecting session and framework"
-    },
-    {
-      content: "Load guidance-specification.md and session metadata for context",
-      status: "pending",
-      activeForm: "Loading framework and session context"
-    },
-    {
-      content: "Execute data-architect analysis using conceptual-planning-agent with FLOW_CONTROL",
-      status: "pending",
-      activeForm: "Executing data-architect framework analysis"
-    },
-    {
-      content: "Generate analysis.md addressing all framework discussion points",
-      status: "pending",
-      activeForm: "Generating structured data-architect analysis"
-    },
-    {
-      content: "Update workflow-session.json with data-architect completion status",
-      status: "pending",
-      activeForm: "Updating session metadata"
-    }
-  ]
-});
-```
-
-## 📊 **Output Structure**
-
-### Framework-Based Analysis
-```
-.workflow/active/WFS-{session}/.brainstorming/data-architect/
-└── analysis.md    # Structured analysis addressing guidance-specification.md discussion points
-```
-
-### Analysis Document Structure
-```markdown
-# Data Architect Analysis: [Topic from Framework]
-
-## Framework Reference
-**Topic Framework**: @../guidance-specification.md
-**Role Focus**: Data Architecture perspective
-
-## Discussion Points Analysis
-[Address each point from guidance-specification.md with data architecture expertise]
-
-### Core Requirements (from framework)
-[Data architecture perspective on requirements]
-
-### Technical Considerations (from framework)
-[Data model, pipeline, and storage considerations]
-
-### User Experience Factors (from framework)
-[Data access patterns and analytics user experience]
-
-### Implementation Challenges (from framework)
-[Data migration, quality, and governance challenges]
-
-### Success Metrics (from framework)
-[Data quality metrics and analytics success criteria]
-
-## Data Architecture Specific Recommendations
-[Role-specific data architecture recommendations and solutions]
-
----
-*Generated by data-architect analysis addressing structured framework*
-```
-
-## 🔄 **Session Integration**
-
-### Completion Status Update
-```json
-{
-  "data_architect": {
-    "status": "completed",
-    "framework_addressed": true,
-    "output_location": ".workflow/active/WFS-{session}/.brainstorming/data-architect/analysis.md",
-    "framework_reference": "@../guidance-specification.md"
-  }
-}
-```
-
-### Integration Points
-- **Framework Reference**: @../guidance-specification.md for structured discussion points
-- **Cross-Role Synthesis**: Data architecture insights available for synthesis-report.md integration
-- **Agent Autonomy**: Independent execution with framework guidance

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

@@ -1,200 +0,0 @@
----
-name: product-manager
-description: Generate or update product-manager/analysis.md addressing guidance-specification discussion points for product management perspective
-argument-hint: "optional topic - uses existing framework if available"
-allowed-tools: Task(conceptual-planning-agent), TodoWrite(*), Read(*), Write(*)
----
-
-## 🎯 **Product Manager Analysis Generator**
-
-### Purpose
-**Specialized command for generating product-manager/analysis.md** that addresses guidance-specification.md discussion points from product strategy perspective. Creates or updates role-specific analysis with framework references.
-
-### Core Function
-- **Framework-based Analysis**: Address each discussion point in guidance-specification.md
-- **Product Strategy Focus**: User needs, business value, and market positioning
-- **Update Mechanism**: Create new or update existing analysis.md
-- **Agent Delegation**: Use conceptual-planning-agent for analysis generation
-
-### Analysis Scope
-- **User Needs Analysis**: Target users, problems, and value propositions
-- **Business Impact Assessment**: ROI, metrics, and commercial outcomes
-- **Market Positioning**: Competitive analysis and differentiation
-- **Product Strategy**: Roadmaps, priorities, and go-to-market approaches
-
-## ⚙️ **Execution Protocol**
-
-### Phase 1: Session & Framework Detection
-```bash
-# Check active session and framework
-CHECK: find .workflow/active/ -name "WFS-*" -type d
-IF active_session EXISTS:
-    session_id = get_active_session()
-    brainstorm_dir = .workflow/active/WFS-{session}/.brainstorming/
-
-    CHECK: brainstorm_dir/guidance-specification.md
-    IF EXISTS:
-        framework_mode = true
-        load_framework = true
-    ELSE:
-        IF topic_provided:
-            framework_mode = false  # Create analysis without framework
-        ELSE:
-            ERROR: "No framework found and no topic provided"
-```
-
-### Phase 2: Analysis Mode Detection
-```bash
-# Determine execution mode
-IF framework_mode == true:
-    mode = "framework_based_analysis"
-    topic_ref = load_framework_topic()
-    discussion_points = extract_framework_points()
-ELSE:
-    mode = "standalone_analysis"
-    topic_ref = provided_topic
-    discussion_points = generate_basic_structure()
-```
-
-### Phase 3: Agent Execution with Flow Control
-**Framework-Based Analysis Generation**
-
-```bash
-Task(conceptual-planning-agent): "
-[FLOW_CONTROL]
-
-Execute product-manager analysis for existing topic framework
-
-## Context Loading
-ASSIGNED_ROLE: product-manager
-OUTPUT_LOCATION: .workflow/active/WFS-{session}/.brainstorming/product-manager/
-ANALYSIS_MODE: {framework_mode ? "framework_based" : "standalone"}
-
-## Flow Control Steps
-1. **load_topic_framework**
-   - Action: Load structured topic discussion framework
-   - Command: Read(.workflow/active/WFS-{session}/.brainstorming/guidance-specification.md)
-   - Output: topic_framework_content
-
-2. **load_role_template**
-   - Action: Load product-manager planning template
-   - Command: bash($(cat ~/.claude/workflows/cli-templates/planning-roles/product-manager.md))
-   - Output: role_template_guidelines
-
-3. **load_session_metadata**
-   - Action: Load session metadata and existing context
-   - Command: Read(.workflow/active/WFS-{session}/workflow-session.json)
-   - Output: session_context
-
-## Analysis Requirements
-**Framework Reference**: Address all discussion points in guidance-specification.md from product strategy perspective
-**Role Focus**: User value, business impact, market positioning, product strategy
-**Structured Approach**: Create analysis.md addressing framework discussion points
-**Template Integration**: Apply role template guidelines within framework structure
-
-## Expected Deliverables
-1. **analysis.md**: Comprehensive product strategy analysis addressing all framework discussion points
-2. **Framework Reference**: Include @../guidance-specification.md reference in analysis
-
-## Completion Criteria
-- Address each discussion point from guidance-specification.md with product management expertise
-- Provide actionable business strategies and user value propositions
-- Include market analysis and competitive positioning insights
-- Reference framework document using @ notation for integration
-"
-```
-
-## 📋 **TodoWrite Integration**
-
-### Workflow Progress Tracking
-```javascript
-TodoWrite({
-  todos: [
-    {
-      content: "Detect active session and locate topic framework",
-      status: "in_progress",
-      activeForm: "Detecting session and framework"
-    },
-    {
-      content: "Load guidance-specification.md and session metadata for context",
-      status: "pending",
-      activeForm: "Loading framework and session context"
-    },
-    {
-      content: "Execute product-manager analysis using conceptual-planning-agent with FLOW_CONTROL",
-      status: "pending",
-      activeForm: "Executing product-manager framework analysis"
-    },
-    {
-      content: "Generate analysis.md addressing all framework discussion points",
-      status: "pending",
-      activeForm: "Generating structured product-manager analysis"
-    },
-    {
-      content: "Update workflow-session.json with product-manager completion status",
-      status: "pending",
-      activeForm: "Updating session metadata"
-    }
-  ]
-});
-```
-
-## 📊 **Output Structure**
-
-### Framework-Based Analysis
-```
-.workflow/active/WFS-{session}/.brainstorming/product-manager/
-└── analysis.md    # Structured analysis addressing guidance-specification.md discussion points
-```
-
-### Analysis Document Structure
-```markdown
-# Product Manager Analysis: [Topic from Framework]
-
-## Framework Reference
-**Topic Framework**: @../guidance-specification.md
-**Role Focus**: Product Strategy perspective
-
-## Discussion Points Analysis
-[Address each point from guidance-specification.md with product management expertise]
-
-### Core Requirements (from framework)
-[Product strategy perspective on user needs and requirements]
-
-### Technical Considerations (from framework)
-[Business and technical feasibility considerations]
-
-### User Experience Factors (from framework)
-[User value proposition and market positioning analysis]
-
-### Implementation Challenges (from framework)
-[Business execution and go-to-market considerations]
-
-### Success Metrics (from framework)
-[Product success metrics and business KPIs]
-
-## Product Strategy Specific Recommendations
-[Role-specific product management strategies and business solutions]
-
----
-*Generated by product-manager analysis addressing structured framework*
-```
-
-## 🔄 **Session Integration**
-
-### Completion Status Update
-```json
-{
-  "product_manager": {
-    "status": "completed",
-    "framework_addressed": true,
-    "output_location": ".workflow/active/WFS-{session}/.brainstorming/product-manager/analysis.md",
-    "framework_reference": "@../guidance-specification.md"
-  }
-}
-```
-
-### Integration Points
-- **Framework Reference**: @../guidance-specification.md for structured discussion points
-- **Cross-Role Synthesis**: Product strategy insights available for synthesis-report.md integration
-- **Agent Autonomy**: Independent execution with framework guidance

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

@@ -1,200 +0,0 @@
----
-name: product-owner
-description: Generate or update product-owner/analysis.md addressing guidance-specification discussion points for product ownership perspective
-argument-hint: "optional topic - uses existing framework if available"
-allowed-tools: Task(conceptual-planning-agent), TodoWrite(*), Read(*), Write(*)
----
-
-## 🎯 **Product Owner Analysis Generator**
-
-### Purpose
-**Specialized command for generating product-owner/analysis.md** that addresses guidance-specification.md discussion points from product backlog and feature prioritization perspective. Creates or updates role-specific analysis with framework references.
-
-### Core Function
-- **Framework-based Analysis**: Address each discussion point in guidance-specification.md
-- **Product Backlog Focus**: Feature prioritization, user stories, and acceptance criteria
-- **Update Mechanism**: Create new or update existing analysis.md
-- **Agent Delegation**: Use conceptual-planning-agent for analysis generation
-
-### Analysis Scope
-- **Backlog Management**: User story creation, refinement, and prioritization
-- **Stakeholder Alignment**: Requirements gathering, value definition, and expectation management
-- **Feature Prioritization**: ROI analysis, MoSCoW method, and value-driven delivery
-- **Acceptance Criteria**: Definition of Done, acceptance testing, and quality standards
-
-## ⚙️ **Execution Protocol**
-
-### Phase 1: Session & Framework Detection
-```bash
-# Check active session and framework
-CHECK: find .workflow/active/ -name "WFS-*" -type d
-IF active_session EXISTS:
-    session_id = get_active_session()
-    brainstorm_dir = .workflow/active/WFS-{session}/.brainstorming/
-
-    CHECK: brainstorm_dir/guidance-specification.md
-    IF EXISTS:
-        framework_mode = true
-        load_framework = true
-    ELSE:
-        IF topic_provided:
-            framework_mode = false  # Create analysis without framework
-        ELSE:
-            ERROR: "No framework found and no topic provided"
-```
-
-### Phase 2: Analysis Mode Detection
-```bash
-# Determine execution mode
-IF framework_mode == true:
-    mode = "framework_based_analysis"
-    topic_ref = load_framework_topic()
-    discussion_points = extract_framework_points()
-ELSE:
-    mode = "standalone_analysis"
-    topic_ref = provided_topic
-    discussion_points = generate_basic_structure()
-```
-
-### Phase 3: Agent Execution with Flow Control
-**Framework-Based Analysis Generation**
-
-```bash
-Task(conceptual-planning-agent): "
-[FLOW_CONTROL]
-
-Execute product-owner analysis for existing topic framework
-
-## Context Loading
-ASSIGNED_ROLE: product-owner
-OUTPUT_LOCATION: .workflow/active/WFS-{session}/.brainstorming/product-owner/
-ANALYSIS_MODE: {framework_mode ? "framework_based" : "standalone"}
-
-## Flow Control Steps
-1. **load_topic_framework**
-   - Action: Load structured topic discussion framework
-   - Command: Read(.workflow/active/WFS-{session}/.brainstorming/guidance-specification.md)
-   - Output: topic_framework_content
-
-2. **load_role_template**
-   - Action: Load product-owner planning template
-   - Command: bash($(cat ~/.claude/workflows/cli-templates/planning-roles/product-owner.md))
-   - Output: role_template_guidelines
-
-3. **load_session_metadata**
-   - Action: Load session metadata and existing context
-   - Command: Read(.workflow/active/WFS-{session}/workflow-session.json)
-   - Output: session_context
-
-## Analysis Requirements
-**Framework Reference**: Address all discussion points in guidance-specification.md from product backlog and feature prioritization perspective
-**Role Focus**: Backlog management, stakeholder alignment, feature prioritization, acceptance criteria
-**Structured Approach**: Create analysis.md addressing framework discussion points
-**Template Integration**: Apply role template guidelines within framework structure
-
-## Expected Deliverables
-1. **analysis.md**: Comprehensive product ownership analysis addressing all framework discussion points
-2. **Framework Reference**: Include @../guidance-specification.md reference in analysis
-
-## Completion Criteria
-- Address each discussion point from guidance-specification.md with product ownership expertise
-- Provide actionable user stories and acceptance criteria definitions
-- Include feature prioritization and stakeholder alignment strategies
-- Reference framework document using @ notation for integration
-"
-```
-
-## 📋 **TodoWrite Integration**
-
-### Workflow Progress Tracking
-```javascript
-TodoWrite({
-  todos: [
-    {
-      content: "Detect active session and locate topic framework",
-      status: "in_progress",
-      activeForm: "Detecting session and framework"
-    },
-    {
-      content: "Load guidance-specification.md and session metadata for context",
-      status: "pending",
-      activeForm: "Loading framework and session context"
-    },
-    {
-      content: "Execute product-owner analysis using conceptual-planning-agent with FLOW_CONTROL",
-      status: "pending",
-      activeForm: "Executing product-owner framework analysis"
-    },
-    {
-      content: "Generate analysis.md addressing all framework discussion points",
-      status: "pending",
-      activeForm: "Generating structured product-owner analysis"
-    },
-    {
-      content: "Update workflow-session.json with product-owner completion status",
-      status: "pending",
-      activeForm: "Updating session metadata"
-    }
-  ]
-});
-```
-
-## 📊 **Output Structure**
-
-### Framework-Based Analysis
-```
-.workflow/active/WFS-{session}/.brainstorming/product-owner/
-└── analysis.md    # Structured analysis addressing guidance-specification.md discussion points
-```
-
-### Analysis Document Structure
-```markdown
-# Product Owner Analysis: [Topic from Framework]
-
-## Framework Reference
-**Topic Framework**: @../guidance-specification.md
-**Role Focus**: Product Backlog & Feature Prioritization perspective
-
-## Discussion Points Analysis
-[Address each point from guidance-specification.md with product ownership expertise]
-
-### Core Requirements (from framework)
-[User story formulation and backlog refinement perspective]
-
-### Technical Considerations (from framework)
-[Technical feasibility and implementation sequencing considerations]
-
-### User Experience Factors (from framework)
-[User value definition and acceptance criteria analysis]
-
-### Implementation Challenges (from framework)
-[Sprint planning, dependency management, and delivery strategies]
-
-### Success Metrics (from framework)
-[Feature adoption, value delivery metrics, and stakeholder satisfaction indicators]
-
-## Product Owner Specific Recommendations
-[Role-specific backlog management and feature prioritization strategies]
-
----
-*Generated by product-owner analysis addressing structured framework*
-```
-
-## 🔄 **Session Integration**
-
-### Completion Status Update
-```json
-{
-  "product_owner": {
-    "status": "completed",
-    "framework_addressed": true,
-    "output_location": ".workflow/active/WFS-{session}/.brainstorming/product-owner/analysis.md",
-    "framework_reference": "@../guidance-specification.md"
-  }
-}
-```
-
-### Integration Points
-- **Framework Reference**: @../guidance-specification.md for structured discussion points
-- **Cross-Role Synthesis**: Product ownership insights available for synthesis-report.md integration
-- **Agent Autonomy**: Independent execution with framework guidance

.claude/commands/workflow/brainstorm/role-analysis.md

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

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

@@ -1,200 +0,0 @@
----
-name: scrum-master
-description: Generate or update scrum-master/analysis.md addressing guidance-specification discussion points for Agile process perspective
-argument-hint: "optional topic - uses existing framework if available"
-allowed-tools: Task(conceptual-planning-agent), TodoWrite(*), Read(*), Write(*)
----
-
-## 🎯 **Scrum Master Analysis Generator**
-
-### Purpose
-**Specialized command for generating scrum-master/analysis.md** that addresses guidance-specification.md discussion points from agile process and team collaboration perspective. Creates or updates role-specific analysis with framework references.
-
-### Core Function
-- **Framework-based Analysis**: Address each discussion point in guidance-specification.md
-- **Agile Process Focus**: Sprint planning, team dynamics, and delivery optimization
-- **Update Mechanism**: Create new or update existing analysis.md
-- **Agent Delegation**: Use conceptual-planning-agent for analysis generation
-
-### Analysis Scope
-- **Sprint Planning**: Task breakdown, estimation, and iteration planning
-- **Team Collaboration**: Communication patterns, impediment removal, and facilitation
-- **Process Optimization**: Agile ceremonies, retrospectives, and continuous improvement
-- **Delivery Management**: Velocity tracking, burndown analysis, and release planning
-
-## ⚙️ **Execution Protocol**
-
-### Phase 1: Session & Framework Detection
-```bash
-# Check active session and framework
-CHECK: find .workflow/active/ -name "WFS-*" -type d
-IF active_session EXISTS:
-    session_id = get_active_session()
-    brainstorm_dir = .workflow/active/WFS-{session}/.brainstorming/
-
-    CHECK: brainstorm_dir/guidance-specification.md
-    IF EXISTS:
-        framework_mode = true
-        load_framework = true
-    ELSE:
-        IF topic_provided:
-            framework_mode = false  # Create analysis without framework
-        ELSE:
-            ERROR: "No framework found and no topic provided"
-```
-
-### Phase 2: Analysis Mode Detection
-```bash
-# Determine execution mode
-IF framework_mode == true:
-    mode = "framework_based_analysis"
-    topic_ref = load_framework_topic()
-    discussion_points = extract_framework_points()
-ELSE:
-    mode = "standalone_analysis"
-    topic_ref = provided_topic
-    discussion_points = generate_basic_structure()
-```
-
-### Phase 3: Agent Execution with Flow Control
-**Framework-Based Analysis Generation**
-
-```bash
-Task(conceptual-planning-agent): "
-[FLOW_CONTROL]
-
-Execute scrum-master analysis for existing topic framework
-
-## Context Loading
-ASSIGNED_ROLE: scrum-master
-OUTPUT_LOCATION: .workflow/active/WFS-{session}/.brainstorming/scrum-master/
-ANALYSIS_MODE: {framework_mode ? "framework_based" : "standalone"}
-
-## Flow Control Steps
-1. **load_topic_framework**
-   - Action: Load structured topic discussion framework
-   - Command: Read(.workflow/active/WFS-{session}/.brainstorming/guidance-specification.md)
-   - Output: topic_framework_content
-
-2. **load_role_template**
-   - Action: Load scrum-master planning template
-   - Command: bash($(cat ~/.claude/workflows/cli-templates/planning-roles/scrum-master.md))
-   - Output: role_template_guidelines
-
-3. **load_session_metadata**
-   - Action: Load session metadata and existing context
-   - Command: Read(.workflow/active/WFS-{session}/workflow-session.json)
-   - Output: session_context
-
-## Analysis Requirements
-**Framework Reference**: Address all discussion points in guidance-specification.md from agile process and team collaboration perspective
-**Role Focus**: Sprint planning, team dynamics, process optimization, delivery management
-**Structured Approach**: Create analysis.md addressing framework discussion points
-**Template Integration**: Apply role template guidelines within framework structure
-
-## Expected Deliverables
-1. **analysis.md**: Comprehensive agile process analysis addressing all framework discussion points
-2. **Framework Reference**: Include @../guidance-specification.md reference in analysis
-
-## Completion Criteria
-- Address each discussion point from guidance-specification.md with scrum mastery expertise
-- Provide actionable sprint planning and team facilitation strategies
-- Include process optimization and impediment removal insights
-- Reference framework document using @ notation for integration
-"
-```
-
-## 📋 **TodoWrite Integration**
-
-### Workflow Progress Tracking
-```javascript
-TodoWrite({
-  todos: [
-    {
-      content: "Detect active session and locate topic framework",
-      status: "in_progress",
-      activeForm: "Detecting session and framework"
-    },
-    {
-      content: "Load guidance-specification.md and session metadata for context",
-      status: "pending",
-      activeForm: "Loading framework and session context"
-    },
-    {
-      content: "Execute scrum-master analysis using conceptual-planning-agent with FLOW_CONTROL",
-      status: "pending",
-      activeForm: "Executing scrum-master framework analysis"
-    },
-    {
-      content: "Generate analysis.md addressing all framework discussion points",
-      status: "pending",
-      activeForm: "Generating structured scrum-master analysis"
-    },
-    {
-      content: "Update workflow-session.json with scrum-master completion status",
-      status: "pending",
-      activeForm: "Updating session metadata"
-    }
-  ]
-});
-```
-
-## 📊 **Output Structure**
-
-### Framework-Based Analysis
-```
-.workflow/active/WFS-{session}/.brainstorming/scrum-master/
-└── analysis.md    # Structured analysis addressing guidance-specification.md discussion points
-```
-
-### Analysis Document Structure
-```markdown
-# Scrum Master Analysis: [Topic from Framework]
-
-## Framework Reference
-**Topic Framework**: @../guidance-specification.md
-**Role Focus**: Agile Process & Team Collaboration perspective
-
-## Discussion Points Analysis
-[Address each point from guidance-specification.md with scrum mastery expertise]
-
-### Core Requirements (from framework)
-[Sprint planning and iteration breakdown perspective]
-
-### Technical Considerations (from framework)
-[Technical debt management and process considerations]
-
-### User Experience Factors (from framework)
-[User story refinement and acceptance criteria analysis]
-
-### Implementation Challenges (from framework)
-[Impediment identification and removal strategies]
-
-### Success Metrics (from framework)
-[Velocity tracking, burndown metrics, and team performance indicators]
-
-## Scrum Master Specific Recommendations
-[Role-specific agile process optimization and team facilitation strategies]
-
----
-*Generated by scrum-master analysis addressing structured framework*
-```
-
-## 🔄 **Session Integration**
-
-### Completion Status Update
-```json
-{
-  "scrum_master": {
-    "status": "completed",
-    "framework_addressed": true,
-    "output_location": ".workflow/active/WFS-{session}/.brainstorming/scrum-master/analysis.md",
-    "framework_reference": "@../guidance-specification.md"
-  }
-}
-```
-
-### Integration Points
-- **Framework Reference**: @../guidance-specification.md for structured discussion points
-- **Cross-Role Synthesis**: Agile process insights available for synthesis-report.md integration
-- **Agent Autonomy**: Independent execution with framework guidance

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

@@ -1,200 +0,0 @@
----
-name: subject-matter-expert
-description: Generate or update subject-matter-expert/analysis.md addressing guidance-specification discussion points for domain expertise perspective
-argument-hint: "optional topic - uses existing framework if available"
-allowed-tools: Task(conceptual-planning-agent), TodoWrite(*), Read(*), Write(*)
----
-
-## 🎯 **Subject Matter Expert Analysis Generator**
-
-### Purpose
-**Specialized command for generating subject-matter-expert/analysis.md** that addresses guidance-specification.md discussion points from domain knowledge and technical expertise perspective. Creates or updates role-specific analysis with framework references.
-
-### Core Function
-- **Framework-based Analysis**: Address each discussion point in guidance-specification.md
-- **Domain Expertise Focus**: Deep technical knowledge, industry standards, and best practices
-- **Update Mechanism**: Create new or update existing analysis.md
-- **Agent Delegation**: Use conceptual-planning-agent for analysis generation
-
-### Analysis Scope
-- **Domain Knowledge**: Industry-specific expertise, regulatory requirements, and compliance
-- **Technical Standards**: Best practices, design patterns, and architectural guidelines
-- **Risk Assessment**: Technical debt, scalability concerns, and maintenance implications
-- **Knowledge Transfer**: Documentation strategies, training requirements, and expertise sharing
-
-## ⚙️ **Execution Protocol**
-
-### Phase 1: Session & Framework Detection
-```bash
-# Check active session and framework
-CHECK: find .workflow/active/ -name "WFS-*" -type d
-IF active_session EXISTS:
-    session_id = get_active_session()
-    brainstorm_dir = .workflow/active/WFS-{session}/.brainstorming/
-
-    CHECK: brainstorm_dir/guidance-specification.md
-    IF EXISTS:
-        framework_mode = true
-        load_framework = true
-    ELSE:
-        IF topic_provided:
-            framework_mode = false  # Create analysis without framework
-        ELSE:
-            ERROR: "No framework found and no topic provided"
-```
-
-### Phase 2: Analysis Mode Detection
-```bash
-# Determine execution mode
-IF framework_mode == true:
-    mode = "framework_based_analysis"
-    topic_ref = load_framework_topic()
-    discussion_points = extract_framework_points()
-ELSE:
-    mode = "standalone_analysis"
-    topic_ref = provided_topic
-    discussion_points = generate_basic_structure()
-```
-
-### Phase 3: Agent Execution with Flow Control
-**Framework-Based Analysis Generation**
-
-```bash
-Task(conceptual-planning-agent): "
-[FLOW_CONTROL]
-
-Execute subject-matter-expert analysis for existing topic framework
-
-## Context Loading
-ASSIGNED_ROLE: subject-matter-expert
-OUTPUT_LOCATION: .workflow/active/WFS-{session}/.brainstorming/subject-matter-expert/
-ANALYSIS_MODE: {framework_mode ? "framework_based" : "standalone"}
-
-## Flow Control Steps
-1. **load_topic_framework**
-   - Action: Load structured topic discussion framework
-   - Command: Read(.workflow/active/WFS-{session}/.brainstorming/guidance-specification.md)
-   - Output: topic_framework_content
-
-2. **load_role_template**
-   - Action: Load subject-matter-expert planning template
-   - Command: bash($(cat ~/.claude/workflows/cli-templates/planning-roles/subject-matter-expert.md))
-   - Output: role_template_guidelines
-
-3. **load_session_metadata**
-   - Action: Load session metadata and existing context
-   - Command: Read(.workflow/active/WFS-{session}/workflow-session.json)
-   - Output: session_context
-
-## Analysis Requirements
-**Framework Reference**: Address all discussion points in guidance-specification.md from domain expertise and technical standards perspective
-**Role Focus**: Domain knowledge, technical standards, risk assessment, knowledge transfer
-**Structured Approach**: Create analysis.md addressing framework discussion points
-**Template Integration**: Apply role template guidelines within framework structure
-
-## Expected Deliverables
-1. **analysis.md**: Comprehensive domain expertise analysis addressing all framework discussion points
-2. **Framework Reference**: Include @../guidance-specification.md reference in analysis
-
-## Completion Criteria
-- Address each discussion point from guidance-specification.md with subject matter expertise
-- Provide actionable technical standards and best practices recommendations
-- Include risk assessment and compliance considerations
-- Reference framework document using @ notation for integration
-"
-```
-
-## 📋 **TodoWrite Integration**
-
-### Workflow Progress Tracking
-```javascript
-TodoWrite({
-  todos: [
-    {
-      content: "Detect active session and locate topic framework",
-      status: "in_progress",
-      activeForm: "Detecting session and framework"
-    },
-    {
-      content: "Load guidance-specification.md and session metadata for context",
-      status: "pending",
-      activeForm: "Loading framework and session context"
-    },
-    {
-      content: "Execute subject-matter-expert analysis using conceptual-planning-agent with FLOW_CONTROL",
-      status: "pending",
-      activeForm: "Executing subject-matter-expert framework analysis"
-    },
-    {
-      content: "Generate analysis.md addressing all framework discussion points",
-      status: "pending",
-      activeForm: "Generating structured subject-matter-expert analysis"
-    },
-    {
-      content: "Update workflow-session.json with subject-matter-expert completion status",
-      status: "pending",
-      activeForm: "Updating session metadata"
-    }
-  ]
-});
-```
-
-## 📊 **Output Structure**
-
-### Framework-Based Analysis
-```
-.workflow/active/WFS-{session}/.brainstorming/subject-matter-expert/
-└── analysis.md    # Structured analysis addressing guidance-specification.md discussion points
-```
-
-### Analysis Document Structure
-```markdown
-# Subject Matter Expert Analysis: [Topic from Framework]
-
-## Framework Reference
-**Topic Framework**: @../guidance-specification.md
-**Role Focus**: Domain Expertise & Technical Standards perspective
-
-## Discussion Points Analysis
-[Address each point from guidance-specification.md with subject matter expertise]
-
-### Core Requirements (from framework)
-[Domain-specific requirements and industry standards perspective]
-
-### Technical Considerations (from framework)
-[Deep technical analysis, architectural patterns, and best practices]
-
-### User Experience Factors (from framework)
-[Domain-specific usability standards and industry conventions]
-
-### Implementation Challenges (from framework)
-[Technical risks, scalability concerns, and maintenance implications]
-
-### Success Metrics (from framework)
-[Domain-specific KPIs, compliance metrics, and quality standards]
-
-## Subject Matter Expert Specific Recommendations
-[Role-specific technical expertise and industry best practices]
-
----
-*Generated by subject-matter-expert analysis addressing structured framework*
-```
-
-## 🔄 **Session Integration**
-
-### Completion Status Update
-```json
-{
-  "subject_matter_expert": {
-    "status": "completed",
-    "framework_addressed": true,
-    "output_location": ".workflow/active/WFS-{session}/.brainstorming/subject-matter-expert/analysis.md",
-    "framework_reference": "@../guidance-specification.md"
-  }
-}
-```
-
-### Integration Points
-- **Framework Reference**: @../guidance-specification.md for structured discussion points
-- **Cross-Role Synthesis**: Domain expertise insights available for synthesis-report.md integration
-- **Agent Autonomy**: Independent execution with framework guidance

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

@@ -1,10 +1,14 @@
 ---
 name: synthesis
 description: Clarify and refine role analyses through intelligent Q&A and targeted updates with synthesis agent
-argument-hint: "[optional: --session session-id]"
+argument-hint: "[-y|--yes] [optional: --session session-id]"
 allowed-tools: Task(conceptual-planning-agent), TodoWrite(*), Read(*), Write(*), Edit(*), Glob(*), AskUserQuestion(*)
 ---
 
+## Auto Mode
+
+When `--yes` or `-y`: Auto-select all enhancements, skip clarification questions, use default answers.
+
 ## Overview
 
 Six-phase workflow to eliminate ambiguities and enhance conceptual depth in role analyses:

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

@@ -1,389 +0,0 @@
----
-name: system-architect
-description: Generate or update system-architect/analysis.md addressing guidance-specification discussion points for system architecture perspective
-argument-hint: "optional topic - uses existing framework if available"
-allowed-tools: Task(conceptual-planning-agent), TodoWrite(*), Read(*), Write(*)
----
-
-## 🏗️ **System Architect Analysis Generator**
-
-### Purpose
-**Specialized command for generating system-architect/analysis.md** that addresses guidance-specification.md discussion points from system architecture perspective. Creates or updates role-specific analysis with framework references.
-
-### Core Function
-- **Framework-based Analysis**: Address each discussion point in guidance-specification.md
-- **Architecture Focus**: Technical architecture, scalability, and system design perspective
-- **Update Mechanism**: Create new or update existing analysis.md
-- **Agent Delegation**: Use conceptual-planning-agent for analysis generation
-
-### Analysis Scope
-- **Technical Architecture**: Scalable and maintainable system design
-- **Technology Selection**: Stack evaluation and architectural decisions
-- **Performance & Scalability**: Capacity planning and optimization strategies
-- **Integration Patterns**: System communication and data flow design
-
-### Role Boundaries & Responsibilities
-
-#### **What This Role OWNS (Macro-Architecture)**
-- **System-Level Architecture**: Service boundaries, deployment topology, and system composition
-- **Cross-Service Communication Patterns**: Choosing between microservices/monolithic, event-driven/request-response, sync/async patterns
-- **Technology Stack Decisions**: Language, framework, database, and infrastructure choices
-- **Non-Functional Requirements**: Scalability, performance, availability, disaster recovery, and monitoring strategies
-- **Integration Planning**: How systems and services connect at the macro level (not specific API contracts)
-
-#### **What This Role DOES NOT Own (Defers to Other Roles)**
-- **API Contract Details**: Specific endpoint definitions, URL structures, HTTP methods → Defers to **API Designer**
-- **Data Schemas**: Detailed data model design and entity relationships → Defers to **Data Architect**
-- **UI/UX Design**: Interface design and user experience → Defers to **UX Expert** and **UI Designer**
-
-#### **Handoff Points**
-- **TO API Designer**: Provides architectural constraints (REST vs GraphQL, sync vs async) that define the API design space
-- **TO Data Architect**: Provides system-level data flow requirements and integration patterns
-- **FROM Data Architect**: Receives canonical data model to inform system integration design
-
-## ⚙️ **Execution Protocol**
-
-### Phase 1: Session & Framework Detection
-```bash
-# Check active session and framework
-CHECK: find .workflow/active/ -name "WFS-*" -type d
-IF active_session EXISTS:
-    session_id = get_active_session()
-    brainstorm_dir = .workflow/active/WFS-{session}/.brainstorming/
-
-    CHECK: brainstorm_dir/guidance-specification.md
-    IF EXISTS:
-        framework_mode = true
-        load_framework = true
-    ELSE:
-        IF topic_provided:
-            framework_mode = false  # Create analysis without framework
-        ELSE:
-            ERROR: "No framework found and no topic provided"
-```
-
-### Phase 2: Analysis Mode Detection
-```bash
-# Check existing analysis
-CHECK: brainstorm_dir/system-architect/analysis.md
-IF EXISTS:
-    SHOW existing analysis summary
-    ASK: "Analysis exists. Do you want to:"
-    OPTIONS:
-      1. "Update with new insights" → Update existing
-      2. "Replace completely" → Generate new
-      3. "Cancel" → Exit without changes
-ELSE:
-    CREATE new analysis
-```
-
-### Phase 3: Agent Task Generation
-**Framework-Based Analysis** (when guidance-specification.md exists):
-```bash
-Task(subagent_type="conceptual-planning-agent",
-     run_in_background=false,
-     prompt="Generate system architect analysis addressing topic framework
-
-     ## Framework Integration Required
-     **MANDATORY**: Load and address guidance-specification.md discussion points
-     **Framework Reference**: @{session.brainstorm_dir}/guidance-specification.md
-     **Output Location**: {session.brainstorm_dir}/system-architect/analysis.md
-
-     ## Analysis Requirements
-     1. **Load Topic Framework**: Read guidance-specification.md completely
-     2. **Address Each Discussion Point**: Respond to all 5 framework sections from system architecture perspective
-     3. **Include Framework Reference**: Start analysis.md with @../guidance-specification.md
-     4. **Technical Focus**: Emphasize scalability, architecture patterns, technology decisions
-     5. **Structured Response**: Use framework structure for analysis organization
-
-     ## Framework Sections to Address
-     - Core Requirements (from architecture perspective)
-     - Technical Considerations (detailed architectural analysis)
-     - User Experience Factors (technical UX considerations)
-     - Implementation Challenges (architecture risks and solutions)
-     - Success Metrics (technical metrics and monitoring)
-
-     ## Output Structure Required
-     ```markdown
-     # System Architect Analysis: [Topic]
-
-     **Framework Reference**: @../guidance-specification.md
-     **Role Focus**: System Architecture and Technical Design
-
-     ## Core Requirements Analysis
-     [Address framework requirements from architecture perspective]
-
-     ## Technical Considerations
-     [Detailed architectural analysis]
-
-     ## User Experience Factors
-     [Technical aspects of UX implementation]
-
-     ## Implementation Challenges
-     [Architecture risks and mitigation strategies]
-
-     ## Success Metrics
-     [Technical metrics and system monitoring]
-
-     ## Architecture-Specific Recommendations
-     [Detailed technical recommendations]
-     ```",
-     description="Generate system architect framework-based analysis")
-```
-
-### Phase 4: Update Mechanism
-**Analysis Update Process**:
-```bash
-# For existing analysis updates
-IF update_mode = "incremental":
-    Task(subagent_type="conceptual-planning-agent",
-         run_in_background=false,
-         prompt="Update existing system architect analysis
-
-         ## Current Analysis Context
-         **Existing Analysis**: @{session.brainstorm_dir}/system-architect/analysis.md
-         **Framework Reference**: @{session.brainstorm_dir}/guidance-specification.md
-
-         ## Update Requirements
-         1. **Preserve Structure**: Maintain existing analysis structure
-         2. **Add New Insights**: Integrate new technical insights and recommendations
-         3. **Framework Alignment**: Ensure continued alignment with topic framework
-         4. **Technical Updates**: Add new architecture patterns, technology considerations
-         5. **Maintain References**: Keep @../guidance-specification.md reference
-
-         ## Update Instructions
-         - Read existing analysis completely
-         - Identify areas for enhancement or new insights
-         - Add technical depth while preserving original structure
-         - Update recommendations with new architectural approaches
-         - Maintain framework discussion point addressing",
-         description="Update system architect analysis incrementally")
-```
-
-## Document Structure
-
-### Output Files
-```
-.workflow/active/WFS-[topic]/.brainstorming/
-├── guidance-specification.md          # Input: Framework (if exists)
-└── system-architect/
-    └── analysis.md            # ★ OUTPUT: Framework-based analysis
-```
-
-### Analysis Structure
-**Required Elements**:
-- **Framework Reference**: @../guidance-specification.md (if framework exists)
-- **Role Focus**: System Architecture and Technical Design perspective
-- **5 Framework Sections**: Address each framework discussion point
-- **Technical Recommendations**: Architecture-specific insights and solutions
-- How should we design APIs and manage versioning?
-
-**4. Performance and Scalability**
-- Where are the current system performance bottlenecks?
-- How should we handle traffic growth and scaling demands?
-- What database scaling and optimization strategies are needed?
-
-## ⚡ **Two-Step Execution Flow**
-
-### ⚠️ Session Management - FIRST STEP
-Session detection and selection:
-```bash
-# Check for existing sessions
-existing_sessions=$(find .workflow/active/ -name "WFS-*" -type d 2>/dev/null)
-if [ multiple_sessions ]; then
-  prompt_user_to_select_session()
-else
-  use_existing_or_create_new()
-fi
-```
-
-### Step 1: Context Gathering Phase
-**System Architect Perspective Questioning**
-
-Before agent assignment, gather comprehensive system architecture context:
-
-#### 📋 Role-Specific Questions
-1. **Scale & Performance Requirements**
-   - Expected user load and traffic patterns?
-   - Performance requirements (latency, throughput)?
-   - Data volume and growth projections?
-
-2. **Technical Constraints & Environment**
-   - Existing technology stack and constraints?
-   - Integration requirements with external systems?
-   - Infrastructure and deployment environment?
-
-3. **Architecture Complexity & Patterns**
-   - Microservices vs monolithic considerations?
-   - Data consistency and transaction requirements?
-   - Event-driven vs request-response patterns?
-
-4. **Non-Functional Requirements**
-   - High availability and disaster recovery needs?
-   - Security and compliance requirements?
-   - Monitoring and observability expectations?
-
-#### Context Validation
-- **Minimum Response**: Each answer must be ≥50 characters
-- **Re-prompting**: Insufficient detail triggers follow-up questions
-- **Context Storage**: Save responses to `.brainstorming/system-architect-context.md`
-
-### Step 2: Agent Assignment with Flow Control
-**Dedicated Agent Execution**
-
-```bash
-Task(conceptual-planning-agent): "
-[FLOW_CONTROL]
-
-Execute dedicated system-architect conceptual analysis for: {topic}
-
-ASSIGNED_ROLE: system-architect
-OUTPUT_LOCATION: .brainstorming/system-architect/
-USER_CONTEXT: {validated_responses_from_context_gathering}
-
-Flow Control Steps:
-[
-  {
-    \"step\": \"load_role_template\",
-    \"action\": \"Load system-architect planning template\",
-    \"command\": \"bash($(cat ~/.claude/workflows/cli-templates/planning-roles/system-architect.md))\",
-    \"output_to\": \"role_template\"
-  }
-]
-
-Conceptual Analysis Requirements:
-- Apply system-architect perspective to topic analysis
-- Focus on architectural patterns, scalability, and integration points
-- Use loaded role template framework for analysis structure
-- Generate role-specific deliverables in designated output location
-- Address all user context from questioning phase
-
-Deliverables:
-- analysis.md: Main system architecture analysis
-- recommendations.md: Architecture recommendations
-- deliverables/: Architecture-specific outputs as defined in role template
-
-Embody system-architect role expertise for comprehensive conceptual planning."
-```
-
-### Progress Tracking
-TodoWrite tracking for two-step process:
-```json
-[
-  {"content": "Gather system architect context through role-specific questioning", "status": "in_progress", "activeForm": "Gathering context"},
-  {"content": "Validate context responses and save to system-architect-context.md", "status": "pending", "activeForm": "Validating context"},
-  {"content": "Load system-architect planning template via flow control", "status": "pending", "activeForm": "Loading template"},
-  {"content": "Execute dedicated conceptual-planning-agent for system-architect role", "status": "pending", "activeForm": "Executing agent"}
-]
-```
-
-## 📊 **Output Specification**
-
-### Output Location
-```
-.workflow/active/WFS-{topic-slug}/.brainstorming/system-architect/
-├── analysis.md                 # Primary architecture analysis
-├── architecture-design.md      # Detailed system design and diagrams
-├── technology-stack.md         # Technology stack recommendations and justifications
-└── integration-plan.md         # System integration and API strategies
-```
-
-### Document Templates
-
-#### analysis.md Structure
-```markdown
-# System Architecture Analysis: {Topic}
-*Generated: {timestamp}*
-
-## Executive Summary
-[Key architectural findings and recommendations overview]
-
-## Current State Assessment
-### Existing Architecture Overview
-### Technical Stack Analysis
-### Performance Bottlenecks
-### Technical Debt Assessment
-
-## Requirements Analysis
-### Functional Requirements
-### Non-Functional Requirements
-- Performance: [Response time, throughput requirements]
-- Scalability: [User growth, data volume expectations]
-- Availability: [Uptime requirements]
-- Security: [Security requirements]
-
-## Proposed Architecture
-### High-Level Architecture Design
-### Component Breakdown
-### Data Flow Diagrams
-### Technology Stack Recommendations
-
-## Implementation Strategy
-### Migration Planning
-### Risk Mitigation
-### Performance Optimization
-### Security Considerations
-
-## Scalability and Maintenance
-### Horizontal Scaling Strategy
-### Monitoring and Observability
-### Deployment Strategy
-### Long-term Maintenance Plan
-```
-
-## 🔄 **Session Integration**
-
-### Status Synchronization
-Upon completion, update `workflow-session.json`:
-```json
-{
-  "phases": {
-    "BRAINSTORM": {
-      "system_architect": {
-        "status": "completed",
-        "completed_at": "timestamp",
-        "output_directory": ".workflow/active/WFS-{topic}/.brainstorming/system-architect/",
-        "key_insights": ["scalability_bottleneck", "architecture_pattern", "technology_recommendation"]
-      }
-    }
-  }
-}
-```
-
-### Cross-Role Collaboration
-System architect perspective provides:
-- **Technical Constraints and Possibilities** → Product Manager
-- **Architecture Requirements and Limitations** → UI Designer
-- **Data Architecture Requirements** → Data Architect
-- **Security Architecture Framework** → Security Expert
-- **Technical Implementation Framework** → Feature Planner
-
-## ✅ **Quality Assurance**
-
-### Required Analysis Elements
-- [ ] Clear architecture diagrams and component designs
-- [ ] Detailed technology stack evaluation and recommendations
-- [ ] Scalability and performance analysis with metrics
-- [ ] System integration and API design specifications
-- [ ] Comprehensive risk assessment and mitigation strategies
-
-### Architecture Design Principles
-- [ ] **Scalability**: System can handle growth in users and data
-- [ ] **Maintainability**: Clear code structure, easy to modify and extend
-- [ ] **Reliability**: Built-in fault tolerance and recovery mechanisms
-- [ ] **Security**: Integrated security controls and protection measures
-- [ ] **Performance**: Meets response time and throughput requirements
-
-### Technical Decision Validation
-- [ ] Technology choices have thorough justification and comparison analysis
-- [ ] Architectural patterns align with business requirements and constraints
-- [ ] Integration solutions consider compatibility and maintenance costs
-- [ ] Deployment strategies are feasible with acceptable risk levels
-- [ ] Monitoring and operations strategies are comprehensive and actionable
-
-### Implementation Readiness
-- [ ] **Technical Feasibility**: All proposed solutions are technically achievable
-- [ ] **Resource Planning**: Resource requirements clearly defined and realistic
-- [ ] **Risk Management**: Technical risks identified with mitigation plans
-- [ ] **Performance Validation**: Architecture can meet performance requirements
-- [ ] **Evolution Strategy**: Design allows for future growth and changes

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

@@ -1,221 +0,0 @@
----
-name: ui-designer
-description: Generate or update ui-designer/analysis.md addressing guidance-specification discussion points for UI design perspective
-argument-hint: "optional topic - uses existing framework if available"
-allowed-tools: Task(conceptual-planning-agent), TodoWrite(*), Read(*), Write(*)
----
-
-## 🎨 **UI Designer Analysis Generator**
-
-### Purpose
-**Specialized command for generating ui-designer/analysis.md** that addresses guidance-specification.md discussion points from UI/UX design perspective. Creates or updates role-specific analysis with framework references.
-
-### Core Function
-- **Framework-based Analysis**: Address each discussion point in guidance-specification.md
-- **UI/UX Focus**: User experience, interface design, and accessibility perspective
-- **Update Mechanism**: Create new or update existing analysis.md
-- **Agent Delegation**: Use conceptual-planning-agent for analysis generation
-
-### Analysis Scope
-- **Visual Design**: Color palettes, typography, spacing, and visual hierarchy implementation
-- **High-Fidelity Mockups**: Polished, pixel-perfect interface designs
-- **Design System Implementation**: Component libraries, design tokens, and style guides
-- **Micro-Interactions & Animations**: Transition effects, loading states, and interactive feedback
-- **Responsive Design**: Layout adaptations for different screen sizes and devices
-
-### Role Boundaries & Responsibilities
-
-#### **What This Role OWNS (Concrete Visual Interface Implementation)**
-- **Visual Design Language**: Colors, typography, iconography, spacing, and overall aesthetic
-- **High-Fidelity Mockups**: Polished designs showing exactly how the interface will look
-- **Design System Components**: Building and documenting reusable UI components (buttons, inputs, cards, etc.)
-- **Design Tokens**: Defining variables for colors, spacing, typography that can be used in code
-- **Micro-Interactions**: Hover states, transitions, animations, and interactive feedback details
-- **Responsive Layouts**: Adapting designs for mobile, tablet, and desktop breakpoints
-
-#### **What This Role DOES NOT Own (Defers to Other Roles)**
-- **User Research & Personas**: User behavior analysis and needs assessment → Defers to **UX Expert**
-- **Information Architecture**: Content structure and navigation strategy → Defers to **UX Expert**
-- **Low-Fidelity Wireframes**: Structural layouts without visual design → Defers to **UX Expert**
-
-#### **Handoff Points**
-- **FROM UX Expert**: Receives wireframes, user flows, and information architecture as the foundation for visual design
-- **TO Frontend Developers**: Provides design specifications, component libraries, and design tokens for implementation
-- **WITH API Designer**: Coordinates on data presentation and form validation feedback (visual aspects only)
-
-## ⚙️ **Execution Protocol**
-
-### Phase 1: Session & Framework Detection
-```bash
-# Check active session and framework
-CHECK: find .workflow/active/ -name "WFS-*" -type d
-IF active_session EXISTS:
-    session_id = get_active_session()
-    brainstorm_dir = .workflow/active/WFS-{session}/.brainstorming/
-
-    CHECK: brainstorm_dir/guidance-specification.md
-    IF EXISTS:
-        framework_mode = true
-        load_framework = true
-    ELSE:
-        IF topic_provided:
-            framework_mode = false  # Create analysis without framework
-        ELSE:
-            ERROR: "No framework found and no topic provided"
-```
-
-### Phase 2: Analysis Mode Detection
-```bash
-# Determine execution mode
-IF framework_mode == true:
-    mode = "framework_based_analysis"
-    topic_ref = load_framework_topic()
-    discussion_points = extract_framework_points()
-ELSE:
-    mode = "standalone_analysis"
-    topic_ref = provided_topic
-    discussion_points = generate_basic_structure()
-```
-
-### Phase 3: Agent Execution with Flow Control
-**Framework-Based Analysis Generation**
-
-```bash
-Task(conceptual-planning-agent): "
-[FLOW_CONTROL]
-
-Execute ui-designer analysis for existing topic framework
-
-## Context Loading
-ASSIGNED_ROLE: ui-designer
-OUTPUT_LOCATION: .workflow/active/WFS-{session}/.brainstorming/ui-designer/
-ANALYSIS_MODE: {framework_mode ? "framework_based" : "standalone"}
-
-## Flow Control Steps
-1. **load_topic_framework**
-   - Action: Load structured topic discussion framework
-   - Command: Read(.workflow/active/WFS-{session}/.brainstorming/guidance-specification.md)
-   - Output: topic_framework_content
-
-2. **load_role_template**
-   - Action: Load ui-designer planning template
-   - Command: bash($(cat ~/.claude/workflows/cli-templates/planning-roles/ui-designer.md))
-   - Output: role_template_guidelines
-
-3. **load_session_metadata**
-   - Action: Load session metadata and existing context
-   - Command: Read(.workflow/active/WFS-{session}/workflow-session.json)
-   - Output: session_context
-
-## Analysis Requirements
-**Framework Reference**: Address all discussion points in guidance-specification.md from UI/UX perspective
-**Role Focus**: User experience design, interface optimization, accessibility compliance
-**Structured Approach**: Create analysis.md addressing framework discussion points
-**Template Integration**: Apply role template guidelines within framework structure
-
-## Expected Deliverables
-1. **analysis.md**: Comprehensive UI/UX analysis addressing all framework discussion points
-2. **Framework Reference**: Include @../guidance-specification.md reference in analysis
-
-## Completion Criteria
-- Address each discussion point from guidance-specification.md with UI/UX design expertise
-- Provide actionable design recommendations and interface solutions
-- Include accessibility considerations and WCAG compliance planning
-- Reference framework document using @ notation for integration
-"
-```
-
-## 📋 **TodoWrite Integration**
-
-### Workflow Progress Tracking
-```javascript
-TodoWrite({
-  todos: [
-    {
-      content: "Detect active session and locate topic framework",
-      status: "in_progress",
-      activeForm: "Detecting session and framework"
-    },
-    {
-      content: "Load guidance-specification.md and session metadata for context",
-      status: "pending",
-      activeForm: "Loading framework and session context"
-    },
-    {
-      content: "Execute ui-designer analysis using conceptual-planning-agent with FLOW_CONTROL",
-      status: "pending",
-      activeForm: "Executing ui-designer framework analysis"
-    },
-    {
-      content: "Generate analysis.md addressing all framework discussion points",
-      status: "pending",
-      activeForm: "Generating structured ui-designer analysis"
-    },
-    {
-      content: "Update workflow-session.json with ui-designer completion status",
-      status: "pending",
-      activeForm: "Updating session metadata"
-    }
-  ]
-});
-```
-
-## 📊 **Output Structure**
-
-### Framework-Based Analysis
-```
-.workflow/active/WFS-{session}/.brainstorming/ui-designer/
-└── analysis.md    # Structured analysis addressing guidance-specification.md discussion points
-```
-
-### Analysis Document Structure
-```markdown
-# UI Designer Analysis: [Topic from Framework]
-
-## Framework Reference
-**Topic Framework**: @../guidance-specification.md
-**Role Focus**: UI/UX Design perspective
-
-## Discussion Points Analysis
-[Address each point from guidance-specification.md with UI/UX expertise]
-
-### Core Requirements (from framework)
-[UI/UX perspective on requirements]
-
-### Technical Considerations (from framework)
-[Interface and design system considerations]
-
-### User Experience Factors (from framework)
-[Detailed UX analysis and recommendations]
-
-### Implementation Challenges (from framework)
-[Design implementation and accessibility considerations]
-
-### Success Metrics (from framework)
-[UX metrics and usability success criteria]
-
-## UI/UX Specific Recommendations
-[Role-specific design recommendations and solutions]
-
----
-*Generated by ui-designer analysis addressing structured framework*
-```
-
-## 🔄 **Session Integration**
-
-### Completion Status Update
-```json
-{
-  "ui_designer": {
-    "status": "completed",
-    "framework_addressed": true,
-    "output_location": ".workflow/active/WFS-{session}/.brainstorming/ui-designer/analysis.md",
-    "framework_reference": "@../guidance-specification.md"
-  }
-}
-```
-
-### Integration Points
-- **Framework Reference**: @../guidance-specification.md for structured discussion points
-- **Cross-Role Synthesis**: UI/UX insights available for synthesis-report.md integration
-- **Agent Autonomy**: Independent execution with framework guidance

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

@@ -1,221 +0,0 @@
----
-name: ux-expert
-description: Generate or update ux-expert/analysis.md addressing guidance-specification discussion points for UX perspective
-argument-hint: "optional topic - uses existing framework if available"
-allowed-tools: Task(conceptual-planning-agent), TodoWrite(*), Read(*), Write(*)
----
-
-## 🎯 **UX Expert Analysis Generator**
-
-### Purpose
-**Specialized command for generating ux-expert/analysis.md** that addresses guidance-specification.md discussion points from user experience and interface design perspective. Creates or updates role-specific analysis with framework references.
-
-### Core Function
-- **Framework-based Analysis**: Address each discussion point in guidance-specification.md
-- **UX Design Focus**: User interface, interaction patterns, and usability optimization
-- **Update Mechanism**: Create new or update existing analysis.md
-- **Agent Delegation**: Use conceptual-planning-agent for analysis generation
-
-### Analysis Scope
-- **User Research**: User personas, behavioral analysis, and needs assessment
-- **Information Architecture**: Content structure, navigation hierarchy, and mental models
-- **User Journey Mapping**: User flows, task analysis, and interaction models
-- **Usability Strategy**: Accessibility planning, cognitive load reduction, and user testing frameworks
-- **Wireframing**: Low-fidelity layouts and structural prototypes (not visual design)
-
-### Role Boundaries & Responsibilities
-
-#### **What This Role OWNS (Abstract User Experience & Research)**
-- **User Research & Personas**: Understanding target users, their goals, pain points, and behaviors
-- **Information Architecture**: Organizing content and defining navigation structures at a conceptual level
-- **User Journey Mapping**: Defining user flows, task sequences, and interaction models
-- **Wireframes & Low-Fidelity Prototypes**: Structural layouts showing information hierarchy (boxes and arrows, not colors/fonts)
-- **Usability Testing Strategy**: Planning user testing, A/B tests, and validation methods
-- **Accessibility Planning**: WCAG compliance strategy and inclusive design principles
-
-#### **What This Role DOES NOT Own (Defers to Other Roles)**
-- **Visual Design**: Colors, typography, spacing, visual style → Defers to **UI Designer**
-- **High-Fidelity Mockups**: Polished, pixel-perfect designs → Defers to **UI Designer**
-- **Component Implementation**: Design system components, CSS, animations → Defers to **UI Designer**
-
-#### **Handoff Points**
-- **TO UI Designer**: Provides wireframes, user flows, and information architecture that UI Designer will transform into high-fidelity visual designs
-- **FROM User Research**: May receive external research data to inform UX decisions
-- **TO Product Owner**: Provides user insights and validation results to inform feature prioritization
-
-## ⚙️ **Execution Protocol**
-
-### Phase 1: Session & Framework Detection
-```bash
-# Check active session and framework
-CHECK: find .workflow/active/ -name "WFS-*" -type d
-IF active_session EXISTS:
-    session_id = get_active_session()
-    brainstorm_dir = .workflow/active/WFS-{session}/.brainstorming/
-
-    CHECK: brainstorm_dir/guidance-specification.md
-    IF EXISTS:
-        framework_mode = true
-        load_framework = true
-    ELSE:
-        IF topic_provided:
-            framework_mode = false  # Create analysis without framework
-        ELSE:
-            ERROR: "No framework found and no topic provided"
-```
-
-### Phase 2: Analysis Mode Detection
-```bash
-# Determine execution mode
-IF framework_mode == true:
-    mode = "framework_based_analysis"
-    topic_ref = load_framework_topic()
-    discussion_points = extract_framework_points()
-ELSE:
-    mode = "standalone_analysis"
-    topic_ref = provided_topic
-    discussion_points = generate_basic_structure()
-```
-
-### Phase 3: Agent Execution with Flow Control
-**Framework-Based Analysis Generation**
-
-```bash
-Task(conceptual-planning-agent): "
-[FLOW_CONTROL]
-
-Execute ux-expert analysis for existing topic framework
-
-## Context Loading
-ASSIGNED_ROLE: ux-expert
-OUTPUT_LOCATION: .workflow/active/WFS-{session}/.brainstorming/ux-expert/
-ANALYSIS_MODE: {framework_mode ? "framework_based" : "standalone"}
-
-## Flow Control Steps
-1. **load_topic_framework**
-   - Action: Load structured topic discussion framework
-   - Command: Read(.workflow/active/WFS-{session}/.brainstorming/guidance-specification.md)
-   - Output: topic_framework_content
-
-2. **load_role_template**
-   - Action: Load ux-expert planning template
-   - Command: bash($(cat ~/.claude/workflows/cli-templates/planning-roles/ux-expert.md))
-   - Output: role_template_guidelines
-
-3. **load_session_metadata**
-   - Action: Load session metadata and existing context
-   - Command: Read(.workflow/active/WFS-{session}/workflow-session.json)
-   - Output: session_context
-
-## Analysis Requirements
-**Framework Reference**: Address all discussion points in guidance-specification.md from user experience and interface design perspective
-**Role Focus**: UI design, interaction patterns, usability optimization, design systems
-**Structured Approach**: Create analysis.md addressing framework discussion points
-**Template Integration**: Apply role template guidelines within framework structure
-
-## Expected Deliverables
-1. **analysis.md**: Comprehensive UX design analysis addressing all framework discussion points
-2. **Framework Reference**: Include @../guidance-specification.md reference in analysis
-
-## Completion Criteria
-- Address each discussion point from guidance-specification.md with UX design expertise
-- Provide actionable interface design and usability optimization strategies
-- Include accessibility considerations and interaction pattern recommendations
-- Reference framework document using @ notation for integration
-"
-```
-
-## 📋 **TodoWrite Integration**
-
-### Workflow Progress Tracking
-```javascript
-TodoWrite({
-  todos: [
-    {
-      content: "Detect active session and locate topic framework",
-      status: "in_progress",
-      activeForm: "Detecting session and framework"
-    },
-    {
-      content: "Load guidance-specification.md and session metadata for context",
-      status: "pending",
-      activeForm: "Loading framework and session context"
-    },
-    {
-      content: "Execute ux-expert analysis using conceptual-planning-agent with FLOW_CONTROL",
-      status: "pending",
-      activeForm: "Executing ux-expert framework analysis"
-    },
-    {
-      content: "Generate analysis.md addressing all framework discussion points",
-      status: "pending",
-      activeForm: "Generating structured ux-expert analysis"
-    },
-    {
-      content: "Update workflow-session.json with ux-expert completion status",
-      status: "pending",
-      activeForm: "Updating session metadata"
-    }
-  ]
-});
-```
-
-## 📊 **Output Structure**
-
-### Framework-Based Analysis
-```
-.workflow/active/WFS-{session}/.brainstorming/ux-expert/
-└── analysis.md    # Structured analysis addressing guidance-specification.md discussion points
-```
-
-### Analysis Document Structure
-```markdown
-# UX Expert Analysis: [Topic from Framework]
-
-## Framework Reference
-**Topic Framework**: @../guidance-specification.md
-**Role Focus**: User Experience & Interface Design perspective
-
-## Discussion Points Analysis
-[Address each point from guidance-specification.md with UX design expertise]
-
-### Core Requirements (from framework)
-[User interface and interaction design requirements perspective]
-
-### Technical Considerations (from framework)
-[Design system implementation and technical feasibility considerations]
-
-### User Experience Factors (from framework)
-[Usability optimization, accessibility, and user-centered design analysis]
-
-### Implementation Challenges (from framework)
-[Design implementation challenges and progressive enhancement strategies]
-
-### Success Metrics (from framework)
-[UX metrics including usability testing, user satisfaction, and design KPIs]
-
-## UX Expert Specific Recommendations
-[Role-specific interface design patterns and usability optimization strategies]
-
----
-*Generated by ux-expert analysis addressing structured framework*
-```
-
-## 🔄 **Session Integration**
-
-### Completion Status Update
-```json
-{
-  "ux_expert": {
-    "status": "completed",
-    "framework_addressed": true,
-    "output_location": ".workflow/active/WFS-{session}/.brainstorming/ux-expert/analysis.md",
-    "framework_reference": "@../guidance-specification.md"
-  }
-}
-```
-
-### Integration Points
-- **Framework Reference**: @../guidance-specification.md for structured discussion points
-- **Cross-Role Synthesis**: UX design insights available for synthesis-report.md integration
-- **Agent Autonomy**: Independent execution with framework guidance

.claude/commands/workflow/clean.md

@@ -1,7 +1,7 @@
 ---
 name: clean
 description: Intelligent code cleanup with mainline detection, stale artifact discovery, and safe execution
-argument-hint: "[--dry-run] [\"focus area\"]"
+argument-hint: "[-y|--yes] [--dry-run] [\"focus area\"]"
 allowed-tools: TodoWrite(*), Task(*), AskUserQuestion(*), Read(*), Glob(*), Bash(*), Write(*)
 ---
 
@@ -21,8 +21,22 @@ Intelligent cleanup command that explores the codebase to identify the developme
 
 ```bash
 /workflow:clean                          # Full intelligent cleanup (explore → analyze → confirm → execute)
+/workflow:clean --yes                    # Auto mode (use safe defaults, no confirmation)
 /workflow:clean --dry-run                # Explore and analyze only, no execution
-/workflow:clean "auth module"            # Focus cleanup on specific area
+/workflow:clean -y "auth module"         # Auto mode with focus area
+```
+
+## Auto Mode Defaults
+
+When `--yes` or `-y` flag is used:
+- **Categories to Clean**: Auto-selects `["Sessions"]` only (safest - only workflow sessions)
+- **Risk Level**: Auto-selects `"Low only"` (only low-risk items)
+- All confirmations skipped, proceeds directly to execution
+
+**Flag Parsing**:
+```javascript
+const autoYes = $ARGUMENTS.includes('--yes') || $ARGUMENTS.includes('-y')
+const dryRun = $ARGUMENTS.includes('--dry-run')
 ```
 
 ## Execution Process
@@ -329,39 +343,57 @@ To execute cleanup: /workflow:clean
 
 **Step 3.3: User Confirmation**
 ```javascript
-AskUserQuestion({
-  questions: [
-    {
-      question: "Which categories to clean?",
-      header: "Categories",
-      multiSelect: true,
-      options: [
-        {
-          label: "Sessions",
-          description: `${manifest.summary.by_category.stale_sessions} stale workflow sessions`
-        },
-        {
-          label: "Documents",
-          description: `${manifest.summary.by_category.drifted_documents} drifted documents`
-        },
-        {
-          label: "Dead Code",
-          description: `${manifest.summary.by_category.dead_code} unused code files`
-        }
-      ]
-    },
-    {
-      question: "Risk level to include?",
-      header: "Risk",
-      multiSelect: false,
-      options: [
-        { label: "Low only", description: "Safest - only obviously stale items" },
-        { label: "Low + Medium", description: "Recommended - includes likely unused items" },
-        { label: "All", description: "Aggressive - includes high-risk items" }
-      ]
-    }
-  ]
-})
+// Parse --yes flag
+const autoYes = $ARGUMENTS.includes('--yes') || $ARGUMENTS.includes('-y')
+
+let userSelection
+
+if (autoYes) {
+  // Auto mode: Use safe defaults
+  console.log(`[--yes] Auto-selecting safe cleanup defaults:`)
+  console.log(`  - Categories: Sessions only`)
+  console.log(`  - Risk level: Low only`)
+
+  userSelection = {
+    categories: ["Sessions"],
+    risk: "Low only"
+  }
+} else {
+  // Interactive mode: Ask user
+  userSelection = AskUserQuestion({
+    questions: [
+      {
+        question: "Which categories to clean?",
+        header: "Categories",
+        multiSelect: true,
+        options: [
+          {
+            label: "Sessions",
+            description: `${manifest.summary.by_category.stale_sessions} stale workflow sessions`
+          },
+          {
+            label: "Documents",
+            description: `${manifest.summary.by_category.drifted_documents} drifted documents`
+          },
+          {
+            label: "Dead Code",
+            description: `${manifest.summary.by_category.dead_code} unused code files`
+          }
+        ]
+      },
+      {
+        question: "Risk level to include?",
+        header: "Risk",
+        multiSelect: false,
+        options: [
+          { label: "Low only", description: "Safest - only obviously stale items" },
+          { label: "Low + Medium", description: "Recommended - includes likely unused items" },
+          { label: "All", description: "Aggressive - includes high-risk items" }
+        ]
+      }
+    ]
+  })
+}
 ```
 
 ---

.claude/commands/workflow/debug-with-file.md

@@ -1,10 +1,14 @@
 ---
 name: debug-with-file
 description: Interactive hypothesis-driven debugging with documented exploration, understanding evolution, and Gemini-assisted correction
-argument-hint: "\"bug description or error message\""
+argument-hint: "[-y|--yes] \"bug description or error message\""
 allowed-tools: TodoWrite(*), Task(*), AskUserQuestion(*), Read(*), Grep(*), Glob(*), Bash(*), Edit(*), Write(*)
 ---
 
+## Auto Mode
+
+When `--yes` or `-y`: Auto-confirm all decisions (hypotheses, fixes, iteration), use recommended settings.
+
 # Workflow Debug-With-File Command (/workflow:debug-with-file)
 
 ## Overview
@@ -13,6 +17,8 @@ Enhanced evidence-based debugging with **documented exploration process**. Recor
 
 **Core workflow**: Explore → Document → Log → Analyze → Correct Understanding → Fix → Verify
 
+**Scope**: Adds temporary debug logging to observe program state; cleans up all instrumentation after resolution. Does NOT execute code injection, security testing, or modify program behavior.
+
 **Key enhancements over /workflow:debug**:
 - **understanding.md**: Timeline of exploration and learning
 - **Gemini-assisted correction**: Validates and corrects hypotheses
@@ -40,7 +46,7 @@ Explore Mode:
    ├─ Locate error source in codebase
    ├─ Document initial understanding in understanding.md
    ├─ Generate testable hypotheses with Gemini validation
-   ├─ Add NDJSON logging instrumentation
+   ├─ Add NDJSON debug logging statements
    └─ Output: Hypothesis list + await user reproduction
 
 Analyze Mode:
@@ -212,9 +218,9 @@ Save Gemini output to `hypotheses.json`:
 }
 ```
 
-**Step 1.4: Add NDJSON Instrumentation**
+**Step 1.4: Add NDJSON Debug Logging**
 
-For each hypothesis, add logging (same as original debug command).
+For each hypothesis, add temporary logging statements to observe program state at key execution points. Use NDJSON format for structured log parsing. These are read-only observations that do not modify program behavior.
 
 **Step 1.5: Update understanding.md**
 
@@ -437,7 +443,7 @@ What we learned from this debugging session:
 
 **Step 3.3: Cleanup**
 
-Remove debug instrumentation (same as original command).
+Remove all temporary debug logging statements added during investigation. Verify no instrumentation code remains in production code.
 
 ---
 
@@ -643,7 +649,7 @@ Why is config value None during update?
 
 | Feature | /workflow:debug | /workflow:debug-with-file |
 |---------|-----------------|---------------------------|
-| NDJSON logging | ✅ | ✅ |
+| NDJSON debug logging | ✅ | ✅ |
 | Hypothesis generation | Manual | Gemini-assisted |
 | Exploration documentation | ❌ | ✅ understanding.md |
 | Understanding evolution | ❌ | ✅ Timeline + corrections |

.claude/commands/workflow/debug.md

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

.claude/commands/workflow/execute.md

@@ -1,7 +1,7 @@
 ---
 name: execute
 description: Coordinate agent execution for workflow tasks with automatic session discovery, parallel task processing, and status tracking
-argument-hint: "[--resume-session=\"session-id\"]"
+argument-hint: "[-y|--yes] [--resume-session=\"session-id\"]"
 ---
 
 # Workflow Execute Command
@@ -11,6 +11,30 @@ Orchestrates autonomous workflow execution through systematic task discovery, ag
 
 **Resume Mode**: When called with `--resume-session` flag, skips discovery phase and directly enters TodoWrite generation and agent execution for the specified session.
 
+## Usage
+
+```bash
+# Interactive mode (with confirmations)
+/workflow:execute
+/workflow:execute --resume-session="WFS-auth"
+
+# Auto mode (skip confirmations, use defaults)
+/workflow:execute --yes
+/workflow:execute -y
+/workflow:execute -y --resume-session="WFS-auth"
+```
+
+## Auto Mode Defaults
+
+When `--yes` or `-y` flag is used:
+- **Session Selection**: Automatically selects the first (most recent) active session
+- **Completion Choice**: Automatically completes session (runs `/workflow:session:complete --yes`)
+
+**Flag Parsing**:
+```javascript
+const autoYes = $ARGUMENTS.includes('--yes') || $ARGUMENTS.includes('-y')
+```
+
 ## Performance Optimization Strategy
 
 **Lazy Loading**: Task JSONs read **on-demand** during execution, not upfront. TODO_LIST.md + IMPL_PLAN.md provide metadata for planning.
@@ -122,24 +146,38 @@ List sessions with metadata and prompt user selection:
 bash(for dir in .workflow/active/WFS-*/; do [ -d "$dir" ] || continue; session=$(basename "$dir"); project=$(jq -r '.project // "Unknown"' "${dir}workflow-session.json" 2>/dev/null || echo "Unknown"); total=$(grep -c '^\- \[' "${dir}TODO_LIST.md" 2>/dev/null || echo 0); completed=$(grep -c '^\- \[x\]' "${dir}TODO_LIST.md" 2>/dev/null || echo 0); if [ "$total" -gt 0 ]; then progress=$((completed * 100 / total)); else progress=0; fi; echo "$session | $project | $completed/$total tasks ($progress%)"; done)
 ```
 
-Use AskUserQuestion to present formatted options (max 4 options shown):
+**Parse --yes flag**:
 ```javascript
-// If more than 4 sessions, show most recent 4 with "Other" option for manual input
-const sessions = getActiveSessions()  // sorted by last modified
-const displaySessions = sessions.slice(0, 4)
+const autoYes = $ARGUMENTS.includes('--yes') || $ARGUMENTS.includes('-y')
+```
 
-AskUserQuestion({
-  questions: [{
-    question: "Multiple active sessions detected. Select one:",
-    header: "Session",
-    multiSelect: false,
-    options: displaySessions.map(s => ({
-      label: s.id,
-      description: `${s.project} | ${s.progress}`
-    }))
-    // Note: User can select "Other" to manually enter session ID
-  }]
-})
+**Conditional Selection**:
+```javascript
+if (autoYes) {
+  // Auto mode: Select first session (most recent)
+  const firstSession = sessions[0]
+  console.log(`[--yes] Auto-selecting session: ${firstSession.id}`)
+  selectedSessionId = firstSession.id
+  // Continue to Phase 2
+} else {
+  // Interactive mode: Use AskUserQuestion to present formatted options (max 4 options shown)
+  // If more than 4 sessions, show most recent 4 with "Other" option for manual input
+  const sessions = getActiveSessions()  // sorted by last modified
+  const displaySessions = sessions.slice(0, 4)
+
+  AskUserQuestion({
+    questions: [{
+      question: "Multiple active sessions detected. Select one:",
+      header: "Session",
+      multiSelect: false,
+      options: displaySessions.map(s => ({
+        label: s.id,
+        description: `${s.project} | ${s.progress}`
+      }))
+      // Note: User can select "Other" to manually enter session ID
+    }]
+  })
+}
 ```
 
 **Input Validation**:
@@ -252,23 +290,33 @@ while (TODO_LIST.md has pending tasks) {
 6. **User Choice**: When all tasks finished, ask user to choose next step:
 
 ```javascript
-AskUserQuestion({
-  questions: [{
-    question: "All tasks completed. What would you like to do next?",
-    header: "Next Step",
-    multiSelect: false,
-    options: [
-      {
-        label: "Enter Review",
-        description: "Run specialized review (security/architecture/quality/action-items)"
-      },
-      {
-        label: "Complete Session",
-        description: "Archive session and update manifest"
-      }
-    ]
-  }]
-})
+// Parse --yes flag
+const autoYes = $ARGUMENTS.includes('--yes') || $ARGUMENTS.includes('-y')
+
+if (autoYes) {
+  // Auto mode: Complete session automatically
+  console.log(`[--yes] Auto-selecting: Complete Session`)
+  SlashCommand("/workflow:session:complete --yes")
+} else {
+  // Interactive mode: Ask user
+  AskUserQuestion({
+    questions: [{
+      question: "All tasks completed. What would you like to do next?",
+      header: "Next Step",
+      multiSelect: false,
+      options: [
+        {
+          label: "Enter Review",
+          description: "Run specialized review (security/architecture/quality/action-items)"
+        },
+        {
+          label: "Complete Session",
+          description: "Archive session and update manifest"
+        }
+      ]
+    }]
+  })
+}
 ```
 
 **Based on user selection**:
@@ -429,7 +477,7 @@ Task(subagent_type="{meta.agent}",
      - TODO List: {session.todo_list_path}
      - Summaries: {session.summaries_dir}
 
-     **Execution**: Read task JSON → Parse flow_control → Execute implementation_approach → Update TODO_LIST.md → Generate summary",
+     **Execution**: Read task JSON → Execute pre_analysis → Check execution_config.method → (CLI: handoff to CLI tool | Agent: direct implementation) → Update TODO_LIST.md → Generate summary",
      description="Implement: {task.id}")
 ```
 
@@ -438,9 +486,11 @@ Task(subagent_type="{meta.agent}",
 - `[FLOW_CONTROL]`: Triggers flow_control.pre_analysis execution
 
 **Why Path-Based**: Agent (code-developer.md) autonomously:
-- Reads and parses task JSON (requirements, acceptance, flow_control)
-- Loads tech stack guidelines based on detected language
-- Executes pre_analysis steps and implementation_approach
+- Reads and parses task JSON (requirements, acceptance, flow_control, execution_config)
+- Executes pre_analysis steps (Phase 1: context gathering)
+- Checks execution_config.method (Phase 2: determine mode)
+- CLI mode: Builds handoff prompt and executes via ccw cli with resume strategy
+- Agent mode: Directly implements using modification_points and logic_flow
 - Generates structured summary with integration points
 
 Embedding task content in prompt creates duplication and conflicts with agent's parsing logic.

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

@@ -1,7 +1,7 @@
 ---
 name: lite-execute
 description: Execute tasks based on in-memory plan, prompt description, or file content
-argument-hint: "[--in-memory] [\"task description\"|file-path]"
+argument-hint: "[-y|--yes] [--in-memory] [\"task description\"|file-path]"
 allowed-tools: TodoWrite(*), Task(*), Bash(*)
 ---
 
@@ -62,31 +62,49 @@ Flexible task execution command supporting three input modes: in-memory plan (fr
 
 **User Interaction**:
 ```javascript
-AskUserQuestion({
-  questions: [
-    {
-      question: "Select execution method:",
-      header: "Execution",
-      multiSelect: false,
-      options: [
-        { label: "Agent", description: "@code-developer agent" },
-        { label: "Codex", description: "codex CLI tool" },
-        { label: "Auto", description: "Auto-select based on complexity" }
-      ]
-    },
-    {
-      question: "Enable code review after execution?",
-      header: "Code Review",
-      multiSelect: false,
-      options: [
-        { label: "Skip", description: "No review" },
-        { label: "Gemini Review", description: "Gemini CLI tool" },
-        { label: "Codex Review", description: "Git-aware review (prompt OR --uncommitted)" },
-        { label: "Agent Review", description: "Current agent review" }
-      ]
-    }
-  ]
-})
+// Parse --yes flag
+const autoYes = $ARGUMENTS.includes('--yes') || $ARGUMENTS.includes('-y')
+
+let userSelection
+
+if (autoYes) {
+  // Auto mode: Use defaults
+  console.log(`[--yes] Auto-confirming execution:`)
+  console.log(`  - Execution method: Auto`)
+  console.log(`  - Code review: Skip`)
+
+  userSelection = {
+    execution_method: "Auto",
+    code_review_tool: "Skip"
+  }
+} else {
+  // Interactive mode: Ask user
+  userSelection = AskUserQuestion({
+    questions: [
+      {
+        question: "Select execution method:",
+        header: "Execution",
+        multiSelect: false,
+        options: [
+          { label: "Agent", description: "@code-developer agent" },
+          { label: "Codex", description: "codex CLI tool" },
+          { label: "Auto", description: "Auto-select based on complexity" }
+        ]
+      },
+      {
+        question: "Enable code review after execution?",
+        header: "Code Review",
+        multiSelect: false,
+        options: [
+          { label: "Skip", description: "No review" },
+          { label: "Gemini Review", description: "Gemini CLI tool" },
+          { label: "Codex Review", description: "Git-aware review (prompt OR --uncommitted)" },
+          { label: "Agent Review", description: "Current agent review" }
+        ]
+      }
+    ]
+  })
+}
 ```
 
 ### Mode 3: File Content
@@ -327,7 +345,7 @@ for (const call of sequential) {
 
 ```javascript
 function buildExecutionPrompt(batch) {
-  // Task template (4 parts: Modification Points → How → Reference → Done)
+  // Task template (6 parts: Modification Points → Why → How → Reference → Risks → Done)
   const formatTask = (t) => `
 ## ${t.title}
 
@@ -336,18 +354,38 @@ function buildExecutionPrompt(batch) {
 ### Modification Points
 ${t.modification_points.map(p => `- **${p.file}** → \`${p.target}\`: ${p.change}`).join('\n')}
 
+${t.rationale ? `
+### Why this approach (Medium/High)
+${t.rationale.chosen_approach}
+${t.rationale.decision_factors?.length > 0 ? `\nKey factors: ${t.rationale.decision_factors.join(', ')}` : ''}
+${t.rationale.tradeoffs ? `\nTradeoffs: ${t.rationale.tradeoffs}` : ''}
+` : ''}
+
 ### How to do it
 ${t.description}
 
 ${t.implementation.map(step => `- ${step}`).join('\n')}
 
+${t.code_skeleton ? `
+### Code skeleton (High)
+${t.code_skeleton.interfaces?.length > 0 ? `**Interfaces**: ${t.code_skeleton.interfaces.map(i => `\`${i.name}\` - ${i.purpose}`).join(', ')}` : ''}
+${t.code_skeleton.key_functions?.length > 0 ? `\n**Functions**: ${t.code_skeleton.key_functions.map(f => `\`${f.signature}\` - ${f.purpose}`).join(', ')}` : ''}
+${t.code_skeleton.classes?.length > 0 ? `\n**Classes**: ${t.code_skeleton.classes.map(c => `\`${c.name}\` - ${c.purpose}`).join(', ')}` : ''}
+` : ''}
+
 ### Reference
 - Pattern: ${t.reference?.pattern || 'N/A'}
 - Files: ${t.reference?.files?.join(', ') || 'N/A'}
 ${t.reference?.examples ? `- Notes: ${t.reference.examples}` : ''}
 
+${t.risks?.length > 0 ? `
+### Risk mitigations (High)
+${t.risks.map(r => `- ${r.description} → **${r.mitigation}**`).join('\n')}
+` : ''}
+
 ### Done when
-${t.acceptance.map(c => `- [ ] ${c}`).join('\n')}`
+${t.acceptance.map(c => `- [ ] ${c}`).join('\n')}
+${t.verification?.success_metrics?.length > 0 ? `\n**Success metrics**: ${t.verification.success_metrics.join(', ')}` : ''}`
 
   // Build prompt
   const sections = []
@@ -364,9 +402,14 @@ ${t.acceptance.map(c => `- [ ] ${c}`).join('\n')}`
   if (clarificationContext) {
     context.push(`### Clarifications\n${Object.entries(clarificationContext).map(([q, a]) => `- ${q}: ${a}`).join('\n')}`)
   }
+  if (executionContext?.planObject?.data_flow?.diagram) {
+    context.push(`### Data Flow\n${executionContext.planObject.data_flow.diagram}`)
+  }
   if (executionContext?.session?.artifacts?.plan) {
     context.push(`### Artifacts\nPlan: ${executionContext.session.artifacts.plan}`)
   }
+  // Project guidelines (user-defined constraints from /workflow:session:solidify)
+  context.push(`### Project Guidelines\n@.workflow/project-guidelines.json`)
   if (context.length > 0) sections.push(`## Context\n${context.join('\n\n')}`)
 
   sections.push(`Complete each task according to its "Done when" checklist.`)
@@ -462,11 +505,13 @@ Progress tracked at batch level (not individual task level). Icons: ⚡ (paralle
 
 **Skip Condition**: Only run if `codeReviewTool ≠ "Skip"`
 
-**Review Focus**: Verify implementation against plan acceptance criteria
-- Read plan.json for task acceptance criteria
+**Review Focus**: Verify implementation against plan acceptance criteria and verification requirements
+- Read plan.json for task acceptance criteria and verification checklist
 - Check each acceptance criterion is fulfilled
+- Verify success metrics from verification field (Medium/High complexity)
+- Run unit/integration tests specified in verification field
 - Validate code quality and identify issues
-- Ensure alignment with planned approach
+- Ensure alignment with planned approach and risk mitigations
 
 **Operations**:
 - Agent Review: Current agent performs direct review
@@ -478,17 +523,23 @@ Progress tracked at batch level (not individual task level). Icons: ⚡ (paralle
 
 **Review Criteria**:
 - **Acceptance Criteria**: Verify each criterion from plan.tasks[].acceptance
+- **Verification Checklist** (Medium/High): Check unit_tests, integration_tests, success_metrics from plan.tasks[].verification
 - **Code Quality**: Analyze quality, identify issues, suggest improvements
-- **Plan Alignment**: Validate implementation matches planned approach
+- **Plan Alignment**: Validate implementation matches planned approach and risk mitigations
 
 **Shared Prompt Template** (used by all CLI tools):
 ```
-PURPOSE: Code review for implemented changes against plan acceptance criteria
-TASK: • Verify plan acceptance criteria fulfillment • Analyze code quality • Identify issues • Suggest improvements • Validate plan adherence
+PURPOSE: Code review for implemented changes against plan acceptance criteria and verification requirements
+TASK: • Verify plan acceptance criteria fulfillment • Check verification requirements (unit tests, success metrics) • Analyze code quality • Identify issues • Suggest improvements • Validate plan adherence and risk mitigations
 MODE: analysis
-CONTEXT: @**/* @{plan.json} [@{exploration.json}] | Memory: Review lite-execute changes against plan requirements
-EXPECTED: Quality assessment with acceptance criteria verification, issue identification, and recommendations. Explicitly check each acceptance criterion from plan.json tasks.
-CONSTRAINTS: Focus on plan acceptance criteria and plan adherence | analysis=READ-ONLY
+CONTEXT: @**/* @{plan.json} [@{exploration.json}] | Memory: Review lite-execute changes against plan requirements including verification checklist
+EXPECTED: Quality assessment with:
+  - Acceptance criteria verification (all tasks)
+  - Verification checklist validation (Medium/High: unit_tests, integration_tests, success_metrics)
+  - Issue identification
+  - Recommendations
+  Explicitly check each acceptance criterion and verification item from plan.json tasks.
+CONSTRAINTS: Focus on plan acceptance criteria, verification requirements, and plan adherence | analysis=READ-ONLY
 ```
 
 **Tool-Specific Execution** (Apply shared prompt template above):

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

@@ -1,7 +1,7 @@
 ---
 name: lite-fix
 description: Lightweight bug diagnosis and fix workflow with intelligent severity assessment and optional hotfix mode for production incidents
-argument-hint: "[--hotfix] \"bug description or issue reference\""
+argument-hint: "[-y|--yes] [--hotfix] \"bug description or issue reference\""
 allowed-tools: TodoWrite(*), Task(*), SlashCommand(*), AskUserQuestion(*)
 ---
 
@@ -25,10 +25,32 @@ Intelligent lightweight bug fixing command with dynamic workflow adaptation base
 /workflow:lite-fix [FLAGS] <BUG_DESCRIPTION>
 
 # Flags
+-y, --yes                  Skip all confirmations (auto mode)
 --hotfix, -h               Production hotfix mode (minimal diagnosis, fast fix)
 
 # Arguments
 <bug-description>          Bug description, error message, or path to .md file (required)
+
+# Examples
+/workflow:lite-fix "用户登录失败"                    # Interactive mode
+/workflow:lite-fix --yes "用户登录失败"              # Auto mode (no confirmations)
+/workflow:lite-fix -y --hotfix "生产环境数据库连接失败"   # Auto + hotfix mode
+```
+
+## Auto Mode Defaults
+
+When `--yes` or `-y` flag is used:
+- **Clarification Questions**: Skipped (no clarification phase)
+- **Fix Plan Confirmation**: Auto-selected "Allow"
+- **Execution Method**: Auto-selected "Auto"
+- **Code Review**: Auto-selected "Skip"
+- **Severity**: Uses auto-detected severity (no manual override)
+- **Hotfix Mode**: Respects --hotfix flag if present, otherwise normal mode
+
+**Flag Parsing**:
+```javascript
+const autoYes = $ARGUMENTS.includes('--yes') || $ARGUMENTS.includes('-y')
+const hotfixMode = $ARGUMENTS.includes('--hotfix') || $ARGUMENTS.includes('-h')
 ```
 
 ## Execution Process
@@ -332,9 +354,17 @@ function deduplicateClarifications(clarifications) {
 
 const uniqueClarifications = deduplicateClarifications(allClarifications)
 
-// Multi-round clarification: batch questions (max 4 per round)
-// ⚠️ MUST execute ALL rounds until uniqueClarifications exhausted
-if (uniqueClarifications.length > 0) {
+// Parse --yes flag
+const autoYes = $ARGUMENTS.includes('--yes') || $ARGUMENTS.includes('-y')
+
+if (autoYes) {
+  // Auto mode: Skip clarification phase
+  console.log(`[--yes] Skipping ${uniqueClarifications.length} clarification questions`)
+  console.log(`Proceeding to fix planning with diagnosis results...`)
+  // Continue to Phase 3
+} else if (uniqueClarifications.length > 0) {
+  // Interactive mode: Multi-round clarification
+  // ⚠️ MUST execute ALL rounds until uniqueClarifications exhausted
   const BATCH_SIZE = 4
   const totalRounds = Math.ceil(uniqueClarifications.length / BATCH_SIZE)
 
@@ -380,6 +410,7 @@ if (uniqueClarifications.length > 0) {
 const schema = Bash(`cat ~/.claude/workflows/cli-templates/schemas/fix-plan-json-schema.json`)
 
 // Step 2: Generate fix-plan following schema (Claude directly, no agent)
+// For Medium complexity: include rationale + verification (optional, but recommended)
 const fixPlan = {
   summary: "...",
   root_cause: "...",
@@ -389,13 +420,67 @@ const fixPlan = {
   recommended_execution: "Agent",
   severity: severity,
   risk_level: "...",
-  _metadata: { timestamp: getUtc8ISOString(), source: "direct-planning", planning_mode: "direct" }
+
+  // Medium complexity fields (optional for direct planning, auto-filled for Low)
+  ...(severity === "Medium" ? {
+    design_decisions: [
+      {
+        decision: "Use immediate_patch strategy for minimal risk",
+        rationale: "Keeps changes localized and quick to review",
+        tradeoff: "Defers comprehensive refactoring"
+      }
+    ],
+    tasks_with_rationale: {
+      // Each task gets rationale if Medium
+      task_rationale_example: {
+        rationale: {
+          chosen_approach: "Direct fix approach",
+          alternatives_considered: ["Workaround", "Refactor"],
+          decision_factors: ["Minimal impact", "Quick turnaround"],
+          tradeoffs: "Doesn't address underlying issue"
+        },
+        verification: {
+          unit_tests: ["test_bug_fix_basic"],
+          integration_tests: [],
+          manual_checks: ["Reproduce issue", "Verify fix"],
+          success_metrics: ["Issue resolved", "No regressions"]
+        }
+      }
+    }
+  } : {}),
+
+  _metadata: {
+    timestamp: getUtc8ISOString(),
+    source: "direct-planning",
+    planning_mode: "direct",
+    complexity: severity === "Medium" ? "Medium" : "Low"
+  }
 }
 
-// Step 3: Write fix-plan to session folder
+// Step 3: Merge task rationale into tasks array
+if (severity === "Medium") {
+  fixPlan.tasks = fixPlan.tasks.map(task => ({
+    ...task,
+    rationale: fixPlan.tasks_with_rationale[task.id]?.rationale || {
+      chosen_approach: "Standard fix",
+      alternatives_considered: [],
+      decision_factors: ["Correctness", "Simplicity"],
+      tradeoffs: "None"
+    },
+    verification: fixPlan.tasks_with_rationale[task.id]?.verification || {
+      unit_tests: [`test_${task.id}_basic`],
+      integration_tests: [],
+      manual_checks: ["Verify fix works"],
+      success_metrics: ["Test pass"]
+    }
+  }))
+  delete fixPlan.tasks_with_rationale  // Clean up temp field
+}
+
+// Step 4: Write fix-plan to session folder
 Write(`${sessionFolder}/fix-plan.json`, JSON.stringify(fixPlan, null, 2))
 
-// Step 4: MUST continue to Phase 4 (Confirmation) - DO NOT execute code here
+// Step 5: MUST continue to Phase 4 (Confirmation) - DO NOT execute code here
 ```
 
 **High/Critical Severity** - Invoke cli-lite-planning-agent:
@@ -451,11 +536,41 @@ Generate fix-plan.json with:
   - description
   - modification_points: ALL files to modify for this fix (group related changes)
   - implementation (2-5 steps covering all modification_points)
-  - verification (test criteria)
+  - acceptance: Quantified acceptance criteria
   - depends_on: task IDs this task depends on (use sparingly)
+
+  **High/Critical complexity fields per task** (REQUIRED):
+  - rationale:
+    - chosen_approach: Why this fix approach (not alternatives)
+    - alternatives_considered: Other approaches evaluated
+    - decision_factors: Key factors influencing choice
+    - tradeoffs: Known tradeoffs of this approach
+  - verification:
+    - unit_tests: Test names to add/verify
+    - integration_tests: Integration test names
+    - manual_checks: Manual verification steps
+    - success_metrics: Quantified success criteria
+  - risks:
+    - description: Risk description
+    - probability: Low|Medium|High
+    - impact: Low|Medium|High
+    - mitigation: How to mitigate
+    - fallback: Fallback if fix fails
+  - code_skeleton (optional): Key interfaces/functions to implement
+    - interfaces: [{name, definition, purpose}]
+    - key_functions: [{signature, purpose, returns}]
+
+**Top-level High/Critical fields** (REQUIRED):
+- data_flow: How data flows through affected code
+  - diagram: "A → B → C" style flow
+  - stages: [{stage, input, output, component}]
+- design_decisions: Global fix decisions
+  - [{decision, rationale, tradeoff}]
+
 - estimated_time, recommended_execution, severity, risk_level
 - _metadata:
   - timestamp, source, planning_mode
+  - complexity: "High" | "Critical"
   - diagnosis_angles: ${JSON.stringify(manifest.diagnoses.map(d => d.angle))}
 
 ## Task Grouping Rules
@@ -467,11 +582,21 @@ Generate fix-plan.json with:
 
 ## Execution
 1. Read ALL diagnosis files for comprehensive context
-2. Execute CLI planning using Gemini (Qwen fallback)
+2. Execute CLI planning using Gemini (Qwen fallback) with --rule planning-fix-strategy template
 3. Synthesize findings from multiple diagnosis angles
-4. Parse output and structure fix-plan
-5. Write JSON: Write('${sessionFolder}/fix-plan.json', jsonContent)
-6. Return brief completion summary
+4. Generate fix-plan with:
+   - For High/Critical: REQUIRED new fields (rationale, verification, risks, code_skeleton, data_flow, design_decisions)
+   - Each task MUST have rationale (why this fix), verification (how to verify success), and risks (potential issues)
+5. Parse output and structure fix-plan
+6. Write JSON: Write('${sessionFolder}/fix-plan.json', jsonContent)
+7. Return brief completion summary
+
+## Output Format for CLI
+Include these sections in your fix-plan output:
+- Summary, Root Cause, Strategy (existing)
+- Data Flow: Diagram showing affected code paths
+- Design Decisions: Key architectural choices in the fix
+- Tasks: Each with rationale (Medium/High), verification (Medium/High), risks (High), code_skeleton (High)
 `
 )
 ```
@@ -505,40 +630,60 @@ ${fixPlan.tasks.map((t, i) => `${i+1}. ${t.title} (${t.scope})`).join('\n')}
 
 **Step 4.2: Collect Confirmation**
 ```javascript
-AskUserQuestion({
-  questions: [
-    {
-      question: `Confirm fix plan? (${fixPlan.tasks.length} tasks, ${fixPlan.severity} severity)`,
-      header: "Confirm",
-      multiSelect: true,
-      options: [
-        { label: "Allow", description: "Proceed as-is" },
-        { label: "Modify", description: "Adjust before execution" },
-        { label: "Cancel", description: "Abort workflow" }
-      ]
-    },
-    {
-      question: "Execution method:",
-      header: "Execution",
-      multiSelect: false,
-      options: [
-        { label: "Agent", description: "@code-developer agent" },
-        { label: "Codex", description: "codex CLI tool" },
-        { label: "Auto", description: `Auto: ${fixPlan.severity === 'Low' ? 'Agent' : 'Codex'}` }
-      ]
-    },
-    {
-      question: "Code review after fix?",
-      header: "Review",
-      multiSelect: false,
-      options: [
-        { label: "Gemini Review", description: "Gemini CLI" },
-        { label: "Agent Review", description: "@code-reviewer" },
-        { label: "Skip", description: "No review" }
-      ]
-    }
-  ]
-})
+// Parse --yes flag
+const autoYes = $ARGUMENTS.includes('--yes') || $ARGUMENTS.includes('-y')
+
+let userSelection
+
+if (autoYes) {
+  // Auto mode: Use defaults
+  console.log(`[--yes] Auto-confirming fix plan:`)
+  console.log(`  - Confirmation: Allow`)
+  console.log(`  - Execution: Auto`)
+  console.log(`  - Review: Skip`)
+
+  userSelection = {
+    confirmation: "Allow",
+    execution_method: "Auto",
+    code_review_tool: "Skip"
+  }
+} else {
+  // Interactive mode: Ask user
+  userSelection = AskUserQuestion({
+    questions: [
+      {
+        question: `Confirm fix plan? (${fixPlan.tasks.length} tasks, ${fixPlan.severity} severity)`,
+        header: "Confirm",
+        multiSelect: false,
+        options: [
+          { label: "Allow", description: "Proceed as-is" },
+          { label: "Modify", description: "Adjust before execution" },
+          { label: "Cancel", description: "Abort workflow" }
+        ]
+      },
+      {
+        question: "Execution method:",
+        header: "Execution",
+        multiSelect: false,
+        options: [
+          { label: "Agent", description: "@code-developer agent" },
+          { label: "Codex", description: "codex CLI tool" },
+          { label: "Auto", description: `Auto: ${fixPlan.severity === 'Low' ? 'Agent' : 'Codex'}` }
+        ]
+      },
+      {
+        question: "Code review after fix?",
+        header: "Review",
+        multiSelect: false,
+        options: [
+          { label: "Gemini Review", description: "Gemini CLI" },
+          { label: "Agent Review", description: "@code-reviewer" },
+          { label: "Skip", description: "No review" }
+        ]
+      }
+    ]
+  })
+}
 ```
 
 ---
@@ -565,7 +710,11 @@ const fixPlan = JSON.parse(Read(`${sessionFolder}/fix-plan.json`))
 executionContext = {
   mode: "bugfix",
   severity: fixPlan.severity,
-  planObject: fixPlan,
+  planObject: {
+    ...fixPlan,
+    // Ensure complexity is set based on severity for new field consumption
+    complexity: fixPlan.complexity || (fixPlan.severity === 'Critical' ? 'High' : (fixPlan.severity === 'High' ? 'High' : 'Medium'))
+  },
   diagnosisContext: diagnoses,
   diagnosisAngles: manifest.diagnoses.map(d => d.angle),
   diagnosisManifest: manifest,

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

@@ -1,10 +1,14 @@
 ---
 name: workflow:lite-lite-lite
 description: Ultra-lightweight multi-tool analysis and direct execution. No artifacts for simple tasks; auto-creates planning docs in .workflow/.scratchpad/ for complex tasks. Auto tool selection based on task analysis, user-driven iteration via AskUser.
-argument-hint: "<task description>"
+argument-hint: "[-y|--yes] <task description>"
 allowed-tools: TodoWrite(*), Task(*), AskUserQuestion(*), Read(*), Bash(*), Write(*), mcp__ace-tool__search_context(*), mcp__ccw-tools__write_file(*)
 ---
 
+## Auto Mode
+
+When `--yes` or `-y`: Skip clarification questions, auto-select tools, execute directly with recommended settings.
+
 # Ultra-Lite Multi-Tool Workflow
 
 ## Quick Start

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

@@ -1,7 +1,7 @@
 ---
 name: lite-plan
 description: Lightweight interactive planning workflow with in-memory planning, code exploration, and execution execute to lite-execute after user confirmation
-argument-hint: "[-e|--explore] \"task description\"|file.md"
+argument-hint: "[-y|--yes] [-e|--explore] \"task description\"|file.md"
 allowed-tools: TodoWrite(*), Task(*), SlashCommand(*), AskUserQuestion(*)
 ---
 
@@ -25,10 +25,30 @@ Intelligent lightweight planning command with dynamic workflow adaptation based
 /workflow:lite-plan [FLAGS] <TASK_DESCRIPTION>
 
 # Flags
+-y, --yes                  Skip all confirmations (auto mode)
 -e, --explore              Force code exploration phase (overrides auto-detection)
 
 # Arguments
 <task-description>         Task description or path to .md file (required)
+
+# Examples
+/workflow:lite-plan "实现JWT认证"                    # Interactive mode
+/workflow:lite-plan --yes "实现JWT认证"              # Auto mode (no confirmations)
+/workflow:lite-plan -y -e "优化数据库查询性能"       # Auto mode + force exploration
+```
+
+## Auto Mode Defaults
+
+When `--yes` or `-y` flag is used:
+- **Clarification Questions**: Skipped (no clarification phase)
+- **Plan Confirmation**: Auto-selected "Allow"
+- **Execution Method**: Auto-selected "Auto"
+- **Code Review**: Auto-selected "Skip"
+
+**Flag Parsing**:
+```javascript
+const autoYes = $ARGUMENTS.includes('--yes') || $ARGUMENTS.includes('-y')
+const forceExplore = $ARGUMENTS.includes('--explore') || $ARGUMENTS.includes('-e')
 ```
 
 ## Execution Process
@@ -52,8 +72,8 @@ Phase 2: Clarification (optional, multi-round)
 
 Phase 3: Planning (NO CODE EXECUTION - planning only)
    └─ Decision (based on Phase 1 complexity):
-      ├─ Low → Load schema: cat ~/.claude/workflows/cli-templates/schemas/plan-json-schema.json → Direct Claude planning (following schema) → plan.json → MUST proceed to Phase 4
-      └─ Medium/High → cli-lite-planning-agent → plan.json → MUST proceed to Phase 4
+      ├─ Low → Load schema: cat ~/.claude/workflows/cli-templates/schemas/plan-json-schema.json → Direct Claude planning (following schema) → plan.json
+      └─ Medium/High → cli-lite-planning-agent → plan.json (agent internally executes quality check)
 
 Phase 4: Confirmation & Selection
    ├─ Display plan summary (tasks, complexity, estimated time)
@@ -323,8 +343,16 @@ explorations.forEach(exp => {
 // - Produce dedupedClarifications with unique intents only
 const dedupedClarifications = intelligentMerge(allClarifications)
 
-// Multi-round clarification: batch questions (max 4 per round)
-if (dedupedClarifications.length > 0) {
+// Parse --yes flag
+const autoYes = $ARGUMENTS.includes('--yes') || $ARGUMENTS.includes('-y')
+
+if (autoYes) {
+  // Auto mode: Skip clarification phase
+  console.log(`[--yes] Skipping ${dedupedClarifications.length} clarification questions`)
+  console.log(`Proceeding to planning with exploration results...`)
+  // Continue to Phase 3
+} else if (dedupedClarifications.length > 0) {
+  // Interactive mode: Multi-round clarification
   const BATCH_SIZE = 4
   const totalRounds = Math.ceil(dedupedClarifications.length / BATCH_SIZE)
 
@@ -497,42 +525,62 @@ ${plan.tasks.map((t, i) => `${i+1}. ${t.title} (${t.file})`).join('\n')}
 
 **Step 4.2: Collect Confirmation**
 ```javascript
-// Note: Execution "Other" option allows specifying CLI tools from ~/.claude/cli-tools.json
-AskUserQuestion({
-  questions: [
-    {
-      question: `Confirm plan? (${plan.tasks.length} tasks, ${plan.complexity})`,
-      header: "Confirm",
-      multiSelect: true,
-      options: [
-        { label: "Allow", description: "Proceed as-is" },
-        { label: "Modify", description: "Adjust before execution" },
-        { label: "Cancel", description: "Abort workflow" }
-      ]
-    },
-    {
-      question: "Execution method:",
-      header: "Execution",
-      multiSelect: false,
-      options: [
-        { label: "Agent", description: "@code-developer agent" },
-        { label: "Codex", description: "codex CLI tool" },
-        { label: "Auto", description: `Auto: ${plan.complexity === 'Low' ? 'Agent' : 'Codex'}` }
-      ]
-    },
-    {
-      question: "Code review after execution?",
-      header: "Review",
-      multiSelect: false,
-      options: [
-        { label: "Gemini Review", description: "Gemini CLI review" },
-        { label: "Codex Review", description: "Git-aware review (prompt OR --uncommitted)" },
-        { label: "Agent Review", description: "@code-reviewer agent" },
-        { label: "Skip", description: "No review" }
-      ]
-    }
-  ]
-})
+// Parse --yes flag
+const autoYes = $ARGUMENTS.includes('--yes') || $ARGUMENTS.includes('-y')
+
+let userSelection
+
+if (autoYes) {
+  // Auto mode: Use defaults
+  console.log(`[--yes] Auto-confirming plan:`)
+  console.log(`  - Confirmation: Allow`)
+  console.log(`  - Execution: Auto`)
+  console.log(`  - Review: Skip`)
+
+  userSelection = {
+    confirmation: "Allow",
+    execution_method: "Auto",
+    code_review_tool: "Skip"
+  }
+} else {
+  // Interactive mode: Ask user
+  // Note: Execution "Other" option allows specifying CLI tools from ~/.claude/cli-tools.json
+  userSelection = AskUserQuestion({
+    questions: [
+      {
+        question: `Confirm plan? (${plan.tasks.length} tasks, ${plan.complexity})`,
+        header: "Confirm",
+        multiSelect: false,
+        options: [
+          { label: "Allow", description: "Proceed as-is" },
+          { label: "Modify", description: "Adjust before execution" },
+          { label: "Cancel", description: "Abort workflow" }
+        ]
+      },
+      {
+        question: "Execution method:",
+        header: "Execution",
+        multiSelect: false,
+        options: [
+          { label: "Agent", description: "@code-developer agent" },
+          { label: "Codex", description: "codex CLI tool" },
+          { label: "Auto", description: `Auto: ${plan.complexity === 'Low' ? 'Agent' : 'Codex'}` }
+        ]
+      },
+      {
+        question: "Code review after execution?",
+        header: "Review",
+        multiSelect: false,
+        options: [
+          { label: "Gemini Review", description: "Gemini CLI review" },
+          { label: "Codex Review", description: "Git-aware review (prompt OR --uncommitted)" },
+          { label: "Agent Review", description: "@code-reviewer agent" },
+          { label: "Skip", description: "No review" }
+        ]
+      }
+    ]
+  })
+}
 ```
 
 ---

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

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

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

@@ -1,10 +1,14 @@
 ---
 name: workflow:multi-cli-plan
 description: Multi-CLI collaborative planning workflow with ACE context gathering and iterative cross-verification. Uses cli-discuss-agent for Gemini+Codex+Claude analysis to converge on optimal execution plan.
-argument-hint: "<task description> [--max-rounds=3] [--tools=gemini,codex] [--mode=parallel|serial]"
+argument-hint: "[-y|--yes] <task description> [--max-rounds=3] [--tools=gemini,codex] [--mode=parallel|serial]"
 allowed-tools: TodoWrite(*), Task(*), AskUserQuestion(*), Read(*), Bash(*), Write(*), mcp__ace-tool__search_context(*)
 ---
 
+## Auto Mode
+
+When `--yes` or `-y`: Auto-approve plan, use recommended solution and execution method (Agent, Skip review).
+
 # Multi-CLI Collaborative Planning Command
 
 ## Quick Start

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

@@ -0,0 +1,362 @@
+---
+name: plan-verify
+description: Perform READ-ONLY verification analysis between IMPL_PLAN.md, task JSONs, and brainstorming artifacts. Generates structured report with quality gate recommendation. Does NOT modify any files.
+argument-hint: "[optional: --session session-id]"
+allowed-tools: Read(*), Write(*), Glob(*), Bash(*)
+---
+
+## User Input
+
+```text
+$ARGUMENTS
+```
+
+You **MUST** consider the user input before proceeding (if not empty).
+
+## Goal
+
+Generate a comprehensive verification report that identifies inconsistencies, duplications, ambiguities, and underspecified items between action planning artifacts (`IMPL_PLAN.md`, `task.json`) and brainstorming artifacts (`role analysis documents`). This command MUST run only after `/workflow:plan` has successfully produced complete `IMPL_PLAN.md` and task JSON files.
+
+**Output**: A structured Markdown report saved to `.workflow/active/WFS-{session}/.process/PLAN_VERIFICATION.md` containing:
+- Executive summary with quality gate recommendation
+- Detailed findings by severity (CRITICAL/HIGH/MEDIUM/LOW)
+- Requirements coverage analysis
+- Dependency integrity check
+- Synthesis alignment validation
+- Actionable remediation recommendations
+
+## Operating Constraints
+
+**STRICTLY READ-ONLY FOR SOURCE ARTIFACTS**:
+- **MUST NOT** modify `IMPL_PLAN.md`, any `task.json` files, or brainstorming artifacts
+- **MUST NOT** create or delete task files
+- **MUST ONLY** write the verification report to `.process/PLAN_VERIFICATION.md`
+
+**Synthesis Authority**: The `role analysis documents` are **authoritative** for requirements and design decisions. Any conflicts between IMPL_PLAN/tasks and synthesis are automatically CRITICAL and require adjustment of the plan/tasks—not reinterpretation of requirements.
+
+**Quality Gate Authority**: The verification report provides a binding recommendation (BLOCK_EXECUTION / PROCEED_WITH_FIXES / PROCEED_WITH_CAUTION / PROCEED) based on objective severity criteria. User MUST review critical/high issues before proceeding with implementation.
+
+## Execution Steps
+
+### 1. Initialize Analysis Context
+
+```bash
+# Detect active workflow session
+IF --session parameter provided:
+    session_id = provided session
+ELSE:
+    # Auto-detect active session
+    active_sessions = bash(find .workflow/active/ -name "WFS-*" -type d 2>/dev/null)
+    IF active_sessions is empty:
+        ERROR: "No active workflow session found. Use --session <session-id>"
+        EXIT
+    ELSE IF active_sessions has multiple entries:
+        # Use most recently modified session
+        session_id = bash(ls -td .workflow/active/WFS-*/ 2>/dev/null | head -1 | xargs basename)
+    ELSE:
+        session_id = basename(active_sessions[0])
+
+# Derive absolute paths
+session_dir = .workflow/active/WFS-{session}
+brainstorm_dir = session_dir/.brainstorming
+task_dir = session_dir/.task
+process_dir = session_dir/.process
+session_file = session_dir/workflow-session.json
+
+# Create .process directory if not exists (report output location)
+IF NOT EXISTS(process_dir):
+    bash(mkdir -p "{process_dir}")
+
+# Validate required artifacts
+# Note: "role analysis documents" refers to [role]/analysis.md files (e.g., product-manager/analysis.md)
+SYNTHESIS_DIR = brainstorm_dir  # Contains role analysis files: */analysis.md
+IMPL_PLAN = session_dir/IMPL_PLAN.md
+TASK_FILES = Glob(task_dir/*.json)
+
+# Abort if missing - in order of dependency
+SESSION_FILE_EXISTS = EXISTS(session_file)
+IF NOT SESSION_FILE_EXISTS:
+    WARNING: "workflow-session.json not found. User intent alignment verification will be skipped."
+    # Continue execution - this is optional context, not blocking
+
+SYNTHESIS_FILES = Glob(brainstorm_dir/*/analysis.md)
+IF SYNTHESIS_FILES.count == 0:
+    ERROR: "No role analysis documents found in .brainstorming/*/analysis.md. Run /workflow:brainstorm:synthesis first"
+    EXIT
+
+IF NOT EXISTS(IMPL_PLAN):
+    ERROR: "IMPL_PLAN.md not found. Run /workflow:plan first"
+    EXIT
+
+IF TASK_FILES.count == 0:
+    ERROR: "No task JSON files found. Run /workflow:plan first"
+    EXIT
+```
+
+### 2. Load Artifacts (Progressive Disclosure)
+
+Load only minimal necessary context from each artifact:
+
+**From workflow-session.json** (OPTIONAL - Primary Reference for User Intent):
+- **ONLY IF EXISTS**: Load user intent context
+- Original user prompt/intent (project or description field)
+- User's stated goals and objectives
+- User's scope definition
+- **IF MISSING**: Set user_intent_analysis = "SKIPPED: workflow-session.json not found"
+
+**From role analysis documents** (AUTHORITATIVE SOURCE):
+- Functional Requirements (IDs, descriptions, acceptance criteria)
+- Non-Functional Requirements (IDs, targets)
+- Business Requirements (IDs, success metrics)
+- Key Architecture Decisions
+- Risk factors and mitigation strategies
+- Implementation Roadmap (high-level phases)
+
+**From IMPL_PLAN.md**:
+- Summary and objectives
+- Context Analysis
+- Implementation Strategy
+- Task Breakdown Summary
+- Success Criteria
+- Brainstorming Artifacts References (if present)
+
+**From task.json files**:
+- Task IDs
+- Titles and descriptions
+- Status
+- Dependencies (depends_on, blocks)
+- Context (requirements, focus_paths, acceptance, artifacts)
+- Flow control (pre_analysis, implementation_approach)
+- Meta (complexity, priority)
+
+### 3. Build Semantic Models
+
+Create internal representations (do not include raw artifacts in output):
+
+**Requirements inventory**:
+- Each functional/non-functional/business requirement with stable ID
+- Requirement text, acceptance criteria, priority
+
+**Architecture decisions inventory**:
+- ADRs from synthesis
+- Technology choices
+- Data model references
+
+**Task coverage mapping**:
+- Map each task to one or more requirements (by ID reference or keyword inference)
+- Map each requirement to covering tasks
+
+**Dependency graph**:
+- Task-to-task dependencies (depends_on, blocks)
+- Requirement-level dependencies (from synthesis)
+
+### 4. Detection Passes (Agent-Driven Multi-Dimensional Analysis)
+
+**Execution Strategy**:
+- Single `cli-explore-agent` invocation
+- Agent executes multiple CLI analyses internally (different dimensions: A-H)
+- Token Budget: 50 findings maximum (aggregate remainder in overflow summary)
+- Priority Allocation: CRITICAL (unlimited) → HIGH (15) → MEDIUM (20) → LOW (15)
+- Early Exit: If CRITICAL findings > 0 in User Intent/Requirements Coverage, skip LOW/MEDIUM checks
+
+**Execution Order** (Agent orchestrates internally):
+
+1. **Tier 1 (CRITICAL Path)**: A, B, C - User intent, coverage, consistency (full analysis)
+2. **Tier 2 (HIGH Priority)**: D, E - Dependencies, synthesis alignment (limit 15 findings)
+3. **Tier 3 (MEDIUM Priority)**: F - Specification quality (limit 20 findings)
+4. **Tier 4 (LOW Priority)**: G, H - Duplication, feasibility (limit 15 findings)
+
+---
+
+#### Phase 4.1: Launch Unified Verification Agent
+
+```javascript
+Task(
+  subagent_type="cli-explore-agent",
+  run_in_background=false,
+  description="Multi-dimensional plan verification",
+  prompt=`
+## Plan Verification Task
+
+### MANDATORY FIRST STEPS
+1. Read: ~/.claude/workflows/cli-templates/schemas/plan-verify-agent-schema.json (dimensions & rules)
+2. Read: ~/.claude/workflows/cli-templates/schemas/verify-json-schema.json (output schema)
+3. Read: ${session_file} (user intent)
+4. Read: ${IMPL_PLAN} (implementation plan)
+5. Glob: ${task_dir}/*.json (task files)
+6. Glob: ${SYNTHESIS_DIR}/*/analysis.md (role analyses)
+
+### Execution Flow
+
+**Load schema → Execute tiered CLI analysis → Aggregate findings → Write JSON**
+
+FOR each tier in [1, 2, 3, 4]:
+  - Load tier config from plan-verify-agent-schema.json
+  - Execute: ccw cli -p "PURPOSE: Verify dimensions {tier.dimensions}
+    TASK: {tier.checks from schema}
+    CONTEXT: @${session_dir}/**/*
+    EXPECTED: Findings JSON with dimension, severity, location, summary, recommendation
+    CONSTRAINTS: Limit {tier.limit} findings
+    " --tool gemini --mode analysis --rule {tier.rule}
+  - Parse findings, check early exit condition
+  - IF tier == 1 AND critical_count > 0: skip tier 3-4
+
+### Output
+Write: ${process_dir}/verification-findings.json (follow verify-json-schema.json)
+Return: Quality gate decision + 2-3 sentence summary
+`
+)
+```
+
+---
+
+#### Phase 4.2: Load and Organize Findings
+
+```javascript
+// Load findings (single parse for all subsequent use)
+const data = JSON.parse(Read(`${process_dir}/verification-findings.json`))
+const { session_id, timestamp, verification_tiers_completed, findings, summary } = data
+const { critical_count, high_count, medium_count, low_count, total_findings, coverage_percentage, recommendation } = summary
+
+// Group by severity and dimension
+const bySeverity = Object.groupBy(findings, f => f.severity)
+const byDimension = Object.groupBy(findings, f => f.dimension)
+
+// Dimension metadata (from schema)
+const DIMS = {
+  A: "User Intent Alignment", B: "Requirements Coverage", C: "Consistency Validation",
+  D: "Dependency Integrity", E: "Synthesis Alignment", F: "Task Specification Quality",
+  G: "Duplication Detection", H: "Feasibility Assessment"
+}
+```
+
+### 5. Generate Report
+
+```javascript
+// Helper: render dimension section
+const renderDimension = (dim) => {
+  const items = byDimension[dim] || []
+  return items.length > 0
+    ? items.map(f => `### ${f.id}: ${f.summary}\n- **Severity**: ${f.severity}\n- **Location**: ${f.location.join(', ')}\n- **Recommendation**: ${f.recommendation}`).join('\n\n')
+    : `> ✅ No ${DIMS[dim]} issues detected.`
+}
+
+// Helper: render severity section
+const renderSeverity = (severity, impact) => {
+  const items = bySeverity[severity] || []
+  return items.length > 0
+    ? items.map(f => `#### ${f.id}: ${f.summary}\n- **Dimension**: ${f.dimension_name}\n- **Location**: ${f.location.join(', ')}\n- **Impact**: ${impact}\n- **Recommendation**: ${f.recommendation}`).join('\n\n')
+    : `> ✅ No ${severity.toLowerCase()}-severity issues detected.`
+}
+
+// Build Markdown report
+const fullReport = `
+# Plan Verification Report
+
+**Session**: WFS-${session_id} | **Generated**: ${timestamp}
+**Tiers Completed**: ${verification_tiers_completed.join(', ')}
+
+---
+
+## Executive Summary
+
+| Metric | Value | Status |
+|--------|-------|--------|
+| Risk Level | ${critical_count > 0 ? 'CRITICAL' : high_count > 0 ? 'HIGH' : medium_count > 0 ? 'MEDIUM' : 'LOW'} | ${critical_count > 0 ? '🔴' : high_count > 0 ? '🟠' : medium_count > 0 ? '🟡' : '🟢'} |
+| Critical/High/Medium/Low | ${critical_count}/${high_count}/${medium_count}/${low_count} | |
+| Coverage | ${coverage_percentage}% | ${coverage_percentage >= 90 ? '🟢' : coverage_percentage >= 75 ? '🟡' : '🔴'} |
+
+**Recommendation**: **${recommendation}**
+
+---
+
+## Findings Summary
+
+| ID | Dimension | Severity | Location | Summary |
+|----|-----------|----------|----------|---------|
+${findings.map(f => `| ${f.id} | ${f.dimension_name} | ${f.severity} | ${f.location.join(', ')} | ${f.summary} |`).join('\n')}
+
+---
+
+## Analysis by Dimension
+
+${['A','B','C','D','E','F','G','H'].map(d => `### ${d}. ${DIMS[d]}\n\n${renderDimension(d)}`).join('\n\n---\n\n')}
+
+---
+
+## Findings by Severity
+
+### CRITICAL (${critical_count})
+${renderSeverity('CRITICAL', 'Blocks execution')}
+
+### HIGH (${high_count})
+${renderSeverity('HIGH', 'Fix before execution recommended')}
+
+### MEDIUM (${medium_count})
+${renderSeverity('MEDIUM', 'Address during/after implementation')}
+
+### LOW (${low_count})
+${renderSeverity('LOW', 'Optional improvement')}
+
+---
+
+## Next Steps
+
+${recommendation === 'BLOCK_EXECUTION' ? '🛑 **BLOCK**: Fix critical issues → Re-verify' :
+  recommendation === 'PROCEED_WITH_FIXES' ? '⚠️ **FIX RECOMMENDED**: Address high issues → Re-verify or Execute' :
+  '✅ **READY**: Proceed to /workflow:execute'}
+
+Re-verify: \`/workflow:plan-verify --session ${session_id}\`
+Execute: \`/workflow:execute --resume-session="${session_id}"\`
+`
+
+// Write report
+Write(`${process_dir}/PLAN_VERIFICATION.md`, fullReport)
+console.log(`✅ Report: ${process_dir}/PLAN_VERIFICATION.md\n📊 ${recommendation} | C:${critical_count} H:${high_count} M:${medium_count} L:${low_count} | Coverage:${coverage_percentage}%`)
+```
+
+### 6. Next Step Selection
+
+```javascript
+const autoYes = $ARGUMENTS.includes('--yes') || $ARGUMENTS.includes('-y')
+const canExecute = recommendation !== 'BLOCK_EXECUTION'
+
+// Auto mode
+if (autoYes) {
+  if (canExecute) {
+    SlashCommand("/workflow:execute --yes --resume-session=\"${session_id}\"")
+  } else {
+    console.log(`[--yes] BLOCK_EXECUTION - Fix ${critical_count} critical issues first.`)
+  }
+  return
+}
+
+// Interactive mode - build options based on quality gate
+const options = canExecute
+  ? [
+      { label: canExecute && recommendation === 'PROCEED_WITH_FIXES' ? "Execute Anyway" : "Execute (Recommended)",
+        description: "Proceed to /workflow:execute" },
+      { label: "Review Report", description: "Review findings before deciding" },
+      { label: "Re-verify", description: "Re-run after manual fixes" }
+    ]
+  : [
+      { label: "Review Report", description: "Review critical issues" },
+      { label: "Re-verify", description: "Re-run after fixing issues" }
+    ]
+
+const selection = AskUserQuestion({
+  questions: [{
+    question: `Quality gate: ${recommendation}. Next step?`,
+    header: "Action",
+    multiSelect: false,
+    options
+  }]
+})
+
+// Handle selection
+if (selection.includes("Execute")) {
+  SlashCommand("/workflow:execute --resume-session=\"${session_id}\"")
+} else if (selection === "Re-verify") {
+  SlashCommand("/workflow:plan-verify --session ${session_id}")
+}
+```

.claude/commands/workflow/plan.md

@@ -1,10 +1,15 @@
 ---
 name: plan
 description: 5-phase planning workflow with action-planning-agent task generation, outputs IMPL_PLAN.md and task JSONs
-argument-hint: "\"text description\"|file.md"
+argument-hint: "[-y|--yes] \"text description\"|file.md"
 allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*)
+group: workflow
 ---
 
+## Auto Mode
+
+When `--yes` or `-y`: Auto-continue all phases (skip confirmations), use recommended conflict resolutions.
+
 # Workflow Plan Command (/workflow:plan)
 
 ## Coordinator Role
@@ -111,7 +116,38 @@ CONTEXT: Existing user database schema, REST API endpoints
 
 **TodoWrite**: Mark phase 1 completed, phase 2 in_progress
 
-**After Phase 1**: Return to user showing Phase 1 results, then auto-continue to Phase 2
+**After Phase 1**: Initialize planning-notes.md with user intent
+
+```javascript
+// Create minimal planning notes document
+const planningNotesPath = `.workflow/active/${sessionId}/planning-notes.md`
+const userGoal = structuredDescription.goal
+const userConstraints = structuredDescription.context || "None specified"
+
+Write(planningNotesPath, `# Planning Notes
+
+**Session**: ${sessionId}
+**Created**: ${new Date().toISOString()}
+
+## User Intent (Phase 1)
+
+- **GOAL**: ${userGoal}
+- **KEY_CONSTRAINTS**: ${userConstraints}
+
+---
+
+## Context Findings (Phase 2)
+(To be filled by context-gather)
+
+## Conflict Decisions (Phase 3)
+(To be filled if conflicts detected)
+
+## Consolidated Constraints (Phase 4 Input)
+1. ${userConstraints}
+`)
+```
+
+Return to user showing Phase 1 results, then auto-continue to Phase 2
 
 ---
 
@@ -134,6 +170,7 @@ SlashCommand(command="/workflow:tools:context-gather --session [sessionId] \"[st
 **Validation**:
 - Context package path extracted
 - File exists and is valid JSON
+- `prioritized_context` field exists
 
 <!-- TodoWrite: When context-gather executed, INSERT 3 context-gather tasks, mark first as in_progress -->
 
@@ -164,7 +201,37 @@ SlashCommand(command="/workflow:tools:context-gather --session [sessionId] \"[st
 
 **Note**: Phase 2 tasks completed and collapsed to summary.
 
-**After Phase 2**: Return to user showing Phase 2 results, then auto-continue to Phase 3/4 (depending on conflict_risk)
+**After Phase 2**: Update planning-notes.md with context findings, then auto-continue
+
+```javascript
+// Read context-package to extract key findings
+const contextPackage = JSON.parse(Read(contextPath))
+const conflictRisk = contextPackage.conflict_detection?.risk_level || 'low'
+const criticalFiles = (contextPackage.exploration_results?.aggregated_insights?.critical_files || [])
+  .slice(0, 5).map(f => f.path)
+const archPatterns = contextPackage.project_context?.architecture_patterns || []
+const constraints = contextPackage.exploration_results?.aggregated_insights?.constraints || []
+
+// Append Phase 2 findings to planning-notes.md
+Edit(planningNotesPath, {
+  old: '## Context Findings (Phase 2)\n(To be filled by context-gather)',
+  new: `## Context Findings (Phase 2)
+
+- **CRITICAL_FILES**: ${criticalFiles.join(', ') || 'None identified'}
+- **ARCHITECTURE**: ${archPatterns.join(', ') || 'Not detected'}
+- **CONFLICT_RISK**: ${conflictRisk}
+- **CONSTRAINTS**: ${constraints.length > 0 ? constraints.join('; ') : 'None'}`
+})
+
+// Append Phase 2 constraints to consolidated list
+Edit(planningNotesPath, {
+  old: '## Consolidated Constraints (Phase 4 Input)',
+  new: `## Consolidated Constraints (Phase 4 Input)
+${constraints.map((c, i) => `${i + 2}. [Context] ${c}`).join('\n')}`
+})
+```
+
+Return to user showing Phase 2 results, then auto-continue to Phase 3/4 (depending on conflict_risk)
 
 ---
 
@@ -225,7 +292,45 @@ SlashCommand(command="/workflow:tools:conflict-resolution --session [sessionId]
 
 **Note**: Phase 3 tasks completed and collapsed to summary.
 
-**After Phase 3**: Return to user showing conflict resolution results (if executed) and selected strategies, then auto-continue to Phase 3.5
+**After Phase 3**: Update planning-notes.md with conflict decisions (if executed), then auto-continue
+
+```javascript
+// If Phase 3 was executed, update planning-notes.md
+if (conflictRisk >= 'medium') {
+  const conflictResPath = `.workflow/active/${sessionId}/.process/conflict-resolution.json`
+
+  if (fs.existsSync(conflictResPath)) {
+    const conflictRes = JSON.parse(Read(conflictResPath))
+    const resolved = conflictRes.resolved_conflicts || []
+    const modifiedArtifacts = conflictRes.modified_artifacts || []
+    const planningConstraints = conflictRes.planning_constraints || []
+
+    // Update Phase 3 section
+    Edit(planningNotesPath, {
+      old: '## Conflict Decisions (Phase 3)\n(To be filled if conflicts detected)',
+      new: `## Conflict Decisions (Phase 3)
+
+- **RESOLVED**: ${resolved.map(r => `${r.type} → ${r.strategy}`).join('; ') || 'None'}
+- **MODIFIED_ARTIFACTS**: ${modifiedArtifacts.join(', ') || 'None'}
+- **CONSTRAINTS**: ${planningConstraints.join('; ') || 'None'}`
+    })
+
+    // Append Phase 3 constraints to consolidated list
+    if (planningConstraints.length > 0) {
+      const currentNotes = Read(planningNotesPath)
+      const constraintCount = (currentNotes.match(/^\d+\./gm) || []).length
+
+      Edit(planningNotesPath, {
+        old: '## Consolidated Constraints (Phase 4 Input)',
+        new: `## Consolidated Constraints (Phase 4 Input)
+${planningConstraints.map((c, i) => `${constraintCount + i + 1}. [Conflict] ${c}`).join('\n')}`
+      })
+    }
+  }
+}
+```
+
+Return to user showing conflict resolution results (if executed) and selected strategies, then auto-continue to Phase 3.5
 
 **Memory State Check**:
 - Evaluate current context window usage and memory state
@@ -278,7 +383,12 @@ SlashCommand(command="/workflow:tools:task-generate-agent --session [sessionId]"
 
 **CLI Execution Note**: CLI tool usage is now determined semantically by action-planning-agent based on user's task description. If user specifies "use Codex/Gemini/Qwen for X", the agent embeds `command` fields in relevant `implementation_approach` steps.
 
-**Input**: `sessionId` from Phase 1
+**Input**:
+- `sessionId` from Phase 1
+- **planning-notes.md**: Consolidated constraints from all phases (Phase 1-3)
+  - Path: `.workflow/active/[sessionId]/planning-notes.md`
+  - Contains: User intent, context findings, conflict decisions, consolidated constraints
+  - **Purpose**: Provides structured, minimal context summary to action-planning-agent
 
 **Validation**:
 - `.workflow/active/[sessionId]/IMPL_PLAN.md` exists
@@ -311,20 +421,55 @@ SlashCommand(command="/workflow:tools:task-generate-agent --session [sessionId]"
 
 **Note**: Agent task completed. No collapse needed (single task).
 
-**Return to User**:
-```
-Planning complete for session: [sessionId]
-Tasks generated: [count]
-Plan: .workflow/active/[sessionId]/IMPL_PLAN.md
+**Step 4.2: User Decision** - Choose next action
 
-Recommended Next Steps:
-1. /workflow:action-plan-verify --session [sessionId]  # Verify plan quality before execution
-2. /workflow:status  # Review task breakdown
-3. /workflow:execute  # Start implementation (after verification)
+After Phase 4 completes, present user with action choices:
 
-Quality Gate: Consider running /workflow:action-plan-verify to catch issues early
+```javascript
+console.log(`
+✅ Planning complete for session: ${sessionId}
+📊 Tasks generated: ${taskCount}
+📋 Plan: .workflow/active/${sessionId}/IMPL_PLAN.md
+`);
+
+// Ask user for next action
+const userChoice = AskUserQuestion({
+  questions: [{
+    question: "Planning complete. What would you like to do next?",
+    header: "Next Action",
+    multiSelect: false,
+    options: [
+      {
+        label: "Verify Plan Quality (Recommended)",
+        description: "Run quality verification to catch issues before execution. Checks plan structure, task dependencies, and completeness."
+      },
+      {
+        label: "Start Execution",
+        description: "Begin implementing tasks immediately. Use this if you've already reviewed the plan or want to start quickly."
+      },
+      {
+        label: "Review Status Only",
+        description: "View task breakdown and session status without taking further action. You can decide what to do next manually."
+      }
+    ]
+  }]
+});
+
+// Execute based on user choice
+if (userChoice.answers["Next Action"] === "Verify Plan Quality (Recommended)") {
+  console.log("\n🔍 Starting plan verification...\n");
+  SlashCommand(command="/workflow:plan-verify --session " + sessionId);
+} else if (userChoice.answers["Next Action"] === "Start Execution") {
+  console.log("\n🚀 Starting task execution...\n");
+  SlashCommand(command="/workflow:execute --session " + sessionId);
+} else if (userChoice.answers["Next Action"] === "Review Status Only") {
+  console.log("\n📊 Displaying session status...\n");
+  SlashCommand(command="/workflow:status --session " + sessionId);
+}
 ```
 
+**Return to User**: Based on user's choice, execute the corresponding workflow command.
+
 ## TodoWrite Pattern
 
 **Core Concept**: Dynamic task attachment and collapse for real-time visibility into workflow execution.
@@ -400,26 +545,21 @@ User Input (task description)
     ↓
 Phase 1: session:start --auto "structured-description"
     ↓ Output: sessionId
-    ↓ Session Memory: Previous tasks, context, artifacts
+    ↓ Write: planning-notes.md (User Intent section)
     ↓
 Phase 2: context-gather --session sessionId "structured-description"
-    ↓ Input: sessionId + session memory + structured description
-    ↓ Output: contextPath (context-package.json) + conflict_risk
+    ↓ Input: sessionId + structured description
+    ↓ Output: contextPath (context-package.json with prioritized_context) + conflict_risk
+    ↓ Update: planning-notes.md (Context Findings + Consolidated Constraints)
     ↓
 Phase 3: conflict-resolution [AUTO-TRIGGERED if conflict_risk ≥ medium]
     ↓ Input: sessionId + contextPath + conflict_risk
-    ↓ CLI-powered conflict detection (JSON output)
-    ↓ AskUserQuestion: Present conflicts + resolution strategies
-    ↓ User selects strategies (or skip)
-    ↓ Apply modifications via Edit tool:
-    ↓   - Update guidance-specification.md
-    ↓   - Update role analyses (*.md)
-    ↓   - Mark context-package.json as "resolved"
-    ↓ Output: Modified brainstorm artifacts (NO report file)
+    ↓ Output: Modified brainstorm artifacts
+    ↓ Update: planning-notes.md (Conflict Decisions + Consolidated Constraints)
     ↓ Skip if conflict_risk is none/low → proceed directly to Phase 4
     ↓
 Phase 4: task-generate-agent --session sessionId
-    ↓ Input: sessionId + resolved brainstorm artifacts + session memory
+    ↓ Input: sessionId + planning-notes.md + context-package.json + brainstorm artifacts
     ↓ Output: IMPL_PLAN.md, task JSONs, TODO_LIST.md
     ↓
 Return summary to user
@@ -546,6 +686,6 @@ CONSTRAINTS: [Limitations or boundaries]
 - `/workflow:tools:task-generate-agent` - Phase 4: Generate task JSON files with agent-driven approach
 
 **Follow-up Commands**:
-- `/workflow:action-plan-verify` - Recommended: Verify plan quality and catch issues before execution
+- `/workflow:plan-verify` - Recommended: Verify plan quality and catch issues before execution
 - `/workflow:status` - Review task breakdown and current progress
 - `/workflow:execute` - Begin implementation of generated tasks

.claude/commands/workflow/quick-plan-with-file.md

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

.claude/commands/workflow/replan.md

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

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

@@ -1,26 +1,26 @@
 ---
-name: review-fix
+name: review-cycle-fix
 description: Automated fixing of code review findings with AI-powered planning and coordinated execution. Uses intelligent grouping, multi-stage timeline coordination, and test-driven verification.
 argument-hint: "<export-file|review-dir> [--resume] [--max-iterations=N]"
 allowed-tools: SlashCommand(*), TodoWrite(*), Read(*), Bash(*), Task(*), Edit(*), Write(*)
 ---
 
-# Workflow Review-Fix Command
+# Workflow Review-Cycle-Fix Command
 
 ## Quick Start
 
 ```bash
 # Fix from exported findings file (session-based path)
-/workflow:review-fix .workflow/active/WFS-123/.review/fix-export-1706184622000.json
+/workflow:review-cycle-fix .workflow/active/WFS-123/.review/fix-export-1706184622000.json
 
 # Fix from review directory (auto-discovers latest export)
-/workflow:review-fix .workflow/active/WFS-123/.review/
+/workflow:review-cycle-fix .workflow/active/WFS-123/.review/
 
 # Resume interrupted fix session
-/workflow:review-fix --resume
+/workflow:review-cycle-fix --resume
 
 # Custom max retry attempts per finding
-/workflow:review-fix .workflow/active/WFS-123/.review/ --max-iterations=5
+/workflow:review-cycle-fix .workflow/active/WFS-123/.review/ --max-iterations=5
 ```
 
 **Fix Source**: Exported findings from review cycle dashboard
@@ -605,6 +605,4 @@ Use `ccw view` to open the workflow dashboard in browser:
 
 ```bash
 ccw view
-```
-
-
+```

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

@@ -764,8 +764,8 @@ After completing a module review, use the generated findings JSON for automated
 /workflow:review-module-cycle src/auth/**
 
 # Step 2: Run automated fixes using dimension findings
-/workflow:review-fix .workflow/active/WFS-{session-id}/.review/
+/workflow:review-cycle-fix .workflow/active/WFS-{session-id}/.review/
 ```
 
-See `/workflow:review-fix` for automated fixing with smart grouping, parallel execution, and test verification.
+See `/workflow:review-cycle-fix` for automated fixing with smart grouping, parallel execution, and test verification.
 

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

@@ -775,8 +775,8 @@ After completing a review, use the generated findings JSON for automated fixing:
 /workflow:review-session-cycle
 
 # Step 2: Run automated fixes using dimension findings
-/workflow:review-fix .workflow/active/WFS-{session-id}/.review/
+/workflow:review-cycle-fix .workflow/active/WFS-{session-id}/.review/
 ```
 
-See `/workflow:review-fix` for automated fixing with smart grouping, parallel execution, and test verification.
+See `/workflow:review-cycle-fix` for automated fixing with smart grouping, parallel execution, and test verification.
 

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

@@ -1,8 +1,10 @@
 ---
 name: complete
 description: Mark active workflow session as complete, archive with lessons learned, update manifest, remove active flag
+argument-hint: "[-y|--yes] [--detailed]"
 examples:
   - /workflow:session:complete
+  - /workflow:session:complete --yes
   - /workflow:session:complete --detailed
 ---
 
@@ -139,20 +141,41 @@ test -f .workflow/project-tech.json || echo "SKIP"
 After successful archival, prompt user to capture learnings:
 
 ```javascript
-AskUserQuestion({
-  questions: [{
-    question: "Would you like to solidify learnings from this session into project guidelines?",
-    header: "Solidify",
-    options: [
-      { label: "Yes, solidify now", description: "Extract learnings and update project-guidelines.json" },
-      { label: "Skip", description: "Archive complete, no learnings to capture" }
-    ],
-    multiSelect: false
-  }]
-})
+// Parse --yes flag
+const autoYes = $ARGUMENTS.includes('--yes') || $ARGUMENTS.includes('-y')
+
+if (autoYes) {
+  // Auto mode: Skip solidify
+  console.log(`[--yes] Auto-selecting: Skip solidify`)
+  console.log(`Session archived successfully.`)
+  // Done - no solidify
+} else {
+  // Interactive mode: Ask user
+  AskUserQuestion({
+    questions: [{
+      question: "Would you like to solidify learnings from this session into project guidelines?",
+      header: "Solidify",
+      options: [
+        { label: "Yes, solidify now", description: "Extract learnings and update project-guidelines.json" },
+        { label: "Skip", description: "Archive complete, no learnings to capture" }
+      ],
+      multiSelect: false
+    }]
+  })
+
+  // **If "Yes, solidify now"**: Execute `/workflow:session:solidify` with the archived session ID.
+}
 ```
 
-**If "Yes, solidify now"**: Execute `/workflow:session:solidify` with the archived session ID.
+## Auto Mode Defaults
+
+When `--yes` or `-y` flag is used:
+- **Solidify Learnings**: Auto-selected "Skip" (archive only, no solidify)
+
+**Flag Parsing**:
+```javascript
+const autoYes = $ARGUMENTS.includes('--yes') || $ARGUMENTS.includes('-y')
+```
 
 **Output**:
 ```

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

@@ -1,14 +1,18 @@
 ---
 name: solidify
 description: Crystallize session learnings and user-defined constraints into permanent project guidelines
-argument-hint: "[--type <convention|constraint|learning>] [--category <category>] \"rule or insight\""
+argument-hint: "[-y|--yes] [--type <convention|constraint|learning>] [--category <category>] \"rule or insight\""
 examples:
   - /workflow:session:solidify "Use functional components for all React code" --type convention
-  - /workflow:session:solidify "No direct DB access from controllers" --type constraint --category architecture
+  - /workflow:session:solidify -y "No direct DB access from controllers" --type constraint --category architecture
   - /workflow:session:solidify "Cache invalidation requires event sourcing" --type learning --category architecture
   - /workflow:session:solidify --interactive
 ---
 
+## Auto Mode
+
+When `--yes` or `-y`: Auto-categorize and add guideline without confirmation.
+
 # Session Solidify Command (/workflow:session:solidify)
 
 ## Overview

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

@@ -268,15 +268,19 @@ SlashCommand(command="/workflow:tools:conflict-resolution --session [sessionId]
 
 ### Phase 5: TDD Task Generation
 
-**Step 5.1: Execute** - TDD task generation via action-planning-agent
+**Step 5.1: Execute** - TDD task generation via action-planning-agent with Phase 0 user configuration
 
 ```javascript
 SlashCommand(command="/workflow:tools:task-generate-tdd --session [sessionId]")
 ```
 
-**Note**: CLI tool usage is determined semantically from user's task description.
+**Note**: Phase 0 now includes:
+- Supplementary materials collection (file paths or inline content)
+- Execution method preference (Agent/Hybrid/CLI)
+- CLI tool preference (Codex/Gemini/Qwen/Auto)
+- These preferences are passed to agent for task generation
 
-**Parse**: Extract feature count, task count (not chain count - tasks now contain internal TDD cycles)
+**Parse**: Extract feature count, task count (not chain count - tasks now contain internal TDD cycles), CLI execution IDs assigned
 
 **Validate**:
 - IMPL_PLAN.md exists (unified plan with TDD Implementation Tasks section)
@@ -284,15 +288,24 @@ SlashCommand(command="/workflow:tools:task-generate-tdd --session [sessionId]")
 - TODO_LIST.md exists with internal TDD phase indicators
 - Each IMPL task includes:
   - `meta.tdd_workflow: true`
-  - `flow_control.implementation_approach` with 3 steps (red/green/refactor)
+  - `meta.cli_execution_id: {session_id}-{task_id}`
+  - `meta.cli_execution: { "strategy": "new|resume|fork|merge_fork", ... }`
+  - `flow_control.implementation_approach` with exactly 3 steps (red/green/refactor)
   - Green phase includes test-fix-cycle configuration
+  - `context.focus_paths`: absolute or clear relative paths (enhanced with exploration critical_files)
+  - `flow_control.pre_analysis`: includes exploration integration_points analysis
 - IMPL_PLAN.md contains workflow_type: "tdd" in frontmatter
-- Task count ≤10 (compliance with task limit)
+- User configuration applied:
+  - If executionMethod == "cli" or "hybrid": command field added to steps
+  - CLI tool preference reflected in execution guidance
+- Task count ≤18 (compliance with hard limit)
 
 **Red Flag Detection** (Non-Blocking Warnings):
-- Task count >10: `⚠️ High task count may indicate insufficient decomposition`
+- Task count >18: `⚠️ Task count exceeds hard limit - request re-scope`
+- Missing cli_execution_id: `⚠️ Task lacks CLI execution ID for resume support`
 - Missing test-fix-cycle: `⚠️ Green phase lacks auto-revert configuration`
 - Generic task names: `⚠️ Vague task names suggest unclear TDD cycles`
+- Missing focus_paths: `⚠️ Task lacks clear file scope for implementation`
 
 **Action**: Log warnings to `.workflow/active/[sessionId]/.process/tdd-warnings.log` (non-blocking)
 
@@ -338,14 +351,22 @@ SlashCommand(command="/workflow:tools:task-generate-tdd --session [sessionId]")
 1. Each task contains complete TDD workflow (Red-Green-Refactor internally)
 2. Task structure validation:
    - `meta.tdd_workflow: true` in all IMPL tasks
+   - `meta.cli_execution_id` present (format: {session_id}-{task_id})
+   - `meta.cli_execution` strategy assigned (new/resume/fork/merge_fork)
    - `flow_control.implementation_approach` has exactly 3 steps
    - Each step has correct `tdd_phase`: "red", "green", "refactor"
+   - `context.focus_paths` are absolute or clear relative paths
+   - `flow_control.pre_analysis` includes exploration integration analysis
 3. Dependency validation:
    - Sequential features: IMPL-N depends_on ["IMPL-(N-1)"] if needed
    - Complex features: IMPL-N.M depends_on ["IMPL-N.(M-1)"] for subtasks
+   - CLI execution strategies correctly assigned based on dependency graph
 4. Agent assignment: All IMPL tasks use @code-developer
 5. Test-fix cycle: Green phase step includes test-fix-cycle logic with max_iterations
-6. Task count: Total tasks ≤10 (simple + subtasks)
+6. Task count: Total tasks ≤18 (simple + subtasks hard limit)
+7. User configuration:
+   - Execution method choice reflected in task structure
+   - CLI tool preference documented in implementation guidance (if CLI selected)
 
 **Red Flag Checklist** (from TDD best practices):
 - [ ] No tasks skip Red phase (`tdd_phase: "red"` exists in step 1)
@@ -371,7 +392,7 @@ ls -la .workflow/active/[sessionId]/.task/IMPL-*.json
 echo "IMPL tasks: $(ls .workflow/active/[sessionId]/.task/IMPL-*.json 2>/dev/null | wc -l)"
 
 # Sample task structure verification (first task)
-jq '{id, tdd: .meta.tdd_workflow, phases: [.flow_control.implementation_approach[].tdd_phase]}' \
+jq '{id, tdd: .meta.tdd_workflow, cli_id: .meta.cli_execution_id, phases: [.flow_control.implementation_approach[].tdd_phase]}' \
   "$(ls .workflow/active/[sessionId]/.task/IMPL-*.json | head -1)"
 ```
 
@@ -379,8 +400,9 @@ jq '{id, tdd: .meta.tdd_workflow, phases: [.flow_control.implementation_approach
 | Evidence Type | Verification Method | Pass Criteria |
 |---------------|---------------------|---------------|
 | File existence | `ls -la` artifacts | All files present |
-| Task count | Count IMPL-*.json | Count matches claims |
-| TDD structure | jq sample extraction | Shows red/green/refactor |
+| Task count | Count IMPL-*.json | Count matches claims (≤18) |
+| TDD structure | jq sample extraction | Shows red/green/refactor + cli_execution_id |
+| CLI execution IDs | jq extraction | All tasks have cli_execution_id assigned |
 | Warning log | Check tdd-warnings.log | Logged (may be empty) |
 
 **Return Summary**:
@@ -393,7 +415,7 @@ Total tasks: [M] (1 task per simple feature + subtasks for complex features)
 Task breakdown:
 - Simple features: [K] tasks (IMPL-1 to IMPL-K)
 - Complex features: [L] features with [P] subtasks
-- Total task count: [M] (within 10-task limit)
+- Total task count: [M] (within 18-task hard limit)
 
 Structure:
 - IMPL-1: {Feature 1 Name} (Internal: Red → Green → Refactor)
@@ -407,22 +429,31 @@ Plans generated:
 - Unified Implementation Plan: .workflow/active/[sessionId]/IMPL_PLAN.md
   (includes TDD Implementation Tasks section with workflow_type: "tdd")
 - Task List: .workflow/active/[sessionId]/TODO_LIST.md
-  (with internal TDD phase indicators)
+  (with internal TDD phase indicators and CLI execution strategies)
+- Task JSONs: .workflow/active/[sessionId]/.task/IMPL-*.json
+  (with cli_execution_id and execution strategies for resume support)
 
 TDD Configuration:
 - Each task contains complete Red-Green-Refactor cycle
 - Green phase includes test-fix cycle (max 3 iterations)
 - Auto-revert on max iterations reached
+- CLI execution strategies: new/resume/fork/merge_fork based on dependency graph
+
+User Configuration Applied:
+- Execution Method: [agent|hybrid|cli]
+- CLI Tool Preference: [codex|gemini|qwen|auto]
+- Supplementary Materials: [included|none]
+- Task generation follows cli-tools-usage.md guidelines
 
 ⚠️ ACTION REQUIRED: Before execution, ensure you understand WHY each Red phase test is expected to fail.
    This is crucial for valid TDD - if you don't know why the test fails, you can't verify it tests the right thing.
 
 Recommended Next Steps:
-1. /workflow:action-plan-verify --session [sessionId]  # Verify TDD plan quality and dependencies
-2. /workflow:execute --session [sessionId]  # Start TDD execution
+1. /workflow:plan-verify --session [sessionId]  # Verify TDD plan quality and dependencies
+2. /workflow:execute --session [sessionId]  # Start TDD execution with CLI strategies
 3. /workflow:tdd-verify [sessionId]  # Post-execution TDD compliance check
 
-Quality Gate: Consider running /workflow:action-plan-verify to validate TDD task structure and dependencies
+Quality Gate: Consider running /workflow:plan-verify to validate TDD task structure, dependencies, and CLI execution strategies
 ```
 
 ## TodoWrite Pattern
@@ -500,7 +531,7 @@ TDD Workflow Orchestrator
 │
 └─ Phase 6: TDD Structure Validation
    └─ Internal validation + summary returned
-   └─ Recommend: /workflow:action-plan-verify
+   └─ Recommend: /workflow:plan-verify
 
 Key Points:
 • ← ATTACHED: SlashCommand attaches sub-tasks to orchestrator TodoWrite
@@ -547,9 +578,11 @@ Convert user input to TDD-structured format:
 | Parsing failure | Empty/malformed output | Retry once, then report |
 | Missing context-package | File read error | Re-run `/workflow:tools:context-gather` |
 | Invalid task JSON | jq parse error | Report malformed file path |
-| High task count (>10) | Count validation | Log warning, continue (non-blocking) |
+| Task count exceeds 18 | Count validation ≥19 | Request re-scope, split into multiple sessions |
+| Missing cli_execution_id | All tasks lack ID | Regenerate tasks with phase 0 user config |
 | Test-context missing | File not found | Re-run `/workflow:tools:test-context-gather` |
 | Phase timeout | No response | Retry phase, check CLI connectivity |
+| CLI tool not available | Tool not in cli-tools.json | Fall back to alternative preferred tool |
 
 ## Related Commands
 
@@ -565,7 +598,7 @@ Convert user input to TDD-structured format:
 - `/workflow:tools:task-generate-tdd` - Phase 5: Generate TDD tasks (CLI tool usage determined semantically)
 
 **Follow-up Commands**:
-- `/workflow:action-plan-verify` - Recommended: Verify TDD plan quality and structure before execution
+- `/workflow:plan-verify` - Recommended: Verify TDD plan quality and structure before execution
 - `/workflow:status` - Review TDD task breakdown
 - `/workflow:execute` - Begin TDD implementation
 - `/workflow:tdd-verify` - Post-execution: Verify TDD compliance and generate quality report
@@ -574,7 +607,7 @@ Convert user input to TDD-structured format:
 
 | Situation | Recommended Command | Purpose |
 |-----------|---------------------|---------|
-| First time planning | `/workflow:action-plan-verify` | Validate task structure before execution |
+| First time planning | `/workflow:plan-verify` | Validate task structure before execution |
 | Warnings in tdd-warnings.log | Review log, refine tasks | Address Red Flags before proceeding |
 | High task count warning | Consider `/workflow:session:start` | Split into focused sub-sessions |
 | Ready to implement | `/workflow:execute` | Begin TDD Red-Green-Refactor cycles |
@@ -587,7 +620,7 @@ Convert user input to TDD-structured format:
 ```
 /workflow:tdd-plan
         ↓
-[Planning Complete] ──→ /workflow:action-plan-verify (recommended)
+[Planning Complete] ──→ /workflow:plan-verify (recommended)
         ↓
 [Verified/Ready] ─────→ /workflow:execute
         ↓

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

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

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

@@ -1,12 +1,16 @@
 ---
 name: conflict-resolution
 description: Detect and resolve conflicts between plan and existing codebase using CLI-powered analysis with Gemini/Qwen
-argument-hint: "--session WFS-session-id --context path/to/context-package.json"
+argument-hint: "[-y|--yes] --session WFS-session-id --context path/to/context-package.json"
 examples:
   - /workflow:tools:conflict-resolution --session WFS-auth --context .workflow/active/WFS-auth/.process/context-package.json
-  - /workflow:tools:conflict-resolution --session WFS-payment --context .workflow/active/WFS-payment/.process/context-package.json
+  - /workflow:tools:conflict-resolution -y --session WFS-payment --context .workflow/active/WFS-payment/.process/context-package.json
 ---
 
+## Auto Mode
+
+When `--yes` or `-y`: Auto-select recommended strategy for each conflict, skip clarification questions.
+
 # Conflict Resolution Command
 
 ## Purpose
@@ -21,10 +25,10 @@ Analyzes conflicts between implementation plans and existing codebase, **includi
 | Responsibility | Description |
 |---------------|-------------|
 | **Detect Conflicts** | Analyze plan vs existing code inconsistencies |
-| **Scenario Uniqueness** | **NEW**: Search and compare new modules with existing modules for functional overlaps |
+| **Scenario Uniqueness** | Search and compare new modules with existing modules for functional overlaps |
 | **Generate Strategies** | Provide 2-4 resolution options per conflict |
-| **Iterative Clarification** | **NEW**: Ask unlimited questions until scenario boundaries are clear and unique |
-| **Agent Re-analysis** | **NEW**: Dynamically update strategies based on user clarifications |
+| **Iterative Clarification** | Ask unlimited questions until scenario boundaries are clear and unique |
+| **Agent Re-analysis** | Dynamically update strategies based on user clarifications |
 | **CLI Analysis** | Use Gemini/Qwen (Claude fallback) |
 | **User Decision** | Present options ONE BY ONE, never auto-apply |
 | **Direct Text Output** | Output questions via text directly, NEVER use bash echo/printf |
@@ -53,7 +57,7 @@ Analyzes conflicts between implementation plans and existing codebase, **includi
 - Breaking updates
 
 ### 5. Module Scenario Overlap
-- **NEW**: Functional overlap between new and existing modules
+- Functional overlap between new and existing modules
 - Scenario boundary ambiguity
 - Duplicate responsibility detection
 - Module merge/split decisions
@@ -130,7 +134,7 @@ Task(subagent_type="cli-execution-agent", run_in_background=false, prompt=`
   ### 1. Load Context
   - Read existing files from conflict_detection.existing_files
   - Load plan from .workflow/active/{session_id}/.process/context-package.json
-  - **NEW**: Load exploration_results and use aggregated_insights for enhanced analysis
+  - Load exploration_results and use aggregated_insights for enhanced analysis
   - Extract role analyses and requirements
 
   ### 2. Execute CLI Analysis (Enhanced with Exploration + Scenario Uniqueness)
@@ -182,33 +186,25 @@ Task(subagent_type="cli-execution-agent", run_in_background=false, prompt=`
   - modifications.old_content: 20-100 chars for unique Edit tool matching
   - modifications.new_content: preserves markdown formatting
   - modification_suggestions: 2-5 actionable suggestions for custom handling
-`)
-```
 
-**Agent Internal Flow** (Enhanced):
-```
-1. Load context package
-2. Check conflict_risk (exit if none/low)
-3. Read existing files + plan artifacts
-4. Run CLI analysis (Gemini→Qwen→Claude) with enhanced tasks:
-   - Standard conflict detection (Architecture/API/Data/Dependency)
-   - **NEW: Module scenario uniqueness detection**
-     * Extract new module functionality from plan
-     * Search all existing modules with similar keywords/functionality
-     * Compare scenario coverage and responsibilities
-     * Identify functional overlaps and boundary ambiguities
-     * Generate ModuleOverlap conflicts with overlap_analysis
-5. Parse conflict findings (including ModuleOverlap category)
-6. Generate 2-4 strategies per conflict:
-   - Include modifications for each strategy
-   - **For ModuleOverlap**: Add clarification_needed questions for boundary definition
-7. Return JSON to stdout (NOT file write)
-8. Return execution log path
+  ### 5. Planning Notes Record (REQUIRED)
+  After analysis complete, append a brief execution record to planning-notes.md:
+
+  **File**: .workflow/active/{session_id}/planning-notes.md
+  **Location**: Under "## Conflict Decisions (Phase 3)" section
+  **Format**:
+  \`\`\`
+  ### [Conflict-Resolution Agent] YYYY-MM-DD
+  - **Note**: [智能补充：简短总结冲突类型、解决策略、关键决策等]
+  \`\`\`
+`)
 ```
 
 ### Phase 3: User Interaction Loop
 
 ```javascript
+const autoYes = $ARGUMENTS.includes('--yes') || $ARGUMENTS.includes('-y')
+
 FOR each conflict:
   round = 0, clarified = false, userClarifications = []
 
@@ -216,8 +212,13 @@ FOR each conflict:
     // 1. Display conflict info (text output for context)
     displayConflictSummary(conflict)  // id, brief, severity, overlap_analysis if ModuleOverlap
 
-    // 2. Strategy selection via AskUserQuestion
-    AskUserQuestion({
+    // 2. Strategy selection
+    if (autoYes) {
+      console.log(`[--yes] Auto-selecting recommended strategy`)
+      selectedStrategy = conflict.strategies[conflict.recommended || 0]
+      clarified = true  // Skip clarification loop
+    } else {
+      AskUserQuestion({
       questions: [{
         question: formatStrategiesForDisplay(conflict.strategies),
         header: "策略选择",
@@ -230,18 +231,19 @@ FOR each conflict:
           { label: "自定义修改", description: `建议: ${conflict.modification_suggestions?.slice(0,2).join('; ')}` }
         ]
       }]
-    })
+      })
 
-    // 3. Handle selection
-    if (userChoice === "自定义修改") {
-      customConflicts.push({ id, brief, category, suggestions, overlap_analysis })
-      break
+      // 3. Handle selection
+      if (userChoice === "自定义修改") {
+        customConflicts.push({ id, brief, category, suggestions, overlap_analysis })
+        break
+      }
+
+      selectedStrategy = findStrategyByName(userChoice)
     }
 
-    selectedStrategy = findStrategyByName(userChoice)
-
     // 4. Clarification (if needed) - batched max 4 per call
-    if (selectedStrategy.clarification_needed?.length > 0) {
+    if (!autoYes && selectedStrategy.clarification_needed?.length > 0) {
       for (batch of chunk(selectedStrategy.clarification_needed, 4)) {
         AskUserQuestion({
           questions: batch.map((q, i) => ({

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

@@ -35,7 +35,7 @@ Step 1: Context-Package Detection
       ├─ Valid package exists → Return existing (skip execution)
       └─ No valid package → Continue to Step 2
 
-Step 2: Complexity Assessment & Parallel Explore (NEW)
+Step 2: Complexity Assessment & Parallel Explore
    ├─ Analyze task_description → classify Low/Medium/High
    ├─ Select exploration angles (1-4 based on complexity)
    ├─ Launch N cli-explore-agents in parallel
@@ -213,19 +213,37 @@ Write(`${sessionFolder}/explorations-manifest.json`, JSON.stringify(explorationM
 **Only execute after Step 2 completes**
 
 ```javascript
+// Load user intent from planning-notes.md (from Phase 1)
+const planningNotesPath = `.workflow/active/${session_id}/planning-notes.md`;
+let userIntent = { goal: task_description, key_constraints: "None specified" };
+
+if (file_exists(planningNotesPath)) {
+  const notesContent = Read(planningNotesPath);
+  const goalMatch = notesContent.match(/\*\*GOAL\*\*:\s*(.+)/);
+  const constraintsMatch = notesContent.match(/\*\*KEY_CONSTRAINTS\*\*:\s*(.+)/);
+  if (goalMatch) userIntent.goal = goalMatch[1].trim();
+  if (constraintsMatch) userIntent.key_constraints = constraintsMatch[1].trim();
+}
+
 Task(
   subagent_type="context-search-agent",
   run_in_background=false,
   description="Gather comprehensive context for plan",
   prompt=`
 ## Execution Mode
-**PLAN MODE** (Comprehensive) - Full Phase 1-3 execution
+**PLAN MODE** (Comprehensive) - Full Phase 1-3 execution with priority sorting
 
 ## Session Information
 - **Session ID**: ${session_id}
 - **Task Description**: ${task_description}
 - **Output Path**: .workflow/${session_id}/.process/context-package.json
 
+## User Intent (from Phase 1 - Planning Notes)
+**GOAL**: ${userIntent.goal}
+**KEY_CONSTRAINTS**: ${userIntent.key_constraints}
+
+This is the PRIMARY context source - all subsequent analysis must align with user intent.
+
 ## Exploration Input (from Step 2)
 - **Manifest**: ${sessionFolder}/explorations-manifest.json
 - **Exploration Count**: ${explorationManifest.exploration_count}
@@ -245,7 +263,13 @@ Execute complete context-search-agent workflow for implementation planning:
 4. **Analysis**: Extract keywords, determine scope, classify complexity based on task description and project state
 
 ### Phase 2: Multi-Source Context Discovery
-Execute all discovery tracks:
+Execute all discovery tracks (WITH USER INTENT INTEGRATION):
+- **Track -1**: User Intent & Priority Foundation (EXECUTE FIRST)
+  - Load user intent (GOAL, KEY_CONSTRAINTS) from session input
+  - Map user requirements to codebase entities (files, modules, patterns)
+  - Establish baseline priority scores based on user goal alignment
+  - Output: user_intent_mapping.json with preliminary priority scores
+
 - **Track 0**: Exploration Synthesis (load ${sessionFolder}/explorations-manifest.json, prioritize critical_files, deduplicate patterns/integration_points)
 - **Track 1**: Historical archive analysis (query manifest.json for lessons learned)
 - **Track 2**: Reference documentation (CLAUDE.md, architecture docs)
@@ -254,13 +278,45 @@ Execute all discovery tracks:
 
 ### Phase 3: Synthesis, Assessment & Packaging
 1. Apply relevance scoring and build dependency graph
-2. **Synthesize 4-source data**: Merge findings from all sources (archive > docs > code > web). **Prioritize the context from `project-tech.json`** for architecture and tech stack unless code analysis reveals it's outdated.
-3. **Populate `project_context`**: Directly use the `overview` from `project-tech.json` to fill the `project_context` section. Include description, technology_stack, architecture, and key_components.
-4. **Populate `project_guidelines`**: Load conventions, constraints, and learnings from `project-guidelines.json` into a dedicated section.
-5. Integrate brainstorm artifacts (if .brainstorming/ exists, read content)
-6. Perform conflict detection with risk assessment
-7. **Inject historical conflicts** from archive analysis into conflict_detection
-8. Generate and validate context-package.json
+2. **Synthesize 5-source data** (including Track -1): Merge findings from all sources
+   - Priority order: User Intent > Archive > Docs > Exploration > Code > Web
+   - **Prioritize the context from `project-tech.json`** for architecture and tech stack unless code analysis reveals it's outdated
+3. **Context Priority Sorting**:
+   a. Combine scores from Track -1 (user intent alignment) + relevance scores + exploration critical_files
+   b. Classify files into priority tiers:
+      - **Critical** (score ≥ 0.85): Directly mentioned in user goal OR exploration critical_files
+      - **High** (0.70-0.84): Key dependencies, patterns required for goal
+      - **Medium** (0.50-0.69): Supporting files, indirect dependencies
+      - **Low** (< 0.50): Contextual awareness only
+   c. Generate dependency_order: Based on dependency graph + user goal sequence
+   d. Document sorting_rationale: Explain prioritization logic
+
+4. **Populate `project_context`**: Directly use the `overview` from `project-tech.json` to fill the `project_context` section. Include description, technology_stack, architecture, and key_components.
+5. **Populate `project_guidelines`**: Load conventions, constraints, and learnings from `project-guidelines.json` into a dedicated section.
+6. Integrate brainstorm artifacts (if .brainstorming/ exists, read content)
+7. Perform conflict detection with risk assessment
+8. **Inject historical conflicts** from archive analysis into conflict_detection
+9. **Generate prioritized_context section**:
+   ```json
+   {
+     "prioritized_context": {
+       "user_intent": {
+         "goal": "...",
+         "scope": "...",
+         "key_constraints": ["..."]
+       },
+       "priority_tiers": {
+         "critical": [{ "path": "...", "relevance": 0.95, "rationale": "..." }],
+         "high": [...],
+         "medium": [...],
+         "low": [...]
+       },
+       "dependency_order": ["module1", "module2", "module3"],
+       "sorting_rationale": "Based on user goal alignment (Track -1), exploration critical files, and dependency graph analysis"
+     }
+   }
+   ```
+10. Generate and validate context-package.json with prioritized_context field
 
 ## Output Requirements
 Complete context-package.json with:
@@ -272,6 +328,7 @@ Complete context-package.json with:
 - **brainstorm_artifacts**: {guidance_specification, role_analyses[], synthesis_output} with content
 - **conflict_detection**: {risk_level, risk_factors, affected_modules[], mitigation_strategy, historical_conflicts[]}
 - **exploration_results**: {manifest_path, exploration_count, angles, explorations[], aggregated_insights} (from Track 0)
+- **prioritized_context**: {user_intent, priority_tiers{critical, high, medium, low}, dependency_order[], sorting_rationale}
 
 ## Quality Validation
 Before completion verify:
@@ -282,6 +339,17 @@ Before completion verify:
 - [ ] No sensitive data exposed
 - [ ] Total files ≤50 (prioritize high-relevance)
 
+## Planning Notes Record (REQUIRED)
+After completing context-package.json, append a brief execution record to planning-notes.md:
+
+**File**: .workflow/active/${session_id}/planning-notes.md
+**Location**: Under "## Context Findings (Phase 2)" section
+**Format**:
+\`\`\`
+### [Context-Search Agent] YYYY-MM-DD
+- **Note**: [智能补充：简短总结关键发现，如探索角度、关键文件、冲突风险等]
+\`\`\`
+
 Execute autonomously following agent documentation.
 Report completion with statistics.
 `
@@ -326,116 +394,11 @@ Refer to `context-search-agent.md` Phase 3.7 for complete `context-package.json`
 - **brainstorm_artifacts**: Brainstorm documents with full content (if exists)
 - **conflict_detection**: Risk assessment with mitigation strategies and historical conflicts
 - **exploration_results**: Aggregated exploration insights (from parallel explore phase)
-
-## Historical Archive Analysis
-
-### Track 1: Query Archive Manifest
-
-The context-search-agent MUST perform historical archive analysis as Track 1 in Phase 2:
-
-**Step 1: Check for Archive Manifest**
-```bash
-# Check if archive manifest exists
-if [[ -f .workflow/archives/manifest.json ]]; then
-  # Manifest available for querying
-fi
-```
-
-**Step 2: Extract Task Keywords**
-```javascript
-// From current task description, extract key entities and operations
-const keywords = extractKeywords(task_description);
-// Examples: ["User", "model", "authentication", "JWT", "reporting"]
-```
-
-**Step 3: Search Archive for Relevant Sessions**
-```javascript
-// Query manifest for sessions with matching tags or descriptions
-const relevantArchives = archives.filter(archive => {
-  return archive.tags.some(tag => keywords.includes(tag)) ||
-         keywords.some(kw => archive.description.toLowerCase().includes(kw.toLowerCase()));
-});
-```
-
-**Step 4: Extract Watch Patterns**
-```javascript
-// For each relevant archive, check watch_patterns for applicability
-const historicalConflicts = [];
-
-relevantArchives.forEach(archive => {
-  archive.lessons.watch_patterns?.forEach(pattern => {
-    // Check if pattern trigger matches current task
-    if (isPatternRelevant(pattern.pattern, task_description)) {
-      historicalConflicts.push({
-        source_session: archive.session_id,
-        pattern: pattern.pattern,
-        action: pattern.action,
-        files_to_check: pattern.related_files,
-        archived_at: archive.archived_at
-      });
-    }
-  });
-});
-```
-
-**Step 5: Inject into Context Package**
-```json
-{
-  "conflict_detection": {
-    "risk_level": "medium",
-    "risk_factors": ["..."],
-    "affected_modules": ["..."],
-    "mitigation_strategy": "...",
-    "historical_conflicts": [
-      {
-        "source_session": "WFS-auth-feature",
-        "pattern": "When modifying User model",
-        "action": "Check reporting-service and auditing-service dependencies",
-        "files_to_check": ["src/models/User.ts", "src/services/reporting.ts"],
-        "archived_at": "2025-09-16T09:00:00Z"
-      }
-    ]
-  }
-}
-```
-
-### Risk Level Escalation
-
-If `historical_conflicts` array is not empty, minimum risk level should be "medium":
-
-```javascript
-if (historicalConflicts.length > 0 && currentRisk === "low") {
-  conflict_detection.risk_level = "medium";
-  conflict_detection.risk_factors.push(
-    `${historicalConflicts.length} historical conflict pattern(s) detected from past sessions`
-  );
-}
-```
-
-### Archive Query Algorithm
-
-```markdown
-1. IF .workflow/archives/manifest.json does NOT exist → Skip Track 1, continue to Track 2
-2. IF manifest exists:
-   a. Load manifest.json
-   b. Extract keywords from task_description (nouns, verbs, technical terms)
-   c. Filter archives where:
-      - ANY tag matches keywords (case-insensitive) OR
-      - description contains keywords (case-insensitive substring match)
-   d. For each relevant archive:
-      - Read lessons.watch_patterns array
-      - Check if pattern.pattern keywords overlap with task_description
-      - If relevant: Add to historical_conflicts array
-   e. IF historical_conflicts.length > 0:
-      - Set risk_level = max(current_risk, "medium")
-      - Add to risk_factors
-3. Continue to Track 2 (reference documentation)
-```
+- **prioritized_context**: Pre-sorted context with user intent and priority tiers (critical/high/medium/low)
 
 ## Notes
 
 - **Detection-first**: Always check for existing package before invoking agent
-- **Dual project file integration**: Agent reads both `.workflow/project-tech.json` (tech analysis) and `.workflow/project-guidelines.json` (user constraints) as primary sources
-- **Guidelines injection**: Project guidelines are included in context-package to ensure task generation respects user-defined constraints
-- **No redundancy**: This command is a thin orchestrator, all logic in agent
+- **User intent integration**: Load user intent from planning-notes.md (Phase 1 output)
+- **Output**: Generates `context-package.json` with `prioritized_context` field
 - **Plan-specific**: Use this for implementation planning; brainstorm mode uses direct agent call

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

@@ -1,11 +1,16 @@
 ---
 name: task-generate-agent
 description: Generate implementation plan documents (IMPL_PLAN.md, task JSONs, TODO_LIST.md) using action-planning-agent - produces planning artifacts, does NOT execute code implementation
-argument-hint: "--session WFS-session-id"
+argument-hint: "[-y|--yes] --session WFS-session-id"
 examples:
   - /workflow:tools:task-generate-agent --session WFS-auth
+  - /workflow:tools:task-generate-agent -y --session WFS-auth
 ---
 
+## Auto Mode
+
+When `--yes` or `-y`: Skip user questions, use defaults (no materials, Agent executor, Codex CLI tool).
+
 # Generate Implementation Plan Command
 
 ## Overview
@@ -14,6 +19,10 @@ Generate implementation planning documents (IMPL_PLAN.md, task JSONs, TODO_LIST.
 ## Core Philosophy
 - **Planning Only**: Generate planning documents (IMPL_PLAN.md, task JSONs, TODO_LIST.md) - does NOT implement code
 - **Agent-Driven Document Generation**: Delegate plan generation to action-planning-agent
+- **NO Redundant Context Sorting**: Context priority sorting is ALREADY completed in context-gather Phase 2/3
+  - Use `context-package.json.prioritized_context` directly
+  - DO NOT re-sort files or re-compute priorities
+  - `priority_tiers` and `dependency_order` are pre-computed and ready-to-use
 - **N+1 Parallel Planning**: Auto-detect multi-module projects, enable parallel planning (2+1 or 3+1 mode)
 - **Progressive Loading**: Load context incrementally (Core → Selective → On-Demand) due to analysis.md file size
 - **Memory-First**: Reuse loaded documents from conversation memory
@@ -67,9 +76,25 @@ Phase 3: Integration (+1 Coordinator, Multi-Module Only)
 
 **Purpose**: Collect user preferences before task generation to ensure generated tasks match execution expectations.
 
-**User Questions**:
+**Auto Mode Check**:
 ```javascript
-AskUserQuestion({
+const autoYes = $ARGUMENTS.includes('--yes') || $ARGUMENTS.includes('-y')
+
+if (autoYes) {
+  console.log(`[--yes] Using defaults: No materials, Agent executor, Codex CLI`)
+  userConfig = {
+    supplementaryMaterials: { type: "none", content: [] },
+    executionMethod: "agent",
+    preferredCliTool: "codex",
+    enableResume: true
+  }
+  // Skip to Phase 1
+}
+```
+
+**User Questions** (skipped if autoYes):
+```javascript
+if (!autoYes) AskUserQuestion({
   questions: [
     {
       question: "Do you have supplementary materials or guidelines to include?",
@@ -104,11 +129,10 @@ AskUserQuestion({
     }
   ]
 })
-```
 
-**Handle Materials Response**:
+**Handle Materials Response** (skipped if autoYes):
 ```javascript
-if (userConfig.materials === "Provide file paths") {
+if (!autoYes && userConfig.materials === "Provide file paths") {
   // Follow-up question for file paths
   const pathsResponse = AskUserQuestion({
     questions: [{
@@ -141,12 +165,13 @@ const userConfig = {
 
 ### Phase 1: Context Preparation & Module Detection (Command Responsibility)
 
-**Command prepares session paths, metadata, and detects module structure.**
+**Command prepares session paths, metadata, detects module structure. Context priority sorting is NOT performed here - it's already completed in context-gather Phase 2/3.**
 
 **Session Path Structure**:
 ```
 .workflow/active/WFS-{session-id}/
 ├── workflow-session.json          # Session metadata
+├── planning-notes.md              # Consolidated planning notes
 ├── .process/
 │   └── context-package.json       # Context package with artifact catalog
 ├── .task/                         # Output: Task JSON files
@@ -228,9 +253,21 @@ IMPORTANT: This is PLANNING ONLY - you are generating planning documents, NOT im
 
 CRITICAL: Follow the progressive loading strategy defined in agent specification (load analysis.md files incrementally due to file size)
 
+## PLANNING NOTES (PHASE 1-3 CONTEXT)
+Load: .workflow/active/{session-id}/planning-notes.md
+
+This document contains:
+- User Intent: Original GOAL and KEY_CONSTRAINTS from Phase 1
+- Context Findings: Critical files, architecture, and constraints from Phase 2
+- Conflict Decisions: Resolved conflicts and planning constraints from Phase 3
+- Consolidated Constraints: All constraints from all phases
+
+**USAGE**: Read planning-notes.md FIRST. Use Consolidated Constraints list to guide task sequencing and dependencies.
+
 ## SESSION PATHS
 Input:
   - Session Metadata: .workflow/active/{session-id}/workflow-session.json
+  - Planning Notes: .workflow/active/{session-id}/planning-notes.md
   - Context Package: .workflow/active/{session-id}/.process/context-package.json
 
 Output:
@@ -258,7 +295,17 @@ CLI Resume Support (MANDATORY for all CLI commands):
 - Read previous task's cliExecutionId from session state
 - Format: ccw cli -p "[prompt]" --resume ${previousCliId} --tool ${tool} --mode write
 
-## EXPLORATION CONTEXT (from context-package.exploration_results)
+## PRIORITIZED CONTEXT (from context-package.prioritized_context) - ALREADY SORTED
+Context sorting is ALREADY COMPLETED in context-gather Phase 2/3. DO NOT re-sort.
+Direct usage:
+- **user_intent**: Use goal/scope/key_constraints for task alignment
+- **priority_tiers.critical**: These files are PRIMARY focus for task generation
+- **priority_tiers.high**: These files are SECONDARY focus
+- **dependency_order**: Use this for task sequencing - already computed
+- **sorting_rationale**: Reference for understanding priority decisions
+
+## EXPLORATION CONTEXT (from context-package.exploration_results) - SUPPLEMENT ONLY
+If prioritized_context is incomplete, fall back to exploration_results:
 - Load exploration_results from context-package.json
 - Use aggregated_insights.critical_files for focus_paths generation
 - Apply aggregated_insights.constraints to acceptance criteria
@@ -278,8 +325,10 @@ CLI Resume Support (MANDATORY for all CLI commands):
    - 6-field schema (id, title, status, context_package_path, meta, context, flow_control)
    - Quantified requirements with explicit counts
    - Artifacts integration from context package
-   - **focus_paths enhanced with exploration critical_files**
-   - Flow control with pre_analysis steps (include exploration integration_points analysis)
+   - **focus_paths generated directly from prioritized_context.priority_tiers (critical + high)**
+     - NO re-sorting or re-prioritization - use pre-computed tiers as-is
+     - Critical files are PRIMARY focus, High files are SECONDARY
+   - Flow control with pre_analysis steps (use prioritized_context.dependency_order for task sequencing)
    - **CLI Execution IDs and strategies (MANDATORY)**
 
 2. Implementation Plan (IMPL_PLAN.md)
@@ -327,6 +376,19 @@ Hard Constraints:
   - IMPL_PLAN.md created with complete structure
   - TODO_LIST.md generated matching task JSONs
 - Return completion status with document count and task breakdown summary
+
+## PLANNING NOTES RECORD (REQUIRED)
+After completing all documents, append a brief execution record to planning-notes.md:
+
+**File**: .workflow/active/{session_id}/planning-notes.md
+**Location**: Create new section after "## Consolidated Constraints"
+**Format**:
+\`\`\`
+## Task Generation (Phase 4)
+
+### [Action-Planning Agent] YYYY-MM-DD
+- **Note**: [智能补充：简短总结任务数量、关键任务、依赖关系等]
+\`\`\`
 `
 )
 ```
@@ -356,16 +418,22 @@ IMPORTANT: Generate Task JSONs ONLY. IMPL_PLAN.md and TODO_LIST.md by Phase 3 Co
 
 CRITICAL: Follow the progressive loading strategy defined in agent specification (load analysis.md files incrementally due to file size)
 
+## PLANNING NOTES (PHASE 1-3 CONTEXT)
+Load: .workflow/active/{session-id}/planning-notes.md
+
+This document contains consolidated constraints and user intent to guide module-scoped task generation.
+
 ## MODULE SCOPE
 - Module: ${module.name} (${module.type})
 - Focus Paths: ${module.paths.join(', ')}
 - Task ID Prefix: IMPL-${module.prefix}
-- Task Limit: ≤9 tasks (hard limit for this module)
+- Task Limit: ≤6 tasks (hard limit for this module)
 - Other Modules: ${otherModules.join(', ')} (reference only, do NOT generate tasks for them)
 
 ## SESSION PATHS
 Input:
   - Session Metadata: .workflow/active/{session-id}/workflow-session.json
+  - Planning Notes: .workflow/active/{session-id}/planning-notes.md
   - Context Package: .workflow/active/{session-id}/.process/context-package.json
 
 Output:
@@ -391,7 +459,16 @@ CLI Resume Support (MANDATORY for all CLI commands):
 - Read previous task's cliExecutionId from session state
 - Format: ccw cli -p "[prompt]" --resume ${previousCliId} --tool ${tool} --mode write
 
-## EXPLORATION CONTEXT (from context-package.exploration_results)
+## PRIORITIZED CONTEXT (from context-package.prioritized_context) - ALREADY SORTED
+Context sorting is ALREADY COMPLETED in context-gather Phase 2/3. DO NOT re-sort.
+Filter by module scope (${module.paths.join(', ')}):
+- **user_intent**: Use for task alignment within module
+- **priority_tiers.critical**: Filter for files in ${module.paths.join(', ')} → PRIMARY focus
+- **priority_tiers.high**: Filter for files in ${module.paths.join(', ')} → SECONDARY focus
+- **dependency_order**: Use module-relevant entries for task sequencing
+
+## EXPLORATION CONTEXT (from context-package.exploration_results) - SUPPLEMENT ONLY
+If prioritized_context is incomplete for this module, fall back to exploration_results:
 - Load exploration_results from context-package.json
 - Filter for ${module.name} module: Use aggregated_insights.critical_files matching ${module.paths.join(', ')}
 - Apply module-relevant constraints from aggregated_insights.constraints
@@ -418,8 +495,10 @@ Task JSON Files (.task/IMPL-${module.prefix}*.json):
   - Task ID format: IMPL-${module.prefix}1, IMPL-${module.prefix}2, ...
   - Quantified requirements with explicit counts
   - Artifacts integration from context package (filtered for ${module.name})
-  - **focus_paths enhanced with exploration critical_files (module-scoped)**
-  - Flow control with pre_analysis steps (include exploration integration_points analysis)
+  - **focus_paths generated directly from prioritized_context.priority_tiers filtered by ${module.paths.join(', ')}**
+    - NO re-sorting - use pre-computed tiers filtered for this module
+    - Critical files are PRIMARY focus, High files are SECONDARY
+  - Flow control with pre_analysis steps (use prioritized_context.dependency_order for module task sequencing)
   - **CLI Execution IDs and strategies (MANDATORY)**
   - Focus ONLY on ${module.name} module scope
 
@@ -462,6 +541,21 @@ Hard Constraints:
 - Cross-module dependencies use CROSS:: placeholder format consistently
 - Focus paths scoped to ${module.paths.join(', ')} only
 - Return: task count, task IDs, dependency summary (internal + cross-module)
+
+## PLANNING NOTES RECORD (REQUIRED)
+After completing module task JSONs, append a brief execution record to planning-notes.md:
+
+**File**: .workflow/active/{session_id}/planning-notes.md
+**Location**: Create new section after "## Consolidated Constraints" (if not exists)
+**Format**:
+\`\`\`
+## Task Generation (Phase 4)
+
+### [Action-Planning Agent - ${module.name}] YYYY-MM-DD
+- **Note**: [智能补充：简短总结本模块任务数量、关键任务等]
+\`\`\`
+
+**Note**: Multiple module agents will append their records. Phase 3 Integration Coordinator will add final summary.
     `
   )
 );
@@ -542,6 +636,17 @@ Module Count: ${modules.length}
 - No CROSS:: placeholders remaining in task JSONs
 - IMPL_PLAN.md and TODO_LIST.md generated with multi-module structure
 - Return: task count, per-module breakdown, resolved dependency count
+
+## PLANNING NOTES RECORD (REQUIRED)
+After completing integration, append final summary to planning-notes.md:
+
+**File**: .workflow/active/{session_id}/planning-notes.md
+**Location**: Under "## Task Generation (Phase 4)" section (after module agent records)
+**Format**:
+\`\`\`
+### [Integration Coordinator] YYYY-MM-DD
+- **Note**: [智能补充：简短总结总任务数、跨模块依赖解决情况等]
+\`\`\`
   `
 )
 ```
@@ -559,5 +664,4 @@ function resolveCrossModuleDependency(placeholder, allTasks) {
     ? candidates.sort((a, b) => a.id.localeCompare(b.id))[0].id
     : placeholder; // Keep for manual resolution
 }
-```
-
+```

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

@@ -1,11 +1,16 @@
 ---
 name: task-generate-tdd
 description: Autonomous TDD task generation using action-planning-agent with Red-Green-Refactor cycles, test-first structure, and cycle validation
-argument-hint: "--session WFS-session-id"
+argument-hint: "[-y|--yes] --session WFS-session-id"
 examples:
   - /workflow:tools:task-generate-tdd --session WFS-auth
+  - /workflow:tools:task-generate-tdd -y --session WFS-auth
 ---
 
+## Auto Mode
+
+When `--yes` or `-y`: Skip user questions, use defaults (no materials, Agent executor).
+
 # Autonomous TDD Task Generation Command
 
 ## Overview
@@ -78,44 +83,176 @@ Phase 2: Agent Execution (Document Generation)
 
 ## Execution Lifecycle
 
-### Phase 1: Discovery & Context Loading
+### Phase 0: User Configuration (Interactive)
+
+**Purpose**: Collect user preferences before TDD task generation to ensure generated tasks match execution expectations and provide necessary supplementary context.
+
+**User Questions**:
+```javascript
+AskUserQuestion({
+  questions: [
+    {
+      question: "Do you have supplementary materials or guidelines to include?",
+      header: "Materials",
+      multiSelect: false,
+      options: [
+        { label: "No additional materials", description: "Use existing context only" },
+        { label: "Provide file paths", description: "I'll specify paths to include" },
+        { label: "Provide inline content", description: "I'll paste content directly" }
+      ]
+    },
+    {
+      question: "Select execution method for generated TDD tasks:",
+      header: "Execution",
+      multiSelect: false,
+      options: [
+        { label: "Agent (Recommended)", description: "Claude agent executes Red-Green-Refactor cycles directly" },
+        { label: "Hybrid", description: "Agent orchestrates, calls CLI for complex steps (Red/Green phases)" },
+        { label: "CLI Only", description: "All TDD cycles via CLI tools (codex/gemini/qwen)" }
+      ]
+    },
+    {
+      question: "If using CLI, which tool do you prefer?",
+      header: "CLI Tool",
+      multiSelect: false,
+      options: [
+        { label: "Codex (Recommended)", description: "Best for TDD Red-Green-Refactor cycles" },
+        { label: "Gemini", description: "Best for analysis and large context" },
+        { label: "Qwen", description: "Alternative analysis tool" },
+        { label: "Auto", description: "Let agent decide per-task" }
+      ]
+    }
+  ]
+})
+```
+
+**Handle Materials Response**:
+```javascript
+if (userConfig.materials === "Provide file paths") {
+  // Follow-up question for file paths
+  const pathsResponse = AskUserQuestion({
+    questions: [{
+      question: "Enter file paths to include (comma-separated or one per line):",
+      header: "Paths",
+      multiSelect: false,
+      options: [
+        { label: "Enter paths", description: "Provide paths in text input" }
+      ]
+    }]
+  })
+  userConfig.supplementaryPaths = parseUserPaths(pathsResponse)
+}
+```
+
+**Build userConfig**:
+```javascript
+const userConfig = {
+  supplementaryMaterials: {
+    type: "none|paths|inline",
+    content: [...],  // Parsed paths or inline content
+  },
+  executionMethod: "agent|hybrid|cli",
+  preferredCliTool: "codex|gemini|qwen|auto",
+  enableResume: true  // Always enable resume for CLI executions
+}
+```
+
+**Pass to Agent**: Include `userConfig` in agent prompt for Phase 2.
+
+---
+
+### Phase 1: Context Preparation & Discovery
+
+**Command Responsibility**: Command prepares session paths and metadata, provides to agent for autonomous context loading.
+
 **⚡ Memory-First Rule**: Skip file loading if documents already in conversation memory
 
-**Agent Context Package**:
+**📊 Progressive Loading Strategy**: Load context incrementally due to large analysis.md file sizes:
+- **Core**: session metadata + context-package.json (always load)
+- **Selective**: synthesis_output OR (guidance + relevant role analyses) - NOT all role analyses
+- **On-Demand**: conflict resolution (if conflict_risk >= medium), test context
+
+**🛤️ Path Clarity Requirement**: All `focus_paths` prefer absolute paths (e.g., `D:\\project\\src\\module`), or clear relative paths from project root (e.g., `./src/module`)
+
+**Session Path Structure** (Provided by Command to Agent):
+```
+.workflow/active/WFS-{session-id}/
+├── workflow-session.json          # Session metadata
+├── .process/
+│   ├── context-package.json       # Context package with artifact catalog
+│   ├── test-context-package.json  # Test coverage analysis
+│   └── conflict-resolution.json   # Conflict resolution (if exists)
+├── .task/                         # Output: Task JSON files
+│   ├── IMPL-1.json
+│   ├── IMPL-2.json
+│   └── ...
+├── IMPL_PLAN.md                   # Output: TDD implementation plan
+└── TODO_LIST.md                   # Output: TODO list with TDD phases
+```
+
+**Command Preparation**:
+1. **Assemble Session Paths** for agent prompt:
+   - `session_metadata_path`: `.workflow/active/{session-id}/workflow-session.json`
+   - `context_package_path`: `.workflow/active/{session-id}/.process/context-package.json`
+   - `test_context_package_path`: `.workflow/active/{session-id}/.process/test-context-package.json`
+   - Output directory paths
+
+2. **Provide Metadata** (simple values):
+   - `session_id`: WFS-{session-id}
+   - `workflow_type`: "tdd"
+   - `mcp_capabilities`: {exa_code, exa_web, code_index}
+
+3. **Pass userConfig** from Phase 0
+
+**Agent Context Package** (Agent loads autonomously):
 ```javascript
 {
   "session_id": "WFS-[session-id]",
   "workflow_type": "tdd",
-  // Note: CLI tool usage is determined semantically by action-planning-agent based on user's task description
+
+  // Core (ALWAYS load)
   "session_metadata": {
     // If in memory: use cached content
-    // Else: Load from .workflow/active//{session-id}/workflow-session.json
+    // Else: Load from workflow-session.json
   },
+  "context_package": {
+    // If in memory: use cached content
+    // Else: Load from context-package.json
+  },
+
+  // Selective (load based on progressive strategy)
   "brainstorm_artifacts": {
     // Loaded from context-package.json → brainstorm_artifacts section
-    "role_analyses": [
+    "synthesis_output": {"path": "...", "exists": true},  // Load if exists (highest priority)
+    "guidance_specification": {"path": "...", "exists": true},  // Load if no synthesis
+    "role_analyses": [  // Load SELECTIVELY based on task relevance
       {
         "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/active//{session-id}/.process/context-package.json",
-  "context_package": {
-    // If in memory: use cached content
-    // Else: Load from .workflow/active//{session-id}/.process/context-package.json
-  },
-  "test_context_package_path": ".workflow/active//{session-id}/.process/test-context-package.json",
+
+  // On-Demand (load if exists)
   "test_context_package": {
-    // Existing test patterns and coverage analysis
+    // Load from test-context-package.json
+    // Contains existing test patterns and coverage analysis
   },
+  "conflict_resolution": {
+    // Load from conflict-resolution.json if conflict_risk >= medium
+    // Check context-package.conflict_detection.resolution_file
+  },
+
+  // Capabilities
   "mcp_capabilities": {
-    "codex_lens": true,
     "exa_code": true,
-    "exa_web": true
+    "exa_web": true,
+    "code_index": true
+  },
+
+  // User configuration from Phase 0
+  "user_config": {
+    // From Phase 0 AskUserQuestion
   }
 }
 ```
@@ -124,21 +261,21 @@ Phase 2: Agent Execution (Document Generation)
 1. **Load Session Context** (if not in memory)
    ```javascript
    if (!memory.has("workflow-session.json")) {
-     Read(.workflow/active//{session-id}/workflow-session.json)
+     Read(.workflow/active/{session-id}/workflow-session.json)
    }
    ```
 
 2. **Load Context Package** (if not in memory)
    ```javascript
    if (!memory.has("context-package.json")) {
-     Read(.workflow/active//{session-id}/.process/context-package.json)
+     Read(.workflow/active/{session-id}/.process/context-package.json)
    }
    ```
 
 3. **Load Test Context Package** (if not in memory)
    ```javascript
    if (!memory.has("test-context-package.json")) {
-     Read(.workflow/active//{session-id}/.process/test-context-package.json)
+     Read(.workflow/active/{session-id}/.process/test-context-package.json)
    }
    ```
 
@@ -180,62 +317,81 @@ Phase 2: Agent Execution (Document Generation)
    )
    ```
 
-### Phase 2: Agent Execution (Document Generation)
+### Phase 2: Agent Execution (TDD Document Generation)
 
-**Pre-Agent Template Selection** (Command decides path before invoking agent):
-```javascript
-// Command checks flag and selects template PATH (not content)
-const templatePath = hasCliExecuteFlag
-  ? "~/.claude/workflows/cli-templates/prompts/workflow/task-json-cli-mode.txt"
-  : "~/.claude/workflows/cli-templates/prompts/workflow/task-json-agent-mode.txt";
-```
+**Purpose**: Generate TDD planning documents (IMPL_PLAN.md, task JSONs, TODO_LIST.md) - planning only, NOT code implementation.
 
 **Agent Invocation**:
 ```javascript
 Task(
   subagent_type="action-planning-agent",
   run_in_background=false,
-  description="Generate TDD task JSON and implementation plan",
+  description="Generate TDD planning documents (IMPL_PLAN.md, task JSONs, TODO_LIST.md)",
   prompt=`
-## Execution Context
+## TASK OBJECTIVE
+Generate TDD implementation planning documents (IMPL_PLAN.md, task JSONs, TODO_LIST.md) for workflow session
 
-**Session ID**: WFS-{session-id}
-**Workflow Type**: TDD
-**Note**: CLI tool usage is determined semantically from user's task description
+IMPORTANT: This is PLANNING ONLY - you are generating planning documents, NOT implementing code.
 
-## Phase 1: Discovery Results (Provided Context)
+CRITICAL: Follow the progressive loading strategy (load analysis.md files incrementally due to file size):
+- **Core**: session metadata + context-package.json (always)
+- **Selective**: synthesis_output OR (guidance + relevant role analyses) - NOT all
+- **On-Demand**: conflict resolution (if conflict_risk >= medium), test context
 
-### Session Metadata
-{session_metadata_content}
+## SESSION PATHS
+Input:
+  - Session Metadata: .workflow/active/{session-id}/workflow-session.json
+  - Context Package: .workflow/active/{session-id}/.process/context-package.json
+  - Test Context: .workflow/active/{session-id}/.process/test-context-package.json
 
-### Role Analyses (Enhanced by Synthesis)
-{role_analyses_content}
-- Includes requirements, design specs, enhancements, and clarifications from synthesis phase
+Output:
+  - Task Dir: .workflow/active/{session-id}/.task/
+  - IMPL_PLAN: .workflow/active/{session-id}/IMPL_PLAN.md
+  - TODO_LIST: .workflow/active/{session-id}/TODO_LIST.md
 
-### Artifacts Inventory
-- **Guidance Specification**: {guidance_spec_path}
-- **Role Analyses**: {role_analyses_list}
+## CONTEXT METADATA
+Session ID: {session-id}
+Workflow Type: TDD
+MCP Capabilities: {exa_code, exa_web, code_index}
 
-### Context Package
-{context_package_summary}
-- Includes conflict_risk assessment
+## USER CONFIGURATION (from Phase 0)
+Execution Method: ${userConfig.executionMethod}  // agent|hybrid|cli
+Preferred CLI Tool: ${userConfig.preferredCliTool}  // codex|gemini|qwen|auto
+Supplementary Materials: ${userConfig.supplementaryMaterials}
 
-### Test Context Package
-{test_context_package_summary}
-- Existing test patterns, framework config, coverage analysis
+## CLI TOOL SELECTION
+Based on userConfig.executionMethod:
+- "agent": No command field in implementation_approach steps
+- "hybrid": Add command field to complex steps only (Red/Green phases recommended for CLI)
+- "cli": Add command field to ALL Red-Green-Refactor steps
 
-### 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
-- Conflict resolution results stored in conflict-resolution.json
+CLI Resume Support (MANDATORY for all CLI commands):
+- Use --resume parameter to continue from previous task execution
+- Read previous task's cliExecutionId from session state
+- Format: ccw cli -p "[prompt]" --resume [previousCliId] --tool [tool] --mode write
 
-### MCP Analysis Results (Optional)
-**Code Structure**: {mcp_code_index_results}
-**External Research**: {mcp_exa_research_results}
+## EXPLORATION CONTEXT (from context-package.exploration_results)
+- Load exploration_results from context-package.json
+- Use aggregated_insights.critical_files for focus_paths generation
+- Apply aggregated_insights.constraints to acceptance criteria
+- Reference aggregated_insights.all_patterns for implementation approach
+- Use aggregated_insights.all_integration_points for precise modification locations
+- Use conflict_indicators for risk-aware task sequencing
 
-## Phase 2: TDD Document Generation Task
+## CONFLICT RESOLUTION CONTEXT (if exists)
+- Check context-package.conflict_detection.resolution_file for conflict-resolution.json path
+- If exists, load .process/conflict-resolution.json:
+  - Apply planning_constraints as task constraints (for brainstorm-less workflows)
+  - Reference resolved_conflicts for implementation approach alignment
+  - Handle custom_conflicts with explicit task notes
+
+## TEST CONTEXT INTEGRATION
+- Load test-context-package.json for existing test patterns and coverage analysis
+- Extract test framework configuration (Jest/Pytest/etc.)
+- Identify existing test conventions and patterns
+- Map coverage gaps to TDD Red phase test targets
+
+## TDD DOCUMENT GENERATION TASK
 
 **Agent Configuration Reference**: All TDD task generation rules, quantification requirements, Red-Green-Refactor cycle structure, quality standards, and execution details are defined in action-planning-agent.
 
@@ -256,31 +412,61 @@ If conflict_risk was medium/high, modifications have been applied to:
 #### Required Outputs Summary
 
 ##### 1. TDD Task JSON Files (.task/IMPL-*.json)
-- **Location**: `.workflow/active//{session-id}/.task/`
-- **Schema**: 5-field structure with TDD-specific metadata
+- **Location**: `.workflow/active/{session-id}/.task/`
+- **Schema**: 6-field structure with TDD-specific metadata
+  - `id, title, status, context_package_path, meta, context, flow_control`
   - `meta.tdd_workflow`: true (REQUIRED)
   - `meta.max_iterations`: 3 (Green phase test-fix cycle limit)
+  - `meta.cli_execution_id`: Unique CLI execution ID (format: `{session_id}-{task_id}`)
+  - `meta.cli_execution`: Strategy object (new|resume|fork|merge_fork)
   - `context.tdd_cycles`: Array with quantified test cases and coverage
+  - `context.focus_paths`: Absolute or clear relative paths (enhanced with exploration critical_files)
   - `flow_control.implementation_approach`: Exactly 3 steps with `tdd_phase` field
     1. Red Phase (`tdd_phase: "red"`): Write failing tests
     2. Green Phase (`tdd_phase: "green"`): Implement to pass tests
     3. Refactor Phase (`tdd_phase: "refactor"`): Improve code quality
-  - CLI tool usage determined semantically (add `command` field when user requests CLI execution)
+  - `flow_control.pre_analysis`: Include exploration integration_points analysis
+  - CLI tool usage based on userConfig (add `command` field per executionMethod)
 - **Details**: See action-planning-agent.md § TDD Task JSON Generation
 
 ##### 2. IMPL_PLAN.md (TDD Variant)
-- **Location**: `.workflow/active//{session-id}/IMPL_PLAN.md`
+- **Location**: `.workflow/active/{session-id}/IMPL_PLAN.md`
 - **Template**: `~/.claude/workflows/cli-templates/prompts/workflow/impl-plan-template.txt`
 - **TDD-Specific Frontmatter**: workflow_type="tdd", tdd_workflow=true, feature_count, task_breakdown
 - **TDD Implementation Tasks Section**: Feature-by-feature with internal Red-Green-Refactor cycles
+- **Context Analysis**: Artifact references and exploration insights
 - **Details**: See action-planning-agent.md § TDD Implementation Plan Creation
 
 ##### 3. TODO_LIST.md
-- **Location**: `.workflow/active//{session-id}/TODO_LIST.md`
+- **Location**: `.workflow/active/{session-id}/TODO_LIST.md`
 - **Format**: Hierarchical task list with internal TDD phase indicators (Red → Green → Refactor)
 - **Status**: ▸ (container), [ ] (pending), [x] (completed)
+- **Links**: Task JSON references and summaries
 - **Details**: See action-planning-agent.md § TODO List Generation
 
+### CLI EXECUTION ID REQUIREMENTS (MANDATORY)
+
+Each task JSON MUST include:
+- **meta.cli_execution_id**: Unique ID for CLI execution (format: `{session_id}-{task_id}`)
+- **meta.cli_execution**: Strategy object based on depends_on:
+  - No deps → `{ "strategy": "new" }`
+  - 1 dep (single child) → `{ "strategy": "resume", "resume_from": "parent-cli-id" }`
+  - 1 dep (multiple children) → `{ "strategy": "fork", "resume_from": "parent-cli-id" }`
+  - N deps → `{ "strategy": "merge_fork", "resume_from": ["id1", "id2", ...] }`
+  - **Type**: `resume_from: string | string[]` (string for resume/fork, array for merge_fork)
+
+**CLI Execution Strategy Rules**:
+1. **new**: Task has no dependencies - starts fresh CLI conversation
+2. **resume**: Task has 1 parent AND that parent has only this child - continues same conversation
+3. **fork**: Task has 1 parent BUT parent has multiple children - creates new branch with parent context
+4. **merge_fork**: Task has multiple parents - merges all parent contexts into new conversation
+
+**Execution Command Patterns**:
+- new: `ccw cli -p "[prompt]" --tool [tool] --mode write --id [cli_execution_id]`
+- resume: `ccw cli -p "[prompt]" --resume [resume_from] --tool [tool] --mode write`
+- fork: `ccw cli -p "[prompt]" --resume [resume_from] --id [cli_execution_id] --tool [tool] --mode write`
+- merge_fork: `ccw cli -p "[prompt]" --resume [resume_from.join(',')] --id [cli_execution_id] --tool [tool] --mode write` (resume_from is array)
+
 ### Quantification Requirements (MANDATORY)
 
 **Core Rules**:
@@ -302,6 +488,7 @@ If conflict_risk was medium/high, modifications have been applied to:
 - [ ] Every acceptance criterion includes measurable coverage percentage
 - [ ] tdd_cycles array contains test_count and test_cases for each cycle
 - [ ] No vague language ("comprehensive", "complete", "thorough")
+- [ ] cli_execution_id and cli_execution strategy assigned to each task
 
 ### Agent Execution Summary
 
@@ -317,20 +504,34 @@ If conflict_risk was medium/high, modifications have been applied to:
 - ✓ Quantification requirements enforced (explicit counts, measurable acceptance, exact targets)
 - ✓ Task count ≤18 (hard limit)
 - ✓ Each task has meta.tdd_workflow: true
-- ✓ Each task has exactly 3 implementation steps with tdd_phase field
-- ✓ Green phase includes test-fix cycle logic
-- ✓ Artifact references mapped correctly
-- ✓ MCP tool integration added
+- ✓ Each task has exactly 3 implementation steps with tdd_phase field ("red", "green", "refactor")
+- ✓ Each task has meta.cli_execution_id and meta.cli_execution strategy
+- ✓ Green phase includes test-fix cycle logic with max_iterations
+- ✓ focus_paths are absolute or clear relative paths (from exploration critical_files)
+- ✓ Artifact references mapped correctly from context package
+- ✓ Exploration context integrated (critical_files, constraints, patterns, integration_points)
+- ✓ Conflict resolution context applied (if conflict_risk >= medium)
+- ✓ Test context integrated (existing test patterns and coverage analysis)
 - ✓ Documents follow TDD template structure
+- ✓ CLI tool selection based on userConfig.executionMethod
 
-## Output
+## SUCCESS CRITERIA
+- All planning documents generated successfully:
+  - Task JSONs valid and saved to .task/ directory with cli_execution_id
+  - IMPL_PLAN.md created with complete TDD structure
+  - TODO_LIST.md generated matching task JSONs
+- CLI execution strategies assigned based on task dependencies
+- Return completion status with document count and task breakdown summary
 
-Generate all three documents and report completion status:
-- TDD task JSON files created: N files (IMPL-*.json)
+## OUTPUT SUMMARY
+Generate all three documents and report:
+- TDD task JSON files created: N files (IMPL-*.json) with cli_execution_id assigned
 - TDD cycles configured: N cycles with quantified test cases
-- Artifacts integrated: synthesis-spec, guidance-specification, N role analyses
+- CLI execution strategies: new/resume/fork/merge_fork assigned per dependency graph
+- Artifacts integrated: synthesis-spec/guidance-specification, relevant role analyses
+- Exploration context: critical_files, constraints, patterns, integration_points
 - Test context integrated: existing patterns and coverage
-- MCP enhancements: CodexLens, exa-research
+- Conflict resolution: applied (if conflict_risk >= medium)
 - Session ready for TDD execution: /workflow:execute
 `
 )
@@ -338,50 +539,64 @@ Generate all three documents and report completion status:
 
 ### Agent Context Passing
 
-**Memory-Aware Context Assembly**:
+**Context Delegation Model**: Command provides paths and metadata, agent loads context autonomously using progressive loading strategy.
+
+**Command Provides** (in agent prompt):
 ```javascript
-// Assemble context package for agent
-const agentContext = {
-  session_id: "WFS-[id]",
+// Command assembles these simple values and paths for agent
+const commandProvides = {
+  // Session paths
+  session_metadata_path: ".workflow/active/WFS-{id}/workflow-session.json",
+  context_package_path: ".workflow/active/WFS-{id}/.process/context-package.json",
+  test_context_package_path: ".workflow/active/WFS-{id}/.process/test-context-package.json",
+  output_task_dir: ".workflow/active/WFS-{id}/.task/",
+  output_impl_plan: ".workflow/active/WFS-{id}/IMPL_PLAN.md",
+  output_todo_list: ".workflow/active/WFS-{id}/TODO_LIST.md",
+
+  // Simple metadata
+  session_id: "WFS-{id}",
   workflow_type: "tdd",
+  mcp_capabilities: { exa_code: true, exa_web: true, code_index: true },
 
-  // Use memory if available, else load
-  session_metadata: memory.has("workflow-session.json")
-    ? memory.get("workflow-session.json")
-    : Read(.workflow/active/WFS-[id]/workflow-session.json),
-
-  context_package_path: ".workflow/active/WFS-[id]/.process/context-package.json",
-
-  context_package: memory.has("context-package.json")
-    ? memory.get("context-package.json")
-    : Read(".workflow/active/WFS-[id]/.process/context-package.json"),
-
-  test_context_package_path: ".workflow/active/WFS-[id]/.process/test-context-package.json",
-
-  test_context_package: memory.has("test-context-package.json")
-    ? memory.get("test-context-package.json")
-    : Read(".workflow/active/WFS-[id]/.process/test-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 (prefer new JSON format)
-  conflict_resolution: context_package.conflict_detection?.resolution_file
-    ? Read(context_package.conflict_detection.resolution_file)  // .process/conflict-resolution.json
-    : (brainstorm_artifacts?.conflict_resolution?.exists
-        ? Read(brainstorm_artifacts.conflict_resolution.path)
-        : null),
-
-  // Optional MCP enhancements
-  mcp_analysis: executeMcpDiscovery()
+  // User configuration from Phase 0
+  user_config: {
+    supplementaryMaterials: { type: "...", content: [...] },
+    executionMethod: "agent|hybrid|cli",
+    preferredCliTool: "codex|gemini|qwen|auto",
+    enableResume: true
+  }
 }
 ```
 
+**Agent Loads Autonomously** (progressive loading):
+```javascript
+// Agent executes progressive loading based on memory state
+const agentLoads = {
+  // Core (ALWAYS load if not in memory)
+  session_metadata: loadIfNotInMemory(session_metadata_path),
+  context_package: loadIfNotInMemory(context_package_path),
+
+  // Selective (based on progressive strategy)
+  // Priority: synthesis_output > guidance + relevant_role_analyses
+  brainstorm_content: loadSelectiveBrainstormArtifacts(context_package),
+
+  // On-Demand (load if exists and relevant)
+  test_context: loadIfExists(test_context_package_path),
+  conflict_resolution: loadConflictResolution(context_package),
+
+  // Optional (if MCP available)
+  exploration_results: extractExplorationResults(context_package),
+  external_research: executeMcpResearch()  // If needed
+}
+```
+
+**Progressive Loading Implementation** (agent responsibility):
+1. **Check memory first** - skip if already loaded
+2. **Load core files** - session metadata + context-package.json
+3. **Smart selective loading** - synthesis_output OR (guidance + task-relevant role analyses)
+4. **On-demand loading** - test context, conflict resolution (if conflict_risk >= medium)
+5. **Extract references** - exploration results, artifact paths from context package
+
 ## TDD Task Structure Reference
 
 This section provides quick reference for TDD task JSON structure. For complete implementation details, see the agent invocation prompt in Phase 2 above.
@@ -389,14 +604,31 @@ This section provides quick reference for TDD task JSON structure. For complete
 **Quick Reference**:
 - Each TDD task contains complete Red-Green-Refactor cycle
 - Task ID format: `IMPL-N` (simple) or `IMPL-N.M` (complex subtasks)
-- Required metadata: `meta.tdd_workflow: true`, `meta.max_iterations: 3`
-- Flow control: Exactly 3 steps with `tdd_phase` field (red, green, refactor)
-- Context: `tdd_cycles` array with quantified test cases and coverage
+- Required metadata:
+  - `meta.tdd_workflow: true`
+  - `meta.max_iterations: 3`
+  - `meta.cli_execution_id: "{session_id}-{task_id}"`
+  - `meta.cli_execution: { "strategy": "new|resume|fork|merge_fork", ... }`
+- Context: `tdd_cycles` array with quantified test cases and coverage:
+  ```javascript
+  tdd_cycles: [
+    {
+      test_count: 5,                    // Number of test cases to write
+      test_cases: ["case1", "case2"],   // Enumerated test scenarios
+      implementation_scope: "...",      // Files and functions to implement
+      expected_coverage: ">=85%"        // Coverage target
+    }
+  ]
+  ```
+- Context: `focus_paths` use absolute or clear relative paths
+- Flow control: Exactly 3 steps with `tdd_phase` field ("red", "green", "refactor")
+- Flow control: `pre_analysis` includes exploration integration_points analysis
+- Command field: Added per `userConfig.executionMethod` (agent/hybrid/cli)
 - See Phase 2 agent prompt for full schema and requirements
 
 ## Output Files Structure
 ```
-.workflow/active//{session-id}/
+.workflow/active/{session-id}/
 ├── IMPL_PLAN.md                     # Unified plan with TDD Implementation Tasks section
 ├── TODO_LIST.md                     # Progress tracking with internal TDD phase indicators
 ├── .task/
@@ -432,9 +664,9 @@ This section provides quick reference for TDD task JSON structure. For complete
 - No circular dependencies allowed
 
 ### Task Limits
-- Maximum 10 total tasks (simple + subtasks)
-- Flat hierarchy (≤5 tasks) or two-level (6-10 tasks with containers)
-- Re-scope requirements if >10 tasks needed
+- Maximum 18 total tasks (simple + subtasks) - hard limit for TDD workflows
+- Flat hierarchy (≤5 tasks) or two-level (6-18 tasks with containers)
+- Re-scope requirements if >18 tasks needed
 
 ### TDD Workflow Validation
 - `meta.tdd_workflow` must be true
@@ -454,7 +686,7 @@ This section provides quick reference for TDD task JSON structure. For complete
 ### TDD Generation Errors
 | Error | Cause | Resolution |
 |-------|-------|------------|
-| Task count exceeds 10 | Too many features or subtasks | Re-scope requirements or merge features |
+| Task count exceeds 18 | Too many features or subtasks | Re-scope requirements or merge features into multiple TDD sessions |
 | Missing test framework | No test config | Configure testing first |
 | Invalid TDD workflow | Missing tdd_phase or incomplete flow_control | Fix TDD structure in ANALYSIS_RESULTS.md |
 | Missing tdd_workflow flag | Task doesn't have meta.tdd_workflow: true | Add TDD workflow metadata |
@@ -512,6 +744,6 @@ IMPL (Green phase) tasks include automatic test-fix cycle:
 
 
 ## Configuration Options
-- **meta.max_iterations**: Number of fix attempts (default: 3 for TDD, 5 for test-gen)
+- **meta.max_iterations**: Number of fix attempts in Green phase (default: 3)
 - **CLI tool usage**: Determined semantically from user's task description via `command` field in implementation_approach
 

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

@@ -1,10 +1,14 @@
 ---
 name: animation-extract
 description: Extract animation and transition patterns from prompt inference and image references for design system documentation
-argument-hint: "[--design-id <id>] [--session <id>] [--images "<glob>"] [--focus "<types>"] [--interactive] [--refine]"
+argument-hint: "[-y|--yes] [--design-id <id>] [--session <id>] [--images "<glob>"] [--focus "<types>"] [--interactive] [--refine]"
 allowed-tools: TodoWrite(*), Read(*), Write(*), Glob(*), Bash(*), AskUserQuestion(*), Task(ui-design-agent)
 ---
 
+## Auto Mode
+
+When `--yes` or `-y`: Skip all clarification questions, use AI-inferred animation decisions.
+
 # Animation Extraction Command
 
 ## Overview

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

@@ -1,10 +1,14 @@
 ---
 name: layout-extract
 description: Extract structural layout information from reference images or text prompts using Claude analysis with variant generation or refinement mode
-argument-hint: [--design-id <id>] [--session <id>] [--images "<glob>"] [--prompt "<desc>"] [--targets "<list>"] [--variants <count>] [--device-type <desktop|mobile|tablet|responsive>] [--interactive] [--refine]
+argument-hint: "[-y|--yes] [--design-id <id>] [--session <id>] [--images "<glob>"] [--prompt "<desc>"] [--targets "<list>"] [--variants <count>] [--device-type <desktop|mobile|tablet|responsive>] [--interactive] [--refine]"
 allowed-tools: TodoWrite(*), Read(*), Write(*), Glob(*), Bash(*), AskUserQuestion(*), Task(ui-design-agent), mcp__exa__web_search_exa(*)
 ---
 
+## Auto Mode
+
+When `--yes` or `-y`: Skip all clarification questions, use AI-inferred layout decisions.
+
 # Layout Extraction Command
 
 ## Overview

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

@@ -1,10 +1,14 @@
 ---
 name: style-extract
 description: Extract design style from reference images or text prompts using Claude analysis with variant generation or refinement mode
-argument-hint: "[--design-id <id>] [--session <id>] [--images "<glob>"] [--prompt "<desc>"] [--variants <count>] [--interactive] [--refine]"
+argument-hint: "[-y|--yes] [--design-id <id>] [--session <id>] [--images "<glob>"] [--prompt "<desc>"] [--variants <count>] [--interactive] [--refine]"
 allowed-tools: TodoWrite(*), Read(*), Write(*), Glob(*), AskUserQuestion(*)
 ---
 
+## Auto Mode
+
+When `--yes` or `-y`: Skip all clarification questions, use AI-inferred design decisions.
+
 # Style Extraction Command
 
 ## Overview

.claude/commands/workflow/unified-execute-with-file.md

@@ -0,0 +1,807 @@
+---
+name: unified-execute-with-file
+description: Universal execution engine for consuming any planning/brainstorm/analysis output with minimal progress tracking, multi-agent coordination, and incremental execution
+argument-hint: "[-y|--yes] [-p|--plan <path>] [-m|--mode sequential|parallel] [\"execution context or task name\"]"
+allowed-tools: TodoWrite(*), Task(*), AskUserQuestion(*), Read(*), Grep(*), Glob(*), Bash(*), Edit(*), Write(*)
+---
+
+## Auto Mode
+
+When `--yes` or `-y`: Auto-confirm execution decisions, use default parallel strategy where possible.
+
+# Workflow Unified-Execute-With-File Command (/workflow:unified-execute-with-file)
+
+## Overview
+
+Universal execution engine that consumes **any** planning/brainstorm/analysis output and executes it with minimal progress tracking. Coordinates multiple agents (subagents or CLI tools), handles dependencies, and maintains execution timeline in a single minimal document.
+
+**Core workflow**: Load Plan → Parse Tasks → Coordinate Agents → Execute → Track Progress → Verify
+
+**Key features**:
+- **Plan Format Agnostic**: Consumes IMPL_PLAN.md, brainstorm.md, analysis conclusions, debug resolutions
+- **execution.md**: Single source of truth for progress, execution timeline, and results
+- **Multi-Agent Orchestration**: Parallel execution where possible, sequential where needed
+- **Incremental Execution**: Resume from failure point, no re-execution of completed tasks
+- **Dependency Management**: Automatic topological sort and wait strategy
+- **Real-Time Progress**: TodoWrite integration for live task status
+
+## Usage
+
+```bash
+/workflow:unified-execute-with-file [FLAGS] [EXECUTION_CONTEXT]
+
+# Flags
+-y, --yes              Auto-confirm execution decisions, use defaults
+-p, --plan <path>      Explicitly specify plan file (auto-detected if omitted)
+-m, --mode <mode>      Execution strategy: sequential (strict order) | parallel (smart dependencies)
+
+# Arguments
+[execution-context]    Optional: Task category, module name, or execution focus (for filtering/priority)
+
+# Examples
+/workflow:unified-execute-with-file                                    # Auto-detect and execute latest plan
+/workflow:unified-execute-with-file -p .workflow/plans/auth-plan.md   # Execute specific plan
+/workflow:unified-execute-with-file -y "auth module"                  # Auto-execute with context focus
+/workflow:unified-execute-with-file -m sequential "payment feature"   # Sequential execution
+```
+
+## Execution Process
+
+```
+Plan Detection:
+   ├─ Check for IMPL_PLAN.md or task JSON files in .workflow/
+   ├─ Or use explicit --plan path
+   ├─ Or auto-detect from git branch/issue context
+   └─ Load plan metadata and task definitions
+
+Session Initialization:
+   ├─ Create .workflow/.execution/{sessionId}/
+   ├─ Initialize execution.md with plan summary
+   ├─ Parse all tasks, identify dependencies
+   ├─ Determine execution strategy (parallel/sequential)
+   └─ Initialize progress tracking
+
+Pre-Execution Validation:
+   ├─ Check task feasibility (required files exist, tools available)
+   ├─ Validate dependency graph (detect cycles)
+   ├─ Ask user to confirm execution (unless --yes)
+   └─ Display execution plan and timeline estimate
+
+Task Execution Loop (Parallel/Sequential):
+   ├─ Select next executable tasks (dependencies satisfied)
+   ├─ Launch agents in parallel (if strategy=parallel)
+   ├─ Monitor execution, wait for completion
+   ├─ Capture outputs, log results
+   ├─ Update execution.md with progress
+   ├─ Mark tasks complete/failed
+   └─ Repeat until all done or max failures reached
+
+Error Handling:
+   ├─ Task failure → Ask user: retry|skip|abort
+   ├─ Dependency failure → Auto-skip dependent tasks
+   ├─ Output conflict → Ask for resolution
+   └─ Timeout → Mark as timeout, continue or escalate
+
+Completion:
+   ├─ Mark session complete
+   ├─ Summarize execution results in execution.md
+   ├─ Generate completion report (statistics, failures, recommendations)
+   └─ Offer follow-up: review|debug|enhance
+
+Output:
+   ├─ .workflow/.execution/{sessionId}/execution.md (plan and overall status)
+   ├─ .workflow/.execution/{sessionId}/execution-events.md (SINGLE SOURCE OF TRUTH - all task executions)
+   └─ Generated files in project directories (src/*, tests/*, docs/*, etc.)
+```
+
+## Implementation
+
+### Session Setup & Plan Detection
+
+```javascript
+const getUtc8ISOString = () => new Date(Date.now() + 8 * 60 * 60 * 1000).toISOString()
+
+// Plan detection strategy
+let planPath = $ARGUMENTS.match(/--plan\s+(\S+)/)?.[1]
+
+if (!planPath) {
+  // Auto-detect: check recent workflow artifacts
+  const candidates = [
+    '.workflow/.plan/IMPL_PLAN.md',
+    '.workflow/plans/IMPL_PLAN.md',
+    '.workflow/IMPL_PLAN.md',
+  ]
+
+  // Find most recent plan
+  planPath = findMostRecentPlan(candidates)
+
+  if (!planPath) {
+    // Check for task JSONs
+    const taskJsons = glob('.workflow/**/*.json').filter(f => f.includes('IMPL-') || f.includes('task'))
+    if (taskJsons.length > 0) {
+      planPath = taskJsons[0] // Primary task
+    }
+  }
+}
+
+if (!planPath) {
+  AskUserQuestion({
+    questions: [{
+      question: "未找到执行规划。请选择方式:",
+      header: "Plan Source",
+      multiSelect: false,
+      options: [
+        { label: "浏览文件", description: "从 .workflow 目录选择" },
+        { label: "使用最近规划", description: "从git提交消息推断" },
+        { label: "手动输入路径", description: "直接指定规划文件路径" }
+      ]
+    }]
+  })
+}
+
+// Parse plan and extract tasks
+const planContent = Read(planPath)
+const plan = parsePlan(planContent, planPath) // Format-agnostic parser
+
+const executionId = `EXEC-${plan.slug}-${getUtc8ISOString().substring(0, 10)}-${randomId(4)}`
+const executionFolder = `.workflow/.execution/${executionId}`
+const executionPath = `${executionFolder}/execution.md`
+const eventLogPath = `${executionFolder}/execution-events.md`
+
+bash(`mkdir -p ${executionFolder}`)
+```
+
+---
+
+## Plan Format Parsers
+
+Support multiple plan sources:
+
+```javascript
+function parsePlan(content, filePath) {
+  const ext = filePath.split('.').pop()
+
+  if (filePath.includes('IMPL_PLAN')) {
+    return parseImplPlan(content) // From /workflow:plan
+  } else if (filePath.includes('brainstorm')) {
+    return parseBrainstormPlan(content) // From /workflow:brainstorm-with-file
+  } else if (filePath.includes('synthesis')) {
+    return parseSynthesisPlan(content) // From /workflow:brainstorm-with-file synthesis.json
+  } else if (filePath.includes('conclusions')) {
+    return parseConclusionsPlan(content) // From /workflow:analyze-with-file conclusions.json
+  } else if (filePath.endsWith('.json') && content.includes('tasks')) {
+    return parseTaskJson(content) // Direct task JSON
+  }
+
+  throw new Error(`Unsupported plan format: ${filePath}`)
+}
+
+// IMPL_PLAN.md parser
+function parseImplPlan(content) {
+  // Extract:
+  // - Overview/summary
+  // - Phase sections
+  // - Task list with dependencies
+  // - Critical files
+  // - Execution order
+
+  return {
+    type: 'impl-plan',
+    title: extractSection(content, 'Overview'),
+    phases: extractPhases(content),
+    tasks: extractTasks(content),
+    criticalFiles: extractCriticalFiles(content),
+    estimatedDuration: extractEstimate(content)
+  }
+}
+
+// Brainstorm synthesis.json parser
+function parseSynthesisPlan(content) {
+  const synthesis = JSON.parse(content)
+
+  return {
+    type: 'brainstorm-synthesis',
+    title: synthesis.topic,
+    ideas: synthesis.top_ideas,
+    tasks: synthesis.top_ideas.map(idea => ({
+      id: `IDEA-${slugify(idea.title)}`,
+      type: 'investigation',
+      title: idea.title,
+      description: idea.description,
+      dependencies: [],
+      agent_type: 'cli-execution-agent',
+      prompt: `Implement: ${idea.title}\n${idea.description}`,
+      expected_output: idea.next_steps
+    })),
+    recommendations: synthesis.recommendations
+  }
+}
+```
+
+---
+
+### Phase 1: Plan Loading & Validation
+
+**Step 1.1: Parse Plan and Extract Tasks**
+
+```javascript
+const tasks = plan.tasks || parseTasksFromContent(plan)
+
+// Normalize task structure
+const normalizedTasks = tasks.map(task => ({
+  id: task.id || `TASK-${generateId()}`,
+  title: task.title || task.content,
+  description: task.description || task.activeForm,
+  type: task.type || inferTaskType(task), // 'code', 'test', 'doc', 'analysis', 'integration'
+  agent_type: task.agent_type || selectBestAgent(task),
+  dependencies: task.dependencies || [],
+
+  // Execution parameters
+  prompt: task.prompt || task.description,
+  files_to_modify: task.files_to_modify || [],
+  expected_output: task.expected_output || [],
+
+  // Metadata
+  priority: task.priority || 'normal',
+  parallel_safe: task.parallel_safe !== false,
+  estimated_duration: task.estimated_duration || null,
+
+  // Status tracking
+  status: 'pending',
+  attempts: 0,
+  max_retries: 2
+}))
+
+// Validate and detect issues
+const validation = {
+  cycles: detectDependencyCycles(normalizedTasks),
+  missing_dependencies: findMissingDependencies(normalizedTasks),
+  file_conflicts: detectOutputConflicts(normalizedTasks),
+  warnings: []
+}
+
+if (validation.cycles.length > 0) {
+  throw new Error(`Circular dependencies detected: ${validation.cycles.join(', ')}`)
+}
+```
+
+**Step 1.2: Create execution.md**
+
+```markdown
+# Execution Progress
+
+**Execution ID**: ${executionId}
+**Plan Source**: ${planPath}
+**Started**: ${getUtc8ISOString()}
+**Mode**: ${executionMode}
+
+**Plan Summary**:
+- Title: ${plan.title}
+- Total Tasks: ${tasks.length}
+- Phases: ${plan.phases?.length || 'N/A'}
+
+---
+
+## Execution Plan
+
+### Task Overview
+
+| Task ID | Title | Type | Agent | Dependencies | Status |
+|---------|-------|------|-------|--------------|--------|
+${normalizedTasks.map(t => `| ${t.id} | ${t.title} | ${t.type} | ${t.agent_type} | ${t.dependencies.join(',')} | ${t.status} |`).join('\n')}
+
+### Dependency Graph
+
+\`\`\`
+${generateDependencyGraph(normalizedTasks)}
+\`\`\`
+
+### Execution Strategy
+
+- **Mode**: ${executionMode}
+- **Parallelization**: ${calculateParallel(normalizedTasks)}
+- **Estimated Duration**: ${estimateTotalDuration(normalizedTasks)}
+
+---
+
+## Execution Timeline
+
+*Updates as execution progresses*
+
+---
+
+## Current Status
+
+${executionStatus()}
+```
+
+**Step 1.3: Pre-Execution Confirmation**
+
+```javascript
+const autoYes = $ARGUMENTS.includes('--yes') || $ARGUMENTS.includes('-y')
+
+if (!autoYes) {
+  AskUserQuestion({
+    questions: [{
+      question: `准备执行 ${normalizedTasks.length} 个任务，模式: ${executionMode}\n\n关键任务:\n${normalizedTasks.slice(0, 3).map(t => `• ${t.id}: ${t.title}`).join('\n')}\n\n继续?`,
+      header: "Confirmation",
+      multiSelect: false,
+      options: [
+        { label: "开始执行", description: "按计划执行" },
+        { label: "调整参数", description: "修改执行参数" },
+        { label: "查看详情", description: "查看完整任务列表" },
+        { label: "取消", description: "退出不执行" }
+      ]
+    }]
+  })
+}
+```
+
+---
+
+## Phase 2: Execution Orchestration
+
+**Step 2.1: Determine Execution Order**
+
+```javascript
+// Topological sort
+const executionOrder = topologicalSort(normalizedTasks)
+
+// For parallel mode, group tasks into waves
+let executionWaves = []
+if (executionMode === 'parallel') {
+  executionWaves = groupIntoWaves(executionOrder, parallelLimit = 3)
+} else {
+  executionWaves = executionOrder.map(task => [task])
+}
+
+// Log execution plan to execution.md
+// execution-events.md will track actual progress as tasks execute
+```
+
+**Step 2.2: Execute Task Waves**
+
+```javascript
+let completedCount = 0
+let failedCount = 0
+const results = {}
+
+for (let waveIndex = 0; waveIndex < executionWaves.length; waveIndex++) {
+  const wave = executionWaves[waveIndex]
+
+  console.log(`\n=== Wave ${waveIndex + 1}/${executionWaves.length} ===`)
+  console.log(`Tasks: ${wave.map(t => t.id).join(', ')}`)
+
+  // Launch tasks in parallel
+  const taskPromises = wave.map(task => executeTask(task, executionFolder))
+
+  // Wait for wave completion
+  const waveResults = await Promise.allSettled(taskPromises)
+
+  // Process results
+  for (let i = 0; i < waveResults.length; i++) {
+    const result = waveResults[i]
+    const task = wave[i]
+
+    if (result.status === 'fulfilled') {
+      results[task.id] = result.value
+      if (result.value.success) {
+        completedCount++
+        task.status = 'completed'
+        console.log(`✅ ${task.id}: Completed`)
+      } else if (result.value.retry) {
+        console.log(`⚠️ ${task.id}: Will retry`)
+        task.status = 'pending'
+      } else {
+        console.log(`❌ ${task.id}: Failed`)
+      }
+    } else {
+      console.log(`❌ ${task.id}: Execution error`)
+    }
+
+    // Progress is tracked in execution-events.md (appended by executeTask)
+  }
+
+  // Update execution.md summary
+  appendExecutionTimeline(executionPath, waveIndex + 1, wave, waveResults)
+}
+```
+
+**Step 2.3: Execute Individual Task with Unified Event Logging**
+
+```javascript
+async function executeTask(task, executionFolder) {
+  const eventLogPath = `${executionFolder}/execution-events.md`
+  const startTime = Date.now()
+
+  try {
+    // Read previous execution events for context
+    let previousEvents = ''
+    if (fs.existsSync(eventLogPath)) {
+      previousEvents = Read(eventLogPath)
+    }
+
+    // Select agent based on task type
+    const agent = selectAgent(task.agent_type)
+
+    // Build execution context including previous agent outputs
+    const executionContext = `
+## Previous Agent Executions (for reference)
+
+${previousEvents}
+
+---
+
+## Current Task: ${task.id}
+
+**Title**: ${task.title}
+**Agent**: ${agent}
+**Time**: ${getUtc8ISOString()}
+
+### Description
+${task.description}
+
+### Context
+- Modified Files: ${task.files_to_modify.join(', ')}
+- Expected Output: ${task.expected_output.join(', ')}
+- Previous Artifacts: [list any artifacts from previous tasks]
+
+### Requirements
+${task.requirements || 'Follow the plan'}
+
+### Constraints
+${task.constraints || 'No breaking changes'}
+`
+
+    // Execute based on agent type
+    let result
+
+    if (agent === 'code-developer' || agent === 'tdd-developer') {
+      // Code implementation
+      result = await Task({
+        subagent_type: agent,
+        description: `Execute: ${task.title}`,
+        prompt: executionContext,
+        run_in_background: false
+      })
+    } else if (agent === 'cli-execution-agent' || agent === 'universal-executor') {
+      // CLI-based execution
+      result = await Bash({
+        command: `ccw cli -p "${escapeQuotes(executionContext)}" --tool gemini --mode analysis`,
+        run_in_background: false
+      })
+    } else if (agent === 'test-fix-agent') {
+      // Test execution and fixing
+      result = await Task({
+        subagent_type: 'test-fix-agent',
+        description: `Execute Tests: ${task.title}`,
+        prompt: executionContext,
+        run_in_background: false
+      })
+    } else {
+      // Generic task execution
+      result = await Task({
+        subagent_type: 'universal-executor',
+        description: task.title,
+        prompt: executionContext,
+        run_in_background: false
+      })
+    }
+
+    // Capture artifacts (code, tests, docs generated by this task)
+    const artifacts = captureArtifacts(task, executionFolder)
+
+    // Append to unified execution events log
+    const eventEntry = `
+## Task ${task.id} - COMPLETED ✅
+
+**Timestamp**: ${getUtc8ISOString()}
+**Duration**: ${calculateDuration(startTime)}ms
+**Agent**: ${agent}
+
+### Execution Summary
+
+${generateSummary(result)}
+
+### Key Outputs
+
+${formatOutputs(result)}
+
+### Generated Artifacts
+
+${artifacts.map(a => `- **${a.type}**: \`${a.path}\` (${a.size})`).join('\n')}
+
+### Notes for Next Agent
+
+${generateNotesForNextAgent(result, task)}
+
+---
+`
+
+    appendToEventLog(eventLogPath, eventEntry)
+
+    return {
+      success: true,
+      task_id: task.id,
+      output: result,
+      artifacts: artifacts,
+      duration: calculateDuration(startTime)
+    }
+  } catch (error) {
+    // Append failure event to unified log
+    const failureEntry = `
+## Task ${task.id} - FAILED ❌
+
+**Timestamp**: ${getUtc8ISOString()}
+**Duration**: ${calculateDuration(startTime)}ms
+**Agent**: ${agent}
+**Error**: ${error.message}
+
+### Error Details
+
+\`\`\`
+${error.stack}
+\`\`\`
+
+### Recovery Notes for Next Attempt
+
+${generateRecoveryNotes(error, task)}
+
+---
+`
+
+    appendToEventLog(eventLogPath, failureEntry)
+
+    // Handle failure: retry, skip, or abort
+    task.attempts++
+    if (task.attempts < task.max_retries && autoYes) {
+      console.log(`⚠️ ${task.id}: Failed, retrying (${task.attempts}/${task.max_retries})`)
+      return { success: false, task_id: task.id, error: error.message, retry: true, duration: calculateDuration(startTime) }
+    } else if (task.attempts >= task.max_retries && !autoYes) {
+      const decision = AskUserQuestion({
+        questions: [{
+          question: `任务失败: ${task.id}\n错误: ${error.message}`,
+          header: "Decision",
+          multiSelect: false,
+          options: [
+            { label: "重试", description: "重新执行该任务" },
+            { label: "跳过", description: "跳过此任务，继续下一个" },
+            { label: "终止", description: "停止整个执行" }
+          ]
+        }]
+      })
+      if (decision === 'retry') {
+        task.attempts = 0
+        return { success: false, task_id: task.id, error: error.message, retry: true, duration: calculateDuration(startTime) }
+      } else if (decision === 'skip') {
+        task.status = 'skipped'
+        skipDependentTasks(task.id, normalizedTasks)
+      } else {
+        throw new Error('Execution aborted by user')
+      }
+    } else {
+      task.status = 'failed'
+      skipDependentTasks(task.id, normalizedTasks)
+    }
+
+    return {
+      success: false,
+      task_id: task.id,
+      error: error.message,
+      duration: calculateDuration(startTime)
+    }
+  }
+}
+
+// Helper function to append to unified event log
+function appendToEventLog(logPath, eventEntry) {
+  if (fs.existsSync(logPath)) {
+    const currentContent = Read(logPath)
+    Write(logPath, currentContent + eventEntry)
+  } else {
+    Write(logPath, eventEntry)
+  }
+}
+```
+
+---
+
+## Phase 3: Progress Tracking & Event Logging
+
+The `execution-events.md` file is the **single source of truth** for all agent executions:
+- Each agent **reads** previous execution events for context
+- **Executes** its task (with full knowledge of what was done before)
+- **Writes** its execution event (success or failure) in markdown format
+- Next agent **reads** all previous events, creating a "knowledge chain"
+
+**Event log format** (appended entry):
+```markdown
+## Task {id} - {STATUS} {emoji}
+
+**Timestamp**: {time}
+**Duration**: {ms}
+**Agent**: {type}
+
+### Execution Summary
+{What was done}
+
+### Generated Artifacts
+- `src/types/auth.ts` (2.3KB)
+
+### Notes for Next Agent
+- Key decisions made
+- Potential issues
+- Ready for: TASK-003
+```
+
+---
+
+## Phase 4: Completion & Summary
+
+After all tasks complete or max failures reached:
+
+1. **Collect results**: Count completed/failed/skipped tasks
+2. **Update execution.md**: Add "Execution Completed" section with statistics
+3. **execution-events.md**: Already contains all detailed execution records
+
+```javascript
+const statistics = {
+  total_tasks: normalizedTasks.length,
+  completed: normalizedTasks.filter(t => t.status === 'completed').length,
+  failed: normalizedTasks.filter(t => t.status === 'failed').length,
+  skipped: normalizedTasks.filter(t => t.status === 'skipped').length,
+  success_rate: (completedCount / normalizedTasks.length * 100).toFixed(1)
+}
+
+// Update execution.md with final status
+appendExecutionSummary(executionPath, statistics)
+```
+
+**Post-Completion Options** (unless --yes):
+
+```javascript
+AskUserQuestion({
+  questions: [{
+    question: "执行完成。是否需要后续操作?",
+    header: "Next Steps",
+    multiSelect: true,
+    options: [
+      { label: "查看详情", description: "查看完整执行日志" },
+      { label: "调试失败项", description: "对失败任务进行调试" },
+      { label: "优化执行", description: "分析执行改进建议" },
+      { label: "完成", description: "不需要后续操作" }
+    ]
+  }]
+})
+```
+
+---
+
+## Session Folder Structure
+
+```
+.workflow/.execution/{sessionId}/
+├── execution.md              # Execution plan and overall status
+└── execution-events.md       # 📋 Unified execution log (all agents) - SINGLE SOURCE OF TRUTH
+                               # This is both human-readable AND machine-parseable
+
+# Generated files go directly to project directories (not into execution folder)
+# E.g. TASK-001 generates: src/types/auth.ts (not artifacts/src/types/auth.ts)
+# execution-events.md records the actual project paths
+```
+
+**Key Concept**:
+- **execution-events.md** is the **single source of truth** for execution state
+- Human-readable: Clear markdown format with task summaries
+- Machine-parseable: Status indicators (✅/❌/⏳) and structured sections
+- Progress tracking: Read task count by parsing status indicators
+- No redundancy: One unified log for all purposes
+
+---
+
+## Agent Selection Strategy
+
+```javascript
+function selectBestAgent(task) {
+  if (task.type === 'code' || task.type === 'implementation') {
+    return task.includes_tests ? 'tdd-developer' : 'code-developer'
+  } else if (task.type === 'test' || task.type === 'test-fix') {
+    return 'test-fix-agent'
+  } else if (task.type === 'doc' || task.type === 'documentation') {
+    return 'doc-generator'
+  } else if (task.type === 'analysis' || task.type === 'investigation') {
+    return 'cli-execution-agent'
+  } else if (task.type === 'debug') {
+    return 'debug-explore-agent'
+  } else {
+    return 'universal-executor'
+  }
+}
+```
+
+## Parallelization Rules
+
+```javascript
+function calculateParallel(tasks) {
+  // Group tasks into execution waves
+  // Constraints:
+  // - Tasks with same file modifications must be sequential
+  // - Tasks with dependencies must wait
+  // - Max 3 parallel tasks per wave (resource constraint)
+
+  const waves = []
+  const completed = new Set()
+
+  while (completed.size < tasks.length) {
+    const available = tasks.filter(t =>
+      !completed.has(t.id) &&
+      t.dependencies.every(d => completed.has(d))
+    )
+
+    if (available.length === 0) break
+
+    // Check for file conflicts
+    const noConflict = []
+    const modifiedFiles = new Set()
+
+    for (const task of available) {
+      const conflicts = task.files_to_modify.some(f => modifiedFiles.has(f))
+      if (!conflicts && noConflict.length < 3) {
+        noConflict.push(task)
+        task.files_to_modify.forEach(f => modifiedFiles.add(f))
+      } else if (!conflicts && noConflict.length < 3) {
+        waves.push([task])
+        completed.add(task.id)
+      }
+    }
+
+    if (noConflict.length > 0) {
+      waves.push(noConflict)
+      noConflict.forEach(t => completed.add(t.id))
+    }
+  }
+
+  return waves
+}
+```
+
+## Error Handling & Recovery
+
+| Situation | Action |
+|-----------|--------|
+| Task timeout | Mark as timeout, ask user: retry/skip/abort |
+| Missing dependency | Auto-skip dependent tasks, log warning |
+| File conflict | Detect before execution, ask for resolution |
+| Output mismatch | Validate against expected_output, flag for review |
+| Agent unavailable | Fallback to universal-executor |
+| Execution interrupted | Support resume with `/workflow:unified-execute-with-file --continue` |
+
+## Usage Recommendations
+
+Use `/workflow:unified-execute-with-file` when:
+- Executing any planning document (IMPL_PLAN.md, brainstorm conclusions, analysis recommendations)
+- Multiple tasks with dependencies need orchestration
+- Want minimal progress tracking without clutter
+- Need to handle failures gracefully and resume
+- Want to parallelize where possible but ensure correctness
+
+Use for consuming output from:
+- `/workflow:plan` → IMPL_PLAN.md
+- `/workflow:brainstorm-with-file` → synthesis.json → execution
+- `/workflow:analyze-with-file` → conclusions.json → execution
+- `/workflow:debug-with-file` → recommendations → execution
+- `/workflow:lite-plan` → task JSONs → execution
+
+## Session Resume
+
+```bash
+/workflow:unified-execute-with-file --continue     # Resume last execution
+/workflow:unified-execute-with-file --continue EXEC-xxx-2025-01-27-abcd  # Resume specific
+```
+
+When resuming:
+1. Load execution.md and execution-events.md
+2. Parse execution-events.md to identify completed/failed/skipped tasks
+3. Recalculate remaining dependencies
+4. Resume from first incomplete task
+5. Append to execution-events.md with "Resumed from [sessionId]" note

.claude/skills/ccw-help/SKILL.md

@@ -11,8 +11,8 @@ CCW 命令帮助系统，提供命令搜索、推荐、文档查看功能。
 
 ## Trigger Conditions
 
-- 关键词: "ccw-help", "ccw-issue", "帮助", "命令", "怎么用"
-- 场景: 询问命令用法、搜索命令、请求下一步建议
+- 关键词: "ccw-help", "ccw-issue", "帮助", "命令", "怎么用", "ccw 怎么用", "工作流"
+- 场景: 询问命令用法、搜索命令、请求下一步建议、询问任务应该用哪个工作流
 
 ## Operation Modes
 
@@ -50,7 +50,35 @@ CCW 命令帮助系统，提供命令搜索、推荐、文档查看功能。
 1. Query `essential_commands` array
 2. Guide appropriate workflow entry point
 
-### Mode 5: Issue Reporting
+### Mode 5: CCW Command Orchestration
+
+**Triggers**: "ccw ", "自动工作流", "自动选择工作流", "帮我规划"
+
+**Process**:
+1. Analyze user intent (task type, complexity, clarity)
+2. Auto-select workflow level (1-4 or Issue)
+3. Build command chain based on workflow
+4. Get user confirmation
+5. Execute chain with TODO tracking
+
+**Supported Workflows**:
+- **Level 1** (Lite-Lite-Lite): Ultra-simple quick tasks
+- **Level 2** (Rapid/Hotfix): Bug fixes, simple features, documentation
+- **Level 2.5** (Rapid-to-Issue): Bridge from quick planning to issue workflow
+- **Level 3** (Coupled): Complex features with planning, execution, review, tests
+- **Level 3 Variants**:
+  - TDD workflows (test-first development)
+  - Test-fix workflows (debug failing tests)
+  - Review workflows (code review and fixes)
+  - UI design workflows
+- **Level 4** (Full): Exploratory tasks with brainstorming
+- **With-File Workflows**: Documented exploration with multi-CLI collaboration
+  - `brainstorm-with-file`: Multi-perspective ideation
+  - `debug-with-file`: Hypothesis-driven debugging
+  - `analyze-with-file`: Collaborative analysis
+- **Issue Workflow**: Batch issue discovery, planning, queueing, execution
+
+### Mode 6: Issue Reporting
 
 **Triggers**: "ccw-issue", "报告 bug"
 
@@ -84,28 +112,60 @@ Single source of truth: **[command.json](command.json)**
 ## Slash Commands
 
 ```bash
-/ccw-help                    # 通用帮助入口
-/ccw-help search <keyword>   # 搜索命令
-/ccw-help next <command>     # 获取下一步建议
-/ccw-issue                   # 问题报告
+/ccw "task description"          # Auto-select workflow and execute
+/ccw-help                        # General help entry
+/ccw-help search <keyword>       # Search commands
+/ccw-help next <command>         # Get next step suggestions
+/ccw-issue                       # Issue reporting
+```
+
+### CCW Command Examples
+
+```bash
+/ccw "Add user authentication"          # → auto-select level 2-3
+/ccw "Fix memory leak in WebSocket"     # → auto-select bugfix workflow
+/ccw "Implement with TDD"               # → detect TDD, use tdd-plan → execute → tdd-verify
+/ccw "头脑风暴: 用户通知系统"          # → detect brainstorm, use brainstorm-with-file
+/ccw "深度调试: 系统随机崩溃"          # → detect debug-file, use debug-with-file
+/ccw "协作分析: 认证架构设计"          # → detect analyze-file, use analyze-with-file
 ```
 
 ## Maintenance
 
-### Update Index
+### Update Mechanism
+
+CCW-Help skill supports manual updates through user confirmation dialog.
+
+#### How to Update
+
+**Option 1: When executing the skill, user will be prompted:**
+
+```
+Would you like to update CCW-Help command index?
+- Yes: Run auto-update and regenerate command.json
+- No: Use current index
+```
+
+**Option 2: Manual update**
 
 ```bash
 cd D:/Claude_dms3/.claude/skills/ccw-help
-python scripts/analyze_commands.py
+python scripts/auto-update.py
 ```
 
-脚本功能：扫描 commands/ 和 agents/ 目录，生成统一的 command.json
+This runs `analyze_commands.py` to scan commands/ and agents/ directories and regenerate `command.json`.
+
+#### Update Scripts
+
+- **`auto-update.py`**: Simple wrapper that runs analyze_commands.py
+- **`analyze_commands.py`**: Scans directories and generates command index
 
 ## Statistics
 
-- **Commands**: 88+
+- **Commands**: 50+
 - **Agents**: 16
-- **Essential**: 10 核心命令
+- **Workflows**: 6 main levels + 3 with-file variants
+- **Essential**: 10 core commands
 
 ## Core Principle
 

.claude/skills/ccw-help/index/all-agents.json

@@ -0,0 +1,97 @@
+[
+  {
+    "name": "action-planning-agent",
+    "description": "|",
+    "source": "../../../agents/action-planning-agent.md"
+  },
+  {
+    "name": "cli-discuss-agent",
+    "description": "|",
+    "source": "../../../agents/cli-discuss-agent.md"
+  },
+  {
+    "name": "cli-execution-agent",
+    "description": "|",
+    "source": "../../../agents/cli-execution-agent.md"
+  },
+  {
+    "name": "cli-explore-agent",
+    "description": "|",
+    "source": "../../../agents/cli-explore-agent.md"
+  },
+  {
+    "name": "cli-lite-planning-agent",
+    "description": "|",
+    "source": "../../../agents/cli-lite-planning-agent.md"
+  },
+  {
+    "name": "cli-planning-agent",
+    "description": "|",
+    "source": "../../../agents/cli-planning-agent.md"
+  },
+  {
+    "name": "code-developer",
+    "description": "|",
+    "source": "../../../agents/code-developer.md"
+  },
+  {
+    "name": "conceptual-planning-agent",
+    "description": "|",
+    "source": "../../../agents/conceptual-planning-agent.md"
+  },
+  {
+    "name": "context-search-agent",
+    "description": "|",
+    "source": "../../../agents/context-search-agent.md"
+  },
+  {
+    "name": "debug-explore-agent",
+    "description": "|",
+    "source": "../../../agents/debug-explore-agent.md"
+  },
+  {
+    "name": "doc-generator",
+    "description": "|",
+    "source": "../../../agents/doc-generator.md"
+  },
+  {
+    "name": "issue-plan-agent",
+    "description": "|",
+    "source": "../../../agents/issue-plan-agent.md"
+  },
+  {
+    "name": "issue-queue-agent",
+    "description": "|",
+    "source": "../../../agents/issue-queue-agent.md"
+  },
+  {
+    "name": "memory-bridge",
+    "description": "Execute complex project documentation updates using script coordination",
+    "source": "../../../agents/memory-bridge.md"
+  },
+  {
+    "name": "tdd-developer",
+    "description": "|",
+    "source": "../../../agents/tdd-developer.md"
+  },
+  {
+    "name": "test-context-search-agent",
+    "description": "|",
+    "source": "../../../agents/test-context-search-agent.md"
+  },
+  {
+    "name": "test-fix-agent",
+    "description": "|",
+    "source": "../../../agents/test-fix-agent.md"
+  },
+  {
+    "name": "ui-design-agent",
+    "description": "|",
+    "source": "../../../agents/ui-design-agent.md"
+  },
+  {
+    "name": "universal-executor",
+    "description": "|",
+    "source": "../../../agents/universal-executor.md"
+  }
+]

.claude/skills/ccw-help/index/all-commands.json

@@ -0,0 +1,805 @@
+[
+  {
+    "name": "ccw-coordinator",
+    "command": "/ccw-coordinator",
+    "description": "Command orchestration tool - analyze requirements, recommend chain, execute sequentially with state persistence",
+    "arguments": "[task description]",
+    "category": "general",
+    "subcategory": null,
+    "usage_scenario": "general",
+    "difficulty": "Intermediate",
+    "source": "../../../commands/ccw-coordinator.md"
+  },
+  {
+    "name": "ccw-debug",
+    "command": "/ccw-debug",
+    "description": "Aggregated debug command - combines debugging diagnostics and test verification in a synergistic workflow supporting cli-quick / debug-first / test-first / bidirectional-verification modes",
+    "arguments": "[--mode cli|debug|test|bidirectional] [--yes|-y] [--hotfix] \\\"bug description or error message\\",
+    "category": "general",
+    "subcategory": null,
+    "usage_scenario": "general",
+    "difficulty": "Intermediate",
+    "source": "../../../commands/ccw-debug.md"
+  },
+  {
+    "name": "ccw",
+    "command": "/ccw",
+    "description": "Main workflow orchestrator - analyze intent, select workflow, execute command chain in main process",
+    "arguments": "\\\"task description\\",
+    "category": "general",
+    "subcategory": null,
+    "usage_scenario": "general",
+    "difficulty": "Intermediate",
+    "source": "../../../commands/ccw.md"
+  },
+  {
+    "name": "cli-init",
+    "command": "/cli:cli-init",
+    "description": "Generate .gemini/ and .qwen/ config directories with settings.json and ignore files based on workspace technology detection",
+    "arguments": "[--tool gemini|qwen|all] [--output path] [--preview]",
+    "category": "cli",
+    "subcategory": null,
+    "usage_scenario": "general",
+    "difficulty": "Intermediate",
+    "source": "../../../commands/cli/cli-init.md"
+  },
+  {
+    "name": "codex-review",
+    "command": "/cli:codex-review",
+    "description": "Interactive code review using Codex CLI via ccw endpoint with configurable review target, model, and custom instructions",
+    "arguments": "[--uncommitted|--base <branch>|--commit <sha>] [--model <model>] [--title <title>] [prompt]",
+    "category": "cli",
+    "subcategory": null,
+    "usage_scenario": "analysis",
+    "difficulty": "Intermediate",
+    "source": "../../../commands/cli/codex-review.md"
+  },
+  {
+    "name": "convert-to-plan",
+    "command": "/issue:convert-to-plan",
+    "description": "Convert planning artifacts (lite-plan, workflow session, markdown) to issue solutions",
+    "arguments": "[-y|--yes] [--issue <id>] [--supplement] <SOURCE>",
+    "category": "issue",
+    "subcategory": null,
+    "usage_scenario": "planning",
+    "difficulty": "Intermediate",
+    "source": "../../../commands/issue/convert-to-plan.md"
+  },
+  {
+    "name": "issue:discover-by-prompt",
+    "command": "/issue:discover-by-prompt",
+    "description": "Discover issues from user prompt with Gemini-planned iterative multi-agent exploration. Uses ACE semantic search for context gathering and supports cross-module comparison (e.g., frontend vs backend API contracts).",
+    "arguments": "[-y|--yes] <prompt> [--scope=src/**] [--depth=standard|deep] [--max-iterations=5]",
+    "category": "issue",
+    "subcategory": null,
+    "usage_scenario": "general",
+    "difficulty": "Intermediate",
+    "source": "../../../commands/issue/discover-by-prompt.md"
+  },
+  {
+    "name": "issue:discover",
+    "command": "/issue:discover",
+    "description": "Discover potential issues from multiple perspectives (bug, UX, test, quality, security, performance, maintainability, best-practices) using CLI explore. Supports Exa external research for security and best-practices perspectives.",
+    "arguments": "[-y|--yes] <path-pattern> [--perspectives=bug,ux,...] [--external]",
+    "category": "issue",
+    "subcategory": null,
+    "usage_scenario": "general",
+    "difficulty": "Intermediate",
+    "source": "../../../commands/issue/discover.md"
+  },
+  {
+    "name": "execute",
+    "command": "/issue:execute",
+    "description": "Execute queue with DAG-based parallel orchestration (one commit per solution)",
+    "arguments": "[-y|--yes] --queue <queue-id> [--worktree [<existing-path>]]",
+    "category": "issue",
+    "subcategory": null,
+    "usage_scenario": "implementation",
+    "difficulty": "Intermediate",
+    "source": "../../../commands/issue/execute.md"
+  },
+  {
+    "name": "from-brainstorm",
+    "command": "/issue:from-brainstorm",
+    "description": "Convert brainstorm session ideas into issue with executable solution for parallel-dev-cycle",
+    "arguments": "SESSION=\\\"<session-id>\\\" [--idea=<index>] [--auto] [-y|--yes]",
+    "category": "issue",
+    "subcategory": null,
+    "usage_scenario": "planning",
+    "difficulty": "Intermediate",
+    "source": "../../../commands/issue/from-brainstorm.md"
+  },
+  {
+    "name": "new",
+    "command": "/issue:new",
+    "description": "Create structured issue from GitHub URL or text description",
+    "arguments": "[-y|--yes] <github-url | text-description> [--priority 1-5]",
+    "category": "issue",
+    "subcategory": null,
+    "usage_scenario": "general",
+    "difficulty": "Intermediate",
+    "source": "../../../commands/issue/new.md"
+  },
+  {
+    "name": "plan",
+    "command": "/issue:plan",
+    "description": "Batch plan issue resolution using issue-plan-agent (explore + plan closed-loop)",
+    "arguments": "[-y|--yes] --all-pending <issue-id>[,<issue-id>,...] [--batch-size 3]",
+    "category": "issue",
+    "subcategory": null,
+    "usage_scenario": "planning",
+    "difficulty": "Intermediate",
+    "source": "../../../commands/issue/plan.md"
+  },
+  {
+    "name": "queue",
+    "command": "/issue:queue",
+    "description": "Form execution queue from bound solutions using issue-queue-agent (solution-level)",
+    "arguments": "[-y|--yes] [--queues <n>] [--issue <id>]",
+    "category": "issue",
+    "subcategory": null,
+    "usage_scenario": "general",
+    "difficulty": "Intermediate",
+    "source": "../../../commands/issue/queue.md"
+  },
+  {
+    "name": "compact",
+    "command": "/memory:compact",
+    "description": "Compact current session memory into structured text for session recovery, extracting objective/plan/files/decisions/constraints/state, and save via MCP core_memory tool",
+    "arguments": "[optional: session description]",
+    "category": "memory",
+    "subcategory": null,
+    "usage_scenario": "general",
+    "difficulty": "Intermediate",
+    "source": "../../../commands/memory/compact.md"
+  },
+  {
+    "name": "docs-full-cli",
+    "command": "/memory:docs-full-cli",
+    "description": "Generate full project documentation using CLI execution (Layer 3→1) with batched agents (4 modules/agent) and gemini→qwen→codex fallback, <20 modules uses direct parallel",
+    "arguments": "[path] [--tool <gemini|qwen|codex>]",
+    "category": "memory",
+    "subcategory": null,
+    "usage_scenario": "documentation",
+    "difficulty": "Intermediate",
+    "source": "../../../commands/memory/docs-full-cli.md"
+  },
+  {
+    "name": "docs-related-cli",
+    "command": "/memory:docs-related-cli",
+    "description": "Generate/update documentation for git-changed modules using CLI execution with batched agents (4 modules/agent) and gemini→qwen→codex fallback, <15 modules uses direct parallel",
+    "arguments": "[--tool <gemini|qwen|codex>]",
+    "category": "memory",
+    "subcategory": null,
+    "usage_scenario": "documentation",
+    "difficulty": "Intermediate",
+    "source": "../../../commands/memory/docs-related-cli.md"
+  },
+  {
+    "name": "load",
+    "command": "/memory:load",
+    "description": "Delegate to universal-executor agent to analyze project via Gemini/Qwen CLI and return JSON core content package for task context",
+    "arguments": "[--tool gemini|qwen] \\\"task context description\\",
+    "category": "memory",
+    "subcategory": null,
+    "usage_scenario": "general",
+    "difficulty": "Intermediate",
+    "source": "../../../commands/memory/load.md"
+  },
+  {
+    "name": "style-skill-memory",
+    "command": "/memory:style-skill-memory",
+    "description": "Generate SKILL memory package from style reference for easy loading and consistent design system usage",
+    "arguments": "[package-name] [--regenerate]",
+    "category": "memory",
+    "subcategory": null,
+    "usage_scenario": "documentation",
+    "difficulty": "Intermediate",
+    "source": "../../../commands/memory/style-skill-memory.md"
+  },
+  {
+    "name": "tips",
+    "command": "/memory:tips",
+    "description": "Quick note-taking command to capture ideas, snippets, reminders, and insights for later reference",
+    "arguments": "<note content> [--tag <tag1,tag2>] [--context <context>]",
+    "category": "memory",
+    "subcategory": null,
+    "usage_scenario": "general",
+    "difficulty": "Intermediate",
+    "source": "../../../commands/memory/tips.md"
+  },
+  {
+    "name": "update-full",
+    "command": "/memory:update-full",
+    "description": "Update all CLAUDE.md files using layer-based execution (Layer 3→1) with batched agents (4 modules/agent) and gemini→qwen→codex fallback, <20 modules uses direct parallel",
+    "arguments": "[--tool gemini|qwen|codex] [--path <directory>]",
+    "category": "memory",
+    "subcategory": null,
+    "usage_scenario": "general",
+    "difficulty": "Intermediate",
+    "source": "../../../commands/memory/update-full.md"
+  },
+  {
+    "name": "update-related",
+    "command": "/memory:update-related",
+    "description": "Update CLAUDE.md for git-changed modules using batched agent execution (4 modules/agent) with gemini→qwen→codex fallback, <15 modules uses direct execution",
+    "arguments": "[--tool gemini|qwen|codex]",
+    "category": "memory",
+    "subcategory": null,
+    "usage_scenario": "general",
+    "difficulty": "Intermediate",
+    "source": "../../../commands/memory/update-related.md"
+  },
+  {
+    "name": "ccw view",
+    "command": "/ccw view",
+    "description": "Dashboard - Open CCW workflow dashboard for managing tasks and sessions",
+    "arguments": "",
+    "category": "general",
+    "subcategory": null,
+    "usage_scenario": "general",
+    "difficulty": "Intermediate",
+    "source": "../../../commands/view.md"
+  },
+  {
+    "name": "analyze-with-file",
+    "command": "/workflow:analyze-with-file",
+    "description": "Interactive collaborative analysis with documented discussions, CLI-assisted exploration, and evolving understanding",
+    "arguments": "[-y|--yes] [-c|--continue] \\\"topic or question\\",
+    "category": "workflow",
+    "subcategory": null,
+    "usage_scenario": "analysis",
+    "difficulty": "Beginner",
+    "source": "../../../commands/workflow/analyze-with-file.md"
+  },
+  {
+    "name": "artifacts",
+    "command": "/workflow:brainstorm:artifacts",
+    "description": "Interactive clarification generating confirmed guidance specification through role-based analysis and synthesis",
+    "arguments": "[-y|--yes] topic or challenge description [--count N]",
+    "category": "workflow",
+    "subcategory": "brainstorm",
+    "usage_scenario": "general",
+    "difficulty": "Intermediate",
+    "source": "../../../commands/workflow/brainstorm/artifacts.md"
+  },
+  {
+    "name": "auto-parallel",
+    "command": "/workflow:brainstorm:auto-parallel",
+    "description": "Parallel brainstorming automation with dynamic role selection and concurrent execution across multiple perspectives",
+    "arguments": "[-y|--yes] topic or challenge description [--count N]",
+    "category": "workflow",
+    "subcategory": "brainstorm",
+    "usage_scenario": "general",
+    "difficulty": "Advanced",
+    "source": "../../../commands/workflow/brainstorm/auto-parallel.md"
+  },
+  {
+    "name": "role-analysis",
+    "command": "/workflow:brainstorm:role-analysis",
+    "description": "Unified role-specific analysis generation with interactive context gathering and incremental updates",
+    "arguments": "[role-name] [--session session-id] [--update] [--include-questions] [--skip-questions]",
+    "category": "workflow",
+    "subcategory": "brainstorm",
+    "usage_scenario": "general",
+    "difficulty": "Intermediate",
+    "source": "../../../commands/workflow/brainstorm/role-analysis.md"
+  },
+  {
+    "name": "synthesis",
+    "command": "/workflow:brainstorm:synthesis",
+    "description": "Clarify and refine role analyses through intelligent Q&A and targeted updates with synthesis agent",
+    "arguments": "[-y|--yes] [optional: --session session-id]",
+    "category": "workflow",
+    "subcategory": "brainstorm",
+    "usage_scenario": "general",
+    "difficulty": "Advanced",
+    "source": "../../../commands/workflow/brainstorm/synthesis.md"
+  },
+  {
+    "name": "brainstorm-with-file",
+    "command": "/workflow:brainstorm-with-file",
+    "description": "Interactive brainstorming with multi-CLI collaboration, idea expansion, and documented thought evolution",
+    "arguments": "[-y|--yes] [-c|--continue] [-m|--mode creative|structured] \\\"idea or topic\\",
+    "category": "workflow",
+    "subcategory": null,
+    "usage_scenario": "planning",
+    "difficulty": "Intermediate",
+    "source": "../../../commands/workflow/brainstorm-with-file.md"
+  },
+  {
+    "name": "clean",
+    "command": "/workflow:clean",
+    "description": "Intelligent code cleanup with mainline detection, stale artifact discovery, and safe execution",
+    "arguments": "[-y|--yes] [--dry-run] [\\\"focus area\\\"]",
+    "category": "workflow",
+    "subcategory": null,
+    "usage_scenario": "general",
+    "difficulty": "Intermediate",
+    "source": "../../../commands/workflow/clean.md"
+  },
+  {
+    "name": "debug-with-file",
+    "command": "/workflow:debug-with-file",
+    "description": "Interactive hypothesis-driven debugging with documented exploration, understanding evolution, and Gemini-assisted correction",
+    "arguments": "[-y|--yes] \\\"bug description or error message\\",
+    "category": "workflow",
+    "subcategory": null,
+    "usage_scenario": "general",
+    "difficulty": "Intermediate",
+    "source": "../../../commands/workflow/debug-with-file.md"
+  },
+  {
+    "name": "execute",
+    "command": "/workflow:execute",
+    "description": "Coordinate agent execution for workflow tasks with automatic session discovery, parallel task processing, and status tracking",
+    "arguments": "[-y|--yes] [--resume-session=\\\"session-id\\\"]",
+    "category": "workflow",
+    "subcategory": null,
+    "usage_scenario": "implementation",
+    "difficulty": "Intermediate",
+    "source": "../../../commands/workflow/execute.md"
+  },
+  {
+    "name": "init",
+    "command": "/workflow:init",
+    "description": "Initialize project-level state with intelligent project analysis using cli-explore-agent",
+    "arguments": "[--regenerate]",
+    "category": "workflow",
+    "subcategory": null,
+    "usage_scenario": "general",
+    "difficulty": "Intermediate",
+    "source": "../../../commands/workflow/init.md"
+  },
+  {
+    "name": "lite-execute",
+    "command": "/workflow:lite-execute",
+    "description": "Execute tasks based on in-memory plan, prompt description, or file content",
+    "arguments": "[-y|--yes] [--in-memory] [\\\"task description\\\"|file-path]",
+    "category": "workflow",
+    "subcategory": null,
+    "usage_scenario": "implementation",
+    "difficulty": "Intermediate",
+    "source": "../../../commands/workflow/lite-execute.md"
+  },
+  {
+    "name": "lite-fix",
+    "command": "/workflow:lite-fix",
+    "description": "Lightweight bug diagnosis and fix workflow with intelligent severity assessment and optional hotfix mode for production incidents",
+    "arguments": "[-y|--yes] [--hotfix] \\\"bug description or issue reference\\",
+    "category": "workflow",
+    "subcategory": null,
+    "usage_scenario": "general",
+    "difficulty": "Intermediate",
+    "source": "../../../commands/workflow/lite-fix.md"
+  },
+  {
+    "name": "workflow:lite-lite-lite",
+    "command": "/workflow:lite-lite-lite",
+    "description": "Ultra-lightweight multi-tool analysis and direct execution. No artifacts for simple tasks; auto-creates planning docs in .workflow/.scratchpad/ for complex tasks. Auto tool selection based on task analysis, user-driven iteration via AskUser.",
+    "arguments": "[-y|--yes] <task description>",
+    "category": "workflow",
+    "subcategory": null,
+    "usage_scenario": "general",
+    "difficulty": "Intermediate",
+    "source": "../../../commands/workflow/lite-lite-lite.md"
+  },
+  {
+    "name": "lite-plan",
+    "command": "/workflow:lite-plan",
+    "description": "Lightweight interactive planning workflow with in-memory planning, code exploration, and execution execute to lite-execute after user confirmation",
+    "arguments": "[-y|--yes] [-e|--explore] \\\"task description\\\"|file.md",
+    "category": "workflow",
+    "subcategory": null,
+    "usage_scenario": "planning",
+    "difficulty": "Intermediate",
+    "source": "../../../commands/workflow/lite-plan.md"
+  },
+  {
+    "name": "workflow:multi-cli-plan",
+    "command": "/workflow:multi-cli-plan",
+    "description": "Multi-CLI collaborative planning workflow with ACE context gathering and iterative cross-verification. Uses cli-discuss-agent for Gemini+Codex+Claude analysis to converge on optimal execution plan.",
+    "arguments": "[-y|--yes] <task description> [--max-rounds=3] [--tools=gemini,codex] [--mode=parallel|serial]",
+    "category": "workflow",
+    "subcategory": null,
+    "usage_scenario": "planning",
+    "difficulty": "Intermediate",
+    "source": "../../../commands/workflow/multi-cli-plan.md"
+  },
+  {
+    "name": "plan-verify",
+    "command": "/workflow:plan-verify",
+    "description": "Perform READ-ONLY verification analysis between IMPL_PLAN.md, task JSONs, and brainstorming artifacts. Generates structured report with quality gate recommendation. Does NOT modify any files.",
+    "arguments": "[optional: --session session-id]",
+    "category": "workflow",
+    "subcategory": null,
+    "usage_scenario": "planning",
+    "difficulty": "Intermediate",
+    "source": "../../../commands/workflow/plan-verify.md"
+  },
+  {
+    "name": "plan",
+    "command": "/workflow:plan",
+    "description": "5-phase planning workflow with action-planning-agent task generation, outputs IMPL_PLAN.md and task JSONs",
+    "arguments": "[-y|--yes] \\\"text description\\\"|file.md",
+    "category": "workflow",
+    "subcategory": null,
+    "usage_scenario": "planning",
+    "difficulty": "Intermediate",
+    "source": "../../../commands/workflow/plan.md"
+  },
+  {
+    "name": "replan",
+    "command": "/workflow:replan",
+    "description": "Interactive workflow replanning with session-level artifact updates and boundary clarification through guided questioning",
+    "arguments": "[-y|--yes] [--session session-id] [task-id] \\\"requirements\\\"|file.md [--interactive]",
+    "category": "workflow",
+    "subcategory": null,
+    "usage_scenario": "planning",
+    "difficulty": "Intermediate",
+    "source": "../../../commands/workflow/replan.md"
+  },
+  {
+    "name": "review-cycle-fix",
+    "command": "/workflow:review-cycle-fix",
+    "description": "Automated fixing of code review findings with AI-powered planning and coordinated execution. Uses intelligent grouping, multi-stage timeline coordination, and test-driven verification.",
+    "arguments": "<export-file|review-dir> [--resume] [--max-iterations=N]",
+    "category": "workflow",
+    "subcategory": null,
+    "usage_scenario": "analysis",
+    "difficulty": "Intermediate",
+    "source": "../../../commands/workflow/review-cycle-fix.md"
+  },
+  {
+    "name": "review-module-cycle",
+    "command": "/workflow:review-module-cycle",
+    "description": "Independent multi-dimensional code review for specified modules/files. Analyzes specific code paths across 7 dimensions with hybrid parallel-iterative execution, independent of workflow sessions.",
+    "arguments": "<path-pattern> [--dimensions=security,architecture,...] [--max-iterations=N]",
+    "category": "workflow",
+    "subcategory": null,
+    "usage_scenario": "analysis",
+    "difficulty": "Intermediate",
+    "source": "../../../commands/workflow/review-module-cycle.md"
+  },
+  {
+    "name": "review-session-cycle",
+    "command": "/workflow:review-session-cycle",
+    "description": "Session-based comprehensive multi-dimensional code review. Analyzes git changes from workflow session across 7 dimensions with hybrid parallel-iterative execution, aggregates findings, and performs focused deep-dives on critical issues until quality gates met.",
+    "arguments": "[session-id] [--dimensions=security,architecture,...] [--max-iterations=N]",
+    "category": "workflow",
+    "subcategory": null,
+    "usage_scenario": "session-management",
+    "difficulty": "Intermediate",
+    "source": "../../../commands/workflow/review-session-cycle.md"
+  },
+  {
+    "name": "review",
+    "command": "/workflow:review",
+    "description": "Post-implementation review with specialized types (security/architecture/action-items/quality) using analysis agents and Gemini",
+    "arguments": "[--type=security|architecture|action-items|quality] [--archived] [optional: session-id]",
+    "category": "workflow",
+    "subcategory": null,
+    "usage_scenario": "analysis",
+    "difficulty": "Intermediate",
+    "source": "../../../commands/workflow/review.md"
+  },
+  {
+    "name": "complete",
+    "command": "/workflow:session:complete",
+    "description": "Mark active workflow session as complete, archive with lessons learned, update manifest, remove active flag",
+    "arguments": "[-y|--yes] [--detailed]",
+    "category": "workflow",
+    "subcategory": "session",
+    "usage_scenario": "session-management",
+    "difficulty": "Intermediate",
+    "source": "../../../commands/workflow/session/complete.md"
+  },
+  {
+    "name": "list",
+    "command": "/workflow:session:list",
+    "description": "List all workflow sessions with status filtering, shows session metadata and progress information",
+    "arguments": "",
+    "category": "workflow",
+    "subcategory": "session",
+    "usage_scenario": "general",
+    "difficulty": "Beginner",
+    "source": "../../../commands/workflow/session/list.md"
+  },
+  {
+    "name": "resume",
+    "command": "/workflow:session:resume",
+    "description": "Resume the most recently paused workflow session with automatic session discovery and status update",
+    "arguments": "",
+    "category": "workflow",
+    "subcategory": "session",
+    "usage_scenario": "session-management",
+    "difficulty": "Intermediate",
+    "source": "../../../commands/workflow/session/resume.md"
+  },
+  {
+    "name": "solidify",
+    "command": "/workflow:session:solidify",
+    "description": "Crystallize session learnings and user-defined constraints into permanent project guidelines",
+    "arguments": "[-y|--yes] [--type <convention|constraint|learning>] [--category <category>] \\\"rule or insight\\",
+    "category": "workflow",
+    "subcategory": "session",
+    "usage_scenario": "general",
+    "difficulty": "Intermediate",
+    "source": "../../../commands/workflow/session/solidify.md"
+  },
+  {
+    "name": "start",
+    "command": "/workflow:session:start",
+    "description": "Discover existing sessions or start new workflow session with intelligent session management and conflict detection",
+    "arguments": "[--type <workflow|review|tdd|test|docs>] [--auto|--new] [optional: task description for new session]",
+    "category": "workflow",
+    "subcategory": "session",
+    "usage_scenario": "general",
+    "difficulty": "Intermediate",
+    "source": "../../../commands/workflow/session/start.md"
+  },
+  {
+    "name": "tdd-plan",
+    "command": "/workflow:tdd-plan",
+    "description": "TDD workflow planning with Red-Green-Refactor task chain generation, test-first development structure, and cycle tracking",
+    "arguments": "\\\"feature description\\\"|file.md",
+    "category": "workflow",
+    "subcategory": null,
+    "usage_scenario": "planning",
+    "difficulty": "Advanced",
+    "source": "../../../commands/workflow/tdd-plan.md"
+  },
+  {
+    "name": "tdd-verify",
+    "command": "/workflow:tdd-verify",
+    "description": "Verify TDD workflow compliance against Red-Green-Refactor cycles. Generates quality report with coverage analysis and quality gate recommendation. Orchestrates sub-commands for comprehensive validation.",
+    "arguments": "[optional: --session WFS-session-id]",
+    "category": "workflow",
+    "subcategory": null,
+    "usage_scenario": "testing",
+    "difficulty": "Advanced",
+    "source": "../../../commands/workflow/tdd-verify.md"
+  },
+  {
+    "name": "test-cycle-execute",
+    "command": "/workflow:test-cycle-execute",
+    "description": "Execute test-fix workflow with dynamic task generation and iterative fix cycles until test pass rate >= 95% or max iterations reached. Uses @cli-planning-agent for failure analysis and task generation.",
+    "arguments": "[--resume-session=\\\"session-id\\\"] [--max-iterations=N]",
+    "category": "workflow",
+    "subcategory": null,
+    "usage_scenario": "implementation",
+    "difficulty": "Intermediate",
+    "source": "../../../commands/workflow/test-cycle-execute.md"
+  },
+  {
+    "name": "test-fix-gen",
+    "command": "/workflow:test-fix-gen",
+    "description": "Create test-fix workflow session from session ID, description, or file path with test strategy generation and task planning",
+    "arguments": "(source-session-id | \\\"feature description\\\" | /path/to/file.md)",
+    "category": "workflow",
+    "subcategory": null,
+    "usage_scenario": "testing",
+    "difficulty": "Intermediate",
+    "source": "../../../commands/workflow/test-fix-gen.md"
+  },
+  {
+    "name": "test-gen",
+    "command": "/workflow:test-gen",
+    "description": "Create independent test-fix workflow session from completed implementation session, analyzes code to generate test tasks",
+    "arguments": "source-session-id",
+    "category": "workflow",
+    "subcategory": null,
+    "usage_scenario": "testing",
+    "difficulty": "Intermediate",
+    "source": "../../../commands/workflow/test-gen.md"
+  },
+  {
+    "name": "conflict-resolution",
+    "command": "/workflow:tools:conflict-resolution",
+    "description": "Detect and resolve conflicts between plan and existing codebase using CLI-powered analysis with Gemini/Qwen",
+    "arguments": "[-y|--yes] --session WFS-session-id --context path/to/context-package.json",
+    "category": "workflow",
+    "subcategory": "tools",
+    "usage_scenario": "general",
+    "difficulty": "Advanced",
+    "source": "../../../commands/workflow/tools/conflict-resolution.md"
+  },
+  {
+    "name": "gather",
+    "command": "/workflow:tools:gather",
+    "description": "Intelligently collect project context using context-search-agent based on task description, packages into standardized JSON",
+    "arguments": "--session WFS-session-id \\\"task description\\",
+    "category": "workflow",
+    "subcategory": "tools",
+    "usage_scenario": "general",
+    "difficulty": "Intermediate",
+    "source": "../../../commands/workflow/tools/context-gather.md"
+  },
+  {
+    "name": "task-generate-agent",
+    "command": "/workflow:tools:task-generate-agent",
+    "description": "Generate implementation plan documents (IMPL_PLAN.md, task JSONs, TODO_LIST.md) using action-planning-agent - produces planning artifacts, does NOT execute code implementation",
+    "arguments": "[-y|--yes] --session WFS-session-id",
+    "category": "workflow",
+    "subcategory": "tools",
+    "usage_scenario": "implementation",
+    "difficulty": "Advanced",
+    "source": "../../../commands/workflow/tools/task-generate-agent.md"
+  },
+  {
+    "name": "task-generate-tdd",
+    "command": "/workflow:tools:task-generate-tdd",
+    "description": "Autonomous TDD task generation using action-planning-agent with Red-Green-Refactor cycles, test-first structure, and cycle validation",
+    "arguments": "[-y|--yes] --session WFS-session-id",
+    "category": "workflow",
+    "subcategory": "tools",
+    "usage_scenario": "implementation",
+    "difficulty": "Advanced",
+    "source": "../../../commands/workflow/tools/task-generate-tdd.md"
+  },
+  {
+    "name": "tdd-coverage-analysis",
+    "command": "/workflow:tools:tdd-coverage-analysis",
+    "description": "Analyze test coverage and TDD cycle execution with Red-Green-Refactor compliance verification",
+    "arguments": "--session WFS-session-id",
+    "category": "workflow",
+    "subcategory": "tools",
+    "usage_scenario": "testing",
+    "difficulty": "Advanced",
+    "source": "../../../commands/workflow/tools/tdd-coverage-analysis.md"
+  },
+  {
+    "name": "test-concept-enhanced",
+    "command": "/workflow:tools:test-concept-enhanced",
+    "description": "Coordinate test analysis workflow using cli-execution-agent to generate test strategy via Gemini",
+    "arguments": "--session WFS-test-session-id --context path/to/test-context-package.json",
+    "category": "workflow",
+    "subcategory": "tools",
+    "usage_scenario": "testing",
+    "difficulty": "Intermediate",
+    "source": "../../../commands/workflow/tools/test-concept-enhanced.md"
+  },
+  {
+    "name": "test-context-gather",
+    "command": "/workflow:tools:test-context-gather",
+    "description": "Collect test coverage context using test-context-search-agent and package into standardized test-context JSON",
+    "arguments": "--session WFS-test-session-id",
+    "category": "workflow",
+    "subcategory": "tools",
+    "usage_scenario": "testing",
+    "difficulty": "Intermediate",
+    "source": "../../../commands/workflow/tools/test-context-gather.md"
+  },
+  {
+    "name": "test-task-generate",
+    "command": "/workflow:tools:test-task-generate",
+    "description": "Generate test planning documents (IMPL_PLAN.md, test task JSONs, TODO_LIST.md) using action-planning-agent - produces test planning artifacts, does NOT execute tests",
+    "arguments": "--session WFS-test-session-id",
+    "category": "workflow",
+    "subcategory": "tools",
+    "usage_scenario": "implementation",
+    "difficulty": "Intermediate",
+    "source": "../../../commands/workflow/tools/test-task-generate.md"
+  },
+  {
+    "name": "animation-extract",
+    "command": "/workflow:ui-design:animation-extract",
+    "description": "Extract animation and transition patterns from prompt inference and image references for design system documentation",
+    "arguments": "[-y|--yes] [--design-id <id>] [--session <id>] [--images \"<glob>\"] [--focus \"<types>\"] [--interactive] [--refine]",
+    "category": "workflow",
+    "subcategory": "ui-design",
+    "usage_scenario": "general",
+    "difficulty": "Intermediate",
+    "source": "../../../commands/workflow/ui-design/animation-extract.md"
+  },
+  {
+    "name": "workflow:ui-design:codify-style",
+    "command": "/workflow:ui-design:codify-style",
+    "description": "Orchestrator to extract styles from code and generate shareable reference package with preview (automatic file discovery)",
+    "arguments": "<path> [--package-name <name>] [--output-dir <path>] [--overwrite]",
+    "category": "workflow",
+    "subcategory": "ui-design",
+    "usage_scenario": "planning",
+    "difficulty": "Intermediate",
+    "source": "../../../commands/workflow/ui-design/codify-style.md"
+  },
+  {
+    "name": "design-sync",
+    "command": "/workflow:ui-design:design-sync",
+    "description": "Synchronize finalized design system references to brainstorming artifacts, preparing them for /workflow:plan consumption",
+    "arguments": "--session <session_id> [--selected-prototypes \"<list>\"]",
+    "category": "workflow",
+    "subcategory": "ui-design",
+    "usage_scenario": "planning",
+    "difficulty": "Intermediate",
+    "source": "../../../commands/workflow/ui-design/design-sync.md"
+  },
+  {
+    "name": "explore-auto",
+    "command": "/workflow:ui-design:explore-auto",
+    "description": "Interactive exploratory UI design workflow with style-centric batch generation, creates design variants from prompts/images with parallel execution and user selection",
+    "arguments": "[--input \"<value>\"] [--targets \"<list>\"] [--target-type \"page|component\"] [--session <id>] [--style-variants <count>] [--layout-variants <count>]",
+    "category": "workflow",
+    "subcategory": "ui-design",
+    "usage_scenario": "general",
+    "difficulty": "Intermediate",
+    "source": "../../../commands/workflow/ui-design/explore-auto.md"
+  },
+  {
+    "name": "generate",
+    "command": "/workflow:ui-design:generate",
+    "description": "Assemble UI prototypes by combining layout templates with design tokens (default animation support), pure assembler without new content generation",
+    "arguments": "[--design-id <id>] [--session <id>]",
+    "category": "workflow",
+    "subcategory": "ui-design",
+    "usage_scenario": "implementation",
+    "difficulty": "Intermediate",
+    "source": "../../../commands/workflow/ui-design/generate.md"
+  },
+  {
+    "name": "imitate-auto",
+    "command": "/workflow:ui-design:imitate-auto",
+    "description": "UI design workflow with direct code/image input for design token extraction and prototype generation",
+    "arguments": "[--input \"<value>\"] [--session <id>]",
+    "category": "workflow",
+    "subcategory": "ui-design",
+    "usage_scenario": "general",
+    "difficulty": "Intermediate",
+    "source": "../../../commands/workflow/ui-design/imitate-auto.md"
+  },
+  {
+    "name": "workflow:ui-design:import-from-code",
+    "command": "/workflow:ui-design:import-from-code",
+    "description": "Import design system from code files (CSS/JS/HTML/SCSS) with automatic file discovery and parallel agent analysis",
+    "arguments": "[--design-id <id>] [--session <id>] [--source <path>]",
+    "category": "workflow",
+    "subcategory": "ui-design",
+    "usage_scenario": "planning",
+    "difficulty": "Intermediate",
+    "source": "../../../commands/workflow/ui-design/import-from-code.md"
+  },
+  {
+    "name": "layout-extract",
+    "command": "/workflow:ui-design:layout-extract",
+    "description": "Extract structural layout information from reference images or text prompts using Claude analysis with variant generation or refinement mode",
+    "arguments": "[-y|--yes] [--design-id <id>] [--session <id>] [--images \"<glob>\"] [--prompt \"<desc>\"] [--targets \"<list>\"] [--variants <count>] [--device-type <desktop|mobile|tablet|responsive>] [--interactive] [--refine]",
+    "category": "workflow",
+    "subcategory": "ui-design",
+    "usage_scenario": "general",
+    "difficulty": "Intermediate",
+    "source": "../../../commands/workflow/ui-design/layout-extract.md"
+  },
+  {
+    "name": "workflow:ui-design:reference-page-generator",
+    "command": "/workflow:ui-design:reference-page-generator",
+    "description": "Generate multi-component reference pages and documentation from design run extraction",
+    "arguments": "[--design-run <path>] [--package-name <name>] [--output-dir <path>]",
+    "category": "workflow",
+    "subcategory": "ui-design",
+    "usage_scenario": "planning",
+    "difficulty": "Intermediate",
+    "source": "../../../commands/workflow/ui-design/reference-page-generator.md"
+  },
+  {
+    "name": "style-extract",
+    "command": "/workflow:ui-design:style-extract",
+    "description": "Extract design style from reference images or text prompts using Claude analysis with variant generation or refinement mode",
+    "arguments": "[-y|--yes] [--design-id <id>] [--session <id>] [--images \"<glob>\"] [--prompt \"<desc>\"] [--variants <count>] [--interactive] [--refine]",
+    "category": "workflow",
+    "subcategory": "ui-design",
+    "usage_scenario": "general",
+    "difficulty": "Intermediate",
+    "source": "../../../commands/workflow/ui-design/style-extract.md"
+  },
+  {
+    "name": "unified-execute-with-file",
+    "command": "/workflow:unified-execute-with-file",
+    "description": "Universal execution engine for consuming any planning/brainstorm/analysis output with minimal progress tracking, multi-agent coordination, and incremental execution",
+    "arguments": "[-y|--yes] [-p|--plan <path>] [-m|--mode sequential|parallel] [\\\"execution context or task name\\\"]",
+    "category": "workflow",
+    "subcategory": null,
+    "usage_scenario": "implementation",
+    "difficulty": "Intermediate",
+    "source": "../../../commands/workflow/unified-execute-with-file.md"
+  }
+]

.claude/skills/ccw-help/index/by-category.json

@@ -0,0 +1,833 @@
+{
+  "general": {
+    "_root": [
+      {
+        "name": "ccw-coordinator",
+        "command": "/ccw-coordinator",
+        "description": "Command orchestration tool - analyze requirements, recommend chain, execute sequentially with state persistence",
+        "arguments": "[task description]",
+        "category": "general",
+        "subcategory": null,
+        "usage_scenario": "general",
+        "difficulty": "Intermediate",
+        "source": "../../../commands/ccw-coordinator.md"
+      },
+      {
+        "name": "ccw-debug",
+        "command": "/ccw-debug",
+        "description": "Aggregated debug command - combines debugging diagnostics and test verification in a synergistic workflow supporting cli-quick / debug-first / test-first / bidirectional-verification modes",
+        "arguments": "[--mode cli|debug|test|bidirectional] [--yes|-y] [--hotfix] \\\"bug description or error message\\",
+        "category": "general",
+        "subcategory": null,
+        "usage_scenario": "general",
+        "difficulty": "Intermediate",
+        "source": "../../../commands/ccw-debug.md"
+      },
+      {
+        "name": "ccw",
+        "command": "/ccw",
+        "description": "Main workflow orchestrator - analyze intent, select workflow, execute command chain in main process",
+        "arguments": "\\\"task description\\",
+        "category": "general",
+        "subcategory": null,
+        "usage_scenario": "general",
+        "difficulty": "Intermediate",
+        "source": "../../../commands/ccw.md"
+      },
+      {
+        "name": "ccw view",
+        "command": "/ccw view",
+        "description": "Dashboard - Open CCW workflow dashboard for managing tasks and sessions",
+        "arguments": "",
+        "category": "general",
+        "subcategory": null,
+        "usage_scenario": "general",
+        "difficulty": "Intermediate",
+        "source": "../../../commands/view.md"
+      }
+    ]
+  },
+  "cli": {
+    "_root": [
+      {
+        "name": "cli-init",
+        "command": "/cli:cli-init",
+        "description": "Generate .gemini/ and .qwen/ config directories with settings.json and ignore files based on workspace technology detection",
+        "arguments": "[--tool gemini|qwen|all] [--output path] [--preview]",
+        "category": "cli",
+        "subcategory": null,
+        "usage_scenario": "general",
+        "difficulty": "Intermediate",
+        "source": "../../../commands/cli/cli-init.md"
+      },
+      {
+        "name": "codex-review",
+        "command": "/cli:codex-review",
+        "description": "Interactive code review using Codex CLI via ccw endpoint with configurable review target, model, and custom instructions",
+        "arguments": "[--uncommitted|--base <branch>|--commit <sha>] [--model <model>] [--title <title>] [prompt]",
+        "category": "cli",
+        "subcategory": null,
+        "usage_scenario": "analysis",
+        "difficulty": "Intermediate",
+        "source": "../../../commands/cli/codex-review.md"
+      }
+    ]
+  },
+  "issue": {
+    "_root": [
+      {
+        "name": "convert-to-plan",
+        "command": "/issue:convert-to-plan",
+        "description": "Convert planning artifacts (lite-plan, workflow session, markdown) to issue solutions",
+        "arguments": "[-y|--yes] [--issue <id>] [--supplement] <SOURCE>",
+        "category": "issue",
+        "subcategory": null,
+        "usage_scenario": "planning",
+        "difficulty": "Intermediate",
+        "source": "../../../commands/issue/convert-to-plan.md"
+      },
+      {
+        "name": "issue:discover-by-prompt",
+        "command": "/issue:discover-by-prompt",
+        "description": "Discover issues from user prompt with Gemini-planned iterative multi-agent exploration. Uses ACE semantic search for context gathering and supports cross-module comparison (e.g., frontend vs backend API contracts).",
+        "arguments": "[-y|--yes] <prompt> [--scope=src/**] [--depth=standard|deep] [--max-iterations=5]",
+        "category": "issue",
+        "subcategory": null,
+        "usage_scenario": "general",
+        "difficulty": "Intermediate",
+        "source": "../../../commands/issue/discover-by-prompt.md"
+      },
+      {
+        "name": "issue:discover",
+        "command": "/issue:discover",
+        "description": "Discover potential issues from multiple perspectives (bug, UX, test, quality, security, performance, maintainability, best-practices) using CLI explore. Supports Exa external research for security and best-practices perspectives.",
+        "arguments": "[-y|--yes] <path-pattern> [--perspectives=bug,ux,...] [--external]",
+        "category": "issue",
+        "subcategory": null,
+        "usage_scenario": "general",
+        "difficulty": "Intermediate",
+        "source": "../../../commands/issue/discover.md"
+      },
+      {
+        "name": "execute",
+        "command": "/issue:execute",
+        "description": "Execute queue with DAG-based parallel orchestration (one commit per solution)",
+        "arguments": "[-y|--yes] --queue <queue-id> [--worktree [<existing-path>]]",
+        "category": "issue",
+        "subcategory": null,
+        "usage_scenario": "implementation",
+        "difficulty": "Intermediate",
+        "source": "../../../commands/issue/execute.md"
+      },
+      {
+        "name": "from-brainstorm",
+        "command": "/issue:from-brainstorm",
+        "description": "Convert brainstorm session ideas into issue with executable solution for parallel-dev-cycle",
+        "arguments": "SESSION=\\\"<session-id>\\\" [--idea=<index>] [--auto] [-y|--yes]",
+        "category": "issue",
+        "subcategory": null,
+        "usage_scenario": "planning",
+        "difficulty": "Intermediate",
+        "source": "../../../commands/issue/from-brainstorm.md"
+      },
+      {
+        "name": "new",
+        "command": "/issue:new",
+        "description": "Create structured issue from GitHub URL or text description",
+        "arguments": "[-y|--yes] <github-url | text-description> [--priority 1-5]",
+        "category": "issue",
+        "subcategory": null,
+        "usage_scenario": "general",
+        "difficulty": "Intermediate",
+        "source": "../../../commands/issue/new.md"
+      },
+      {
+        "name": "plan",
+        "command": "/issue:plan",
+        "description": "Batch plan issue resolution using issue-plan-agent (explore + plan closed-loop)",
+        "arguments": "[-y|--yes] --all-pending <issue-id>[,<issue-id>,...] [--batch-size 3]",
+        "category": "issue",
+        "subcategory": null,
+        "usage_scenario": "planning",
+        "difficulty": "Intermediate",
+        "source": "../../../commands/issue/plan.md"
+      },
+      {
+        "name": "queue",
+        "command": "/issue:queue",
+        "description": "Form execution queue from bound solutions using issue-queue-agent (solution-level)",
+        "arguments": "[-y|--yes] [--queues <n>] [--issue <id>]",
+        "category": "issue",
+        "subcategory": null,
+        "usage_scenario": "general",
+        "difficulty": "Intermediate",
+        "source": "../../../commands/issue/queue.md"
+      }
+    ]
+  },
+  "memory": {
+    "_root": [
+      {
+        "name": "compact",
+        "command": "/memory:compact",
+        "description": "Compact current session memory into structured text for session recovery, extracting objective/plan/files/decisions/constraints/state, and save via MCP core_memory tool",
+        "arguments": "[optional: session description]",
+        "category": "memory",
+        "subcategory": null,
+        "usage_scenario": "general",
+        "difficulty": "Intermediate",
+        "source": "../../../commands/memory/compact.md"
+      },
+      {
+        "name": "docs-full-cli",
+        "command": "/memory:docs-full-cli",
+        "description": "Generate full project documentation using CLI execution (Layer 3→1) with batched agents (4 modules/agent) and gemini→qwen→codex fallback, <20 modules uses direct parallel",
+        "arguments": "[path] [--tool <gemini|qwen|codex>]",
+        "category": "memory",
+        "subcategory": null,
+        "usage_scenario": "documentation",
+        "difficulty": "Intermediate",
+        "source": "../../../commands/memory/docs-full-cli.md"
+      },
+      {
+        "name": "docs-related-cli",
+        "command": "/memory:docs-related-cli",
+        "description": "Generate/update documentation for git-changed modules using CLI execution with batched agents (4 modules/agent) and gemini→qwen→codex fallback, <15 modules uses direct parallel",
+        "arguments": "[--tool <gemini|qwen|codex>]",
+        "category": "memory",
+        "subcategory": null,
+        "usage_scenario": "documentation",
+        "difficulty": "Intermediate",
+        "source": "../../../commands/memory/docs-related-cli.md"
+      },
+      {
+        "name": "load",
+        "command": "/memory:load",
+        "description": "Delegate to universal-executor agent to analyze project via Gemini/Qwen CLI and return JSON core content package for task context",
+        "arguments": "[--tool gemini|qwen] \\\"task context description\\",
+        "category": "memory",
+        "subcategory": null,
+        "usage_scenario": "general",
+        "difficulty": "Intermediate",
+        "source": "../../../commands/memory/load.md"
+      },
+      {
+        "name": "style-skill-memory",
+        "command": "/memory:style-skill-memory",
+        "description": "Generate SKILL memory package from style reference for easy loading and consistent design system usage",
+        "arguments": "[package-name] [--regenerate]",
+        "category": "memory",
+        "subcategory": null,
+        "usage_scenario": "documentation",
+        "difficulty": "Intermediate",
+        "source": "../../../commands/memory/style-skill-memory.md"
+      },
+      {
+        "name": "tips",
+        "command": "/memory:tips",
+        "description": "Quick note-taking command to capture ideas, snippets, reminders, and insights for later reference",
+        "arguments": "<note content> [--tag <tag1,tag2>] [--context <context>]",
+        "category": "memory",
+        "subcategory": null,
+        "usage_scenario": "general",
+        "difficulty": "Intermediate",
+        "source": "../../../commands/memory/tips.md"
+      },
+      {
+        "name": "update-full",
+        "command": "/memory:update-full",
+        "description": "Update all CLAUDE.md files using layer-based execution (Layer 3→1) with batched agents (4 modules/agent) and gemini→qwen→codex fallback, <20 modules uses direct parallel",
+        "arguments": "[--tool gemini|qwen|codex] [--path <directory>]",
+        "category": "memory",
+        "subcategory": null,
+        "usage_scenario": "general",
+        "difficulty": "Intermediate",
+        "source": "../../../commands/memory/update-full.md"
+      },
+      {
+        "name": "update-related",
+        "command": "/memory:update-related",
+        "description": "Update CLAUDE.md for git-changed modules using batched agent execution (4 modules/agent) with gemini→qwen→codex fallback, <15 modules uses direct execution",
+        "arguments": "[--tool gemini|qwen|codex]",
+        "category": "memory",
+        "subcategory": null,
+        "usage_scenario": "general",
+        "difficulty": "Intermediate",
+        "source": "../../../commands/memory/update-related.md"
+      }
+    ]
+  },
+  "workflow": {
+    "_root": [
+      {
+        "name": "analyze-with-file",
+        "command": "/workflow:analyze-with-file",
+        "description": "Interactive collaborative analysis with documented discussions, CLI-assisted exploration, and evolving understanding",
+        "arguments": "[-y|--yes] [-c|--continue] \\\"topic or question\\",
+        "category": "workflow",
+        "subcategory": null,
+        "usage_scenario": "analysis",
+        "difficulty": "Beginner",
+        "source": "../../../commands/workflow/analyze-with-file.md"
+      },
+      {
+        "name": "brainstorm-with-file",
+        "command": "/workflow:brainstorm-with-file",
+        "description": "Interactive brainstorming with multi-CLI collaboration, idea expansion, and documented thought evolution",
+        "arguments": "[-y|--yes] [-c|--continue] [-m|--mode creative|structured] \\\"idea or topic\\",
+        "category": "workflow",
+        "subcategory": null,
+        "usage_scenario": "planning",
+        "difficulty": "Intermediate",
+        "source": "../../../commands/workflow/brainstorm-with-file.md"
+      },
+      {
+        "name": "clean",
+        "command": "/workflow:clean",
+        "description": "Intelligent code cleanup with mainline detection, stale artifact discovery, and safe execution",
+        "arguments": "[-y|--yes] [--dry-run] [\\\"focus area\\\"]",
+        "category": "workflow",
+        "subcategory": null,
+        "usage_scenario": "general",
+        "difficulty": "Intermediate",
+        "source": "../../../commands/workflow/clean.md"
+      },
+      {
+        "name": "debug-with-file",
+        "command": "/workflow:debug-with-file",
+        "description": "Interactive hypothesis-driven debugging with documented exploration, understanding evolution, and Gemini-assisted correction",
+        "arguments": "[-y|--yes] \\\"bug description or error message\\",
+        "category": "workflow",
+        "subcategory": null,
+        "usage_scenario": "general",
+        "difficulty": "Intermediate",
+        "source": "../../../commands/workflow/debug-with-file.md"
+      },
+      {
+        "name": "execute",
+        "command": "/workflow:execute",
+        "description": "Coordinate agent execution for workflow tasks with automatic session discovery, parallel task processing, and status tracking",
+        "arguments": "[-y|--yes] [--resume-session=\\\"session-id\\\"]",
+        "category": "workflow",
+        "subcategory": null,
+        "usage_scenario": "implementation",
+        "difficulty": "Intermediate",
+        "source": "../../../commands/workflow/execute.md"
+      },
+      {
+        "name": "init",
+        "command": "/workflow:init",
+        "description": "Initialize project-level state with intelligent project analysis using cli-explore-agent",
+        "arguments": "[--regenerate]",
+        "category": "workflow",
+        "subcategory": null,
+        "usage_scenario": "general",
+        "difficulty": "Intermediate",
+        "source": "../../../commands/workflow/init.md"
+      },
+      {
+        "name": "lite-execute",
+        "command": "/workflow:lite-execute",
+        "description": "Execute tasks based on in-memory plan, prompt description, or file content",
+        "arguments": "[-y|--yes] [--in-memory] [\\\"task description\\\"|file-path]",
+        "category": "workflow",
+        "subcategory": null,
+        "usage_scenario": "implementation",
+        "difficulty": "Intermediate",
+        "source": "../../../commands/workflow/lite-execute.md"
+      },
+      {
+        "name": "lite-fix",
+        "command": "/workflow:lite-fix",
+        "description": "Lightweight bug diagnosis and fix workflow with intelligent severity assessment and optional hotfix mode for production incidents",
+        "arguments": "[-y|--yes] [--hotfix] \\\"bug description or issue reference\\",
+        "category": "workflow",
+        "subcategory": null,
+        "usage_scenario": "general",
+        "difficulty": "Intermediate",
+        "source": "../../../commands/workflow/lite-fix.md"
+      },
+      {
+        "name": "workflow:lite-lite-lite",
+        "command": "/workflow:lite-lite-lite",
+        "description": "Ultra-lightweight multi-tool analysis and direct execution. No artifacts for simple tasks; auto-creates planning docs in .workflow/.scratchpad/ for complex tasks. Auto tool selection based on task analysis, user-driven iteration via AskUser.",
+        "arguments": "[-y|--yes] <task description>",
+        "category": "workflow",
+        "subcategory": null,
+        "usage_scenario": "general",
+        "difficulty": "Intermediate",
+        "source": "../../../commands/workflow/lite-lite-lite.md"
+      },
+      {
+        "name": "lite-plan",
+        "command": "/workflow:lite-plan",
+        "description": "Lightweight interactive planning workflow with in-memory planning, code exploration, and execution execute to lite-execute after user confirmation",
+        "arguments": "[-y|--yes] [-e|--explore] \\\"task description\\\"|file.md",
+        "category": "workflow",
+        "subcategory": null,
+        "usage_scenario": "planning",
+        "difficulty": "Intermediate",
+        "source": "../../../commands/workflow/lite-plan.md"
+      },
+      {
+        "name": "workflow:multi-cli-plan",
+        "command": "/workflow:multi-cli-plan",
+        "description": "Multi-CLI collaborative planning workflow with ACE context gathering and iterative cross-verification. Uses cli-discuss-agent for Gemini+Codex+Claude analysis to converge on optimal execution plan.",
+        "arguments": "[-y|--yes] <task description> [--max-rounds=3] [--tools=gemini,codex] [--mode=parallel|serial]",
+        "category": "workflow",
+        "subcategory": null,
+        "usage_scenario": "planning",
+        "difficulty": "Intermediate",
+        "source": "../../../commands/workflow/multi-cli-plan.md"
+      },
+      {
+        "name": "plan-verify",
+        "command": "/workflow:plan-verify",
+        "description": "Perform READ-ONLY verification analysis between IMPL_PLAN.md, task JSONs, and brainstorming artifacts. Generates structured report with quality gate recommendation. Does NOT modify any files.",
+        "arguments": "[optional: --session session-id]",
+        "category": "workflow",
+        "subcategory": null,
+        "usage_scenario": "planning",
+        "difficulty": "Intermediate",
+        "source": "../../../commands/workflow/plan-verify.md"
+      },
+      {
+        "name": "plan",
+        "command": "/workflow:plan",
+        "description": "5-phase planning workflow with action-planning-agent task generation, outputs IMPL_PLAN.md and task JSONs",
+        "arguments": "[-y|--yes] \\\"text description\\\"|file.md",
+        "category": "workflow",
+        "subcategory": null,
+        "usage_scenario": "planning",
+        "difficulty": "Intermediate",
+        "source": "../../../commands/workflow/plan.md"
+      },
+      {
+        "name": "replan",
+        "command": "/workflow:replan",
+        "description": "Interactive workflow replanning with session-level artifact updates and boundary clarification through guided questioning",
+        "arguments": "[-y|--yes] [--session session-id] [task-id] \\\"requirements\\\"|file.md [--interactive]",
+        "category": "workflow",
+        "subcategory": null,
+        "usage_scenario": "planning",
+        "difficulty": "Intermediate",
+        "source": "../../../commands/workflow/replan.md"
+      },
+      {
+        "name": "review-cycle-fix",
+        "command": "/workflow:review-cycle-fix",
+        "description": "Automated fixing of code review findings with AI-powered planning and coordinated execution. Uses intelligent grouping, multi-stage timeline coordination, and test-driven verification.",
+        "arguments": "<export-file|review-dir> [--resume] [--max-iterations=N]",
+        "category": "workflow",
+        "subcategory": null,
+        "usage_scenario": "analysis",
+        "difficulty": "Intermediate",
+        "source": "../../../commands/workflow/review-cycle-fix.md"
+      },
+      {
+        "name": "review-module-cycle",
+        "command": "/workflow:review-module-cycle",
+        "description": "Independent multi-dimensional code review for specified modules/files. Analyzes specific code paths across 7 dimensions with hybrid parallel-iterative execution, independent of workflow sessions.",
+        "arguments": "<path-pattern> [--dimensions=security,architecture,...] [--max-iterations=N]",
+        "category": "workflow",
+        "subcategory": null,
+        "usage_scenario": "analysis",
+        "difficulty": "Intermediate",
+        "source": "../../../commands/workflow/review-module-cycle.md"
+      },
+      {
+        "name": "review-session-cycle",
+        "command": "/workflow:review-session-cycle",
+        "description": "Session-based comprehensive multi-dimensional code review. Analyzes git changes from workflow session across 7 dimensions with hybrid parallel-iterative execution, aggregates findings, and performs focused deep-dives on critical issues until quality gates met.",
+        "arguments": "[session-id] [--dimensions=security,architecture,...] [--max-iterations=N]",
+        "category": "workflow",
+        "subcategory": null,
+        "usage_scenario": "session-management",
+        "difficulty": "Intermediate",
+        "source": "../../../commands/workflow/review-session-cycle.md"
+      },
+      {
+        "name": "review",
+        "command": "/workflow:review",
+        "description": "Post-implementation review with specialized types (security/architecture/action-items/quality) using analysis agents and Gemini",
+        "arguments": "[--type=security|architecture|action-items|quality] [--archived] [optional: session-id]",
+        "category": "workflow",
+        "subcategory": null,
+        "usage_scenario": "analysis",
+        "difficulty": "Intermediate",
+        "source": "../../../commands/workflow/review.md"
+      },
+      {
+        "name": "tdd-plan",
+        "command": "/workflow:tdd-plan",
+        "description": "TDD workflow planning with Red-Green-Refactor task chain generation, test-first development structure, and cycle tracking",
+        "arguments": "\\\"feature description\\\"|file.md",
+        "category": "workflow",
+        "subcategory": null,
+        "usage_scenario": "planning",
+        "difficulty": "Advanced",
+        "source": "../../../commands/workflow/tdd-plan.md"
+      },
+      {
+        "name": "tdd-verify",
+        "command": "/workflow:tdd-verify",
+        "description": "Verify TDD workflow compliance against Red-Green-Refactor cycles. Generates quality report with coverage analysis and quality gate recommendation. Orchestrates sub-commands for comprehensive validation.",
+        "arguments": "[optional: --session WFS-session-id]",
+        "category": "workflow",
+        "subcategory": null,
+        "usage_scenario": "testing",
+        "difficulty": "Advanced",
+        "source": "../../../commands/workflow/tdd-verify.md"
+      },
+      {
+        "name": "test-cycle-execute",
+        "command": "/workflow:test-cycle-execute",
+        "description": "Execute test-fix workflow with dynamic task generation and iterative fix cycles until test pass rate >= 95% or max iterations reached. Uses @cli-planning-agent for failure analysis and task generation.",
+        "arguments": "[--resume-session=\\\"session-id\\\"] [--max-iterations=N]",
+        "category": "workflow",
+        "subcategory": null,
+        "usage_scenario": "implementation",
+        "difficulty": "Intermediate",
+        "source": "../../../commands/workflow/test-cycle-execute.md"
+      },
+      {
+        "name": "test-fix-gen",
+        "command": "/workflow:test-fix-gen",
+        "description": "Create test-fix workflow session from session ID, description, or file path with test strategy generation and task planning",
+        "arguments": "(source-session-id | \\\"feature description\\\" | /path/to/file.md)",
+        "category": "workflow",
+        "subcategory": null,
+        "usage_scenario": "testing",
+        "difficulty": "Intermediate",
+        "source": "../../../commands/workflow/test-fix-gen.md"
+      },
+      {
+        "name": "test-gen",
+        "command": "/workflow:test-gen",
+        "description": "Create independent test-fix workflow session from completed implementation session, analyzes code to generate test tasks",
+        "arguments": "source-session-id",
+        "category": "workflow",
+        "subcategory": null,
+        "usage_scenario": "testing",
+        "difficulty": "Intermediate",
+        "source": "../../../commands/workflow/test-gen.md"
+      },
+      {
+        "name": "unified-execute-with-file",
+        "command": "/workflow:unified-execute-with-file",
+        "description": "Universal execution engine for consuming any planning/brainstorm/analysis output with minimal progress tracking, multi-agent coordination, and incremental execution",
+        "arguments": "[-y|--yes] [-p|--plan <path>] [-m|--mode sequential|parallel] [\\\"execution context or task name\\\"]",
+        "category": "workflow",
+        "subcategory": null,
+        "usage_scenario": "implementation",
+        "difficulty": "Intermediate",
+        "source": "../../../commands/workflow/unified-execute-with-file.md"
+      }
+    ],
+    "brainstorm": [
+      {
+        "name": "artifacts",
+        "command": "/workflow:brainstorm:artifacts",
+        "description": "Interactive clarification generating confirmed guidance specification through role-based analysis and synthesis",
+        "arguments": "[-y|--yes] topic or challenge description [--count N]",
+        "category": "workflow",
+        "subcategory": "brainstorm",
+        "usage_scenario": "general",
+        "difficulty": "Intermediate",
+        "source": "../../../commands/workflow/brainstorm/artifacts.md"
+      },
+      {
+        "name": "auto-parallel",
+        "command": "/workflow:brainstorm:auto-parallel",
+        "description": "Parallel brainstorming automation with dynamic role selection and concurrent execution across multiple perspectives",
+        "arguments": "[-y|--yes] topic or challenge description [--count N]",
+        "category": "workflow",
+        "subcategory": "brainstorm",
+        "usage_scenario": "general",
+        "difficulty": "Advanced",
+        "source": "../../../commands/workflow/brainstorm/auto-parallel.md"
+      },
+      {
+        "name": "role-analysis",
+        "command": "/workflow:brainstorm:role-analysis",
+        "description": "Unified role-specific analysis generation with interactive context gathering and incremental updates",
+        "arguments": "[role-name] [--session session-id] [--update] [--include-questions] [--skip-questions]",
+        "category": "workflow",
+        "subcategory": "brainstorm",
+        "usage_scenario": "general",
+        "difficulty": "Intermediate",
+        "source": "../../../commands/workflow/brainstorm/role-analysis.md"
+      },
+      {
+        "name": "synthesis",
+        "command": "/workflow:brainstorm:synthesis",
+        "description": "Clarify and refine role analyses through intelligent Q&A and targeted updates with synthesis agent",
+        "arguments": "[-y|--yes] [optional: --session session-id]",
+        "category": "workflow",
+        "subcategory": "brainstorm",
+        "usage_scenario": "general",
+        "difficulty": "Advanced",
+        "source": "../../../commands/workflow/brainstorm/synthesis.md"
+      }
+    ],
+    "session": [
+      {
+        "name": "complete",
+        "command": "/workflow:session:complete",
+        "description": "Mark active workflow session as complete, archive with lessons learned, update manifest, remove active flag",
+        "arguments": "[-y|--yes] [--detailed]",
+        "category": "workflow",
+        "subcategory": "session",
+        "usage_scenario": "session-management",
+        "difficulty": "Intermediate",
+        "source": "../../../commands/workflow/session/complete.md"
+      },
+      {
+        "name": "list",
+        "command": "/workflow:session:list",
+        "description": "List all workflow sessions with status filtering, shows session metadata and progress information",
+        "arguments": "",
+        "category": "workflow",
+        "subcategory": "session",
+        "usage_scenario": "general",
+        "difficulty": "Beginner",
+        "source": "../../../commands/workflow/session/list.md"
+      },
+      {
+        "name": "resume",
+        "command": "/workflow:session:resume",
+        "description": "Resume the most recently paused workflow session with automatic session discovery and status update",
+        "arguments": "",
+        "category": "workflow",
+        "subcategory": "session",
+        "usage_scenario": "session-management",
+        "difficulty": "Intermediate",
+        "source": "../../../commands/workflow/session/resume.md"
+      },
+      {
+        "name": "solidify",
+        "command": "/workflow:session:solidify",
+        "description": "Crystallize session learnings and user-defined constraints into permanent project guidelines",
+        "arguments": "[-y|--yes] [--type <convention|constraint|learning>] [--category <category>] \\\"rule or insight\\",
+        "category": "workflow",
+        "subcategory": "session",
+        "usage_scenario": "general",
+        "difficulty": "Intermediate",
+        "source": "../../../commands/workflow/session/solidify.md"
+      },
+      {
+        "name": "start",
+        "command": "/workflow:session:start",
+        "description": "Discover existing sessions or start new workflow session with intelligent session management and conflict detection",
+        "arguments": "[--type <workflow|review|tdd|test|docs>] [--auto|--new] [optional: task description for new session]",
+        "category": "workflow",
+        "subcategory": "session",
+        "usage_scenario": "general",
+        "difficulty": "Intermediate",
+        "source": "../../../commands/workflow/session/start.md"
+      }
+    ],
+    "tools": [
+      {
+        "name": "conflict-resolution",
+        "command": "/workflow:tools:conflict-resolution",
+        "description": "Detect and resolve conflicts between plan and existing codebase using CLI-powered analysis with Gemini/Qwen",
+        "arguments": "[-y|--yes] --session WFS-session-id --context path/to/context-package.json",
+        "category": "workflow",
+        "subcategory": "tools",
+        "usage_scenario": "general",
+        "difficulty": "Advanced",
+        "source": "../../../commands/workflow/tools/conflict-resolution.md"
+      },
+      {
+        "name": "gather",
+        "command": "/workflow:tools:gather",
+        "description": "Intelligently collect project context using context-search-agent based on task description, packages into standardized JSON",
+        "arguments": "--session WFS-session-id \\\"task description\\",
+        "category": "workflow",
+        "subcategory": "tools",
+        "usage_scenario": "general",
+        "difficulty": "Intermediate",
+        "source": "../../../commands/workflow/tools/context-gather.md"
+      },
+      {
+        "name": "task-generate-agent",
+        "command": "/workflow:tools:task-generate-agent",
+        "description": "Generate implementation plan documents (IMPL_PLAN.md, task JSONs, TODO_LIST.md) using action-planning-agent - produces planning artifacts, does NOT execute code implementation",
+        "arguments": "[-y|--yes] --session WFS-session-id",
+        "category": "workflow",
+        "subcategory": "tools",
+        "usage_scenario": "implementation",
+        "difficulty": "Advanced",
+        "source": "../../../commands/workflow/tools/task-generate-agent.md"
+      },
+      {
+        "name": "task-generate-tdd",
+        "command": "/workflow:tools:task-generate-tdd",
+        "description": "Autonomous TDD task generation using action-planning-agent with Red-Green-Refactor cycles, test-first structure, and cycle validation",
+        "arguments": "[-y|--yes] --session WFS-session-id",
+        "category": "workflow",
+        "subcategory": "tools",
+        "usage_scenario": "implementation",
+        "difficulty": "Advanced",
+        "source": "../../../commands/workflow/tools/task-generate-tdd.md"
+      },
+      {
+        "name": "tdd-coverage-analysis",
+        "command": "/workflow:tools:tdd-coverage-analysis",
+        "description": "Analyze test coverage and TDD cycle execution with Red-Green-Refactor compliance verification",
+        "arguments": "--session WFS-session-id",
+        "category": "workflow",
+        "subcategory": "tools",
+        "usage_scenario": "testing",
+        "difficulty": "Advanced",
+        "source": "../../../commands/workflow/tools/tdd-coverage-analysis.md"
+      },
+      {
+        "name": "test-concept-enhanced",
+        "command": "/workflow:tools:test-concept-enhanced",
+        "description": "Coordinate test analysis workflow using cli-execution-agent to generate test strategy via Gemini",
+        "arguments": "--session WFS-test-session-id --context path/to/test-context-package.json",
+        "category": "workflow",
+        "subcategory": "tools",
+        "usage_scenario": "testing",
+        "difficulty": "Intermediate",
+        "source": "../../../commands/workflow/tools/test-concept-enhanced.md"
+      },
+      {
+        "name": "test-context-gather",
+        "command": "/workflow:tools:test-context-gather",
+        "description": "Collect test coverage context using test-context-search-agent and package into standardized test-context JSON",
+        "arguments": "--session WFS-test-session-id",
+        "category": "workflow",
+        "subcategory": "tools",
+        "usage_scenario": "testing",
+        "difficulty": "Intermediate",
+        "source": "../../../commands/workflow/tools/test-context-gather.md"
+      },
+      {
+        "name": "test-task-generate",
+        "command": "/workflow:tools:test-task-generate",
+        "description": "Generate test planning documents (IMPL_PLAN.md, test task JSONs, TODO_LIST.md) using action-planning-agent - produces test planning artifacts, does NOT execute tests",
+        "arguments": "--session WFS-test-session-id",
+        "category": "workflow",
+        "subcategory": "tools",
+        "usage_scenario": "implementation",
+        "difficulty": "Intermediate",
+        "source": "../../../commands/workflow/tools/test-task-generate.md"
+      }
+    ],
+    "ui-design": [
+      {
+        "name": "animation-extract",
+        "command": "/workflow:ui-design:animation-extract",
+        "description": "Extract animation and transition patterns from prompt inference and image references for design system documentation",
+        "arguments": "[-y|--yes] [--design-id <id>] [--session <id>] [--images \"<glob>\"] [--focus \"<types>\"] [--interactive] [--refine]",
+        "category": "workflow",
+        "subcategory": "ui-design",
+        "usage_scenario": "general",
+        "difficulty": "Intermediate",
+        "source": "../../../commands/workflow/ui-design/animation-extract.md"
+      },
+      {
+        "name": "workflow:ui-design:codify-style",
+        "command": "/workflow:ui-design:codify-style",
+        "description": "Orchestrator to extract styles from code and generate shareable reference package with preview (automatic file discovery)",
+        "arguments": "<path> [--package-name <name>] [--output-dir <path>] [--overwrite]",
+        "category": "workflow",
+        "subcategory": "ui-design",
+        "usage_scenario": "planning",
+        "difficulty": "Intermediate",
+        "source": "../../../commands/workflow/ui-design/codify-style.md"
+      },
+      {
+        "name": "design-sync",
+        "command": "/workflow:ui-design:design-sync",
+        "description": "Synchronize finalized design system references to brainstorming artifacts, preparing them for /workflow:plan consumption",
+        "arguments": "--session <session_id> [--selected-prototypes \"<list>\"]",
+        "category": "workflow",
+        "subcategory": "ui-design",
+        "usage_scenario": "planning",
+        "difficulty": "Intermediate",
+        "source": "../../../commands/workflow/ui-design/design-sync.md"
+      },
+      {
+        "name": "explore-auto",
+        "command": "/workflow:ui-design:explore-auto",
+        "description": "Interactive exploratory UI design workflow with style-centric batch generation, creates design variants from prompts/images with parallel execution and user selection",
+        "arguments": "[--input \"<value>\"] [--targets \"<list>\"] [--target-type \"page|component\"] [--session <id>] [--style-variants <count>] [--layout-variants <count>]",
+        "category": "workflow",
+        "subcategory": "ui-design",
+        "usage_scenario": "general",
+        "difficulty": "Intermediate",
+        "source": "../../../commands/workflow/ui-design/explore-auto.md"
+      },
+      {
+        "name": "generate",
+        "command": "/workflow:ui-design:generate",
+        "description": "Assemble UI prototypes by combining layout templates with design tokens (default animation support), pure assembler without new content generation",
+        "arguments": "[--design-id <id>] [--session <id>]",
+        "category": "workflow",
+        "subcategory": "ui-design",
+        "usage_scenario": "implementation",
+        "difficulty": "Intermediate",
+        "source": "../../../commands/workflow/ui-design/generate.md"
+      },
+      {
+        "name": "imitate-auto",
+        "command": "/workflow:ui-design:imitate-auto",
+        "description": "UI design workflow with direct code/image input for design token extraction and prototype generation",
+        "arguments": "[--input \"<value>\"] [--session <id>]",
+        "category": "workflow",
+        "subcategory": "ui-design",
+        "usage_scenario": "general",
+        "difficulty": "Intermediate",
+        "source": "../../../commands/workflow/ui-design/imitate-auto.md"
+      },
+      {
+        "name": "workflow:ui-design:import-from-code",
+        "command": "/workflow:ui-design:import-from-code",
+        "description": "Import design system from code files (CSS/JS/HTML/SCSS) with automatic file discovery and parallel agent analysis",
+        "arguments": "[--design-id <id>] [--session <id>] [--source <path>]",
+        "category": "workflow",
+        "subcategory": "ui-design",
+        "usage_scenario": "planning",
+        "difficulty": "Intermediate",
+        "source": "../../../commands/workflow/ui-design/import-from-code.md"
+      },
+      {
+        "name": "layout-extract",
+        "command": "/workflow:ui-design:layout-extract",
+        "description": "Extract structural layout information from reference images or text prompts using Claude analysis with variant generation or refinement mode",
+        "arguments": "[-y|--yes] [--design-id <id>] [--session <id>] [--images \"<glob>\"] [--prompt \"<desc>\"] [--targets \"<list>\"] [--variants <count>] [--device-type <desktop|mobile|tablet|responsive>] [--interactive] [--refine]",
+        "category": "workflow",
+        "subcategory": "ui-design",
+        "usage_scenario": "general",
+        "difficulty": "Intermediate",
+        "source": "../../../commands/workflow/ui-design/layout-extract.md"
+      },
+      {
+        "name": "workflow:ui-design:reference-page-generator",
+        "command": "/workflow:ui-design:reference-page-generator",
+        "description": "Generate multi-component reference pages and documentation from design run extraction",
+        "arguments": "[--design-run <path>] [--package-name <name>] [--output-dir <path>]",
+        "category": "workflow",
+        "subcategory": "ui-design",
+        "usage_scenario": "planning",
+        "difficulty": "Intermediate",
+        "source": "../../../commands/workflow/ui-design/reference-page-generator.md"
+      },
+      {
+        "name": "style-extract",
+        "command": "/workflow:ui-design:style-extract",
+        "description": "Extract design style from reference images or text prompts using Claude analysis with variant generation or refinement mode",
+        "arguments": "[-y|--yes] [--design-id <id>] [--session <id>] [--images \"<glob>\"] [--prompt \"<desc>\"] [--variants <count>] [--interactive] [--refine]",
+        "category": "workflow",
+        "subcategory": "ui-design",
+        "usage_scenario": "general",
+        "difficulty": "Intermediate",
+        "source": "../../../commands/workflow/ui-design/style-extract.md"
+      }
+    ]
+  }
+}

.claude/skills/ccw-help/index/by-use-case.json

@@ -0,0 +1,819 @@
+{
+  "general": [
+    {
+      "name": "ccw-coordinator",
+      "command": "/ccw-coordinator",
+      "description": "Command orchestration tool - analyze requirements, recommend chain, execute sequentially with state persistence",
+      "arguments": "[task description]",
+      "category": "general",
+      "subcategory": null,
+      "usage_scenario": "general",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/ccw-coordinator.md"
+    },
+    {
+      "name": "ccw-debug",
+      "command": "/ccw-debug",
+      "description": "Aggregated debug command - combines debugging diagnostics and test verification in a synergistic workflow supporting cli-quick / debug-first / test-first / bidirectional-verification modes",
+      "arguments": "[--mode cli|debug|test|bidirectional] [--yes|-y] [--hotfix] \\\"bug description or error message\\",
+      "category": "general",
+      "subcategory": null,
+      "usage_scenario": "general",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/ccw-debug.md"
+    },
+    {
+      "name": "ccw",
+      "command": "/ccw",
+      "description": "Main workflow orchestrator - analyze intent, select workflow, execute command chain in main process",
+      "arguments": "\\\"task description\\",
+      "category": "general",
+      "subcategory": null,
+      "usage_scenario": "general",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/ccw.md"
+    },
+    {
+      "name": "cli-init",
+      "command": "/cli:cli-init",
+      "description": "Generate .gemini/ and .qwen/ config directories with settings.json and ignore files based on workspace technology detection",
+      "arguments": "[--tool gemini|qwen|all] [--output path] [--preview]",
+      "category": "cli",
+      "subcategory": null,
+      "usage_scenario": "general",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/cli/cli-init.md"
+    },
+    {
+      "name": "issue:discover-by-prompt",
+      "command": "/issue:discover-by-prompt",
+      "description": "Discover issues from user prompt with Gemini-planned iterative multi-agent exploration. Uses ACE semantic search for context gathering and supports cross-module comparison (e.g., frontend vs backend API contracts).",
+      "arguments": "[-y|--yes] <prompt> [--scope=src/**] [--depth=standard|deep] [--max-iterations=5]",
+      "category": "issue",
+      "subcategory": null,
+      "usage_scenario": "general",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/issue/discover-by-prompt.md"
+    },
+    {
+      "name": "issue:discover",
+      "command": "/issue:discover",
+      "description": "Discover potential issues from multiple perspectives (bug, UX, test, quality, security, performance, maintainability, best-practices) using CLI explore. Supports Exa external research for security and best-practices perspectives.",
+      "arguments": "[-y|--yes] <path-pattern> [--perspectives=bug,ux,...] [--external]",
+      "category": "issue",
+      "subcategory": null,
+      "usage_scenario": "general",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/issue/discover.md"
+    },
+    {
+      "name": "new",
+      "command": "/issue:new",
+      "description": "Create structured issue from GitHub URL or text description",
+      "arguments": "[-y|--yes] <github-url | text-description> [--priority 1-5]",
+      "category": "issue",
+      "subcategory": null,
+      "usage_scenario": "general",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/issue/new.md"
+    },
+    {
+      "name": "queue",
+      "command": "/issue:queue",
+      "description": "Form execution queue from bound solutions using issue-queue-agent (solution-level)",
+      "arguments": "[-y|--yes] [--queues <n>] [--issue <id>]",
+      "category": "issue",
+      "subcategory": null,
+      "usage_scenario": "general",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/issue/queue.md"
+    },
+    {
+      "name": "compact",
+      "command": "/memory:compact",
+      "description": "Compact current session memory into structured text for session recovery, extracting objective/plan/files/decisions/constraints/state, and save via MCP core_memory tool",
+      "arguments": "[optional: session description]",
+      "category": "memory",
+      "subcategory": null,
+      "usage_scenario": "general",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/memory/compact.md"
+    },
+    {
+      "name": "load",
+      "command": "/memory:load",
+      "description": "Delegate to universal-executor agent to analyze project via Gemini/Qwen CLI and return JSON core content package for task context",
+      "arguments": "[--tool gemini|qwen] \\\"task context description\\",
+      "category": "memory",
+      "subcategory": null,
+      "usage_scenario": "general",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/memory/load.md"
+    },
+    {
+      "name": "tips",
+      "command": "/memory:tips",
+      "description": "Quick note-taking command to capture ideas, snippets, reminders, and insights for later reference",
+      "arguments": "<note content> [--tag <tag1,tag2>] [--context <context>]",
+      "category": "memory",
+      "subcategory": null,
+      "usage_scenario": "general",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/memory/tips.md"
+    },
+    {
+      "name": "update-full",
+      "command": "/memory:update-full",
+      "description": "Update all CLAUDE.md files using layer-based execution (Layer 3→1) with batched agents (4 modules/agent) and gemini→qwen→codex fallback, <20 modules uses direct parallel",
+      "arguments": "[--tool gemini|qwen|codex] [--path <directory>]",
+      "category": "memory",
+      "subcategory": null,
+      "usage_scenario": "general",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/memory/update-full.md"
+    },
+    {
+      "name": "update-related",
+      "command": "/memory:update-related",
+      "description": "Update CLAUDE.md for git-changed modules using batched agent execution (4 modules/agent) with gemini→qwen→codex fallback, <15 modules uses direct execution",
+      "arguments": "[--tool gemini|qwen|codex]",
+      "category": "memory",
+      "subcategory": null,
+      "usage_scenario": "general",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/memory/update-related.md"
+    },
+    {
+      "name": "ccw view",
+      "command": "/ccw view",
+      "description": "Dashboard - Open CCW workflow dashboard for managing tasks and sessions",
+      "arguments": "",
+      "category": "general",
+      "subcategory": null,
+      "usage_scenario": "general",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/view.md"
+    },
+    {
+      "name": "artifacts",
+      "command": "/workflow:brainstorm:artifacts",
+      "description": "Interactive clarification generating confirmed guidance specification through role-based analysis and synthesis",
+      "arguments": "[-y|--yes] topic or challenge description [--count N]",
+      "category": "workflow",
+      "subcategory": "brainstorm",
+      "usage_scenario": "general",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/workflow/brainstorm/artifacts.md"
+    },
+    {
+      "name": "auto-parallel",
+      "command": "/workflow:brainstorm:auto-parallel",
+      "description": "Parallel brainstorming automation with dynamic role selection and concurrent execution across multiple perspectives",
+      "arguments": "[-y|--yes] topic or challenge description [--count N]",
+      "category": "workflow",
+      "subcategory": "brainstorm",
+      "usage_scenario": "general",
+      "difficulty": "Advanced",
+      "source": "../../../commands/workflow/brainstorm/auto-parallel.md"
+    },
+    {
+      "name": "role-analysis",
+      "command": "/workflow:brainstorm:role-analysis",
+      "description": "Unified role-specific analysis generation with interactive context gathering and incremental updates",
+      "arguments": "[role-name] [--session session-id] [--update] [--include-questions] [--skip-questions]",
+      "category": "workflow",
+      "subcategory": "brainstorm",
+      "usage_scenario": "general",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/workflow/brainstorm/role-analysis.md"
+    },
+    {
+      "name": "synthesis",
+      "command": "/workflow:brainstorm:synthesis",
+      "description": "Clarify and refine role analyses through intelligent Q&A and targeted updates with synthesis agent",
+      "arguments": "[-y|--yes] [optional: --session session-id]",
+      "category": "workflow",
+      "subcategory": "brainstorm",
+      "usage_scenario": "general",
+      "difficulty": "Advanced",
+      "source": "../../../commands/workflow/brainstorm/synthesis.md"
+    },
+    {
+      "name": "clean",
+      "command": "/workflow:clean",
+      "description": "Intelligent code cleanup with mainline detection, stale artifact discovery, and safe execution",
+      "arguments": "[-y|--yes] [--dry-run] [\\\"focus area\\\"]",
+      "category": "workflow",
+      "subcategory": null,
+      "usage_scenario": "general",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/workflow/clean.md"
+    },
+    {
+      "name": "debug-with-file",
+      "command": "/workflow:debug-with-file",
+      "description": "Interactive hypothesis-driven debugging with documented exploration, understanding evolution, and Gemini-assisted correction",
+      "arguments": "[-y|--yes] \\\"bug description or error message\\",
+      "category": "workflow",
+      "subcategory": null,
+      "usage_scenario": "general",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/workflow/debug-with-file.md"
+    },
+    {
+      "name": "init",
+      "command": "/workflow:init",
+      "description": "Initialize project-level state with intelligent project analysis using cli-explore-agent",
+      "arguments": "[--regenerate]",
+      "category": "workflow",
+      "subcategory": null,
+      "usage_scenario": "general",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/workflow/init.md"
+    },
+    {
+      "name": "lite-fix",
+      "command": "/workflow:lite-fix",
+      "description": "Lightweight bug diagnosis and fix workflow with intelligent severity assessment and optional hotfix mode for production incidents",
+      "arguments": "[-y|--yes] [--hotfix] \\\"bug description or issue reference\\",
+      "category": "workflow",
+      "subcategory": null,
+      "usage_scenario": "general",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/workflow/lite-fix.md"
+    },
+    {
+      "name": "workflow:lite-lite-lite",
+      "command": "/workflow:lite-lite-lite",
+      "description": "Ultra-lightweight multi-tool analysis and direct execution. No artifacts for simple tasks; auto-creates planning docs in .workflow/.scratchpad/ for complex tasks. Auto tool selection based on task analysis, user-driven iteration via AskUser.",
+      "arguments": "[-y|--yes] <task description>",
+      "category": "workflow",
+      "subcategory": null,
+      "usage_scenario": "general",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/workflow/lite-lite-lite.md"
+    },
+    {
+      "name": "list",
+      "command": "/workflow:session:list",
+      "description": "List all workflow sessions with status filtering, shows session metadata and progress information",
+      "arguments": "",
+      "category": "workflow",
+      "subcategory": "session",
+      "usage_scenario": "general",
+      "difficulty": "Beginner",
+      "source": "../../../commands/workflow/session/list.md"
+    },
+    {
+      "name": "solidify",
+      "command": "/workflow:session:solidify",
+      "description": "Crystallize session learnings and user-defined constraints into permanent project guidelines",
+      "arguments": "[-y|--yes] [--type <convention|constraint|learning>] [--category <category>] \\\"rule or insight\\",
+      "category": "workflow",
+      "subcategory": "session",
+      "usage_scenario": "general",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/workflow/session/solidify.md"
+    },
+    {
+      "name": "start",
+      "command": "/workflow:session:start",
+      "description": "Discover existing sessions or start new workflow session with intelligent session management and conflict detection",
+      "arguments": "[--type <workflow|review|tdd|test|docs>] [--auto|--new] [optional: task description for new session]",
+      "category": "workflow",
+      "subcategory": "session",
+      "usage_scenario": "general",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/workflow/session/start.md"
+    },
+    {
+      "name": "conflict-resolution",
+      "command": "/workflow:tools:conflict-resolution",
+      "description": "Detect and resolve conflicts between plan and existing codebase using CLI-powered analysis with Gemini/Qwen",
+      "arguments": "[-y|--yes] --session WFS-session-id --context path/to/context-package.json",
+      "category": "workflow",
+      "subcategory": "tools",
+      "usage_scenario": "general",
+      "difficulty": "Advanced",
+      "source": "../../../commands/workflow/tools/conflict-resolution.md"
+    },
+    {
+      "name": "gather",
+      "command": "/workflow:tools:gather",
+      "description": "Intelligently collect project context using context-search-agent based on task description, packages into standardized JSON",
+      "arguments": "--session WFS-session-id \\\"task description\\",
+      "category": "workflow",
+      "subcategory": "tools",
+      "usage_scenario": "general",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/workflow/tools/context-gather.md"
+    },
+    {
+      "name": "animation-extract",
+      "command": "/workflow:ui-design:animation-extract",
+      "description": "Extract animation and transition patterns from prompt inference and image references for design system documentation",
+      "arguments": "[-y|--yes] [--design-id <id>] [--session <id>] [--images \"<glob>\"] [--focus \"<types>\"] [--interactive] [--refine]",
+      "category": "workflow",
+      "subcategory": "ui-design",
+      "usage_scenario": "general",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/workflow/ui-design/animation-extract.md"
+    },
+    {
+      "name": "explore-auto",
+      "command": "/workflow:ui-design:explore-auto",
+      "description": "Interactive exploratory UI design workflow with style-centric batch generation, creates design variants from prompts/images with parallel execution and user selection",
+      "arguments": "[--input \"<value>\"] [--targets \"<list>\"] [--target-type \"page|component\"] [--session <id>] [--style-variants <count>] [--layout-variants <count>]",
+      "category": "workflow",
+      "subcategory": "ui-design",
+      "usage_scenario": "general",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/workflow/ui-design/explore-auto.md"
+    },
+    {
+      "name": "imitate-auto",
+      "command": "/workflow:ui-design:imitate-auto",
+      "description": "UI design workflow with direct code/image input for design token extraction and prototype generation",
+      "arguments": "[--input \"<value>\"] [--session <id>]",
+      "category": "workflow",
+      "subcategory": "ui-design",
+      "usage_scenario": "general",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/workflow/ui-design/imitate-auto.md"
+    },
+    {
+      "name": "layout-extract",
+      "command": "/workflow:ui-design:layout-extract",
+      "description": "Extract structural layout information from reference images or text prompts using Claude analysis with variant generation or refinement mode",
+      "arguments": "[-y|--yes] [--design-id <id>] [--session <id>] [--images \"<glob>\"] [--prompt \"<desc>\"] [--targets \"<list>\"] [--variants <count>] [--device-type <desktop|mobile|tablet|responsive>] [--interactive] [--refine]",
+      "category": "workflow",
+      "subcategory": "ui-design",
+      "usage_scenario": "general",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/workflow/ui-design/layout-extract.md"
+    },
+    {
+      "name": "style-extract",
+      "command": "/workflow:ui-design:style-extract",
+      "description": "Extract design style from reference images or text prompts using Claude analysis with variant generation or refinement mode",
+      "arguments": "[-y|--yes] [--design-id <id>] [--session <id>] [--images \"<glob>\"] [--prompt \"<desc>\"] [--variants <count>] [--interactive] [--refine]",
+      "category": "workflow",
+      "subcategory": "ui-design",
+      "usage_scenario": "general",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/workflow/ui-design/style-extract.md"
+    }
+  ],
+  "analysis": [
+    {
+      "name": "codex-review",
+      "command": "/cli:codex-review",
+      "description": "Interactive code review using Codex CLI via ccw endpoint with configurable review target, model, and custom instructions",
+      "arguments": "[--uncommitted|--base <branch>|--commit <sha>] [--model <model>] [--title <title>] [prompt]",
+      "category": "cli",
+      "subcategory": null,
+      "usage_scenario": "analysis",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/cli/codex-review.md"
+    },
+    {
+      "name": "analyze-with-file",
+      "command": "/workflow:analyze-with-file",
+      "description": "Interactive collaborative analysis with documented discussions, CLI-assisted exploration, and evolving understanding",
+      "arguments": "[-y|--yes] [-c|--continue] \\\"topic or question\\",
+      "category": "workflow",
+      "subcategory": null,
+      "usage_scenario": "analysis",
+      "difficulty": "Beginner",
+      "source": "../../../commands/workflow/analyze-with-file.md"
+    },
+    {
+      "name": "review-cycle-fix",
+      "command": "/workflow:review-cycle-fix",
+      "description": "Automated fixing of code review findings with AI-powered planning and coordinated execution. Uses intelligent grouping, multi-stage timeline coordination, and test-driven verification.",
+      "arguments": "<export-file|review-dir> [--resume] [--max-iterations=N]",
+      "category": "workflow",
+      "subcategory": null,
+      "usage_scenario": "analysis",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/workflow/review-cycle-fix.md"
+    },
+    {
+      "name": "review-module-cycle",
+      "command": "/workflow:review-module-cycle",
+      "description": "Independent multi-dimensional code review for specified modules/files. Analyzes specific code paths across 7 dimensions with hybrid parallel-iterative execution, independent of workflow sessions.",
+      "arguments": "<path-pattern> [--dimensions=security,architecture,...] [--max-iterations=N]",
+      "category": "workflow",
+      "subcategory": null,
+      "usage_scenario": "analysis",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/workflow/review-module-cycle.md"
+    },
+    {
+      "name": "review",
+      "command": "/workflow:review",
+      "description": "Post-implementation review with specialized types (security/architecture/action-items/quality) using analysis agents and Gemini",
+      "arguments": "[--type=security|architecture|action-items|quality] [--archived] [optional: session-id]",
+      "category": "workflow",
+      "subcategory": null,
+      "usage_scenario": "analysis",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/workflow/review.md"
+    }
+  ],
+  "planning": [
+    {
+      "name": "convert-to-plan",
+      "command": "/issue:convert-to-plan",
+      "description": "Convert planning artifacts (lite-plan, workflow session, markdown) to issue solutions",
+      "arguments": "[-y|--yes] [--issue <id>] [--supplement] <SOURCE>",
+      "category": "issue",
+      "subcategory": null,
+      "usage_scenario": "planning",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/issue/convert-to-plan.md"
+    },
+    {
+      "name": "from-brainstorm",
+      "command": "/issue:from-brainstorm",
+      "description": "Convert brainstorm session ideas into issue with executable solution for parallel-dev-cycle",
+      "arguments": "SESSION=\\\"<session-id>\\\" [--idea=<index>] [--auto] [-y|--yes]",
+      "category": "issue",
+      "subcategory": null,
+      "usage_scenario": "planning",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/issue/from-brainstorm.md"
+    },
+    {
+      "name": "plan",
+      "command": "/issue:plan",
+      "description": "Batch plan issue resolution using issue-plan-agent (explore + plan closed-loop)",
+      "arguments": "[-y|--yes] --all-pending <issue-id>[,<issue-id>,...] [--batch-size 3]",
+      "category": "issue",
+      "subcategory": null,
+      "usage_scenario": "planning",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/issue/plan.md"
+    },
+    {
+      "name": "brainstorm-with-file",
+      "command": "/workflow:brainstorm-with-file",
+      "description": "Interactive brainstorming with multi-CLI collaboration, idea expansion, and documented thought evolution",
+      "arguments": "[-y|--yes] [-c|--continue] [-m|--mode creative|structured] \\\"idea or topic\\",
+      "category": "workflow",
+      "subcategory": null,
+      "usage_scenario": "planning",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/workflow/brainstorm-with-file.md"
+    },
+    {
+      "name": "lite-plan",
+      "command": "/workflow:lite-plan",
+      "description": "Lightweight interactive planning workflow with in-memory planning, code exploration, and execution execute to lite-execute after user confirmation",
+      "arguments": "[-y|--yes] [-e|--explore] \\\"task description\\\"|file.md",
+      "category": "workflow",
+      "subcategory": null,
+      "usage_scenario": "planning",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/workflow/lite-plan.md"
+    },
+    {
+      "name": "workflow:multi-cli-plan",
+      "command": "/workflow:multi-cli-plan",
+      "description": "Multi-CLI collaborative planning workflow with ACE context gathering and iterative cross-verification. Uses cli-discuss-agent for Gemini+Codex+Claude analysis to converge on optimal execution plan.",
+      "arguments": "[-y|--yes] <task description> [--max-rounds=3] [--tools=gemini,codex] [--mode=parallel|serial]",
+      "category": "workflow",
+      "subcategory": null,
+      "usage_scenario": "planning",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/workflow/multi-cli-plan.md"
+    },
+    {
+      "name": "plan-verify",
+      "command": "/workflow:plan-verify",
+      "description": "Perform READ-ONLY verification analysis between IMPL_PLAN.md, task JSONs, and brainstorming artifacts. Generates structured report with quality gate recommendation. Does NOT modify any files.",
+      "arguments": "[optional: --session session-id]",
+      "category": "workflow",
+      "subcategory": null,
+      "usage_scenario": "planning",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/workflow/plan-verify.md"
+    },
+    {
+      "name": "plan",
+      "command": "/workflow:plan",
+      "description": "5-phase planning workflow with action-planning-agent task generation, outputs IMPL_PLAN.md and task JSONs",
+      "arguments": "[-y|--yes] \\\"text description\\\"|file.md",
+      "category": "workflow",
+      "subcategory": null,
+      "usage_scenario": "planning",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/workflow/plan.md"
+    },
+    {
+      "name": "replan",
+      "command": "/workflow:replan",
+      "description": "Interactive workflow replanning with session-level artifact updates and boundary clarification through guided questioning",
+      "arguments": "[-y|--yes] [--session session-id] [task-id] \\\"requirements\\\"|file.md [--interactive]",
+      "category": "workflow",
+      "subcategory": null,
+      "usage_scenario": "planning",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/workflow/replan.md"
+    },
+    {
+      "name": "tdd-plan",
+      "command": "/workflow:tdd-plan",
+      "description": "TDD workflow planning with Red-Green-Refactor task chain generation, test-first development structure, and cycle tracking",
+      "arguments": "\\\"feature description\\\"|file.md",
+      "category": "workflow",
+      "subcategory": null,
+      "usage_scenario": "planning",
+      "difficulty": "Advanced",
+      "source": "../../../commands/workflow/tdd-plan.md"
+    },
+    {
+      "name": "workflow:ui-design:codify-style",
+      "command": "/workflow:ui-design:codify-style",
+      "description": "Orchestrator to extract styles from code and generate shareable reference package with preview (automatic file discovery)",
+      "arguments": "<path> [--package-name <name>] [--output-dir <path>] [--overwrite]",
+      "category": "workflow",
+      "subcategory": "ui-design",
+      "usage_scenario": "planning",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/workflow/ui-design/codify-style.md"
+    },
+    {
+      "name": "design-sync",
+      "command": "/workflow:ui-design:design-sync",
+      "description": "Synchronize finalized design system references to brainstorming artifacts, preparing them for /workflow:plan consumption",
+      "arguments": "--session <session_id> [--selected-prototypes \"<list>\"]",
+      "category": "workflow",
+      "subcategory": "ui-design",
+      "usage_scenario": "planning",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/workflow/ui-design/design-sync.md"
+    },
+    {
+      "name": "workflow:ui-design:import-from-code",
+      "command": "/workflow:ui-design:import-from-code",
+      "description": "Import design system from code files (CSS/JS/HTML/SCSS) with automatic file discovery and parallel agent analysis",
+      "arguments": "[--design-id <id>] [--session <id>] [--source <path>]",
+      "category": "workflow",
+      "subcategory": "ui-design",
+      "usage_scenario": "planning",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/workflow/ui-design/import-from-code.md"
+    },
+    {
+      "name": "workflow:ui-design:reference-page-generator",
+      "command": "/workflow:ui-design:reference-page-generator",
+      "description": "Generate multi-component reference pages and documentation from design run extraction",
+      "arguments": "[--design-run <path>] [--package-name <name>] [--output-dir <path>]",
+      "category": "workflow",
+      "subcategory": "ui-design",
+      "usage_scenario": "planning",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/workflow/ui-design/reference-page-generator.md"
+    }
+  ],
+  "implementation": [
+    {
+      "name": "execute",
+      "command": "/issue:execute",
+      "description": "Execute queue with DAG-based parallel orchestration (one commit per solution)",
+      "arguments": "[-y|--yes] --queue <queue-id> [--worktree [<existing-path>]]",
+      "category": "issue",
+      "subcategory": null,
+      "usage_scenario": "implementation",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/issue/execute.md"
+    },
+    {
+      "name": "execute",
+      "command": "/workflow:execute",
+      "description": "Coordinate agent execution for workflow tasks with automatic session discovery, parallel task processing, and status tracking",
+      "arguments": "[-y|--yes] [--resume-session=\\\"session-id\\\"]",
+      "category": "workflow",
+      "subcategory": null,
+      "usage_scenario": "implementation",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/workflow/execute.md"
+    },
+    {
+      "name": "lite-execute",
+      "command": "/workflow:lite-execute",
+      "description": "Execute tasks based on in-memory plan, prompt description, or file content",
+      "arguments": "[-y|--yes] [--in-memory] [\\\"task description\\\"|file-path]",
+      "category": "workflow",
+      "subcategory": null,
+      "usage_scenario": "implementation",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/workflow/lite-execute.md"
+    },
+    {
+      "name": "test-cycle-execute",
+      "command": "/workflow:test-cycle-execute",
+      "description": "Execute test-fix workflow with dynamic task generation and iterative fix cycles until test pass rate >= 95% or max iterations reached. Uses @cli-planning-agent for failure analysis and task generation.",
+      "arguments": "[--resume-session=\\\"session-id\\\"] [--max-iterations=N]",
+      "category": "workflow",
+      "subcategory": null,
+      "usage_scenario": "implementation",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/workflow/test-cycle-execute.md"
+    },
+    {
+      "name": "task-generate-agent",
+      "command": "/workflow:tools:task-generate-agent",
+      "description": "Generate implementation plan documents (IMPL_PLAN.md, task JSONs, TODO_LIST.md) using action-planning-agent - produces planning artifacts, does NOT execute code implementation",
+      "arguments": "[-y|--yes] --session WFS-session-id",
+      "category": "workflow",
+      "subcategory": "tools",
+      "usage_scenario": "implementation",
+      "difficulty": "Advanced",
+      "source": "../../../commands/workflow/tools/task-generate-agent.md"
+    },
+    {
+      "name": "task-generate-tdd",
+      "command": "/workflow:tools:task-generate-tdd",
+      "description": "Autonomous TDD task generation using action-planning-agent with Red-Green-Refactor cycles, test-first structure, and cycle validation",
+      "arguments": "[-y|--yes] --session WFS-session-id",
+      "category": "workflow",
+      "subcategory": "tools",
+      "usage_scenario": "implementation",
+      "difficulty": "Advanced",
+      "source": "../../../commands/workflow/tools/task-generate-tdd.md"
+    },
+    {
+      "name": "test-task-generate",
+      "command": "/workflow:tools:test-task-generate",
+      "description": "Generate test planning documents (IMPL_PLAN.md, test task JSONs, TODO_LIST.md) using action-planning-agent - produces test planning artifacts, does NOT execute tests",
+      "arguments": "--session WFS-test-session-id",
+      "category": "workflow",
+      "subcategory": "tools",
+      "usage_scenario": "implementation",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/workflow/tools/test-task-generate.md"
+    },
+    {
+      "name": "generate",
+      "command": "/workflow:ui-design:generate",
+      "description": "Assemble UI prototypes by combining layout templates with design tokens (default animation support), pure assembler without new content generation",
+      "arguments": "[--design-id <id>] [--session <id>]",
+      "category": "workflow",
+      "subcategory": "ui-design",
+      "usage_scenario": "implementation",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/workflow/ui-design/generate.md"
+    },
+    {
+      "name": "unified-execute-with-file",
+      "command": "/workflow:unified-execute-with-file",
+      "description": "Universal execution engine for consuming any planning/brainstorm/analysis output with minimal progress tracking, multi-agent coordination, and incremental execution",
+      "arguments": "[-y|--yes] [-p|--plan <path>] [-m|--mode sequential|parallel] [\\\"execution context or task name\\\"]",
+      "category": "workflow",
+      "subcategory": null,
+      "usage_scenario": "implementation",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/workflow/unified-execute-with-file.md"
+    }
+  ],
+  "documentation": [
+    {
+      "name": "docs-full-cli",
+      "command": "/memory:docs-full-cli",
+      "description": "Generate full project documentation using CLI execution (Layer 3→1) with batched agents (4 modules/agent) and gemini→qwen→codex fallback, <20 modules uses direct parallel",
+      "arguments": "[path] [--tool <gemini|qwen|codex>]",
+      "category": "memory",
+      "subcategory": null,
+      "usage_scenario": "documentation",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/memory/docs-full-cli.md"
+    },
+    {
+      "name": "docs-related-cli",
+      "command": "/memory:docs-related-cli",
+      "description": "Generate/update documentation for git-changed modules using CLI execution with batched agents (4 modules/agent) and gemini→qwen→codex fallback, <15 modules uses direct parallel",
+      "arguments": "[--tool <gemini|qwen|codex>]",
+      "category": "memory",
+      "subcategory": null,
+      "usage_scenario": "documentation",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/memory/docs-related-cli.md"
+    },
+    {
+      "name": "style-skill-memory",
+      "command": "/memory:style-skill-memory",
+      "description": "Generate SKILL memory package from style reference for easy loading and consistent design system usage",
+      "arguments": "[package-name] [--regenerate]",
+      "category": "memory",
+      "subcategory": null,
+      "usage_scenario": "documentation",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/memory/style-skill-memory.md"
+    }
+  ],
+  "session-management": [
+    {
+      "name": "review-session-cycle",
+      "command": "/workflow:review-session-cycle",
+      "description": "Session-based comprehensive multi-dimensional code review. Analyzes git changes from workflow session across 7 dimensions with hybrid parallel-iterative execution, aggregates findings, and performs focused deep-dives on critical issues until quality gates met.",
+      "arguments": "[session-id] [--dimensions=security,architecture,...] [--max-iterations=N]",
+      "category": "workflow",
+      "subcategory": null,
+      "usage_scenario": "session-management",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/workflow/review-session-cycle.md"
+    },
+    {
+      "name": "complete",
+      "command": "/workflow:session:complete",
+      "description": "Mark active workflow session as complete, archive with lessons learned, update manifest, remove active flag",
+      "arguments": "[-y|--yes] [--detailed]",
+      "category": "workflow",
+      "subcategory": "session",
+      "usage_scenario": "session-management",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/workflow/session/complete.md"
+    },
+    {
+      "name": "resume",
+      "command": "/workflow:session:resume",
+      "description": "Resume the most recently paused workflow session with automatic session discovery and status update",
+      "arguments": "",
+      "category": "workflow",
+      "subcategory": "session",
+      "usage_scenario": "session-management",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/workflow/session/resume.md"
+    }
+  ],
+  "testing": [
+    {
+      "name": "tdd-verify",
+      "command": "/workflow:tdd-verify",
+      "description": "Verify TDD workflow compliance against Red-Green-Refactor cycles. Generates quality report with coverage analysis and quality gate recommendation. Orchestrates sub-commands for comprehensive validation.",
+      "arguments": "[optional: --session WFS-session-id]",
+      "category": "workflow",
+      "subcategory": null,
+      "usage_scenario": "testing",
+      "difficulty": "Advanced",
+      "source": "../../../commands/workflow/tdd-verify.md"
+    },
+    {
+      "name": "test-fix-gen",
+      "command": "/workflow:test-fix-gen",
+      "description": "Create test-fix workflow session from session ID, description, or file path with test strategy generation and task planning",
+      "arguments": "(source-session-id | \\\"feature description\\\" | /path/to/file.md)",
+      "category": "workflow",
+      "subcategory": null,
+      "usage_scenario": "testing",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/workflow/test-fix-gen.md"
+    },
+    {
+      "name": "test-gen",
+      "command": "/workflow:test-gen",
+      "description": "Create independent test-fix workflow session from completed implementation session, analyzes code to generate test tasks",
+      "arguments": "source-session-id",
+      "category": "workflow",
+      "subcategory": null,
+      "usage_scenario": "testing",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/workflow/test-gen.md"
+    },
+    {
+      "name": "tdd-coverage-analysis",
+      "command": "/workflow:tools:tdd-coverage-analysis",
+      "description": "Analyze test coverage and TDD cycle execution with Red-Green-Refactor compliance verification",
+      "arguments": "--session WFS-session-id",
+      "category": "workflow",
+      "subcategory": "tools",
+      "usage_scenario": "testing",
+      "difficulty": "Advanced",
+      "source": "../../../commands/workflow/tools/tdd-coverage-analysis.md"
+    },
+    {
+      "name": "test-concept-enhanced",
+      "command": "/workflow:tools:test-concept-enhanced",
+      "description": "Coordinate test analysis workflow using cli-execution-agent to generate test strategy via Gemini",
+      "arguments": "--session WFS-test-session-id --context path/to/test-context-package.json",
+      "category": "workflow",
+      "subcategory": "tools",
+      "usage_scenario": "testing",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/workflow/tools/test-concept-enhanced.md"
+    },
+    {
+      "name": "test-context-gather",
+      "command": "/workflow:tools:test-context-gather",
+      "description": "Collect test coverage context using test-context-search-agent and package into standardized test-context JSON",
+      "arguments": "--session WFS-test-session-id",
+      "category": "workflow",
+      "subcategory": "tools",
+      "usage_scenario": "testing",
+      "difficulty": "Intermediate",
+      "source": "../../../commands/workflow/tools/test-context-gather.md"
+    }
+  ]
+}

.claude/skills/ccw-help/index/command-relationships.json

@@ -0,0 +1,160 @@
+{
+  "workflow:plan": {
+    "calls_internally": [
+      "workflow:session:start",
+      "workflow:tools:context-gather",
+      "workflow:tools:conflict-resolution",
+      "workflow:tools:task-generate-agent"
+    ],
+    "next_steps": [
+      "workflow:plan-verify",
+      "workflow:status",
+      "workflow:execute"
+    ],
+    "alternatives": [
+      "workflow:tdd-plan"
+    ],
+    "prerequisites": []
+  },
+  "workflow:tdd-plan": {
+    "calls_internally": [
+      "workflow:session:start",
+      "workflow:tools:context-gather",
+      "workflow:tools:task-generate-tdd"
+    ],
+    "next_steps": [
+      "workflow:tdd-verify",
+      "workflow:status",
+      "workflow:execute"
+    ],
+    "alternatives": [
+      "workflow:plan"
+    ],
+    "prerequisites": []
+  },
+  "workflow:execute": {
+    "prerequisites": [
+      "workflow:plan",
+      "workflow:tdd-plan"
+    ],
+    "related": [
+      "workflow:status",
+      "workflow:resume"
+    ],
+    "next_steps": [
+      "workflow:review",
+      "workflow:tdd-verify"
+    ]
+  },
+  "workflow:plan-verify": {
+    "prerequisites": [
+      "workflow:plan"
+    ],
+    "next_steps": [
+      "workflow:execute"
+    ],
+    "related": [
+      "workflow:status"
+    ]
+  },
+  "workflow:tdd-verify": {
+    "prerequisites": [
+      "workflow:execute"
+    ],
+    "related": [
+      "workflow:tools:tdd-coverage-analysis"
+    ]
+  },
+  "workflow:session:start": {
+    "next_steps": [
+      "workflow:plan",
+      "workflow:execute"
+    ],
+    "related": [
+      "workflow:session:list",
+      "workflow:session:resume"
+    ]
+  },
+  "workflow:session:resume": {
+    "alternatives": [
+      "workflow:resume"
+    ],
+    "related": [
+      "workflow:session:list",
+      "workflow:status"
+    ]
+  },
+  "workflow:lite-plan": {
+    "calls_internally": [
+      "workflow:lite-execute"
+    ],
+    "next_steps": [
+      "workflow:lite-execute",
+      "workflow:status"
+    ],
+    "alternatives": [
+      "workflow:plan"
+    ],
+    "prerequisites": []
+  },
+  "workflow:lite-fix": {
+    "next_steps": [
+      "workflow:lite-execute",
+      "workflow:status"
+    ],
+    "alternatives": [
+      "workflow:lite-plan"
+    ],
+    "related": [
+      "workflow:test-cycle-execute"
+    ]
+  },
+  "workflow:lite-execute": {
+    "prerequisites": [
+      "workflow:lite-plan",
+      "workflow:lite-fix"
+    ],
+    "related": [
+      "workflow:execute",
+      "workflow:status"
+    ]
+  },
+  "workflow:review-session-cycle": {
+    "prerequisites": [
+      "workflow:execute"
+    ],
+    "next_steps": [
+      "workflow:review-fix"
+    ],
+    "related": [
+      "workflow:review-module-cycle"
+    ]
+  },
+  "workflow:review-fix": {
+    "prerequisites": [
+      "workflow:review-module-cycle",
+      "workflow:review-session-cycle"
+    ],
+    "related": [
+      "workflow:test-cycle-execute"
+    ]
+  },
+  "memory:docs": {
+    "calls_internally": [
+      "workflow:session:start",
+      "workflow:tools:context-gather"
+    ],
+    "next_steps": [
+      "workflow:execute"
+    ]
+  },
+  "memory:skill-memory": {
+    "next_steps": [
+      "workflow:plan",
+      "cli:analyze"
+    ],
+    "related": [
+      "memory:load-skill-memory"
+    ]
+  }
+}

.claude/skills/ccw-help/index/essential-commands.json

@@ -0,0 +1,90 @@
+[
+  {
+    "name": "lite-plan",
+    "command": "/workflow:lite-plan",
+    "description": "Lightweight interactive planning workflow with in-memory planning, code exploration, and execution execute to lite-execute after user confirmation",
+    "arguments": "[-y|--yes] [-e|--explore] \\\"task description\\\"|file.md",
+    "category": "workflow",
+    "subcategory": null,
+    "usage_scenario": "planning",
+    "difficulty": "Intermediate",
+    "source": "../../../commands/workflow/lite-plan.md"
+  },
+  {
+    "name": "lite-fix",
+    "command": "/workflow:lite-fix",
+    "description": "Lightweight bug diagnosis and fix workflow with intelligent severity assessment and optional hotfix mode for production incidents",
+    "arguments": "[-y|--yes] [--hotfix] \\\"bug description or issue reference\\",
+    "category": "workflow",
+    "subcategory": null,
+    "usage_scenario": "general",
+    "difficulty": "Intermediate",
+    "source": "../../../commands/workflow/lite-fix.md"
+  },
+  {
+    "name": "plan",
+    "command": "/workflow:plan",
+    "description": "5-phase planning workflow with action-planning-agent task generation, outputs IMPL_PLAN.md and task JSONs",
+    "arguments": "[-y|--yes] \\\"text description\\\"|file.md",
+    "category": "workflow",
+    "subcategory": null,
+    "usage_scenario": "planning",
+    "difficulty": "Intermediate",
+    "source": "../../../commands/workflow/plan.md"
+  },
+  {
+    "name": "execute",
+    "command": "/workflow:execute",
+    "description": "Coordinate agent execution for workflow tasks with automatic session discovery, parallel task processing, and status tracking",
+    "arguments": "[-y|--yes] [--resume-session=\\\"session-id\\\"]",
+    "category": "workflow",
+    "subcategory": null,
+    "usage_scenario": "implementation",
+    "difficulty": "Intermediate",
+    "source": "../../../commands/workflow/execute.md"
+  },
+  {
+    "name": "start",
+    "command": "/workflow:session:start",
+    "description": "Discover existing sessions or start new workflow session with intelligent session management and conflict detection",
+    "arguments": "[--type <workflow|review|tdd|test|docs>] [--auto|--new] [optional: task description for new session]",
+    "category": "workflow",
+    "subcategory": "session",
+    "usage_scenario": "general",
+    "difficulty": "Intermediate",
+    "source": "../../../commands/workflow/session/start.md"
+  },
+  {
+    "name": "review-session-cycle",
+    "command": "/workflow:review-session-cycle",
+    "description": "Session-based comprehensive multi-dimensional code review. Analyzes git changes from workflow session across 7 dimensions with hybrid parallel-iterative execution, aggregates findings, and performs focused deep-dives on critical issues until quality gates met.",
+    "arguments": "[session-id] [--dimensions=security,architecture,...] [--max-iterations=N]",
+    "category": "workflow",
+    "subcategory": null,
+    "usage_scenario": "session-management",
+    "difficulty": "Intermediate",
+    "source": "../../../commands/workflow/review-session-cycle.md"
+  },
+  {
+    "name": "artifacts",
+    "command": "/workflow:brainstorm:artifacts",
+    "description": "Interactive clarification generating confirmed guidance specification through role-based analysis and synthesis",
+    "arguments": "[-y|--yes] topic or challenge description [--count N]",
+    "category": "workflow",
+    "subcategory": "brainstorm",
+    "usage_scenario": "general",
+    "difficulty": "Intermediate",
+    "source": "../../../commands/workflow/brainstorm/artifacts.md"
+  },
+  {
+    "name": "plan-verify",
+    "command": "/workflow:plan-verify",
+    "description": "Perform READ-ONLY verification analysis between IMPL_PLAN.md, task JSONs, and brainstorming artifacts. Generates structured report with quality gate recommendation. Does NOT modify any files.",
+    "arguments": "[optional: --session session-id]",
+    "category": "workflow",
+    "subcategory": null,
+    "usage_scenario": "planning",
+    "difficulty": "Intermediate",
+    "source": "../../../commands/workflow/plan-verify.md"
+  }
+]

.claude/skills/ccw-help/scripts/analyze_commands.py

@@ -144,7 +144,7 @@ def build_command_relationships() -> Dict[str, Any]:
     return {
         "workflow:plan": {
             "calls_internally": ["workflow:session:start", "workflow:tools:context-gather", "workflow:tools:conflict-resolution", "workflow:tools:task-generate-agent"],
-            "next_steps": ["workflow:action-plan-verify", "workflow:status", "workflow:execute"],
+            "next_steps": ["workflow:plan-verify", "workflow:status", "workflow:execute"],
             "alternatives": ["workflow:tdd-plan"],
             "prerequisites": []
         },
@@ -159,7 +159,7 @@ def build_command_relationships() -> Dict[str, Any]:
             "related": ["workflow:status", "workflow:resume"],
             "next_steps": ["workflow:review", "workflow:tdd-verify"]
         },
-        "workflow:action-plan-verify": {
+        "workflow:plan-verify": {
             "prerequisites": ["workflow:plan"],
             "next_steps": ["workflow:execute"],
             "related": ["workflow:status"]
@@ -217,7 +217,7 @@ def identify_essential_commands(all_commands: List[Dict]) -> List[Dict]:
         "workflow:execute", "workflow:status", "workflow:session:start",
         "workflow:review-session-cycle", "cli:analyze", "cli:chat",
         "memory:docs", "workflow:brainstorm:artifacts",
-        "workflow:action-plan-verify", "workflow:resume", "version"
+        "workflow:plan-verify", "workflow:resume", "version"
     ]
 
     essential = []

.claude/skills/ccw-help/scripts/auto-update.py

@@ -0,0 +1,34 @@
+#!/usr/bin/env python3
+"""
+Simple update script for ccw-help skill.
+Runs analyze_commands.py to regenerate command index.
+"""
+
+import sys
+import subprocess
+from pathlib import Path
+
+BASE_DIR = Path("D:/Claude_dms3/.claude")
+SKILL_DIR = BASE_DIR / "skills" / "ccw-help"
+ANALYZE_SCRIPT = SKILL_DIR / "scripts" / "analyze_commands.py"
+
+def run_update():
+    """Run command analysis update."""
+    try:
+        result = subprocess.run(
+            [sys.executable, str(ANALYZE_SCRIPT)],
+            capture_output=True,
+            text=True,
+            timeout=30
+        )
+
+        print(result.stdout)
+        return result.returncode == 0
+
+    except Exception as e:
+        print(f"Error running update: {e}")
+        return False
+
+if __name__ == '__main__':
+    success = run_update()
+    sys.exit(0 if success else 1)

.claude/skills/ccw-loop/SKILL.md

@@ -0,0 +1,259 @@
+---
+name: ccw-loop
+description: Stateless iterative development loop workflow with documented progress. Supports develop, debug, and validate phases with file-based state tracking. Triggers on "ccw-loop", "dev loop", "development loop", "开发循环", "迭代开发".
+allowed-tools: Task(*), AskUserQuestion(*), Read(*), Grep(*), Glob(*), Bash(*), Edit(*), Write(*), TodoWrite(*)
+---
+
+# CCW Loop - Stateless Iterative Development Workflow
+
+无状态迭代开发循环工作流，支持开发 (develop)、调试 (debug)、验证 (validate) 三个阶段，每个阶段都有独立的文件记录进展。
+
+## Arguments
+
+| Arg | Required | Description |
+|-----|----------|-------------|
+| task | No | Task description (for new loop, mutually exclusive with --loop-id) |
+| --loop-id | No | Existing loop ID to continue (from API or previous session) |
+| --auto | No | Auto-cycle mode (develop → debug → validate → complete) |
+
+## Unified Architecture (API + Skill Integration)
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│                     Dashboard (UI)                              │
+│  [Create] [Start] [Pause] [Resume] [Stop] [View Progress]       │
+└─────────────────────────────────────────────────────────────────┘
+                              │
+                              ▼
+┌─────────────────────────────────────────────────────────────────┐
+│              loop-v2-routes.ts (Control Plane)                  │
+│                                                                 │
+│  State: .loop/{loopId}.json (MASTER)                            │
+│  Tasks: .loop/{loopId}.tasks.jsonl                              │
+│                                                                 │
+│  /start → Trigger ccw-loop skill with --loop-id                 │
+│  /pause → Set status='paused' (skill checks before action)      │
+│  /stop  → Set status='failed' (skill terminates)                │
+│  /resume → Set status='running' (skill continues)               │
+└─────────────────────────────────────────────────────────────────┘
+                              │
+                              ▼
+┌─────────────────────────────────────────────────────────────────┐
+│               ccw-loop Skill (Execution Plane)                  │
+│                                                                 │
+│  Reads/Writes: .loop/{loopId}.json (unified state)              │
+│  Writes: .loop/{loopId}.progress/* (progress files)             │
+│                                                                 │
+│  BEFORE each action:                                            │
+│    → Check status: paused/stopped → exit gracefully             │
+│    → running → continue with action                             │
+│                                                                 │
+│  Actions: init → develop → debug → validate → complete          │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+## Key Design Principles
+
+1. **统一状态**: API 和 Skill 共享 `.loop/{loopId}.json` 状态文件
+2. **控制信号**: Skill 每个 Action 前检查 status 字段 (paused/stopped)
+3. **文件驱动**: 所有进度、理解、结果都记录在 `.loop/{loopId}.progress/`
+4. **可恢复**: 任何时候可以继续之前的循环 (`--loop-id`)
+5. **双触发**: 支持 API 触发 (`--loop-id`) 和直接调用 (task description)
+6. **Gemini 辅助**: 使用 CLI 工具进行深度分析和假设验证
+
+## Execution Modes
+
+### Mode 1: Interactive (交互式)
+
+用户手动选择每个动作，适合复杂任务。
+
+```
+用户 → 选择动作 → 执行 → 查看结果 → 选择下一动作
+```
+
+### Mode 2: Auto-Loop (自动循环)
+
+按预设顺序自动执行，适合标准开发流程。
+
+```
+Develop → Debug → Validate → (如有问题) → Develop → ...
+```
+
+## Session Structure (Unified Location)
+
+```
+.loop/
+├── {loopId}.json              # 主状态文件 (API + Skill 共享)
+├── {loopId}.tasks.jsonl       # 任务列表 (API 管理)
+└── {loopId}.progress/         # Skill 进度文件
+    ├── develop.md             # 开发进度记录
+    ├── debug.md               # 理解演变文档
+    ├── validate.md            # 验证报告
+    ├── changes.log            # 代码变更日志 (NDJSON)
+    └── debug.log              # 调试日志 (NDJSON)
+```
+
+## Directory Setup
+
+```javascript
+// loopId 来源:
+// 1. API 触发时: 从 --loop-id 参数获取
+// 2. 直接调用时: 生成新的 loop-v2-{timestamp}-{random}
+
+const loopId = args['--loop-id'] || generateLoopId()
+const loopFile = `.loop/${loopId}.json`
+const progressDir = `.loop/${loopId}.progress`
+
+// 创建进度目录
+Bash(`mkdir -p "${progressDir}"`)
+```
+
+## Action Catalog
+
+| Action | Purpose | Output Files | CLI Integration |
+|--------|---------|--------------|-----------------|
+| [action-init](phases/actions/action-init.md) | 初始化循环会话 | meta.json, state.json | - |
+| [action-develop-with-file](phases/actions/action-develop-with-file.md) | 开发任务执行 | progress.md, tasks.json | gemini --mode write |
+| [action-debug-with-file](phases/actions/action-debug-with-file.md) | 假设驱动调试 | understanding.md, hypotheses.json | gemini --mode analysis |
+| [action-validate-with-file](phases/actions/action-validate-with-file.md) | 测试与验证 | validation.md, test-results.json | gemini --mode analysis |
+| [action-complete](phases/actions/action-complete.md) | 完成循环 | summary.md | - |
+| [action-menu](phases/actions/action-menu.md) | 显示操作菜单 | - | - |
+
+## Usage
+
+```bash
+# 启动新循环 (直接调用)
+/ccw-loop "实现用户认证功能"
+
+# 继续现有循环 (API 触发或手动恢复)
+/ccw-loop --loop-id loop-v2-20260122-abc123
+
+# 自动循环模式
+/ccw-loop --auto "修复登录bug并添加测试"
+
+# API 触发自动循环
+/ccw-loop --loop-id loop-v2-20260122-abc123 --auto
+```
+
+## Execution Flow
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│  /ccw-loop [<task> | --loop-id <id>] [--auto]                    │
+├─────────────────────────────────────────────────────────────────┤
+│                                                                  │
+│  1. Parameter Detection:                                         │
+│     ├─ IF --loop-id provided:                                    │
+│     │   ├─ Read .loop/{loopId}.json                              │
+│     │   ├─ Validate status === 'running'                         │
+│     │   └─ Continue from skill_state.current_action              │
+│     └─ ELSE (task description):                                  │
+│         ├─ Generate new loopId                                   │
+│         ├─ Create .loop/{loopId}.json                            │
+│         └─ Initialize with action-init                           │
+│                                                                  │
+│  2. Orchestrator Loop:                                           │
+│     ├─ Read state from .loop/{loopId}.json                       │
+│     ├─ Check control signals:                                    │
+│     │   ├─ status === 'paused' → Exit (wait for resume)          │
+│     │   ├─ status === 'failed' → Exit with error                 │
+│     │   └─ status === 'running' → Continue                       │
+│     ├─ Show menu / auto-select next action                       │
+│     ├─ Execute action                                            │
+│     ├─ Update .loop/{loopId}.progress/{action}.md                │
+│     ├─ Update .loop/{loopId}.json (skill_state)                  │
+│     └─ Loop or exit based on user choice / completion            │
+│                                                                  │
+│  3. Action Execution:                                            │
+│     ├─ BEFORE: checkControlSignals() → exit if paused/stopped    │
+│     ├─ Develop: Plan → Implement → Document progress             │
+│     ├─ Debug: Hypothesize → Instrument → Analyze → Fix           │
+│     ├─ Validate: Test → Check → Report                           │
+│     └─ AFTER: Update skill_state in .loop/{loopId}.json          │
+│                                                                  │
+│  4. Termination:                                                 │
+│     ├─ Control signal: paused (graceful exit, wait resume)       │
+│     ├─ Control signal: stopped (failed state)                    │
+│     ├─ User exits (interactive mode)                             │
+│     ├─ All tasks completed (status → completed)                  │
+│     └─ Max iterations reached                                    │
+│                                                                  │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+## Reference Documents
+
+| Document | Purpose |
+|----------|---------|
+| [phases/orchestrator.md](phases/orchestrator.md) | 编排器：状态读取 + 动作选择 |
+| [phases/state-schema.md](phases/state-schema.md) | 状态结构定义 |
+| [specs/loop-requirements.md](specs/loop-requirements.md) | 循环需求规范 |
+| [specs/action-catalog.md](specs/action-catalog.md) | 动作目录 |
+| [templates/progress-template.md](templates/progress-template.md) | 进度文档模板 |
+| [templates/understanding-template.md](templates/understanding-template.md) | 理解文档模板 |
+
+## Integration with Loop Monitor (Dashboard)
+
+此 Skill 与 CCW Dashboard 的 Loop Monitor 实现 **控制平面 + 执行平面** 分离架构：
+
+### Control Plane (Dashboard/API → loop-v2-routes.ts)
+
+1. **创建循环**: `POST /api/loops/v2` → 创建 `.loop/{loopId}.json`
+2. **启动执行**: `POST /api/loops/v2/:loopId/start` → 触发 `/ccw-loop --loop-id {loopId} --auto`
+3. **暂停执行**: `POST /api/loops/v2/:loopId/pause` → 设置 `status='paused'` (Skill 下次检查时退出)
+4. **恢复执行**: `POST /api/loops/v2/:loopId/resume` → 设置 `status='running'` → 重新触发 Skill
+5. **停止执行**: `POST /api/loops/v2/:loopId/stop` → 设置 `status='failed'`
+
+### Execution Plane (ccw-loop Skill)
+
+1. **读取状态**: 从 `.loop/{loopId}.json` 读取 API 设置的状态
+2. **检查控制**: 每个 Action 前检查 `status` 字段
+3. **执行动作**: develop → debug → validate → complete
+4. **更新进度**: 写入 `.loop/{loopId}.progress/*.md` 和更新 `skill_state`
+5. **状态同步**: Dashboard 通过读取 `.loop/{loopId}.json` 获取进度
+
+## CLI Integration Points
+
+### Develop Phase
+```bash
+ccw cli -p "PURPOSE: Implement {task}...
+TASK: • Analyze requirements • Write code • Update progress
+MODE: write
+CONTEXT: @progress.md @tasks.json
+EXPECTED: Implementation + updated progress.md
+" --tool gemini --mode write --rule development-implement-feature
+```
+
+### Debug Phase
+```bash
+ccw cli -p "PURPOSE: Generate debugging hypotheses...
+TASK: • Analyze error • Generate hypotheses • Add instrumentation
+MODE: analysis
+CONTEXT: @understanding.md @debug.log
+EXPECTED: Hypotheses + instrumentation plan
+" --tool gemini --mode analysis --rule analysis-diagnose-bug-root-cause
+```
+
+### Validate Phase
+```bash
+ccw cli -p "PURPOSE: Validate implementation...
+TASK: • Run tests • Check coverage • Verify requirements
+MODE: analysis
+CONTEXT: @validation.md @test-results.json
+EXPECTED: Validation report
+" --tool gemini --mode analysis --rule analysis-review-code-quality
+```
+
+## Error Handling
+
+| Situation | Action |
+|-----------|--------|
+| Session not found | Create new session |
+| State file corrupted | Rebuild from file contents |
+| CLI tool fails | Fallback to manual analysis |
+| Tests fail | Loop back to develop/debug |
+| >10 iterations | Warn user, suggest break |
+
+## Post-Completion Expansion
+
+完成后询问用户是否扩展为 issue (test/enhance/refactor/doc)，选中项调用 `/issue:new "{summary} - {dimension}"`

.claude/skills/ccw-loop/phases/actions/action-complete.md

@@ -0,0 +1,320 @@
+# Action: Complete
+
+完成 CCW Loop 会话，生成总结报告。
+
+## Purpose
+
+- 生成完成报告
+- 汇总所有阶段成果
+- 提供后续建议
+- 询问是否扩展为 Issue
+
+## Preconditions
+
+- [ ] state.initialized === true
+- [ ] state.status === 'running'
+
+## Execution
+
+### Step 1: 汇总统计
+
+```javascript
+const getUtc8ISOString = () => new Date(Date.now() + 8 * 60 * 60 * 1000).toISOString()
+
+const sessionFolder = `.workflow/.loop/${state.session_id}`
+
+const stats = {
+  // 时间统计
+  duration: Date.now() - new Date(state.created_at).getTime(),
+  iterations: state.iteration_count,
+
+  // 开发统计
+  develop: {
+    total_tasks: state.develop.total_count,
+    completed_tasks: state.develop.completed_count,
+    completion_rate: state.develop.total_count > 0
+      ? (state.develop.completed_count / state.develop.total_count * 100).toFixed(1)
+      : 0
+  },
+
+  // 调试统计
+  debug: {
+    iterations: state.debug.iteration,
+    hypotheses_tested: state.debug.hypotheses.length,
+    root_cause_found: state.debug.confirmed_hypothesis !== null
+  },
+
+  // 验证统计
+  validate: {
+    runs: state.validate.test_results.length,
+    passed: state.validate.passed,
+    coverage: state.validate.coverage,
+    failed_tests: state.validate.failed_tests.length
+  }
+}
+
+console.log('\n生成完成报告...')
+```
+
+### Step 2: 生成总结报告
+
+```javascript
+const summaryReport = `# CCW Loop Session Summary
+
+**Session ID**: ${state.session_id}
+**Task**: ${state.task_description}
+**Started**: ${state.created_at}
+**Completed**: ${getUtc8ISOString()}
+**Duration**: ${formatDuration(stats.duration)}
+
+---
+
+## Executive Summary
+
+${state.validate.passed
+  ? '✅ **任务成功完成** - 所有测试通过，验证成功'
+  : state.develop.completed_count === state.develop.total_count
+    ? '⚠️ **开发完成，验证未通过** - 需要进一步调试'
+    : '⏸️ **任务部分完成** - 仍有待处理项'}
+
+---
+
+## Development Phase
+
+| Metric | Value |
+|--------|-------|
+| Total Tasks | ${stats.develop.total_tasks} |
+| Completed | ${stats.develop.completed_tasks} |
+| Completion Rate | ${stats.develop.completion_rate}% |
+
+### Completed Tasks
+
+${state.develop.tasks.filter(t => t.status === 'completed').map(t => `
+- ✅ ${t.description}
+  - Files: ${t.files_changed?.join(', ') || 'N/A'}
+  - Completed: ${t.completed_at}
+`).join('\n')}
+
+### Pending Tasks
+
+${state.develop.tasks.filter(t => t.status !== 'completed').map(t => `
+- ⏳ ${t.description}
+`).join('\n') || '_None_'}
+
+---
+
+## Debug Phase
+
+| Metric | Value |
+|--------|-------|
+| Iterations | ${stats.debug.iterations} |
+| Hypotheses Tested | ${stats.debug.hypotheses_tested} |
+| Root Cause Found | ${stats.debug.root_cause_found ? 'Yes' : 'No'} |
+
+${stats.debug.root_cause_found ? `
+### Confirmed Root Cause
+
+**${state.debug.confirmed_hypothesis}**: ${state.debug.hypotheses.find(h => h.id === state.debug.confirmed_hypothesis)?.description || 'N/A'}
+` : ''}
+
+### Hypothesis Summary
+
+${state.debug.hypotheses.map(h => `
+- **${h.id}**: ${h.status.toUpperCase()}
+  - ${h.description}
+`).join('\n') || '_No hypotheses tested_'}
+
+---
+
+## Validation Phase
+
+| Metric | Value |
+|--------|-------|
+| Test Runs | ${stats.validate.runs} |
+| Status | ${stats.validate.passed ? 'PASSED' : 'FAILED'} |
+| Coverage | ${stats.validate.coverage || 'N/A'}% |
+| Failed Tests | ${stats.validate.failed_tests} |
+
+${stats.validate.failed_tests > 0 ? `
+### Failed Tests
+
+${state.validate.failed_tests.map(t => `- ❌ ${t}`).join('\n')}
+` : ''}
+
+---
+
+## Files Modified
+
+${listModifiedFiles(sessionFolder)}
+
+---
+
+## Key Learnings
+
+${state.debug.iteration > 0 ? `
+### From Debugging
+
+${extractLearnings(state.debug.hypotheses)}
+` : ''}
+
+---
+
+## Recommendations
+
+${generateRecommendations(stats, state)}
+
+---
+
+## Session Artifacts
+
+| File | Description |
+|------|-------------|
+| \`develop/progress.md\` | Development progress timeline |
+| \`develop/tasks.json\` | Task list with status |
+| \`debug/understanding.md\` | Debug exploration and learnings |
+| \`debug/hypotheses.json\` | Hypothesis history |
+| \`validate/validation.md\` | Validation report |
+| \`validate/test-results.json\` | Test execution results |
+
+---
+
+*Generated by CCW Loop at ${getUtc8ISOString()}*
+`
+
+Write(`${sessionFolder}/summary.md`, summaryReport)
+console.log(`\n报告已保存: ${sessionFolder}/summary.md`)
+```
+
+### Step 3: 询问后续扩展
+
+```javascript
+console.log('\n' + '═'.repeat(60))
+console.log('  任务已完成')
+console.log('═'.repeat(60))
+
+const expansionResponse = await AskUserQuestion({
+  questions: [{
+    question: "是否将发现扩展为 Issue？",
+    header: "扩展选项",
+    multiSelect: true,
+    options: [
+      { label: "测试 (Test)", description: "添加更多测试用例" },
+      { label: "增强 (Enhance)", description: "功能增强建议" },
+      { label: "重构 (Refactor)", description: "代码重构建议" },
+      { label: "文档 (Doc)", description: "文档更新需求" },
+      { label: "否，直接完成", description: "不创建 Issue" }
+    ]
+  }]
+})
+
+const selectedExpansions = expansionResponse["扩展选项"]
+
+if (selectedExpansions && !selectedExpansions.includes("否，直接完成")) {
+  for (const expansion of selectedExpansions) {
+    const dimension = expansion.split(' ')[0].toLowerCase()
+    const issueSummary = `${state.task_description} - ${dimension}`
+
+    console.log(`\n创建 Issue: ${issueSummary}`)
+
+    // 调用 /issue:new 创建 issue
+    await Bash({
+      command: `/issue:new "${issueSummary}"`,
+      run_in_background: false
+    })
+  }
+}
+```
+
+### Step 4: 最终输出
+
+```javascript
+console.log(`
+═══════════════════════════════════════════════════════════
+  ✅ CCW Loop 会话完成
+═══════════════════════════════════════════════════════════
+
+  会话 ID: ${state.session_id}
+  用时: ${formatDuration(stats.duration)}
+  迭代: ${stats.iterations}
+
+  开发: ${stats.develop.completed_tasks}/${stats.develop.total_tasks} 任务完成
+  调试: ${stats.debug.iterations} 次迭代
+  验证: ${stats.validate.passed ? '通过 ✅' : '未通过 ❌'}
+
+  报告: ${sessionFolder}/summary.md
+
+═══════════════════════════════════════════════════════════
+`)
+```
+
+## State Updates
+
+```javascript
+return {
+  stateUpdates: {
+    status: 'completed',
+    completed_at: getUtc8ISOString(),
+    summary: stats
+  },
+  continue: false,
+  message: `会话 ${state.session_id} 已完成`
+}
+```
+
+## Helper Functions
+
+```javascript
+function formatDuration(ms) {
+  const seconds = Math.floor(ms / 1000)
+  const minutes = Math.floor(seconds / 60)
+  const hours = Math.floor(minutes / 60)
+
+  if (hours > 0) {
+    return `${hours}h ${minutes % 60}m`
+  } else if (minutes > 0) {
+    return `${minutes}m ${seconds % 60}s`
+  } else {
+    return `${seconds}s`
+  }
+}
+
+function generateRecommendations(stats, state) {
+  const recommendations = []
+
+  if (stats.develop.completion_rate < 100) {
+    recommendations.push('- 完成剩余开发任务')
+  }
+
+  if (!stats.validate.passed) {
+    recommendations.push('- 修复失败的测试')
+  }
+
+  if (stats.validate.coverage && stats.validate.coverage < 80) {
+    recommendations.push(`- 提高测试覆盖率 (当前: ${stats.validate.coverage}%)`)
+  }
+
+  if (stats.debug.iterations > 3 && !stats.debug.root_cause_found) {
+    recommendations.push('- 考虑代码重构以简化调试')
+  }
+
+  if (recommendations.length === 0) {
+    recommendations.push('- 考虑代码审查')
+    recommendations.push('- 更新相关文档')
+    recommendations.push('- 准备部署')
+  }
+
+  return recommendations.join('\n')
+}
+```
+
+## Error Handling
+
+| Error Type | Recovery |
+|------------|----------|
+| 报告生成失败 | 显示基本统计，跳过文件写入 |
+| Issue 创建失败 | 记录错误，继续完成 |
+
+## Next Actions
+
+- 无 (终止状态)
+- 如需继续: 使用 `ccw-loop --resume {session-id}` 重新打开会话

.claude/skills/ccw-loop/phases/actions/action-debug-with-file.md

@@ -0,0 +1,485 @@
+# Action: Debug With File
+
+假设驱动调试，记录理解演变到 understanding.md，支持 Gemini 辅助分析和假设生成。
+
+## Purpose
+
+执行假设驱动的调试流程，包括：
+- 定位错误源
+- 生成可测试假设
+- 添加 NDJSON 日志
+- 分析日志证据
+- 纠正错误理解
+- 应用修复
+
+## Preconditions
+
+- [ ] state.initialized === true
+- [ ] state.status === 'running'
+
+## Session Setup
+
+```javascript
+const getUtc8ISOString = () => new Date(Date.now() + 8 * 60 * 60 * 1000).toISOString()
+
+const sessionFolder = `.workflow/.loop/${state.session_id}`
+const debugFolder = `${sessionFolder}/debug`
+const understandingPath = `${debugFolder}/understanding.md`
+const hypothesesPath = `${debugFolder}/hypotheses.json`
+const debugLogPath = `${debugFolder}/debug.log`
+```
+
+---
+
+## Mode Detection
+
+```javascript
+// 自动检测模式
+const understandingExists = fs.existsSync(understandingPath)
+const logHasContent = fs.existsSync(debugLogPath) && fs.statSync(debugLogPath).size > 0
+
+const debugMode = logHasContent ? 'analyze' : (understandingExists ? 'continue' : 'explore')
+
+console.log(`Debug mode: ${debugMode}`)
+```
+
+---
+
+## Explore Mode (首次调试)
+
+### Step 1.1: 定位错误源
+
+```javascript
+if (debugMode === 'explore') {
+  // 询问用户 bug 描述
+  const bugInput = await AskUserQuestion({
+    questions: [{
+      question: "请描述遇到的 bug 或错误信息：",
+      header: "Bug 描述",
+      multiSelect: false,
+      options: [
+        { label: "手动输入", description: "输入错误描述或堆栈" },
+        { label: "从测试失败", description: "从验证阶段的失败测试中获取" }
+      ]
+    }]
+  })
+
+  const bugDescription = bugInput["Bug 描述"]
+
+  // 提取关键词并搜索
+  const searchResults = await Task({
+    subagent_type: 'Explore',
+    run_in_background: false,
+    prompt: `Search codebase for error patterns related to: ${bugDescription}`
+  })
+
+  // 分析搜索结果，识别受影响的位置
+  const affectedLocations = analyzeSearchResults(searchResults)
+}
+```
+
+### Step 1.2: 记录初始理解
+
+```javascript
+// 创建 understanding.md
+const initialUnderstanding = `# Understanding Document
+
+**Session ID**: ${state.session_id}
+**Bug Description**: ${bugDescription}
+**Started**: ${getUtc8ISOString()}
+
+---
+
+## Exploration Timeline
+
+### Iteration 1 - Initial Exploration (${getUtc8ISOString()})
+
+#### Current Understanding
+
+Based on bug description and initial code search:
+
+- Error pattern: ${errorPattern}
+- Affected areas: ${affectedLocations.map(l => l.file).join(', ')}
+- Initial hypothesis: ${initialThoughts}
+
+#### Evidence from Code Search
+
+${searchResults.map(r => `
+**Keyword: "${r.keyword}"**
+- Found in: ${r.files.join(', ')}
+- Key findings: ${r.insights}
+`).join('\n')}
+
+#### Next Steps
+
+- Generate testable hypotheses
+- Add instrumentation
+- Await reproduction
+
+---
+
+## Current Consolidated Understanding
+
+${initialConsolidatedUnderstanding}
+`
+
+Write(understandingPath, initialUnderstanding)
+```
+
+### Step 1.3: Gemini 辅助假设生成
+
+```bash
+ccw cli -p "
+PURPOSE: Generate debugging hypotheses for: ${bugDescription}
+Success criteria: Testable hypotheses with clear evidence criteria
+
+TASK:
+• Analyze error pattern and code search results
+• Identify 3-5 most likely root causes
+• For each hypothesis, specify:
+  - What might be wrong
+  - What evidence would confirm/reject it
+  - Where to add instrumentation
+• Rank by likelihood
+
+MODE: analysis
+
+CONTEXT: @${understandingPath} | Search results in understanding.md
+
+EXPECTED:
+- Structured hypothesis list (JSON format)
+- Each hypothesis with: id, description, testable_condition, logging_point, evidence_criteria
+- Likelihood ranking (1=most likely)
+
+CONSTRAINTS: Focus on testable conditions
+" --tool gemini --mode analysis --rule analysis-diagnose-bug-root-cause
+```
+
+### Step 1.4: 保存假设
+
+```javascript
+const hypotheses = {
+  iteration: 1,
+  timestamp: getUtc8ISOString(),
+  bug_description: bugDescription,
+  hypotheses: [
+    {
+      id: "H1",
+      description: "...",
+      testable_condition: "...",
+      logging_point: "file.ts:func:42",
+      evidence_criteria: {
+        confirm: "...",
+        reject: "..."
+      },
+      likelihood: 1,
+      status: "pending"
+    }
+    // ...
+  ],
+  gemini_insights: "...",
+  corrected_assumptions: []
+}
+
+Write(hypothesesPath, JSON.stringify(hypotheses, null, 2))
+```
+
+### Step 1.5: 添加 NDJSON 日志
+
+```javascript
+// 为每个假设添加日志点
+for (const hypothesis of hypotheses.hypotheses) {
+  const [file, func, line] = hypothesis.logging_point.split(':')
+
+  const logStatement = `console.log(JSON.stringify({
+    hid: "${hypothesis.id}",
+    ts: Date.now(),
+    func: "${func}",
+    data: { /* 相关数据 */ }
+  }))`
+
+  // 使用 Edit 工具添加日志
+  // ...
+}
+```
+
+---
+
+## Analyze Mode (有日志后)
+
+### Step 2.1: 解析调试日志
+
+```javascript
+if (debugMode === 'analyze') {
+  // 读取 NDJSON 日志
+  const logContent = Read(debugLogPath)
+  const entries = logContent.split('\n')
+    .filter(l => l.trim())
+    .map(l => JSON.parse(l))
+
+  // 按假设分组
+  const byHypothesis = groupBy(entries, 'hid')
+}
+```
+
+### Step 2.2: Gemini 辅助证据分析
+
+```bash
+ccw cli -p "
+PURPOSE: Analyze debug log evidence to validate/correct hypotheses for: ${bugDescription}
+Success criteria: Clear verdict per hypothesis + corrected understanding
+
+TASK:
+• Parse log entries by hypothesis
+• Evaluate evidence against expected criteria
+• Determine verdict: confirmed | rejected | inconclusive
+• Identify incorrect assumptions from previous understanding
+• Suggest corrections to understanding
+
+MODE: analysis
+
+CONTEXT:
+@${debugLogPath}
+@${understandingPath}
+@${hypothesesPath}
+
+EXPECTED:
+- Per-hypothesis verdict with reasoning
+- Evidence summary
+- List of incorrect assumptions with corrections
+- Updated consolidated understanding
+- Root cause if confirmed, or next investigation steps
+
+CONSTRAINTS: Evidence-based reasoning only, no speculation
+" --tool gemini --mode analysis --rule analysis-diagnose-bug-root-cause
+```
+
+### Step 2.3: 更新理解文档
+
+```javascript
+// 追加新迭代到 understanding.md
+const iteration = state.debug.iteration + 1
+
+const analysisEntry = `
+### Iteration ${iteration} - Evidence Analysis (${getUtc8ISOString()})
+
+#### Log Analysis Results
+
+${results.map(r => `
+**${r.id}**: ${r.verdict.toUpperCase()}
+- Evidence: ${JSON.stringify(r.evidence)}
+- Reasoning: ${r.reason}
+`).join('\n')}
+
+#### Corrected Understanding
+
+Previous misunderstandings identified and corrected:
+
+${corrections.map(c => `
+- ~~${c.wrong}~~ → ${c.corrected}
+  - Why wrong: ${c.reason}
+  - Evidence: ${c.evidence}
+`).join('\n')}
+
+#### New Insights
+
+${newInsights.join('\n- ')}
+
+#### Gemini Analysis
+
+${geminiAnalysis}
+
+${confirmedHypothesis ? `
+#### Root Cause Identified
+
+**${confirmedHypothesis.id}**: ${confirmedHypothesis.description}
+
+Evidence supporting this conclusion:
+${confirmedHypothesis.supportingEvidence}
+` : `
+#### Next Steps
+
+${nextSteps}
+`}
+
+---
+
+## Current Consolidated Understanding (Updated)
+
+### What We Know
+
+- ${validUnderstanding1}
+- ${validUnderstanding2}
+
+### What Was Disproven
+
+- ~~${wrongAssumption}~~ (Evidence: ${disproofEvidence})
+
+### Current Investigation Focus
+
+${currentFocus}
+
+### Remaining Questions
+
+- ${openQuestion1}
+- ${openQuestion2}
+`
+
+const existingContent = Read(understandingPath)
+Write(understandingPath, existingContent + analysisEntry)
+```
+
+### Step 2.4: 更新假设状态
+
+```javascript
+const hypothesesData = JSON.parse(Read(hypothesesPath))
+
+// 更新假设状态
+hypothesesData.hypotheses = hypothesesData.hypotheses.map(h => ({
+  ...h,
+  status: results.find(r => r.id === h.id)?.verdict || h.status,
+  evidence: results.find(r => r.id === h.id)?.evidence || h.evidence,
+  verdict_reason: results.find(r => r.id === h.id)?.reason || h.verdict_reason
+}))
+
+hypothesesData.iteration++
+hypothesesData.timestamp = getUtc8ISOString()
+
+Write(hypothesesPath, JSON.stringify(hypothesesData, null, 2))
+```
+
+---
+
+## Fix & Verification
+
+### Step 3.1: 应用修复
+
+```javascript
+if (confirmedHypothesis) {
+  console.log(`\n根因确认: ${confirmedHypothesis.description}`)
+  console.log('准备应用修复...')
+
+  // 使用 Gemini 生成修复代码
+  const fixPrompt = `
+PURPOSE: Fix the identified root cause
+Root Cause: ${confirmedHypothesis.description}
+Evidence: ${confirmedHypothesis.supportingEvidence}
+
+TASK:
+• Generate fix code
+• Ensure backward compatibility
+• Add tests if needed
+
+MODE: write
+
+CONTEXT: @${confirmedHypothesis.logging_point.split(':')[0]}
+
+EXPECTED: Fixed code + verification steps
+`
+
+  await Bash({
+    command: `ccw cli -p "${fixPrompt}" --tool gemini --mode write --rule development-debug-runtime-issues`,
+    run_in_background: false
+  })
+}
+```
+
+### Step 3.2: 记录解决方案
+
+```javascript
+const resolutionEntry = `
+### Resolution (${getUtc8ISOString()})
+
+#### Fix Applied
+
+- Modified files: ${modifiedFiles.join(', ')}
+- Fix description: ${fixDescription}
+- Root cause addressed: ${rootCause}
+
+#### Verification Results
+
+${verificationResults}
+
+#### Lessons Learned
+
+1. ${lesson1}
+2. ${lesson2}
+
+#### Key Insights for Future
+
+- ${insight1}
+- ${insight2}
+`
+
+const existingContent = Read(understandingPath)
+Write(understandingPath, existingContent + resolutionEntry)
+```
+
+### Step 3.3: 清理日志
+
+```javascript
+// 移除调试日志
+// (可选，根据用户选择)
+```
+
+---
+
+## State Updates
+
+```javascript
+return {
+  stateUpdates: {
+    debug: {
+      current_bug: bugDescription,
+      hypotheses: hypothesesData.hypotheses,
+      confirmed_hypothesis: confirmedHypothesis?.id || null,
+      iteration: hypothesesData.iteration,
+      last_analysis_at: getUtc8ISOString(),
+      understanding_updated: true
+    },
+    last_action: 'action-debug-with-file'
+  },
+  continue: true,
+  message: confirmedHypothesis
+    ? `根因确认: ${confirmedHypothesis.description}\n修复已应用，请验证`
+    : `分析完成，需要更多证据\n请复现 bug 后再次执行`
+}
+```
+
+## Error Handling
+
+| Error Type | Recovery |
+|------------|----------|
+| 空 debug.log | 提示用户复现 bug |
+| 所有假设被否定 | 使用 Gemini 生成新假设 |
+| 修复无效 | 记录失败尝试，迭代 |
+| >5 迭代 | 建议升级到 /workflow:lite-fix |
+| Gemini 不可用 | 回退到手动分析 |
+
+## Understanding Document Template
+
+参考 [templates/understanding-template.md](../../templates/understanding-template.md)
+
+## CLI Integration
+
+### 假设生成
+```bash
+ccw cli -p "PURPOSE: Generate debugging hypotheses..." --tool gemini --mode analysis --rule analysis-diagnose-bug-root-cause
+```
+
+### 证据分析
+```bash
+ccw cli -p "PURPOSE: Analyze debug log evidence..." --tool gemini --mode analysis --rule analysis-diagnose-bug-root-cause
+```
+
+### 生成修复
+```bash
+ccw cli -p "PURPOSE: Fix the identified root cause..." --tool gemini --mode write --rule development-debug-runtime-issues
+```
+
+## Next Actions (Hints)
+
+- 根因确认: `action-validate-with-file` (验证修复)
+- 需要更多证据: 等待用户复现，再次执行此动作
+- 所有假设否定: 重新执行此动作生成新假设
+- 用户选择: `action-menu` (返回菜单)

.claude/skills/ccw-loop/phases/actions/action-develop-with-file.md

@@ -0,0 +1,365 @@
+# Action: Develop With File
+
+增量开发任务执行，记录进度到 progress.md，支持 Gemini 辅助实现。
+
+## Purpose
+
+执行开发任务并记录进度，包括：
+- 分析任务需求
+- 使用 Gemini/CLI 实现代码
+- 记录代码变更
+- 更新进度文档
+
+## Preconditions
+
+- [ ] state.status === 'running'
+- [ ] state.skill_state !== null
+- [ ] state.skill_state.develop.tasks.some(t => t.status === 'pending')
+
+## Session Setup (Unified Location)
+
+```javascript
+const getUtc8ISOString = () => new Date(Date.now() + 8 * 60 * 60 * 1000).toISOString()
+
+// 统一位置: .loop/{loopId}
+const loopId = state.loop_id
+const loopFile = `.loop/${loopId}.json`
+const progressDir = `.loop/${loopId}.progress`
+const progressPath = `${progressDir}/develop.md`
+const changesLogPath = `${progressDir}/changes.log`
+```
+
+---
+
+## Execution
+
+### Step 0: Check Control Signals (CRITICAL)
+
+```javascript
+/**
+ * CRITICAL: 每个 Action 必须在开始时检查控制信号
+ * 如果 API 设置了 paused/stopped，Skill 应立即退出
+ */
+function checkControlSignals(loopId) {
+  const state = JSON.parse(Read(`.loop/${loopId}.json`))
+
+  switch (state.status) {
+    case 'paused':
+      console.log('⏸️ Loop paused by API. Exiting action.')
+      return { continue: false, reason: 'paused' }
+
+    case 'failed':
+      console.log('⏹️ Loop stopped by API. Exiting action.')
+      return { continue: false, reason: 'stopped' }
+
+    case 'running':
+      return { continue: true, reason: 'running' }
+
+    default:
+      return { continue: false, reason: 'unknown_status' }
+  }
+}
+
+// Execute check
+const control = checkControlSignals(loopId)
+if (!control.continue) {
+  return {
+    skillStateUpdates: { current_action: null },
+    continue: false,
+    message: `Action terminated: ${control.reason}`
+  }
+}
+```
+
+### Step 1: 加载任务列表
+
+```javascript
+// 读取任务列表 (从 skill_state)
+let tasks = state.skill_state?.develop?.tasks || []
+
+// 如果任务列表为空，询问用户创建
+if (tasks.length === 0) {
+  // 使用 Gemini 分析任务描述，生成任务列表
+  const analysisPrompt = `
+PURPOSE: 分析开发任务并分解为可执行步骤
+Success: 生成 3-7 个具体、可验证的子任务
+
+TASK:
+• 分析任务描述: ${state.task_description}
+• 识别关键功能点
+• 分解为独立子任务
+• 为每个子任务指定工具和模式
+
+MODE: analysis
+
+CONTEXT: @package.json @src/**/*.ts | Memory: 项目结构
+
+EXPECTED:
+JSON 格式:
+{
+  "tasks": [
+    {
+      "id": "task-001",
+      "description": "任务描述",
+      "tool": "gemini",
+      "mode": "write",
+      "files": ["src/xxx.ts"]
+    }
+  ]
+}
+`
+
+  const result = await Task({
+    subagent_type: 'cli-execution-agent',
+    run_in_background: false,
+    prompt: `Execute Gemini CLI with prompt: ${analysisPrompt}`
+  })
+
+  tasks = JSON.parse(result).tasks
+}
+
+// 找到第一个待处理任务
+const currentTask = tasks.find(t => t.status === 'pending')
+
+if (!currentTask) {
+  return {
+    skillStateUpdates: {
+      develop: { ...state.skill_state.develop, current_task: null }
+    },
+    continue: true,
+    message: '所有开发任务已完成'
+  }
+}
+```
+
+### Step 2: 执行开发任务
+
+```javascript
+console.log(`\n执行任务: ${currentTask.description}`)
+
+// 更新任务状态
+currentTask.status = 'in_progress'
+
+// 使用 Gemini 实现
+const implementPrompt = `
+PURPOSE: 实现开发任务
+Task: ${currentTask.description}
+Success criteria: 代码实现完成，测试通过
+
+TASK:
+• 分析现有代码结构
+• 实现功能代码
+• 添加必要的类型定义
+• 确保代码风格一致
+
+MODE: write
+
+CONTEXT: @${currentTask.files?.join(' @') || 'src/**/*.ts'}
+
+EXPECTED:
+- 完整的代码实现
+- 代码变更列表
+- 简要实现说明
+
+CONSTRAINTS: 遵循现有代码风格 | 不破坏现有功能
+`
+
+const implementResult = await Bash({
+  command: `ccw cli -p "${implementPrompt}" --tool gemini --mode write --rule development-implement-feature`,
+  run_in_background: false
+})
+
+// 记录代码变更
+const timestamp = getUtc8ISOString()
+const changeEntry = {
+  timestamp,
+  task_id: currentTask.id,
+  description: currentTask.description,
+  files_changed: currentTask.files || [],
+  result: 'success'
+}
+
+// 追加到 changes.log (NDJSON 格式)
+const changesContent = Read(changesLogPath) || ''
+Write(changesLogPath, changesContent + JSON.stringify(changeEntry) + '\n')
+```
+
+### Step 3: 更新进度文档
+
+```javascript
+const timestamp = getUtc8ISOString()
+const iteration = state.develop.completed_count + 1
+
+// 读取现有进度文档
+let progressContent = Read(progressPath) || ''
+
+// 如果是新文档，添加头部
+if (!progressContent) {
+  progressContent = `# Development Progress
+
+**Session ID**: ${state.session_id}
+**Task**: ${state.task_description}
+**Started**: ${timestamp}
+
+---
+
+## Progress Timeline
+
+`
+}
+
+// 追加本次进度
+const progressEntry = `
+### Iteration ${iteration} - ${currentTask.description} (${timestamp})
+
+#### Task Details
+
+- **ID**: ${currentTask.id}
+- **Tool**: ${currentTask.tool}
+- **Mode**: ${currentTask.mode}
+
+#### Implementation Summary
+
+${implementResult.summary || '实现完成'}
+
+#### Files Changed
+
+${currentTask.files?.map(f => `- \`${f}\``).join('\n') || '- No files specified'}
+
+#### Status: COMPLETED
+
+---
+
+`
+
+Write(progressPath, progressContent + progressEntry)
+
+// 更新任务状态
+currentTask.status = 'completed'
+currentTask.completed_at = timestamp
+```
+
+### Step 4: 更新任务列表文件
+
+```javascript
+// 更新 tasks.json
+const updatedTasks = tasks.map(t =>
+  t.id === currentTask.id ? currentTask : t
+)
+
+Write(tasksPath, JSON.stringify(updatedTasks, null, 2))
+```
+
+## State Updates
+
+```javascript
+return {
+  stateUpdates: {
+    develop: {
+      tasks: updatedTasks,
+      current_task_id: null,
+      completed_count: state.develop.completed_count + 1,
+      total_count: updatedTasks.length,
+      last_progress_at: getUtc8ISOString()
+    },
+    last_action: 'action-develop-with-file'
+  },
+  continue: true,
+  message: `任务完成: ${currentTask.description}\n进度: ${state.develop.completed_count + 1}/${updatedTasks.length}`
+}
+```
+
+## Error Handling
+
+| Error Type | Recovery |
+|------------|----------|
+| Gemini CLI 失败 | 提示用户手动实现，记录到 progress.md |
+| 文件写入失败 | 重试一次，失败则记录错误 |
+| 任务解析失败 | 询问用户手动输入任务 |
+
+## Progress Document Template
+
+```markdown
+# Development Progress
+
+**Session ID**: LOOP-xxx-2026-01-22
+**Task**: 实现用户认证功能
+**Started**: 2026-01-22T10:00:00+08:00
+
+---
+
+## Progress Timeline
+
+### Iteration 1 - 分析登录组件 (2026-01-22T10:05:00+08:00)
+
+#### Task Details
+
+- **ID**: task-001
+- **Tool**: gemini
+- **Mode**: analysis
+
+#### Implementation Summary
+
+分析了现有登录组件结构，识别了需要修改的文件和依赖关系。
+
+#### Files Changed
+
+- `src/components/Login.tsx`
+- `src/hooks/useAuth.ts`
+
+#### Status: COMPLETED
+
+---
+
+### Iteration 2 - 实现登录 API (2026-01-22T10:15:00+08:00)
+
+...
+
+---
+
+## Current Statistics
+
+| Metric | Value |
+|--------|-------|
+| Total Tasks | 5 |
+| Completed | 2 |
+| In Progress | 1 |
+| Pending | 2 |
+| Progress | 40% |
+
+---
+
+## Next Steps
+
+- [ ] 完成剩余任务
+- [ ] 运行测试
+- [ ] 代码审查
+```
+
+## CLI Integration
+
+### 任务分析
+```bash
+ccw cli -p "PURPOSE: 分解开发任务为子任务
+TASK: • 分析任务描述 • 识别功能点 • 生成任务列表
+MODE: analysis
+CONTEXT: @package.json @src/**/*
+EXPECTED: JSON 任务列表
+" --tool gemini --mode analysis --rule planning-breakdown-task-steps
+```
+
+### 代码实现
+```bash
+ccw cli -p "PURPOSE: 实现功能代码
+TASK: • 分析需求 • 编写代码 • 添加类型
+MODE: write
+CONTEXT: @src/xxx.ts
+EXPECTED: 完整实现
+" --tool gemini --mode write --rule development-implement-feature
+```
+
+## Next Actions (Hints)
+
+- 所有任务完成: `action-debug-with-file` (开始调试)
+- 任务失败: `action-develop-with-file` (重试或下一个任务)
+- 用户选择: `action-menu` (返回菜单)

.claude/skills/ccw-loop/phases/actions/action-init.md

@@ -0,0 +1,200 @@
+# Action: Initialize
+
+初始化 CCW Loop 会话，创建目录结构和初始状态。
+
+## Purpose
+
+- 创建会话目录结构
+- 初始化状态文件
+- 分析任务描述生成初始任务列表
+- 准备执行环境
+
+## Preconditions
+
+- [ ] state.status === 'pending'
+- [ ] state.initialized === false
+
+## Execution
+
+### Step 1: 创建目录结构
+
+```javascript
+const getUtc8ISOString = () => new Date(Date.now() + 8 * 60 * 60 * 1000).toISOString()
+
+const taskSlug = state.task_description.toLowerCase().replace(/[^a-z0-9]+/g, '-').substring(0, 30)
+const dateStr = getUtc8ISOString().substring(0, 10)
+const sessionId = `LOOP-${taskSlug}-${dateStr}`
+const sessionFolder = `.workflow/.loop/${sessionId}`
+
+Bash(`mkdir -p "${sessionFolder}/develop"`)
+Bash(`mkdir -p "${sessionFolder}/debug"`)
+Bash(`mkdir -p "${sessionFolder}/validate"`)
+
+console.log(`Session created: ${sessionId}`)
+console.log(`Location: ${sessionFolder}`)
+```
+
+### Step 2: 创建元数据文件
+
+```javascript
+const meta = {
+  session_id: sessionId,
+  task_description: state.task_description,
+  created_at: getUtc8ISOString(),
+  mode: state.mode || 'interactive'
+}
+
+Write(`${sessionFolder}/meta.json`, JSON.stringify(meta, null, 2))
+```
+
+### Step 3: 分析任务生成开发任务列表
+
+```javascript
+// 使用 Gemini 分析任务描述
+console.log('\n分析任务描述...')
+
+const analysisPrompt = `
+PURPOSE: 分析开发任务并分解为可执行步骤
+Success: 生成 3-7 个具体、可验证的子任务
+
+TASK:
+• 分析任务描述: ${state.task_description}
+• 识别关键功能点
+• 分解为独立子任务
+• 为每个子任务指定工具和模式
+
+MODE: analysis
+
+CONTEXT: @package.json @src/**/*.ts (如存在)
+
+EXPECTED:
+JSON 格式:
+{
+  "tasks": [
+    {
+      "id": "task-001",
+      "description": "任务描述",
+      "tool": "gemini",
+      "mode": "write",
+      "priority": 1
+    }
+  ],
+  "estimated_complexity": "low|medium|high",
+  "key_files": ["file1.ts", "file2.ts"]
+}
+
+CONSTRAINTS: 生成实际可执行的任务
+`
+
+const result = await Bash({
+  command: `ccw cli -p "${analysisPrompt}" --tool gemini --mode analysis --rule planning-breakdown-task-steps`,
+  run_in_background: false
+})
+
+const analysis = JSON.parse(result.stdout)
+const tasks = analysis.tasks.map((t, i) => ({
+  ...t,
+  id: t.id || `task-${String(i + 1).padStart(3, '0')}`,
+  status: 'pending',
+  created_at: getUtc8ISOString(),
+  completed_at: null,
+  files_changed: []
+}))
+
+// 保存任务列表
+Write(`${sessionFolder}/develop/tasks.json`, JSON.stringify(tasks, null, 2))
+```
+
+### Step 4: 初始化进度文档
+
+```javascript
+const progressInitial = `# Development Progress
+
+**Session ID**: ${sessionId}
+**Task**: ${state.task_description}
+**Started**: ${getUtc8ISOString()}
+**Estimated Complexity**: ${analysis.estimated_complexity}
+
+---
+
+## Task List
+
+${tasks.map((t, i) => `${i + 1}. [ ] ${t.description}`).join('\n')}
+
+## Key Files
+
+${analysis.key_files?.map(f => `- \`${f}\``).join('\n') || '- To be determined'}
+
+---
+
+## Progress Timeline
+
+`
+
+Write(`${sessionFolder}/develop/progress.md`, progressInitial)
+```
+
+### Step 5: 显示初始化结果
+
+```javascript
+console.log(`\n✅ 会话初始化完成`)
+console.log(`\n任务列表 (${tasks.length} 项):`)
+tasks.forEach((t, i) => {
+  console.log(`  ${i + 1}. ${t.description} [${t.tool}/${t.mode}]`)
+})
+console.log(`\n预估复杂度: ${analysis.estimated_complexity}`)
+console.log(`\n执行 'develop' 开始开发，或 'menu' 查看更多选项`)
+```
+
+## State Updates
+
+```javascript
+return {
+  stateUpdates: {
+    session_id: sessionId,
+    status: 'running',
+    initialized: true,
+    develop: {
+      tasks: tasks,
+      current_task_id: null,
+      completed_count: 0,
+      total_count: tasks.length,
+      last_progress_at: null
+    },
+    debug: {
+      current_bug: null,
+      hypotheses: [],
+      confirmed_hypothesis: null,
+      iteration: 0,
+      last_analysis_at: null,
+      understanding_updated: false
+    },
+    validate: {
+      test_results: [],
+      coverage: null,
+      passed: false,
+      failed_tests: [],
+      last_run_at: null
+    },
+    context: {
+      estimated_complexity: analysis.estimated_complexity,
+      key_files: analysis.key_files
+    }
+  },
+  continue: true,
+  message: `会话 ${sessionId} 已初始化\n${tasks.length} 个开发任务待执行`
+}
+```
+
+## Error Handling
+
+| Error Type | Recovery |
+|------------|----------|
+| 目录创建失败 | 检查权限，重试 |
+| Gemini 分析失败 | 提示用户手动输入任务 |
+| 任务解析失败 | 使用默认任务列表 |
+
+## Next Actions
+
+- 成功: `action-menu` (显示操作菜单) 或 `action-develop-with-file` (直接开始开发)
+- 失败: 报错退出

.claude/skills/ccw-loop/phases/actions/action-menu.md

@@ -0,0 +1,192 @@
+# Action: Menu
+
+显示交互式操作菜单，让用户选择下一步操作。
+
+## Purpose
+
+- 显示当前状态摘要
+- 提供操作选项
+- 接收用户选择
+- 返回下一个动作
+
+## Preconditions
+
+- [ ] state.initialized === true
+- [ ] state.status === 'running'
+
+## Execution
+
+### Step 1: 生成状态摘要
+
+```javascript
+const getUtc8ISOString = () => new Date(Date.now() + 8 * 60 * 60 * 1000).toISOString()
+
+// 开发进度
+const developProgress = state.develop.total_count > 0
+  ? `${state.develop.completed_count}/${state.develop.total_count} (${(state.develop.completed_count / state.develop.total_count * 100).toFixed(0)}%)`
+  : '未开始'
+
+// 调试状态
+const debugStatus = state.debug.confirmed_hypothesis
+  ? `✅ 已确认根因`
+  : state.debug.iteration > 0
+    ? `🔍 迭代 ${state.debug.iteration}`
+    : '未开始'
+
+// 验证状态
+const validateStatus = state.validate.passed
+  ? `✅ 通过`
+  : state.validate.test_results.length > 0
+    ? `❌ ${state.validate.failed_tests.length} 个失败`
+    : '未运行'
+
+const statusSummary = `
+═══════════════════════════════════════════════════════════
+  CCW Loop - ${state.session_id}
+═══════════════════════════════════════════════════════════
+
+  任务: ${state.task_description}
+  迭代: ${state.iteration_count}
+
+  ┌─────────────────────────────────────────────────────┐
+  │  开发 (Develop)  │  ${developProgress.padEnd(20)}      │
+  │  调试 (Debug)    │  ${debugStatus.padEnd(20)}      │
+  │  验证 (Validate) │  ${validateStatus.padEnd(20)}      │
+  └─────────────────────────────────────────────────────┘
+
+═══════════════════════════════════════════════════════════
+`
+
+console.log(statusSummary)
+```
+
+### Step 2: 显示操作选项
+
+```javascript
+const options = [
+  {
+    label: "📝 继续开发 (Develop)",
+    description: state.develop.completed_count < state.develop.total_count
+      ? `执行下一个开发任务`
+      : "所有任务已完成，可添加新任务",
+    action: "action-develop-with-file"
+  },
+  {
+    label: "🔍 开始调试 (Debug)",
+    description: state.debug.iteration > 0
+      ? "继续假设驱动调试"
+      : "开始新的调试会话",
+    action: "action-debug-with-file"
+  },
+  {
+    label: "✅ 运行验证 (Validate)",
+    description: "运行测试并检查覆盖率",
+    action: "action-validate-with-file"
+  },
+  {
+    label: "📊 查看详情 (Status)",
+    description: "查看详细进度和文件",
+    action: "action-status"
+  },
+  {
+    label: "🏁 完成循环 (Complete)",
+    description: "结束当前循环",
+    action: "action-complete"
+  },
+  {
+    label: "🚪 退出 (Exit)",
+    description: "保存状态并退出",
+    action: "exit"
+  }
+]
+
+const response = await AskUserQuestion({
+  questions: [{
+    question: "选择下一步操作：",
+    header: "操作",
+    multiSelect: false,
+    options: options.map(o => ({
+      label: o.label,
+      description: o.description
+    }))
+  }]
+})
+
+const selectedLabel = response["操作"]
+const selectedOption = options.find(o => o.label === selectedLabel)
+const nextAction = selectedOption?.action || 'action-menu'
+```
+
+### Step 3: 处理特殊选项
+
+```javascript
+if (nextAction === 'exit') {
+  console.log('\n保存状态并退出...')
+  return {
+    stateUpdates: {
+      status: 'user_exit'
+    },
+    continue: false,
+    message: '会话已保存，使用 --resume 可继续'
+  }
+}
+
+if (nextAction === 'action-status') {
+  // 显示详细状态
+  const sessionFolder = `.workflow/.loop/${state.session_id}`
+
+  console.log('\n=== 开发进度 ===')
+  const progress = Read(`${sessionFolder}/develop/progress.md`)
+  console.log(progress?.substring(0, 500) + '...')
+
+  console.log('\n=== 调试状态 ===')
+  if (state.debug.hypotheses.length > 0) {
+    state.debug.hypotheses.forEach(h => {
+      console.log(`  ${h.id}: ${h.status} - ${h.description.substring(0, 50)}...`)
+    })
+  } else {
+    console.log('  尚未开始调试')
+  }
+
+  console.log('\n=== 验证结果 ===')
+  if (state.validate.test_results.length > 0) {
+    const latest = state.validate.test_results[state.validate.test_results.length - 1]
+    console.log(`  最近运行: ${latest.timestamp}`)
+    console.log(`  通过率: ${latest.summary.pass_rate}%`)
+  } else {
+    console.log('  尚未运行验证')
+  }
+
+  // 返回菜单
+  return {
+    stateUpdates: {},
+    continue: true,
+    nextAction: 'action-menu',
+    message: ''
+  }
+}
+```
+
+## State Updates
+
+```javascript
+return {
+  stateUpdates: {
+    // 不更新状态，仅返回下一个动作
+  },
+  continue: true,
+  nextAction: nextAction,
+  message: `执行: ${selectedOption?.label || nextAction}`
+}
+```
+
+## Error Handling
+
+| Error Type | Recovery |
+|------------|----------|
+| 用户取消 | 返回菜单 |
+| 无效选择 | 重新显示菜单 |
+
+## Next Actions
+
+根据用户选择动态决定下一个动作。

.claude/skills/ccw-loop/phases/actions/action-validate-with-file.md

@@ -0,0 +1,307 @@
+# Action: Validate With File
+
+运行测试并验证实现，记录结果到 validation.md，支持 Gemini 辅助分析测试覆盖率和质量。
+
+## Purpose
+
+执行测试验证流程，包括:
+- 运行单元测试
+- 运行集成测试
+- 检查代码覆盖率
+- 生成验证报告
+- 分析失败原因
+
+## Preconditions
+
+- [ ] state.initialized === true
+- [ ] state.status === 'running'
+- [ ] state.develop.completed_count > 0 || state.debug.confirmed_hypothesis !== null
+
+## Session Setup
+
+```javascript
+const getUtc8ISOString = () => new Date(Date.now() + 8 * 60 * 60 * 1000).toISOString()
+
+const sessionFolder = `.workflow/.loop/${state.session_id}`
+const validateFolder = `${sessionFolder}/validate`
+const validationPath = `${validateFolder}/validation.md`
+const testResultsPath = `${validateFolder}/test-results.json`
+const coveragePath = `${validateFolder}/coverage.json`
+```
+
+---
+
+## Execution
+
+### Step 1: 运行测试
+
+```javascript
+console.log('\n运行测试...')
+
+// 检测测试框架
+const packageJson = JSON.parse(Read('package.json'))
+const testScript = packageJson.scripts?.test || 'npm test'
+
+// 运行测试并捕获输出
+const testResult = await Bash({
+  command: testScript,
+  timeout: 300000  // 5分钟
+})
+
+// 解析测试输出
+const testResults = parseTestOutput(testResult.stdout)
+```
+
+### Step 2: 检查覆盖率
+
+```javascript
+// 运行覆盖率检查
+let coverageData = null
+
+if (packageJson.scripts?.['test:coverage']) {
+  const coverageResult = await Bash({
+    command: 'npm run test:coverage',
+    timeout: 300000
+  })
+
+  // 解析覆盖率报告
+  coverageData = parseCoverageReport(coverageResult.stdout)
+
+  Write(coveragePath, JSON.stringify(coverageData, null, 2))
+}
+```
+
+### Step 3: Gemini 辅助分析
+
+```bash
+ccw cli -p "
+PURPOSE: Analyze test results and coverage
+Success criteria: Identify quality issues and suggest improvements
+
+TASK:
+• Analyze test execution results
+• Review code coverage metrics
+• Identify missing test cases
+• Suggest quality improvements
+• Verify requirements coverage
+
+MODE: analysis
+
+CONTEXT:
+@${testResultsPath}
+@${coveragePath}
+@${sessionFolder}/develop/progress.md
+
+EXPECTED:
+- Quality assessment report
+- Failed tests analysis
+- Coverage gaps identification
+- Improvement recommendations
+- Pass/Fail decision with rationale
+
+CONSTRAINTS: Evidence-based quality assessment
+" --tool gemini --mode analysis --rule analysis-review-code-quality
+```
+
+### Step 4: 生成验证报告
+
+```javascript
+const timestamp = getUtc8ISOString()
+const iteration = (state.validate.test_results?.length || 0) + 1
+
+const validationReport = `# Validation Report
+
+**Session ID**: ${state.session_id}
+**Task**: ${state.task_description}
+**Validated**: ${timestamp}
+
+---
+
+## Iteration ${iteration} - Validation Run
+
+### Test Execution Summary
+
+| Metric | Value |
+|--------|-------|
+| Total Tests | ${testResults.total} |
+| Passed | ${testResults.passed} |
+| Failed | ${testResults.failed} |
+| Skipped | ${testResults.skipped} |
+| Duration | ${testResults.duration_ms}ms |
+| **Pass Rate** | **${(testResults.passed / testResults.total * 100).toFixed(1)}%** |
+
+### Coverage Report
+
+${coverageData ? `
+| File | Statements | Branches | Functions | Lines |
+|------|------------|----------|-----------|-------|
+${coverageData.files.map(f => `| ${f.path} | ${f.statements}% | ${f.branches}% | ${f.functions}% | ${f.lines}% |`).join('\n')}
+
+**Overall Coverage**: ${coverageData.overall.statements}%
+` : '_No coverage data available_'}
+
+### Failed Tests
+
+${testResults.failed > 0 ? `
+${testResults.failures.map(f => `
+#### ${f.test_name}
+
+- **Suite**: ${f.suite}
+- **Error**: ${f.error_message}
+- **Stack**:
+\`\`\`
+${f.stack_trace}
+\`\`\`
+`).join('\n')}
+` : '_All tests passed_'}
+
+### Gemini Quality Analysis
+
+${geminiAnalysis}
+
+### Recommendations
+
+${recommendations.map(r => `- ${r}`).join('\n')}
+
+---
+
+## Validation Decision
+
+**Result**: ${testResults.passed === testResults.total ? '✅ PASS' : '❌ FAIL'}
+
+**Rationale**: ${validationDecision}
+
+${testResults.passed !== testResults.total ? `
+### Next Actions
+
+1. Review failed tests
+2. Debug failures using action-debug-with-file
+3. Fix issues and re-run validation
+` : `
+### Next Actions
+
+1. Consider code review
+2. Prepare for deployment
+3. Update documentation
+`}
+`
+
+// 写入验证报告
+Write(validationPath, validationReport)
+```
+
+### Step 5: 保存测试结果
+
+```javascript
+const testResultsData = {
+  iteration,
+  timestamp,
+  summary: {
+    total: testResults.total,
+    passed: testResults.passed,
+    failed: testResults.failed,
+    skipped: testResults.skipped,
+    pass_rate: (testResults.passed / testResults.total * 100).toFixed(1),
+    duration_ms: testResults.duration_ms
+  },
+  tests: testResults.tests,
+  failures: testResults.failures,
+  coverage: coverageData?.overall || null
+}
+
+Write(testResultsPath, JSON.stringify(testResultsData, null, 2))
+```
+
+---
+
+## State Updates
+
+```javascript
+const validationPassed = testResults.failed === 0 && testResults.passed > 0
+
+return {
+  stateUpdates: {
+    validate: {
+      test_results: [...(state.validate.test_results || []), testResultsData],
+      coverage: coverageData?.overall.statements || null,
+      passed: validationPassed,
+      failed_tests: testResults.failures.map(f => f.test_name),
+      last_run_at: getUtc8ISOString()
+    },
+    last_action: 'action-validate-with-file'
+  },
+  continue: true,
+  message: validationPassed
+    ? `验证通过 ✅\n测试: ${testResults.passed}/${testResults.total}\n覆盖率: ${coverageData?.overall.statements || 'N/A'}%`
+    : `验证失败 ❌\n失败: ${testResults.failed}/${testResults.total}\n建议进入调试模式`
+}
+```
+
+## Test Output Parsers
+
+### Jest/Vitest Parser
+
+```javascript
+function parseJestOutput(stdout) {
+  const testPattern = /Tests:\s+(\d+) passed.*?(\d+) failed.*?(\d+) total/
+  const match = stdout.match(testPattern)
+
+  return {
+    total: parseInt(match[3]),
+    passed: parseInt(match[1]),
+    failed: parseInt(match[2]),
+    // ... parse individual test results
+  }
+}
+```
+
+### Pytest Parser
+
+```javascript
+function parsePytestOutput(stdout) {
+  const summaryPattern = /(\d+) passed.*?(\d+) failed.*?(\d+) error/
+  // ... implementation
+}
+```
+
+## Error Handling
+
+| Error Type | Recovery |
+|------------|----------|
+| Tests don't run | 检查测试脚本配置，提示用户 |
+| All tests fail | 建议进入 debug 模式 |
+| Coverage tool missing | 跳过覆盖率检查，仅运行测试 |
+| Timeout | 增加超时时间或拆分测试 |
+
+## Validation Report Template
+
+参考 [templates/validation-template.md](../../templates/validation-template.md)
+
+## CLI Integration
+
+### 质量分析
+```bash
+ccw cli -p "PURPOSE: Analyze test results and coverage...
+TASK: • Review results • Identify gaps • Suggest improvements
+MODE: analysis
+CONTEXT: @test-results.json @coverage.json
+EXPECTED: Quality assessment
+" --tool gemini --mode analysis --rule analysis-review-code-quality
+```
+
+### 测试生成 (如覆盖率低)
+```bash
+ccw cli -p "PURPOSE: Generate missing test cases...
+TASK: • Analyze uncovered code • Write tests
+MODE: write
+CONTEXT: @coverage.json @src/**/*
+EXPECTED: Test code
+" --tool gemini --mode write --rule development-generate-tests
+```
+
+## Next Actions (Hints)
+
+- 验证通过: `action-complete` (完成循环)
+- 验证失败: `action-debug-with-file` (调试失败测试)
+- 覆盖率低: `action-develop-with-file` (添加测试)
+- 用户选择: `action-menu` (返回菜单)

.claude/skills/ccw-loop/phases/orchestrator.md

@@ -0,0 +1,486 @@
+# Orchestrator
+
+根据当前状态选择并执行下一个动作，实现无状态循环工作流。与 API (loop-v2-routes.ts) 协作实现控制平面/执行平面分离。
+
+## Role
+
+检查控制信号 → 读取文件状态 → 选择动作 → 执行 → 更新文件 → 循环，直到完成或被外部暂停/停止。
+
+## State Management (Unified Location)
+
+### 读取状态
+
+```javascript
+const getUtc8ISOString = () => new Date(Date.now() + 8 * 60 * 60 * 1000).toISOString()
+
+/**
+ * 读取循环状态 (统一位置)
+ * @param loopId - Loop ID (e.g., "loop-v2-20260122-abc123")
+ */
+function readLoopState(loopId) {
+  const stateFile = `.loop/${loopId}.json`
+
+  if (!fs.existsSync(stateFile)) {
+    return null
+  }
+
+  const state = JSON.parse(Read(stateFile))
+  return state
+}
+```
+
+### 更新状态
+
+```javascript
+/**
+ * 更新循环状态 (只更新 skill_state 部分，不修改 API 字段)
+ * @param loopId - Loop ID
+ * @param updates - 更新内容 (skill_state 字段)
+ */
+function updateLoopState(loopId, updates) {
+  const stateFile = `.loop/${loopId}.json`
+  const currentState = readLoopState(loopId)
+
+  if (!currentState) {
+    throw new Error(`Loop state not found: ${loopId}`)
+  }
+
+  // 只更新 skill_state 和 updated_at
+  const newState = {
+    ...currentState,
+    updated_at: getUtc8ISOString(),
+    skill_state: {
+      ...currentState.skill_state,
+      ...updates
+    }
+  }
+
+  Write(stateFile, JSON.stringify(newState, null, 2))
+  return newState
+}
+```
+
+### 创建新循环状态 (直接调用时)
+
+```javascript
+/**
+ * 创建新的循环状态 (仅在直接调用时使用，API 触发时状态已存在)
+ */
+function createLoopState(loopId, taskDescription) {
+  const stateFile = `.loop/${loopId}.json`
+  const now = getUtc8ISOString()
+
+  const state = {
+    // API 兼容字段
+    loop_id: loopId,
+    title: taskDescription.substring(0, 100),
+    description: taskDescription,
+    max_iterations: 10,
+    status: 'running',  // 直接调用时设为 running
+    current_iteration: 0,
+    created_at: now,
+    updated_at: now,
+
+    // Skill 扩展字段
+    skill_state: null  // 由 action-init 初始化
+  }
+
+  // 确保目录存在
+  Bash(`mkdir -p ".loop"`)
+  Bash(`mkdir -p ".loop/${loopId}.progress"`)
+
+  Write(stateFile, JSON.stringify(state, null, 2))
+  return state
+}
+```
+
+## Control Signal Checking
+
+```javascript
+/**
+ * 检查 API 控制信号
+ * 必须在每个 Action 开始前调用
+ * @returns { continue: boolean, reason: string }
+ */
+function checkControlSignals(loopId) {
+  const state = readLoopState(loopId)
+
+  if (!state) {
+    return { continue: false, reason: 'state_not_found' }
+  }
+
+  switch (state.status) {
+    case 'paused':
+      // API 暂停了循环，Skill 应退出等待 resume
+      console.log(`⏸️ Loop paused by API. Waiting for resume...`)
+      return { continue: false, reason: 'paused' }
+
+    case 'failed':
+      // API 停止了循环 (用户手动停止)
+      console.log(`⏹️ Loop stopped by API.`)
+      return { continue: false, reason: 'stopped' }
+
+    case 'completed':
+      // 已完成
+      console.log(`✅ Loop already completed.`)
+      return { continue: false, reason: 'completed' }
+
+    case 'created':
+      // API 创建但未启动 (不应该走到这里)
+      console.log(`⚠️ Loop not started by API.`)
+      return { continue: false, reason: 'not_started' }
+
+    case 'running':
+      // 正常继续
+      return { continue: true, reason: 'running' }
+
+    default:
+      console.log(`⚠️ Unknown status: ${state.status}`)
+      return { continue: false, reason: 'unknown_status' }
+  }
+}
+```
+
+## Decision Logic
+
+```javascript
+/**
+ * 选择下一个 Action (基于 skill_state)
+ */
+function selectNextAction(state, mode = 'interactive') {
+  const skillState = state.skill_state
+
+  // 1. 终止条件检查 (API status)
+  if (state.status === 'completed') return null
+  if (state.status === 'failed') return null
+  if (state.current_iteration >= state.max_iterations) {
+    console.warn(`已达到最大迭代次数 (${state.max_iterations})`)
+    return 'action-complete'
+  }
+
+  // 2. 初始化检查
+  if (!skillState || !skillState.current_action) {
+    return 'action-init'
+  }
+
+  // 3. 模式判断
+  if (mode === 'interactive') {
+    return 'action-menu'  // 显示菜单让用户选择
+  }
+
+  // 4. 自动模式：基于状态自动选择
+  if (mode === 'auto') {
+    // 按优先级：develop → debug → validate
+
+    // 如果有待开发任务
+    const hasPendingDevelop = skillState.develop?.tasks?.some(t => t.status === 'pending')
+    if (hasPendingDevelop) {
+      return 'action-develop-with-file'
+    }
+
+    // 如果开发完成但未调试
+    if (skillState.last_action === 'action-develop-with-file') {
+      const needsDebug = skillState.develop?.completed < skillState.develop?.total
+      if (needsDebug) {
+        return 'action-debug-with-file'
+      }
+    }
+
+    // 如果调试完成但未验证
+    if (skillState.last_action === 'action-debug-with-file' ||
+        skillState.debug?.confirmed_hypothesis) {
+      return 'action-validate-with-file'
+    }
+
+    // 如果验证失败，回到开发
+    if (skillState.last_action === 'action-validate-with-file') {
+      if (!skillState.validate?.passed) {
+        return 'action-develop-with-file'
+      }
+    }
+
+    // 全部通过，完成
+    if (skillState.validate?.passed && !hasPendingDevelop) {
+      return 'action-complete'
+    }
+
+    // 默认：开发
+    return 'action-develop-with-file'
+  }
+
+  // 5. 默认完成
+  return 'action-complete'
+}
+```
+
+## Execution Loop
+
+```javascript
+/**
+ * 运行编排器
+ * @param options.loopId - 现有 Loop ID (API 触发时)
+ * @param options.task - 任务描述 (直接调用时)
+ * @param options.mode - 'interactive' | 'auto'
+ */
+async function runOrchestrator(options = {}) {
+  const { loopId: existingLoopId, task, mode = 'interactive' } = options
+
+  console.log('=== CCW Loop Orchestrator Started ===')
+
+  // 1. 确定 loopId
+  let loopId
+  let state
+
+  if (existingLoopId) {
+    // API 触发：使用现有 loopId
+    loopId = existingLoopId
+    state = readLoopState(loopId)
+
+    if (!state) {
+      console.error(`Loop not found: ${loopId}`)
+      return { status: 'error', message: 'Loop not found' }
+    }
+
+    console.log(`Resuming loop: ${loopId}`)
+    console.log(`Status: ${state.status}`)
+
+  } else if (task) {
+    // 直接调用：创建新 loopId
+    const timestamp = getUtc8ISOString().replace(/[-:]/g, '').split('.')[0]
+    const random = Math.random().toString(36).substring(2, 10)
+    loopId = `loop-v2-${timestamp}-${random}`
+
+    console.log(`Creating new loop: ${loopId}`)
+    console.log(`Task: ${task}`)
+
+    state = createLoopState(loopId, task)
+
+  } else {
+    console.error('Either --loop-id or task description is required')
+    return { status: 'error', message: 'Missing loopId or task' }
+  }
+
+  const progressDir = `.loop/${loopId}.progress`
+
+  // 2. 主循环
+  let iteration = state.current_iteration || 0
+
+  while (iteration < state.max_iterations) {
+    iteration++
+
+    // ========================================
+    // CRITICAL: Check control signals first
+    // ========================================
+    const control = checkControlSignals(loopId)
+    if (!control.continue) {
+      console.log(`\n🛑 Loop terminated: ${control.reason}`)
+      break
+    }
+
+    // 重新读取状态 (可能被 API 更新)
+    state = readLoopState(loopId)
+
+    console.log(`\n[Iteration ${iteration}] Status: ${state.status}`)
+
+    // 选择下一个动作
+    const actionId = selectNextAction(state, mode)
+
+    if (!actionId) {
+      console.log('No action selected, terminating.')
+      break
+    }
+
+    console.log(`[Iteration ${iteration}] Executing: ${actionId}`)
+
+    // 更新 current_iteration
+    state = {
+      ...state,
+      current_iteration: iteration,
+      updated_at: getUtc8ISOString()
+    }
+    Write(`.loop/${loopId}.json`, JSON.stringify(state, null, 2))
+
+    // 执行动作
+    try {
+      const actionPromptFile = `.claude/skills/ccw-loop/phases/actions/${actionId}.md`
+
+      if (!fs.existsSync(actionPromptFile)) {
+        console.error(`Action file not found: ${actionPromptFile}`)
+        continue
+      }
+
+      const actionPrompt = Read(actionPromptFile)
+
+      // 构建 Agent 提示
+      const agentPrompt = `
+[LOOP CONTEXT]
+Loop ID: ${loopId}
+State File: .loop/${loopId}.json
+Progress Dir: ${progressDir}
+
+[CURRENT STATE]
+${JSON.stringify(state, null, 2)}
+
+[ACTION INSTRUCTIONS]
+${actionPrompt}
+
+[TASK]
+You are executing ${actionId} for loop: ${state.title || state.description}
+
+[CONTROL SIGNALS]
+Before executing, check if status is still 'running'.
+If status is 'paused' or 'failed', exit gracefully.
+
+[RETURN]
+Return JSON with:
+- skillStateUpdates: Object with skill_state fields to update
+- continue: Boolean indicating if loop should continue
+- message: String with user message
+`
+
+      const result = await Task({
+        subagent_type: 'universal-executor',
+        run_in_background: false,
+        description: `Execute ${actionId}`,
+        prompt: agentPrompt
+      })
+
+      // 解析结果
+      const actionResult = JSON.parse(result)
+
+      // 更新状态 (只更新 skill_state)
+      updateLoopState(loopId, {
+        current_action: null,
+        last_action: actionId,
+        completed_actions: [
+          ...(state.skill_state?.completed_actions || []),
+          actionId
+        ],
+        ...actionResult.skillStateUpdates
+      })
+
+      // 显示消息
+      if (actionResult.message) {
+        console.log(`\n${actionResult.message}`)
+      }
+
+      // 检查是否继续
+      if (actionResult.continue === false) {
+        console.log('Action requested termination.')
+        break
+      }
+
+    } catch (error) {
+      console.error(`Error executing ${actionId}: ${error.message}`)
+
+      // 错误处理
+      updateLoopState(loopId, {
+        current_action: null,
+        errors: [
+          ...(state.skill_state?.errors || []),
+          {
+            action: actionId,
+            message: error.message,
+            timestamp: getUtc8ISOString()
+          }
+        ]
+      })
+    }
+  }
+
+  if (iteration >= state.max_iterations) {
+    console.log(`\n⚠️ Reached maximum iterations (${state.max_iterations})`)
+    console.log('Consider breaking down the task or taking a break.')
+  }
+
+  console.log('\n=== CCW Loop Orchestrator Finished ===')
+
+  // 返回最终状态
+  const finalState = readLoopState(loopId)
+  return {
+    status: finalState.status,
+    loop_id: loopId,
+    iterations: iteration,
+    final_state: finalState
+  }
+}
+```
+
+## Action Catalog
+
+| Action | Purpose | Preconditions | Effects |
+|--------|---------|---------------|---------|
+| [action-init](actions/action-init.md) | 初始化会话 | status=pending | initialized=true |
+| [action-menu](actions/action-menu.md) | 显示操作菜单 | initialized=true | 用户选择下一动作 |
+| [action-develop-with-file](actions/action-develop-with-file.md) | 开发任务 | initialized=true | 更新 progress.md |
+| [action-debug-with-file](actions/action-debug-with-file.md) | 假设调试 | initialized=true | 更新 understanding.md |
+| [action-validate-with-file](actions/action-validate-with-file.md) | 测试验证 | initialized=true | 更新 validation.md |
+| [action-complete](actions/action-complete.md) | 完成循环 | validation_passed=true | status=completed |
+
+## Termination Conditions
+
+1. **API 暂停**: `state.status === 'paused'` (Skill 退出，等待 resume)
+2. **API 停止**: `state.status === 'failed'` (Skill 终止)
+3. **任务完成**: `state.status === 'completed'`
+4. **迭代限制**: `state.current_iteration >= state.max_iterations`
+5. **Action 请求终止**: `actionResult.continue === false`
+
+## Error Recovery
+
+| Error Type | Recovery Strategy |
+|------------|-------------------|
+| 动作执行失败 | 记录错误，增加 error_count，继续下一动作 |
+| 状态文件损坏 | 从其他文件重建状态 (progress.md, understanding.md 等) |
+| 用户中止 | 保存当前状态，允许 --resume 恢复 |
+| CLI 工具失败 | 回退到手动分析模式 |
+
+## Mode Strategies
+
+### Interactive Mode (默认)
+
+每次显示菜单，让用户选择动作：
+
+```
+当前状态: 开发中
+可用操作:
+  1. 继续开发 (develop)
+  2. 开始调试 (debug)
+  3. 运行验证 (validate)
+  4. 查看进度 (status)
+  5. 退出 (exit)
+
+请选择:
+```
+
+### Auto Mode (自动循环)
+
+按预设流程自动执行：
+
+```
+Develop → Debug → Validate →
+  ↓ (如验证失败)
+Develop (修复) → Debug → Validate → 完成
+```
+
+## State Machine (API Status)
+
+```mermaid
+stateDiagram-v2
+    [*] --> created: API creates loop
+    created --> running: API /start → Trigger Skill
+    running --> paused: API /pause → Set status
+    running --> completed: action-complete
+    running --> failed: API /stop OR error
+    paused --> running: API /resume → Re-trigger Skill
+    completed --> [*]
+    failed --> [*]
+
+    note right of paused
+      Skill checks status before each action
+      If paused, Skill exits gracefully
+    end note
+
+    note right of running
+      Skill executes: init → develop → debug → validate
+    end note
+```

.claude/skills/ccw-loop/phases/state-schema.md

@@ -0,0 +1,474 @@
+# State Schema
+
+CCW Loop 的状态结构定义（统一版本）。
+
+## 状态文件
+
+**位置**: `.loop/{loopId}.json` (统一位置，API + Skill 共享)
+
+**旧版本位置** (仅向后兼容): `.workflow/.loop/{session-id}/state.json`
+
+## 结构定义
+
+### 统一状态接口 (Unified Loop State)
+
+```typescript
+/**
+ * Unified Loop State - API 和 Skill 共享的状态结构
+ * API (loop-v2-routes.ts) 拥有状态的主控权
+ * Skill (ccw-loop) 读取和更新此状态
+ */
+interface LoopState {
+  // =====================================================
+  // API FIELDS (from loop-v2-routes.ts)
+  // 这些字段由 API 管理，Skill 只读
+  // =====================================================
+
+  loop_id: string                // Loop ID, e.g., "loop-v2-20260122-abc123"
+  title: string                  // Loop 标题
+  description: string            // Loop 描述
+  max_iterations: number         // 最大迭代次数
+  status: 'created' | 'running' | 'paused' | 'completed' | 'failed'
+  current_iteration: number      // 当前迭代次数
+  created_at: string             // 创建时间 (ISO8601)
+  updated_at: string             // 最后更新时间 (ISO8601)
+  completed_at?: string          // 完成时间 (ISO8601)
+  failure_reason?: string        // 失败原因
+
+  // =====================================================
+  // SKILL EXTENSION FIELDS
+  // 这些字段由 Skill 管理，API 只读
+  // =====================================================
+
+  skill_state?: {
+    // 当前执行动作
+    current_action: 'init' | 'develop' | 'debug' | 'validate' | 'complete' | null
+    last_action: string | null
+    completed_actions: string[]
+    mode: 'interactive' | 'auto'
+
+    // === 开发阶段 ===
+    develop: {
+      total: number
+      completed: number
+      current_task?: string
+      tasks: DevelopTask[]
+      last_progress_at: string | null
+    }
+
+    // === 调试阶段 ===
+    debug: {
+      active_bug?: string
+      hypotheses_count: number
+      hypotheses: Hypothesis[]
+      confirmed_hypothesis: string | null
+      iteration: number
+      last_analysis_at: string | null
+    }
+
+    // === 验证阶段 ===
+    validate: {
+      pass_rate: number           // 测试通过率 (0-100)
+      coverage: number            // 覆盖率 (0-100)
+      test_results: TestResult[]
+      passed: boolean
+      failed_tests: string[]
+      last_run_at: string | null
+    }
+
+    // === 错误追踪 ===
+    errors: Array<{
+      action: string
+      message: string
+      timestamp: string
+    }>
+  }
+}
+
+interface DevelopTask {
+  id: string
+  description: string
+  tool: 'gemini' | 'qwen' | 'codex' | 'bash'
+  mode: 'analysis' | 'write'
+  status: 'pending' | 'in_progress' | 'completed' | 'failed'
+  files_changed: string[]
+  created_at: string
+  completed_at: string | null
+}
+
+interface Hypothesis {
+  id: string                    // H1, H2, ...
+  description: string
+  testable_condition: string
+  logging_point: string
+  evidence_criteria: {
+    confirm: string
+    reject: string
+  }
+  likelihood: number            // 1 = 最可能
+  status: 'pending' | 'confirmed' | 'rejected' | 'inconclusive'
+  evidence: Record<string, any> | null
+  verdict_reason: string | null
+}
+
+interface TestResult {
+  test_name: string
+  suite: string
+  status: 'passed' | 'failed' | 'skipped'
+  duration_ms: number
+  error_message: string | null
+  stack_trace: string | null
+}
+```
+
+## 初始状态
+
+### 由 API 创建时 (Dashboard 触发)
+
+```json
+{
+  "loop_id": "loop-v2-20260122-abc123",
+  "title": "Implement user authentication",
+  "description": "Add login/logout functionality",
+  "max_iterations": 10,
+  "status": "created",
+  "current_iteration": 0,
+  "created_at": "2026-01-22T10:00:00+08:00",
+  "updated_at": "2026-01-22T10:00:00+08:00"
+}
+```
+
+### 由 Skill 初始化后 (action-init)
+
+```json
+{
+  "loop_id": "loop-v2-20260122-abc123",
+  "title": "Implement user authentication",
+  "description": "Add login/logout functionality",
+  "max_iterations": 10,
+  "status": "running",
+  "current_iteration": 0,
+  "created_at": "2026-01-22T10:00:00+08:00",
+  "updated_at": "2026-01-22T10:00:05+08:00",
+
+  "skill_state": {
+    "current_action": "init",
+    "last_action": null,
+    "completed_actions": [],
+    "mode": "auto",
+
+    "develop": {
+      "total": 3,
+      "completed": 0,
+      "current_task": null,
+      "tasks": [
+        { "id": "task-001", "description": "Create auth component", "status": "pending" }
+      ],
+      "last_progress_at": null
+    },
+
+    "debug": {
+      "active_bug": null,
+      "hypotheses_count": 0,
+      "hypotheses": [],
+      "confirmed_hypothesis": null,
+      "iteration": 0,
+      "last_analysis_at": null
+    },
+
+    "validate": {
+      "pass_rate": 0,
+      "coverage": 0,
+      "test_results": [],
+      "passed": false,
+      "failed_tests": [],
+      "last_run_at": null
+    },
+
+    "errors": []
+  }
+}
+```
+
+## 控制信号检查 (Control Signals)
+
+Skill 在每个 Action 开始前必须检查控制信号：
+
+```javascript
+/**
+ * 检查 API 控制信号
+ * @returns { continue: boolean, action: 'pause_exit' | 'stop_exit' | 'continue' }
+ */
+function checkControlSignals(loopId) {
+  const state = JSON.parse(Read(`.loop/${loopId}.json`))
+
+  switch (state.status) {
+    case 'paused':
+      // API 暂停了循环，Skill 应退出等待 resume
+      return { continue: false, action: 'pause_exit' }
+
+    case 'failed':
+      // API 停止了循环 (用户手动停止)
+      return { continue: false, action: 'stop_exit' }
+
+    case 'running':
+      // 正常继续
+      return { continue: true, action: 'continue' }
+
+    default:
+      // 异常状态
+      return { continue: false, action: 'stop_exit' }
+  }
+}
+```
+
+### 在 Action 中使用
+
+```markdown
+## Execution
+
+### Step 1: Check Control Signals
+
+\`\`\`javascript
+const control = checkControlSignals(loopId)
+if (!control.continue) {
+  // 输出退出原因
+  console.log(`Loop ${control.action}: status = ${state.status}`)
+
+  // 如果是 pause_exit，保存当前进度
+  if (control.action === 'pause_exit') {
+    updateSkillState(loopId, { current_action: 'paused' })
+  }
+
+  return  // 退出 Action
+}
+\`\`\`
+
+### Step 2: Execute Action Logic
+...
+```
+
+## 状态转换规则
+
+### 1. 初始化 (action-init)
+
+```javascript
+// Skill 初始化后
+{
+  // API 字段更新
+  status: 'created' → 'running',  // 或保持 'running' 如果 API 已设置
+  updated_at: timestamp,
+
+  // Skill 字段初始化
+  skill_state: {
+    current_action: 'init',
+    mode: 'auto',
+    develop: {
+      tasks: [...parsed_tasks],
+      total: N,
+      completed: 0
+    }
+  }
+}
+```
+
+### 2. 开发进行中 (action-develop-with-file)
+
+```javascript
+// 开发任务执行后
+{
+  updated_at: timestamp,
+  current_iteration: state.current_iteration + 1,
+
+  skill_state: {
+    current_action: 'develop',
+    last_action: 'action-develop-with-file',
+    completed_actions: [...state.skill_state.completed_actions, 'action-develop-with-file'],
+    develop: {
+      current_task: 'task-xxx',
+      completed: N+1,
+      last_progress_at: timestamp
+    }
+  }
+}
+```
+
+### 3. 调试进行中 (action-debug-with-file)
+
+```javascript
+// 调试执行后
+{
+  updated_at: timestamp,
+  current_iteration: state.current_iteration + 1,
+
+  skill_state: {
+    current_action: 'debug',
+    last_action: 'action-debug-with-file',
+    debug: {
+      active_bug: '...',
+      hypotheses_count: N,
+      hypotheses: [...new_hypotheses],
+      iteration: N+1,
+      last_analysis_at: timestamp
+    }
+  }
+}
+```
+
+### 4. 验证完成 (action-validate-with-file)
+
+```javascript
+// 验证执行后
+{
+  updated_at: timestamp,
+  current_iteration: state.current_iteration + 1,
+
+  skill_state: {
+    current_action: 'validate',
+    last_action: 'action-validate-with-file',
+    validate: {
+      test_results: [...results],
+      pass_rate: 95.5,
+      coverage: 85.0,
+      passed: true | false,
+      failed_tests: ['test1', 'test2'],
+      last_run_at: timestamp
+    }
+  }
+}
+```
+
+### 5. 完成 (action-complete)
+
+```javascript
+// 循环完成后
+{
+  status: 'running' → 'completed',
+  completed_at: timestamp,
+  updated_at: timestamp,
+
+  skill_state: {
+    current_action: 'complete',
+    last_action: 'action-complete'
+  }
+}
+```
+
+## 状态派生字段
+
+以下字段可从状态计算得出，不需要存储：
+
+```javascript
+// 开发完成度
+const developProgress = state.develop.total_count > 0
+  ? (state.develop.completed_count / state.develop.total_count) * 100
+  : 0
+
+// 是否有待开发任务
+const hasPendingDevelop = state.develop.tasks.some(t => t.status === 'pending')
+
+// 调试是否完成
+const debugCompleted = state.debug.confirmed_hypothesis !== null
+
+// 验证是否通过
+const validationPassed = state.validate.passed && state.validate.test_results.length > 0
+
+// 整体进度
+const overallProgress = (
+  (developProgress * 0.5) +
+  (debugCompleted ? 25 : 0) +
+  (validationPassed ? 25 : 0)
+)
+```
+
+## 文件同步
+
+### 统一位置 (Unified Location)
+
+状态与文件的对应关系：
+
+| 状态字段 | 同步文件 | 同步时机 |
+|----------|----------|----------|
+| 整个 LoopState | `.loop/{loopId}.json` | 每次状态变更 (主文件) |
+| `skill_state.develop` | `.loop/{loopId}.progress/develop.md` | 每次开发操作后 |
+| `skill_state.debug` | `.loop/{loopId}.progress/debug.md` | 每次调试操作后 |
+| `skill_state.validate` | `.loop/{loopId}.progress/validate.md` | 每次验证操作后 |
+| 代码变更日志 | `.loop/{loopId}.progress/changes.log` | 每次文件修改 (NDJSON) |
+| 调试日志 | `.loop/{loopId}.progress/debug.log` | 每次调试日志 (NDJSON) |
+
+### 文件结构示例
+
+```
+.loop/
+├── loop-v2-20260122-abc123.json         # 主状态文件 (API + Skill)
+├── loop-v2-20260122-abc123.tasks.jsonl  # 任务列表 (API 管理)
+└── loop-v2-20260122-abc123.progress/    # Skill 进度文件
+    ├── develop.md                       # 开发进度
+    ├── debug.md                         # 调试理解
+    ├── validate.md                      # 验证报告
+    ├── changes.log                      # 代码变更 (NDJSON)
+    └── debug.log                        # 调试日志 (NDJSON)
+```
+
+## 状态恢复
+
+如果主状态文件 `.loop/{loopId}.json` 损坏，可以从进度文件重建 skill_state:
+
+```javascript
+function rebuildSkillStateFromProgress(loopId) {
+  const progressDir = `.loop/${loopId}.progress`
+
+  // 尝试从进度文件解析状态
+  const skill_state = {
+    develop: parseProgressFile(`${progressDir}/develop.md`),
+    debug: parseProgressFile(`${progressDir}/debug.md`),
+    validate: parseProgressFile(`${progressDir}/validate.md`)
+  }
+
+  return skill_state
+}
+
+// 解析进度 Markdown 文件
+function parseProgressFile(filePath) {
+  const content = Read(filePath)
+  if (!content) return null
+
+  // 从 Markdown 表格和结构中提取数据
+  // ... implementation
+}
+```
+
+### 恢复策略
+
+1. **API 字段**: 无法恢复 - 需要从 API 重新获取或用户手动输入
+2. **skill_state 字段**: 可以从 `.progress/` 目录的 Markdown 文件解析
+3. **任务列表**: 从 `.loop/{loopId}.tasks.jsonl` 恢复
+
+## 状态验证
+
+```javascript
+function validateState(state) {
+  const errors = []
+
+  // 必需字段
+  if (!state.session_id) errors.push('Missing session_id')
+  if (!state.task_description) errors.push('Missing task_description')
+
+  // 状态一致性
+  if (state.initialized && state.status === 'pending') {
+    errors.push('Inconsistent: initialized but status is pending')
+  }
+
+  if (state.status === 'completed' && !state.validate.passed) {
+    errors.push('Inconsistent: completed but validation not passed')
+  }
+
+  // 开发任务一致性
+  const completedTasks = state.develop.tasks.filter(t => t.status === 'completed').length
+  if (completedTasks !== state.develop.completed_count) {
+    errors.push('Inconsistent: completed_count mismatch')
+  }
+
+  return { valid: errors.length === 0, errors }
+}
+```

.claude/skills/ccw-loop/specs/action-catalog.md

@@ -0,0 +1,300 @@
+# Action Catalog
+
+CCW Loop 所有可用动作的目录和说明。
+
+## Available Actions
+
+| Action | Purpose | Preconditions | Effects | CLI Integration |
+|--------|---------|---------------|---------|-----------------|
+| [action-init](../phases/actions/action-init.md) | 初始化会话 | status=pending, initialized=false | status→running, initialized→true, 创建目录和任务列表 | Gemini 任务分解 |
+| [action-menu](../phases/actions/action-menu.md) | 显示操作菜单 | initialized=true, status=running | 返回用户选择的动作 | - |
+| [action-develop-with-file](../phases/actions/action-develop-with-file.md) | 执行开发任务 | initialized=true, pending tasks > 0 | 更新 progress.md, 完成一个任务 | Gemini 代码实现 |
+| [action-debug-with-file](../phases/actions/action-debug-with-file.md) | 假设驱动调试 | initialized=true | 更新 understanding.md, hypotheses.json | Gemini 假设生成和证据分析 |
+| [action-validate-with-file](../phases/actions/action-validate-with-file.md) | 运行测试验证 | initialized=true, develop > 0 or debug confirmed | 更新 validation.md, test-results.json | Gemini 质量分析 |
+| [action-complete](../phases/actions/action-complete.md) | 完成循环 | initialized=true | status→completed, 生成 summary.md | - |
+
+## Action Dependencies Graph
+
+```mermaid
+graph TD
+    START([用户启动 /ccw-loop]) --> INIT[action-init]
+    INIT --> MENU[action-menu]
+
+    MENU --> DEVELOP[action-develop-with-file]
+    MENU --> DEBUG[action-debug-with-file]
+    MENU --> VALIDATE[action-validate-with-file]
+    MENU --> STATUS[action-status]
+    MENU --> COMPLETE[action-complete]
+    MENU --> EXIT([退出])
+
+    DEVELOP --> MENU
+    DEBUG --> MENU
+    VALIDATE --> MENU
+    STATUS --> MENU
+    COMPLETE --> END([结束])
+    EXIT --> END
+
+    style INIT fill:#e1f5fe
+    style MENU fill:#fff3e0
+    style DEVELOP fill:#e8f5e9
+    style DEBUG fill:#fce4ec
+    style VALIDATE fill:#f3e5f5
+    style COMPLETE fill:#c8e6c9
+```
+
+## Action Execution Matrix
+
+### Interactive Mode
+
+| State | Auto-Selected Action | User Options |
+|-------|---------------------|--------------|
+| pending | action-init | - |
+| running, !initialized | action-init | - |
+| running, initialized | action-menu | All actions |
+
+### Auto Mode
+
+| Condition | Selected Action |
+|-----------|----------------|
+| pending_develop_tasks > 0 | action-develop-with-file |
+| last_action=develop, !debug_completed | action-debug-with-file |
+| last_action=debug, !validation_completed | action-validate-with-file |
+| validation_failed | action-develop-with-file (fix) |
+| validation_passed, no pending | action-complete |
+
+## Action Inputs/Outputs
+
+### action-init
+
+**Inputs**:
+- state.task_description
+- User input (optional)
+
+**Outputs**:
+- meta.json
+- state.json (初始化)
+- develop/tasks.json
+- develop/progress.md
+
+**State Changes**:
+```javascript
+{
+  status: 'pending' → 'running',
+  initialized: false → true,
+  develop.tasks: [] → [task1, task2, ...]
+}
+```
+
+### action-develop-with-file
+
+**Inputs**:
+- state.develop.tasks
+- User selection (如有多个待处理任务)
+
+**Outputs**:
+- develop/progress.md (追加)
+- develop/tasks.json (更新)
+- develop/changes.log (追加)
+
+**State Changes**:
+```javascript
+{
+  develop.current_task_id: null → 'task-xxx' → null,
+  develop.completed_count: N → N+1,
+  last_action: X → 'action-develop-with-file'
+}
+```
+
+### action-debug-with-file
+
+**Inputs**:
+- Bug description (用户输入或从测试失败获取)
+- debug.log (如已有)
+
+**Outputs**:
+- debug/understanding.md (追加)
+- debug/hypotheses.json (更新)
+- Code changes (添加日志或修复)
+
+**State Changes**:
+```javascript
+{
+  debug.current_bug: null → 'bug description',
+  debug.hypotheses: [...updated],
+  debug.iteration: N → N+1,
+  debug.confirmed_hypothesis: null → 'H1' (如确认)
+}
+```
+
+### action-validate-with-file
+
+**Inputs**:
+- 测试脚本 (从 package.json)
+- 覆盖率工具 (可选)
+
+**Outputs**:
+- validate/validation.md (追加)
+- validate/test-results.json (更新)
+- validate/coverage.json (更新)
+
+**State Changes**:
+```javascript
+{
+  validate.test_results: [...new results],
+  validate.coverage: null → 85.5,
+  validate.passed: false → true,
+  validate.failed_tests: ['test1', 'test2'] → []
+}
+```
+
+### action-complete
+
+**Inputs**:
+- state (完整状态)
+- User choices (扩展选项)
+
+**Outputs**:
+- summary.md
+- Issues (如选择扩展)
+
+**State Changes**:
+```javascript
+{
+  status: 'running' → 'completed',
+  completed_at: null → timestamp
+}
+```
+
+## Action Sequences
+
+### Typical Happy Path
+
+```
+action-init
+  → action-develop-with-file (task 1)
+  → action-develop-with-file (task 2)
+  → action-develop-with-file (task 3)
+  → action-validate-with-file
+    → PASS
+  → action-complete
+```
+
+### Debug Iteration Path
+
+```
+action-init
+  → action-develop-with-file (task 1)
+  → action-validate-with-file
+    → FAIL
+  → action-debug-with-file (探索)
+  → action-debug-with-file (分析)
+    → Root cause found
+  → action-validate-with-file
+    → PASS
+  → action-complete
+```
+
+### Multi-Iteration Path
+
+```
+action-init
+  → action-develop-with-file (task 1)
+  → action-debug-with-file
+  → action-develop-with-file (task 2)
+  → action-validate-with-file
+    → FAIL
+  → action-debug-with-file
+  → action-validate-with-file
+    → PASS
+  → action-complete
+```
+
+## Error Scenarios
+
+### CLI Tool Failure
+
+```
+action-develop-with-file
+  → Gemini CLI fails
+  → Fallback to manual implementation
+  → Prompt user for code
+  → Continue
+```
+
+### Test Failure
+
+```
+action-validate-with-file
+  → Tests fail
+  → Record failed tests
+  → Suggest action-debug-with-file
+  → User chooses debug or manual fix
+```
+
+### Max Iterations Reached
+
+```
+state.iteration_count >= 10
+  → Warning message
+  → Suggest break or task split
+  → Allow continue or exit
+```
+
+## Action Extensions
+
+### Adding New Actions
+
+To add a new action:
+
+1. Create `phases/actions/action-{name}.md`
+2. Define preconditions, execution, state updates
+3. Add to this catalog
+4. Update orchestrator.md decision logic
+5. Add to action-menu.md options
+
+### Action Template
+
+```markdown
+# Action: {Name}
+
+{Brief description}
+
+## Purpose
+
+{Detailed purpose}
+
+## Preconditions
+
+- [ ] condition1
+- [ ] condition2
+
+## Execution
+
+### Step 1: {Step Name}
+
+\`\`\`javascript
+// code
+\`\`\`
+
+## State Updates
+
+\`\`\`javascript
+return {
+  stateUpdates: {
+    // updates
+  },
+  continue: true,
+  message: "..."
+}
+\`\`\`
+
+## Error Handling
+
+| Error Type | Recovery |
+|------------|----------|
+| ... | ... |
+
+## Next Actions (Hints)
+
+- condition: next_action
+```